agents 0.2.13 → 0.2.15

package/dist/src-tpG9NtHy.js

@@ -0,0 +1,2457 @@
+import { MessageType } from "./ai-types-UZlfLOYP.js";
+import { camelCaseToKebabCase } from "./client-DjR-lC16.js";
+import { DisposableStore, MCPClientManager } from "./client-CZBVDDoO.js";
+import { DurableObjectOAuthClientProvider } from "./do-oauth-client-provider-B2jr6UNq.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { parseCronExpression } from "cron-schedule";
+import { nanoid } from "nanoid";
+import { EmailMessage } from "cloudflare:email";
+import { Server, getServerByName, routePartykitRequest } from "partyserver";
+import { ElicitRequestSchema as ElicitRequestSchema$1, InitializeRequestSchema, JSONRPCMessageSchema, isInitializeRequest, isJSONRPCError, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse } from "@modelcontextprotocol/sdk/types.js";
+
+//#region src/observability/index.ts
+/**
+* A generic observability implementation that logs events to the console.
+*/
+const genericObservability = { emit(event) {
+	if (isLocalMode()) {
+		console.log(event.displayMessage);
+		return;
+	}
+	console.log(event);
+} };
+let localMode = false;
+function isLocalMode() {
+	if (localMode) return true;
+	const { request } = getCurrentAgent();
+	if (!request) return false;
+	localMode = new URL(request.url).hostname === "localhost";
+	return localMode;
+}
+
+//#endregion
+//#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, 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 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 });
+				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, 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, 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 });
+				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, 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}`);
+				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, 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 });
+	};
+};
+const 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 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 });
+			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, 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, 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;
+}
+function isDurableObjectNamespace(namespace) {
+	return typeof namespace === "object" && namespace !== null && "newUniqueId" in namespace && typeof namespace.newUniqueId === "function" && "idFromName" in namespace && typeof namespace.idFromName === "function";
+}
+
+//#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?.();
+	}
+};
+/**
+* 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);
+	}
+};
+
+//#endregion
+//#region src/mcp/worker-transport.ts
+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;
+	}
+	async start() {
+		if (this.started) throw new Error("Transport already started");
+		this.started = true;
+	}
+	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" }
+		});
+		const sessionValid = this.validateSession(request);
+		if (sessionValid !== true) return sessionValid;
+		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" }
+		});
+		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",
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Expose-Headers": "mcp-session-id"
+		});
+		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" }
+		});
+		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" }
+		});
+		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" }
+			});
+		}
+		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" }
+			});
+		}
+		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" }
+			});
+			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.sessionId = this.sessionIdGenerator?.();
+			this.initialized = true;
+			if (this.sessionId && this.onsessioninitialized) this.onsessioninitialized(this.sessionId);
+		}
+		if (!isInitializationRequest) {
+			const sessionValid = this.validateSession(request);
+			if (sessionValid !== true) return sessionValid;
+		}
+		if (!messages.some(isJSONRPCRequest)) {
+			for (const message of messages) this.onmessage?.(message);
+			return new Response(null, {
+				status: 202,
+				headers: { "Access-Control-Allow-Origin": "*" }
+			});
+		}
+		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",
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Expose-Headers": "mcp-session-id"
+		});
+		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 sessionValid = this.validateSession(request);
+		if (sessionValid !== true) return sessionValid;
+		await this.close();
+		return new Response(null, {
+			status: 200,
+			headers: { "Access-Control-Allow-Origin": "*" }
+		});
+	}
+	handleOptionsRequest(_request) {
+		const headers = new Headers({
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+			"Access-Control-Allow-Headers": "Content-Type, Accept, Authorization, mcp-session-id",
+			"Access-Control-Max-Age": "86400"
+		});
+		return new Response(null, {
+			status: 204,
+			headers
+		});
+	}
+	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 true;
+		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" }
+		});
+		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" }
+		});
+		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" }
+		});
+		return true;
+	}
+	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",
+						"Access-Control-Allow-Origin": "*",
+						"Access-Control-Expose-Headers": "mcp-session-id"
+					});
+					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);
+				}
+			}
+		}
+	}
+};
+
+//#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 experimental_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 {
+			let response;
+			if (authContext) response = await runWithAuthContext(authContext, handleRequest);
+			else response = await handleRequest();
+			return response;
+		} 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" }
+			});
+		}
+	};
+}
+
+//#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" } = {}) {
+		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)(request, ctx);
+				case "sse": return createLegacySseHandler(path, namespace, corsOptions)(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/index.ts
+/**
+* Type guard for RPC request messages
+*/
+function isRPCRequest(msg) {
+	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === MessageType.RPC && "id" in msg && typeof msg.id === "string" && "method" in msg && typeof msg.method === "string" && "args" in msg && Array.isArray(msg.args);
+}
+/**
+* Type guard for state update messages
+*/
+function isStateUpdateMessage(msg) {
+	return typeof msg === "object" && msg !== null && "type" in msg && msg.type === MessageType.CF_AGENT_STATE && "state" in msg;
+}
+const callableMetadata = /* @__PURE__ */ new Map();
+/**
+* Decorator that marks a method as callable by clients
+* @param metadata Optional metadata about the callable method
+*/
+function callable(metadata = {}) {
+	return function callableDecorator(target, context) {
+		if (!callableMetadata.has(target)) callableMetadata.set(target, metadata);
+		return target;
+	};
+}
+let didWarnAboutUnstableCallable = false;
+/**
+* Decorator that marks a method as callable by clients
+* @deprecated this has been renamed to callable, and unstable_callable will be removed in the next major version
+* @param metadata Optional metadata about the callable method
+*/
+const unstable_callable = (metadata = {}) => {
+	if (!didWarnAboutUnstableCallable) {
+		didWarnAboutUnstableCallable = true;
+		console.warn("unstable_callable is deprecated, use callable instead. unstable_callable will be removed in the next major version.");
+	}
+	callable(metadata);
+};
+function getNextCronTime(cron) {
+	return parseCronExpression(cron).getNextDate();
+}
+const STATE_ROW_ID = "cf_state_row_id";
+const STATE_WAS_CHANGED = "cf_state_was_changed";
+const DEFAULT_STATE = {};
+const agentContext = new AsyncLocalStorage();
+function getCurrentAgent() {
+	const store = agentContext.getStore();
+	if (!store) return {
+		agent: void 0,
+		connection: void 0,
+		request: void 0,
+		email: void 0
+	};
+	return store;
+}
+/**
+* Wraps a method to run within the agent context, ensuring getCurrentAgent() works properly
+* @param agent The agent instance
+* @param method The method to wrap
+* @returns A wrapped method that runs within the agent context
+*/
+function withAgentContext(method) {
+	return function(...args) {
+		const { connection, request, email, agent } = getCurrentAgent();
+		if (agent === this) return method.apply(this, args);
+		return agentContext.run({
+			agent: this,
+			connection,
+			request,
+			email
+		}, () => {
+			return method.apply(this, args);
+		});
+	};
+}
+/**
+* Base class for creating Agent implementations
+* @template Env Environment type containing bindings
+* @template State State type to store within the Agent
+*/
+var Agent = class Agent extends Server {
+	/**
+	* Current state of the Agent
+	*/
+	get state() {
+		if (this._state !== DEFAULT_STATE) return this._state;
+		const wasChanged = this.sql`
+        SELECT state FROM cf_agents_state WHERE id = ${STATE_WAS_CHANGED}
+      `;
+		const result = this.sql`
+      SELECT state FROM cf_agents_state WHERE id = ${STATE_ROW_ID}
+    `;
+		if (wasChanged[0]?.state === "true" || result[0]?.state) {
+			const state = result[0]?.state;
+			this._state = JSON.parse(state);
+			return this._state;
+		}
+		if (this.initialState === DEFAULT_STATE) return;
+		this.setState(this.initialState);
+		return this.initialState;
+	}
+	static {
+		this.options = { hibernate: true };
+	}
+	/**
+	* Execute SQL queries against the Agent's database
+	* @template T Type of the returned rows
+	* @param strings SQL query template strings
+	* @param values Values to be inserted into the query
+	* @returns Array of query results
+	*/
+	sql(strings, ...values) {
+		let query = "";
+		try {
+			query = strings.reduce((acc, str, i) => acc + str + (i < values.length ? "?" : ""), "");
+			return [...this.ctx.storage.sql.exec(query, ...values)];
+		} catch (e) {
+			console.error(`failed to execute sql query: ${query}`, e);
+			throw this.onError(e);
+		}
+	}
+	constructor(ctx, env) {
+		super(ctx, env);
+		this._state = DEFAULT_STATE;
+		this._disposables = new DisposableStore();
+		this._ParentClass = Object.getPrototypeOf(this).constructor;
+		this.mcp = new MCPClientManager(this._ParentClass.name, "0.0.1");
+		this.initialState = DEFAULT_STATE;
+		this.observability = genericObservability;
+		this._flushingQueue = false;
+		this.alarm = async () => {
+			const now = Math.floor(Date.now() / 1e3);
+			const result = this.sql`
+      SELECT * FROM cf_agents_schedules WHERE time <= ${now}
+    `;
+			if (result && Array.isArray(result)) for (const row of result) {
+				const callback = this[row.callback];
+				if (!callback) {
+					console.error(`callback ${row.callback} not found`);
+					continue;
+				}
+				await agentContext.run({
+					agent: this,
+					connection: void 0,
+					request: void 0,
+					email: void 0
+				}, async () => {
+					try {
+						this.observability?.emit({
+							displayMessage: `Schedule ${row.id} executed`,
+							id: nanoid(),
+							payload: {
+								callback: row.callback,
+								id: row.id
+							},
+							timestamp: Date.now(),
+							type: "schedule:execute"
+						}, this.ctx);
+						await callback.bind(this)(JSON.parse(row.payload), row);
+					} catch (e) {
+						console.error(`error executing callback "${row.callback}"`, e);
+					}
+				});
+				if (row.type === "cron") {
+					const nextExecutionTime = getNextCronTime(row.cron);
+					const nextTimestamp = Math.floor(nextExecutionTime.getTime() / 1e3);
+					this.sql`
+          UPDATE cf_agents_schedules SET time = ${nextTimestamp} WHERE id = ${row.id}
+        `;
+				} else this.sql`
+          DELETE FROM cf_agents_schedules WHERE id = ${row.id}
+        `;
+			}
+			await this._scheduleNextAlarm();
+		};
+		if (!wrappedClasses.has(this.constructor)) {
+			this._autoWrapCustomMethods();
+			wrappedClasses.add(this.constructor);
+		}
+		this._disposables.add(this.mcp.onConnected(async () => {
+			this.broadcastMcpServers();
+		}));
+		this._disposables.add(this.mcp.onObservabilityEvent((event) => {
+			this.observability?.emit(event);
+		}));
+		this.sql`
+      CREATE TABLE IF NOT EXISTS cf_agents_state (
+        id TEXT PRIMARY KEY NOT NULL,
+        state TEXT
+      )
+    `;
+		this.sql`
+      CREATE TABLE IF NOT EXISTS cf_agents_queues (
+        id TEXT PRIMARY KEY NOT NULL,
+        payload TEXT,
+        callback TEXT,
+        created_at INTEGER DEFAULT (unixepoch())
+      )
+    `;
+		this.ctx.blockConcurrencyWhile(async () => {
+			return this._tryCatch(async () => {
+				this.sql`
+        CREATE TABLE IF NOT EXISTS cf_agents_schedules (
+          id TEXT PRIMARY KEY NOT NULL DEFAULT (randomblob(9)),
+          callback TEXT,
+          payload TEXT,
+          type TEXT NOT NULL CHECK(type IN ('scheduled', 'delayed', 'cron')),
+          time INTEGER,
+          delayInSeconds INTEGER,
+          cron TEXT,
+          created_at INTEGER DEFAULT (unixepoch())
+        )
+      `;
+				await this.alarm();
+			});
+		});
+		this.sql`
+      CREATE TABLE IF NOT EXISTS cf_agents_mcp_servers (
+        id TEXT PRIMARY KEY NOT NULL,
+        name TEXT NOT NULL,
+        server_url TEXT NOT NULL,
+        callback_url TEXT NOT NULL,
+        client_id TEXT,
+        auth_url TEXT,
+        server_options TEXT
+      )
+    `;
+		const _onRequest = this.onRequest.bind(this);
+		this.onRequest = (request) => {
+			return agentContext.run({
+				agent: this,
+				connection: void 0,
+				request,
+				email: void 0
+			}, async () => {
+				const callbackResult = await this._handlePotentialOAuthCallback(request);
+				if (callbackResult) return callbackResult;
+				return this._tryCatch(() => _onRequest(request));
+			});
+		};
+		const _onMessage = this.onMessage.bind(this);
+		this.onMessage = async (connection, message) => {
+			return agentContext.run({
+				agent: this,
+				connection,
+				request: void 0,
+				email: void 0
+			}, async () => {
+				if (typeof message !== "string") return this._tryCatch(() => _onMessage(connection, message));
+				let parsed;
+				try {
+					parsed = JSON.parse(message);
+				} catch (_e) {
+					return this._tryCatch(() => _onMessage(connection, message));
+				}
+				if (isStateUpdateMessage(parsed)) {
+					this._setStateInternal(parsed.state, connection);
+					return;
+				}
+				if (isRPCRequest(parsed)) {
+					try {
+						const { id, method, args } = parsed;
+						const methodFn = this[method];
+						if (typeof methodFn !== "function") throw new Error(`Method ${method} does not exist`);
+						if (!this._isCallable(method)) throw new Error(`Method ${method} is not callable`);
+						const metadata = callableMetadata.get(methodFn);
+						if (metadata?.streaming) {
+							const stream = new StreamingResponse(connection, id);
+							await methodFn.apply(this, [stream, ...args]);
+							return;
+						}
+						const result = await methodFn.apply(this, args);
+						this.observability?.emit({
+							displayMessage: `RPC call to ${method}`,
+							id: nanoid(),
+							payload: {
+								method,
+								streaming: metadata?.streaming
+							},
+							timestamp: Date.now(),
+							type: "rpc"
+						}, this.ctx);
+						const response = {
+							done: true,
+							id,
+							result,
+							success: true,
+							type: MessageType.RPC
+						};
+						connection.send(JSON.stringify(response));
+					} catch (e) {
+						const response = {
+							error: e instanceof Error ? e.message : "Unknown error occurred",
+							id: parsed.id,
+							success: false,
+							type: MessageType.RPC
+						};
+						connection.send(JSON.stringify(response));
+						console.error("RPC error:", e);
+					}
+					return;
+				}
+				return this._tryCatch(() => _onMessage(connection, message));
+			});
+		};
+		const _onConnect = this.onConnect.bind(this);
+		this.onConnect = (connection, ctx$1) => {
+			return agentContext.run({
+				agent: this,
+				connection,
+				request: ctx$1.request,
+				email: void 0
+			}, () => {
+				if (this.state) connection.send(JSON.stringify({
+					state: this.state,
+					type: MessageType.CF_AGENT_STATE
+				}));
+				connection.send(JSON.stringify({
+					mcp: this.getMcpServers(),
+					type: MessageType.CF_AGENT_MCP_SERVERS
+				}));
+				this.observability?.emit({
+					displayMessage: "Connection established",
+					id: nanoid(),
+					payload: { connectionId: connection.id },
+					timestamp: Date.now(),
+					type: "connect"
+				}, this.ctx);
+				return this._tryCatch(() => _onConnect(connection, ctx$1));
+			});
+		};
+		const _onStart = this.onStart.bind(this);
+		this.onStart = async (props) => {
+			return agentContext.run({
+				agent: this,
+				connection: void 0,
+				request: void 0,
+				email: void 0
+			}, async () => {
+				await this._tryCatch(() => {
+					const servers = this.sql`
+            SELECT id, name, server_url, client_id, auth_url, callback_url, server_options FROM cf_agents_mcp_servers;
+          `;
+					this.broadcastMcpServers();
+					if (servers && Array.isArray(servers) && servers.length > 0) {
+						servers.forEach((server) => {
+							if (server.callback_url) this.mcp.registerCallbackUrl(`${server.callback_url}/${server.id}`);
+						});
+						servers.forEach((server) => {
+							this._connectToMcpServerInternal(server.name, server.server_url, server.callback_url, server.server_options ? JSON.parse(server.server_options) : void 0, {
+								id: server.id,
+								oauthClientId: server.client_id ?? void 0
+							}).then(() => {
+								this.broadcastMcpServers();
+							}).catch((error) => {
+								console.error(`Error connecting to MCP server: ${server.name} (${server.server_url})`, error);
+								this.broadcastMcpServers();
+							});
+						});
+					}
+					return _onStart(props);
+				});
+			});
+		};
+	}
+	_setStateInternal(state, source = "server") {
+		this._state = state;
+		this.sql`
+    INSERT OR REPLACE INTO cf_agents_state (id, state)
+    VALUES (${STATE_ROW_ID}, ${JSON.stringify(state)})
+  `;
+		this.sql`
+    INSERT OR REPLACE INTO cf_agents_state (id, state)
+    VALUES (${STATE_WAS_CHANGED}, ${JSON.stringify(true)})
+  `;
+		this.broadcast(JSON.stringify({
+			state,
+			type: MessageType.CF_AGENT_STATE
+		}), source !== "server" ? [source.id] : []);
+		return this._tryCatch(() => {
+			const { connection, request, email } = agentContext.getStore() || {};
+			return agentContext.run({
+				agent: this,
+				connection,
+				request,
+				email
+			}, async () => {
+				this.observability?.emit({
+					displayMessage: "State updated",
+					id: nanoid(),
+					payload: {},
+					timestamp: Date.now(),
+					type: "state:update"
+				}, this.ctx);
+				return this.onStateUpdate(state, source);
+			});
+		});
+	}
+	/**
+	* Update the Agent's state
+	* @param state New state to set
+	*/
+	setState(state) {
+		this._setStateInternal(state, "server");
+	}
+	/**
+	* Called when the Agent's state is updated
+	* @param state Updated state
+	* @param source Source of the state update ("server" or a client connection)
+	*/
+	onStateUpdate(state, source) {}
+	/**
+	* Called when the Agent receives an email via routeAgentEmail()
+	* Override this method to handle incoming emails
+	* @param email Email message to process
+	*/
+	async _onEmail(email) {
+		return agentContext.run({
+			agent: this,
+			connection: void 0,
+			request: void 0,
+			email
+		}, async () => {
+			if ("onEmail" in this && typeof this.onEmail === "function") return this._tryCatch(() => this.onEmail(email));
+			else {
+				console.log("Received email from:", email.from, "to:", email.to);
+				console.log("Subject:", email.headers.get("subject"));
+				console.log("Implement onEmail(email: AgentEmail): Promise<void> in your agent to process emails");
+			}
+		});
+	}
+	/**
+	* Reply to an email
+	* @param email The email to reply to
+	* @param options Options for the reply
+	* @returns void
+	*/
+	async replyToEmail(email, options) {
+		return this._tryCatch(async () => {
+			const agentName = camelCaseToKebabCase(this._ParentClass.name);
+			const agentId = this.name;
+			const { createMimeMessage } = await import("mimetext");
+			const msg = createMimeMessage();
+			msg.setSender({
+				addr: email.to,
+				name: options.fromName
+			});
+			msg.setRecipient(email.from);
+			msg.setSubject(options.subject || `Re: ${email.headers.get("subject")}` || "No subject");
+			msg.addMessage({
+				contentType: options.contentType || "text/plain",
+				data: options.body
+			});
+			const messageId = `<${agentId}@${email.from.split("@")[1]}>`;
+			msg.setHeader("In-Reply-To", email.headers.get("Message-ID"));
+			msg.setHeader("Message-ID", messageId);
+			msg.setHeader("X-Agent-Name", agentName);
+			msg.setHeader("X-Agent-ID", agentId);
+			if (options.headers) for (const [key, value] of Object.entries(options.headers)) msg.setHeader(key, value);
+			await email.reply({
+				from: email.to,
+				raw: msg.asRaw(),
+				to: email.from
+			});
+		});
+	}
+	async _tryCatch(fn) {
+		try {
+			return await fn();
+		} catch (e) {
+			throw this.onError(e);
+		}
+	}
+	/**
+	* Automatically wrap custom methods with agent context
+	* This ensures getCurrentAgent() works in all custom methods without decorators
+	*/
+	_autoWrapCustomMethods() {
+		const basePrototypes = [Agent.prototype, Server.prototype];
+		const baseMethods = /* @__PURE__ */ new Set();
+		for (const baseProto of basePrototypes) {
+			let proto$1 = baseProto;
+			while (proto$1 && proto$1 !== Object.prototype) {
+				const methodNames = Object.getOwnPropertyNames(proto$1);
+				for (const methodName of methodNames) baseMethods.add(methodName);
+				proto$1 = Object.getPrototypeOf(proto$1);
+			}
+		}
+		let proto = Object.getPrototypeOf(this);
+		let depth = 0;
+		while (proto && proto !== Object.prototype && depth < 10) {
+			const methodNames = Object.getOwnPropertyNames(proto);
+			for (const methodName of methodNames) {
+				const descriptor = Object.getOwnPropertyDescriptor(proto, methodName);
+				if (baseMethods.has(methodName) || methodName.startsWith("_") || !descriptor || !!descriptor.get || typeof descriptor.value !== "function") continue;
+				const wrappedFunction = withAgentContext(this[methodName]);
+				if (this._isCallable(methodName)) callableMetadata.set(wrappedFunction, callableMetadata.get(this[methodName]));
+				this.constructor.prototype[methodName] = wrappedFunction;
+			}
+			proto = Object.getPrototypeOf(proto);
+			depth++;
+		}
+	}
+	onError(connectionOrError, error) {
+		let theError;
+		if (connectionOrError && error) {
+			theError = error;
+			console.error("Error on websocket connection:", connectionOrError.id, theError);
+			console.error("Override onError(connection, error) to handle websocket connection errors");
+		} else {
+			theError = connectionOrError;
+			console.error("Error on server:", theError);
+			console.error("Override onError(error) to handle server errors");
+		}
+		throw theError;
+	}
+	/**
+	* Render content (not implemented in base class)
+	*/
+	render() {
+		throw new Error("Not implemented");
+	}
+	/**
+	* Queue a task to be executed in the future
+	* @param payload Payload to pass to the callback
+	* @param callback Name of the method to call
+	* @returns The ID of the queued task
+	*/
+	async queue(callback, payload) {
+		const id = nanoid(9);
+		if (typeof callback !== "string") throw new Error("Callback must be a string");
+		if (typeof this[callback] !== "function") throw new Error(`this.${callback} is not a function`);
+		this.sql`
+      INSERT OR REPLACE INTO cf_agents_queues (id, payload, callback)
+      VALUES (${id}, ${JSON.stringify(payload)}, ${callback})
+    `;
+		this._flushQueue().catch((e) => {
+			console.error("Error flushing queue:", e);
+		});
+		return id;
+	}
+	async _flushQueue() {
+		if (this._flushingQueue) return;
+		this._flushingQueue = true;
+		while (true) {
+			const result = this.sql`
+      SELECT * FROM cf_agents_queues
+      ORDER BY created_at ASC
+    `;
+			if (!result || result.length === 0) break;
+			for (const row of result || []) {
+				const callback = this[row.callback];
+				if (!callback) {
+					console.error(`callback ${row.callback} not found`);
+					continue;
+				}
+				const { connection, request, email } = agentContext.getStore() || {};
+				await agentContext.run({
+					agent: this,
+					connection,
+					request,
+					email
+				}, async () => {
+					await callback.bind(this)(JSON.parse(row.payload), row);
+					await this.dequeue(row.id);
+				});
+			}
+		}
+		this._flushingQueue = false;
+	}
+	/**
+	* Dequeue a task by ID
+	* @param id ID of the task to dequeue
+	*/
+	async dequeue(id) {
+		this.sql`DELETE FROM cf_agents_queues WHERE id = ${id}`;
+	}
+	/**
+	* Dequeue all tasks
+	*/
+	async dequeueAll() {
+		this.sql`DELETE FROM cf_agents_queues`;
+	}
+	/**
+	* Dequeue all tasks by callback
+	* @param callback Name of the callback to dequeue
+	*/
+	async dequeueAllByCallback(callback) {
+		this.sql`DELETE FROM cf_agents_queues WHERE callback = ${callback}`;
+	}
+	/**
+	* Get a queued task by ID
+	* @param id ID of the task to get
+	* @returns The task or undefined if not found
+	*/
+	async getQueue(id) {
+		const result = this.sql`
+      SELECT * FROM cf_agents_queues WHERE id = ${id}
+    `;
+		return result ? {
+			...result[0],
+			payload: JSON.parse(result[0].payload)
+		} : void 0;
+	}
+	/**
+	* Get all queues by key and value
+	* @param key Key to filter by
+	* @param value Value to filter by
+	* @returns Array of matching QueueItem objects
+	*/
+	async getQueues(key, value) {
+		return this.sql`
+      SELECT * FROM cf_agents_queues
+    `.filter((row) => JSON.parse(row.payload)[key] === value);
+	}
+	/**
+	* Schedule a task to be executed in the future
+	* @template T Type of the payload data
+	* @param when When to execute the task (Date, seconds delay, or cron expression)
+	* @param callback Name of the method to call
+	* @param payload Data to pass to the callback
+	* @returns Schedule object representing the scheduled task
+	*/
+	async schedule(when, callback, payload) {
+		const id = nanoid(9);
+		const emitScheduleCreate = (schedule) => this.observability?.emit({
+			displayMessage: `Schedule ${schedule.id} created`,
+			id: nanoid(),
+			payload: {
+				callback,
+				id
+			},
+			timestamp: Date.now(),
+			type: "schedule:create"
+		}, this.ctx);
+		if (typeof callback !== "string") throw new Error("Callback must be a string");
+		if (typeof this[callback] !== "function") throw new Error(`this.${callback} is not a function`);
+		if (when instanceof Date) {
+			const timestamp = Math.floor(when.getTime() / 1e3);
+			this.sql`
+        INSERT OR REPLACE INTO cf_agents_schedules (id, callback, payload, type, time)
+        VALUES (${id}, ${callback}, ${JSON.stringify(payload)}, 'scheduled', ${timestamp})
+      `;
+			await this._scheduleNextAlarm();
+			const schedule = {
+				callback,
+				id,
+				payload,
+				time: timestamp,
+				type: "scheduled"
+			};
+			emitScheduleCreate(schedule);
+			return schedule;
+		}
+		if (typeof when === "number") {
+			const time = new Date(Date.now() + when * 1e3);
+			const timestamp = Math.floor(time.getTime() / 1e3);
+			this.sql`
+        INSERT OR REPLACE INTO cf_agents_schedules (id, callback, payload, type, delayInSeconds, time)
+        VALUES (${id}, ${callback}, ${JSON.stringify(payload)}, 'delayed', ${when}, ${timestamp})
+      `;
+			await this._scheduleNextAlarm();
+			const schedule = {
+				callback,
+				delayInSeconds: when,
+				id,
+				payload,
+				time: timestamp,
+				type: "delayed"
+			};
+			emitScheduleCreate(schedule);
+			return schedule;
+		}
+		if (typeof when === "string") {
+			const nextExecutionTime = getNextCronTime(when);
+			const timestamp = Math.floor(nextExecutionTime.getTime() / 1e3);
+			this.sql`
+        INSERT OR REPLACE INTO cf_agents_schedules (id, callback, payload, type, cron, time)
+        VALUES (${id}, ${callback}, ${JSON.stringify(payload)}, 'cron', ${when}, ${timestamp})
+      `;
+			await this._scheduleNextAlarm();
+			const schedule = {
+				callback,
+				cron: when,
+				id,
+				payload,
+				time: timestamp,
+				type: "cron"
+			};
+			emitScheduleCreate(schedule);
+			return schedule;
+		}
+		throw new Error("Invalid schedule type");
+	}
+	/**
+	* Get a scheduled task by ID
+	* @template T Type of the payload data
+	* @param id ID of the scheduled task
+	* @returns The Schedule object or undefined if not found
+	*/
+	async getSchedule(id) {
+		const result = this.sql`
+      SELECT * FROM cf_agents_schedules WHERE id = ${id}
+    `;
+		if (!result) {
+			console.error(`schedule ${id} not found`);
+			return;
+		}
+		return {
+			...result[0],
+			payload: JSON.parse(result[0].payload)
+		};
+	}
+	/**
+	* Get scheduled tasks matching the given criteria
+	* @template T Type of the payload data
+	* @param criteria Criteria to filter schedules
+	* @returns Array of matching Schedule objects
+	*/
+	getSchedules(criteria = {}) {
+		let query = "SELECT * FROM cf_agents_schedules WHERE 1=1";
+		const params = [];
+		if (criteria.id) {
+			query += " AND id = ?";
+			params.push(criteria.id);
+		}
+		if (criteria.type) {
+			query += " AND type = ?";
+			params.push(criteria.type);
+		}
+		if (criteria.timeRange) {
+			query += " AND time >= ? AND time <= ?";
+			const start = criteria.timeRange.start || /* @__PURE__ */ new Date(0);
+			const end = criteria.timeRange.end || /* @__PURE__ */ new Date(999999999999999);
+			params.push(Math.floor(start.getTime() / 1e3), Math.floor(end.getTime() / 1e3));
+		}
+		return this.ctx.storage.sql.exec(query, ...params).toArray().map((row) => ({
+			...row,
+			payload: JSON.parse(row.payload)
+		}));
+	}
+	/**
+	* Cancel a scheduled task
+	* @param id ID of the task to cancel
+	* @returns true if the task was cancelled, false otherwise
+	*/
+	async cancelSchedule(id) {
+		const schedule = await this.getSchedule(id);
+		if (schedule) this.observability?.emit({
+			displayMessage: `Schedule ${id} cancelled`,
+			id: nanoid(),
+			payload: {
+				callback: schedule.callback,
+				id: schedule.id
+			},
+			timestamp: Date.now(),
+			type: "schedule:cancel"
+		}, this.ctx);
+		this.sql`DELETE FROM cf_agents_schedules WHERE id = ${id}`;
+		await this._scheduleNextAlarm();
+		return true;
+	}
+	async _scheduleNextAlarm() {
+		const result = this.sql`
+      SELECT time FROM cf_agents_schedules
+      WHERE time > ${Math.floor(Date.now() / 1e3)}
+      ORDER BY time ASC
+      LIMIT 1
+    `;
+		if (!result) return;
+		if (result.length > 0 && "time" in result[0]) {
+			const nextTime = result[0].time * 1e3;
+			await this.ctx.storage.setAlarm(nextTime);
+		}
+	}
+	/**
+	* Destroy the Agent, removing all state and scheduled tasks
+	*/
+	async destroy() {
+		this.sql`DROP TABLE IF EXISTS cf_agents_state`;
+		this.sql`DROP TABLE IF EXISTS cf_agents_schedules`;
+		this.sql`DROP TABLE IF EXISTS cf_agents_mcp_servers`;
+		this.sql`DROP TABLE IF EXISTS cf_agents_queues`;
+		await this.ctx.storage.deleteAlarm();
+		await this.ctx.storage.deleteAll();
+		this._disposables.dispose();
+		await this.mcp.dispose?.();
+		this.ctx.abort("destroyed");
+		this.observability?.emit({
+			displayMessage: "Agent destroyed",
+			id: nanoid(),
+			payload: {},
+			timestamp: Date.now(),
+			type: "destroy"
+		}, this.ctx);
+	}
+	/**
+	* Get all methods marked as callable on this Agent
+	* @returns A map of method names to their metadata
+	*/
+	_isCallable(method) {
+		return callableMetadata.has(this[method]);
+	}
+	/**
+	* Connect to a new MCP Server
+	*
+	* @param serverName Name of the MCP server
+	* @param url MCP Server SSE URL
+	* @param callbackHost Base host for the agent, used for the redirect URI. If not provided, will be derived from the current request.
+	* @param agentsPrefix agents routing prefix if not using `agents`
+	* @param options MCP client and transport options
+	* @returns authUrl
+	*/
+	async addMcpServer(serverName, url, callbackHost, agentsPrefix = "agents", options) {
+		let resolvedCallbackHost = callbackHost;
+		if (!resolvedCallbackHost) {
+			const { request } = getCurrentAgent();
+			if (!request) throw new Error("callbackHost is required when not called within a request context");
+			const requestUrl = new URL(request.url);
+			resolvedCallbackHost = `${requestUrl.protocol}//${requestUrl.host}`;
+		}
+		const callbackUrl = `${resolvedCallbackHost}/${agentsPrefix}/${camelCaseToKebabCase(this._ParentClass.name)}/${this.name}/callback`;
+		const serverId = nanoid(8);
+		this.sql`
+        INSERT OR REPLACE INTO cf_agents_mcp_servers (id, name, server_url, client_id, auth_url, callback_url, server_options)
+      VALUES (
+        ${serverId},
+        ${serverName},
+        ${url},
+        ${null},
+        ${null},
+        ${callbackUrl},
+        ${options ? JSON.stringify(options) : null}
+        );
+    `;
+		const result = await this._connectToMcpServerInternal(serverName, url, callbackUrl, options, { id: serverId });
+		if (result.clientId || result.authUrl) this.sql`
+        UPDATE cf_agents_mcp_servers
+        SET client_id = ${result.clientId ?? null}, auth_url = ${result.authUrl ?? null}
+        WHERE id = ${serverId}
+      `;
+		this.broadcastMcpServers();
+		return result;
+	}
+	/**
+	* Handle potential OAuth callback requests after DO hibernation.
+	* Detects OAuth callbacks, restores state from database, and processes the callback.
+	* Returns a Response if this was an OAuth callback, otherwise returns undefined.
+	*/
+	async _handlePotentialOAuthCallback(request) {
+		if (request.method !== "GET") return;
+		const url = new URL(request.url);
+		if (!(url.pathname.includes("/callback/") && url.searchParams.has("code"))) return;
+		const pathParts = url.pathname.split("/");
+		const callbackIndex = pathParts.indexOf("callback");
+		const serverId = callbackIndex !== -1 ? pathParts[callbackIndex + 1] : null;
+		if (!serverId) return new Response("Invalid callback URL: missing serverId", { status: 400 });
+		if (this.mcp.isCallbackRequest(request) && this.mcp.mcpConnections[serverId]) return this._processOAuthCallback(request);
+		try {
+			const server = this.sql`
+        SELECT id, name, server_url, client_id, auth_url, callback_url, server_options
+        FROM cf_agents_mcp_servers
+        WHERE id = ${serverId}
+      `.find((s) => s.id === serverId);
+			if (!server) return new Response(`OAuth callback failed: Server ${serverId} not found in database`, { status: 404 });
+			if (!server.callback_url) return new Response(`OAuth callback failed: No callback URL stored for server ${serverId}`, { status: 500 });
+			this.mcp.registerCallbackUrl(`${server.callback_url}/${server.id}`);
+			if (!this.mcp.mcpConnections[serverId]) {
+				let parsedOptions;
+				try {
+					parsedOptions = server.server_options ? JSON.parse(server.server_options) : void 0;
+				} catch {
+					return new Response(`OAuth callback failed: Invalid server options in database for ${serverId}`, { status: 500 });
+				}
+				await this._connectToMcpServerInternal(server.name, server.server_url, server.callback_url, parsedOptions, {
+					id: server.id,
+					oauthClientId: server.client_id ?? void 0
+				});
+			}
+			return this._processOAuthCallback(request);
+		} catch (error) {
+			const errorMsg = error instanceof Error ? error.message : "Unknown error";
+			console.error(`Failed to restore MCP state for ${serverId}:`, error);
+			return new Response(`OAuth callback failed during state restoration: ${errorMsg}`, { status: 500 });
+		}
+	}
+	/**
+	* Process an OAuth callback request (assumes state is already restored)
+	*/
+	async _processOAuthCallback(request) {
+		const result = await this.mcp.handleCallbackRequest(request);
+		this.broadcastMcpServers();
+		if (result.authSuccess) this.mcp.establishConnection(result.serverId).catch((error) => {
+			console.error("Background connection failed:", error);
+		}).finally(() => {
+			this.broadcastMcpServers();
+		});
+		return this.handleOAuthCallbackResponse(result, request);
+	}
+	async _connectToMcpServerInternal(_serverName, url, callbackUrl, options, reconnect) {
+		const authProvider = new DurableObjectOAuthClientProvider(this.ctx.storage, this.name, callbackUrl);
+		if (reconnect) {
+			authProvider.serverId = reconnect.id;
+			if (reconnect.oauthClientId) authProvider.clientId = reconnect.oauthClientId;
+		}
+		const transportType = options?.transport?.type ?? "auto";
+		let headerTransportOpts = {};
+		if (options?.transport?.headers) headerTransportOpts = {
+			eventSourceInit: { fetch: (url$1, init) => fetch(url$1, {
+				...init,
+				headers: options?.transport?.headers
+			}) },
+			requestInit: { headers: options?.transport?.headers }
+		};
+		const { id, authUrl, clientId } = await this.mcp.connect(url, {
+			client: options?.client,
+			reconnect,
+			transport: {
+				...headerTransportOpts,
+				authProvider,
+				type: transportType
+			}
+		});
+		return {
+			authUrl,
+			clientId,
+			id
+		};
+	}
+	async removeMcpServer(id) {
+		this.mcp.closeConnection(id);
+		this.mcp.unregisterCallbackUrl(id);
+		this.sql`
+      DELETE FROM cf_agents_mcp_servers WHERE id = ${id};
+    `;
+		this.broadcastMcpServers();
+	}
+	getMcpServers() {
+		const mcpState = {
+			prompts: this.mcp.listPrompts(),
+			resources: this.mcp.listResources(),
+			servers: {},
+			tools: this.mcp.listTools()
+		};
+		const servers = this.sql`
+      SELECT id, name, server_url, client_id, auth_url, callback_url, server_options FROM cf_agents_mcp_servers;
+    `;
+		if (servers && Array.isArray(servers) && servers.length > 0) for (const server of servers) {
+			const serverConn = this.mcp.mcpConnections[server.id];
+			mcpState.servers[server.id] = {
+				auth_url: server.auth_url,
+				capabilities: serverConn?.serverCapabilities ?? null,
+				instructions: serverConn?.instructions ?? null,
+				name: server.name,
+				server_url: server.server_url,
+				state: serverConn?.connectionState ?? "authenticating"
+			};
+		}
+		return mcpState;
+	}
+	broadcastMcpServers() {
+		this.broadcast(JSON.stringify({
+			mcp: this.getMcpServers(),
+			type: MessageType.CF_AGENT_MCP_SERVERS
+		}));
+	}
+	/**
+	* Handle OAuth callback response using MCPClientManager configuration
+	* @param result OAuth callback result
+	* @param request The original request (needed for base URL)
+	* @returns Response for the OAuth callback
+	*/
+	handleOAuthCallbackResponse(result, request) {
+		const config = this.mcp.getOAuthCallbackConfig();
+		if (config?.customHandler) return config.customHandler(result);
+		if (config?.successRedirect && result.authSuccess) return Response.redirect(config.successRedirect);
+		if (config?.errorRedirect && !result.authSuccess) return Response.redirect(`${config.errorRedirect}?error=${encodeURIComponent(result.authError || "Unknown error")}`);
+		const baseUrl = new URL(request.url).origin;
+		return Response.redirect(baseUrl);
+	}
+};
+const wrappedClasses = /* @__PURE__ */ new Set();
+/**
+* Route a request to the appropriate Agent
+* @param request Request to route
+* @param env Environment containing Agent bindings
+* @param options Routing options
+* @returns Response from the Agent or undefined if no route matched
+*/
+async function routeAgentRequest(request, env, options) {
+	const corsHeaders$1 = options?.cors === true ? {
+		"Access-Control-Allow-Credentials": "true",
+		"Access-Control-Allow-Methods": "GET, POST, HEAD, OPTIONS",
+		"Access-Control-Allow-Origin": "*",
+		"Access-Control-Max-Age": "86400"
+	} : options?.cors;
+	if (request.method === "OPTIONS") {
+		if (corsHeaders$1) return new Response(null, { headers: corsHeaders$1 });
+		console.warn("Received an OPTIONS request, but cors was not enabled. Pass `cors: true` or `cors: { ...custom cors headers }` to routeAgentRequest to enable CORS.");
+	}
+	let response = await routePartykitRequest(request, env, {
+		prefix: "agents",
+		...options
+	});
+	if (response && corsHeaders$1 && request.headers.get("upgrade")?.toLowerCase() !== "websocket" && request.headers.get("Upgrade")?.toLowerCase() !== "websocket") response = new Response(response.body, { headers: {
+		...response.headers,
+		...corsHeaders$1
+	} });
+	return response;
+}
+/**
+* Create a resolver that uses the message-id header to determine the agent to route the email to
+* @returns A function that resolves the agent to route the email to
+*/
+function createHeaderBasedEmailResolver() {
+	return async (email, _env) => {
+		const messageId = email.headers.get("message-id");
+		if (messageId) {
+			const messageIdMatch = messageId.match(/<([^@]+)@([^>]+)>/);
+			if (messageIdMatch) {
+				const [, agentId$1, domain] = messageIdMatch;
+				return {
+					agentName: domain.split(".")[0],
+					agentId: agentId$1
+				};
+			}
+		}
+		const references = email.headers.get("references");
+		if (references) {
+			const referencesMatch = references.match(/<([A-Za-z0-9+/]{43}=)@([^>]+)>/);
+			if (referencesMatch) {
+				const [, base64Id, domain] = referencesMatch;
+				const agentId$1 = Buffer.from(base64Id, "base64").toString("hex");
+				return {
+					agentName: domain.split(".")[0],
+					agentId: agentId$1
+				};
+			}
+		}
+		const agentName = email.headers.get("x-agent-name");
+		const agentId = email.headers.get("x-agent-id");
+		if (agentName && agentId) return {
+			agentName,
+			agentId
+		};
+		return null;
+	};
+}
+/**
+* Create a resolver that uses the email address to determine the agent to route the email to
+* @param defaultAgentName The default agent name to use if the email address does not contain a sub-address
+* @returns A function that resolves the agent to route the email to
+*/
+function createAddressBasedEmailResolver(defaultAgentName) {
+	return async (email, _env) => {
+		const emailMatch = email.to.match(/^([^+@]+)(?:\+([^@]+))?@(.+)$/);
+		if (!emailMatch) return null;
+		const [, localPart, subAddress] = emailMatch;
+		if (subAddress) return {
+			agentName: localPart,
+			agentId: subAddress
+		};
+		return {
+			agentName: defaultAgentName,
+			agentId: localPart
+		};
+	};
+}
+/**
+* Create a resolver that uses the agentName and agentId to determine the agent to route the email to
+* @param agentName The name of the agent to route the email to
+* @param agentId The id of the agent to route the email to
+* @returns A function that resolves the agent to route the email to
+*/
+function createCatchAllEmailResolver(agentName, agentId) {
+	return async () => ({
+		agentName,
+		agentId
+	});
+}
+const agentMapCache = /* @__PURE__ */ new WeakMap();
+/**
+* Route an email to the appropriate Agent
+* @param email The email to route
+* @param env The environment containing the Agent bindings
+* @param options The options for routing the email
+* @returns A promise that resolves when the email has been routed
+*/
+async function routeAgentEmail(email, env, options) {
+	const routingInfo = await options.resolver(email, env);
+	if (!routingInfo) {
+		console.warn("No routing information found for email, dropping message");
+		return;
+	}
+	if (!agentMapCache.has(env)) {
+		const map = {};
+		for (const [key, value] of Object.entries(env)) if (value && typeof value === "object" && "idFromName" in value && typeof value.idFromName === "function") {
+			map[key] = value;
+			map[camelCaseToKebabCase(key)] = value;
+		}
+		agentMapCache.set(env, map);
+	}
+	const agentMap = agentMapCache.get(env);
+	const namespace = agentMap[routingInfo.agentName];
+	if (!namespace) {
+		const availableAgents = Object.keys(agentMap).filter((key) => !key.includes("-")).join(", ");
+		throw new Error(`Agent namespace '${routingInfo.agentName}' not found in environment. Available agents: ${availableAgents}`);
+	}
+	const agent = await getAgentByName(namespace, routingInfo.agentId);
+	const serialisableEmail = {
+		getRaw: async () => {
+			const reader = email.raw.getReader();
+			const chunks = [];
+			let done = false;
+			while (!done) {
+				const { value, done: readerDone } = await reader.read();
+				done = readerDone;
+				if (value) chunks.push(value);
+			}
+			const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+			const combined = new Uint8Array(totalLength);
+			let offset = 0;
+			for (const chunk of chunks) {
+				combined.set(chunk, offset);
+				offset += chunk.length;
+			}
+			return combined;
+		},
+		headers: email.headers,
+		rawSize: email.rawSize,
+		setReject: (reason) => {
+			email.setReject(reason);
+		},
+		forward: (rcptTo, headers) => {
+			return email.forward(rcptTo, headers);
+		},
+		reply: (options$1) => {
+			return email.reply(new EmailMessage(options$1.from, options$1.to, options$1.raw));
+		},
+		from: email.from,
+		to: email.to
+	};
+	await agent._onEmail(serialisableEmail);
+}
+/**
+* Get or create an Agent by name
+* @template Env Environment type containing bindings
+* @template T Type of the Agent class
+* @param namespace Agent namespace
+* @param name Name of the Agent instance
+* @param options Options for Agent creation
+* @returns Promise resolving to an Agent instance stub
+*/
+async function getAgentByName(namespace, name, options) {
+	return getServerByName(namespace, name, options);
+}
+/**
+* A wrapper for streaming responses in callable methods
+*/
+var StreamingResponse = class {
+	constructor(connection, id) {
+		this._closed = false;
+		this._connection = connection;
+		this._id = id;
+	}
+	/**
+	* Send a chunk of data to the client
+	* @param chunk The data to send
+	*/
+	send(chunk) {
+		if (this._closed) throw new Error("StreamingResponse is already closed");
+		const response = {
+			done: false,
+			id: this._id,
+			result: chunk,
+			success: true,
+			type: MessageType.RPC
+		};
+		this._connection.send(JSON.stringify(response));
+	}
+	/**
+	* End the stream and send the final chunk (if any)
+	* @param finalChunk Optional final chunk of data to send
+	*/
+	end(finalChunk) {
+		if (this._closed) throw new Error("StreamingResponse is already closed");
+		this._closed = true;
+		const response = {
+			done: true,
+			id: this._id,
+			result: finalChunk,
+			success: true,
+			type: MessageType.RPC
+		};
+		this._connection.send(JSON.stringify(response));
+	}
+};
+
+//#endregion
+export { Agent, ElicitRequestSchema$1 as ElicitRequestSchema, McpAgent, StreamingResponse, WorkerTransport, callable, createAddressBasedEmailResolver, createCatchAllEmailResolver, createHeaderBasedEmailResolver, experimental_createMcpHandler, genericObservability, getAgentByName, getCurrentAgent, getMcpAuthContext, routeAgentEmail, routeAgentRequest, unstable_callable };
+//# sourceMappingURL=src-tpG9NtHy.js.map