@mastra/mcp 0.14.4 → 0.14.5-alpha.0

package/dist/index.js

@@ -2963,6 +2963,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
    *
@@ -2988,6 +2989,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,
@@ -3003,6 +3023,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: () => randomUUID(),
       // default: enabled
@@ -3144,6 +3170,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 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) {
+      const mastraError = new MastraError(
+        {
+          id: "MCP_SERVER_SERVERLESS_REQUEST_FAILED",
+          domain: ErrorDomain.MCP,
+          category: ErrorCategory.USER,
+          text: "Failed to handle serverless MCP request"
+        },
+        error
+      );
+      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 instanceof Error ? error.message : String(error)
+            },
+            id: null
+          })
+        );
+      }
+    }
+  }
   /**
    * Establishes the SSE connection for the MCP server.
    *