alepha 0.13.8 → 0.14.0

package/dist/mcp/index.d.ts

@@ -0,0 +1,820 @@
+import * as alepha3 from "alepha";
+import { Alepha, AlephaError, Async, KIND, Primitive, Static, TObject, TSchema } from "alepha";
+import * as alepha_logger0 from "alepha/logger";
+import * as alepha_server0 from "alepha/server";
+import * as readline from "node:readline";
+
+//#region ../../src/mcp/errors/McpError.d.ts
+declare class McpError extends Error {
+  name: string;
+  code: number;
+  constructor(message: string, code?: number);
+}
+declare class McpMethodNotFoundError extends McpError {
+  name: string;
+  constructor(method: string);
+}
+declare class McpToolNotFoundError extends McpError {
+  name: string;
+  tool: string;
+  constructor(tool: string);
+}
+declare class McpResourceNotFoundError extends McpError {
+  name: string;
+  uri: string;
+  constructor(uri: string);
+}
+declare class McpPromptNotFoundError extends McpError {
+  name: string;
+  prompt: string;
+  constructor(prompt: string);
+}
+declare class McpInvalidParamsError extends McpError {
+  name: string;
+  constructor(message: string);
+}
+//#endregion
+//#region ../../src/mcp/interfaces/McpTypes.d.ts
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id?: string | number;
+  method: string;
+  params?: Record<string, unknown>;
+}
+interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  id: string | number;
+  result?: unknown;
+  error?: JsonRpcError;
+}
+interface JsonRpcNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params?: Record<string, unknown>;
+}
+interface JsonRpcError {
+  code: number;
+  message: string;
+  data?: unknown;
+}
+interface McpCapabilities {
+  tools?: Record<string, never>;
+  resources?: Record<string, never>;
+  prompts?: Record<string, never>;
+}
+interface McpServerInfo {
+  name: string;
+  version: string;
+}
+interface McpClientInfo {
+  name: string;
+  version: string;
+}
+interface McpInitializeParams {
+  protocolVersion: string;
+  capabilities: McpCapabilities;
+  clientInfo: McpClientInfo;
+}
+interface McpInitializeResult {
+  protocolVersion: string;
+  capabilities: McpCapabilities;
+  serverInfo: McpServerInfo;
+}
+interface McpToolDescriptor {
+  name: string;
+  description: string;
+  inputSchema: McpJsonSchema;
+}
+interface McpJsonSchema {
+  type: string;
+  properties?: Record<string, unknown>;
+  required?: string[];
+}
+interface McpToolCallParams {
+  name: string;
+  arguments?: Record<string, unknown>;
+}
+interface McpToolCallResult {
+  content: McpContent[];
+  isError?: boolean;
+}
+interface McpContent {
+  type: "text" | "image" | "resource";
+  text?: string;
+  data?: string;
+  mimeType?: string;
+}
+interface McpResourceDescriptor {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+}
+interface McpResourceReadParams {
+  uri: string;
+}
+interface McpResourceReadResult {
+  contents: McpResourceContent[];
+}
+interface McpResourceContent {
+  uri: string;
+  mimeType?: string;
+  text?: string;
+  blob?: string;
+}
+interface McpPromptDescriptor {
+  name: string;
+  description?: string;
+  arguments?: McpPromptArgument[];
+}
+interface McpPromptArgument {
+  name: string;
+  description?: string;
+  required?: boolean;
+}
+interface McpPromptGetParams {
+  name: string;
+  arguments?: Record<string, string>;
+}
+interface McpPromptGetResult {
+  description?: string;
+  messages: McpPromptMessage[];
+}
+interface McpPromptMessage {
+  role: "user" | "assistant";
+  content: McpPromptContent;
+}
+interface McpPromptContent {
+  type: "text" | "image" | "resource";
+  text?: string;
+  data?: string;
+  mimeType?: string;
+}
+interface ToolPrimitiveSchema {
+  params?: TObject;
+  result?: TSchema;
+}
+/**
+ * Context passed to MCP handlers from the transport layer.
+ *
+ * This allows tools, resources, and prompts to access request-level
+ * information like headers for authentication.
+ */
+interface McpContext<T = unknown> {
+  /**
+   * HTTP headers from the request (for SSE transport).
+   */
+  headers?: Record<string, string | string[] | undefined>;
+  /**
+   * Custom context data set by transport or middleware.
+   * Can be used to pass authenticated user, project scope, etc.
+   */
+  data?: T;
+}
+type ToolHandler<T extends ToolPrimitiveSchema, TContext = unknown> = (args: ToolHandlerArgs<T, TContext>) => Async<ToolHandlerResult<T>>;
+interface ToolHandlerArgs<T extends ToolPrimitiveSchema, TContext = unknown> {
+  params: T["params"] extends TObject ? Static<T["params"]> : Record<string, never>;
+  context?: McpContext<TContext>;
+}
+type ToolHandlerResult<T extends ToolPrimitiveSchema> = T["result"] extends TSchema ? Static<T["result"]> : unknown;
+type ResourceHandler<TContext = unknown> = (args: ResourceHandlerArgs<TContext>) => Async<ResourceContent>;
+interface ResourceHandlerArgs<TContext = unknown> {
+  context?: McpContext<TContext>;
+}
+interface ResourceContent {
+  text?: string;
+  blob?: Uint8Array;
+}
+type PromptHandler<T extends TObject, TContext = unknown> = (args: PromptHandlerArgs<T, TContext>) => Async<PromptMessage[]>;
+interface PromptHandlerArgs<T extends TObject, TContext = unknown> {
+  args: Static<T>;
+  context?: McpContext<TContext>;
+}
+interface PromptMessage {
+  role: "user" | "assistant";
+  content: string;
+}
+//#endregion
+//#region ../../src/mcp/helpers/jsonrpc.d.ts
+declare const JSONRPC_VERSION: "2.0";
+declare const MCP_PROTOCOL_VERSION: "2024-11-05";
+declare const JsonRpcErrorCodes: {
+  readonly PARSE_ERROR: -32700;
+  readonly INVALID_REQUEST: -32600;
+  readonly METHOD_NOT_FOUND: -32601;
+  readonly INVALID_PARAMS: -32602;
+  readonly INTERNAL_ERROR: -32603;
+};
+declare function createResponse(id: string | number, result: unknown): JsonRpcResponse;
+declare function createErrorResponse(id: string | number, error: JsonRpcError): JsonRpcResponse;
+declare function createNotification(method: string, params?: Record<string, unknown>): JsonRpcNotification;
+declare function createParseError(message?: string): JsonRpcError;
+declare function createInvalidRequestError(message?: string): JsonRpcError;
+declare function createMethodNotFoundError(method: string): JsonRpcError;
+declare function createInvalidParamsError(message: string): JsonRpcError;
+declare function createInternalError(message: string): JsonRpcError;
+declare function parseMessage(data: string): JsonRpcRequest;
+declare function isValidJsonRpcRequest(value: unknown): value is JsonRpcRequest;
+declare function isNotification(request: JsonRpcRequest): boolean;
+declare class JsonRpcParseError extends AlephaError {
+  name: string;
+}
+//#endregion
+//#region ../../src/mcp/primitives/$resource.d.ts
+/**
+ * Creates an MCP resource primitive for exposing read-only data.
+ *
+ * Resources represent any kind of data that an LLM might want to read,
+ * such as files, database records, API responses, or computed data.
+ *
+ * **Key Features**
+ * - URI-based identification for resources
+ * - Support for text and binary content
+ * - MIME type specification
+ * - Lazy loading via handler function
+ *
+ * @example
+ * ```ts
+ * class ProjectResources {
+ *   readme = $resource({
+ *     uri: "file:///readme",
+ *     description: "Project README file",
+ *     mimeType: "text/markdown",
+ *     handler: async () => ({
+ *       text: await fs.readFile("README.md", "utf-8"),
+ *     }),
+ *   });
+ *
+ *   config = $resource({
+ *     uri: "config://app",
+ *     name: "Application Configuration",
+ *     mimeType: "application/json",
+ *     handler: async () => ({
+ *       text: JSON.stringify(this.configService.getConfig()),
+ *     }),
+ *   });
+ * }
+ * ```
+ */
+declare const $resource: {
+  (options: ResourcePrimitiveOptions): ResourcePrimitive;
+  [KIND]: typeof ResourcePrimitive;
+};
+interface ResourcePrimitiveOptions {
+  /**
+   * The URI that identifies this resource.
+   *
+   * URIs should follow a consistent scheme for your application.
+   * Common patterns:
+   * - `file:///path/to/file` - File system resources
+   * - `db://table/id` - Database records
+   * - `api://endpoint` - API responses
+   * - `config://name` - Configuration values
+   *
+   * @example "file:///readme.md"
+   * @example "db://users/123"
+   */
+  uri: string;
+  /**
+   * Human-readable name for the resource.
+   *
+   * If not provided, defaults to the property key where the resource is declared.
+   *
+   * @example "Project README"
+   * @example "User Profile"
+   */
+  name?: string;
+  /**
+   * Description of what this resource contains.
+   *
+   * Helps the LLM understand the purpose and content of the resource.
+   *
+   * @example "The main README file for the project"
+   */
+  description?: string;
+  /**
+   * MIME type of the resource content.
+   *
+   * Helps clients understand how to interpret the content.
+   *
+   * @default "text/plain"
+   * @example "text/markdown"
+   * @example "application/json"
+   */
+  mimeType?: string;
+  /**
+   * Handler function that returns the resource content.
+   *
+   * Called when the resource is read. Can return text or binary content.
+   *
+   * @returns Resource content with either `text` or `blob` property
+   */
+  handler: ResourceHandler;
+}
+declare class ResourcePrimitive extends Primitive<ResourcePrimitiveOptions> {
+  protected readonly mcpServer: McpServerProvider;
+  /**
+   * Returns the name of the resource.
+   */
+  get name(): string;
+  /**
+   * Returns the URI of the resource.
+   */
+  get uri(): string;
+  /**
+   * Returns the description of the resource.
+   */
+  get description(): string | undefined;
+  /**
+   * Returns the MIME type of the resource.
+   */
+  get mimeType(): string;
+  protected onInit(): void;
+  /**
+   * Read the resource content.
+   *
+   * @param context - Optional context from the transport layer
+   * @returns The resource content
+   */
+  read(context?: McpContext): Promise<ResourceContent>;
+  /**
+   * Convert the resource to an MCP resource descriptor for protocol messages.
+   */
+  toDescriptor(): McpResourceDescriptor;
+}
+//#endregion
+//#region ../../src/mcp/primitives/$tool.d.ts
+/**
+ * Creates an MCP tool primitive for defining callable functions.
+ *
+ * Tools are the primary way for LLMs to interact with external systems through MCP.
+ * Each tool has a name, description, typed parameters, and a handler function.
+ *
+ * **Key Features**
+ * - Full TypeScript inference for parameters and results
+ * - Automatic schema validation using TypeBox
+ * - JSON Schema generation for MCP protocol
+ * - Integration with MCP server provider
+ *
+ * @example
+ * ```ts
+ * class CalculatorTools {
+ *   add = $tool({
+ *     description: "Add two numbers together",
+ *     schema: {
+ *       params: t.object({
+ *         a: t.number(),
+ *         b: t.number(),
+ *       }),
+ *       result: t.number(),
+ *     },
+ *     handler: async ({ params }) => {
+ *       return params.a + params.b;
+ *     },
+ *   });
+ *
+ *   greet = $tool({
+ *     description: "Generate a greeting message",
+ *     schema: {
+ *       params: t.object({
+ *         name: t.text(),
+ *       }),
+ *       result: t.text(),
+ *     },
+ *     handler: async ({ params }) => {
+ *       return `Hello, ${params.name}!`;
+ *     },
+ *   });
+ * }
+ * ```
+ */
+declare const $tool: {
+  <T extends ToolPrimitiveSchema>(options: ToolPrimitiveOptions<T>): ToolPrimitive<T>;
+  [KIND]: typeof ToolPrimitive;
+};
+interface ToolPrimitiveOptions<T extends ToolPrimitiveSchema> {
+  /**
+   * The name of the tool.
+   *
+   * If not provided, defaults to the property key where the tool is declared.
+   * Names should be descriptive and use kebab-case or snake_case.
+   *
+   * @example "calculate-sum"
+   * @example "get_weather"
+   */
+  name?: string;
+  /**
+   * A human-readable description of what the tool does.
+   *
+   * This description is sent to the LLM to help it understand
+   * when and how to use the tool. Be clear and specific.
+   *
+   * @example "Calculate the sum of two numbers"
+   * @example "Retrieve current weather data for a given location"
+   */
+  description: string;
+  /**
+   * TypeBox schema defining the tool's parameters and result type.
+   *
+   * - **params**: TObject schema for input parameters (optional)
+   * - **result**: TSchema for the return value (optional)
+   *
+   * Schemas provide:
+   * - Type inference for handler function
+   * - Runtime validation of inputs
+   * - JSON Schema generation for MCP protocol
+   */
+  schema?: T;
+  /**
+   * The handler function that executes when the tool is called.
+   *
+   * Receives validated parameters and returns the result.
+   * Errors thrown here are caught and returned as MCP errors.
+   *
+   * @param args - Object containing validated params
+   * @returns The tool result (can be async)
+   */
+  handler: (args: ToolHandlerArgs<T>) => Async<ToolHandlerResult<T>>;
+}
+declare class ToolPrimitive<T extends ToolPrimitiveSchema> extends Primitive<ToolPrimitiveOptions<T>> {
+  protected readonly mcpServer: McpServerProvider;
+  /**
+   * Returns the name of the tool.
+   */
+  get name(): string;
+  /**
+   * Returns the description of the tool.
+   */
+  get description(): string;
+  protected onInit(): void;
+  /**
+   * Execute the tool with the given parameters.
+   *
+   * @param params - Raw parameters to validate and pass to the handler
+   * @param context - Optional context from the transport layer
+   * @returns The tool result
+   */
+  execute(params: unknown, context?: McpContext): Promise<ToolHandlerResult<T>>;
+  /**
+   * Convert the tool to an MCP tool descriptor for protocol messages.
+   */
+  toDescriptor(): McpToolDescriptor;
+  /**
+   * Convert a TypeBox schema to JSON Schema format.
+   */
+  protected schemaToJsonSchema(schema: TObject): McpJsonSchema;
+  /**
+   * Convert a single property schema to JSON Schema format.
+   */
+  protected propertyToJsonSchema(schema: TSchema): Record<string, unknown>;
+}
+//#endregion
+//#region ../../src/mcp/providers/McpServerProvider.d.ts
+/**
+ * Core MCP server provider that handles protocol messages.
+ *
+ * This provider maintains registries of tools, resources, and prompts,
+ * and routes incoming JSON-RPC requests to the appropriate handlers.
+ *
+ * It is transport-agnostic - actual communication is handled by
+ * transport providers like StdioMcpTransport or SseMcpTransport.
+ */
+declare class McpServerProvider {
+  protected readonly log: alepha_logger0.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly tools: Map<string, ToolPrimitive<any>>;
+  protected readonly resources: Map<string, ResourcePrimitive>;
+  protected readonly prompts: Map<string, PromptPrimitive<any>>;
+  protected initialized: boolean;
+  protected serverInfo: McpServerInfo;
+  /**
+   * Register a tool with the MCP server.
+   */
+  registerTool(tool: ToolPrimitive<any>): void;
+  /**
+   * Register a resource with the MCP server.
+   */
+  registerResource(resource: ResourcePrimitive): void;
+  /**
+   * Register a prompt with the MCP server.
+   */
+  registerPrompt(prompt: PromptPrimitive<any>): void;
+  /**
+   * Get the server capabilities based on registered primitives.
+   */
+  getCapabilities(): McpCapabilities;
+  /**
+   * Get all registered tools.
+   */
+  getTools(): ToolPrimitive<any>[];
+  /**
+   * Get all registered resources.
+   */
+  getResources(): ResourcePrimitive[];
+  /**
+   * Get all registered prompts.
+   */
+  getPrompts(): PromptPrimitive<any>[];
+  /**
+   * Get a tool by name.
+   */
+  getTool(name: string): ToolPrimitive<any> | undefined;
+  /**
+   * Get a resource by URI.
+   */
+  getResource(uri: string): ResourcePrimitive | undefined;
+  /**
+   * Get a prompt by name.
+   */
+  getPrompt(name: string): PromptPrimitive<any> | undefined;
+  /**
+   * Handle an incoming JSON-RPC request.
+   *
+   * @param request - The parsed JSON-RPC request
+   * @param context - Optional context from the transport layer (headers, auth, etc.)
+   * @returns The JSON-RPC response, or null for notifications
+   */
+  handleMessage(request: JsonRpcRequest, context?: McpContext): Promise<JsonRpcResponse | null>;
+  /**
+   * Handle a JSON-RPC request that expects a response.
+   */
+  protected handleRequest(request: JsonRpcRequest, context?: McpContext): Promise<unknown>;
+  /**
+   * Handle a notification (no response expected).
+   */
+  protected handleNotification(request: JsonRpcRequest): Promise<void>;
+  protected handleInitialize(params: Record<string, unknown>): McpInitializeResult;
+  protected handlePing(): Record<string, never>;
+  protected handleToolsList(): {
+    tools: McpToolDescriptor[];
+  };
+  protected handleToolsCall(params: Record<string, unknown>, context?: McpContext): Promise<McpToolCallResult>;
+  protected handleResourcesList(): {
+    resources: McpResourceDescriptor[];
+  };
+  protected handleResourcesRead(params: Record<string, unknown>, context?: McpContext): Promise<McpResourceReadResult>;
+  protected handlePromptsList(): {
+    prompts: McpPromptDescriptor[];
+  };
+  protected handlePromptsGet(params: Record<string, unknown>, context?: McpContext): Promise<McpPromptGetResult>;
+}
+//#endregion
+//#region ../../src/mcp/primitives/$prompt.d.ts
+/**
+ * Creates an MCP prompt primitive for defining reusable prompt templates.
+ *
+ * Prompts allow you to define templated messages that can be filled in
+ * with arguments at runtime. They're useful for creating consistent
+ * interaction patterns.
+ *
+ * @example
+ * ```ts
+ * class Prompts {
+ *   greeting = $prompt({
+ *     description: "Generate a personalized greeting",
+ *     args: t.object({
+ *       name: t.text({ description: "Name of the person to greet" }),
+ *       style: t.optional(t.enum(["formal", "casual"])),
+ *     }),
+ *     handler: async ({ args }) => [
+ *       {
+ *         role: "user",
+ *         content: args.style === "formal"
+ *           ? `Please greet ${args.name} in a formal manner.`
+ *           : `Say hi to ${args.name}!`,
+ *       },
+ *     ],
+ *   });
+ *
+ *   codeReview = $prompt({
+ *     description: "Request a code review",
+ *     args: t.object({
+ *       code: t.text({ description: "The code to review" }),
+ *       language: t.text({ description: "Programming language" }),
+ *     }),
+ *     handler: async ({ args }) => [
+ *       {
+ *         role: "user",
+ *         content: `Please review this ${args.language} code:\n\n${args.code}`,
+ *       },
+ *     ],
+ *   });
+ * }
+ * ```
+ */
+declare const $prompt: {
+  <T extends TObject>(options: PromptPrimitiveOptions<T>): PromptPrimitive<T>;
+  [KIND]: typeof PromptPrimitive;
+};
+interface PromptPrimitiveOptions<T extends TObject> {
+  /**
+   * The name of the prompt.
+   *
+   * If not provided, defaults to the property key where the prompt is declared.
+   *
+   * @example "greeting"
+   * @example "code-review"
+   */
+  name?: string;
+  /**
+   * Description of what this prompt does.
+   *
+   * Helps users understand the purpose of the prompt.
+   *
+   * @example "Generate a personalized greeting message"
+   */
+  description?: string;
+  /**
+   * TypeBox schema defining the prompt arguments.
+   *
+   * Each property in the schema becomes an argument that can be
+   * filled in when the prompt is used.
+   */
+  args?: T;
+  /**
+   * Handler function that generates the prompt messages.
+   *
+   * Receives the validated arguments and returns an array of messages.
+   *
+   * @param args - Object containing validated arguments
+   * @returns Array of prompt messages
+   */
+  handler: (args: PromptHandlerArgs<T>) => Async<PromptMessage[]>;
+}
+declare class PromptPrimitive<T extends TObject> extends Primitive<PromptPrimitiveOptions<T>> {
+  protected readonly mcpServer: McpServerProvider;
+  /**
+   * Returns the name of the prompt.
+   */
+  get name(): string;
+  /**
+   * Returns the description of the prompt.
+   */
+  get description(): string | undefined;
+  protected onInit(): void;
+  /**
+   * Get the prompt messages with the given arguments.
+   *
+   * @param rawArgs - Raw arguments to validate and pass to the handler
+   * @param context - Optional context from the transport layer
+   * @returns Array of prompt messages
+   */
+  get(rawArgs: unknown, context?: McpContext): Promise<PromptMessage[]>;
+  /**
+   * Convert the prompt to an MCP prompt descriptor for protocol messages.
+   */
+  toDescriptor(): McpPromptDescriptor;
+  /**
+   * Convert a TypeBox schema to an array of prompt arguments.
+   */
+  protected schemaToArguments(schema: TObject): McpPromptArgument[];
+}
+//#endregion
+//#region ../../src/mcp/transports/SseMcpTransport.d.ts
+/**
+ * SSE (Server-Sent Events) transport for MCP communication.
+ *
+ * This transport uses HTTP with SSE for server-to-client messages
+ * and POST requests for client-to-server messages.
+ *
+ * Endpoints:
+ * - GET /mcp - SSE stream for server events
+ * - POST /mcp - JSON-RPC request endpoint
+ *
+ * @example
+ * ```ts
+ * import { Alepha, run } from "alepha";
+ * import { AlephaServer } from "alepha/server";
+ * import { AlephaMcp, AlephaMcpSse } from "alepha/mcp";
+ *
+ * class MyTools {
+ *   // ... tool definitions
+ * }
+ *
+ * run(
+ *   Alepha.create()
+ *     .with(AlephaServer)
+ *     .with(AlephaMcp)
+ *     .with(AlephaMcpSse)
+ *     .with(MyTools)
+ * );
+ * ```
+ */
+declare class SseMcpTransport {
+  protected readonly log: alepha_logger0.Logger;
+  protected readonly env: {
+    MCP_SSE_PATH: string;
+  };
+  protected readonly mcpServer: McpServerProvider;
+  /**
+   * SSE endpoint for server-to-client messages.
+   *
+   * Returns a text/event-stream response with server capabilities
+   * and keeps the connection open for notifications.
+   */
+  sse: alepha_server0.RoutePrimitive<alepha_server0.RequestConfigSchema>;
+  /**
+   * POST endpoint for client-to-server JSON-RPC messages.
+   */
+  message: alepha_server0.RoutePrimitive<{
+    body: alepha3.TRecord<string, alepha3.TAny>;
+  }>;
+  /**
+   * Format a message as an SSE event.
+   */
+  protected formatSseEvent(event: string, data: string): string;
+}
+//#endregion
+//#region ../../src/mcp/transports/StdioMcpTransport.d.ts
+/**
+ * Stdio transport for MCP communication.
+ *
+ * This transport uses stdin/stdout for JSON-RPC message exchange,
+ * which is the standard transport for local MCP servers.
+ *
+ * Messages are newline-delimited JSON objects.
+ *
+ * @example
+ * ```ts
+ * import { Alepha, run } from "alepha";
+ * import { AlephaMcp, AlephaMcpStdio } from "alepha/mcp";
+ *
+ * class MyTools {
+ *   // ... tool definitions
+ * }
+ *
+ * run(
+ *   Alepha.create()
+ *     .with(AlephaMcp)
+ *     .with(AlephaMcpStdio)
+ *     .with(MyTools)
+ * );
+ * ```
+ */
+declare class StdioMcpTransport {
+  protected readonly log: alepha_logger0.Logger;
+  protected readonly mcpServer: McpServerProvider;
+  protected rl?: readline.Interface;
+  protected started: boolean;
+  onStart: alepha3.HookPrimitive<"start">;
+  onStop: alepha3.HookPrimitive<"stop">;
+  /**
+   * Start the stdio transport.
+   */
+  protected start(): void;
+  /**
+   * Stop the stdio transport.
+   */
+  protected stop(): void;
+  /**
+   * Handle an incoming line from stdin.
+   */
+  protected handleLine(line: string): Promise<void>;
+  /**
+   * Handle stdin close event.
+   */
+  protected handleClose(): void;
+  /**
+   * Send a message to stdout.
+   */
+  protected send(message: object): void;
+}
+//#endregion
+//#region ../../src/mcp/index.d.ts
+/**
+ * Core MCP module with primitives and server provider.
+ *
+ * This module registers the $tool, $resource, and $prompt primitives
+ * and the McpServerProvider. You need to add a transport module
+ * (AlephaMcpStdio or AlephaMcpSse) for actual communication.
+ *
+ * @example
+ * ```ts
+ * import { Alepha, run } from "alepha";
+ * import { AlephaMcp, AlephaMcpStdio, $tool, t } from "alepha/mcp";
+ *
+ * class MyMcpServer {
+ *   add = $tool({
+ *     description: "Add two numbers",
+ *     schema: {
+ *       params: t.object({ a: t.number(), b: t.number() }),
+ *       result: t.number(),
+ *     },
+ *     handler: async ({ params }) => params.a + params.b,
+ *   });
+ * }
+ *
+ * run(
+ *   Alepha.create()
+ *     .with(AlephaMcp)
+ *     .with(AlephaMcpStdio)
+ *     .with(MyMcpServer)
+ * );
+ * ```
+ *
+ * @module alepha.mcp
+ */
+declare const AlephaMcp: alepha3.Service<alepha3.Module>;
+//#endregion
+export { $prompt, $resource, $tool, AlephaMcp, JSONRPC_VERSION, type JsonRpcError, JsonRpcErrorCodes, type JsonRpcNotification, JsonRpcParseError, type JsonRpcRequest, type JsonRpcResponse, MCP_PROTOCOL_VERSION, type McpCapabilities, type McpClientInfo, type McpContent, type McpContext, McpError, type McpInitializeParams, type McpInitializeResult, McpInvalidParamsError, type McpJsonSchema, McpMethodNotFoundError, type McpPromptArgument, type McpPromptContent, type McpPromptDescriptor, type McpPromptGetParams, type McpPromptGetResult, type McpPromptMessage, McpPromptNotFoundError, type McpResourceContent, type McpResourceDescriptor, McpResourceNotFoundError, type McpResourceReadParams, type McpResourceReadResult, type McpServerInfo, McpServerProvider, type McpToolCallParams, type McpToolCallResult, type McpToolDescriptor, McpToolNotFoundError, type PromptHandler, type PromptHandlerArgs, type PromptMessage, PromptPrimitive, type PromptPrimitiveOptions, type ResourceContent, type ResourceHandler, type ResourceHandlerArgs, ResourcePrimitive, type ResourcePrimitiveOptions, SseMcpTransport, StdioMcpTransport, type ToolHandler, type ToolHandlerArgs, type ToolHandlerResult, ToolPrimitive, type ToolPrimitiveOptions, type ToolPrimitiveSchema, createErrorResponse, createInternalError, createInvalidParamsError, createInvalidRequestError, createMethodNotFoundError, createNotification, createParseError, createResponse, isNotification, isValidJsonRpcRequest, parseMessage };
+//# sourceMappingURL=index.d.ts.map