mcp-use 1.5.0-canary.5 → 1.5.0-canary.7

package/dist/src/server/index.js

@@ -1756,7 +1756,7 @@ if (container && Component) {
     });
   }
   /**
-   * Mount MCP server endpoints at /mcp
+   * Mount MCP server endpoints at /mcp and /sse
    *
    * Sets up the HTTP transport layer for the MCP server, creating endpoints for
    * Server-Sent Events (SSE) streaming, POST message handling, and DELETE session cleanup.
@@ -1770,48 +1770,65 @@ if (container && Component) {
    *
    * @example
    * Endpoints created:
-   * - GET /mcp - SSE streaming endpoint for real-time communication
-   * - POST /mcp - Message handling endpoint for MCP protocol messages
-   * - DELETE /mcp - Session cleanup endpoint
+   * - GET /mcp, GET /sse - SSE streaming endpoint for real-time communication
+   * - POST /mcp, POST /sse - Message handling endpoint for MCP protocol messages
+   * - DELETE /mcp, DELETE /sse - Session cleanup endpoint
    */
   async mountMcp() {
     if (this.mcpMounted) return;
     const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
-    const endpoint = "/mcp";
     const idleTimeoutMs = this.config.sessionIdleTimeoutMs ?? 3e5;
     const getOrCreateTransport = /* @__PURE__ */ __name(async (sessionId, isInit = false) => {
+      if (isInit) {
+        if (sessionId && this.sessions.has(sessionId)) {
+          try {
+            this.sessions.get(sessionId).transport.close();
+          } catch (error) {
+          }
+          this.sessions.delete(sessionId);
+        }
+        const isProduction = this.isProductionMode();
+        let allowedOrigins = this.config.allowedOrigins;
+        let enableDnsRebindingProtection = false;
+        if (isProduction) {
+          if (allowedOrigins !== void 0) {
+            enableDnsRebindingProtection = allowedOrigins.length > 0;
+          }
+        } else {
+          allowedOrigins = void 0;
+          enableDnsRebindingProtection = false;
+        }
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: /* @__PURE__ */ __name(() => generateUUID(), "sessionIdGenerator"),
+          enableJsonResponse: true,
+          allowedOrigins,
+          enableDnsRebindingProtection,
+          onsessioninitialized: /* @__PURE__ */ __name((id) => {
+            if (id) {
+              this.sessions.set(id, {
+                transport,
+                lastAccessedAt: Date.now()
+              });
+            }
+          }, "onsessioninitialized"),
+          onsessionclosed: /* @__PURE__ */ __name((id) => {
+            if (id) {
+              this.sessions.delete(id);
+            }
+          }, "onsessionclosed")
+        });
+        await this.server.connect(transport);
+        return transport;
+      }
       if (sessionId && this.sessions.has(sessionId)) {
         const session = this.sessions.get(sessionId);
         session.lastAccessedAt = Date.now();
         return session.transport;
       }
-      if (!isInit && sessionId) {
+      if (sessionId) {
         return null;
       }
-      if (!isInit && !sessionId) {
-        return null;
-      }
-      const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: /* @__PURE__ */ __name(() => generateUUID(), "sessionIdGenerator"),
-        enableJsonResponse: true,
-        allowedOrigins: this.config.allowedOrigins,
-        enableDnsRebindingProtection: this.config.allowedOrigins !== void 0 && this.config.allowedOrigins.length > 0,
-        onsessioninitialized: /* @__PURE__ */ __name((id) => {
-          if (id) {
-            this.sessions.set(id, {
-              transport,
-              lastAccessedAt: Date.now()
-            });
-          }
-        }, "onsessioninitialized"),
-        onsessionclosed: /* @__PURE__ */ __name((id) => {
-          if (id) {
-            this.sessions.delete(id);
-          }
-        }, "onsessionclosed")
-      });
-      await this.server.connect(transport);
-      return transport;
+      return null;
     }, "getOrCreateTransport");
     if (idleTimeoutMs > 0 && !this.idleCleanupInterval) {
       this.idleCleanupInterval = setInterval(() => {
@@ -1934,245 +1951,250 @@ if (container && Component) {
         }, "getResponse")
       };
     }, "createExpressLikeObjects");
-    this.app.post(endpoint, async (c) => {
-      const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
-      let body = {};
-      try {
-        body = await c.req.json();
-        expressReq.body = body;
-      } catch {
-        expressReq.body = {};
-      }
-      const isInit = body?.method === "initialize";
-      const sessionId = c.req.header("mcp-session-id");
-      const transport = await getOrCreateTransport(sessionId, isInit);
-      if (!transport) {
-        if (sessionId) {
-          return c.json(
-            {
-              jsonrpc: "2.0",
-              error: {
-                code: -32e3,
-                message: "Session not found or expired"
-              },
-              id: null
-            },
-            404
-          );
-        } else {
-          return c.json(
-            {
-              jsonrpc: "2.0",
-              error: {
-                code: -32e3,
-                message: "Bad Request: Mcp-Session-Id header is required"
-              },
-              id: null
-            },
-            400
-          );
+    const mountEndpoint = /* @__PURE__ */ __name((endpoint) => {
+      this.app.post(endpoint, async (c) => {
+        const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
+        let body = {};
+        try {
+          body = await c.req.json();
+          expressReq.body = body;
+        } catch {
+          expressReq.body = {};
         }
-      }
-      if (sessionId && this.sessions.has(sessionId)) {
-        this.sessions.get(sessionId).lastAccessedAt = Date.now();
-      }
-      if (expressRes._closeHandler) {
-        c.req.raw.signal?.addEventListener("abort", () => {
-          transport.close();
-        });
-      }
-      await this.waitForRequestComplete(
-        transport,
-        expressReq,
-        expressRes,
-        expressReq.body
-      );
-      const response = getResponse();
-      if (response) {
-        return response;
-      }
-      return c.text("", 200);
-    });
-    this.app.get(endpoint, async (c) => {
-      const sessionId = c.req.header("mcp-session-id");
-      const transport = await getOrCreateTransport(sessionId, false);
-      if (!transport) {
-        if (sessionId) {
-          return c.json(
-            {
-              jsonrpc: "2.0",
-              error: {
-                code: -32e3,
-                message: "Session not found or expired"
+        const isInit = body?.method === "initialize";
+        const sessionId = c.req.header("mcp-session-id");
+        const transport = await getOrCreateTransport(sessionId, isInit);
+        if (!transport) {
+          if (sessionId) {
+            return c.json(
+              {
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Session not found or expired"
+                },
+                // Notifications don't have an id, but we include null for consistency
+                id: body?.id ?? null
               },
-              id: null
-            },
-            404
-          );
-        } else {
-          return c.json(
-            {
-              jsonrpc: "2.0",
-              error: {
-                code: -32e3,
-                message: "Bad Request: Mcp-Session-Id header is required"
+              404
+            );
+          } else {
+            return c.json(
+              {
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Bad Request: Mcp-Session-Id header is required"
+                },
+                id: body?.id ?? null
               },
-              id: null
-            },
-            400
-          );
-        }
-      }
-      if (sessionId && this.sessions.has(sessionId)) {
-        this.sessions.get(sessionId).lastAccessedAt = Date.now();
-      }
-      c.req.raw.signal?.addEventListener("abort", () => {
-        transport.close();
-      });
-      const { readable, writable } = new globalThis.TransformStream();
-      const writer = writable.getWriter();
-      const encoder = new TextEncoder();
-      let resolveResponse;
-      const responsePromise = new Promise((resolve) => {
-        resolveResponse = resolve;
-      });
-      let headersSent = false;
-      const headers = {};
-      let statusCode = 200;
-      const expressRes = {
-        statusCode: 200,
-        headersSent: false,
-        status: /* @__PURE__ */ __name((code) => {
-          statusCode = code;
-          expressRes.statusCode = code;
-          return expressRes;
-        }, "status"),
-        setHeader: /* @__PURE__ */ __name((name, value) => {
-          if (!headersSent) {
-            headers[name] = Array.isArray(value) ? value.join(", ") : value;
-          }
-        }, "setHeader"),
-        getHeader: /* @__PURE__ */ __name((name) => headers[name], "getHeader"),
-        write: /* @__PURE__ */ __name((chunk) => {
-          if (!headersSent) {
-            headersSent = true;
-            resolveResponse(
-              new Response(readable, {
-                status: statusCode,
-                headers
-              })
+              400
             );
           }
-          const data = typeof chunk === "string" ? encoder.encode(chunk) : chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
-          writer.write(data);
-          return true;
-        }, "write"),
-        end: /* @__PURE__ */ __name((chunk) => {
-          if (chunk) {
-            expressRes.write(chunk);
-          }
-          if (!headersSent) {
-            headersSent = true;
-            resolveResponse(
-              new Response(null, {
-                status: statusCode,
-                headers
-              })
+        }
+        if (sessionId && this.sessions.has(sessionId)) {
+          this.sessions.get(sessionId).lastAccessedAt = Date.now();
+        }
+        if (expressRes._closeHandler) {
+          c.req.raw.signal?.addEventListener("abort", () => {
+            transport.close();
+          });
+        }
+        await this.waitForRequestComplete(
+          transport,
+          expressReq,
+          expressRes,
+          expressReq.body
+        );
+        const response = getResponse();
+        if (response) {
+          return response;
+        }
+        return c.text("", 200);
+      });
+      this.app.get(endpoint, async (c) => {
+        const sessionId = c.req.header("mcp-session-id");
+        const transport = await getOrCreateTransport(sessionId, false);
+        if (!transport) {
+          if (sessionId) {
+            return c.json(
+              {
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Session not found or expired"
+                },
+                id: null
+              },
+              404
             );
-            writer.close();
           } else {
-            writer.close();
-          }
-        }, "end"),
-        on: /* @__PURE__ */ __name((event, handler) => {
-          if (event === "close") {
-            expressRes._closeHandler = handler;
-          }
-        }, "on"),
-        once: /* @__PURE__ */ __name(() => {
-        }, "once"),
-        removeListener: /* @__PURE__ */ __name(() => {
-        }, "removeListener"),
-        writeHead: /* @__PURE__ */ __name((code, _headers) => {
-          statusCode = code;
-          expressRes.statusCode = code;
-          if (_headers) {
-            Object.assign(headers, _headers);
-          }
-          if (!headersSent) {
-            headersSent = true;
-            resolveResponse(
-              new Response(readable, {
-                status: statusCode,
-                headers
-              })
+            return c.json(
+              {
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Bad Request: Mcp-Session-Id header is required"
+                },
+                id: null
+              },
+              400
             );
           }
-          return expressRes;
-        }, "writeHead"),
-        flushHeaders: /* @__PURE__ */ __name(() => {
-        }, "flushHeaders")
-      };
-      const expressReq = {
-        ...c.req.raw,
-        url: new URL(c.req.url).pathname + new URL(c.req.url).search,
-        path: new URL(c.req.url).pathname,
-        query: Object.fromEntries(new URL(c.req.url).searchParams),
-        headers: c.req.header(),
-        method: c.req.method
-      };
-      transport.handleRequest(expressReq, expressRes).catch((err) => {
-        console.error("MCP Transport error:", err);
-        try {
-          writer.close();
-        } catch {
         }
+        if (sessionId && this.sessions.has(sessionId)) {
+          this.sessions.get(sessionId).lastAccessedAt = Date.now();
+        }
+        c.req.raw.signal?.addEventListener("abort", () => {
+          transport.close();
+        });
+        const { readable, writable } = new globalThis.TransformStream();
+        const writer = writable.getWriter();
+        const encoder = new TextEncoder();
+        let resolveResponse;
+        const responsePromise = new Promise((resolve) => {
+          resolveResponse = resolve;
+        });
+        let headersSent = false;
+        const headers = {};
+        let statusCode = 200;
+        const expressRes = {
+          statusCode: 200,
+          headersSent: false,
+          status: /* @__PURE__ */ __name((code) => {
+            statusCode = code;
+            expressRes.statusCode = code;
+            return expressRes;
+          }, "status"),
+          setHeader: /* @__PURE__ */ __name((name, value) => {
+            if (!headersSent) {
+              headers[name] = Array.isArray(value) ? value.join(", ") : value;
+            }
+          }, "setHeader"),
+          getHeader: /* @__PURE__ */ __name((name) => headers[name], "getHeader"),
+          write: /* @__PURE__ */ __name((chunk) => {
+            if (!headersSent) {
+              headersSent = true;
+              resolveResponse(
+                new Response(readable, {
+                  status: statusCode,
+                  headers
+                })
+              );
+            }
+            const data = typeof chunk === "string" ? encoder.encode(chunk) : chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+            writer.write(data);
+            return true;
+          }, "write"),
+          end: /* @__PURE__ */ __name((chunk) => {
+            if (chunk) {
+              expressRes.write(chunk);
+            }
+            if (!headersSent) {
+              headersSent = true;
+              resolveResponse(
+                new Response(null, {
+                  status: statusCode,
+                  headers
+                })
+              );
+              writer.close();
+            } else {
+              writer.close();
+            }
+          }, "end"),
+          on: /* @__PURE__ */ __name((event, handler) => {
+            if (event === "close") {
+              expressRes._closeHandler = handler;
+            }
+          }, "on"),
+          once: /* @__PURE__ */ __name(() => {
+          }, "once"),
+          removeListener: /* @__PURE__ */ __name(() => {
+          }, "removeListener"),
+          writeHead: /* @__PURE__ */ __name((code, _headers) => {
+            statusCode = code;
+            expressRes.statusCode = code;
+            if (_headers) {
+              Object.assign(headers, _headers);
+            }
+            if (!headersSent) {
+              headersSent = true;
+              resolveResponse(
+                new Response(readable, {
+                  status: statusCode,
+                  headers
+                })
+              );
+            }
+            return expressRes;
+          }, "writeHead"),
+          flushHeaders: /* @__PURE__ */ __name(() => {
+          }, "flushHeaders")
+        };
+        const expressReq = {
+          ...c.req.raw,
+          url: new URL(c.req.url).pathname + new URL(c.req.url).search,
+          path: new URL(c.req.url).pathname,
+          query: Object.fromEntries(new URL(c.req.url).searchParams),
+          headers: c.req.header(),
+          method: c.req.method
+        };
+        transport.handleRequest(expressReq, expressRes).catch((err) => {
+          console.error("MCP Transport error:", err);
+          try {
+            writer.close();
+          } catch {
+          }
+        });
+        return responsePromise;
       });
-      return responsePromise;
-    });
-    this.app.delete(endpoint, async (c) => {
-      const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
-      const sessionId = c.req.header("mcp-session-id");
-      const transport = await getOrCreateTransport(sessionId, false);
-      if (!transport) {
-        if (sessionId) {
-          return c.json(
-            {
-              jsonrpc: "2.0",
-              error: {
-                code: -32e3,
-                message: "Session not found or expired"
+      this.app.delete(endpoint, async (c) => {
+        const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
+        const sessionId = c.req.header("mcp-session-id");
+        const transport = await getOrCreateTransport(sessionId, false);
+        if (!transport) {
+          if (sessionId) {
+            return c.json(
+              {
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Session not found or expired"
+                },
+                id: null
               },
-              id: null
-            },
-            404
-          );
-        } else {
-          return c.json(
-            {
-              jsonrpc: "2.0",
-              error: {
-                code: -32e3,
-                message: "Bad Request: Mcp-Session-Id header is required"
+              404
+            );
+          } else {
+            return c.json(
+              {
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Bad Request: Mcp-Session-Id header is required"
+                },
+                id: null
               },
-              id: null
-            },
-            400
-          );
+              400
+            );
+          }
         }
-      }
-      c.req.raw.signal?.addEventListener("abort", () => {
-        transport.close();
+        c.req.raw.signal?.addEventListener("abort", () => {
+          transport.close();
+        });
+        await this.waitForRequestComplete(transport, expressReq, expressRes);
+        const response = getResponse();
+        if (response) {
+          return response;
+        }
+        return c.text("", 200);
       });
-      await this.waitForRequestComplete(transport, expressReq, expressRes);
-      const response = getResponse();
-      if (response) {
-        return response;
-      }
-      return c.text("", 200);
-    });
+    }, "mountEndpoint");
+    mountEndpoint("/mcp");
+    mountEndpoint("/sse");
     this.mcpMounted = true;
-    console.log(`[MCP] Server mounted at ${endpoint}`);
+    console.log(`[MCP] Server mounted at /mcp and /sse`);
   }
   /**
    * Start the Hono server with MCP endpoints
@@ -2181,7 +2203,7 @@ if (container && Component) {
    * the inspector UI (if available), and starting the server to listen
    * for incoming connections. This is the main entry point for running the server.
    *
-   * The server will be accessible at the specified port with MCP endpoints at /mcp
+   * The server will be accessible at the specified port with MCP endpoints at /mcp and /sse
    * and inspector UI at /inspector (if the inspector package is installed).
    *
    * @param port - Port number to listen on (defaults to 3001 if not specified)
@@ -2191,7 +2213,7 @@ if (container && Component) {
    * ```typescript
    * await server.listen(8080)
    * // Server now running at http://localhost:8080 (or configured host)
-   * // MCP endpoints: http://localhost:8080/mcp
+   * // MCP endpoints: http://localhost:8080/mcp and http://localhost:8080/sse
    * // Inspector UI: http://localhost:8080/inspector
    * ```
    */
@@ -2295,7 +2317,7 @@ if (container && Component) {
             `[SERVER] Listening on http://${this.serverHost}:${this.serverPort}`
           );
           console.log(
-            `[MCP] Endpoints: http://${this.serverHost}:${this.serverPort}/mcp`
+            `[MCP] Endpoints: http://${this.serverHost}:${this.serverPort}/mcp and http://${this.serverHost}:${this.serverPort}/sse`
           );
         }
       );
@@ -2581,7 +2603,7 @@ if (container && Component) {
    * @example
    * If @mcp-use/inspector is installed:
    * - Inspector UI available at http://localhost:PORT/inspector
-   * - Automatically connects to http://localhost:PORT/mcp
+   * - Automatically connects to http://localhost:PORT/mcp (or /sse)
    *
    * If not installed:
    * - Server continues to function normally
@@ -2931,7 +2953,9 @@ function createMCPServer(name, config = {}) {
     version: config.version || "1.0.0",
     description: config.description,
     host: config.host,
-    baseUrl: config.baseUrl
+    baseUrl: config.baseUrl,
+    allowedOrigins: config.allowedOrigins,
+    sessionIdleTimeoutMs: config.sessionIdleTimeoutMs
   });
   return instance;
 }