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

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;