alepha 0.13.8 → 0.14.0

package/dist/mcp/index.js

@@ -0,0 +1,978 @@
+import { $env, $hook, $inject, $module, Alepha, AlephaError, KIND, Primitive, createPrimitive, t } from "alepha";
+import { $logger } from "alepha/logger";
+import { $route } from "alepha/server";
+import * as readline from "node:readline";
+
+//#region ../../src/mcp/helpers/jsonrpc.ts
+const JSONRPC_VERSION = "2.0";
+const MCP_PROTOCOL_VERSION = "2024-11-05";
+const JsonRpcErrorCodes = {
+	PARSE_ERROR: -32700,
+	INVALID_REQUEST: -32600,
+	METHOD_NOT_FOUND: -32601,
+	INVALID_PARAMS: -32602,
+	INTERNAL_ERROR: -32603
+};
+function createResponse(id, result) {
+	return {
+		jsonrpc: JSONRPC_VERSION,
+		id,
+		result
+	};
+}
+function createErrorResponse(id, error) {
+	return {
+		jsonrpc: JSONRPC_VERSION,
+		id,
+		error
+	};
+}
+function createNotification(method, params) {
+	return {
+		jsonrpc: JSONRPC_VERSION,
+		method,
+		params
+	};
+}
+function createParseError(message = "Parse error") {
+	return {
+		code: JsonRpcErrorCodes.PARSE_ERROR,
+		message
+	};
+}
+function createInvalidRequestError(message = "Invalid request") {
+	return {
+		code: JsonRpcErrorCodes.INVALID_REQUEST,
+		message
+	};
+}
+function createMethodNotFoundError(method) {
+	return {
+		code: JsonRpcErrorCodes.METHOD_NOT_FOUND,
+		message: `Method not found: ${method}`
+	};
+}
+function createInvalidParamsError(message) {
+	return {
+		code: JsonRpcErrorCodes.INVALID_PARAMS,
+		message
+	};
+}
+function createInternalError(message) {
+	return {
+		code: JsonRpcErrorCodes.INTERNAL_ERROR,
+		message
+	};
+}
+function parseMessage(data) {
+	let parsed;
+	try {
+		parsed = JSON.parse(data);
+	} catch {
+		throw new JsonRpcParseError("Invalid JSON");
+	}
+	if (!isValidJsonRpcRequest(parsed)) throw new JsonRpcParseError("Invalid JSON-RPC request");
+	return parsed;
+}
+function isValidJsonRpcRequest(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const obj = value;
+	if (obj.jsonrpc !== JSONRPC_VERSION) return false;
+	if (typeof obj.method !== "string") return false;
+	if (obj.id !== void 0 && typeof obj.id !== "string" && typeof obj.id !== "number") return false;
+	if (obj.params !== void 0 && typeof obj.params !== "object") return false;
+	return true;
+}
+function isNotification(request) {
+	return request.id === void 0;
+}
+var JsonRpcParseError = class extends AlephaError {
+	name = "JsonRpcParseError";
+};
+
+//#endregion
+//#region ../../src/mcp/errors/McpError.ts
+var McpError = class extends Error {
+	name = "McpError";
+	code;
+	constructor(message, code = JsonRpcErrorCodes.INTERNAL_ERROR) {
+		super(message);
+		this.code = code;
+	}
+};
+var McpMethodNotFoundError = class extends McpError {
+	name = "McpMethodNotFoundError";
+	constructor(method) {
+		super(`Method not found: ${method}`, JsonRpcErrorCodes.METHOD_NOT_FOUND);
+	}
+};
+var McpToolNotFoundError = class extends McpError {
+	name = "McpToolNotFoundError";
+	tool;
+	constructor(tool) {
+		super(`Tool not found: ${tool}`, JsonRpcErrorCodes.METHOD_NOT_FOUND);
+		this.tool = tool;
+	}
+};
+var McpResourceNotFoundError = class extends McpError {
+	name = "McpResourceNotFoundError";
+	uri;
+	constructor(uri) {
+		super(`Resource not found: ${uri}`, JsonRpcErrorCodes.METHOD_NOT_FOUND);
+		this.uri = uri;
+	}
+};
+var McpPromptNotFoundError = class extends McpError {
+	name = "McpPromptNotFoundError";
+	prompt;
+	constructor(prompt) {
+		super(`Prompt not found: ${prompt}`, JsonRpcErrorCodes.METHOD_NOT_FOUND);
+		this.prompt = prompt;
+	}
+};
+var McpInvalidParamsError = class extends McpError {
+	name = "McpInvalidParamsError";
+	constructor(message) {
+		super(message, JsonRpcErrorCodes.INVALID_PARAMS);
+	}
+};
+
+//#endregion
+//#region ../../src/mcp/providers/McpServerProvider.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.
+*/
+var McpServerProvider = class {
+	log = $logger();
+	alepha = $inject(Alepha);
+	tools = /* @__PURE__ */ new Map();
+	resources = /* @__PURE__ */ new Map();
+	prompts = /* @__PURE__ */ new Map();
+	initialized = false;
+	serverInfo = {
+		name: "alepha-mcp",
+		version: "1.0.0"
+	};
+	/**
+	* Register a tool with the MCP server.
+	*/
+	registerTool(tool) {
+		this.log.trace(`Registering MCP tool: ${tool.name}`);
+		this.tools.set(tool.name, tool);
+	}
+	/**
+	* Register a resource with the MCP server.
+	*/
+	registerResource(resource) {
+		this.log.trace(`Registering MCP resource: ${resource.uri}`);
+		this.resources.set(resource.uri, resource);
+	}
+	/**
+	* Register a prompt with the MCP server.
+	*/
+	registerPrompt(prompt) {
+		this.log.trace(`Registering MCP prompt: ${prompt.name}`);
+		this.prompts.set(prompt.name, prompt);
+	}
+	/**
+	* Get the server capabilities based on registered primitives.
+	*/
+	getCapabilities() {
+		return {
+			tools: this.tools.size > 0 ? {} : void 0,
+			resources: this.resources.size > 0 ? {} : void 0,
+			prompts: this.prompts.size > 0 ? {} : void 0
+		};
+	}
+	/**
+	* Get all registered tools.
+	*/
+	getTools() {
+		return Array.from(this.tools.values());
+	}
+	/**
+	* Get all registered resources.
+	*/
+	getResources() {
+		return Array.from(this.resources.values());
+	}
+	/**
+	* Get all registered prompts.
+	*/
+	getPrompts() {
+		return Array.from(this.prompts.values());
+	}
+	/**
+	* Get a tool by name.
+	*/
+	getTool(name) {
+		return this.tools.get(name);
+	}
+	/**
+	* Get a resource by URI.
+	*/
+	getResource(uri) {
+		return this.resources.get(uri);
+	}
+	/**
+	* Get a prompt by name.
+	*/
+	getPrompt(name) {
+		return this.prompts.get(name);
+	}
+	/**
+	* 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
+	*/
+	async handleMessage(request, context) {
+		const id = request.id;
+		if (id === void 0) {
+			await this.handleNotification(request);
+			return null;
+		}
+		try {
+			return createResponse(id, await this.handleRequest(request, context));
+		} catch (error) {
+			this.log.error("MCP request failed", error);
+			if (error instanceof McpError) return createErrorResponse(id, {
+				code: error.code,
+				message: error.message
+			});
+			return createErrorResponse(id, createInternalError(error.message));
+		}
+	}
+	/**
+	* Handle a JSON-RPC request that expects a response.
+	*/
+	async handleRequest(request, context) {
+		const { method, params = {} } = request;
+		switch (method) {
+			case "initialize": return this.handleInitialize(params);
+			case "ping": return this.handlePing();
+			case "tools/list": return this.handleToolsList();
+			case "tools/call": return this.handleToolsCall(params, context);
+			case "resources/list": return this.handleResourcesList();
+			case "resources/read": return this.handleResourcesRead(params, context);
+			case "prompts/list": return this.handlePromptsList();
+			case "prompts/get": return this.handlePromptsGet(params, context);
+			default: throw new McpMethodNotFoundError(method);
+		}
+	}
+	/**
+	* Handle a notification (no response expected).
+	*/
+	async handleNotification(request) {
+		const { method } = request;
+		switch (method) {
+			case "notifications/initialized":
+				this.log.debug("MCP client initialized");
+				break;
+			case "notifications/cancelled":
+				this.log.debug("MCP request cancelled", request.params);
+				break;
+			default: this.log.debug(`Unknown MCP notification: ${method}`);
+		}
+	}
+	handleInitialize(params) {
+		this.log.info("MCP client initializing", {
+			clientInfo: params.clientInfo,
+			protocolVersion: params.protocolVersion
+		});
+		this.initialized = true;
+		return {
+			protocolVersion: MCP_PROTOCOL_VERSION,
+			capabilities: this.getCapabilities(),
+			serverInfo: this.serverInfo
+		};
+	}
+	handlePing() {
+		return {};
+	}
+	handleToolsList() {
+		return { tools: Array.from(this.tools.values()).map((t$1) => t$1.toDescriptor()) };
+	}
+	async handleToolsCall(params, context) {
+		const name = params.name;
+		const args = params.arguments ?? {};
+		const tool = this.tools.get(name);
+		if (!tool) throw new McpToolNotFoundError(name);
+		try {
+			const result = await tool.execute(args, context);
+			return { content: [{
+				type: "text",
+				text: typeof result === "string" ? result : JSON.stringify(result ?? null)
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${error.message}`
+				}],
+				isError: true
+			};
+		}
+	}
+	handleResourcesList() {
+		return { resources: Array.from(this.resources.values()).map((r) => r.toDescriptor()) };
+	}
+	async handleResourcesRead(params, context) {
+		const uri = params.uri;
+		const resource = this.resources.get(uri);
+		if (!resource) throw new McpResourceNotFoundError(uri);
+		const content = await resource.read(context);
+		const resourceContent = {
+			uri,
+			mimeType: resource.mimeType
+		};
+		if (content.text !== void 0) resourceContent.text = content.text;
+		if (content.blob !== void 0) resourceContent.blob = Buffer.from(content.blob).toString("base64");
+		return { contents: [resourceContent] };
+	}
+	handlePromptsList() {
+		return { prompts: Array.from(this.prompts.values()).map((p) => p.toDescriptor()) };
+	}
+	async handlePromptsGet(params, context) {
+		const name = params.name;
+		const args = params.arguments ?? {};
+		const prompt = this.prompts.get(name);
+		if (!prompt) throw new McpPromptNotFoundError(name);
+		const mcpMessages = (await prompt.get(args, context)).map((msg) => ({
+			role: msg.role,
+			content: {
+				type: "text",
+				text: msg.content
+			}
+		}));
+		return {
+			description: prompt.description,
+			messages: mcpMessages
+		};
+	}
+};
+
+//#endregion
+//#region ../../src/mcp/primitives/$prompt.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}`,
+*       },
+*     ],
+*   });
+* }
+* ```
+*/
+const $prompt = (options) => {
+	return createPrimitive(PromptPrimitive, options);
+};
+var PromptPrimitive = class extends Primitive {
+	mcpServer = $inject(McpServerProvider);
+	/**
+	* Returns the name of the prompt.
+	*/
+	get name() {
+		return this.options.name ?? this.config.propertyKey;
+	}
+	/**
+	* Returns the description of the prompt.
+	*/
+	get description() {
+		return this.options.description;
+	}
+	onInit() {
+		this.mcpServer.registerPrompt(this);
+	}
+	/**
+	* 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
+	*/
+	async get(rawArgs, context) {
+		let args = rawArgs ?? {};
+		if (this.options.args) args = this.alepha.codec.decode(this.options.args, rawArgs ?? {});
+		return this.options.handler({
+			args,
+			context
+		});
+	}
+	/**
+	* Convert the prompt to an MCP prompt descriptor for protocol messages.
+	*/
+	toDescriptor() {
+		return {
+			name: this.name,
+			description: this.description,
+			arguments: this.options.args ? this.schemaToArguments(this.options.args) : []
+		};
+	}
+	/**
+	* Convert a TypeBox schema to an array of prompt arguments.
+	*/
+	schemaToArguments(schema) {
+		const args = [];
+		for (const [name, propSchema] of Object.entries(schema.properties)) {
+			const prop = propSchema;
+			args.push({
+				name,
+				description: prop.description,
+				required: !t.schema.isOptional(propSchema)
+			});
+		}
+		return args;
+	}
+};
+$prompt[KIND] = PromptPrimitive;
+
+//#endregion
+//#region ../../src/mcp/primitives/$resource.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()),
+*     }),
+*   });
+* }
+* ```
+*/
+const $resource = (options) => {
+	return createPrimitive(ResourcePrimitive, options);
+};
+var ResourcePrimitive = class extends Primitive {
+	mcpServer = $inject(McpServerProvider);
+	/**
+	* Returns the name of the resource.
+	*/
+	get name() {
+		return this.options.name ?? this.config.propertyKey;
+	}
+	/**
+	* Returns the URI of the resource.
+	*/
+	get uri() {
+		return this.options.uri;
+	}
+	/**
+	* Returns the description of the resource.
+	*/
+	get description() {
+		return this.options.description;
+	}
+	/**
+	* Returns the MIME type of the resource.
+	*/
+	get mimeType() {
+		return this.options.mimeType ?? "text/plain";
+	}
+	onInit() {
+		this.mcpServer.registerResource(this);
+	}
+	/**
+	* Read the resource content.
+	*
+	* @param context - Optional context from the transport layer
+	* @returns The resource content
+	*/
+	async read(context) {
+		return this.options.handler({ context });
+	}
+	/**
+	* Convert the resource to an MCP resource descriptor for protocol messages.
+	*/
+	toDescriptor() {
+		return {
+			uri: this.uri,
+			name: this.name,
+			description: this.description,
+			mimeType: this.mimeType
+		};
+	}
+};
+$resource[KIND] = ResourcePrimitive;
+
+//#endregion
+//#region ../../src/mcp/primitives/$tool.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}!`;
+*     },
+*   });
+* }
+* ```
+*/
+const $tool = (options) => {
+	return createPrimitive(ToolPrimitive, options);
+};
+var ToolPrimitive = class extends Primitive {
+	mcpServer = $inject(McpServerProvider);
+	/**
+	* Returns the name of the tool.
+	*/
+	get name() {
+		return this.options.name ?? this.config.propertyKey;
+	}
+	/**
+	* Returns the description of the tool.
+	*/
+	get description() {
+		return this.options.description;
+	}
+	onInit() {
+		this.mcpServer.registerTool(this);
+	}
+	/**
+	* 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
+	*/
+	async execute(params, context) {
+		let validatedParams = params ?? {};
+		if (this.options.schema?.params) validatedParams = this.alepha.codec.decode(this.options.schema.params, validatedParams);
+		const result = await this.options.handler({
+			params: validatedParams,
+			context
+		});
+		if (this.options.schema?.result && result !== void 0) return this.alepha.codec.encode(this.options.schema.result, result);
+		return result;
+	}
+	/**
+	* Convert the tool to an MCP tool descriptor for protocol messages.
+	*/
+	toDescriptor() {
+		return {
+			name: this.name,
+			description: this.description,
+			inputSchema: this.options.schema?.params ? this.schemaToJsonSchema(this.options.schema.params) : {
+				type: "object",
+				properties: {},
+				required: []
+			}
+		};
+	}
+	/**
+	* Convert a TypeBox schema to JSON Schema format.
+	*/
+	schemaToJsonSchema(schema) {
+		const properties = {};
+		const required = [];
+		for (const [key, propSchema] of Object.entries(schema.properties)) {
+			properties[key] = this.propertyToJsonSchema(propSchema);
+			if (!t.schema.isOptional(propSchema)) required.push(key);
+		}
+		return {
+			type: "object",
+			properties,
+			required
+		};
+	}
+	/**
+	* Convert a single property schema to JSON Schema format.
+	*/
+	propertyToJsonSchema(schema) {
+		const result = {};
+		if ("description" in schema) result.description = schema.description;
+		if (t.schema.isString(schema)) {
+			result.type = "string";
+			if ("minLength" in schema) result.minLength = schema.minLength;
+			if ("maxLength" in schema) result.maxLength = schema.maxLength;
+			if ("pattern" in schema) result.pattern = schema.pattern;
+			if ("enum" in schema) result.enum = schema.enum;
+		} else if (t.schema.isNumber(schema)) {
+			result.type = "number";
+			if ("minimum" in schema) result.minimum = schema.minimum;
+			if ("maximum" in schema) result.maximum = schema.maximum;
+		} else if (t.schema.isInteger(schema)) {
+			result.type = "integer";
+			if ("minimum" in schema) result.minimum = schema.minimum;
+			if ("maximum" in schema) result.maximum = schema.maximum;
+		} else if (t.schema.isBoolean(schema)) result.type = "boolean";
+		else if (t.schema.isArray(schema)) {
+			result.type = "array";
+			if ("items" in schema) result.items = this.propertyToJsonSchema(schema.items);
+		} else if (t.schema.isObject(schema)) Object.assign(result, this.schemaToJsonSchema(schema));
+		else if (t.schema.isUnsafe(schema) || t.schema.isOptional(schema)) {
+			const schemaAny = schema;
+			if (schemaAny.type === "string") {
+				result.type = "string";
+				if ("enum" in schema) result.enum = schema.enum;
+				if ("pattern" in schema) result.pattern = schema.pattern;
+			} else if (schemaAny.type === "number") result.type = "number";
+			else if (schemaAny.type === "integer") result.type = "integer";
+			else if (schemaAny.type === "boolean") result.type = "boolean";
+			else if (schemaAny.type === "array") result.type = "array";
+			else if (schemaAny.type === "object") result.type = "object";
+			else result.type = "string";
+		} else result.type = "string";
+		return result;
+	}
+};
+$tool[KIND] = ToolPrimitive;
+
+//#endregion
+//#region ../../src/mcp/transports/SseMcpTransport.ts
+const envSchema = t.object({ MCP_SSE_PATH: t.text({
+	description: "Path for MCP SSE endpoint",
+	default: "/mcp"
+}) });
+/**
+* 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)
+* );
+* ```
+*/
+var SseMcpTransport = class {
+	log = $logger();
+	env = $env(envSchema);
+	mcpServer = $inject(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 = $route({
+		method: "GET",
+		path: this.env.MCP_SSE_PATH,
+		handler: async (request) => {
+			this.log.debug("MCP SSE connection established");
+			const encoder = new TextEncoder();
+			const stream = new ReadableStream({
+				start: (controller) => {
+					const endpointEvent = this.formatSseEvent("endpoint", `${this.env.MCP_SSE_PATH}`);
+					controller.enqueue(encoder.encode(endpointEvent));
+					const capabilitiesNotification = createNotification("notifications/capabilities", { capabilities: this.mcpServer.getCapabilities() });
+					const capabilitiesEvent = this.formatSseEvent("message", JSON.stringify(capabilitiesNotification));
+					controller.enqueue(encoder.encode(capabilitiesEvent));
+				},
+				cancel: () => {
+					this.log.debug("MCP SSE connection closed");
+				}
+			});
+			request.reply.status = 200;
+			request.reply.headers = {
+				"content-type": "text/event-stream",
+				"cache-control": "no-cache",
+				connection: "keep-alive"
+			};
+			request.reply.body = stream;
+		}
+	});
+	/**
+	* POST endpoint for client-to-server JSON-RPC messages.
+	*/
+	message = $route({
+		method: "POST",
+		path: this.env.MCP_SSE_PATH,
+		secure: false,
+		schema: { body: t.json() },
+		handler: async (request) => {
+			try {
+				const body = typeof request.body === "string" ? request.body : JSON.stringify(request.body);
+				this.log.debug("MCP request body", {
+					body,
+					bodyType: typeof request.body
+				});
+				const rpcRequest = parseMessage(body);
+				const context = { headers: request.headers };
+				const response = await this.mcpServer.handleMessage(rpcRequest, context);
+				request.reply.headers["content-type"] = "application/json";
+				request.reply.body = response ? JSON.stringify(response) : "";
+			} catch (error) {
+				if (error instanceof JsonRpcParseError) {
+					request.reply.status = 400;
+					request.reply.headers["content-type"] = "application/json";
+					request.reply.body = JSON.stringify(createErrorResponse(0, createParseError(error.message)));
+				} else {
+					this.log.error("Failed to process MCP message", error);
+					request.reply.status = 500;
+					request.reply.body = JSON.stringify({ error: error.message });
+				}
+			}
+		}
+	});
+	/**
+	* Format a message as an SSE event.
+	*/
+	formatSseEvent(event, data) {
+		return `event: ${event}\ndata: ${data}\n\n`;
+	}
+};
+
+//#endregion
+//#region ../../src/mcp/transports/StdioMcpTransport.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)
+* );
+* ```
+*/
+var StdioMcpTransport = class {
+	log = $logger();
+	mcpServer = $inject(McpServerProvider);
+	rl;
+	started = false;
+	onStart = $hook({
+		on: "start",
+		handler: () => this.start()
+	});
+	onStop = $hook({
+		on: "stop",
+		handler: () => this.stop()
+	});
+	/**
+	* Start the stdio transport.
+	*/
+	start() {
+		if (this.started) return;
+		this.started = true;
+		this.rl = readline.createInterface({
+			input: process.stdin,
+			output: process.stdout,
+			terminal: false
+		});
+		this.rl.on("line", (line) => this.handleLine(line));
+		this.rl.on("close", () => this.handleClose());
+		this.log.info("MCP stdio transport started");
+	}
+	/**
+	* Stop the stdio transport.
+	*/
+	stop() {
+		if (!this.started) return;
+		this.started = false;
+		this.rl?.close();
+		this.rl = void 0;
+		this.log.info("MCP stdio transport stopped");
+	}
+	/**
+	* Handle an incoming line from stdin.
+	*/
+	async handleLine(line) {
+		if (!line.trim()) return;
+		try {
+			const request = parseMessage(line);
+			const response = await this.mcpServer.handleMessage(request);
+			if (response) this.send(response);
+		} catch (error) {
+			if (error instanceof JsonRpcParseError) this.send(createErrorResponse(0, createParseError(error.message)));
+			else this.log.error("Failed to process MCP message", error);
+		}
+	}
+	/**
+	* Handle stdin close event.
+	*/
+	handleClose() {
+		this.log.debug("MCP stdio input closed");
+	}
+	/**
+	* Send a message to stdout.
+	*/
+	send(message) {
+		const json = JSON.stringify(message);
+		process.stdout.write(json + "\n");
+	}
+};
+
+//#endregion
+//#region ../../src/mcp/index.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
+*/
+const AlephaMcp = $module({
+	name: "alepha.mcp",
+	primitives: [
+		$tool,
+		$resource,
+		$prompt
+	],
+	services: [
+		McpServerProvider,
+		SseMcpTransport,
+		StdioMcpTransport
+	],
+	register: (alepha) => {
+		alepha.with(McpServerProvider);
+	}
+});
+
+//#endregion
+export { $prompt, $resource, $tool, AlephaMcp, JSONRPC_VERSION, JsonRpcErrorCodes, JsonRpcParseError, MCP_PROTOCOL_VERSION, McpError, McpInvalidParamsError, McpMethodNotFoundError, McpPromptNotFoundError, McpResourceNotFoundError, McpServerProvider, McpToolNotFoundError, PromptPrimitive, ResourcePrimitive, SseMcpTransport, StdioMcpTransport, ToolPrimitive, createErrorResponse, createInternalError, createInvalidParamsError, createInvalidRequestError, createMethodNotFoundError, createNotification, createParseError, createResponse, isNotification, isValidJsonRpcRequest, parseMessage };
+//# sourceMappingURL=index.js.map