@mastra/mcp 0.5.0-alpha.2 → 0.5.0-alpha.4

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/mcp@0.5.0-alpha.2 build /home/runner/work/mastra/mastra/packages/mcp
+> @mastra/mcp@0.5.0-alpha.4 build /home/runner/work/mastra/mastra/packages/mcp
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.4.0
 TSC Build start
-TSC ⚡️ Build success in 18478ms
+TSC ⚡️ Build success in 17734ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/mcp/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/packages/mcp/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 12208ms
+DTS ⚡️ Build success in 13432ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 25.82 KB
-ESM ⚡️ Build success in 1060ms
-CJS dist/index.cjs 26.18 KB
-CJS ⚡️ Build success in 1060ms
+CJS dist/index.cjs 32.44 KB
+CJS ⚡️ Build success in 1027ms
+ESM dist/index.js 32.14 KB
+ESM ⚡️ Build success in 1029ms

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @mastra/mcp
 
+## 0.5.0-alpha.4
+
+### Patch Changes
+
+- 396be50: updated mcp server routes for MCP SSE for use with hono server
+- da082f8: Switch from serializing json schema string as a function to a library that creates a zod object in memory from the json schema. This reduces the errors we were seeing from zod schema code that could not be serialized.
+- Updated dependencies [396be50]
+- Updated dependencies [c3bd795]
+- Updated dependencies [da082f8]
+- Updated dependencies [a5810ce]
+  - @mastra/core@0.9.4-alpha.3
+
+## 0.5.0-alpha.3
+
+### Patch Changes
+
+- bb1e2c8: Make sure mcp handlers can only be registered once
+
 ## 0.5.0-alpha.2
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -4,11 +4,14 @@ import type * as http from 'node:http';
 import { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
 import { MastraBase } from '@mastra/core/base';
 import { MCPServerBase } from '@mastra/core/mcp';
+import type { MCPServerHonoSSEOptions } from '@mastra/core/mcp';
 import type { MCPServerSSEOptions } from '@mastra/core/mcp';
 import type { Protocol } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import type { SSEStreamingApi } from 'hono/streaming';
+import { SSETransport } from 'hono-mcp-server-sse-transport';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import type { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -18,6 +21,8 @@ import { ToolExecutionContext } from '@mastra/core';
 import type { ToolsInput } from '@mastra/core/agent';
 import { z } from 'zod';
 
+export declare const allTools: ToolsInput;
+
 declare type BaseServerOptions = {
     logger?: LogHandler;
     timeout?: number;
@@ -188,7 +193,10 @@ declare class MCPServer extends MCPServerBase {
     private server;
     private stdioTransport?;
     private sseTransport?;
+    private sseHonoTransports;
     private streamableHTTPTransport?;
+    private listToolsHandlerIsRegistered;
+    private callToolHandlerIsRegistered;
     /**
      * Get the current stdio transport.
      */
@@ -197,6 +205,10 @@ declare class MCPServer extends MCPServerBase {
      * Get the current SSE transport.
      */
     getSseTransport(): SSEServerTransport | undefined;
+    /**
+     * Get the current SSE Hono transport.
+     */
+    getSseHonoTransport(sessionId: string): SSETransport | undefined;
     /**
      * Get the current streamable HTTP transport.
      */
@@ -241,6 +253,16 @@ declare class MCPServer extends MCPServerBase {
      * @param res HTTP response (must support .write/.end)
      */
     startSSE({ url, ssePath, messagePath, req, res }: MCPServerSSEOptions): Promise<void>;
+    /**
+     * Handles MCP-over-SSE protocol for user-provided HTTP servers.
+     * Call this from your HTTP server for both the SSE and message endpoints.
+     *
+     * @param url Parsed URL of the incoming request
+     * @param ssePath Path for establishing the SSE connection (e.g. '/sse')
+     * @param messagePath Path for POSTing client messages (e.g. '/message')
+     * @param context Incoming Hono context
+     */
+    startHonoSSE({ url, ssePath, messagePath, context }: MCPServerHonoSSEOptions): Promise<Response>;
     /**
      * Handles MCP-over-StreamableHTTP protocol for user-provided HTTP servers.
      * Call this from your HTTP server for the streamable HTTP endpoint.
@@ -258,11 +280,14 @@ declare class MCPServer extends MCPServerBase {
         res: http.ServerResponse<http.IncomingMessage>;
         options?: StreamableHTTPServerTransportOptions;
     }): Promise<void>;
-    handlePostMessage(req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage>): Promise<void>;
     connectSSE({ messagePath, res, }: {
         messagePath: string;
         res: http.ServerResponse<http.IncomingMessage>;
     }): Promise<void>;
+    connectHonoSSE({ messagePath, stream }: {
+        messagePath: string;
+        stream: SSEStreamingApi;
+    }): Promise<void>;
     /**
      * Close the MCP server and all its connections
      */
@@ -271,6 +296,8 @@ declare class MCPServer extends MCPServerBase {
 export { MCPServer }
 export { MCPServer as MCPServer_alias_1 }
 
+export declare const mcpServerName = "firecrawl-mcp-fixture";
+
 export declare const server: Server<{
     method: string;
     params?: {

package/dist/_tsup-dts-rollup.d.ts

@@ -4,11 +4,14 @@ import type * as http from 'node:http';
 import { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
 import { MastraBase } from '@mastra/core/base';
 import { MCPServerBase } from '@mastra/core/mcp';
+import type { MCPServerHonoSSEOptions } from '@mastra/core/mcp';
 import type { MCPServerSSEOptions } from '@mastra/core/mcp';
 import type { Protocol } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import type { SSEStreamingApi } from 'hono/streaming';
+import { SSETransport } from 'hono-mcp-server-sse-transport';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import type { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
@@ -18,6 +21,8 @@ import { ToolExecutionContext } from '@mastra/core';
 import type { ToolsInput } from '@mastra/core/agent';
 import { z } from 'zod';
 
+export declare const allTools: ToolsInput;
+
 declare type BaseServerOptions = {
     logger?: LogHandler;
     timeout?: number;
@@ -188,7 +193,10 @@ declare class MCPServer extends MCPServerBase {
     private server;
     private stdioTransport?;
     private sseTransport?;
+    private sseHonoTransports;
     private streamableHTTPTransport?;
+    private listToolsHandlerIsRegistered;
+    private callToolHandlerIsRegistered;
     /**
      * Get the current stdio transport.
      */
@@ -197,6 +205,10 @@ declare class MCPServer extends MCPServerBase {
      * Get the current SSE transport.
      */
     getSseTransport(): SSEServerTransport | undefined;
+    /**
+     * Get the current SSE Hono transport.
+     */
+    getSseHonoTransport(sessionId: string): SSETransport | undefined;
     /**
      * Get the current streamable HTTP transport.
      */
@@ -241,6 +253,16 @@ declare class MCPServer extends MCPServerBase {
      * @param res HTTP response (must support .write/.end)
      */
     startSSE({ url, ssePath, messagePath, req, res }: MCPServerSSEOptions): Promise<void>;
+    /**
+     * Handles MCP-over-SSE protocol for user-provided HTTP servers.
+     * Call this from your HTTP server for both the SSE and message endpoints.
+     *
+     * @param url Parsed URL of the incoming request
+     * @param ssePath Path for establishing the SSE connection (e.g. '/sse')
+     * @param messagePath Path for POSTing client messages (e.g. '/message')
+     * @param context Incoming Hono context
+     */
+    startHonoSSE({ url, ssePath, messagePath, context }: MCPServerHonoSSEOptions): Promise<Response>;
     /**
      * Handles MCP-over-StreamableHTTP protocol for user-provided HTTP servers.
      * Call this from your HTTP server for the streamable HTTP endpoint.
@@ -258,11 +280,14 @@ declare class MCPServer extends MCPServerBase {
         res: http.ServerResponse<http.IncomingMessage>;
         options?: StreamableHTTPServerTransportOptions;
     }): Promise<void>;
-    handlePostMessage(req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage>): Promise<void>;
     connectSSE({ messagePath, res, }: {
         messagePath: string;
         res: http.ServerResponse<http.IncomingMessage>;
     }): Promise<void>;
+    connectHonoSSE({ messagePath, stream }: {
+        messagePath: string;
+        stream: SSEStreamingApi;
+    }): Promise<void>;
     /**
      * Close the MCP server and all its connections
      */
@@ -271,6 +296,8 @@ declare class MCPServer extends MCPServerBase {
 export { MCPServer }
 export { MCPServer as MCPServer_alias_1 }
 
+export declare const mcpServerName = "firecrawl-mcp-fixture";
+
 export declare const server: Server<{
     method: string;
     params?: {

package/dist/index.cjs

@@ -10,11 +10,11 @@ var streamableHttp_js$1 = require('@modelcontextprotocol/sdk/client/streamableHt
 var protocol_js = require('@modelcontextprotocol/sdk/shared/protocol.js');
 var types_js = require('@modelcontextprotocol/sdk/types.js');
 var exitHook = require('exit-hook');
-var jsonSchemaToZod = require('json-schema-to-zod');
 var zod = require('zod');
+var zodFromJsonSchema = require('zod-from-json-schema');
 var equal = require('fast-deep-equal');
 var uuid = require('uuid');
-var crypto = require('crypto');
+var crypto$1 = require('crypto');
 var core = require('@mastra/core');
 var mcp = require('@mastra/core/mcp');
 var runtimeContext = require('@mastra/core/runtime-context');
@@ -22,10 +22,10 @@ var index_js = require('@modelcontextprotocol/sdk/server/index.js');
 var sse_js = require('@modelcontextprotocol/sdk/server/sse.js');
 var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+var streaming = require('hono/streaming');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var jsonSchemaToZod__default = /*#__PURE__*/_interopDefault(jsonSchemaToZod);
 var equal__default = /*#__PURE__*/_interopDefault(equal);
 
 // src/client.ts
@@ -238,7 +238,29 @@ var InternalMastraMCPClient = class extends base.MastraBase {
     });
   }
   convertInputSchema(inputSchema) {
-    return utils.isZodType(inputSchema) ? inputSchema : utils.resolveSerializedZodOutput(jsonSchemaToZod__default.default(inputSchema));
+    if (utils.isZodType(inputSchema)) {
+      return inputSchema;
+    }
+    try {
+      const rawShape = zodFromJsonSchema.jsonSchemaObjectToZodRawShape(inputSchema);
+      return zod.z.object(rawShape);
+    } catch (error) {
+      let errorDetails;
+      if (error instanceof Error) {
+        errorDetails = error.stack;
+      } else {
+        try {
+          errorDetails = JSON.stringify(error);
+        } catch {
+          errorDetails = String(error);
+        }
+      }
+      this.log("error", "Failed to convert JSON schema to Zod schema using zodFromJsonSchema", {
+        error: errorDetails,
+        originalJsonSchema: inputSchema
+      });
+      throw new Error(errorDetails);
+    }
   }
   async tools() {
     this.log("debug", `Requesting tools from MCP server`);
@@ -246,36 +268,43 @@ var InternalMastraMCPClient = class extends base.MastraBase {
     const toolsRes = {};
     tools$1.forEach((tool) => {
       this.log("debug", `Processing tool: ${tool.name}`);
-      const mastraTool = tools.createTool({
-        id: `${this.name}_${tool.name}`,
-        description: tool.description || "",
-        inputSchema: this.convertInputSchema(tool.inputSchema),
-        execute: async ({ context }) => {
-          try {
-            this.log("debug", `Executing tool: ${tool.name}`, { toolArgs: context });
-            const res = await this.client.callTool(
-              {
-                name: tool.name,
-                arguments: context
-              },
-              types_js.CallToolResultSchema,
-              {
-                timeout: this.timeout
-              }
-            );
-            this.log("debug", `Tool executed successfully: ${tool.name}`);
-            return res;
-          } catch (e) {
-            this.log("error", `Error calling tool: ${tool.name}`, {
-              error: e instanceof Error ? e.stack : JSON.stringify(e, null, 2),
-              toolArgs: context
-            });
-            throw e;
+      try {
+        const mastraTool = tools.createTool({
+          id: `${this.name}_${tool.name}`,
+          description: tool.description || "",
+          inputSchema: this.convertInputSchema(tool.inputSchema),
+          execute: async ({ context }) => {
+            try {
+              this.log("debug", `Executing tool: ${tool.name}`, { toolArgs: context });
+              const res = await this.client.callTool(
+                {
+                  name: tool.name,
+                  arguments: context
+                },
+                types_js.CallToolResultSchema,
+                {
+                  timeout: this.timeout
+                }
+              );
+              this.log("debug", `Tool executed successfully: ${tool.name}`);
+              return res;
+            } catch (e) {
+              this.log("error", `Error calling tool: ${tool.name}`, {
+                error: e instanceof Error ? e.stack : JSON.stringify(e, null, 2),
+                toolArgs: context
+              });
+              throw e;
+            }
           }
+        });
+        if (tool.name) {
+          toolsRes[tool.name] = mastraTool;
         }
-      });
-      if (tool.name) {
-        toolsRes[tool.name] = mastraTool;
+      } catch (toolCreationError) {
+        this.log("error", `Failed to create Mastra tool wrapper for MCP tool: ${tool.name}`, {
+          error: toolCreationError instanceof Error ? toolCreationError.stack : String(toolCreationError),
+          mcpToolDefinition: tool
+        });
       }
     });
     return toolsRes;
@@ -477,11 +506,98 @@ var MCPConfiguration = class extends MCPClient {
     );
   }
 };
+var MAXIMUM_MESSAGE_SIZE = 4 * 1024 * 1024;
+var SSETransport = class {
+  messageUrl;
+  stream;
+  _sessionId;
+  onclose;
+  onerror;
+  onmessage;
+  /**
+   * Creates a new SSETransport, which will direct the MPC client to POST messages to messageUrl
+   */
+  constructor(messageUrl, stream) {
+    this.messageUrl = messageUrl;
+    this.stream = stream;
+    this._sessionId = crypto.randomUUID();
+    this.stream.onAbort(() => {
+      void this.close();
+    });
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  // start() is automatically called after MCP Server connects to the transport
+  async start() {
+    if (this.stream == null) {
+      throw new Error("Stream not initialized");
+    }
+    if (this.stream.closed) {
+      throw new Error("SSE transport already closed!");
+    }
+    await this.stream.writeSSE({
+      event: "endpoint",
+      data: `${this.messageUrl}?sessionId=${this.sessionId}`
+    });
+  }
+  async handlePostMessage(context) {
+    if (this.stream?.closed == null) {
+      return context.text("SSE connection not established", 500);
+    }
+    try {
+      const contentType = context.req.header("content-type") || "";
+      if (!contentType.includes("application/json")) {
+        throw new Error(`Unsupported content-type: ${contentType}`);
+      }
+      const contentLength = Number.parseInt(context.req.header("content-length") || "0", 10);
+      if (contentLength > MAXIMUM_MESSAGE_SIZE) {
+        throw new Error(`Request body too large: ${contentLength} bytes`);
+      }
+      const body = await context.req.json();
+      await this.handleMessage(body);
+      return context.text("Accepted", 202);
+    } catch (error) {
+      this.onerror?.(error);
+      return context.text("Error", 400);
+    }
+  }
+  /**
+   * Handle a client message, regardless of how it arrived. This can be used to inform the server of messages that arrive via a means different than HTTP POST.
+   */
+  async handleMessage(message) {
+    let parsedMessage;
+    try {
+      parsedMessage = types_js.JSONRPCMessageSchema.parse(message);
+    } catch (error) {
+      this.onerror?.(error);
+      throw error;
+    }
+    this.onmessage?.(parsedMessage);
+  }
+  async close() {
+    if (this.stream?.closed) {
+      this.stream.abort();
+    }
+  }
+  async send(message) {
+    if (this.stream?.closed) {
+      throw new Error("Not connected");
+    }
+    await this.stream.writeSSE({
+      event: "message",
+      data: JSON.stringify(message)
+    });
+  }
+};
 var MCPServer = class extends mcp.MCPServerBase {
   server;
   stdioTransport;
   sseTransport;
+  sseHonoTransports;
   streamableHTTPTransport;
+  listToolsHandlerIsRegistered = false;
+  callToolHandlerIsRegistered = false;
   /**
    * Get the current stdio transport.
    */
@@ -494,6 +610,12 @@ var MCPServer = class extends mcp.MCPServerBase {
   getSseTransport() {
     return this.sseTransport;
   }
+  /**
+   * Get the current SSE Hono transport.
+   */
+  getSseHonoTransport(sessionId) {
+    return this.sseHonoTransports.get(sessionId);
+  }
   /**
    * Get the current streamable HTTP transport.
    */
@@ -512,6 +634,7 @@ var MCPServer = class extends mcp.MCPServerBase {
     this.logger.info(
       `Initialized MCPServer '${name}' v${version} with tools: ${Object.keys(this.convertedTools).join(", ")}`
     );
+    this.sseHonoTransports = /* @__PURE__ */ new Map();
     this.registerListToolsHandler();
     this.registerCallToolHandler();
   }
@@ -555,6 +678,10 @@ var MCPServer = class extends mcp.MCPServerBase {
    * Register the ListTools handler for listing all available tools.
    */
   registerListToolsHandler() {
+    if (this.listToolsHandlerIsRegistered) {
+      return;
+    }
+    this.listToolsHandlerIsRegistered = true;
     this.server.setRequestHandler(types_js.ListToolsRequestSchema, async () => {
       this.logger.debug("Handling ListTools request");
       return {
@@ -570,6 +697,10 @@ var MCPServer = class extends mcp.MCPServerBase {
    * Register the CallTool handler for executing a tool by name.
    */
   registerCallToolHandler() {
+    if (this.callToolHandlerIsRegistered) {
+      return;
+    }
+    this.callToolHandlerIsRegistered = true;
     this.server.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
       const startTime = Date.now();
       try {
@@ -675,6 +806,43 @@ var MCPServer = class extends mcp.MCPServerBase {
       res.end();
     }
   }
+  /**
+   * Handles MCP-over-SSE protocol for user-provided HTTP servers.
+   * Call this from your HTTP server for both the SSE and message endpoints.
+   *
+   * @param url Parsed URL of the incoming request
+   * @param ssePath Path for establishing the SSE connection (e.g. '/sse')
+   * @param messagePath Path for POSTing client messages (e.g. '/message')
+   * @param context Incoming Hono context
+   */
+  async startHonoSSE({ url, ssePath, messagePath, context }) {
+    if (url.pathname === ssePath) {
+      return streaming.streamSSE(context, async (stream) => {
+        await this.connectHonoSSE({
+          messagePath,
+          stream
+        });
+      });
+    } else if (url.pathname === messagePath) {
+      this.logger.debug("Received message");
+      const sessionId = context.req.query("sessionId");
+      this.logger.debug("Received message for sessionId", { sessionId });
+      if (!sessionId) {
+        return context.text("No sessionId provided", 400);
+      }
+      if (!this.sseHonoTransports.has(sessionId)) {
+        return context.text(`No transport found for sessionId ${sessionId}`, 400);
+      }
+      const message = await this.sseHonoTransports.get(sessionId)?.handlePostMessage(context);
+      if (!message) {
+        return context.text("Transport not found", 400);
+      }
+      return message;
+    } else {
+      this.logger.debug("Unknown path:", { path: url.pathname });
+      return context.text("Unknown path", 404);
+    }
+  }
   /**
    * Handles MCP-over-StreamableHTTP protocol for user-provided HTTP servers.
    * Call this from your HTTP server for the streamable HTTP endpoint.
@@ -690,7 +858,7 @@ var MCPServer = class extends mcp.MCPServerBase {
     httpPath,
     req,
     res,
-    options = { sessionIdGenerator: () => crypto.randomUUID() }
+    options = { sessionIdGenerator: () => crypto$1.randomUUID() }
   }) {
     if (url.pathname === httpPath) {
       this.streamableHTTPTransport = new streamableHttp_js.StreamableHTTPServerTransport(options);
@@ -722,14 +890,6 @@ var MCPServer = class extends mcp.MCPServerBase {
       res.end();
     }
   }
-  async handlePostMessage(req, res) {
-    if (!this.sseTransport) {
-      res.writeHead(503);
-      res.end("SSE connection not established");
-      return;
-    }
-    await this.sseTransport.handlePostMessage(req, res);
-  }
   async connectSSE({
     messagePath,
     res
@@ -745,10 +905,35 @@ var MCPServer = class extends mcp.MCPServerBase {
       this.sseTransport = void 0;
     });
   }
+  async connectHonoSSE({ messagePath, stream }) {
+    this.logger.debug("Received SSE connection");
+    const sseTransport = new SSETransport(messagePath, stream);
+    const sessionId = sseTransport.sessionId;
+    this.logger.debug("SSE Transport created with sessionId:", { sessionId });
+    this.sseHonoTransports.set(sessionId, sseTransport);
+    stream.onAbort(() => {
+      this.logger.debug("SSE Transport aborted with sessionId:", { sessionId });
+      this.sseHonoTransports.delete(sessionId);
+    });
+    await this.server.connect(sseTransport);
+    this.server.onclose = async () => {
+      this.logger.debug("SSE Transport closed with sessionId:", { sessionId });
+      this.sseHonoTransports.delete(sessionId);
+      await this.server.close();
+    };
+    while (true) {
+      const sessionIds = Array.from(this.sseHonoTransports.keys() || []);
+      this.logger.debug("Active Hono SSE sessions:", { sessionIds });
+      await stream.write(":keep-alive\n\n");
+      await stream.sleep(6e4);
+    }
+  }
   /**
    * Close the MCP server and all its connections
    */
   async close() {
+    this.callToolHandlerIsRegistered = false;
+    this.listToolsHandlerIsRegistered = false;
     try {
       if (this.stdioTransport) {
         await this.stdioTransport.close?.();
@@ -758,6 +943,12 @@ var MCPServer = class extends mcp.MCPServerBase {
         await this.sseTransport.close?.();
         this.sseTransport = void 0;
       }
+      if (this.sseHonoTransports) {
+        for (const transport of this.sseHonoTransports.values()) {
+          await transport.close?.();
+        }
+        this.sseHonoTransports.clear();
+      }
       if (this.streamableHTTPTransport) {
         await this.streamableHTTPTransport.close?.();
         this.streamableHTTPTransport = void 0;