@mastra/mcp 0.14.4 → 0.14.5-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @mastra/mcp
 
+## 0.14.5-alpha.0
+
+### Patch Changes
+
+- add flag to skip sessions and streaming in serverless mcp ([#10927](https://github.com/mastra-ai/mastra/pull/10927))
+
+- Updated dependencies [[`b685c9c`](https://github.com/mastra-ai/mastra/commit/b685c9c0b89f49e0d4542c4ac72569682db69794)]:
+  - @mastra/core@0.24.7-alpha.2
+
 ## 0.14.4
 
 ### Patch Changes

package/dist/index.cjs

@@ -2970,6 +2970,7 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
    * @param options.options.onsessioninitialized - Callback when a new session is initialized
    * @param options.options.enableJsonResponse - If true, return JSON instead of SSE streaming
    * @param options.options.eventStore - Event store for message resumability
+   * @param options.options.serverless - If true, run in stateless mode without session management (ideal for serverless environments)
    *
    * @throws {MastraError} If HTTP connection setup fails
    *
@@ -2995,6 +2996,25 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
    *
    * httpServer.listen(1234);
    * ```
+   *
+   * @example Serverless mode (Cloudflare Workers, Vercel Edge, etc.)
+   * ```typescript
+   * export default {
+   *   async fetch(request: Request) {
+   *     const url = new URL(request.url);
+   *     if (url.pathname === '/mcp') {
+   *       await server.startHTTP({
+   *         url,
+   *         httpPath: '/mcp',
+   *         req: request,
+   *         res: response,
+   *         options: { serverless: true },
+   *       });
+   *     }
+   *     return new Response('Not found', { status: 404 });
+   *   },
+   * };
+   * ```
    */
   async startHTTP({
     url,
@@ -3010,6 +3030,12 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
       res.end();
       return;
     }
+    const isStatelessMode = options?.serverless || options && "sessionIdGenerator" in options && options.sessionIdGenerator === void 0;
+    if (isStatelessMode) {
+      this.logger.debug("startHTTP: Running in stateless mode (serverless or sessionIdGenerator: undefined)");
+      await this.handleServerlessRequest(req, res);
+      return;
+    }
     const mergedOptions = {
       sessionIdGenerator: () => crypto$1.randomUUID(),
       // default: enabled
@@ -3151,6 +3177,74 @@ Provided arguments: ${JSON.stringify(request.params.arguments, null, 2)}`
       }
     }
   }
+  /**
+   * Handles a stateless, serverless HTTP request without session management.
+   *
+   * This method bypasses all session/transport state and handles each request independently.
+   * For serverless environments (Cloudflare Workers, Vercel Edge, etc.) where
+   * persistent connections and session state cannot be maintained across requests.
+   *
+   * Each request gets a fresh transport and server instance that are discarded after the response.
+   *
+   * @param req - Incoming HTTP request
+   * @param res - HTTP response object
+   * @private
+   */
+  async handleServerlessRequest(req, res) {
+    try {
+      this.logger.debug(`handleServerlessRequest: Received ${req.method} request`);
+      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(new Error(`Invalid JSON in request body: ${e instanceof Error ? e.message : String(e)}`));
+          }
+        });
+        req.on("error", reject);
+      }) : void 0;
+      this.logger.debug(`handleServerlessRequest: Processing ${req.method} request`, {
+        method: body?.method,
+        id: body?.id
+      });
+      const transientServer = this.createServerInstance();
+      const tempTransport = new streamableHttp_js.StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0,
+        enableJsonResponse: true
+      });
+      await transientServer.connect(tempTransport);
+      await tempTransport.handleRequest(req, res, body);
+      this.logger.debug(`handleServerlessRequest: Completed ${body?.method} request`, { id: body?.id });
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MCP_SERVER_SERVERLESS_REQUEST_FAILED",
+          domain: error.ErrorDomain.MCP,
+          category: error.ErrorCategory.USER,
+          text: "Failed to handle serverless MCP request"
+        },
+        error$1
+      );
+      this.logger.trackException(mastraError);
+      this.logger.error("handleServerlessRequest: Error handling request:", { error: mastraError });
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32603,
+              message: "Internal server error",
+              data: error$1 instanceof Error ? error$1.message : String(error$1)
+            },
+            id: null
+          })
+        );
+      }
+    }
+  }
   /**
    * Establishes the SSE connection for the MCP server.
    *