agents 0.0.0-d72c6a2 → 0.0.0-d7a460e

package/dist/mcp/index.js

@@ -1,1029 +1,1369 @@
-import {
-  Agent,
-  getAgentByName
-} from "../chunk-YDUDMOL6.js";
-import {
-  SSEEdgeClientTransport,
-  StreamableHTTPEdgeClientTransport
-} from "../chunk-MH46VMM4.js";
-import "../chunk-LL2AFX7V.js";
-import "../chunk-QEVM4BVL.js";
-import "../chunk-AVYJQSLW.js";
+import { t as MessageType } from "../ai-types-B3aQaFv3.js";
+import "../client-BfiZ3HQd.js";
+import { a as SSEEdgeClientTransport, i as StreamableHTTPEdgeClientTransport } from "../client-9Ld2_lnt.js";
+import "../do-oauth-client-provider-CswoD5Lu.js";
+import { c as getCurrentAgent, s as getAgentByName, t as Agent } from "../src-Dz0H9hSU.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { ElicitRequestSchema, InitializeRequestSchema, JSONRPCMessageSchema, isInitializeRequest, isJSONRPCError, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse } from "@modelcontextprotocol/sdk/types.js";
 
-// src/mcp/index.ts
-import {
-  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
-} 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 maybeInitializeRequest = messages.find(
-          (msg) => InitializeRequestSchema.safeParse(msg).success
-        );
-        if (!!maybeInitializeRequest && 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 (!!maybeInitializeRequest && 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 (!maybeInitializeRequest && !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.getInitializeRequest();
-        if (maybeInitializeRequest) {
-          await agent.setInitializeRequest(maybeInitializeRequest);
-        } 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(() => {
-                });
-              }
-            } catch (error) {
-              console.error("Error forwarding message to SSE:", error);
-            }
-          }
-          onMessage(event).catch(console.error);
-        });
-        ws.addEventListener("error", (error) => {
-          async function onError(_error) {
-            await writer.close().catch(() => {
-            });
-          }
-          onError(error).catch(console.error);
-        });
-        ws.addEventListener("close", () => {
-          async function onClose() {
-            await writer.close().catch(() => {
-            });
-          }
-          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 = request.headers.get("mcp-session-id");
-        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.getInitializeRequest();
-        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.getInitializeRequest();
-        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 });
-  };
+//#region src/mcp/utils.ts
+/**
+* Since we use WebSockets to bridge the client to the
+* MCP transport in the Agent, we use this header to signal
+* the method of the original request the user made, while
+* leaving the WS Upgrade request as GET.
+*/
+const MCP_HTTP_METHOD_HEADER = "cf-mcp-method";
+/**
+* Since we use WebSockets to bridge the client to the
+* MCP transport in the Agent, we use this header to include
+* the original request body.
+*/
+const MCP_MESSAGE_HEADER = "cf-mcp-message";
+const MAXIMUM_MESSAGE_SIZE_BYTES = 4 * 1024 * 1024;
+const createStreamingHttpHandler = (basePath, namespace, options = {}) => {
+	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 body$1 = 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(body$1, { status: 406 });
+				}
+				const ct = request.headers.get("content-type");
+				if (!ct || !ct.includes("application/json")) {
+					const body$1 = JSON.stringify({
+						error: {
+							code: -32e3,
+							message: "Unsupported Media Type: Content-Type must be application/json"
+						},
+						id: null,
+						jsonrpc: "2.0"
+					});
+					return new Response(body$1, { status: 415 });
+				}
+				if (Number.parseInt(request.headers.get("content-length") ?? "0", 10) > MAXIMUM_MESSAGE_SIZE_BYTES) {
+					const body$1 = 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(body$1, { status: 413 });
+				}
+				let sessionId = request.headers.get("mcp-session-id");
+				let rawMessage;
+				try {
+					rawMessage = await request.json();
+				} catch (_error) {
+					const body$1 = JSON.stringify({
+						error: {
+							code: -32700,
+							message: "Parse error: Invalid JSON"
+						},
+						id: null,
+						jsonrpc: "2.0"
+					});
+					return new Response(body$1, { 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 body$1 = JSON.stringify({
+						error: {
+							code: -32700,
+							message: "Parse error: Invalid JSON-RPC message"
+						},
+						id: null,
+						jsonrpc: "2.0"
+					});
+					return new Response(body$1, { status: 400 });
+				}
+				messages = arrayMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
+				const maybeInitializeRequest = messages.find((msg) => InitializeRequestSchema.safeParse(msg).success);
+				if (!!maybeInitializeRequest && sessionId) {
+					const body$1 = JSON.stringify({
+						error: {
+							code: -32600,
+							message: "Invalid Request: Initialization requests must not include a sessionId"
+						},
+						id: null,
+						jsonrpc: "2.0"
+					});
+					return new Response(body$1, { status: 400 });
+				}
+				if (!!maybeInitializeRequest && messages.length > 1) {
+					const body$1 = JSON.stringify({
+						error: {
+							code: -32600,
+							message: "Invalid Request: Only one initialization request is allowed"
+						},
+						id: null,
+						jsonrpc: "2.0"
+					});
+					return new Response(body$1, { status: 400 });
+				}
+				if (!maybeInitializeRequest && !sessionId) {
+					const body$1 = JSON.stringify({
+						error: {
+							code: -32e3,
+							message: "Bad Request: Mcp-Session-Id header is required"
+						},
+						id: null,
+						jsonrpc: "2.0"
+					});
+					return new Response(body$1, { status: 400 });
+				}
+				sessionId = sessionId ?? namespace.newUniqueId().toString();
+				const agent = await getAgentByName(namespace, `streamable-http:${sessionId}`, {
+					props: ctx.props,
+					jurisdiction: options.jurisdiction
+				});
+				const isInitialized = await agent.getInitializeRequest();
+				if (maybeInitializeRequest) await agent.setInitializeRequest(maybeInitializeRequest);
+				else if (!isInitialized) {
+					const body$1 = JSON.stringify({
+						error: {
+							code: -32001,
+							message: "Session not found"
+						},
+						id: null,
+						jsonrpc: "2.0"
+					});
+					return new Response(body$1, { 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,
+					[MCP_HTTP_METHOD_HEADER]: "POST",
+					[MCP_MESSAGE_HEADER]: Buffer.from(JSON.stringify(messages)).toString("base64"),
+					Upgrade: "websocket"
+				} });
+				if (ctx.props) agent.updateProps(ctx.props);
+				const ws = (await agent.fetch(req)).webSocket;
+				if (!ws) {
+					console.error("Failed to establish WebSocket connection");
+					await writer.close();
+					const body$1 = JSON.stringify({
+						error: {
+							code: -32001,
+							message: "Failed to establish WebSocket connection"
+						},
+						id: null,
+						jsonrpc: "2.0"
+					});
+					return new Response(body$1, { status: 500 });
+				}
+				ws.accept();
+				ws.addEventListener("message", (event) => {
+					async function onMessage(event$1) {
+						try {
+							const data = typeof event$1.data === "string" ? event$1.data : new TextDecoder().decode(event$1.data);
+							const message = JSON.parse(data);
+							if (message.type !== MessageType.CF_MCP_AGENT_EVENT) return;
+							await writer.write(encoder.encode(message.event));
+							if (message.close) {
+								ws?.close();
+								await writer.close().catch(() => {});
+							}
+						} catch (error) {
+							console.error("Error forwarding message to SSE:", error);
+						}
+					}
+					onMessage(event).catch(console.error);
+				});
+				ws.addEventListener("error", (error) => {
+					async function onError(_error) {
+						await writer.close().catch(() => {});
+					}
+					onError(error).catch(console.error);
+				});
+				ws.addEventListener("close", () => {
+					async function onClose() {
+						await writer.close().catch(() => {});
+					}
+					onClose().catch(console.error);
+				});
+				if (messages.every((msg) => isJSONRPCNotification(msg) || isJSONRPCResponse(msg))) {
+					ws.close();
+					return new Response(null, {
+						headers: corsHeaders(request, options.corsOptions),
+						status: 202
+					});
+				}
+				return new Response(readable, {
+					headers: {
+						"Cache-Control": "no-cache",
+						Connection: "keep-alive",
+						"Content-Type": "text/event-stream",
+						"mcp-session-id": sessionId,
+						...corsHeaders(request, options.corsOptions)
+					},
+					status: 200
+				});
+			} else if (request.method === "GET") {
+				if (!request.headers.get("accept")?.includes("text/event-stream")) {
+					const body$1 = JSON.stringify({
+						jsonrpc: "2.0",
+						error: {
+							code: -32e3,
+							message: "Not Acceptable: Client must accept text/event-stream"
+						},
+						id: null
+					});
+					return new Response(body$1, { status: 406 });
+				}
+				const sessionId = request.headers.get("mcp-session-id");
+				if (!sessionId) return new Response(JSON.stringify({
+					error: {
+						code: -32e3,
+						message: "Bad Request: Mcp-Session-Id header is required"
+					},
+					id: null,
+					jsonrpc: "2.0"
+				}), { 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,
+					jurisdiction: options.jurisdiction
+				});
+				if (!await agent.getInitializeRequest()) 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 ws = (await agent.fetch(new Request(request.url, { headers: {
+					...existingHeaders,
+					[MCP_HTTP_METHOD_HEADER]: "GET",
+					Upgrade: "websocket"
+				} }))).webSocket;
+				if (!ws) {
+					await writer.close();
+					return new Response("Failed to establish WS to DO", { status: 500 });
+				}
+				ws.accept();
+				ws.addEventListener("message", (event) => {
+					try {
+						async function onMessage(ev) {
+							const data = typeof ev.data === "string" ? ev.data : new TextDecoder().decode(ev.data);
+							const message = JSON.parse(data);
+							if (message.type !== MessageType.CF_MCP_AGENT_EVENT) return;
+							await writer.write(encoder.encode(message.event));
+						}
+						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, options.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, options.corsOptions)
+				});
+				const agent = await getAgentByName(namespace, `streamable-http:${sessionId}`, { jurisdiction: options.jurisdiction });
+				if (!await agent.getInitializeRequest()) return new Response(JSON.stringify({
+					jsonrpc: "2.0",
+					error: {
+						code: -32001,
+						message: "Session not found"
+					},
+					id: null
+				}), {
+					status: 404,
+					headers: corsHeaders(request, options.corsOptions)
+				});
+				ctx.waitUntil(agent.destroy().catch(() => {}));
+				return new Response(null, {
+					status: 204,
+					headers: corsHeaders(request, options.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 });
-  };
+const createLegacySseHandler = (basePath, namespace, options = {}) => {
+	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 endpointMessage = `event: endpoint\ndata: ${endpointUrl.pathname + endpointUrl.search + endpointUrl.hash}\n\n`;
+			writer.write(encoder.encode(endpointMessage));
+			const agent = await getAgentByName(namespace, `sse:${sessionId}`, {
+				props: ctx.props,
+				jurisdiction: options.jurisdiction
+			});
+			const existingHeaders = {};
+			request.headers.forEach((value, key) => {
+				existingHeaders[key] = value;
+			});
+			if (ctx.props) agent.updateProps(ctx.props);
+			const ws = (await agent.fetch(new Request(request.url, { headers: {
+				...existingHeaders,
+				Upgrade: "websocket"
+			} }))).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(event$1) {
+					try {
+						const message = JSON.parse(event$1.data);
+						const result = JSONRPCMessageSchema.safeParse(message);
+						if (!result.success) return;
+						const messageText = `event: message\ndata: ${JSON.stringify(result.data)}\n\n`;
+						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, options.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,
+				jurisdiction: options.jurisdiction
+			});
+			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, options.corsOptions)
+				},
+				status: 400
+			});
+			return new Response("Accepted", {
+				headers: {
+					"Cache-Control": "no-cache",
+					Connection: "keep-alive",
+					"Content-Type": "text/event-stream",
+					...corsHeaders(request, options.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, 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()
-  };
+	const origin = "*";
+	return {
+		"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 handleCORS(request, corsOptions) {
-  if (request.method === "OPTIONS") {
-    return new Response(null, { headers: corsHeaders(request, corsOptions) });
-  }
-  return null;
+	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";
+	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";
+//#endregion
+//#region src/mcp/transport.ts
 var McpSSETransport = class {
-  constructor(getWebSocket) {
-    this._started = false;
-    this._getWebSocket = getWebSocket;
-  }
-  async start() {
-    if (this._started) {
-      throw new Error("Transport already started");
-    }
-    this._started = true;
-  }
-  async send(message) {
-    if (!this._started) {
-      throw new Error("Transport not started");
-    }
-    const websocket = this._getWebSocket();
-    if (!websocket) {
-      throw new Error("WebSocket not connected");
-    }
-    try {
-      websocket.send(JSON.stringify(message));
-    } catch (error) {
-      this.onerror?.(error);
-    }
-  }
-  async close() {
-    this.onclose?.();
-  }
+	constructor(getWebSocket) {
+		this._started = false;
+		this._getWebSocket = getWebSocket;
+	}
+	async start() {
+		if (this._started) throw new Error("Transport already started");
+		this._started = true;
+	}
+	async send(message) {
+		if (!this._started) throw new Error("Transport not started");
+		const websocket = this._getWebSocket();
+		if (!websocket) throw new Error("WebSocket not connected");
+		try {
+			websocket.send(JSON.stringify(message));
+		} catch (error) {
+			this.onerror?.(error);
+		}
+	}
+	async close() {
+		this.onclose?.();
+	}
 };
-var McpStreamableHttpTransport = class {
-  constructor(getWebSocketForMessageID, notifyResponseIdSent, getWebSocketForStandaloneSse) {
-    this._started = false;
-    this._getWebSocketForMessageID = getWebSocketForMessageID;
-    this._notifyResponseIdSent = notifyResponseIdSent;
-    this._getWebSocketForStandaloneSse = getWebSocketForStandaloneSse;
-  }
-  async start() {
-    if (this._started) {
-      throw new Error("Transport already started");
-    }
-    this._started = true;
-  }
-  async send(message, options) {
-    if (!this._started) {
-      throw new Error("Transport not started");
-    }
-    let requestId = options?.relatedRequestId;
-    if (isJSONRPCResponse2(message) || isJSONRPCError2(message)) {
-      requestId = message.id;
-    }
-    if (requestId === void 0) {
-      if (isJSONRPCResponse2(message) || isJSONRPCError2(message)) {
-        throw new Error(
-          "Cannot send a response on a standalone SSE stream unless resuming a previous client request"
-        );
-      }
-      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 (isJSONRPCResponse2(message) || isJSONRPCError2(message)) {
-        this._notifyResponseIdSent(message.id.toString());
-      }
-    } catch (error) {
-      this.onerror?.(error);
-    }
-  }
-  async close() {
-    this.onclose?.();
-  }
+/**
+* Adapted from: https://github.com/modelcontextprotocol/typescript-sdk/blob/main/src/client/streamableHttp.ts
+* - Validation and initialization are removed as they're handled in `McpAgent.serve()` handler.
+* - Replaces the Node-style `req`/`res` with Worker's `Request`.
+* - Writes events as WS messages that the Worker forwards to the client as SSE events.
+* - Replaces the in-memory maps that track requestID/stream by using `connection.setState()` and `agent.getConnections()`.
+*
+* Besides these points, the implementation is the same and should be updated to match the original as new features are added.
+*/
+var StreamableHTTPServerTransport = class {
+	constructor(options) {
+		this._started = false;
+		this._requestResponseMap = /* @__PURE__ */ new Map();
+		const { agent } = getCurrentAgent();
+		if (!agent) throw new Error("McpAgent was not found in Transport constructor");
+		this.sessionId = agent.getSessionId();
+		this._eventStore = options.eventStore;
+	}
+	/**
+	* Starts the transport. This is required by the Transport interface but is a no-op
+	* for the Streamable HTTP transport as connections are managed per-request.
+	*/
+	async start() {
+		if (this._started) throw new Error("Transport already started");
+		this._started = true;
+	}
+	/**
+	* Handles GET requests for SSE stream
+	*/
+	async handleGetRequest(req) {
+		const { connection } = getCurrentAgent();
+		if (!connection) throw new Error("Connection was not found in handleGetRequest");
+		if (this._eventStore) {
+			const lastEventId = req.headers.get("last-event-id");
+			if (lastEventId) {
+				await this.replayEvents(lastEventId);
+				return;
+			}
+		}
+		connection.setState({ _standaloneSse: true });
+	}
+	/**
+	* Replays events that would have been sent after the specified event ID
+	* Only used when resumability is enabled
+	*/
+	async replayEvents(lastEventId) {
+		if (!this._eventStore) return;
+		const { connection } = getCurrentAgent();
+		if (!connection) throw new Error("Connection was not available in replayEvents");
+		try {
+			await this._eventStore?.replayEventsAfter(lastEventId, { send: async (eventId, message) => {
+				try {
+					this.writeSSEEvent(connection, message, eventId);
+				} catch (error) {
+					this.onerror?.(error);
+				}
+			} });
+		} catch (error) {
+			this.onerror?.(error);
+		}
+	}
+	/**
+	* Writes an event to the SSE stream with proper formatting
+	*/
+	writeSSEEvent(connection, message, eventId, close) {
+		let eventData = "event: message\n";
+		if (eventId) eventData += `id: ${eventId}\n`;
+		eventData += `data: ${JSON.stringify(message)}\n\n`;
+		return connection.send(JSON.stringify({
+			type: MessageType.CF_MCP_AGENT_EVENT,
+			event: eventData,
+			close
+		}));
+	}
+	/**
+	* Handles POST requests containing JSON-RPC messages
+	*/
+	async handlePostRequest(req, parsedBody) {
+		const authInfo = req.auth;
+		const requestInfo = { headers: Object.fromEntries(req.headers.entries()) };
+		delete requestInfo.headers[MCP_HTTP_METHOD_HEADER];
+		delete requestInfo.headers[MCP_MESSAGE_HEADER];
+		delete requestInfo.headers.upgrade;
+		const rawMessage = parsedBody;
+		let messages;
+		if (Array.isArray(rawMessage)) messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
+		else messages = [JSONRPCMessageSchema.parse(rawMessage)];
+		const hasRequests = messages.some(isJSONRPCRequest);
+		if (!hasRequests) for (const message of messages) this.onmessage?.(message, {
+			authInfo,
+			requestInfo
+		});
+		else if (hasRequests) {
+			const { connection } = getCurrentAgent();
+			if (!connection) throw new Error("Connection was not found in handlePostRequest");
+			const requestIds = messages.filter(isJSONRPCRequest).map((message) => message.id);
+			connection.setState({ requestIds });
+			for (const message of messages) this.onmessage?.(message, {
+				authInfo,
+				requestInfo
+			});
+		}
+	}
+	async close() {
+		const { agent } = getCurrentAgent();
+		if (!agent) throw new Error("Agent was not found in close");
+		for (const conn of agent.getConnections()) conn.close(1e3, "Session closed");
+		this.onclose?.();
+	}
+	async send(message, options) {
+		const { agent } = getCurrentAgent();
+		if (!agent) throw new Error("Agent was not found in send");
+		let requestId = options?.relatedRequestId;
+		if (isJSONRPCResponse(message) || isJSONRPCError(message)) requestId = message.id;
+		if (requestId === void 0) {
+			if (isJSONRPCResponse(message) || isJSONRPCError(message)) throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
+			let standaloneConnection;
+			for (const conn of agent.getConnections()) if (conn.state?._standaloneSse) standaloneConnection = conn;
+			if (standaloneConnection === void 0) return;
+			let eventId$1;
+			if (this._eventStore) eventId$1 = await this._eventStore.storeEvent(standaloneConnection.id, message);
+			this.writeSSEEvent(standaloneConnection, message, eventId$1);
+			return;
+		}
+		const connection = Array.from(agent.getConnections()).find((conn) => conn.state?.requestIds?.includes(requestId));
+		if (!connection) throw new Error(`No connection established for request ID: ${String(requestId)}`);
+		let eventId;
+		if (this._eventStore) eventId = await this._eventStore.storeEvent(connection.id, message);
+		let shouldClose = false;
+		if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+			this._requestResponseMap.set(requestId, message);
+			const relatedIds = connection.state?.requestIds ?? [];
+			shouldClose = relatedIds.every((id) => this._requestResponseMap.has(id));
+			if (shouldClose) for (const id of relatedIds) this._requestResponseMap.delete(id);
+		}
+		this.writeSSEEvent(connection, message, eventId, shouldClose);
+	}
 };
 
-// src/mcp/index.ts
-import {
-  ElicitRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-var McpAgent = class _McpAgent extends Agent {
-  constructor(ctx, env) {
-    super(ctx, env);
-    this._requestIdToConnectionId = /* @__PURE__ */ new Map();
-    for (const connection of this.getConnections()) {
-      const meta = connection.state;
-      if (meta?.role === STANDALONE_SSE_MARKER) {
-        this._standaloneSseConnectionId = connection.id;
-        return;
-      }
-    }
-  }
-  /*
-   * Helpers
-   */
-  async setInitializeRequest(initializeRequest) {
-    await this.ctx.storage.put("initializeRequest", initializeRequest);
-  }
-  async getInitializeRequest() {
-    return this.ctx.storage.get("initializeRequest");
-  }
-  /** Read the transport type for this agent.
-   * This relies on the naming scheme being `sse:${sessionId}`
-   * or `streamable-http:${sessionId}`.
-   */
-  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."
-        );
-    }
-  }
-  /** Get the WebSocket for the standalone SSE if any. Streamable HTTP only. */
-  getWebSocketForStandaloneSse() {
-    if (!this._standaloneSseConnectionId) return null;
-    return this.getConnection(this._standaloneSseConnectionId) ?? null;
-  }
-  /** Get the unique WebSocket. SSE transport only. */
-  getWebSocket() {
-    const websockets = Array.from(this.getConnections());
-    if (websockets.length === 0) {
-      return null;
-    }
-    return websockets[0];
-  }
-  /** Get the corresponding WebSocket for a responseId. Streamable HTTP only. */
-  getWebSocketForResponseID(id) {
-    const connectionId = this._requestIdToConnectionId.get(id);
-    if (connectionId === void 0) {
-      return null;
-    }
-    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()
-        );
-      }
-    }
-  }
-  /** Update and store the props */
-  async updateProps(props) {
-    await this.ctx.storage.put("props", props ?? {});
-    this.props = props;
-  }
-  /*
-   * 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;
-    this._transport = this.initTransport();
-    await server.connect(this._transport);
-    const initializeRequest = await this.getInitializeRequest();
-    if (initializeRequest) {
-      this._transport.onmessage?.(initializeRequest);
-    }
-  }
-  /** 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;
-        }
-        break;
-      }
-      case "streamable-http":
-        break;
-    }
-  }
-  /** Handles MCP Messages for Streamable HTTP. */
-  async onMessage(connection, event) {
-    if (this.getTransportType() !== "streamable-http") {
-      const err = new Error(
-        "Internal Server Error: Expected streamable-http protocol"
-      );
-      this._transport?.onerror?.(err);
-      return;
-    }
-    let message;
-    try {
-      const data = typeof event === "string" ? event : new TextDecoder().decode(event);
-      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 (isJSONRPCRequest2(message)) {
-      this._requestIdToConnectionId.set(message.id.toString(), connection.id);
-    }
-    this._transport?.onmessage?.(message);
-  }
-  /** 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;
-    try {
-      while (Date.now() - startTime < timeout) {
-        const response = await this.ctx.storage.get(
-          `elicitation:response:${requestId}`
-        );
-        if (response) {
-          await this.ctx.storage.delete(`elicitation:${requestId}`);
-          await this.ctx.storage.delete(`elicitation:response:${requestId}`);
-          return response;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-      throw new Error("Elicitation request timed out");
-    } finally {
-      await this.ctx.storage.delete(`elicitation:${requestId}`);
-      await this.ctx.storage.delete(`elicitation:response:${requestId}`);
-    }
-  }
-  /** Handle elicitation responses */
-  async _handleElicitationResponse(message) {
-    if (isJSONRPCResponse3(message) && message.result) {
-      const requestId = message.id?.toString();
-      if (!requestId || !requestId.startsWith("elicit_")) return false;
-      const pendingRequest = await this.ctx.storage.get(
-        `elicitation:${requestId}`
-      );
-      if (!pendingRequest) return false;
-      await this.ctx.storage.put(
-        `elicitation:response:${requestId}`,
-        message.result
-      );
-      return true;
-    }
-    if (isJSONRPCError3(message)) {
-      const requestId = message.id?.toString();
-      if (!requestId || !requestId.startsWith("elicit_")) return false;
-      const pendingRequest = await this.ctx.storage.get(
-        `elicitation:${requestId}`
-      );
-      if (!pendingRequest) return false;
-      const errorResult = {
-        action: "cancel",
-        content: {
-          error: message.error.message || "Elicitation request failed"
-        }
-      };
-      await this.ctx.storage.put(
-        `elicitation:response:${requestId}`,
-        errorResult
-      );
-      return true;
-    }
-    return false;
-  }
-  /** Return a handler for the given path for this MCP.
-   * Defaults to Streamable HTTP transport.
-   */
-  static serve(path, {
-    binding = "MCP_OBJECT",
-    corsOptions,
-    transport = "streamable-http"
-  } = {}) {
-    return {
-      async fetch(request, env, ctx) {
-        const corsResponse = handleCORS(request, corsOptions);
-        if (corsResponse) {
-          return corsResponse;
-        }
-        const bindingValue = env[binding];
-        if (bindingValue == null || typeof bindingValue !== "object") {
-          throw new Error(
-            `Could not find McpAgent binding for ${binding}. Did you update your wrangler configuration?`
-          );
-        }
-        if (!isDurableObjectNamespace(bindingValue)) {
-          throw new Error(
-            `Invalid McpAgent binding for ${binding}. Make sure it's a Durable Object binding.`
-          );
-        }
-        const namespace = bindingValue;
-        switch (transport) {
-          case "streamable-http": {
-            const handleStreamableHttp = createStreamingHttpHandler(
-              path,
-              namespace,
-              corsOptions
-            );
-            return handleStreamableHttp(request, ctx);
-          }
-          case "sse": {
-            const handleLegacySse = createLegacySseHandler(
-              path,
-              namespace,
-              corsOptions
-            );
-            return handleLegacySse(request, ctx);
-          }
-          default:
-            return new Response(
-              "Invalid MCP transport mode. Only `streamable-http` or `sse` are allowed.",
-              { status: 500 }
-            );
-        }
-      }
-    };
-  }
-  /**
-   * Legacy api
-   **/
-  static mount(path, opts = {}) {
-    return _McpAgent.serveSSE(path, opts);
-  }
-  static serveSSE(path, opts = {}) {
-    return _McpAgent.serve(path, { ...opts, transport: "sse" });
-  }
+//#endregion
+//#region src/mcp/worker-transport.ts
+const SUPPORTED_PROTOCOL_VERSIONS = ["2025-03-26", "2025-06-18"];
+const DEFAULT_PROTOCOL_VERSION = "2025-03-26";
+const MCP_PROTOCOL_VERSION_HEADER = "MCP-Protocol-Version";
+var WorkerTransport = class {
+	constructor(options) {
+		this.started = false;
+		this.initialized = false;
+		this.enableJsonResponse = false;
+		this.standaloneSseStreamId = "_GET_stream";
+		this.streamMapping = /* @__PURE__ */ new Map();
+		this.requestToStreamMapping = /* @__PURE__ */ new Map();
+		this.requestResponseMap = /* @__PURE__ */ new Map();
+		this.sessionIdGenerator = options?.sessionIdGenerator;
+		this.enableJsonResponse = options?.enableJsonResponse ?? false;
+		this.onsessioninitialized = options?.onsessioninitialized;
+		this.corsOptions = options?.corsOptions;
+	}
+	async start() {
+		if (this.started) throw new Error("Transport already started");
+		this.started = true;
+	}
+	validateProtocolVersion(request) {
+		const versionHeader = request.headers.get(MCP_PROTOCOL_VERSION_HEADER);
+		if (!versionHeader) {
+			if (!this.protocolVersion || this.protocolVersion === DEFAULT_PROTOCOL_VERSION) return;
+			return new Response(JSON.stringify({
+				jsonrpc: "2.0",
+				error: {
+					code: -32e3,
+					message: `Bad Request: ${MCP_PROTOCOL_VERSION_HEADER} header is required`
+				},
+				id: null
+			}), {
+				status: 400,
+				headers: {
+					"Content-Type": "application/json",
+					...this.getHeaders()
+				}
+			});
+		}
+		if (!SUPPORTED_PROTOCOL_VERSIONS.includes(versionHeader)) return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: `Bad Request: Unsupported ${MCP_PROTOCOL_VERSION_HEADER}: ${versionHeader}. Supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")}`
+			},
+			id: null
+		}), {
+			status: 400,
+			headers: {
+				"Content-Type": "application/json",
+				...this.getHeaders()
+			}
+		});
+		if (this.protocolVersion && versionHeader !== this.protocolVersion) return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: `Bad Request: ${MCP_PROTOCOL_VERSION_HEADER} mismatch. Expected: ${this.protocolVersion}, Got: ${versionHeader}`
+			},
+			id: null
+		}), {
+			status: 400,
+			headers: {
+				"Content-Type": "application/json",
+				...this.getHeaders()
+			}
+		});
+	}
+	getHeaders({ forPreflight } = {}) {
+		const options = {
+			origin: "*",
+			headers: "Content-Type, Accept, Authorization, mcp-session-id, MCP-Protocol-Version",
+			methods: "GET, POST, DELETE, OPTIONS",
+			exposeHeaders: "mcp-session-id",
+			maxAge: 86400,
+			...this.corsOptions
+		};
+		if (forPreflight) return {
+			"Access-Control-Allow-Origin": options.origin,
+			"Access-Control-Allow-Headers": options.headers,
+			"Access-Control-Allow-Methods": options.methods,
+			"Access-Control-Max-Age": options.maxAge.toString()
+		};
+		return {
+			"Access-Control-Allow-Origin": options.origin,
+			"Access-Control-Expose-Headers": options.exposeHeaders
+		};
+	}
+	async handleRequest(request, parsedBody) {
+		switch (request.method) {
+			case "OPTIONS": return this.handleOptionsRequest(request);
+			case "GET": return this.handleGetRequest(request);
+			case "POST": return this.handlePostRequest(request, parsedBody);
+			case "DELETE": return this.handleDeleteRequest(request);
+			default: return this.handleUnsupportedRequest();
+		}
+	}
+	async handleGetRequest(request) {
+		if (!request.headers.get("Accept")?.includes("text/event-stream")) return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: "Not Acceptable: Client must accept text/event-stream"
+			},
+			id: null
+		}), {
+			status: 406,
+			headers: {
+				"Content-Type": "application/json",
+				...this.getHeaders()
+			}
+		});
+		const sessionError = this.validateSession(request);
+		if (sessionError) return sessionError;
+		const versionError = this.validateProtocolVersion(request);
+		if (versionError) return versionError;
+		const streamId = this.standaloneSseStreamId;
+		if (this.streamMapping.get(streamId) !== void 0) return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: "Conflict: Only one SSE stream is allowed per session"
+			},
+			id: null
+		}), {
+			status: 409,
+			headers: {
+				"Content-Type": "application/json",
+				...this.getHeaders()
+			}
+		});
+		const { readable, writable } = new TransformStream();
+		const writer = writable.getWriter();
+		const encoder = new TextEncoder();
+		const headers = new Headers({
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+			...this.getHeaders()
+		});
+		if (this.sessionId !== void 0) headers.set("mcp-session-id", this.sessionId);
+		const keepAlive = setInterval(() => {
+			try {
+				writer.write(encoder.encode("event: ping\ndata: \n\n"));
+			} catch {
+				clearInterval(keepAlive);
+			}
+		}, 3e4);
+		this.streamMapping.set(streamId, {
+			writer,
+			encoder,
+			cleanup: () => {
+				clearInterval(keepAlive);
+				this.streamMapping.delete(streamId);
+				writer.close().catch(() => {});
+			}
+		});
+		return new Response(readable, { headers });
+	}
+	async handlePostRequest(request, parsedBody) {
+		const acceptHeader = request.headers.get("Accept");
+		if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: "Not Acceptable: Client must accept both application/json and text/event-stream"
+			},
+			id: null
+		}), {
+			status: 406,
+			headers: {
+				"Content-Type": "application/json",
+				...this.getHeaders()
+			}
+		});
+		if (!request.headers.get("Content-Type")?.includes("application/json")) return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: "Unsupported Media Type: Content-Type must be application/json"
+			},
+			id: null
+		}), {
+			status: 415,
+			headers: {
+				"Content-Type": "application/json",
+				...this.getHeaders()
+			}
+		});
+		let rawMessage = parsedBody;
+		if (rawMessage === void 0) try {
+			rawMessage = await request.json();
+		} catch {
+			return new Response(JSON.stringify({
+				jsonrpc: "2.0",
+				error: {
+					code: -32700,
+					message: "Parse error: Invalid JSON"
+				},
+				id: null
+			}), {
+				status: 400,
+				headers: {
+					"Content-Type": "application/json",
+					...this.getHeaders()
+				}
+			});
+		}
+		let messages;
+		try {
+			if (Array.isArray(rawMessage)) messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
+			else messages = [JSONRPCMessageSchema.parse(rawMessage)];
+		} catch {
+			return new Response(JSON.stringify({
+				jsonrpc: "2.0",
+				error: {
+					code: -32700,
+					message: "Parse error: Invalid JSON-RPC message"
+				},
+				id: null
+			}), {
+				status: 400,
+				headers: {
+					"Content-Type": "application/json",
+					...this.getHeaders()
+				}
+			});
+		}
+		const isInitializationRequest = messages.some(isInitializeRequest);
+		if (isInitializationRequest) {
+			if (this.initialized && this.sessionId !== void 0) return new Response(JSON.stringify({
+				jsonrpc: "2.0",
+				error: {
+					code: -32600,
+					message: "Invalid Request: Server already initialized"
+				},
+				id: null
+			}), {
+				status: 400,
+				headers: {
+					"Content-Type": "application/json",
+					...this.getHeaders()
+				}
+			});
+			if (messages.length > 1) return new Response(JSON.stringify({
+				jsonrpc: "2.0",
+				error: {
+					code: -32600,
+					message: "Invalid Request: Only one initialization request is allowed"
+				},
+				id: null
+			}), {
+				status: 400,
+				headers: {
+					"Content-Type": "application/json",
+					...this.getHeaders()
+				}
+			});
+			const initRequest = messages.find(isInitializeRequest);
+			if (initRequest?.params) {
+				const version = initRequest.params.protocolVersion;
+				if (version && SUPPORTED_PROTOCOL_VERSIONS.includes(version)) this.protocolVersion = version;
+				else this.protocolVersion = DEFAULT_PROTOCOL_VERSION;
+			}
+			this.sessionId = this.sessionIdGenerator?.();
+			this.initialized = true;
+			if (this.sessionId && this.onsessioninitialized) this.onsessioninitialized(this.sessionId);
+		}
+		if (!isInitializationRequest) {
+			const sessionError = this.validateSession(request);
+			if (sessionError) return sessionError;
+			const versionError = this.validateProtocolVersion(request);
+			if (versionError) return versionError;
+		}
+		if (!messages.some(isJSONRPCRequest)) {
+			for (const message of messages) this.onmessage?.(message);
+			return new Response(null, {
+				status: 202,
+				headers: { ...this.getHeaders() }
+			});
+		}
+		const streamId = crypto.randomUUID();
+		if (this.enableJsonResponse) return new Promise((resolve) => {
+			this.streamMapping.set(streamId, {
+				resolveJson: resolve,
+				cleanup: () => {
+					this.streamMapping.delete(streamId);
+				}
+			});
+			for (const message of messages) if (isJSONRPCRequest(message)) this.requestToStreamMapping.set(message.id, streamId);
+			for (const message of messages) this.onmessage?.(message);
+		});
+		const { readable, writable } = new TransformStream();
+		const writer = writable.getWriter();
+		const encoder = new TextEncoder();
+		const headers = new Headers({
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+			...this.getHeaders()
+		});
+		if (this.sessionId !== void 0) headers.set("mcp-session-id", this.sessionId);
+		this.streamMapping.set(streamId, {
+			writer,
+			encoder,
+			cleanup: () => {
+				this.streamMapping.delete(streamId);
+				writer.close().catch(() => {});
+			}
+		});
+		for (const message of messages) if (isJSONRPCRequest(message)) this.requestToStreamMapping.set(message.id, streamId);
+		for (const message of messages) this.onmessage?.(message);
+		return new Response(readable, { headers });
+	}
+	async handleDeleteRequest(request) {
+		const sessionError = this.validateSession(request);
+		if (sessionError) return sessionError;
+		const versionError = this.validateProtocolVersion(request);
+		if (versionError) return versionError;
+		await this.close();
+		return new Response(null, {
+			status: 200,
+			headers: { ...this.getHeaders() }
+		});
+	}
+	handleOptionsRequest(_request) {
+		return new Response(null, {
+			status: 200,
+			headers: { ...this.getHeaders({ forPreflight: true }) }
+		});
+	}
+	handleUnsupportedRequest() {
+		return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: "Method not allowed."
+			},
+			id: null
+		}), {
+			status: 405,
+			headers: {
+				Allow: "GET, POST, DELETE, OPTIONS",
+				"Content-Type": "application/json"
+			}
+		});
+	}
+	validateSession(request) {
+		if (this.sessionIdGenerator === void 0) return;
+		if (!this.initialized) return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: "Bad Request: Server not initialized"
+			},
+			id: null
+		}), {
+			status: 400,
+			headers: {
+				"Content-Type": "application/json",
+				...this.getHeaders()
+			}
+		});
+		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: {
+				"Content-Type": "application/json",
+				...this.getHeaders()
+			}
+		});
+		if (sessionId !== this.sessionId) return new Response(JSON.stringify({
+			jsonrpc: "2.0",
+			error: {
+				code: -32001,
+				message: "Session not found"
+			},
+			id: null
+		}), {
+			status: 404,
+			headers: {
+				"Content-Type": "application/json",
+				...this.getHeaders()
+			}
+		});
+	}
+	async close() {
+		for (const { cleanup } of this.streamMapping.values()) cleanup();
+		this.streamMapping.clear();
+		this.requestResponseMap.clear();
+		this.onclose?.();
+	}
+	async send(message) {
+		let requestId;
+		if (isJSONRPCResponse(message) || isJSONRPCError(message)) requestId = message.id;
+		if (requestId === void 0) {
+			if (isJSONRPCResponse(message) || isJSONRPCError(message)) throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
+			const standaloneSse = this.streamMapping.get(this.standaloneSseStreamId);
+			if (standaloneSse === void 0) return;
+			if (standaloneSse.writer && standaloneSse.encoder) {
+				const data = `event: message\ndata: ${JSON.stringify(message)}\n\n`;
+				await standaloneSse.writer.write(standaloneSse.encoder.encode(data));
+			}
+			return;
+		}
+		const streamId = this.requestToStreamMapping.get(requestId);
+		if (!streamId) throw new Error(`No connection established for request ID: ${String(requestId)}`);
+		const response = this.streamMapping.get(streamId);
+		if (!response) throw new Error(`No connection established for request ID: ${String(requestId)}`);
+		if (!this.enableJsonResponse) {
+			if (response.writer && response.encoder) {
+				const data = `event: message\ndata: ${JSON.stringify(message)}\n\n`;
+				await response.writer.write(response.encoder.encode(data));
+			}
+		}
+		if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+			this.requestResponseMap.set(requestId, message);
+			const relatedIds = Array.from(this.requestToStreamMapping.entries()).filter(([, sid]) => sid === streamId).map(([id]) => id);
+			if (relatedIds.every((id) => this.requestResponseMap.has(id))) {
+				if (this.enableJsonResponse && response.resolveJson) {
+					const responses = relatedIds.map((id) => this.requestResponseMap.get(id));
+					const headers = new Headers({
+						"Content-Type": "application/json",
+						...this.getHeaders()
+					});
+					if (this.sessionId !== void 0) headers.set("mcp-session-id", this.sessionId);
+					const body = responses.length === 1 ? responses[0] : responses;
+					response.resolveJson(new Response(JSON.stringify(body), { headers }));
+				} else response.cleanup();
+				for (const id of relatedIds) {
+					this.requestResponseMap.delete(id);
+					this.requestToStreamMapping.delete(id);
+				}
+			}
+		}
+	}
 };
-export {
-  ElicitRequestSchema,
-  McpAgent,
-  SSEEdgeClientTransport,
-  StreamableHTTPEdgeClientTransport
+
+//#endregion
+//#region src/mcp/auth-context.ts
+const authContextStorage = new AsyncLocalStorage();
+function getMcpAuthContext() {
+	return authContextStorage.getStore();
+}
+function runWithAuthContext(context, fn) {
+	return authContextStorage.run(context, fn);
+}
+
+//#endregion
+//#region src/mcp/handler.ts
+function createMcpHandler(server, options = {}) {
+	const route = options.route ?? "/mcp";
+	return async (request, _env, ctx) => {
+		const url = new URL(request.url);
+		if (route && url.pathname !== route) return new Response("Not Found", { status: 404 });
+		const oauthCtx = ctx;
+		const authContext = oauthCtx.props ? { props: oauthCtx.props } : void 0;
+		const transport = new WorkerTransport(options);
+		await server.connect(transport);
+		const handleRequest = async () => {
+			return await transport.handleRequest(request);
+		};
+		try {
+			if (authContext) return await runWithAuthContext(authContext, handleRequest);
+			else return await handleRequest();
+		} catch (error) {
+			console.error("MCP handler error:", error);
+			return new Response(JSON.stringify({
+				jsonrpc: "2.0",
+				error: {
+					code: -32603,
+					message: error instanceof Error ? error.message : "Internal server error"
+				},
+				id: null
+			}), {
+				status: 500,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+	};
+}
+let didWarnAboutExperimentalCreateMcpHandler = false;
+/**
+* @deprecated This has been renamed to createMcpHandler, and experimental_createMcpHandler will be removed in the next major version
+*/
+function experimental_createMcpHandler(server, options = {}) {
+	if (!didWarnAboutExperimentalCreateMcpHandler) {
+		didWarnAboutExperimentalCreateMcpHandler = true;
+		console.warn("experimental_createMcpHandler is deprecated, use createMcpHandler instead. experimental_createMcpHandler will be removed in the next major version.");
+	}
+	return createMcpHandler(server, options);
+}
+
+//#endregion
+//#region src/mcp/index.ts
+var McpAgent = class McpAgent extends Agent {
+	async setInitializeRequest(initializeRequest) {
+		await this.ctx.storage.put("initializeRequest", initializeRequest);
+	}
+	async getInitializeRequest() {
+		return this.ctx.storage.get("initializeRequest");
+	}
+	/** Read the transport type for this agent.
+	* This relies on the naming scheme being `sse:${sessionId}`
+	* or `streamable-http:${sessionId}`.
+	*/
+	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.");
+		}
+	}
+	/** Read the sessionId for this agent.
+	* This relies on the naming scheme being `sse:${sessionId}`
+	* or `streamable-http:${sessionId}`.
+	*/
+	getSessionId() {
+		const [_, sessionId] = this.name.split(":");
+		if (!sessionId) throw new Error("Invalid session id. McpAgent must be addressed with a valid session id.");
+		return sessionId;
+	}
+	/** Get the unique WebSocket. SSE transport only. */
+	getWebSocket() {
+		const websockets = Array.from(this.getConnections());
+		if (websockets.length === 0) return null;
+		return websockets[0];
+	}
+	/** 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 StreamableHTTPServerTransport({});
+		}
+	}
+	/** Update and store the props */
+	async updateProps(props) {
+		await this.ctx.storage.put("props", props ?? {});
+		this.props = props;
+	}
+	async reinitializeServer() {
+		const initializeRequest = await this.getInitializeRequest();
+		if (initializeRequest) this._transport?.onmessage?.(initializeRequest);
+	}
+	/** 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;
+		this._transport = this.initTransport();
+		await server.connect(this._transport);
+		await this.reinitializeServer();
+	}
+	/** Validates new WebSocket connections. */
+	async onConnect(conn, { request: req }) {
+		switch (this.getTransportType()) {
+			case "sse":
+				if (Array.from(this.getConnections()).length > 1) {
+					conn.close(1008, "Websocket already connected");
+					return;
+				}
+				break;
+			case "streamable-http": if (this._transport instanceof StreamableHTTPServerTransport) switch (req.headers.get(MCP_HTTP_METHOD_HEADER)) {
+				case "POST": {
+					const payloadHeader = req.headers.get(MCP_MESSAGE_HEADER);
+					let rawPayload;
+					if (!payloadHeader) rawPayload = "{}";
+					else try {
+						rawPayload = Buffer.from(payloadHeader, "base64").toString("utf-8");
+					} catch (_error) {
+						throw new Error("Internal Server Error: Failed to decode MCP message header");
+					}
+					const parsedBody = JSON.parse(rawPayload);
+					this._transport?.handlePostRequest(req, parsedBody);
+					break;
+				}
+				case "GET":
+					this._transport?.handleGetRequest(req);
+					break;
+			}
+		}
+	}
+	/** Handles MCP Messages for the legacy SSE transport. */
+	async onSSEMcpMessage(_sessionId, messageBody) {
+		if (this.getTransportType() !== "sse") return /* @__PURE__ */ new Error("Internal Server Error: Expected SSE transport");
+		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;
+		}
+	}
+	/** 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;
+		try {
+			while (Date.now() - startTime < timeout) {
+				const response = await this.ctx.storage.get(`elicitation:response:${requestId}`);
+				if (response) {
+					await this.ctx.storage.delete(`elicitation:${requestId}`);
+					await this.ctx.storage.delete(`elicitation:response:${requestId}`);
+					return response;
+				}
+				await new Promise((resolve) => setTimeout(resolve, 100));
+			}
+			throw new Error("Elicitation request timed out");
+		} finally {
+			await this.ctx.storage.delete(`elicitation:${requestId}`);
+			await this.ctx.storage.delete(`elicitation:response:${requestId}`);
+		}
+	}
+	/** Handle elicitation responses */
+	async _handleElicitationResponse(message) {
+		if (isJSONRPCResponse(message) && message.result) {
+			const requestId = message.id?.toString();
+			if (!requestId || !requestId.startsWith("elicit_")) return false;
+			if (!await this.ctx.storage.get(`elicitation:${requestId}`)) return false;
+			await this.ctx.storage.put(`elicitation:response:${requestId}`, message.result);
+			return true;
+		}
+		if (isJSONRPCError(message)) {
+			const requestId = message.id?.toString();
+			if (!requestId || !requestId.startsWith("elicit_")) return false;
+			if (!await this.ctx.storage.get(`elicitation:${requestId}`)) return false;
+			const errorResult = {
+				action: "cancel",
+				content: { error: message.error.message || "Elicitation request failed" }
+			};
+			await this.ctx.storage.put(`elicitation:response:${requestId}`, errorResult);
+			return true;
+		}
+		return false;
+	}
+	/** Return a handler for the given path for this MCP.
+	* Defaults to Streamable HTTP transport.
+	*/
+	static serve(path, { binding = "MCP_OBJECT", corsOptions, transport = "streamable-http", jurisdiction } = {}) {
+		return { async fetch(request, env, ctx) {
+			const corsResponse = handleCORS(request, corsOptions);
+			if (corsResponse) return corsResponse;
+			const bindingValue = env[binding];
+			if (bindingValue == null || typeof bindingValue !== "object") throw new Error(`Could not find McpAgent binding for ${binding}. Did you update your wrangler configuration?`);
+			if (!isDurableObjectNamespace(bindingValue)) throw new Error(`Invalid McpAgent binding for ${binding}. Make sure it's a Durable Object binding.`);
+			const namespace = bindingValue;
+			switch (transport) {
+				case "streamable-http": return createStreamingHttpHandler(path, namespace, {
+					corsOptions,
+					jurisdiction
+				})(request, ctx);
+				case "sse": return createLegacySseHandler(path, namespace, {
+					corsOptions,
+					jurisdiction
+				})(request, ctx);
+				default: return new Response("Invalid MCP transport mode. Only `streamable-http` or `sse` are allowed.", { status: 500 });
+			}
+		} };
+	}
+	/**
+	* Legacy api
+	**/
+	static mount(path, opts = {}) {
+		return McpAgent.serveSSE(path, opts);
+	}
+	static serveSSE(path, opts = {}) {
+		return McpAgent.serve(path, {
+			...opts,
+			transport: "sse"
+		});
+	}
 };
+
+//#endregion
+export { ElicitRequestSchema, McpAgent, SSEEdgeClientTransport, StreamableHTTPEdgeClientTransport, WorkerTransport, createMcpHandler, experimental_createMcpHandler, getMcpAuthContext };
 //# sourceMappingURL=index.js.map