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

package/dist/index.js

@@ -1,15 +1,15 @@
 import { MastraBase } from '@mastra/core/base';
 import { createTool } from '@mastra/core/tools';
-import { resolveSerializedZodOutput, isZodType } from '@mastra/core/utils';
+import { isZodType } from '@mastra/core/utils';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
-import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesResultSchema, CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesResultSchema, CallToolResultSchema, JSONRPCMessageSchema } from '@modelcontextprotocol/sdk/types.js';
 import { asyncExitHook, gracefulExit } from 'exit-hook';
-import jsonSchemaToZod from 'json-schema-to-zod';
 import { z } from 'zod';
+import { jsonSchemaObjectToZodRawShape } from 'zod-from-json-schema';
 import equal from 'fast-deep-equal';
 import { v5 } from 'uuid';
 import { randomUUID } from 'crypto';
@@ -20,6 +20,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { streamSSE } from 'hono/streaming';
 
 // src/client.ts
 function convertLogLevelToLoggerMethod(level) {
@@ -231,7 +232,29 @@ var InternalMastraMCPClient = class extends MastraBase {
     });
   }
   convertInputSchema(inputSchema) {
-    return isZodType(inputSchema) ? inputSchema : resolveSerializedZodOutput(jsonSchemaToZod(inputSchema));
+    if (isZodType(inputSchema)) {
+      return inputSchema;
+    }
+    try {
+      const rawShape = jsonSchemaObjectToZodRawShape(inputSchema);
+      return 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`);
@@ -239,36 +262,43 @@ var InternalMastraMCPClient = class extends MastraBase {
     const toolsRes = {};
     tools.forEach((tool) => {
       this.log("debug", `Processing tool: ${tool.name}`);
-      const mastraTool = 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
-              },
-              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 = 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
+                },
+                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;
@@ -470,10 +500,95 @@ 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 = 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 MCPServerBase {
   server;
   stdioTransport;
   sseTransport;
+  sseHonoTransports;
   streamableHTTPTransport;
   listToolsHandlerIsRegistered = false;
   callToolHandlerIsRegistered = false;
@@ -489,6 +604,12 @@ var MCPServer = class extends MCPServerBase {
   getSseTransport() {
     return this.sseTransport;
   }
+  /**
+   * Get the current SSE Hono transport.
+   */
+  getSseHonoTransport(sessionId) {
+    return this.sseHonoTransports.get(sessionId);
+  }
   /**
    * Get the current streamable HTTP transport.
    */
@@ -507,6 +628,7 @@ var MCPServer = class extends 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();
   }
@@ -678,6 +800,43 @@ var MCPServer = class extends 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 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.
@@ -725,14 +884,6 @@ var MCPServer = class extends 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
@@ -748,6 +899,29 @@ var MCPServer = class extends 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
    */
@@ -763,6 +937,12 @@ var MCPServer = class extends 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp",
-  "version": "0.5.0-alpha.3",
+  "version": "0.5.0-alpha.4",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -26,18 +26,22 @@
     "date-fns": "^4.1.0",
     "exit-hook": "^4.0.0",
     "fast-deep-equal": "^3.1.3",
-    "json-schema-to-zod": "^2.6.0",
+    "hono": "^4.7.4",
     "uuid": "^11.1.0",
-    "@mastra/core": "^0.9.4-alpha.2"
+    "zod-from-json-schema": "^0.0.5",
+    "@mastra/core": "^0.9.4-alpha.3"
   },
   "peerDependencies": {
     "zod": "^3.0.0"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^1.1.15",
+    "@hono/node-server": "^1.13.8",
+    "@mendable/firecrawl-js": "^1.24.0",
     "@microsoft/api-extractor": "^7.52.5",
     "@types/node": "^20.17.27",
     "eslint": "^9.23.0",
+    "hono-mcp-server-sse-transport": "0.0.6",
     "tsup": "^8.4.0",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",