@mastra/mcp 0.10.3-alpha.0 → 0.10.4-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/mcp@0.10.3-alpha.0 build /home/runner/work/mastra/mastra/packages/mcp
+> @mastra/mcp@0.10.4-alpha.0 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.5.0
 TSC Build start
-TSC ⚡️ Build success in 21509ms
+TSC ⚡️ Build success in 20174ms
 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 23126ms
+DTS ⚡️ Build success in 20211ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 67.33 KB
-CJS ⚡️ Build success in 1667ms
-ESM dist/index.js 67.20 KB
-ESM ⚡️ Build success in 1667ms
+ESM dist/index.js 71.81 KB
+ESM ⚡️ Build success in 1802ms
+CJS dist/index.cjs 71.95 KB
+CJS ⚡️ Build success in 1784ms

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @mastra/mcp
 
+## 0.10.4-alpha.0
+
+### Patch Changes
+
+- 63f6b7d: dependencies updates:
+  - Updated dependency [`@modelcontextprotocol/sdk@^1.12.1` ↗︎](https://www.npmjs.com/package/@modelcontextprotocol/sdk/v/1.12.1) (from `^1.10.2`, in `dependencies`)
+  - Updated dependency [`hono@^4.7.11` ↗︎](https://www.npmjs.com/package/hono/v/4.7.11) (from `^4.7.4`, in `dependencies`)
+- 36f1c36: MCP Client and Server streamable http fixes
+- Updated dependencies [63f6b7d]
+- Updated dependencies [36f1c36]
+- Updated dependencies [10d352e]
+- Updated dependencies [53d3c37]
+  - @mastra/core@0.10.6-alpha.0
+
+## 0.10.3
+
+### Patch Changes
+
+- fc579cd: [MASTRA-3554] Support MCP prompts for MCPServer and MCPClient
+- Updated dependencies [d1ed912]
+- Updated dependencies [f6fd25f]
+- Updated dependencies [dffb67b]
+- Updated dependencies [f1f1f1b]
+- Updated dependencies [925ab94]
+- Updated dependencies [f9816ae]
+- Updated dependencies [82090c1]
+- Updated dependencies [1b443fd]
+- Updated dependencies [ce97900]
+- Updated dependencies [f1309d3]
+- Updated dependencies [14a2566]
+- Updated dependencies [f7f8293]
+- Updated dependencies [48eddb9]
+  - @mastra/core@0.10.4
+
 ## 0.10.3-alpha.0
 
 ### Patch Changes

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

@@ -30,7 +30,6 @@ 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';
 import type { StreamableHTTPServerTransportOptions } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { Tool } from '@mastra/core/tools';
 import { ToolExecutionContext } from '@mastra/core';
@@ -185,7 +184,7 @@ export declare class InternalMastraMCPClient extends MastraBase {
      * @param args Arguments for the prompt
      * @param version (optional) The prompt version to retrieve
      */
-    getPrompt({ name, args, version }: {
+    getPrompt({ name, args, version, }: {
         name: string;
         args?: Record<string, any>;
         version?: string;
@@ -410,7 +409,7 @@ declare class MCPServer extends MCPServerBase {
     private stdioTransport?;
     private sseTransport?;
     private sseHonoTransports;
-    private streamableHTTPTransport?;
+    private streamableHTTPTransports;
     private listToolsHandlerIsRegistered;
     private callToolHandlerIsRegistered;
     private listResourcesHandlerIsRegistered;
@@ -440,10 +439,6 @@ declare class MCPServer extends MCPServerBase {
      * Get the current SSE Hono transport.
      */
     getSseHonoTransport(sessionId: string): SSETransport | undefined;
-    /**
-     * Get the current streamable HTTP transport.
-     */
-    getStreamableHTTPTransport(): StreamableHTTPServerTransport | undefined;
     /**
      * Get the current server instance.
      */

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

@@ -30,7 +30,6 @@ 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';
 import type { StreamableHTTPServerTransportOptions } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { Tool } from '@mastra/core/tools';
 import { ToolExecutionContext } from '@mastra/core';
@@ -185,7 +184,7 @@ export declare class InternalMastraMCPClient extends MastraBase {
      * @param args Arguments for the prompt
      * @param version (optional) The prompt version to retrieve
      */
-    getPrompt({ name, args, version }: {
+    getPrompt({ name, args, version, }: {
         name: string;
         args?: Record<string, any>;
         version?: string;
@@ -410,7 +409,7 @@ declare class MCPServer extends MCPServerBase {
     private stdioTransport?;
     private sseTransport?;
     private sseHonoTransports;
-    private streamableHTTPTransport?;
+    private streamableHTTPTransports;
     private listToolsHandlerIsRegistered;
     private callToolHandlerIsRegistered;
     private listResourcesHandlerIsRegistered;
@@ -440,10 +439,6 @@ declare class MCPServer extends MCPServerBase {
      * Get the current SSE Hono transport.
      */
     getSseHonoTransport(sessionId: string): SSETransport | undefined;
-    /**
-     * Get the current streamable HTTP transport.
-     */
-    getStreamableHTTPTransport(): StreamableHTTPServerTransport | undefined;
     /**
      * Get the current server instance.
      */

package/dist/index.cjs

@@ -299,8 +299,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
         this.log("debug", "Trying Streamable HTTP transport...");
         const streamableTransport = new streamableHttp_js$1.StreamableHTTPClientTransport(url, {
           requestInit,
-          reconnectionOptions: this.serverConfig.reconnectionOptions,
-          sessionId: this.serverConfig.sessionId
+          reconnectionOptions: this.serverConfig.reconnectionOptions
         });
         await this.client.connect(streamableTransport, {
           timeout: (
@@ -331,22 +330,40 @@ var InternalMastraMCPClient = class extends base.MastraBase {
       }
     }
   }
-  isConnected = false;
+  isConnected = null;
   async connect() {
-    if (this.isConnected) return;
+    let res = () => {
+    };
+    let rej = () => {
+    };
+    if (this.isConnected === null) {
+      this.log("debug", `Creating new isConnected promise`);
+      this.isConnected = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+    } else if (await this.isConnected) {
+      this.log("debug", `MCP server already connected`);
+      return;
+    }
     const { command, url } = this.serverConfig;
     if (command) {
-      await this.connectStdio(command);
+      await this.connectStdio(command).catch((e) => {
+        rej(e);
+      });
     } else if (url) {
-      await this.connectHttp(url);
+      await this.connectHttp(url).catch((e) => {
+        rej(e);
+      });
     } else {
+      rej(false);
       throw new Error("Server configuration must include either a command or a url.");
     }
-    this.isConnected = true;
+    res(true);
     const originalOnClose = this.client.onclose;
     this.client.onclose = () => {
       this.log("debug", `MCP server connection closed`);
-      this.isConnected = false;
+      rej(false);
       if (typeof originalOnClose === `function`) {
         originalOnClose();
       }
@@ -387,7 +404,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
       throw e;
     } finally {
       this.transport = void 0;
-      this.isConnected = false;
+      this.isConnected = Promise.resolve(false);
     }
   }
   async listResources() {
@@ -435,7 +452,11 @@ var InternalMastraMCPClient = class extends base.MastraBase {
    * @param args Arguments for the prompt
    * @param version (optional) The prompt version to retrieve
    */
-  async getPrompt({ name, args, version }) {
+  async getPrompt({
+    name,
+    args,
+    version
+  }) {
     this.log("debug", `Requesting prompt from MCP server: ${name}`);
     return await this.client.request(
       { method: "prompts/get", params: { name, arguments: args, version } },
@@ -737,6 +758,7 @@ To fix this you have three different options:
     }
     const exists = this.mcpClientsById.has(name);
     const existingClient = this.mcpClientsById.get(name);
+    this.logger.debug(`getConnectedClient ${name} exists: ${exists}`);
     if (exists) {
       if (!existingClient) {
         throw new Error(`Client ${name} exists but is undefined`);
@@ -750,6 +772,7 @@ To fix this you have three different options:
       server: config,
       timeout: config.timeout ?? this.defaultTimeout
     });
+    mcpClient.__setLogger(this.logger);
     this.mcpClientsById.set(name, mcpClient);
     try {
       await mcpClient.connect();
@@ -959,7 +982,7 @@ var MCPServer = class extends mcp.MCPServerBase {
   stdioTransport;
   sseTransport;
   sseHonoTransports;
-  streamableHTTPTransport;
+  streamableHTTPTransports = /* @__PURE__ */ new Map();
   listToolsHandlerIsRegistered = false;
   callToolHandlerIsRegistered = false;
   listResourcesHandlerIsRegistered = false;
@@ -995,12 +1018,6 @@ var MCPServer = class extends mcp.MCPServerBase {
   getSseHonoTransport(sessionId) {
     return this.sseHonoTransports.get(sessionId);
   }
-  /**
-   * Get the current streamable HTTP transport.
-   */
-  getStreamableHTTPTransport() {
-    return this.streamableHTTPTransport;
-  }
   /**
    * Get the current server instance.
    */
@@ -1672,34 +1689,132 @@ var MCPServer = class extends mcp.MCPServerBase {
     res,
     options = { sessionIdGenerator: () => crypto$1.randomUUID() }
   }) {
-    if (url.pathname === httpPath) {
-      this.streamableHTTPTransport = new streamableHttp_js.StreamableHTTPServerTransport(options);
-      try {
-        await this.server.connect(this.streamableHTTPTransport);
-      } catch (error) {
-        this.logger.error("Error connecting to MCP server", { error });
-        res.writeHead(500);
-        res.end("Error connecting to MCP server");
-        return;
-      }
-      try {
-        await this.streamableHTTPTransport.handleRequest(req, res);
-      } catch (error) {
-        this.logger.error("Error handling MCP connection", { error });
-        res.writeHead(500);
-        res.end("Error handling MCP connection");
-        return;
-      }
-      this.server.onclose = async () => {
-        this.streamableHTTPTransport = void 0;
-        await this.server.close();
-      };
-      res.on("close", () => {
-        this.streamableHTTPTransport = void 0;
-      });
-    } else {
+    this.logger.debug(`startHTTP: Received ${req.method} request to ${url.pathname}`);
+    if (url.pathname !== httpPath) {
+      this.logger.debug(`startHTTP: Pathname ${url.pathname} does not match httpPath ${httpPath}. Returning 404.`);
       res.writeHead(404);
       res.end();
+      return;
+    }
+    const sessionId = req.headers["mcp-session-id"];
+    let transport;
+    this.logger.debug(
+      `startHTTP: Session ID from headers: ${sessionId}. Active transports: ${Array.from(this.streamableHTTPTransports.keys()).join(", ")}`
+    );
+    try {
+      if (sessionId && this.streamableHTTPTransports.has(sessionId)) {
+        transport = this.streamableHTTPTransports.get(sessionId);
+        this.logger.debug(`startHTTP: Using existing Streamable HTTP transport for session ID: ${sessionId}`);
+        if (req.method === "GET") {
+          this.logger.debug(
+            `startHTTP: Handling GET request for existing session ${sessionId}. Calling transport.handleRequest.`
+          );
+        }
+        const body = req.method === "POST" ? await new Promise((resolve, reject) => {
+          let data = "";
+          req.on("data", (chunk) => data += chunk);
+          req.on("end", () => {
+            try {
+              resolve(JSON.parse(data));
+            } catch (e) {
+              reject(e);
+            }
+          });
+          req.on("error", reject);
+        }) : void 0;
+        await transport.handleRequest(req, res, body);
+      } else {
+        this.logger.debug(`startHTTP: No existing Streamable HTTP session ID found. ${req.method}`);
+        if (req.method === "POST") {
+          const body = await new Promise((resolve, reject) => {
+            let data = "";
+            req.on("data", (chunk) => data += chunk);
+            req.on("end", () => {
+              try {
+                resolve(JSON.parse(data));
+              } catch (e) {
+                reject(e);
+              }
+            });
+            req.on("error", reject);
+          });
+          const { isInitializeRequest } = await import('@modelcontextprotocol/sdk/types.js');
+          if (isInitializeRequest(body)) {
+            this.logger.debug("startHTTP: Received Streamable HTTP initialize request, creating new transport.");
+            transport = new streamableHttp_js.StreamableHTTPServerTransport({
+              ...options,
+              sessionIdGenerator: () => crypto$1.randomUUID(),
+              onsessioninitialized: (id) => {
+                this.streamableHTTPTransports.set(id, transport);
+              }
+            });
+            transport.onclose = () => {
+              const closedSessionId = transport?.sessionId;
+              if (closedSessionId && this.streamableHTTPTransports.has(closedSessionId)) {
+                this.logger.debug(
+                  `startHTTP: Streamable HTTP transport closed for session ${closedSessionId}, removing from map.`
+                );
+                this.streamableHTTPTransports.delete(closedSessionId);
+              }
+            };
+            await this.server.connect(transport);
+            if (transport.sessionId) {
+              this.streamableHTTPTransports.set(transport.sessionId, transport);
+              this.logger.debug(
+                `startHTTP: Streamable HTTP session initialized and stored with ID: ${transport.sessionId}`
+              );
+            } else {
+              this.logger.warn("startHTTP: Streamable HTTP transport initialized without a session ID.");
+            }
+            return await transport.handleRequest(req, res, body);
+          } else {
+            this.logger.warn("startHTTP: Received non-initialize POST request without a session ID.");
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Bad Request: No valid session ID provided for non-initialize request"
+                },
+                id: body?.id ?? null
+                // Include original request ID if available
+              })
+            );
+          }
+        } else {
+          this.logger.warn(`startHTTP: Received ${req.method} request without a session ID.`);
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32e3,
+                message: `Bad Request: ${req.method} request requires a valid session ID`
+              },
+              id: null
+            })
+          );
+        }
+      }
+    } catch (error) {
+      this.logger.error("startHTTP: Error handling Streamable HTTP request:", { error });
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32603,
+              message: "Internal server error"
+            },
+            id: null
+            // Cannot determine original request ID in catch
+          })
+        );
+      } else {
+        this.logger.error("startHTTP: Error after headers sent:", error);
+      }
     }
   }
   async connectSSE({
@@ -1766,9 +1881,11 @@ var MCPServer = class extends mcp.MCPServerBase {
         }
         this.sseHonoTransports.clear();
       }
-      if (this.streamableHTTPTransport) {
-        await this.streamableHTTPTransport.close?.();
-        this.streamableHTTPTransport = void 0;
+      if (this.streamableHTTPTransports) {
+        for (const transport of this.streamableHTTPTransports.values()) {
+          await transport.close?.();
+        }
+        this.streamableHTTPTransports.clear();
       }
       await this.server.close();
       this.logger.info("MCP server closed.");

package/dist/index.js

@@ -293,8 +293,7 @@ var InternalMastraMCPClient = class extends MastraBase {
         this.log("debug", "Trying Streamable HTTP transport...");
         const streamableTransport = new StreamableHTTPClientTransport(url, {
           requestInit,
-          reconnectionOptions: this.serverConfig.reconnectionOptions,
-          sessionId: this.serverConfig.sessionId
+          reconnectionOptions: this.serverConfig.reconnectionOptions
         });
         await this.client.connect(streamableTransport, {
           timeout: (
@@ -325,22 +324,40 @@ var InternalMastraMCPClient = class extends MastraBase {
       }
     }
   }
-  isConnected = false;
+  isConnected = null;
   async connect() {
-    if (this.isConnected) return;
+    let res = () => {
+    };
+    let rej = () => {
+    };
+    if (this.isConnected === null) {
+      this.log("debug", `Creating new isConnected promise`);
+      this.isConnected = new Promise((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+    } else if (await this.isConnected) {
+      this.log("debug", `MCP server already connected`);
+      return;
+    }
     const { command, url } = this.serverConfig;
     if (command) {
-      await this.connectStdio(command);
+      await this.connectStdio(command).catch((e) => {
+        rej(e);
+      });
     } else if (url) {
-      await this.connectHttp(url);
+      await this.connectHttp(url).catch((e) => {
+        rej(e);
+      });
     } else {
+      rej(false);
       throw new Error("Server configuration must include either a command or a url.");
     }
-    this.isConnected = true;
+    res(true);
     const originalOnClose = this.client.onclose;
     this.client.onclose = () => {
       this.log("debug", `MCP server connection closed`);
-      this.isConnected = false;
+      rej(false);
       if (typeof originalOnClose === `function`) {
         originalOnClose();
       }
@@ -381,7 +398,7 @@ var InternalMastraMCPClient = class extends MastraBase {
       throw e;
     } finally {
       this.transport = void 0;
-      this.isConnected = false;
+      this.isConnected = Promise.resolve(false);
     }
   }
   async listResources() {
@@ -429,7 +446,11 @@ var InternalMastraMCPClient = class extends MastraBase {
    * @param args Arguments for the prompt
    * @param version (optional) The prompt version to retrieve
    */
-  async getPrompt({ name, args, version }) {
+  async getPrompt({
+    name,
+    args,
+    version
+  }) {
     this.log("debug", `Requesting prompt from MCP server: ${name}`);
     return await this.client.request(
       { method: "prompts/get", params: { name, arguments: args, version } },
@@ -731,6 +752,7 @@ To fix this you have three different options:
     }
     const exists = this.mcpClientsById.has(name);
     const existingClient = this.mcpClientsById.get(name);
+    this.logger.debug(`getConnectedClient ${name} exists: ${exists}`);
     if (exists) {
       if (!existingClient) {
         throw new Error(`Client ${name} exists but is undefined`);
@@ -744,6 +766,7 @@ To fix this you have three different options:
       server: config,
       timeout: config.timeout ?? this.defaultTimeout
     });
+    mcpClient.__setLogger(this.logger);
     this.mcpClientsById.set(name, mcpClient);
     try {
       await mcpClient.connect();
@@ -953,7 +976,7 @@ var MCPServer = class extends MCPServerBase {
   stdioTransport;
   sseTransport;
   sseHonoTransports;
-  streamableHTTPTransport;
+  streamableHTTPTransports = /* @__PURE__ */ new Map();
   listToolsHandlerIsRegistered = false;
   callToolHandlerIsRegistered = false;
   listResourcesHandlerIsRegistered = false;
@@ -989,12 +1012,6 @@ var MCPServer = class extends MCPServerBase {
   getSseHonoTransport(sessionId) {
     return this.sseHonoTransports.get(sessionId);
   }
-  /**
-   * Get the current streamable HTTP transport.
-   */
-  getStreamableHTTPTransport() {
-    return this.streamableHTTPTransport;
-  }
   /**
    * Get the current server instance.
    */
@@ -1666,34 +1683,132 @@ var MCPServer = class extends MCPServerBase {
     res,
     options = { sessionIdGenerator: () => randomUUID() }
   }) {
-    if (url.pathname === httpPath) {
-      this.streamableHTTPTransport = new StreamableHTTPServerTransport(options);
-      try {
-        await this.server.connect(this.streamableHTTPTransport);
-      } catch (error) {
-        this.logger.error("Error connecting to MCP server", { error });
-        res.writeHead(500);
-        res.end("Error connecting to MCP server");
-        return;
-      }
-      try {
-        await this.streamableHTTPTransport.handleRequest(req, res);
-      } catch (error) {
-        this.logger.error("Error handling MCP connection", { error });
-        res.writeHead(500);
-        res.end("Error handling MCP connection");
-        return;
-      }
-      this.server.onclose = async () => {
-        this.streamableHTTPTransport = void 0;
-        await this.server.close();
-      };
-      res.on("close", () => {
-        this.streamableHTTPTransport = void 0;
-      });
-    } else {
+    this.logger.debug(`startHTTP: Received ${req.method} request to ${url.pathname}`);
+    if (url.pathname !== httpPath) {
+      this.logger.debug(`startHTTP: Pathname ${url.pathname} does not match httpPath ${httpPath}. Returning 404.`);
       res.writeHead(404);
       res.end();
+      return;
+    }
+    const sessionId = req.headers["mcp-session-id"];
+    let transport;
+    this.logger.debug(
+      `startHTTP: Session ID from headers: ${sessionId}. Active transports: ${Array.from(this.streamableHTTPTransports.keys()).join(", ")}`
+    );
+    try {
+      if (sessionId && this.streamableHTTPTransports.has(sessionId)) {
+        transport = this.streamableHTTPTransports.get(sessionId);
+        this.logger.debug(`startHTTP: Using existing Streamable HTTP transport for session ID: ${sessionId}`);
+        if (req.method === "GET") {
+          this.logger.debug(
+            `startHTTP: Handling GET request for existing session ${sessionId}. Calling transport.handleRequest.`
+          );
+        }
+        const body = req.method === "POST" ? await new Promise((resolve, reject) => {
+          let data = "";
+          req.on("data", (chunk) => data += chunk);
+          req.on("end", () => {
+            try {
+              resolve(JSON.parse(data));
+            } catch (e) {
+              reject(e);
+            }
+          });
+          req.on("error", reject);
+        }) : void 0;
+        await transport.handleRequest(req, res, body);
+      } else {
+        this.logger.debug(`startHTTP: No existing Streamable HTTP session ID found. ${req.method}`);
+        if (req.method === "POST") {
+          const body = await new Promise((resolve, reject) => {
+            let data = "";
+            req.on("data", (chunk) => data += chunk);
+            req.on("end", () => {
+              try {
+                resolve(JSON.parse(data));
+              } catch (e) {
+                reject(e);
+              }
+            });
+            req.on("error", reject);
+          });
+          const { isInitializeRequest } = await import('@modelcontextprotocol/sdk/types.js');
+          if (isInitializeRequest(body)) {
+            this.logger.debug("startHTTP: Received Streamable HTTP initialize request, creating new transport.");
+            transport = new StreamableHTTPServerTransport({
+              ...options,
+              sessionIdGenerator: () => randomUUID(),
+              onsessioninitialized: (id) => {
+                this.streamableHTTPTransports.set(id, transport);
+              }
+            });
+            transport.onclose = () => {
+              const closedSessionId = transport?.sessionId;
+              if (closedSessionId && this.streamableHTTPTransports.has(closedSessionId)) {
+                this.logger.debug(
+                  `startHTTP: Streamable HTTP transport closed for session ${closedSessionId}, removing from map.`
+                );
+                this.streamableHTTPTransports.delete(closedSessionId);
+              }
+            };
+            await this.server.connect(transport);
+            if (transport.sessionId) {
+              this.streamableHTTPTransports.set(transport.sessionId, transport);
+              this.logger.debug(
+                `startHTTP: Streamable HTTP session initialized and stored with ID: ${transport.sessionId}`
+              );
+            } else {
+              this.logger.warn("startHTTP: Streamable HTTP transport initialized without a session ID.");
+            }
+            return await transport.handleRequest(req, res, body);
+          } else {
+            this.logger.warn("startHTTP: Received non-initialize POST request without a session ID.");
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Bad Request: No valid session ID provided for non-initialize request"
+                },
+                id: body?.id ?? null
+                // Include original request ID if available
+              })
+            );
+          }
+        } else {
+          this.logger.warn(`startHTTP: Received ${req.method} request without a session ID.`);
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32e3,
+                message: `Bad Request: ${req.method} request requires a valid session ID`
+              },
+              id: null
+            })
+          );
+        }
+      }
+    } catch (error) {
+      this.logger.error("startHTTP: Error handling Streamable HTTP request:", { error });
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32603,
+              message: "Internal server error"
+            },
+            id: null
+            // Cannot determine original request ID in catch
+          })
+        );
+      } else {
+        this.logger.error("startHTTP: Error after headers sent:", error);
+      }
     }
   }
   async connectSSE({
@@ -1760,9 +1875,11 @@ var MCPServer = class extends MCPServerBase {
         }
         this.sseHonoTransports.clear();
       }
-      if (this.streamableHTTPTransport) {
-        await this.streamableHTTPTransport.close?.();
-        this.streamableHTTPTransport = void 0;
+      if (this.streamableHTTPTransports) {
+        for (const transport of this.streamableHTTPTransports.values()) {
+          await transport.close?.();
+        }
+        this.streamableHTTPTransports.clear();
       }
       await this.server.close();
       this.logger.info("MCP server closed.");

package/integration-tests/node_modules/.bin/vitest

@@ -10,9 +10,9 @@ case `uname` in
 esac
 
 if [ -z "$NODE_PATH" ]; then
-  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_f2f8c5e73aab614bca86ded968276706/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_f2f8c5e73aab614bca86ded968276706/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules"
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.3_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_693b2e3fc65baebd9dc5fe66abed9401/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.3_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_693b2e3fc65baebd9dc5fe66abed9401/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules"
 else
-  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_f2f8c5e73aab614bca86ded968276706/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.2_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_f2f8c5e73aab614bca86ded968276706/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules:$NODE_PATH"
+  export NODE_PATH="/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.3_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_693b2e3fc65baebd9dc5fe66abed9401/node_modules/vitest/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/vitest@3.2.3_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.0_@vitest+ui@_693b2e3fc65baebd9dc5fe66abed9401/node_modules:/home/runner/work/mastra/mastra/node_modules/.pnpm/node_modules:$NODE_PATH"
 fi
 if [ -x "$basedir/node" ]; then
   exec "$basedir/node"  "$basedir/../vitest/vitest.mjs" "$@"

package/integration-tests/package.json

@@ -15,12 +15,13 @@
     "zod": "^3.25.56"
   },
   "devDependencies": {
+    "@mastra/core": "workspace:*",
     "@testing-library/react": "^16.2.0",
     "@types/node": "^20.17.57",
+    "get-port": "^7.1.0",
     "mastra": "workspace:*",
     "typescript": "^5.8.2",
-    "vitest": "^3.2.2",
-    "@mastra/core": "workspace:*"
+    "vitest": "^3.2.2"
   },
   "peerDependencies": {
     "@mastra/core": "^0.10.0-alpha.0"

package/integration-tests/src/server.test.ts

@@ -1,24 +1,12 @@
 import { spawn } from 'node:child_process';
 import { createServer } from 'node:http';
-import path from 'path';
 import { MCPClient } from '@mastra/mcp';
 import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
 import { ServerInfo } from '@mastra/core/mcp';
+import getPort from 'get-port';
 
 vi.setConfig({ testTimeout: 20000, hookTimeout: 20000 });
 
-// Helper to find an available port
-async function getAvailablePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = createServer();
-    server.listen(0, () => {
-      const { port } = server.address() as { port: number };
-      server.close(() => resolve(port));
-    });
-    server.on('error', reject);
-  });
-}
-
 describe('MCPServer through Mastra HTTP Integration (Subprocess)', () => {
   let mastraServer: ReturnType<typeof spawn>;
   let port: number;
@@ -27,21 +15,12 @@ describe('MCPServer through Mastra HTTP Integration (Subprocess)', () => {
   let client: MCPClient;
 
   beforeAll(async () => {
-    port = await getAvailablePort();
-
-    mastraServer = spawn(
-      'pnpm',
-      [
-        path.resolve(import.meta.dirname, `..`, `..`, `..`, `cli`, `dist`, `index.js`),
-        'dev',
-        '--port',
-        port.toString(),
-      ],
-      {
-        stdio: 'pipe',
-        detached: true, // Run in a new process group so we can kill it and children
-      },
-    );
+    port = await getPort();
+
+    mastraServer = spawn('pnpm', ['mastra', 'dev', '--port', port.toString()], {
+      stdio: 'pipe',
+      detached: true, // Run in a new process group so we can kill it and children
+    });
 
     // Wait for server to be ready
     await new Promise<void>((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp",
-  "version": "0.10.3-alpha.0",
+  "version": "0.10.4-alpha.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -22,36 +22,36 @@
   "author": "",
   "license": "Elastic-2.0",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.10.2",
+    "@modelcontextprotocol/sdk": "^1.12.1",
     "date-fns": "^4.1.0",
     "exit-hook": "^4.0.0",
     "fast-deep-equal": "^3.1.3",
-    "hono": "^4.7.4",
+    "hono": "^4.7.11",
     "uuid": "^11.1.0",
     "zod-from-json-schema": "^0.0.5"
   },
   "peerDependencies": {
-    "zod": "^3.0.0",
-    "@mastra/core": "^0.10.2-alpha.0"
+    "@mastra/core": "^0.10.2-alpha.0",
+    "zod": "^3.0.0"
   },
   "devDependencies": {
-    "@ai-sdk/anthropic": "^1.1.15",
+    "@ai-sdk/anthropic": "^1.2.12",
     "@ai-sdk/openai": "^1.3.22",
-    "ai": "4.3.16",
-    "@hono/node-server": "^1.13.8",
-    "@mendable/firecrawl-js": "^1.24.0",
+    "@hono/node-server": "^1.14.4",
+    "@mendable/firecrawl-js": "^1.25.5",
     "@microsoft/api-extractor": "^7.52.8",
-    "@types/node": "^20.17.57",
+    "@types/node": "^20.19.0",
+    "ai": "4.3.16",
     "eslint": "^9.28.0",
     "hono-mcp-server-sse-transport": "0.0.6",
     "tsup": "^8.5.0",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.2",
-    "vitest": "^3.2.2",
-    "zod": "^3.25.56",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.3",
+    "zod": "^3.25.57",
     "zod-to-json-schema": "^3.24.5",
-    "@internal/lint": "0.0.10",
-    "@mastra/core": "0.10.4-alpha.1"
+    "@internal/lint": "0.0.12",
+    "@mastra/core": "0.10.6-alpha.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/client/client.ts

@@ -11,7 +11,12 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import type { StreamableHTTPClientTransportOptions } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { DEFAULT_REQUEST_TIMEOUT_MSEC } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
-import type { ClientCapabilities, GetPromptResult, ListPromptsResult, LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
+import type {
+  ClientCapabilities,
+  GetPromptResult,
+  ListPromptsResult,
+  LoggingLevel,
+} from '@modelcontextprotocol/sdk/types.js';
 import {
   CallToolResultSchema,
   ListResourcesResultSchema,
@@ -151,7 +156,7 @@ export class InternalMastraMCPClient extends MastraBase {
 
     // Set up log message capturing
     this.setupLogging();
-    
+
     this.resources = new ResourceClientActions({ client: this, logger: this.logger });
     this.prompts = new PromptClientActions({ client: this, logger: this.logger });
   }
@@ -234,7 +239,6 @@ export class InternalMastraMCPClient extends MastraBase {
         const streamableTransport = new StreamableHTTPClientTransport(url, {
           requestInit,
           reconnectionOptions: this.serverConfig.reconnectionOptions,
-          sessionId: this.serverConfig.sessionId,
         });
         await this.client.connect(streamableTransport, {
           timeout:
@@ -267,26 +271,43 @@ export class InternalMastraMCPClient extends MastraBase {
     }
   }
 
-  private isConnected = false;
+  private isConnected: Promise<boolean> | null = null;
 
   async connect() {
-    if (this.isConnected) return;
+    let res: (value: boolean) => void = () => {};
+    let rej: (reason?: any) => void = () => {};
+
+    if (this.isConnected === null) {
+      this.log('debug', `Creating new isConnected promise`);
+      this.isConnected = new Promise<boolean>((resolve, reject) => {
+        res = resolve;
+        rej = reject;
+      });
+    } else if (await this.isConnected) {
+      this.log('debug', `MCP server already connected`);
+      return;
+    }
 
     const { command, url } = this.serverConfig;
 
     if (command) {
-      await this.connectStdio(command);
+      await this.connectStdio(command).catch(e => {
+        rej(e);
+      });
     } else if (url) {
-      await this.connectHttp(url);
+      await this.connectHttp(url).catch(e => {
+        rej(e);
+      });
     } else {
+      rej(false);
       throw new Error('Server configuration must include either a command or a url.');
     }
 
-    this.isConnected = true;
+    res(true);
     const originalOnClose = this.client.onclose;
     this.client.onclose = () => {
       this.log('debug', `MCP server connection closed`);
-      this.isConnected = false;
+      rej(false);
       if (typeof originalOnClose === `function`) {
         originalOnClose();
       }
@@ -330,7 +351,7 @@ export class InternalMastraMCPClient extends MastraBase {
       throw e;
     } finally {
       this.transport = undefined;
-      this.isConnected = false;
+      this.isConnected = Promise.resolve(false);
     }
   }
 
@@ -385,12 +406,20 @@ export class InternalMastraMCPClient extends MastraBase {
    * @param args Arguments for the prompt
    * @param version (optional) The prompt version to retrieve
    */
-  async getPrompt({ name, args, version }: { name: string; args?: Record<string, any>; version?: string }): Promise<GetPromptResult> {
+  async getPrompt({
+    name,
+    args,
+    version,
+  }: {
+    name: string;
+    args?: Record<string, any>;
+    version?: string;
+  }): Promise<GetPromptResult> {
     this.log('debug', `Requesting prompt from MCP server: ${name}`);
     return await this.client.request(
       { method: 'prompts/get', params: { name, arguments: args, version } },
       GetPromptResultSchema,
-      { timeout: this.timeout }
+      { timeout: this.timeout },
     );
   }
 

package/src/client/configuration.ts

@@ -230,6 +230,8 @@ To fix this you have three different options:
     const exists = this.mcpClientsById.has(name);
     const existingClient = this.mcpClientsById.get(name);
 
+    this.logger.debug(`getConnectedClient ${name} exists: ${exists}`);
+    
     if (exists) {
       // This is just to satisfy Typescript since technically you could have this.mcpClientsById.set('someKey', undefined);
       // Should never reach this point basically we always create a new MastraMCPClient instance when we add to the Map.
@@ -249,6 +251,8 @@ To fix this you have three different options:
       timeout: config.timeout ?? this.defaultTimeout,
     });
 
+    mcpClient.__setLogger(this.logger);
+
     this.mcpClientsById.set(name, mcpClient);
 
     try {

package/src/server/server.ts

@@ -58,7 +58,7 @@ export class MCPServer extends MCPServerBase {
   private stdioTransport?: StdioServerTransport;
   private sseTransport?: SSEServerTransport;
   private sseHonoTransports: Map<string, SSETransport>;
-  private streamableHTTPTransport?: StreamableHTTPServerTransport;
+  private streamableHTTPTransports: Map<string, StreamableHTTPServerTransport> = new Map();
   private listToolsHandlerIsRegistered: boolean = false;
   private callToolHandlerIsRegistered: boolean = false;
   private listResourcesHandlerIsRegistered: boolean = false;
@@ -100,13 +100,6 @@ export class MCPServer extends MCPServerBase {
     return this.sseHonoTransports.get(sessionId);
   }
 
-  /**
-   * Get the current streamable HTTP transport.
-   */
-  public getStreamableHTTPTransport(): StreamableHTTPServerTransport | undefined {
-    return this.streamableHTTPTransport;
-  }
-
   /**
    * Get the current server instance.
    */
@@ -880,37 +873,163 @@ export class MCPServer extends MCPServerBase {
     res: http.ServerResponse<http.IncomingMessage>;
     options?: StreamableHTTPServerTransportOptions;
   }) {
-    if (url.pathname === httpPath) {
-      this.streamableHTTPTransport = new StreamableHTTPServerTransport(options);
-      try {
-        await this.server.connect(this.streamableHTTPTransport);
-      } catch (error) {
-        this.logger.error('Error connecting to MCP server', { error });
-        res.writeHead(500);
-        res.end('Error connecting to MCP server');
-        return;
-      }
-
-      try {
-        await this.streamableHTTPTransport.handleRequest(req, res);
-      } catch (error) {
-        this.logger.error('Error handling MCP connection', { error });
-        res.writeHead(500);
-        res.end('Error handling MCP connection');
-        return;
-      }
+    this.logger.debug(`startHTTP: Received ${req.method} request to ${url.pathname}`);
 
-      this.server.onclose = async () => {
-        this.streamableHTTPTransport = undefined;
-        await this.server.close();
-      };
-
-      res.on('close', () => {
-        this.streamableHTTPTransport = undefined;
-      });
-    } else {
+    if (url.pathname !== httpPath) {
+      this.logger.debug(`startHTTP: Pathname ${url.pathname} does not match httpPath ${httpPath}. Returning 404.`);
       res.writeHead(404);
       res.end();
+      return;
+    }
+
+    const sessionId = req.headers['mcp-session-id'] as string | undefined;
+    let transport: StreamableHTTPServerTransport | undefined;
+
+    this.logger.debug(
+      `startHTTP: Session ID from headers: ${sessionId}. Active transports: ${Array.from(this.streamableHTTPTransports.keys()).join(', ')}`,
+    );
+
+    try {
+      if (sessionId && this.streamableHTTPTransports.has(sessionId)) {
+        // Found existing session
+        transport = this.streamableHTTPTransports.get(sessionId)!;
+        this.logger.debug(`startHTTP: Using existing Streamable HTTP transport for session ID: ${sessionId}`);
+
+        if (req.method === 'GET') {
+          this.logger.debug(
+            `startHTTP: Handling GET request for existing session ${sessionId}. Calling transport.handleRequest.`,
+          );
+        }
+
+        // Handle the request using the existing transport
+        // Need to parse body for POST requests before passing to handleRequest
+        const body =
+          req.method === 'POST'
+            ? await new Promise((resolve, reject) => {
+                let data = '';
+                req.on('data', chunk => (data += chunk));
+                req.on('end', () => {
+                  try {
+                    resolve(JSON.parse(data));
+                  } catch (e) {
+                    reject(e);
+                  }
+                });
+                req.on('error', reject);
+              })
+            : undefined;
+
+        await transport.handleRequest(req, res, body);
+      } else {
+        // No session ID or session ID not found
+        this.logger.debug(`startHTTP: No existing Streamable HTTP session ID found. ${req.method}`);
+
+        // Only allow new sessions via POST initialize request
+        if (req.method === 'POST') {
+          const body = await new Promise((resolve, reject) => {
+            let data = '';
+            req.on('data', chunk => (data += chunk));
+            req.on('end', () => {
+              try {
+                resolve(JSON.parse(data));
+              } catch (e) {
+                reject(e);
+              }
+            });
+            req.on('error', reject);
+          });
+
+          // Import isInitializeRequest from the correct path
+          const { isInitializeRequest } = await import('@modelcontextprotocol/sdk/types.js');
+
+          if (isInitializeRequest(body)) {
+            this.logger.debug('startHTTP: Received Streamable HTTP initialize request, creating new transport.');
+
+            // Create a new transport for the new session
+            transport = new StreamableHTTPServerTransport({
+              ...options,
+              sessionIdGenerator: () => randomUUID(),
+              onsessioninitialized: id => {
+                this.streamableHTTPTransports.set(id, transport!);
+              },
+            });
+
+            // Set up onclose handler to clean up transport when closed
+            transport.onclose = () => {
+              const closedSessionId = transport?.sessionId;
+              if (closedSessionId && this.streamableHTTPTransports.has(closedSessionId)) {
+                this.logger.debug(
+                  `startHTTP: Streamable HTTP transport closed for session ${closedSessionId}, removing from map.`,
+                );
+                this.streamableHTTPTransports.delete(closedSessionId);
+              }
+            };
+
+            // Connect the MCP server instance to the new transport
+            await this.server.connect(transport);
+
+            // Store the transport when the session is initialized
+            if (transport.sessionId) {
+              this.streamableHTTPTransports.set(transport.sessionId, transport);
+              this.logger.debug(
+                `startHTTP: Streamable HTTP session initialized and stored with ID: ${transport.sessionId}`,
+              );
+            } else {
+              this.logger.warn('startHTTP: Streamable HTTP transport initialized without a session ID.');
+            }
+
+            // Handle the initialize request
+            return await transport.handleRequest(req, res, body);
+          } else {
+            // POST request but not initialize, and no session ID
+            this.logger.warn('startHTTP: Received non-initialize POST request without a session ID.');
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(
+              JSON.stringify({
+                jsonrpc: '2.0',
+                error: {
+                  code: -32000,
+                  message: 'Bad Request: No valid session ID provided for non-initialize request',
+                },
+                id: (body as any)?.id ?? null, // Include original request ID if available
+              }),
+            );
+          }
+        } else {
+          // Non-POST request (GET/DELETE) without a session ID
+          this.logger.warn(`startHTTP: Received ${req.method} request without a session ID.`);
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(
+            JSON.stringify({
+              jsonrpc: '2.0',
+              error: {
+                code: -32000,
+                message: `Bad Request: ${req.method} request requires a valid session ID`,
+              },
+              id: null,
+            }),
+          );
+        }
+      }
+    } catch (error) {
+      this.logger.error('startHTTP: Error handling Streamable HTTP request:', { error });
+      // If headers haven't been sent, send an error response
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({
+            jsonrpc: '2.0',
+            error: {
+              code: -32603,
+              message: 'Internal server error',
+            },
+            id: null, // Cannot determine original request ID in catch
+          }),
+        );
+      } else {
+        // If headers were already sent (e.g., during SSE stream), just log the error
+        this.logger.error('startHTTP: Error after headers sent:', error);
+      }
     }
   }
 
@@ -991,9 +1110,12 @@ export class MCPServer extends MCPServerBase {
         }
         this.sseHonoTransports.clear();
       }
-      if (this.streamableHTTPTransport) {
-        await this.streamableHTTPTransport.close?.();
-        this.streamableHTTPTransport = undefined;
+      // Close all active Streamable HTTP transports
+      if (this.streamableHTTPTransports) {
+        for (const transport of this.streamableHTTPTransports.values()) {
+          await transport.close?.();
+        }
+        this.streamableHTTPTransports.clear();
       }
       await this.server.close();
       this.logger.info('MCP server closed.');