@contractspec/bundle.library 2.4.0 → 2.6.0

package/dist/application/mcp/index.js

@@ -2,72 +2,161 @@
 // src/application/mcp/common.ts
 import { PresentationRegistry } from "@contractspec/lib.contracts-spec/presentations";
 import { createMcpServer } from "@contractspec/lib.contracts-runtime-server-mcp/provider-mcp";
-import { mcp } from "elysia-mcp";
-function createConsoleLikeLogger(logger) {
-  const isDebug = process.env.CONTRACTSPEC_MCP_DEBUG === "1";
-  const toMessage = (args) => args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-  return {
-    log: (...args) => {
-      if (!isDebug)
-        return;
-      logger.info(toMessage(args));
-    },
-    info: (...args) => {
-      if (!isDebug)
-        return;
-      logger.info(toMessage(args));
-    },
-    warn: (...args) => {
-      logger.warn(toMessage(args));
-    },
-    error: (...args) => {
-      logger.error(toMessage(args));
-    },
-    debug: (...args) => {
-      if (!isDebug)
-        return;
-      logger.debug(toMessage(args));
-    }
-  };
-}
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { Elysia } from "elysia";
+import { randomUUID } from "crypto";
 var baseCtx = {
   actor: "anonymous",
   decide: async () => ({ effect: "allow" })
 };
-function createMcpElysiaHandler({
+function createJsonRpcErrorResponse(status, code, message, data) {
+  return new Response(JSON.stringify({
+    jsonrpc: "2.0",
+    error: {
+      code,
+      message,
+      ...data ? { data } : {}
+    },
+    id: null
+  }), {
+    status,
+    headers: {
+      "content-type": "application/json"
+    }
+  });
+}
+function createSessionState({
   logger,
-  path,
   serverName,
   ops,
   resources,
   prompts,
-  presentations
+  presentations,
+  stateful
 }) {
-  logger.info("Setting up MCP handler...");
-  return mcp({
-    basePath: path,
-    logger: createConsoleLikeLogger(logger),
-    serverInfo: {
-      name: serverName,
-      version: "1.0.0"
-    },
-    stateless: process.env.CONTRACTSPEC_MCP_STATEFUL !== "1",
-    enableJsonResponse: true,
+  const server = new McpServer({
+    name: serverName,
+    version: "1.0.0"
+  }, {
     capabilities: {
       tools: {},
       resources: {},
       prompts: {},
       logging: {}
-    },
-    setupServer: (server) => {
-      logger.info("Setting up MCP server...");
-      createMcpServer(server, ops, resources, prompts, {
+    }
+  });
+  logger.info("Setting up MCP server...");
+  createMcpServer(server, ops, resources, prompts, {
+    logger,
+    toolCtx: () => baseCtx,
+    promptCtx: () => ({ locale: "en" }),
+    resourceCtx: () => ({ locale: "en" }),
+    presentations: new PresentationRegistry(presentations)
+  });
+  const transport = new WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: stateful ? () => randomUUID() : undefined,
+    enableJsonResponse: true
+  });
+  return server.connect(transport).then(() => ({ server, transport }));
+}
+async function closeSessionState(state) {
+  await Promise.allSettled([state.transport.close(), state.server.close()]);
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+function createMcpElysiaHandler({
+  logger,
+  path,
+  serverName,
+  ops,
+  resources,
+  prompts,
+  presentations
+}) {
+  logger.info("Setting up MCP handler...");
+  const isStateful = process.env.CONTRACTSPEC_MCP_STATEFUL === "1";
+  const sessions = new Map;
+  async function handleStateless(request) {
+    const state = await createSessionState({
+      logger,
+      path,
+      serverName,
+      ops,
+      resources,
+      prompts,
+      presentations,
+      stateful: false
+    });
+    try {
+      return await state.transport.handleRequest(request);
+    } finally {
+      await closeSessionState(state);
+    }
+  }
+  async function closeSession(sessionId) {
+    const state = sessions.get(sessionId);
+    if (!state)
+      return;
+    sessions.delete(sessionId);
+    await closeSessionState(state);
+  }
+  async function handleStateful(request) {
+    const requestedSessionId = request.headers.get("mcp-session-id");
+    let state;
+    let createdState = false;
+    if (requestedSessionId) {
+      const existing = sessions.get(requestedSessionId);
+      if (!existing) {
+        return createJsonRpcErrorResponse(404, -32001, "Session not found");
+      }
+      state = existing;
+    } else {
+      state = await createSessionState({
         logger,
-        toolCtx: () => baseCtx,
-        promptCtx: () => ({ locale: "en" }),
-        resourceCtx: () => ({ locale: "en" }),
-        presentations: new PresentationRegistry(presentations)
+        path,
+        serverName,
+        ops,
+        resources,
+        prompts,
+        presentations,
+        stateful: true
+      });
+      createdState = true;
+    }
+    try {
+      const response = await state.transport.handleRequest(request);
+      const activeSessionId = state.transport.sessionId;
+      if (activeSessionId && !sessions.has(activeSessionId)) {
+        sessions.set(activeSessionId, state);
+      }
+      if (request.method === "DELETE" && activeSessionId) {
+        await closeSession(activeSessionId);
+      } else if (!activeSessionId && createdState) {
+        await closeSessionState(state);
+      }
+      return response;
+    } catch (error) {
+      if (createdState) {
+        await closeSessionState(state);
+      }
+      throw error;
+    }
+  }
+  return new Elysia({ name: `mcp-${serverName}` }).all(path, async ({ request }) => {
+    try {
+      if (isStateful) {
+        return await handleStateful(request);
+      }
+      return await handleStateless(request);
+    } catch (error) {
+      logger.error("Error handling MCP request", {
+        path,
+        method: request.method,
+        error: toErrorMessage(error)
       });
+      return createJsonRpcErrorResponse(500, -32000, "Internal error");
     }
   });
 }

package/dist/application/mcp/internalMcp.d.ts

@@ -1,8 +1,6 @@
 export declare function createInternalMcpHandler(path?: string): import("elysia").default<"", {
     decorator: {};
-    store: {
-        authInfo: AuthInfo | undefined;
-    };
+    store: {};
     derive: {};
     resolve: {};
 }, {
@@ -16,39 +14,6 @@ export declare function createInternalMcpHandler(path?: string): import("elysia"
     parser: {};
     response: {};
 }, {
-    [x: string]: {
-        "*": {
-            [x: string]: {
-                body: unknown;
-                params: {
-                    "*": string;
-                } & {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: {} | {
-                        jsonrpc: string;
-                        error: {
-                            code: import("@modelcontextprotocol/sdk/types.js").ErrorCode;
-                            message: string;
-                            data: string;
-                        };
-                        id: null;
-                    };
-                    422: {
-                        type: "validation";
-                        on: string;
-                        summary?: string;
-                        message?: string;
-                        found?: unknown;
-                        property?: string;
-                        expected?: string;
-                    };
-                };
-            };
-        };
-    };
-} & {
     [x: string]: {
         [x: string]: {
             body: unknown;
@@ -56,15 +21,7 @@ export declare function createInternalMcpHandler(path?: string): import("elysia"
             query: unknown;
             headers: unknown;
             response: {
-                200: {} | {
-                    jsonrpc: string;
-                    error: {
-                        code: import("@modelcontextprotocol/sdk/types.js").ErrorCode;
-                        message: string;
-                        data: string;
-                    };
-                    id: null;
-                };
+                200: Response;
             };
         };
     };
@@ -79,15 +36,5 @@ export declare function createInternalMcpHandler(path?: string): import("elysia"
     resolve: {};
     schema: {};
     standaloneSchema: {};
-    response: {
-        200: {} | {
-            jsonrpc: string;
-            error: {
-                code: import("@modelcontextprotocol/sdk/types.js").ErrorCode;
-                message: string;
-                data: string;
-            };
-            id: null;
-        };
-    };
+    response: {};
 }>;

package/dist/application/mcp/internalMcp.js

@@ -2,72 +2,161 @@
 // src/application/mcp/common.ts
 import { PresentationRegistry } from "@contractspec/lib.contracts-spec/presentations";
 import { createMcpServer } from "@contractspec/lib.contracts-runtime-server-mcp/provider-mcp";
-import { mcp } from "elysia-mcp";
-function createConsoleLikeLogger(logger) {
-  const isDebug = process.env.CONTRACTSPEC_MCP_DEBUG === "1";
-  const toMessage = (args) => args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-  return {
-    log: (...args) => {
-      if (!isDebug)
-        return;
-      logger.info(toMessage(args));
-    },
-    info: (...args) => {
-      if (!isDebug)
-        return;
-      logger.info(toMessage(args));
-    },
-    warn: (...args) => {
-      logger.warn(toMessage(args));
-    },
-    error: (...args) => {
-      logger.error(toMessage(args));
-    },
-    debug: (...args) => {
-      if (!isDebug)
-        return;
-      logger.debug(toMessage(args));
-    }
-  };
-}
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { Elysia } from "elysia";
+import { randomUUID } from "crypto";
 var baseCtx = {
   actor: "anonymous",
   decide: async () => ({ effect: "allow" })
 };
-function createMcpElysiaHandler({
+function createJsonRpcErrorResponse(status, code, message, data) {
+  return new Response(JSON.stringify({
+    jsonrpc: "2.0",
+    error: {
+      code,
+      message,
+      ...data ? { data } : {}
+    },
+    id: null
+  }), {
+    status,
+    headers: {
+      "content-type": "application/json"
+    }
+  });
+}
+function createSessionState({
   logger,
-  path,
   serverName,
   ops,
   resources,
   prompts,
-  presentations
+  presentations,
+  stateful
 }) {
-  logger.info("Setting up MCP handler...");
-  return mcp({
-    basePath: path,
-    logger: createConsoleLikeLogger(logger),
-    serverInfo: {
-      name: serverName,
-      version: "1.0.0"
-    },
-    stateless: process.env.CONTRACTSPEC_MCP_STATEFUL !== "1",
-    enableJsonResponse: true,
+  const server = new McpServer({
+    name: serverName,
+    version: "1.0.0"
+  }, {
     capabilities: {
       tools: {},
       resources: {},
       prompts: {},
       logging: {}
-    },
-    setupServer: (server) => {
-      logger.info("Setting up MCP server...");
-      createMcpServer(server, ops, resources, prompts, {
+    }
+  });
+  logger.info("Setting up MCP server...");
+  createMcpServer(server, ops, resources, prompts, {
+    logger,
+    toolCtx: () => baseCtx,
+    promptCtx: () => ({ locale: "en" }),
+    resourceCtx: () => ({ locale: "en" }),
+    presentations: new PresentationRegistry(presentations)
+  });
+  const transport = new WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: stateful ? () => randomUUID() : undefined,
+    enableJsonResponse: true
+  });
+  return server.connect(transport).then(() => ({ server, transport }));
+}
+async function closeSessionState(state) {
+  await Promise.allSettled([state.transport.close(), state.server.close()]);
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+function createMcpElysiaHandler({
+  logger,
+  path,
+  serverName,
+  ops,
+  resources,
+  prompts,
+  presentations
+}) {
+  logger.info("Setting up MCP handler...");
+  const isStateful = process.env.CONTRACTSPEC_MCP_STATEFUL === "1";
+  const sessions = new Map;
+  async function handleStateless(request) {
+    const state = await createSessionState({
+      logger,
+      path,
+      serverName,
+      ops,
+      resources,
+      prompts,
+      presentations,
+      stateful: false
+    });
+    try {
+      return await state.transport.handleRequest(request);
+    } finally {
+      await closeSessionState(state);
+    }
+  }
+  async function closeSession(sessionId) {
+    const state = sessions.get(sessionId);
+    if (!state)
+      return;
+    sessions.delete(sessionId);
+    await closeSessionState(state);
+  }
+  async function handleStateful(request) {
+    const requestedSessionId = request.headers.get("mcp-session-id");
+    let state;
+    let createdState = false;
+    if (requestedSessionId) {
+      const existing = sessions.get(requestedSessionId);
+      if (!existing) {
+        return createJsonRpcErrorResponse(404, -32001, "Session not found");
+      }
+      state = existing;
+    } else {
+      state = await createSessionState({
         logger,
-        toolCtx: () => baseCtx,
-        promptCtx: () => ({ locale: "en" }),
-        resourceCtx: () => ({ locale: "en" }),
-        presentations: new PresentationRegistry(presentations)
+        path,
+        serverName,
+        ops,
+        resources,
+        prompts,
+        presentations,
+        stateful: true
+      });
+      createdState = true;
+    }
+    try {
+      const response = await state.transport.handleRequest(request);
+      const activeSessionId = state.transport.sessionId;
+      if (activeSessionId && !sessions.has(activeSessionId)) {
+        sessions.set(activeSessionId, state);
+      }
+      if (request.method === "DELETE" && activeSessionId) {
+        await closeSession(activeSessionId);
+      } else if (!activeSessionId && createdState) {
+        await closeSessionState(state);
+      }
+      return response;
+    } catch (error) {
+      if (createdState) {
+        await closeSessionState(state);
+      }
+      throw error;
+    }
+  }
+  return new Elysia({ name: `mcp-${serverName}` }).all(path, async ({ request }) => {
+    try {
+      if (isStateful) {
+        return await handleStateful(request);
+      }
+      return await handleStateless(request);
+    } catch (error) {
+      logger.error("Error handling MCP request", {
+        path,
+        method: request.method,
+        error: toErrorMessage(error)
       });
+      return createJsonRpcErrorResponse(500, -32000, "Internal error");
     }
   });
 }