@crush-protocol/mcp-contracts
MCP ServerFreeShared contracts for Crush MCP — tool names, schemas, and error codes
Capabilities5 decomposed
mcp tool schema contract definition and validation
Medium confidenceProvides TypeScript interfaces and type definitions for standardizing tool schemas across MCP servers and clients. Implements a contract-based approach where tool definitions (name, description, input schema, output schema) are centrally defined and shared, enabling compile-time type safety and runtime validation. Uses JSON Schema for input/output specifications with TypeScript generics for end-to-end type inference across the MCP protocol boundary.
Centralizes MCP tool contract definitions as a shared npm package, enabling multiple servers and clients to reference the same TypeScript interfaces and JSON schemas rather than duplicating definitions. Uses TypeScript generics to propagate type information through the MCP protocol boundary, providing end-to-end type safety from client call site to server handler.
Stronger than ad-hoc schema sharing because contracts are versioned, published, and enforced at compile time; lighter than full OpenAPI/AsyncAPI specifications because it focuses specifically on MCP's tool-calling semantics.
standardized mcp error code registry
Medium confidenceDefines a shared enumeration of error codes and error response structures that MCP servers and clients use to communicate failures consistently. Implements a contract layer for error handling where specific error codes (e.g., TOOL_NOT_FOUND, INVALID_ARGUMENT, RATE_LIMITED) map to HTTP-like status semantics. Enables clients to programmatically handle different failure modes without parsing error messages.
Provides a centralized, versioned error code registry as an npm package that all MCP implementations can import and reference, eliminating the need for each server to define its own error semantics. Maps error codes to semantic categories (retryable, client error, server error) enabling automatic retry logic.
More structured than raw error messages because clients can pattern-match on error codes; more lightweight than full exception hierarchies because it uses simple enums rather than class inheritance.
shared tool naming conventions and metadata
Medium confidenceEstablishes a standardized naming scheme and metadata structure for MCP tools (e.g., tool name format, description templates, category tags). Implements conventions as TypeScript constants and interfaces that enforce naming patterns (e.g., snake_case for tool names, required description fields) across all servers. Enables discovery and documentation generation by providing machine-readable tool metadata.
Encodes naming conventions and metadata standards as TypeScript interfaces and constants in a shared package, allowing all MCP implementations to import and enforce the same conventions without duplicating definitions. Provides validation functions to check tool names and metadata against the standard.
More discoverable than implicit conventions because they're explicitly documented in code; more flexible than a centralized registry because conventions are enforced locally by each server.
cross-server mcp contract versioning and compatibility
Medium confidenceManages versioning of shared MCP contracts so that servers and clients can evolve independently while maintaining compatibility. Implements semantic versioning for contract packages, allowing breaking changes to be tracked and communicated. Enables clients to specify which contract versions they support and servers to declare which versions they implement.
Uses npm's semantic versioning system to version shared MCP contracts, allowing servers and clients to declare version compatibility constraints. Enables multiple contract versions to coexist in the same codebase for gradual migration.
More explicit than implicit versioning because version constraints are declared in package.json; more flexible than monolithic versioning because individual contracts can evolve independently.
type-safe mcp function calling with schema inference
Medium confidenceProvides TypeScript generics and type inference that propagate tool schema information through the MCP protocol, enabling type-safe function calls at the client level. When a client calls an MCP tool, the argument types and return types are inferred from the shared contract definition, catching type mismatches at compile time. Implements this through TypeScript's conditional types and mapped types to extract schema information.
Uses TypeScript's advanced type system (conditional types, mapped types, const type parameters) to extract schema information from shared contract definitions and propagate it through function signatures, enabling end-to-end type safety without code generation. Infers both argument types and return types from JSON Schema.
Stronger type safety than runtime validation because errors are caught at compile time; more maintainable than code generation because types are derived from a single source of truth (the contract definition).
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with @crush-protocol/mcp-contracts, ranked by overlap. Discovered automatically through the match graph.
@mcp-contracts/cli
CLI tool for capturing and diffing MCP tool schemas
boilerplate-mcp-tool
CX Boilerplate MCP Tool cli
mcp-tool-lint
Static linter for MCP tool definitions — catch quality defects before deployment
mcp-validate
Validate MCP server tool definitions against the spec. Checks names, descriptions, JSON Schema, parameter docs, and LLM-readiness.
@toolrank/mcp-server
ToolRank MCP Server — Score and optimize MCP tool definitions for AI agent discovery. The first ATO (Agent Tool Optimization) tool.
@claude-flow/mcp
Standalone MCP (Model Context Protocol) server - stdio/http/websocket transports, connection pooling, tool registry
Best For
- ✓teams building multiple MCP servers that need to interoperate
- ✓developers creating MCP client libraries that require type safety
- ✓organizations standardizing on MCP as their tool-calling protocol
- ✓MCP client implementations building resilience patterns
- ✓teams operating multiple MCP servers that need consistent error semantics
- ✓developers building MCP-based agents that need to handle failures gracefully
- ✓organizations building tool ecosystems with 10+ MCP servers
- ✓teams building MCP discovery or documentation systems
Known Limitations
- ⚠Contracts are TypeScript-only — no Python, Go, or Rust bindings provided
- ⚠No runtime schema validation — contracts are compile-time constructs only
- ⚠Requires manual synchronization if contracts change — no versioning or migration tooling
- ⚠No support for polymorphic tool schemas or conditional field requirements
- ⚠Error codes are static — no dynamic error code registration or extension mechanism
- ⚠No built-in error context or structured error details beyond the code
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
Package Details
About
Shared contracts for Crush MCP — tool names, schemas, and error codes
Categories
Alternatives to @crush-protocol/mcp-contracts
Are you the builder of @crush-protocol/mcp-contracts?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →