@exitmcp/core

Provides a standardized MCP server factory that handles initialization, request routing, and graceful shutdown. The core exports server construction patterns that abstract away protocol-level details, allowing developers to focus on tool and resource definitions rather than managing WebSocket/stdio transports, message serialization, or error propagation across the MCP specification.

Implements a centralized registry that maps tool definitions (name, description, input schema) to handler functions, with automatic JSON Schema validation and type coercion. Tools are registered declaratively with OpenAI-compatible function calling schemas, and the registry handles parameter validation, error wrapping, and result serialization before returning to the MCP client.

Defines a pluggable KV interface that abstracts storage backends (in-memory, Redis, DynamoDB, etc.) behind a consistent get/set/delete/list API. The interface uses async/await patterns and supports TTL, batch operations, and optional namespacing, allowing servers to persist state without coupling to a specific storage implementation.

Exposes a Host interface that provides runtime context about the execution environment (platform, available resources, client capabilities, configuration). The server can query host properties to adapt behavior (e.g., enable/disable features based on client support), and the interface supports lazy initialization of expensive resources like database connections.

Defines an Auth interface for pluggable authentication strategies (API keys, OAuth, mutual TLS, custom schemes) with support for token validation, permission checking, and audit logging. The interface integrates with the tool registry to enforce per-tool access control, allowing servers to implement fine-grained authorization without modifying tool handlers.

Implements a middleware chain pattern for intercepting and transforming MCP requests and responses. Middleware can validate requests, enrich context, transform payloads, log events, or enforce policies before tools execute. The pipeline is composable and supports both sync and async middleware, with error handling that propagates failures back to the MCP client.

Enables servers to expose resources (documents, files, data streams) alongside tools, with support for streaming large payloads and content negotiation. Resources are defined with URIs and MIME types, and the interface handles chunked delivery to MCP clients, allowing tools to reference and manipulate resources without loading entire contents into memory.

Provides standardized error handling that converts exceptions and validation failures into MCP-compliant error responses with structured error codes, messages, and optional context. The system distinguishes between client errors (invalid parameters), server errors (tool execution failures), and protocol errors, with proper HTTP-like status codes and error serialization.

Leverages TypeScript generics and type inference to provide compile-time type safety for tool handlers, automatically deriving input/output types from handler function signatures. The system generates JSON schemas from TypeScript types and validates runtime inputs against those schemas, catching type mismatches at both compile time and runtime.