mcp-proxy 2.12.2 → 2.13.1

package/src/simple-stdio-server.ts

@@ -1,8 +1,8 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
-  ListResourceTemplatesRequestSchema,
   ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
   ReadResourceRequestSchema,
   SubscribeRequestSchema,
   UnsubscribeRequestSchema,
@@ -24,8 +24,8 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
   return {
     resources: [
       {
-        uri: "file:///example.txt",
         name: "Example Resource",
+        uri: "file:///example.txt",
       },
     ],
   };
@@ -36,9 +36,9 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     return {
       contents: [
         {
-          uri: "file:///example.txt",
           mimeType: "text/plain",
           text: "This is the content of the example resource.",
+          uri: "file:///example.txt",
         },
       ],
     };
@@ -51,9 +51,9 @@ server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
   return {
     resourceTemplates: [
       {
-        uriTemplate: `file://{filename}`,
-        name: "Example resource template",
         description: "Specify the filename to retrieve",
+        name: "Example resource template",
+        uriTemplate: `file://{filename}`,
       },
     ],
   };

package/src/startHTTPStreamServer.test.ts

@@ -0,0 +1,130 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { EventSource } from "eventsource";
+import { getRandomPort } from "get-port-please";
+import { setTimeout as delay } from "node:timers/promises";
+import { expect, it, vi } from "vitest";
+
+import { proxyServer } from "./proxyServer.js";
+import { startHTTPStreamServer } from "./startHTTPStreamServer.js";
+
+if (!("EventSource" in global)) {
+  // @ts-expect-error - figure out how to use --experimental-eventsource with vitest
+  global.EventSource = EventSource;
+}
+
+it("proxies messages between HTTP stream and stdio servers", async () => {
+  const stdioTransport = new StdioClientTransport({
+    args: ["src/simple-stdio-server.ts"],
+    command: "tsx",
+  });
+
+  const stdioClient = new Client(
+    {
+      name: "mcp-proxy",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {},
+    },
+  );
+
+  await stdioClient.connect(stdioTransport);
+
+  const serverVersion = stdioClient.getServerVersion() as {
+    name: string;
+    version: string;
+  };
+
+  const serverCapabilities = stdioClient.getServerCapabilities() as {
+    capabilities: Record<string, unknown>;
+  };
+
+  const port = await getRandomPort();
+
+  const onConnect = vi.fn();
+  const onClose = vi.fn();
+
+  await startHTTPStreamServer({
+    createServer: async () => {
+      const mcpServer = new Server(serverVersion, {
+        capabilities: serverCapabilities,
+      });
+
+      await proxyServer({
+        client: stdioClient,
+        server: mcpServer,
+        serverCapabilities,
+      });
+
+      return mcpServer;
+    },
+    endpoint: "/stream",
+    onClose,
+    onConnect,
+    port,
+  });
+
+  const streamClient = new Client(
+    {
+      name: "stream-client",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {},
+    },
+  );
+
+  const transport = new StreamableHTTPClientTransport(
+    new URL(`http://localhost:${port}/stream`),
+  );
+
+  await streamClient.connect(transport);
+
+  const result = await streamClient.listResources();
+  expect(result).toEqual({
+    resources: [
+      {
+        name: "Example Resource",
+        uri: "file:///example.txt",
+      },
+    ],
+  });
+
+  expect(
+    await streamClient.readResource({ uri: result.resources[0].uri }, {}),
+  ).toEqual({
+    contents: [
+      {
+        mimeType: "text/plain",
+        text: "This is the content of the example resource.",
+        uri: "file:///example.txt",
+      },
+    ],
+  });
+  expect(await streamClient.subscribeResource({ uri: "xyz" })).toEqual({});
+  expect(await streamClient.unsubscribeResource({ uri: "xyz" })).toEqual({});
+  expect(await streamClient.listResourceTemplates()).toEqual({
+    resourceTemplates: [
+      {
+        description: "Specify the filename to retrieve",
+        name: "Example resource template",
+        uriTemplate: `file://{filename}`,
+      },
+    ],
+  });
+
+  expect(onConnect).toHaveBeenCalled();
+  expect(onClose).not.toHaveBeenCalled();
+
+  // the transport no requires the function terminateSession to be called but the client does not implement it
+  // so we need to call it manually
+  await transport.terminateSession();
+  await streamClient.close();
+
+  await delay(1000);
+
+  expect(onClose).toHaveBeenCalled();
+});

package/src/startHTTPStreamServer.ts

@@ -0,0 +1,281 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  EventStore,
+  StreamableHTTPServerTransport,
+} from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import http from "http";
+import { randomUUID } from "node:crypto";
+
+import { InMemoryEventStore } from "./InMemoryEventStore.js";
+
+export type SSEServer = {
+  close: () => Promise<void>;
+};
+
+type ServerLike = {
+  close: Server["close"];
+  connect: Server["connect"];
+};
+
+export const startHTTPStreamServer = async <T extends ServerLike>({
+  createServer,
+  endpoint,
+  eventStore,
+  onClose,
+  onConnect,
+  onUnhandledRequest,
+  port,
+}: {
+  createServer: (request: http.IncomingMessage) => Promise<T>;
+  endpoint: string;
+  eventStore?: EventStore;
+  onClose?: (server: T) => void;
+  onConnect?: (server: T) => void;
+  onUnhandledRequest?: (
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+  ) => Promise<void>;
+  port: number;
+}): Promise<SSEServer> => {
+  const activeTransports: Record<
+    string,
+    {
+      server: T;
+      transport: StreamableHTTPServerTransport;
+    }
+  > = {};
+
+  /**
+   * @author https://dev.classmethod.jp/articles/mcp-sse/
+   */
+  const httpServer = http.createServer(async (req, res) => {
+    if (req.headers.origin) {
+      try {
+        const origin = new URL(req.headers.origin);
+
+        res.setHeader("Access-Control-Allow-Origin", origin.origin);
+        res.setHeader("Access-Control-Allow-Credentials", "true");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "*");
+      } catch (error) {
+        console.error("Error parsing origin:", error);
+      }
+    }
+
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    if (req.method === "GET" && req.url === `/ping`) {
+      res.writeHead(200).end("pong");
+      return;
+    }
+
+    if (
+      req.method === "POST" &&
+      new URL(req.url!, "http://localhost").pathname === endpoint
+    ) {
+      try {
+        const sessionId = Array.isArray(req.headers["mcp-session-id"])
+          ? req.headers["mcp-session-id"][0]
+          : req.headers["mcp-session-id"];
+        let transport: StreamableHTTPServerTransport;
+        let server: T;
+
+        const body = await getBody(req);
+
+        if (sessionId && activeTransports[sessionId]) {
+          transport = activeTransports[sessionId].transport;
+          server = activeTransports[sessionId].server;
+        } else if (!sessionId && isInitializeRequest(body)) {
+          // Create a new transport for the session
+          transport = new StreamableHTTPServerTransport({
+            eventStore: eventStore || new InMemoryEventStore(),
+            onsessioninitialized: (_sessionId) => {
+              // add only when the id Sesison id is generated
+              activeTransports[_sessionId] = {
+                server,
+                transport,
+              };
+            },
+            sessionIdGenerator: randomUUID,
+          });
+
+          // Handle the server close event
+          transport.onclose = async () => {
+            const sid = transport.sessionId;
+            if (sid && activeTransports[sid]) {
+              onClose?.(server);
+              try {
+                await server.close();
+              } catch (error) {
+                console.error("Error closing server:", error);
+              }
+              delete activeTransports[sid];
+            }
+          };
+
+          // Create the server
+          try {
+            server = await createServer(req);
+          } catch (error) {
+            if (error instanceof Response) {
+              res.writeHead(error.status).end(error.statusText);
+              return;
+            }
+            res.writeHead(500).end("Error creating server");
+            return;
+          }
+
+          server.connect(transport);
+          onConnect?.(server);
+
+          await transport.handleRequest(req, res, body);
+          return;
+        } else {
+          // Error if the server is not created but the request is not an initialize request
+          res.setHeader("Content-Type", "application/json");
+          res.writeHead(400).end(
+            JSON.stringify({
+              error: {
+                code: -32000,
+                message: "Bad Request: No valid session ID provided",
+              },
+              id: null,
+              jsonrpc: "2.0",
+            }),
+          );
+
+          return;
+        }
+
+        // Handle ther request if the server is already created
+        await transport.handleRequest(req, res, body);
+      } catch (error) {
+        console.error("Error handling request:", error);
+        res.setHeader("Content-Type", "application/json");
+        res.writeHead(500).end(
+          JSON.stringify({
+            error: { code: -32603, message: "Internal Server Error" },
+            id: null,
+            jsonrpc: "2.0",
+          }),
+        );
+      }
+      return;
+    }
+
+    if (
+      req.method === "GET" &&
+      new URL(req.url!, "http://localhost").pathname === endpoint
+    ) {
+      const sessionId = req.headers["mcp-session-id"] as string | undefined;
+      const activeTransport:
+        | {
+            server: T;
+            transport: StreamableHTTPServerTransport;
+          }
+        | undefined = sessionId ? activeTransports[sessionId] : undefined;
+
+      if (!sessionId) {
+        res.writeHead(400).end("No sessionId");
+        return;
+      }
+
+      if (!activeTransport) {
+        res.writeHead(400).end("No active transport");
+        return;
+      }
+
+      const lastEventId = req.headers["last-event-id"] as string | undefined;
+      if (lastEventId) {
+        console.log(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
+      } else {
+        console.log(`Establishing new SSE stream for session ${sessionId}`);
+      }
+
+      await activeTransport.transport.handleRequest(req, res);
+      return;
+    }
+
+    if (
+      req.method === "DELETE" &&
+      new URL(req.url!, "http://localhost").pathname === endpoint
+    ) {
+      console.log("received delete request");
+      const sessionId = req.headers["mcp-session-id"] as string | undefined;
+      if (!sessionId) {
+        res.writeHead(400).end("Invalid or missing sessionId");
+        return;
+      }
+
+      console.log("received delete request for session", sessionId);
+
+      const { server, transport } = activeTransports[sessionId];
+      if (!transport) {
+        res.writeHead(400).end("No active transport");
+        return;
+      }
+
+      try {
+        await transport.handleRequest(req, res);
+        onClose?.(server);
+      } catch (error) {
+        console.error("Error handling delete request:", error);
+        res.writeHead(500).end("Error handling delete request");
+      }
+
+      return;
+    }
+
+    if (onUnhandledRequest) {
+      await onUnhandledRequest(req, res);
+    } else {
+      res.writeHead(404).end();
+    }
+  });
+
+  await new Promise((resolve) => {
+    httpServer.listen(port, "::", () => {
+      resolve(undefined);
+    });
+  });
+
+  return {
+    close: async () => {
+      for (const transport of Object.values(activeTransports)) {
+        await transport.transport.close();
+      }
+
+      return new Promise((resolve, reject) => {
+        httpServer.close((error) => {
+          if (error) {
+            reject(error);
+
+            return;
+          }
+
+          resolve();
+        });
+      });
+    },
+  };
+};
+
+function getBody(request: http.IncomingMessage) {
+  return new Promise((resolve) => {
+    const bodyParts: Buffer[] = [];
+    let body: string;
+    request
+      .on("data", (chunk) => {
+        bodyParts.push(chunk);
+      })
+      .on("end", () => {
+        body = Buffer.concat(bodyParts).toString();
+        resolve(JSON.parse(body));
+      });
+  });
+}

package/src/startSSEServer.test.ts

@@ -1,13 +1,14 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { it, expect, vi } from "vitest";
-import { startSSEServer } from "./startSSEServer.js";
-import { getRandomPort } from "get-port-please";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { EventSource } from "eventsource";
+import { getRandomPort } from "get-port-please";
 import { setTimeout as delay } from "node:timers/promises";
+import { expect, it, vi } from "vitest";
+
 import { proxyServer } from "./proxyServer.js";
+import { startSSEServer } from "./startSSEServer.js";
 
 if (!("EventSource" in global)) {
   // @ts-expect-error - figure out how to use --experimental-eventsource with vitest
@@ -16,8 +17,8 @@ if (!("EventSource" in global)) {
 
 it("proxies messages between SSE and stdio servers", async () => {
   const stdioTransport = new StdioClientTransport({
-    command: "tsx",
     args: ["src/simple-stdio-server.ts"],
+    command: "tsx",
   });
 
   const stdioClient = new Client(
@@ -37,7 +38,9 @@ it("proxies messages between SSE and stdio servers", async () => {
     version: string;
   };
 
-  const serverCapabilities = stdioClient.getServerCapabilities() as {};
+  const serverCapabilities = stdioClient.getServerCapabilities() as {
+    capabilities: Record<string, unknown>;
+  };
 
   const port = await getRandomPort();
 
@@ -51,17 +54,17 @@ it("proxies messages between SSE and stdio servers", async () => {
       });
 
       await proxyServer({
-        server: mcpServer,
         client: stdioClient,
+        server: mcpServer,
         serverCapabilities,
       });
 
       return mcpServer;
     },
-    port,
     endpoint: "/sse",
-    onConnect,
     onClose,
+    onConnect,
+    port,
   });
 
   const sseClient = new Client(
@@ -84,18 +87,20 @@ it("proxies messages between SSE and stdio servers", async () => {
   expect(result).toEqual({
     resources: [
       {
-        uri: "file:///example.txt",
         name: "Example Resource",
+        uri: "file:///example.txt",
       },
     ],
   });
 
-  expect(await sseClient.readResource({uri: (result.resources[0].uri)},{})).toEqual({
+  expect(
+    await sseClient.readResource({ uri: result.resources[0].uri }, {}),
+  ).toEqual({
     contents: [
       {
-        uri: "file:///example.txt",
         mimeType: "text/plain",
         text: "This is the content of the example resource.",
+        uri: "file:///example.txt",
       },
     ],
   });
@@ -104,14 +109,13 @@ it("proxies messages between SSE and stdio servers", async () => {
   expect(await sseClient.listResourceTemplates()).toEqual({
     resourceTemplates: [
       {
-        uriTemplate: `file://{filename}`,
-        name: "Example resource template",
         description: "Specify the filename to retrieve",
+        name: "Example resource template",
+        uriTemplate: `file://{filename}`,
       },
     ],
   });
 
-
   expect(onConnect).toHaveBeenCalled();
   expect(onClose).not.toHaveBeenCalled();
 

package/src/startSSEServer.ts

@@ -1,33 +1,33 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import http from "http";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 
 export type SSEServer = {
   close: () => Promise<void>;
 };
 
 type ServerLike = {
-  connect: Server["connect"];
   close: Server["close"];
+  connect: Server["connect"];
 };
 
 export const startSSEServer = async <T extends ServerLike>({
-  port,
   createServer,
   endpoint,
-  onConnect,
   onClose,
+  onConnect,
   onUnhandledRequest,
+  port,
 }: {
-  port: number;
-  endpoint: string;
   createServer: (request: http.IncomingMessage) => Promise<T>;
-  onConnect?: (server: T) => void;
+  endpoint: string;
   onClose?: (server: T) => void;
+  onConnect?: (server: T) => void;
   onUnhandledRequest?: (
     req: http.IncomingMessage,
     res: http.ServerResponse,
   ) => Promise<void>;
+  port: number;
 }): Promise<SSEServer> => {
   const activeTransports: Record<string, SSEServerTransport> = {};
 
@@ -54,13 +54,21 @@ export const startSSEServer = async <T extends ServerLike>({
       return;
     }
 
+    if (req.method === "GET" && req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "text/plain" }).end("OK");
+      return;
+    }
+
     if (req.method === "GET" && req.url === `/ping`) {
       res.writeHead(200).end("pong");
 
       return;
     }
 
-    if (req.method === "GET" && new URL(req.url!, "http://localhost").pathname === endpoint) {
+    if (
+      req.method === "GET" &&
+      new URL(req.url!, "http://localhost").pathname === endpoint
+    ) {
       const transport = new SSEServerTransport("/messages", res);
 
       let server: T;

package/src/tapTransport.ts

@@ -3,22 +3,22 @@ import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
 
 type TransportEvent =
   | {
-      type: "close";
+      error: Error;
+      type: "onerror";
     }
   | {
-      type: "onclose";
+      message: JSONRPCMessage;
+      type: "onmessage";
     }
   | {
-      type: "onerror";
-      error: Error;
+      message: JSONRPCMessage;
+      type: "send";
     }
   | {
-      type: "onmessage";
-      message: JSONRPCMessage;
+      type: "close";
     }
   | {
-      type: "send";
-      message: JSONRPCMessage;
+      type: "onclose";
     }
   | {
       type: "start";
@@ -53,8 +53,8 @@ export const tapTransport = (
 
   transport.onerror = async (error: Error) => {
     eventHandler({
-      type: "onerror",
       error,
+      type: "onerror",
     });
 
     return originalOnError?.(error);
@@ -62,8 +62,8 @@ export const tapTransport = (
 
   transport.onmessage = async (message: JSONRPCMessage) => {
     eventHandler({
-      type: "onmessage",
       message,
+      type: "onmessage",
     });
 
     return originalOnMessage?.(message);
@@ -71,8 +71,8 @@ export const tapTransport = (
 
   transport.send = async (message: JSONRPCMessage) => {
     eventHandler({
-      type: "send",
       message,
+      type: "send",
     });
 
     return originalSend?.(message);