agents 0.1.1 → 0.1.3

package/dist/mcp/index.js

@@ -1,47 +1,600 @@
 import {
-  Agent
-} from "../chunk-PNF6ZMUA.js";
+  Agent,
+  getAgentByName
+} from "../chunk-YDUDMOL6.js";
 import {
   SSEEdgeClientTransport,
   StreamableHTTPEdgeClientTransport
-} from "../chunk-VYENMKFS.js";
+} from "../chunk-MH46VMM4.js";
 import "../chunk-LL2AFX7V.js";
 import "../chunk-QEVM4BVL.js";
 import "../chunk-AVYJQSLW.js";
 
 // src/mcp/index.ts
-import { DurableObject } from "cloudflare:workers";
 import {
-  InitializeRequestSchema,
+  JSONRPCMessageSchema as JSONRPCMessageSchema2,
+  isJSONRPCError as isJSONRPCError3,
+  isJSONRPCNotification as isJSONRPCNotification2,
+  isJSONRPCRequest as isJSONRPCRequest2,
+  isJSONRPCResponse as isJSONRPCResponse3
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/mcp/utils.ts
+import {
   JSONRPCMessageSchema,
+  InitializeRequestSchema,
+  isJSONRPCResponse,
   isJSONRPCError,
   isJSONRPCNotification,
-  isJSONRPCRequest,
-  isJSONRPCResponse
-} from "@modelcontextprotocol/sdk/types.js";
-import {
-  ElicitRequestSchema
+  isJSONRPCRequest
 } from "@modelcontextprotocol/sdk/types.js";
+var STANDALONE_SSE_MARKER = "standalone-sse";
+var STANDALONE_SSE_METHOD = "cf/standalone_sse/attach";
 var MAXIMUM_MESSAGE_SIZE_BYTES = 4 * 1024 * 1024;
+var createStreamingHttpHandler = (basePath, namespace, corsOptions) => {
+  let pathname = basePath;
+  if (basePath === "/") pathname = "/*";
+  const basePattern = new URLPattern({ pathname });
+  return async (request, ctx) => {
+    const url = new URL(request.url);
+    if (basePattern.test(url)) {
+      if (request.method === "POST") {
+        const acceptHeader = request.headers.get("accept");
+        if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
+          const body2 = JSON.stringify({
+            error: {
+              code: -32e3,
+              message: "Not Acceptable: Client must accept both application/json and text/event-stream"
+            },
+            id: null,
+            jsonrpc: "2.0"
+          });
+          return new Response(body2, { status: 406 });
+        }
+        const ct = request.headers.get("content-type");
+        if (!ct || !ct.includes("application/json")) {
+          const body2 = JSON.stringify({
+            error: {
+              code: -32e3,
+              message: "Unsupported Media Type: Content-Type must be application/json"
+            },
+            id: null,
+            jsonrpc: "2.0"
+          });
+          return new Response(body2, { status: 415 });
+        }
+        const contentLength = Number.parseInt(
+          request.headers.get("content-length") ?? "0",
+          10
+        );
+        if (contentLength > MAXIMUM_MESSAGE_SIZE_BYTES) {
+          const body2 = JSON.stringify({
+            error: {
+              code: -32e3,
+              message: `Request body too large. Maximum size is ${MAXIMUM_MESSAGE_SIZE_BYTES} bytes`
+            },
+            id: null,
+            jsonrpc: "2.0"
+          });
+          return new Response(body2, { status: 413 });
+        }
+        let sessionId = request.headers.get("mcp-session-id");
+        let rawMessage;
+        try {
+          rawMessage = await request.json();
+        } catch (_error) {
+          const body2 = JSON.stringify({
+            error: {
+              code: -32700,
+              message: "Parse error: Invalid JSON"
+            },
+            id: null,
+            jsonrpc: "2.0"
+          });
+          return new Response(body2, { status: 400 });
+        }
+        let arrayMessage;
+        if (Array.isArray(rawMessage)) {
+          arrayMessage = rawMessage;
+        } else {
+          arrayMessage = [rawMessage];
+        }
+        let messages = [];
+        for (const msg of arrayMessage) {
+          if (!JSONRPCMessageSchema.safeParse(msg).success) {
+            const body2 = JSON.stringify({
+              error: {
+                code: -32700,
+                message: "Parse error: Invalid JSON-RPC message"
+              },
+              id: null,
+              jsonrpc: "2.0"
+            });
+            return new Response(body2, { status: 400 });
+          }
+        }
+        messages = arrayMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
+        const isInitializationRequest = messages.some(
+          (msg) => InitializeRequestSchema.safeParse(msg).success
+        );
+        if (isInitializationRequest && sessionId) {
+          const body2 = JSON.stringify({
+            error: {
+              code: -32600,
+              message: "Invalid Request: Initialization requests must not include a sessionId"
+            },
+            id: null,
+            jsonrpc: "2.0"
+          });
+          return new Response(body2, { status: 400 });
+        }
+        if (isInitializationRequest && messages.length > 1) {
+          const body2 = JSON.stringify({
+            error: {
+              code: -32600,
+              message: "Invalid Request: Only one initialization request is allowed"
+            },
+            id: null,
+            jsonrpc: "2.0"
+          });
+          return new Response(body2, { status: 400 });
+        }
+        if (!isInitializationRequest && !sessionId) {
+          const body2 = JSON.stringify({
+            error: {
+              code: -32e3,
+              message: "Bad Request: Mcp-Session-Id header is required"
+            },
+            id: null,
+            jsonrpc: "2.0"
+          });
+          return new Response(body2, { status: 400 });
+        }
+        sessionId = sessionId ?? namespace.newUniqueId().toString();
+        const agent = await getAgentByName(
+          namespace,
+          `streamable-http:${sessionId}`,
+          { props: ctx.props }
+        );
+        const isInitialized = await agent.isInitialized();
+        if (isInitializationRequest) {
+          await agent.setInitialized();
+        } else if (!isInitialized) {
+          const body2 = JSON.stringify({
+            error: {
+              code: -32001,
+              message: "Session not found"
+            },
+            id: null,
+            jsonrpc: "2.0"
+          });
+          return new Response(body2, { status: 404 });
+        }
+        const { readable, writable } = new TransformStream();
+        const writer = writable.getWriter();
+        const encoder = new TextEncoder();
+        const existingHeaders = {};
+        request.headers.forEach((value, key) => {
+          existingHeaders[key] = value;
+        });
+        const req = new Request(request.url, {
+          headers: {
+            ...existingHeaders,
+            Upgrade: "websocket"
+          }
+        });
+        if (ctx.props) agent.updateProps(ctx.props);
+        const response = await agent.fetch(req);
+        const ws = response.webSocket;
+        if (!ws) {
+          console.error("Failed to establish WebSocket connection");
+          await writer.close();
+          const body2 = JSON.stringify({
+            error: {
+              code: -32001,
+              message: "Failed to establish WebSocket connection"
+            },
+            id: null,
+            jsonrpc: "2.0"
+          });
+          return new Response(body2, { status: 500 });
+        }
+        const requestIds = /* @__PURE__ */ new Set();
+        ws.accept();
+        ws.addEventListener("message", (event) => {
+          async function onMessage(event2) {
+            try {
+              const data = typeof event2.data === "string" ? event2.data : new TextDecoder().decode(event2.data);
+              const message = JSON.parse(data);
+              const result = JSONRPCMessageSchema.safeParse(message);
+              if (!result.success) {
+                return;
+              }
+              if (isJSONRPCResponse(result.data) || isJSONRPCError(result.data)) {
+                requestIds.delete(result.data.id);
+              }
+              const messageText = `event: message
+data: ${JSON.stringify(result.data)}
+
+`;
+              await writer.write(encoder.encode(messageText));
+              if (requestIds.size === 0) {
+                ws?.close();
+                await writer.close();
+              }
+            } catch (error) {
+              console.error("Error forwarding message to SSE:", error);
+            }
+          }
+          onMessage(event).catch(console.error);
+        });
+        ws.addEventListener("error", (error) => {
+          async function onError(_error) {
+            try {
+              await writer.close();
+            } catch (_e) {
+            }
+          }
+          onError(error).catch(console.error);
+        });
+        ws.addEventListener("close", () => {
+          async function onClose() {
+            try {
+              await writer.close();
+            } catch (error) {
+              console.error("Error closing SSE connection:", error);
+            }
+          }
+          onClose().catch(console.error);
+        });
+        const hasOnlyNotificationsOrResponses = messages.every(
+          (msg) => isJSONRPCNotification(msg) || isJSONRPCResponse(msg)
+        );
+        if (hasOnlyNotificationsOrResponses) {
+          for (const message of messages) {
+            ws.send(JSON.stringify(message));
+          }
+          ws.close();
+          return new Response(null, {
+            headers: corsHeaders(request, corsOptions),
+            status: 202
+          });
+        }
+        for (const message of messages) {
+          if (isJSONRPCRequest(message)) {
+            requestIds.add(message.id);
+          }
+          ws.send(JSON.stringify(message));
+        }
+        return new Response(readable, {
+          headers: {
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Content-Type": "text/event-stream",
+            "mcp-session-id": sessionId,
+            ...corsHeaders(request, corsOptions)
+          },
+          status: 200
+        });
+      } else if (request.method === "GET") {
+        const acceptHeader = request.headers.get("accept");
+        if (!acceptHeader?.includes("text/event-stream")) {
+          const body2 = JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Not Acceptable: Client must accept text/event-stream"
+            },
+            id: null
+          });
+          return new Response(body2, { status: 406 });
+        }
+        const sessionId = url.searchParams.get("sessionId");
+        if (!sessionId)
+          return new Response("Missing sessionId", { status: 400 });
+        const { readable, writable } = new TransformStream();
+        const writer = writable.getWriter();
+        const encoder = new TextEncoder();
+        const agent = await getAgentByName(
+          namespace,
+          `streamable-http:${sessionId}`,
+          { props: ctx.props }
+        );
+        const isInitialized = await agent.isInitialized();
+        if (!isInitialized) {
+          return new Response(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              error: { code: -32001, message: "Session not found" },
+              id: null
+            }),
+            { status: 404 }
+          );
+        }
+        const existingHeaders = {};
+        request.headers.forEach((v, k) => {
+          existingHeaders[k] = v;
+        });
+        if (ctx.props) agent.updateProps(ctx.props);
+        const response = await agent.fetch(
+          new Request(request.url, {
+            headers: {
+              ...existingHeaders,
+              Upgrade: "websocket"
+            }
+          })
+        );
+        const ws = response.webSocket;
+        if (!ws) {
+          await writer.close();
+          return new Response("Failed to establish WS to DO", {
+            status: 500
+          });
+        }
+        ws.accept();
+        ws.send(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            method: STANDALONE_SSE_METHOD,
+            params: {}
+          })
+        );
+        ws.addEventListener("message", (event) => {
+          try {
+            async function onMessage(ev) {
+              const data = typeof ev.data === "string" ? ev.data : new TextDecoder().decode(ev.data);
+              const parsed = JSONRPCMessageSchema.safeParse(JSON.parse(data));
+              if (!parsed.success) return;
+              const frame = `event: message
+data: ${JSON.stringify(parsed.data)}
+
+`;
+              await writer.write(encoder.encode(frame));
+            }
+            onMessage(event).catch(console.error);
+          } catch (e) {
+            console.error("Error forwarding message to SSE:", e);
+          }
+        });
+        ws.addEventListener("error", () => {
+          writer.close().catch(() => {
+          });
+        });
+        ws.addEventListener("close", () => {
+          writer.close().catch(() => {
+          });
+        });
+        return new Response(readable, {
+          headers: {
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Content-Type": "text/event-stream",
+            "mcp-session-id": sessionId,
+            ...corsHeaders(request, corsOptions)
+          },
+          status: 200
+        });
+      } else if (request.method === "DELETE") {
+        const sessionId = request.headers.get("mcp-session-id");
+        if (!sessionId) {
+          return new Response(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              error: {
+                code: -32e3,
+                message: "Bad Request: Mcp-Session-Id header is required"
+              },
+              id: null
+            }),
+            { status: 400, headers: corsHeaders(request, corsOptions) }
+          );
+        }
+        const agent = await getAgentByName(
+          namespace,
+          `streamable-http:${sessionId}`
+        );
+        const isInitialized = await agent.isInitialized();
+        if (!isInitialized) {
+          return new Response(
+            JSON.stringify({
+              jsonrpc: "2.0",
+              error: { code: -32001, message: "Session not found" },
+              id: null
+            }),
+            { status: 404, headers: corsHeaders(request, corsOptions) }
+          );
+        }
+        ctx.waitUntil(
+          agent.destroy().catch(() => {
+          })
+        );
+        return new Response(null, {
+          status: 204,
+          headers: corsHeaders(request, corsOptions)
+        });
+      }
+    }
+    const body = JSON.stringify({
+      error: {
+        code: -32e3,
+        message: "Not found"
+      },
+      id: null,
+      jsonrpc: "2.0"
+    });
+    return new Response(body, { status: 404 });
+  };
+};
+var createLegacySseHandler = (basePath, namespace, corsOptions) => {
+  let pathname = basePath;
+  if (basePath === "/") pathname = "/*";
+  const basePattern = new URLPattern({ pathname });
+  const messagePattern = new URLPattern({ pathname: `${basePath}/message` });
+  return async (request, ctx) => {
+    const url = new URL(request.url);
+    if (request.method === "GET" && basePattern.test(url)) {
+      const sessionId = url.searchParams.get("sessionId") || namespace.newUniqueId().toString();
+      const { readable, writable } = new TransformStream();
+      const writer = writable.getWriter();
+      const encoder = new TextEncoder();
+      const endpointUrl = new URL(request.url);
+      endpointUrl.pathname = encodeURI(`${basePath}/message`);
+      endpointUrl.searchParams.set("sessionId", sessionId);
+      const relativeUrlWithSession = endpointUrl.pathname + endpointUrl.search + endpointUrl.hash;
+      const endpointMessage = `event: endpoint
+data: ${relativeUrlWithSession}
+
+`;
+      writer.write(encoder.encode(endpointMessage));
+      const agent = await getAgentByName(namespace, `sse:${sessionId}`, {
+        props: ctx.props
+      });
+      const existingHeaders = {};
+      request.headers.forEach((value, key) => {
+        existingHeaders[key] = value;
+      });
+      if (ctx.props) agent.updateProps(ctx.props);
+      const response = await agent.fetch(
+        new Request(request.url, {
+          headers: {
+            ...existingHeaders,
+            Upgrade: "websocket"
+          }
+        })
+      );
+      const ws = response.webSocket;
+      if (!ws) {
+        console.error("Failed to establish WebSocket connection");
+        await writer.close();
+        return new Response("Failed to establish WebSocket connection", {
+          status: 500
+        });
+      }
+      ws.accept();
+      ws.addEventListener("message", (event) => {
+        async function onMessage(event2) {
+          try {
+            const message = JSON.parse(event2.data);
+            const result = JSONRPCMessageSchema.safeParse(message);
+            if (!result.success) {
+              return;
+            }
+            const messageText = `event: message
+data: ${JSON.stringify(result.data)}
+
+`;
+            await writer.write(encoder.encode(messageText));
+          } catch (error) {
+            console.error("Error forwarding message to SSE:", error);
+          }
+        }
+        onMessage(event).catch(console.error);
+      });
+      ws.addEventListener("error", (error) => {
+        async function onError(_error) {
+          try {
+            await writer.close();
+          } catch (_e) {
+          }
+        }
+        onError(error).catch(console.error);
+      });
+      ws.addEventListener("close", () => {
+        async function onClose() {
+          try {
+            await writer.close();
+          } catch (error) {
+            console.error("Error closing SSE connection:", error);
+          }
+        }
+        onClose().catch(console.error);
+      });
+      return new Response(readable, {
+        headers: {
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+          "Content-Type": "text/event-stream",
+          ...corsHeaders(request, corsOptions)
+        }
+      });
+    }
+    if (request.method === "POST" && messagePattern.test(url)) {
+      const sessionId = url.searchParams.get("sessionId");
+      if (!sessionId) {
+        return new Response(
+          `Missing sessionId. Expected POST to ${basePath} to initiate new one`,
+          { status: 400 }
+        );
+      }
+      const contentType = request.headers.get("content-type") || "";
+      if (!contentType.includes("application/json")) {
+        return new Response(`Unsupported content-type: ${contentType}`, {
+          status: 400
+        });
+      }
+      const contentLength = Number.parseInt(
+        request.headers.get("content-length") || "0",
+        10
+      );
+      if (contentLength > MAXIMUM_MESSAGE_SIZE_BYTES) {
+        return new Response(`Request body too large: ${contentLength} bytes`, {
+          status: 400
+        });
+      }
+      const agent = await getAgentByName(namespace, `sse:${sessionId}`, {
+        props: ctx.props
+      });
+      const messageBody = await request.json();
+      const error = await agent.onSSEMcpMessage(sessionId, messageBody);
+      if (error) {
+        return new Response(error.message, {
+          headers: {
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Content-Type": "text/event-stream",
+            ...corsHeaders(request, corsOptions)
+          },
+          status: 400
+        });
+      }
+      return new Response("Accepted", {
+        headers: {
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+          "Content-Type": "text/event-stream",
+          ...corsHeaders(request, corsOptions)
+        },
+        status: 202
+      });
+    }
+    return new Response("Not Found", { status: 404 });
+  };
+};
 function corsHeaders(_request, corsOptions = {}) {
   const origin = "*";
   return {
-    "Access-Control-Allow-Headers": corsOptions.headers || "Content-Type, mcp-session-id, mcp-protocol-version",
-    "Access-Control-Allow-Methods": corsOptions.methods || "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": corsOptions.headers || "Content-Type, Accept, mcp-session-id, mcp-protocol-version",
+    "Access-Control-Allow-Methods": corsOptions.methods || "GET, POST, DELETE, OPTIONS",
     "Access-Control-Allow-Origin": corsOptions.origin || origin,
     "Access-Control-Expose-Headers": corsOptions.exposeHeaders || "mcp-session-id",
     "Access-Control-Max-Age": (corsOptions.maxAge || 86400).toString()
   };
 }
-function isDurableObjectNamespace(namespace) {
-  return typeof namespace === "object" && namespace !== null && "newUniqueId" in namespace && typeof namespace.newUniqueId === "function" && "idFromName" in namespace && typeof namespace.idFromName === "function";
-}
 function handleCORS(request, corsOptions) {
   if (request.method === "OPTIONS") {
     return new Response(null, { headers: corsHeaders(request, corsOptions) });
   }
   return null;
 }
+function isDurableObjectNamespace(namespace) {
+  return typeof namespace === "object" && namespace !== null && "newUniqueId" in namespace && typeof namespace.newUniqueId === "function" && "idFromName" in namespace && typeof namespace.idFromName === "function";
+}
+
+// src/mcp/transport.ts
+import {
+  isJSONRPCError as isJSONRPCError2,
+  isJSONRPCResponse as isJSONRPCResponse2
+} from "@modelcontextprotocol/sdk/types.js";
 var McpSSETransport = class {
   constructor(getWebSocket) {
     this._started = false;
@@ -65,7 +618,6 @@ var McpSSETransport = class {
       websocket.send(JSON.stringify(message));
     } catch (error) {
       this.onerror?.(error);
-      throw error;
     }
   }
   async close() {
@@ -73,11 +625,11 @@ var McpSSETransport = class {
   }
 };
 var McpStreamableHttpTransport = class {
-  constructor(getWebSocketForMessageID, notifyResponseIdSent) {
+  constructor(getWebSocketForMessageID, notifyResponseIdSent, getWebSocketForStandaloneSse) {
     this._started = false;
     this._getWebSocketForMessageID = getWebSocketForMessageID;
     this._notifyResponseIdSent = notifyResponseIdSent;
-    this._getWebSocketForGetRequest = () => null;
+    this._getWebSocketForStandaloneSse = getWebSocketForStandaloneSse;
   }
   async start() {
     if (this._started) {
@@ -85,255 +637,162 @@ var McpStreamableHttpTransport = class {
     }
     this._started = true;
   }
-  async send(message) {
+  async send(message, options) {
     if (!this._started) {
       throw new Error("Transport not started");
     }
-    let websocket = null;
-    if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
-      websocket = this._getWebSocketForMessageID(message.id.toString());
-      if (!websocket) {
+    let requestId = options?.relatedRequestId;
+    if (isJSONRPCResponse2(message) || isJSONRPCError2(message)) {
+      requestId = message.id;
+    }
+    if (requestId === void 0) {
+      if (isJSONRPCResponse2(message) || isJSONRPCError2(message)) {
         throw new Error(
-          `Could not find WebSocket for message id: ${message.id}`
+          "Cannot send a response on a standalone SSE stream unless resuming a previous client request"
         );
       }
-    } else if (isJSONRPCRequest(message)) {
-      websocket = this._getWebSocketForGetRequest();
-    } else if (isJSONRPCNotification(message)) {
-      websocket = null;
+      const standaloneSseSocket = this._getWebSocketForStandaloneSse();
+      if (!standaloneSseSocket) {
+        return;
+      }
+      try {
+        standaloneSseSocket?.send(JSON.stringify(message));
+      } catch (error) {
+        this.onerror?.(error);
+      }
+      return;
+    }
+    const websocket = this._getWebSocketForMessageID(requestId.toString());
+    if (!websocket) {
+      throw new Error(`Could not find WebSocket for message id: ${requestId}`);
     }
     try {
       websocket?.send(JSON.stringify(message));
-      if (isJSONRPCResponse(message)) {
+      if (isJSONRPCResponse2(message) || isJSONRPCError2(message)) {
         this._notifyResponseIdSent(message.id.toString());
       }
     } catch (error) {
       this.onerror?.(error);
-      throw error;
     }
   }
   async close() {
     this.onclose?.();
   }
 };
-var McpAgent = class _McpAgent extends DurableObject {
+
+// src/mcp/index.ts
+import {
+  ElicitRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var McpAgent = class _McpAgent extends Agent {
   constructor(ctx, env) {
-    var _a;
     super(ctx, env);
-    this._status = "zero";
-    this._transportType = "unset";
     this._requestIdToConnectionId = /* @__PURE__ */ new Map();
-    this.initRun = false;
-    const self = this;
-    this._agent = new (_a = class extends Agent {
-      onStateUpdate(state, source) {
-        return self.onStateUpdate(state, source);
-      }
-      async onMessage(connection, message) {
-        return self.onMessage(connection, message);
+    for (const connection of this.getConnections()) {
+      const meta = connection.state;
+      if (meta?.role === STANDALONE_SSE_MARKER) {
+        this._standaloneSseConnectionId = connection.id;
+        return;
       }
-    }, _a.options = {
-      hibernate: true
-    }, _a)(ctx, env);
-  }
-  get mcp() {
-    return this._agent.mcp;
-  }
-  get state() {
-    return this._agent.state;
+    }
   }
-  sql(strings, ...values) {
-    return this._agent.sql(strings, ...values);
+  /*
+   * Helpers
+   */
+  async setInitialized() {
+    await this.ctx.storage.put("initialized", true);
   }
-  setState(state) {
-    return this._agent.setState(state);
+  async isInitialized() {
+    return await this.ctx.storage.get("initialized") === true;
   }
-  /**
-   * Elicit user input with a message and schema
+  /** Read the transport type for this agent.
+   * This relies on the naming scheme being `sse:${sessionId}`
+   * or `streamable-http:${sessionId}`.
    */
-  async elicitInput(params) {
-    const requestId = `elicit_${Math.random().toString(36).substring(2, 11)}`;
-    await this.ctx.storage.put(`elicitation:${requestId}`, {
-      message: params.message,
-      requestedSchema: params.requestedSchema,
-      timestamp: Date.now()
-    });
-    const elicitRequest = {
-      jsonrpc: "2.0",
-      id: requestId,
-      method: "elicitation/create",
-      params: {
-        message: params.message,
-        requestedSchema: params.requestedSchema
-      }
-    };
-    if (this._transport) {
-      await this._transport.send(elicitRequest);
-    } else {
-      const connections = this._agent?.getConnections();
-      if (!connections || Array.from(connections).length === 0) {
-        await this.ctx.storage.delete(`elicitation:${requestId}`);
-        throw new Error("No active connections available for elicitation");
-      }
-      const connectionList = Array.from(connections);
-      for (const connection of connectionList) {
-        try {
-          connection.send(JSON.stringify(elicitRequest));
-        } catch (error) {
-          console.error("Failed to send elicitation request:", error);
-        }
-      }
+  getTransportType() {
+    const [t, ..._] = this.name.split(":");
+    switch (t) {
+      case "sse":
+        return "sse";
+      case "streamable-http":
+        return "streamable-http";
+      default:
+        throw new Error(
+          "Invalid transport type. McpAgent must be addressed with a valid protocol."
+        );
     }
-    return this._waitForElicitationResponse(requestId);
   }
-  // we leave the variables as unused for autocomplete purposes
-  // biome-ignore lint/correctness/noUnusedFunctionParameters: overriden later
-  onStateUpdate(state, source) {
+  /** Get the WebSocket for the standalone SSE if any. Streamable HTTP only. */
+  getWebSocketForStandaloneSse() {
+    if (!this._standaloneSseConnectionId) return null;
+    return this.getConnection(this._standaloneSseConnectionId) ?? null;
   }
-  async onStart() {
-    var _a;
-    const self = this;
-    this._agent = new (_a = class extends Agent {
-      constructor() {
-        super(...arguments);
-        this.initialState = self.initialState;
-      }
-      onStateUpdate(state, source) {
-        return self.onStateUpdate(state, source);
-      }
-      async onMessage(connection, event) {
-        return self.onMessage(connection, event);
-      }
-    }, _a.options = {
-      hibernate: true
-    }, _a)(this.ctx, this.env);
-    this.props = await this.ctx.storage.get("props");
-    this._transportType = await this.ctx.storage.get(
-      "transportType"
-    );
-    await this._init(this.props);
-    const server = await this.server;
-    if (this._transportType === "sse") {
-      this._transport = new McpSSETransport(() => this.getWebSocket());
-      await server.connect(this._transport);
-    } else if (this._transportType === "streamable-http") {
-      this._transport = new McpStreamableHttpTransport(
-        (id) => this.getWebSocketForResponseID(id),
-        (id) => this._requestIdToConnectionId.delete(id)
-      );
-      await server.connect(this._transport);
+  /** Get the unique WebSocket. SSE transport only. */
+  getWebSocket() {
+    const websockets = Array.from(this.getConnections());
+    if (websockets.length === 0) {
+      return null;
     }
+    return websockets[0];
   }
-  /**
-   * Handle errors that occur during initialization or operation.
-   * Override this method to provide custom error handling.
-   * @param error - The error that occurred
-   * @returns An error response object with status code and message
-   */
-  onError(error) {
-    console.error("McpAgent error:", error);
-    return {
-      status: 500,
-      message: error.message || "An unexpected error occurred during initialization"
-    };
-  }
-  async _init(props) {
-    await this.updateProps(props);
-    if (!this.ctx.storage.get("transportType")) {
-      await this.ctx.storage.put("transportType", "unset");
+  /** Get the corresponding WebSocket for a responseId. Streamable HTTP only. */
+  getWebSocketForResponseID(id) {
+    const connectionId = this._requestIdToConnectionId.get(id);
+    if (connectionId === void 0) {
+      return null;
     }
-    if (!this.initRun) {
-      this.initRun = true;
-      try {
-        await this.init();
-      } catch (error) {
-        const errorResponse = this.onError(error);
-        throw new Error(`Initialization failed: ${errorResponse.message}`);
+    return this.getConnection(connectionId) ?? null;
+  }
+  /** Returns a new transport matching the type of the Agent. */
+  initTransport() {
+    switch (this.getTransportType()) {
+      case "sse": {
+        return new McpSSETransport(() => this.getWebSocket());
+      }
+      case "streamable-http": {
+        return new McpStreamableHttpTransport(
+          (id) => this.getWebSocketForResponseID(id),
+          (id) => this._requestIdToConnectionId.delete(id),
+          () => this.getWebSocketForStandaloneSse()
+        );
       }
     }
   }
-  async setInitialized() {
-    await this.ctx.storage.put("initialized", true);
-  }
-  async isInitialized() {
-    return await this.ctx.storage.get("initialized") === true;
-  }
+  /** Update and store the props */
   async updateProps(props) {
     await this.ctx.storage.put("props", props ?? {});
     this.props = props;
   }
-  async _initialize() {
-    await this.ctx.blockConcurrencyWhile(async () => {
-      this._status = "starting";
-      await this.onStart();
-      this._status = "started";
-    });
-  }
-  // Allow the worker to fetch a websocket connection to the agent
-  async fetch(request) {
-    if (this._status !== "started") {
-      await this._initialize();
-    }
-    if (request.headers.get("Upgrade") !== "websocket") {
-      return new Response("Expected WebSocket Upgrade request", {
-        status: 400
-      });
-    }
-    const url = new URL(request.url);
-    const path = url.pathname;
+  /*
+   * Base Agent / Parykit Server overrides
+   */
+  /** Sets up the MCP transport and server every time the Agent is started.*/
+  async onStart(props) {
+    if (props) await this.updateProps(props);
+    this.props = await this.ctx.storage.get("props");
+    await this.init();
     const server = await this.server;
-    switch (path) {
-      case "/sse": {
-        const websockets = this.ctx.getWebSockets();
-        if (websockets.length > 0) {
-          return new Response("Websocket already connected", { status: 400 });
-        }
-        await this.ctx.storage.put("transportType", "sse");
-        this._transportType = "sse";
-        if (!this._transport) {
-          this._transport = new McpSSETransport(() => this.getWebSocket());
-          await server.connect(this._transport);
-        }
-        return this._agent.fetch(request);
-      }
-      case "/streamable-http": {
-        if (!this._transport) {
-          this._transport = new McpStreamableHttpTransport(
-            (id) => this.getWebSocketForResponseID(id),
-            (id) => this._requestIdToConnectionId.delete(id)
-          );
-          await server.connect(this._transport);
+    this._transport = this.initTransport();
+    await server.connect(this._transport);
+  }
+  /** Validates new WebSocket connections. */
+  async onConnect(conn, _) {
+    switch (this.getTransportType()) {
+      case "sse": {
+        const websockets = Array.from(this.getConnections());
+        if (websockets.length > 1) {
+          conn.close(1008, "Websocket already connected");
+          return;
         }
-        await this.ctx.storage.put("transportType", "streamable-http");
-        this._transportType = "streamable-http";
-        return this._agent.fetch(request);
+        break;
       }
-      default:
-        return new Response(
-          "Internal Server Error: Expected /sse or /streamable-http path",
-          {
-            status: 500
-          }
-        );
-    }
-  }
-  getWebSocket() {
-    const websockets = this.ctx.getWebSockets();
-    if (websockets.length === 0) {
-      return null;
+      case "streamable-http":
+        break;
     }
-    return websockets[0];
   }
-  getWebSocketForResponseID(id) {
-    const connectionId = this._requestIdToConnectionId.get(id);
-    if (connectionId === void 0) {
-      return null;
-    }
-    return this._agent.getConnection(connectionId) ?? null;
-  }
-  // All messages received here. This is currently never called
+  /** Handles MCP Messages for Streamable HTTP. */
   async onMessage(connection, event) {
-    if (this._transportType !== "streamable-http") {
+    if (this.getTransportType() !== "streamable-http") {
       const err = new Error(
         "Internal Server Error: Expected streamable-http protocol"
       );
@@ -343,22 +802,105 @@ var McpAgent = class _McpAgent extends DurableObject {
     let message;
     try {
       const data = typeof event === "string" ? event : new TextDecoder().decode(event);
-      message = JSONRPCMessageSchema.parse(JSON.parse(data));
+      message = JSONRPCMessageSchema2.parse(JSON.parse(data));
     } catch (error) {
       this._transport?.onerror?.(error);
       return;
     }
+    if (isJSONRPCNotification2(message) && message.method === STANDALONE_SSE_METHOD) {
+      if (this._standaloneSseConnectionId && this._standaloneSseConnectionId !== connection.id) {
+        const standaloneSseSocket = this.getConnection(
+          this._standaloneSseConnectionId
+        );
+        standaloneSseSocket?.close(1e3, "replaced");
+      }
+      connection.setState({
+        role: STANDALONE_SSE_MARKER
+      });
+      this._standaloneSseConnectionId = connection.id;
+      return;
+    }
     if (await this._handleElicitationResponse(message)) {
       return;
     }
-    if (isJSONRPCRequest(message)) {
+    if (isJSONRPCRequest2(message)) {
       this._requestIdToConnectionId.set(message.id.toString(), connection.id);
     }
     this._transport?.onmessage?.(message);
   }
-  /**
-   * Wait for elicitation response through storage polling
+  /** Remove clients from our cache when they disconnect */
+  async onClose(conn, _code, _reason, _wasClean) {
+    for (const [reqId, connId] of this._requestIdToConnectionId) {
+      if (connId === conn.id) this._requestIdToConnectionId.delete(reqId);
+    }
+    if (this._standaloneSseConnectionId === conn.id) {
+      this._standaloneSseConnectionId = void 0;
+    }
+  }
+  /*
+   * Transport ingress and routing
    */
+  /** Handles MCP Messages for the legacy SSE transport. */
+  async onSSEMcpMessage(_sessionId, messageBody) {
+    if (this.getTransportType() !== "sse") {
+      return new Error("Internal Server Error: Expected SSE transport");
+    }
+    try {
+      let parsedMessage;
+      try {
+        parsedMessage = JSONRPCMessageSchema2.parse(messageBody);
+      } catch (error) {
+        this._transport?.onerror?.(error);
+        throw error;
+      }
+      if (await this._handleElicitationResponse(parsedMessage)) {
+        return null;
+      }
+      this._transport?.onmessage?.(parsedMessage);
+      return null;
+    } catch (error) {
+      console.error("Error forwarding message to SSE:", error);
+      this._transport?.onerror?.(error);
+      return error;
+    }
+  }
+  /** Elicit user input with a message and schema */
+  async elicitInput(params) {
+    const requestId = `elicit_${Math.random().toString(36).substring(2, 11)}`;
+    await this.ctx.storage.put(`elicitation:${requestId}`, {
+      message: params.message,
+      requestedSchema: params.requestedSchema,
+      timestamp: Date.now()
+    });
+    const elicitRequest = {
+      jsonrpc: "2.0",
+      id: requestId,
+      method: "elicitation/create",
+      params: {
+        message: params.message,
+        requestedSchema: params.requestedSchema
+      }
+    };
+    if (this._transport) {
+      await this._transport.send(elicitRequest);
+    } else {
+      const connections = this.getConnections();
+      if (!connections || Array.from(connections).length === 0) {
+        await this.ctx.storage.delete(`elicitation:${requestId}`);
+        throw new Error("No active connections available for elicitation");
+      }
+      const connectionList = Array.from(connections);
+      for (const connection of connectionList) {
+        try {
+          connection.send(JSON.stringify(elicitRequest));
+        } catch (error) {
+          console.error("Failed to send elicitation request:", error);
+        }
+      }
+    }
+    return this._waitForElicitationResponse(requestId);
+  }
+  /** Wait for elicitation response through storage polling */
   async _waitForElicitationResponse(requestId) {
     const startTime = Date.now();
     const timeout = 6e4;
@@ -380,10 +922,9 @@ var McpAgent = class _McpAgent extends DurableObject {
       await this.ctx.storage.delete(`elicitation:response:${requestId}`);
     }
   }
-  /**
-   * Handle elicitation responses   */
+  /** Handle elicitation responses */
   async _handleElicitationResponse(message) {
-    if (isJSONRPCResponse(message) && message.result) {
+    if (isJSONRPCResponse3(message) && message.result) {
       const requestId = message.id?.toString();
       if (!requestId || !requestId.startsWith("elicit_")) return false;
       const pendingRequest = await this.ctx.storage.get(
@@ -396,7 +937,7 @@ var McpAgent = class _McpAgent extends DurableObject {
       );
       return true;
     }
-    if (isJSONRPCError(message)) {
+    if (isJSONRPCError3(message)) {
       const requestId = message.id?.toString();
       if (!requestId || !requestId.startsWith("elicit_")) return false;
       const pendingRequest = await this.ctx.storage.get(
@@ -417,535 +958,67 @@ var McpAgent = class _McpAgent extends DurableObject {
     }
     return false;
   }
-  // All messages received over SSE after the initial connection has been established
-  // will be passed here
-  async onSSEMcpMessage(_sessionId, messageBody) {
-    if (this._status !== "started") {
-      await this._initialize();
-    }
-    if (this._transportType !== "sse") {
-      return new Error("Internal Server Error: Expected SSE protocol");
-    }
-    try {
-      let parsedMessage;
-      try {
-        parsedMessage = JSONRPCMessageSchema.parse(messageBody);
-      } catch (error) {
-        this._transport?.onerror?.(error);
-        throw error;
-      }
-      if (await this._handleElicitationResponse(parsedMessage)) {
-        return null;
-      }
-      this._transport?.onmessage?.(parsedMessage);
-      return null;
-    } catch (error) {
-      console.error("Error forwarding message to SSE:", error);
-      this._transport?.onerror?.(error);
-      return error;
-    }
-  }
-  // Delegate all websocket events to the underlying agent
-  async webSocketMessage(ws, event) {
-    if (this._status !== "started") {
-      await this._initialize();
-    }
-    return await this._agent.webSocketMessage(ws, event);
-  }
-  // WebSocket event handlers for hibernation support
-  async webSocketError(ws, error) {
-    if (this._status !== "started") {
-      await this._initialize();
-    }
-    return await this._agent.webSocketError(ws, error);
-  }
-  async webSocketClose(ws, code, reason, wasClean) {
-    if (this._status !== "started") {
-      await this._initialize();
-    }
-    return await this._agent.webSocketClose(ws, code, reason, wasClean);
-  }
-  static mount(path, {
-    binding = "MCP_OBJECT",
-    corsOptions
-  } = {}) {
-    return _McpAgent.serveSSE(path, { binding, corsOptions });
-  }
-  static serveSSE(path, {
-    binding = "MCP_OBJECT",
-    corsOptions
-  } = {}) {
-    let pathname = path;
-    if (path === "/") {
-      pathname = "/*";
-    }
-    const basePattern = new URLPattern({ pathname });
-    const messagePattern = new URLPattern({ pathname: `${pathname}/message` });
-    return {
-      async fetch(request, env, ctx) {
-        const corsResponse = handleCORS(request, corsOptions);
-        if (corsResponse) return corsResponse;
-        const url = new URL(request.url);
-        const bindingValue = env[binding];
-        if (bindingValue == null || typeof bindingValue !== "object") {
-          console.error(
-            `Could not find McpAgent binding for ${binding}. Did you update your wrangler configuration?`
-          );
-          return new Response("Invalid binding", { status: 500 });
-        }
-        if (!isDurableObjectNamespace(bindingValue)) {
-          return new Response("Invalid binding", { status: 500 });
-        }
-        const namespace = bindingValue;
-        if (request.method === "GET" && basePattern.test(url)) {
-          const sessionId = url.searchParams.get("sessionId") || namespace.newUniqueId().toString();
-          const { readable, writable } = new TransformStream();
-          const writer = writable.getWriter();
-          const encoder = new TextEncoder();
-          const endpointUrl = new URL(request.url);
-          endpointUrl.pathname = encodeURI(`${pathname}/message`);
-          endpointUrl.searchParams.set("sessionId", sessionId);
-          const relativeUrlWithSession = endpointUrl.pathname + endpointUrl.search + endpointUrl.hash;
-          const endpointMessage = `event: endpoint
-data: ${relativeUrlWithSession}
-
-`;
-          writer.write(encoder.encode(endpointMessage));
-          const id = namespace.idFromName(`sse:${sessionId}`);
-          const doStub = namespace.get(id);
-          try {
-            await doStub._init(ctx.props);
-          } catch (error) {
-            console.error("Failed to initialize McpAgent:", error);
-            await writer.close();
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return new Response(`Initialization failed: ${errorMessage}`, {
-              status: 500
-            });
-          }
-          const upgradeUrl = new URL(request.url);
-          upgradeUrl.pathname = "/sse";
-          const existingHeaders = {};
-          request.headers.forEach((value, key) => {
-            existingHeaders[key] = value;
-          });
-          const response = await doStub.fetch(
-            new Request(upgradeUrl, {
-              headers: {
-                ...existingHeaders,
-                Upgrade: "websocket",
-                // Required by PartyServer
-                "x-partykit-room": sessionId
-              }
-            })
-          );
-          const ws = response.webSocket;
-          if (!ws) {
-            console.error("Failed to establish WebSocket connection");
-            await writer.close();
-            return new Response("Failed to establish WebSocket connection", {
-              status: 500
-            });
-          }
-          ws.accept();
-          ws.addEventListener("message", (event) => {
-            async function onMessage(event2) {
-              try {
-                const message = JSON.parse(event2.data);
-                const result = JSONRPCMessageSchema.safeParse(message);
-                if (!result.success) {
-                  return;
-                }
-                const messageText = `event: message
-data: ${JSON.stringify(result.data)}
-
-`;
-                await writer.write(encoder.encode(messageText));
-              } catch (error) {
-                console.error("Error forwarding message to SSE:", error);
-              }
-            }
-            onMessage(event).catch(console.error);
-          });
-          ws.addEventListener("error", (error) => {
-            async function onError(_error) {
-              try {
-                await writer.close();
-              } catch (_e) {
-              }
-            }
-            onError(error).catch(console.error);
-          });
-          ws.addEventListener("close", () => {
-            async function onClose() {
-              try {
-                await writer.close();
-              } catch (error) {
-                console.error("Error closing SSE connection:", error);
-              }
-            }
-            onClose().catch(console.error);
-          });
-          return new Response(readable, {
-            headers: {
-              "Cache-Control": "no-cache",
-              Connection: "keep-alive",
-              "Content-Type": "text/event-stream",
-              ...corsHeaders(request, corsOptions)
-            }
-          });
-        }
-        if (request.method === "POST" && messagePattern.test(url)) {
-          const sessionId = url.searchParams.get("sessionId");
-          if (!sessionId) {
-            return new Response(
-              `Missing sessionId. Expected POST to ${pathname} to initiate new one`,
-              { status: 400 }
-            );
-          }
-          const contentType = request.headers.get("content-type") || "";
-          if (!contentType.includes("application/json")) {
-            return new Response(`Unsupported content-type: ${contentType}`, {
-              status: 400
-            });
-          }
-          const contentLength = Number.parseInt(
-            request.headers.get("content-length") || "0",
-            10
-          );
-          if (contentLength > MAXIMUM_MESSAGE_SIZE_BYTES) {
-            return new Response(
-              `Request body too large: ${contentLength} bytes`,
-              {
-                status: 400
-              }
-            );
-          }
-          const id = namespace.idFromName(`sse:${sessionId}`);
-          const doStub = namespace.get(id);
-          const messageBody = await request.json();
-          await doStub.updateProps(ctx.props);
-          const error = await doStub.onSSEMcpMessage(sessionId, messageBody);
-          if (error) {
-            return new Response(error.message, {
-              headers: {
-                "Cache-Control": "no-cache",
-                Connection: "keep-alive",
-                "Content-Type": "text/event-stream",
-                ...corsHeaders(request, corsOptions)
-              },
-              status: 400
-            });
-          }
-          return new Response("Accepted", {
-            headers: {
-              "Cache-Control": "no-cache",
-              Connection: "keep-alive",
-              "Content-Type": "text/event-stream",
-              ...corsHeaders(request, corsOptions)
-            },
-            status: 202
-          });
-        }
-        return new Response("Not Found", { status: 404 });
-      }
-    };
-  }
+  /** Return a handler for the given path for this MCP.
+   * Defaults to Streamable HTTP transport.
+   */
   static serve(path, {
     binding = "MCP_OBJECT",
-    corsOptions
+    corsOptions,
+    transport = "streamable-http"
   } = {}) {
-    let pathname = path;
-    if (path === "/") {
-      pathname = "/*";
-    }
-    const basePattern = new URLPattern({ pathname });
     return {
       async fetch(request, env, ctx) {
         const corsResponse = handleCORS(request, corsOptions);
         if (corsResponse) {
           return corsResponse;
         }
-        const url = new URL(request.url);
         const bindingValue = env[binding];
         if (bindingValue == null || typeof bindingValue !== "object") {
-          console.error(
+          throw new Error(
             `Could not find McpAgent binding for ${binding}. Did you update your wrangler configuration?`
           );
-          return new Response("Invalid binding", { status: 500 });
         }
         if (!isDurableObjectNamespace(bindingValue)) {
-          return new Response("Invalid binding", { status: 500 });
+          throw new Error(
+            `Invalid McpAgent binding for ${binding}. Make sure it's a Durable Object binding.`
+          );
         }
         const namespace = bindingValue;
-        if (request.method === "POST" && basePattern.test(url)) {
-          const acceptHeader = request.headers.get("accept");
-          if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
-            const body2 = JSON.stringify({
-              error: {
-                code: -32e3,
-                message: "Not Acceptable: Client must accept both application/json and text/event-stream"
-              },
-              id: null,
-              jsonrpc: "2.0"
-            });
-            return new Response(body2, { status: 406 });
-          }
-          const ct = request.headers.get("content-type");
-          if (!ct || !ct.includes("application/json")) {
-            const body2 = JSON.stringify({
-              error: {
-                code: -32e3,
-                message: "Unsupported Media Type: Content-Type must be application/json"
-              },
-              id: null,
-              jsonrpc: "2.0"
-            });
-            return new Response(body2, { status: 415 });
-          }
-          const contentLength = Number.parseInt(
-            request.headers.get("content-length") ?? "0",
-            10
-          );
-          if (contentLength > MAXIMUM_MESSAGE_SIZE_BYTES) {
-            const body2 = JSON.stringify({
-              error: {
-                code: -32e3,
-                message: `Request body too large. Maximum size is ${MAXIMUM_MESSAGE_SIZE_BYTES} bytes`
-              },
-              id: null,
-              jsonrpc: "2.0"
-            });
-            return new Response(body2, { status: 413 });
-          }
-          let sessionId = request.headers.get("mcp-session-id");
-          let rawMessage;
-          try {
-            rawMessage = await request.json();
-          } catch (_error) {
-            const body2 = JSON.stringify({
-              error: {
-                code: -32700,
-                message: "Parse error: Invalid JSON"
-              },
-              id: null,
-              jsonrpc: "2.0"
-            });
-            return new Response(body2, { status: 400 });
-          }
-          let arrayMessage;
-          if (Array.isArray(rawMessage)) {
-            arrayMessage = rawMessage;
-          } else {
-            arrayMessage = [rawMessage];
-          }
-          let messages = [];
-          for (const msg of arrayMessage) {
-            if (!JSONRPCMessageSchema.safeParse(msg).success) {
-              const body2 = JSON.stringify({
-                error: {
-                  code: -32700,
-                  message: "Parse error: Invalid JSON-RPC message"
-                },
-                id: null,
-                jsonrpc: "2.0"
-              });
-              return new Response(body2, { status: 400 });
-            }
-          }
-          messages = arrayMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
-          const isInitializationRequest = messages.some(
-            (msg) => InitializeRequestSchema.safeParse(msg).success
-          );
-          if (isInitializationRequest && sessionId) {
-            const body2 = JSON.stringify({
-              error: {
-                code: -32600,
-                message: "Invalid Request: Initialization requests must not include a sessionId"
-              },
-              id: null,
-              jsonrpc: "2.0"
-            });
-            return new Response(body2, { status: 400 });
-          }
-          if (isInitializationRequest && messages.length > 1) {
-            const body2 = JSON.stringify({
-              error: {
-                code: -32600,
-                message: "Invalid Request: Only one initialization request is allowed"
-              },
-              id: null,
-              jsonrpc: "2.0"
-            });
-            return new Response(body2, { status: 400 });
-          }
-          if (!isInitializationRequest && !sessionId) {
-            const body2 = JSON.stringify({
-              error: {
-                code: -32e3,
-                message: "Bad Request: Mcp-Session-Id header is required"
-              },
-              id: null,
-              jsonrpc: "2.0"
-            });
-            return new Response(body2, { status: 400 });
-          }
-          sessionId = sessionId ?? namespace.newUniqueId().toString();
-          const id = namespace.idFromName(`streamable-http:${sessionId}`);
-          const doStub = namespace.get(id);
-          const isInitialized = await doStub.isInitialized();
-          if (isInitializationRequest) {
-            try {
-              await doStub._init(ctx.props);
-              await doStub.setInitialized();
-            } catch (error) {
-              console.error("Failed to initialize McpAgent:", error);
-              const errorMessage = error instanceof Error ? error.message : String(error);
-              const body2 = JSON.stringify({
-                error: {
-                  code: -32001,
-                  message: `Initialization failed: ${errorMessage}`
-                },
-                id: null,
-                jsonrpc: "2.0"
-              });
-              return new Response(body2, { status: 500 });
-            }
-          } else if (!isInitialized) {
-            const body2 = JSON.stringify({
-              error: {
-                code: -32001,
-                message: "Session not found"
-              },
-              id: null,
-              jsonrpc: "2.0"
-            });
-            return new Response(body2, { status: 404 });
-          } else {
-            await doStub.updateProps(ctx.props);
-          }
-          const { readable, writable } = new TransformStream();
-          const writer = writable.getWriter();
-          const encoder = new TextEncoder();
-          const upgradeUrl = new URL(request.url);
-          upgradeUrl.pathname = "/streamable-http";
-          const existingHeaders = {};
-          request.headers.forEach((value, key) => {
-            existingHeaders[key] = value;
-          });
-          const response = await doStub.fetch(
-            new Request(upgradeUrl, {
-              headers: {
-                ...existingHeaders,
-                Upgrade: "websocket",
-                // Required by PartyServer
-                "x-partykit-room": sessionId
-              }
-            })
-          );
-          const ws = response.webSocket;
-          if (!ws) {
-            console.error("Failed to establish WebSocket connection");
-            await writer.close();
-            const body2 = JSON.stringify({
-              error: {
-                code: -32001,
-                message: "Failed to establish WebSocket connection"
-              },
-              id: null,
-              jsonrpc: "2.0"
-            });
-            return new Response(body2, { status: 500 });
-          }
-          const requestIds = /* @__PURE__ */ new Set();
-          ws.accept();
-          ws.addEventListener("message", (event) => {
-            async function onMessage(event2) {
-              try {
-                const data = typeof event2.data === "string" ? event2.data : new TextDecoder().decode(event2.data);
-                const message = JSON.parse(data);
-                const result = JSONRPCMessageSchema.safeParse(message);
-                if (!result.success) {
-                  return;
-                }
-                if (isJSONRPCResponse(result.data) || isJSONRPCError(result.data)) {
-                  requestIds.delete(result.data.id);
-                }
-                const messageText = `event: message
-data: ${JSON.stringify(result.data)}
-
-`;
-                await writer.write(encoder.encode(messageText));
-                if (requestIds.size === 0) {
-                  ws.close();
-                }
-              } catch (error) {
-                console.error("Error forwarding message to SSE:", error);
-              }
-            }
-            onMessage(event).catch(console.error);
-          });
-          ws.addEventListener("error", (error) => {
-            async function onError(_error) {
-              try {
-                await writer.close();
-              } catch (_e) {
-              }
-            }
-            onError(error).catch(console.error);
-          });
-          ws.addEventListener("close", () => {
-            async function onClose() {
-              try {
-                await writer.close();
-              } catch (error) {
-                console.error("Error closing SSE connection:", error);
-              }
-            }
-            onClose().catch(console.error);
-          });
-          const hasOnlyNotificationsOrResponses = messages.every(
-            (msg) => isJSONRPCNotification(msg) || isJSONRPCResponse(msg)
-          );
-          if (hasOnlyNotificationsOrResponses) {
-            for (const message of messages) {
-              ws.send(JSON.stringify(message));
-            }
-            ws.close();
-            return new Response(null, {
-              headers: corsHeaders(request, corsOptions),
-              status: 202
-            });
+        switch (transport) {
+          case "streamable-http": {
+            const handleStreamableHttp = createStreamingHttpHandler(
+              path,
+              namespace,
+              corsOptions
+            );
+            return handleStreamableHttp(request, ctx);
           }
-          for (const message of messages) {
-            if (isJSONRPCRequest(message)) {
-              requestIds.add(message.id);
-            }
-            ws.send(JSON.stringify(message));
+          case "sse": {
+            const handleLegacySse = createLegacySseHandler(
+              path,
+              namespace,
+              corsOptions
+            );
+            return handleLegacySse(request, ctx);
           }
-          return new Response(readable, {
-            headers: {
-              "Cache-Control": "no-cache",
-              Connection: "keep-alive",
-              "Content-Type": "text/event-stream",
-              "mcp-session-id": sessionId,
-              ...corsHeaders(request, corsOptions)
-            },
-            status: 200
-          });
+          default:
+            return new Response(
+              "Invalid MCP transport mode. Only `streamable-http` or `sse` are allowed.",
+              { status: 500 }
+            );
         }
-        const body = JSON.stringify({
-          error: {
-            code: -32e3,
-            message: "Method not allowed"
-          },
-          id: null,
-          jsonrpc: "2.0"
-        });
-        return new Response(body, { status: 405 });
       }
     };
   }
+  /**
+   * Legacy api
+   **/
+  static mount(path, opts = {}) {
+    return _McpAgent.serveSSE(path, opts);
+  }
+  static serveSSE(path, opts = {}) {
+    return _McpAgent.serve(path, { ...opts, transport: "sse" });
+  }
 };
 export {
   ElicitRequestSchema,