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

package/src/client.test.ts

@@ -8,7 +8,7 @@ import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { z } from 'zod';
 
-import { MastraMCPClient } from './client.js';
+import { InternalMastraMCPClient } from './client.js';
 
 async function setupTestServer(withSessionManagement: boolean) {
   const httpServer: HttpServer = createServer();
@@ -62,12 +62,12 @@ describe('MastraMCPClient with Streamable HTTP', () => {
     serverTransport: StreamableHTTPServerTransport;
     baseUrl: URL;
   };
-  let client: MastraMCPClient;
+  let client: InternalMastraMCPClient;
 
   describe('Stateless Mode', () => {
     beforeEach(async () => {
       testServer = await setupTestServer(false);
-      client = new MastraMCPClient({
+      client = new InternalMastraMCPClient({
         name: 'test-stateless-client',
         server: {
           url: testServer.baseUrl,
@@ -99,7 +99,7 @@ describe('MastraMCPClient with Streamable HTTP', () => {
   describe('Stateful Mode', () => {
     beforeEach(async () => {
       testServer = await setupTestServer(true);
-      client = new MastraMCPClient({
+      client = new InternalMastraMCPClient({
         name: 'test-stateful-client',
         server: {
           url: testServer.baseUrl,

package/src/client.ts

@@ -1,6 +1,6 @@
 import { MastraBase } from '@mastra/core/base';
 import { createTool } from '@mastra/core/tools';
-import { isZodType, resolveSerializedZodOutput } 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 type { SSEClientTransportOptions } from '@modelcontextprotocol/sdk/client/sse.js';
@@ -14,9 +14,9 @@ import type { ClientCapabilities, LoggingLevel } from '@modelcontextprotocol/sdk
 import { CallToolResultSchema, ListResourcesResultSchema } from '@modelcontextprotocol/sdk/types.js';
 
 import { asyncExitHook, gracefulExit } from 'exit-hook';
-import jsonSchemaToZod from 'json-schema-to-zod';
-import type { JsonSchema } from 'json-schema-to-zod';
 import { z } from 'zod';
+import { jsonSchemaObjectToZodRawShape } from 'zod-from-json-schema';
+import type { JSONSchema } from 'zod-from-json-schema';
 
 // Re-export MCP SDK LoggingLevel for convenience
 export type { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
@@ -323,11 +323,35 @@ export class InternalMastraMCPClient extends MastraBase {
   }
 
   private convertInputSchema(
-    inputSchema: Awaited<ReturnType<Client['listTools']>>['tools'][0]['inputSchema'] | JsonSchema,
+    inputSchema: Awaited<ReturnType<Client['listTools']>>['tools'][0]['inputSchema'] | JSONSchema,
   ): z.ZodType {
-    return isZodType(inputSchema)
-      ? inputSchema
-      : resolveSerializedZodOutput(jsonSchemaToZod(inputSchema as JsonSchema));
+    if (isZodType(inputSchema)) {
+      return inputSchema;
+    }
+
+    try {
+      // Assuming inputSchema is a JSONSchema object type for tool inputs
+      const rawShape = jsonSchemaObjectToZodRawShape(inputSchema as JSONSchema);
+      return z.object(rawShape); // Wrap the raw shape to return a ZodType (object)
+    } catch (error: unknown) {
+      let errorDetails: string | undefined;
+      if (error instanceof Error) {
+        errorDetails = error.stack;
+      } else {
+        // Attempt to stringify, fallback to String()
+        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() {
@@ -336,38 +360,45 @@ export class InternalMastraMCPClient extends MastraBase {
     const toolsRes: Record<string, any> = {};
     tools.forEach(tool => {
       this.log('debug', `Processing tool: ${tool.name}`);
+      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;
+            }
+          },
+        });
 
-      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: unknown) {
+        // Catch errors during tool creation itself (e.g., if createTool has issues)
+        this.log('error', `Failed to create Mastra tool wrapper for MCP tool: ${tool.name}`, {
+          error: toolCreationError instanceof Error ? toolCreationError.stack : String(toolCreationError),
+          mcpToolDefinition: tool,
+        });
       }
     });
 

package/src/configuration.test.ts

@@ -1,6 +1,8 @@
 import { spawn } from 'child_process';
 import path from 'path';
 import { describe, it, expect, beforeEach, afterEach, afterAll, beforeAll, vi } from 'vitest';
+import { allTools, mcpServerName } from './__fixtures__/fire-crawl-complex-schema';
+import type { LogHandler } from './client';
 import { MCPClient } from './configuration';
 
 vi.setConfig({ testTimeout: 80000, hookTimeout: 80000 });
@@ -357,4 +359,39 @@ describe('MCPClient', () => {
       await mixedConfig.disconnect();
     });
   });
+
+  describe('Schema Handling', () => {
+    let complexClient: MCPClient;
+    let mockLogHandler: LogHandler & ReturnType<typeof vi.fn>;
+
+    beforeEach(async () => {
+      mockLogHandler = vi.fn();
+
+      complexClient = new MCPClient({
+        id: 'complex-schema-test-client-log-handler-firecrawl',
+        servers: {
+          'firecrawl-mcp': {
+            command: 'npx',
+            args: ['-y', 'tsx', path.join(__dirname, '__fixtures__/fire-crawl-complex-schema.ts')],
+            logger: mockLogHandler,
+          },
+        },
+      });
+    });
+
+    afterEach(async () => {
+      mockLogHandler.mockClear();
+      await complexClient?.disconnect().catch(() => {});
+    });
+
+    it('should process tools from firecrawl-mcp without crashing', async () => {
+      const tools = await complexClient.getTools();
+
+      Object.keys(allTools).forEach(toolName => {
+        expect(tools).toHaveProperty(`${mcpServerName.replace(`-fixture`, ``)}_${toolName}`);
+      });
+
+      expect(mockLogHandler.mock.calls.length).toBeGreaterThan(0);
+    });
+  });
 });

package/src/server.test.ts

@@ -1,6 +1,9 @@
 import http from 'node:http';
 import path from 'path';
+import type { ServerType } from '@hono/node-server';
+import { serve } from '@hono/node-server';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { Hono } from 'hono';
 import { describe, it, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
 import { weatherTool } from './__fixtures__/tools';
 import { MCPClient } from './configuration';
@@ -13,34 +16,34 @@ let httpServer: http.Server;
 vi.setConfig({ testTimeout: 20000, hookTimeout: 20000 });
 
 describe('MCPServer', () => {
-  beforeAll(async () => {
-    server = new MCPServer({
-      name: 'Test MCP Server',
-      version: '0.1.0',
-      tools: { weatherTool },
-    });
+  describe('MCPServer SSE transport', () => {
+    let sseRes: Response | undefined;
+    let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
 
-    httpServer = http.createServer(async (req, res) => {
-      const url = new URL(req.url || '', `http://localhost:${PORT}`);
-      await server.startSSE({
-        url,
-        ssePath: '/sse',
-        messagePath: '/message',
-        req,
-        res,
+    beforeAll(async () => {
+      server = new MCPServer({
+        name: 'Test MCP Server',
+        version: '0.1.0',
+        tools: { weatherTool },
       });
-    });
 
-    await new Promise<void>(resolve => httpServer.listen(PORT, () => resolve()));
-  });
+      httpServer = http.createServer(async (req, res) => {
+        const url = new URL(req.url || '', `http://localhost:${PORT}`);
+        await server.startSSE({
+          url,
+          ssePath: '/sse',
+          messagePath: '/message',
+          req,
+          res,
+        });
+      });
 
-  afterAll(async () => {
-    await new Promise<void>(resolve => httpServer.close(() => resolve()));
-  });
+      await new Promise<void>(resolve => httpServer.listen(PORT, () => resolve()));
+    });
 
-  describe('MCPServer SSE transport', () => {
-    let sseRes: Response | undefined;
-    let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
+    afterAll(async () => {
+      await new Promise<void>(resolve => httpServer.close(() => resolve()));
+    });
 
     afterEach(async () => {
       if (reader) {
@@ -111,4 +114,161 @@ describe('MCPServer', () => {
       await existingConfig.disconnect();
     });
   });
+  describe('MCPServer HTTP Transport', () => {
+    let server: MCPServer;
+    let client: MCPClient;
+    const PORT = 9200 + Math.floor(Math.random() * 1000);
+
+    beforeAll(async () => {
+      server = new MCPServer({
+        name: 'Test MCP Server',
+        version: '0.1.0',
+        tools: { weatherTool },
+      });
+
+      httpServer = http.createServer(async (req: http.IncomingMessage, res: http.ServerResponse) => {
+        const url = new URL(req.url || '', `http://localhost:${PORT}`);
+        await server.startHTTP({
+          url,
+          httpPath: '/http',
+          req,
+          res,
+          options: {
+            sessionIdGenerator: undefined,
+            enableJsonResponse: true,
+          },
+        });
+      });
+
+      await new Promise<void>(resolve => httpServer.listen(PORT, () => resolve()));
+
+      client = new MCPClient({
+        servers: {
+          local: {
+            url: new URL(`http://localhost:${PORT}/http`),
+          },
+        },
+      });
+    });
+
+    afterAll(async () => {
+      httpServer.closeAllConnections?.();
+      await new Promise<void>(resolve =>
+        httpServer.close(() => {
+          resolve();
+        }),
+      );
+      await server.close();
+    });
+
+    it('should return 404 for wrong path', async () => {
+      const res = await fetch(`http://localhost:${PORT}/wrong`);
+      expect(res.status).toBe(404);
+    });
+
+    it('should respond to HTTP request using client', async () => {
+      const tools = await client.getTools();
+      const tool = tools['local_weatherTool'];
+      expect(tool).toBeDefined();
+
+      // Call the tool
+      const result = await tool.execute({ context: { location: 'Austin' } });
+
+      // Check the result
+      expect(result).toBeDefined();
+      expect(result.content).toBeInstanceOf(Array);
+      expect(result.content.length).toBeGreaterThan(0);
+
+      const toolOutput = result.content[0];
+      expect(toolOutput.type).toBe('text');
+      const toolResult = JSON.parse(toolOutput.text);
+      expect(toolResult.location).toEqual('Austin');
+      expect(toolResult).toHaveProperty('temperature');
+      expect(toolResult).toHaveProperty('feelsLike');
+      expect(toolResult).toHaveProperty('humidity');
+      expect(toolResult).toHaveProperty('conditions');
+      expect(toolResult).toHaveProperty('windSpeed');
+      expect(toolResult).toHaveProperty('windGust');
+    });
+  });
+
+  describe('MCPServer Hono SSE Transport', () => {
+    let server: MCPServer;
+    let hono: Hono;
+    let honoServer: ServerType;
+    let client: MCPClient;
+    const PORT = 9300 + Math.floor(Math.random() * 1000);
+
+    beforeAll(async () => {
+      server = new MCPServer({
+        name: 'Test MCP Server',
+        version: '0.1.0',
+        tools: { weatherTool },
+      });
+
+      hono = new Hono();
+
+      hono.get('/sse', async c => {
+        const url = new URL(c.req.url, `http://localhost:${PORT}`);
+        return await server.startHonoSSE({
+          url,
+          ssePath: '/sse',
+          messagePath: '/message',
+          context: c,
+        });
+      });
+
+      hono.post('/message', async c => {
+        // Use MCPServer's startHonoSSE to handle message endpoint
+        const url = new URL(c.req.url, `http://localhost:${PORT}`);
+        return await server.startHonoSSE({
+          url,
+          ssePath: '/sse',
+          messagePath: '/message',
+          context: c,
+        });
+      });
+
+      honoServer = serve({ fetch: hono.fetch, port: PORT });
+
+      // Initialize MCPClient with SSE endpoint
+      client = new MCPClient({
+        servers: {
+          local: {
+            url: new URL(`http://localhost:${PORT}/sse`),
+          },
+        },
+      });
+    });
+
+    afterAll(async () => {
+      honoServer.close();
+      await server.close();
+    });
+
+    it('should respond to SSE connection and tool call', async () => {
+      // Get tools from the client
+      const tools = await client.getTools();
+      const tool = tools['local_weatherTool'];
+      expect(tool).toBeDefined();
+
+      // Call the tool using the MCPClient (SSE transport)
+      const result = await tool.execute({ context: { location: 'Austin' } });
+
+      expect(result).toBeDefined();
+      expect(result.content).toBeInstanceOf(Array);
+      expect(result.content.length).toBeGreaterThan(0);
+
+      const toolOutput = result.content[0];
+      expect(toolOutput.type).toBe('text');
+      const toolResult = JSON.parse(toolOutput.text);
+      expect(toolResult.location).toEqual('Austin');
+      expect(toolResult).toHaveProperty('temperature');
+      expect(toolResult).toHaveProperty('feelsLike');
+      expect(toolResult).toHaveProperty('humidity');
+      expect(toolResult).toHaveProperty('conditions');
+      expect(toolResult).toHaveProperty('windSpeed');
+      expect(toolResult).toHaveProperty('windGust');
+    });
+  });
 });

package/src/server.ts

@@ -4,7 +4,7 @@ import type { InternalCoreTool } from '@mastra/core';
 import { makeCoreTool } from '@mastra/core';
 import type { ToolsInput } from '@mastra/core/agent';
 import { MCPServerBase } from '@mastra/core/mcp';
-import type { MCPServerSSEOptions, ConvertedTool } from '@mastra/core/mcp';
+import type { MCPServerSSEOptions, ConvertedTool, MCPServerHonoSSEOptions } from '@mastra/core/mcp';
 import { RuntimeContext } from '@mastra/core/runtime-context';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
@@ -12,12 +12,16 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import type { StreamableHTTPServerTransportOptions } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import type { SSEStreamingApi } from 'hono/streaming';
+import { streamSSE } from 'hono/streaming';
+import { SSETransport } from 'hono-mcp-server-sse-transport';
 import { z } from 'zod';
 
 export class MCPServer extends MCPServerBase {
   private server: Server;
   private stdioTransport?: StdioServerTransport;
   private sseTransport?: SSEServerTransport;
+  private sseHonoTransports: Map<string, SSETransport>;
   private streamableHTTPTransport?: StreamableHTTPServerTransport;
   private listToolsHandlerIsRegistered: boolean = false;
   private callToolHandlerIsRegistered: boolean = false;
@@ -36,6 +40,13 @@ export class MCPServer extends MCPServerBase {
     return this.sseTransport;
   }
 
+  /**
+   * Get the current SSE Hono transport.
+   */
+  public getSseHonoTransport(sessionId: string): SSETransport | undefined {
+    return this.sseHonoTransports.get(sessionId);
+  }
+
   /**
    * Get the current streamable HTTP transport.
    */
@@ -58,6 +69,7 @@ export class MCPServer extends MCPServerBase {
       `Initialized MCPServer '${name}' v${version} with tools: ${Object.keys(this.convertedTools).join(', ')}`,
     );
 
+    this.sseHonoTransports = new Map();
     this.registerListToolsHandler();
     this.registerCallToolHandler();
   }
@@ -242,6 +254,44 @@ export class MCPServer extends MCPServerBase {
     }
   }
 
+  /**
+   * 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
+   */
+  public async startHonoSSE({ url, ssePath, messagePath, context }: MCPServerHonoSSEOptions) {
+    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.
@@ -299,15 +349,6 @@ export class MCPServer extends MCPServerBase {
     }
   }
 
-  public async handlePostMessage(req: http.IncomingMessage, res: http.ServerResponse<http.IncomingMessage>) {
-    if (!this.sseTransport) {
-      res.writeHead(503);
-      res.end('SSE connection not established');
-      return;
-    }
-    await this.sseTransport.handlePostMessage(req, res);
-  }
-
   public async connectSSE({
     messagePath,
     res,
@@ -329,6 +370,35 @@ export class MCPServer extends MCPServerBase {
     });
   }
 
+  public async connectHonoSSE({ messagePath, stream }: { messagePath: string; stream: SSEStreamingApi }) {
+    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) {
+      // This will keep the connection alive
+      // You can also await for a promise that never resolves
+      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(60_000);
+    }
+  }
+
   /**
    * Close the MCP server and all its connections
    */
@@ -344,6 +414,12 @@ export class MCPServer extends MCPServerBase {
         await this.sseTransport.close?.();
         this.sseTransport = undefined;
       }
+      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 = undefined;