hono-agents 0.0.0-e03246e → 0.0.0-e135cf5

package/dist/index.js

@@ -1,48 +1,1932 @@
-// src/index.ts
+import "partysocket";
+import { nanoid } from "nanoid";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { ElicitRequestSchema, PromptListChangedNotificationSchema, ResourceListChangedNotificationSchema, ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { parseCronExpression } from "cron-schedule";
+import "cloudflare:email";
+import { Server, routePartykitRequest } from "partyserver";
 import { env } from "hono/adapter";
 import { createMiddleware } from "hono/factory";
-import { routeAgentRequest } from "agents";
+
+//#region ../agents/dist/ai-types-B3aQaFv3.js
+/**
+* Enum for message types to improve type safety and maintainability
+*/
+let MessageType = /* @__PURE__ */ function(MessageType$1) {
+	MessageType$1["CF_AGENT_CHAT_MESSAGES"] = "cf_agent_chat_messages";
+	MessageType$1["CF_AGENT_USE_CHAT_REQUEST"] = "cf_agent_use_chat_request";
+	MessageType$1["CF_AGENT_USE_CHAT_RESPONSE"] = "cf_agent_use_chat_response";
+	MessageType$1["CF_AGENT_CHAT_CLEAR"] = "cf_agent_chat_clear";
+	MessageType$1["CF_AGENT_CHAT_REQUEST_CANCEL"] = "cf_agent_chat_request_cancel";
+	MessageType$1["CF_AGENT_MCP_SERVERS"] = "cf_agent_mcp_servers";
+	MessageType$1["CF_MCP_AGENT_EVENT"] = "cf_mcp_agent_event";
+	MessageType$1["CF_AGENT_STATE"] = "cf_agent_state";
+	MessageType$1["RPC"] = "rpc";
+	return MessageType$1;
+}({});
+
+//#endregion
+//#region ../agents/dist/client-BfiZ3HQd.js
+/**
+* Convert a camelCase string to a kebab-case string
+* @param str The string to convert
+* @returns The kebab-case string
+*/
+function camelCaseToKebabCase(str) {
+	if (str === str.toUpperCase() && str !== str.toLowerCase()) return str.toLowerCase().replace(/_/g, "-");
+	let kebabified = str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+	kebabified = kebabified.startsWith("-") ? kebabified.slice(1) : kebabified;
+	return kebabified.replace(/_/g, "-").replace(/-$/, "");
+}
+
+//#endregion
+//#region ../agents/dist/client-DZhjV_XA.js
+function toDisposable(fn) {
+	return { dispose: fn };
+}
+var DisposableStore = class {
+	constructor() {
+		this._items = [];
+	}
+	add(d) {
+		this._items.push(d);
+		return d;
+	}
+	dispose() {
+		while (this._items.length) try {
+			this._items.pop().dispose();
+		} catch {}
+	}
+};
+var Emitter = class {
+	constructor() {
+		this._listeners = /* @__PURE__ */ new Set();
+		this.event = (listener) => {
+			this._listeners.add(listener);
+			return toDisposable(() => this._listeners.delete(listener));
+		};
+	}
+	fire(data) {
+		for (const listener of [...this._listeners]) try {
+			listener(data);
+		} catch (err) {
+			console.error("Emitter listener error:", err);
+		}
+	}
+	dispose() {
+		this._listeners.clear();
+	}
+};
+function toErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isUnauthorized(error) {
+	const msg = toErrorMessage(error);
+	return msg.includes("Unauthorized") || msg.includes("401");
+}
+function isTransportNotImplemented(error) {
+	const msg = toErrorMessage(error);
+	return msg.includes("404") || msg.includes("405") || msg.includes("Not Implemented") || msg.includes("not implemented");
+}
+var MCPClientConnection = class {
+	constructor(url, info, options = {
+		client: {},
+		transport: {}
+	}) {
+		this.url = url;
+		this.options = options;
+		this.connectionState = "connecting";
+		this.tools = [];
+		this.prompts = [];
+		this.resources = [];
+		this.resourceTemplates = [];
+		this._onObservabilityEvent = new Emitter();
+		this.onObservabilityEvent = this._onObservabilityEvent.event;
+		this.client = new Client(info, {
+			...options.client,
+			capabilities: {
+				...options.client?.capabilities,
+				elicitation: {}
+			}
+		});
+	}
+	/**
+	* Initialize a client connection
+	*
+	* @returns
+	*/
+	async init() {
+		const transportType = this.options.transport.type;
+		if (!transportType) throw new Error("Transport type must be specified");
+		try {
+			await this.tryConnect(transportType);
+		} catch (e) {
+			if (isUnauthorized(e)) {
+				this.connectionState = "authenticating";
+				return;
+			}
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:connect",
+				displayMessage: `Connection initialization failed for ${this.url.toString()}`,
+				payload: {
+					url: this.url.toString(),
+					transport: transportType,
+					state: this.connectionState,
+					error: toErrorMessage(e)
+				},
+				timestamp: Date.now(),
+				id: nanoid()
+			});
+			this.connectionState = "failed";
+			return;
+		}
+		await this.discoverAndRegister();
+	}
+	/**
+	* Finish OAuth by probing transports based on configured type.
+	* - Explicit: finish on that transport
+	* - Auto: try streamable-http, then sse on 404/405/Not Implemented
+	*/
+	async finishAuthProbe(code) {
+		if (!this.options.transport.authProvider) throw new Error("No auth provider configured");
+		const configuredType = this.options.transport.type;
+		if (!configuredType) throw new Error("Transport type must be specified");
+		const finishAuth = async (base) => {
+			await this.getTransport(base).finishAuth(code);
+		};
+		if (configuredType === "sse" || configuredType === "streamable-http") {
+			await finishAuth(configuredType);
+			return;
+		}
+		try {
+			await finishAuth("streamable-http");
+		} catch (e) {
+			if (isTransportNotImplemented(e)) {
+				await finishAuth("sse");
+				return;
+			}
+			throw e;
+		}
+	}
+	/**
+	* Complete OAuth authorization
+	*/
+	async completeAuthorization(code) {
+		if (this.connectionState !== "authenticating") throw new Error("Connection must be in authenticating state to complete authorization");
+		try {
+			await this.finishAuthProbe(code);
+			this.connectionState = "connecting";
+		} catch (error) {
+			this.connectionState = "failed";
+			throw error;
+		}
+	}
+	/**
+	* Establish connection after successful authorization
+	*/
+	async establishConnection() {
+		if (this.connectionState !== "connecting") throw new Error("Connection must be in connecting state to establish connection");
+		try {
+			const transportType = this.options.transport.type;
+			if (!transportType) throw new Error("Transport type must be specified");
+			await this.tryConnect(transportType);
+			await this.discoverAndRegister();
+		} catch (error) {
+			this.connectionState = "failed";
+			throw error;
+		}
+	}
+	/**
+	* Discover server capabilities and register tools, resources, prompts, and templates
+	*/
+	async discoverAndRegister() {
+		this.connectionState = "discovering";
+		this.serverCapabilities = this.client.getServerCapabilities();
+		if (!this.serverCapabilities) throw new Error("The MCP Server failed to return server capabilities");
+		const [instructionsResult, toolsResult, resourcesResult, promptsResult, resourceTemplatesResult] = await Promise.allSettled([
+			this.client.getInstructions(),
+			this.registerTools(),
+			this.registerResources(),
+			this.registerPrompts(),
+			this.registerResourceTemplates()
+		]);
+		const operations = [
+			{
+				name: "instructions",
+				result: instructionsResult
+			},
+			{
+				name: "tools",
+				result: toolsResult
+			},
+			{
+				name: "resources",
+				result: resourcesResult
+			},
+			{
+				name: "prompts",
+				result: promptsResult
+			},
+			{
+				name: "resource templates",
+				result: resourceTemplatesResult
+			}
+		];
+		for (const { name, result } of operations) if (result.status === "rejected") {
+			const url = this.url.toString();
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:discover",
+				displayMessage: `Failed to discover ${name} for ${url}`,
+				payload: {
+					url,
+					capability: name,
+					error: result.reason
+				},
+				timestamp: Date.now(),
+				id: nanoid()
+			});
+		}
+		this.instructions = instructionsResult.status === "fulfilled" ? instructionsResult.value : void 0;
+		this.tools = toolsResult.status === "fulfilled" ? toolsResult.value : [];
+		this.resources = resourcesResult.status === "fulfilled" ? resourcesResult.value : [];
+		this.prompts = promptsResult.status === "fulfilled" ? promptsResult.value : [];
+		this.resourceTemplates = resourceTemplatesResult.status === "fulfilled" ? resourceTemplatesResult.value : [];
+		this.connectionState = "ready";
+	}
+	/**
+	* Notification handler registration
+	*/
+	async registerTools() {
+		if (!this.serverCapabilities || !this.serverCapabilities.tools) return [];
+		if (this.serverCapabilities.tools.listChanged) this.client.setNotificationHandler(ToolListChangedNotificationSchema, async (_notification) => {
+			this.tools = await this.fetchTools();
+		});
+		return this.fetchTools();
+	}
+	async registerResources() {
+		if (!this.serverCapabilities || !this.serverCapabilities.resources) return [];
+		if (this.serverCapabilities.resources.listChanged) this.client.setNotificationHandler(ResourceListChangedNotificationSchema, async (_notification) => {
+			this.resources = await this.fetchResources();
+		});
+		return this.fetchResources();
+	}
+	async registerPrompts() {
+		if (!this.serverCapabilities || !this.serverCapabilities.prompts) return [];
+		if (this.serverCapabilities.prompts.listChanged) this.client.setNotificationHandler(PromptListChangedNotificationSchema, async (_notification) => {
+			this.prompts = await this.fetchPrompts();
+		});
+		return this.fetchPrompts();
+	}
+	async registerResourceTemplates() {
+		if (!this.serverCapabilities || !this.serverCapabilities.resources) return [];
+		return this.fetchResourceTemplates();
+	}
+	async fetchTools() {
+		let toolsAgg = [];
+		let toolsResult = { tools: [] };
+		do {
+			toolsResult = await this.client.listTools({ cursor: toolsResult.nextCursor }).catch(this._capabilityErrorHandler({ tools: [] }, "tools/list"));
+			toolsAgg = toolsAgg.concat(toolsResult.tools);
+		} while (toolsResult.nextCursor);
+		return toolsAgg;
+	}
+	async fetchResources() {
+		let resourcesAgg = [];
+		let resourcesResult = { resources: [] };
+		do {
+			resourcesResult = await this.client.listResources({ cursor: resourcesResult.nextCursor }).catch(this._capabilityErrorHandler({ resources: [] }, "resources/list"));
+			resourcesAgg = resourcesAgg.concat(resourcesResult.resources);
+		} while (resourcesResult.nextCursor);
+		return resourcesAgg;
+	}
+	async fetchPrompts() {
+		let promptsAgg = [];
+		let promptsResult = { prompts: [] };
+		do {
+			promptsResult = await this.client.listPrompts({ cursor: promptsResult.nextCursor }).catch(this._capabilityErrorHandler({ prompts: [] }, "prompts/list"));
+			promptsAgg = promptsAgg.concat(promptsResult.prompts);
+		} while (promptsResult.nextCursor);
+		return promptsAgg;
+	}
+	async fetchResourceTemplates() {
+		let templatesAgg = [];
+		let templatesResult = { resourceTemplates: [] };
+		do {
+			templatesResult = await this.client.listResourceTemplates({ cursor: templatesResult.nextCursor }).catch(this._capabilityErrorHandler({ resourceTemplates: [] }, "resources/templates/list"));
+			templatesAgg = templatesAgg.concat(templatesResult.resourceTemplates);
+		} while (templatesResult.nextCursor);
+		return templatesAgg;
+	}
+	/**
+	* Handle elicitation request from server
+	* Automatically uses the Agent's built-in elicitation handling if available
+	*/
+	async handleElicitationRequest(_request) {
+		throw new Error("Elicitation handler must be implemented for your platform. Override handleElicitationRequest method.");
+	}
+	/**
+	* Get the transport for the client
+	* @param transportType - The transport type to get
+	* @returns The transport for the client
+	*/
+	getTransport(transportType) {
+		switch (transportType) {
+			case "streamable-http": return new StreamableHTTPClientTransport(this.url, this.options.transport);
+			case "sse": return new SSEClientTransport(this.url, this.options.transport);
+			default: throw new Error(`Unsupported transport type: ${transportType}`);
+		}
+	}
+	async tryConnect(transportType) {
+		const transports = transportType === "auto" ? ["streamable-http", "sse"] : [transportType];
+		for (const currentTransportType of transports) {
+			const isLastTransport = currentTransportType === transports[transports.length - 1];
+			const hasFallback = transportType === "auto" && currentTransportType === "streamable-http" && !isLastTransport;
+			const transport = this.getTransport(currentTransportType);
+			try {
+				await this.client.connect(transport);
+				this.lastConnectedTransport = currentTransportType;
+				const url = this.url.toString();
+				this._onObservabilityEvent.fire({
+					type: "mcp:client:connect",
+					displayMessage: `Connected successfully using ${currentTransportType} transport for ${url}`,
+					payload: {
+						url,
+						transport: currentTransportType,
+						state: this.connectionState
+					},
+					timestamp: Date.now(),
+					id: nanoid()
+				});
+				break;
+			} catch (e) {
+				const error = e instanceof Error ? e : new Error(String(e));
+				if (isUnauthorized(error)) throw e;
+				if (hasFallback && isTransportNotImplemented(error)) {
+					const url = this.url.toString();
+					this._onObservabilityEvent.fire({
+						type: "mcp:client:connect",
+						displayMessage: `${currentTransportType} transport not available, trying ${transports[transports.indexOf(currentTransportType) + 1]} for ${url}`,
+						payload: {
+							url,
+							transport: currentTransportType,
+							state: this.connectionState
+						},
+						timestamp: Date.now(),
+						id: nanoid()
+					});
+					continue;
+				}
+				throw e;
+			}
+		}
+		this.client.setRequestHandler(ElicitRequestSchema, async (request) => {
+			return await this.handleElicitationRequest(request);
+		});
+	}
+	_capabilityErrorHandler(empty, method) {
+		return (e) => {
+			if (e.code === -32601) {
+				const url = this.url.toString();
+				this._onObservabilityEvent.fire({
+					type: "mcp:client:discover",
+					displayMessage: `The server advertised support for the capability ${method.split("/")[0]}, but returned "Method not found" for '${method}' for ${url}`,
+					payload: {
+						url,
+						capability: method.split("/")[0],
+						error: toErrorMessage(e)
+					},
+					timestamp: Date.now(),
+					id: nanoid()
+				});
+				return empty;
+			}
+			throw e;
+		};
+	}
+};
+/**
+* Utility class that aggregates multiple MCP clients into one
+*/
+var MCPClientManager = class {
+	/**
+	* @param _name Name of the MCP client
+	* @param _version Version of the MCP Client
+	* @param auth Auth paramters if being used to create a DurableObjectOAuthClientProvider
+	*/
+	constructor(_name, _version) {
+		this._name = _name;
+		this._version = _version;
+		this.mcpConnections = {};
+		this._callbackUrls = [];
+		this._didWarnAboutUnstableGetAITools = false;
+		this._connectionDisposables = /* @__PURE__ */ new Map();
+		this._onObservabilityEvent = new Emitter();
+		this.onObservabilityEvent = this._onObservabilityEvent.event;
+		this._onConnected = new Emitter();
+		this.onConnected = this._onConnected.event;
+	}
+	/**
+	* Connect to and register an MCP server
+	*
+	* @param transportConfig Transport config
+	* @param clientConfig Client config
+	* @param capabilities Client capabilities (i.e. if the client supports roots/sampling)
+	*/
+	async connect(url, options = {}) {
+		/**
+		* We need to delay loading ai sdk, because putting it in module scope is
+		* causing issues with startup time.
+		* The only place it's used is in getAITools, which only matters after
+		* .connect() is called on at least one server.
+		* So it's safe to delay loading it until .connect() is called.
+		*/
+		if (!this.jsonSchema) {
+			const { jsonSchema } = await import("ai");
+			this.jsonSchema = jsonSchema;
+		}
+		const id = options.reconnect?.id ?? nanoid(8);
+		if (options.transport?.authProvider) {
+			options.transport.authProvider.serverId = id;
+			if (options.reconnect?.oauthClientId) options.transport.authProvider.clientId = options.reconnect?.oauthClientId;
+		}
+		if (!options.reconnect?.oauthCode || !this.mcpConnections[id]) {
+			const normalizedTransport = {
+				...options.transport,
+				type: options.transport?.type ?? "auto"
+			};
+			this.mcpConnections[id] = new MCPClientConnection(new URL(url), {
+				name: this._name,
+				version: this._version
+			}, {
+				client: options.client ?? {},
+				transport: normalizedTransport
+			});
+			const store = new DisposableStore();
+			const existing = this._connectionDisposables.get(id);
+			if (existing) existing.dispose();
+			this._connectionDisposables.set(id, store);
+			store.add(this.mcpConnections[id].onObservabilityEvent((event) => {
+				this._onObservabilityEvent.fire(event);
+			}));
+		}
+		await this.mcpConnections[id].init();
+		if (options.reconnect?.oauthCode) try {
+			await this.mcpConnections[id].completeAuthorization(options.reconnect.oauthCode);
+			await this.mcpConnections[id].establishConnection();
+		} catch (error) {
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:connect",
+				displayMessage: `Failed to complete OAuth reconnection for ${id} for ${url}`,
+				payload: {
+					url,
+					transport: options.transport?.type ?? "auto",
+					state: this.mcpConnections[id].connectionState,
+					error: toErrorMessage(error)
+				},
+				timestamp: Date.now(),
+				id
+			});
+			throw error;
+		}
+		const authUrl = options.transport?.authProvider?.authUrl;
+		if (this.mcpConnections[id].connectionState === "authenticating" && authUrl && options.transport?.authProvider?.redirectUrl) {
+			this._callbackUrls.push(options.transport.authProvider.redirectUrl.toString());
+			return {
+				authUrl,
+				clientId: options.transport?.authProvider?.clientId,
+				id
+			};
+		}
+		return { id };
+	}
+	isCallbackRequest(req) {
+		return req.method === "GET" && !!this._callbackUrls.find((url) => {
+			return req.url.startsWith(url);
+		});
+	}
+	async handleCallbackRequest(req) {
+		const url = new URL(req.url);
+		const urlMatch = this._callbackUrls.find((url$1) => {
+			return req.url.startsWith(url$1);
+		});
+		if (!urlMatch) throw new Error(`No callback URI match found for the request url: ${req.url}. Was the request matched with \`isCallbackRequest()\`?`);
+		const code = url.searchParams.get("code");
+		const state = url.searchParams.get("state");
+		const error = url.searchParams.get("error");
+		const errorDescription = url.searchParams.get("error_description");
+		const urlParams = urlMatch.split("/");
+		const serverId = urlParams[urlParams.length - 1];
+		if (error) return {
+			serverId,
+			authSuccess: false,
+			authError: errorDescription || error
+		};
+		if (!code) throw new Error("Unauthorized: no code provided");
+		if (!state) throw new Error("Unauthorized: no state provided");
+		if (this.mcpConnections[serverId] === void 0) throw new Error(`Could not find serverId: ${serverId}`);
+		if (this.mcpConnections[serverId].connectionState !== "authenticating") throw new Error("Failed to authenticate: the client isn't in the `authenticating` state");
+		const conn = this.mcpConnections[serverId];
+		if (!conn.options.transport.authProvider) throw new Error("Trying to finalize authentication for a server connection without an authProvider");
+		const clientId = conn.options.transport.authProvider.clientId || state;
+		conn.options.transport.authProvider.clientId = clientId;
+		conn.options.transport.authProvider.serverId = serverId;
+		try {
+			await conn.completeAuthorization(code);
+			return {
+				serverId,
+				authSuccess: true
+			};
+		} catch (error$1) {
+			return {
+				serverId,
+				authSuccess: false,
+				authError: error$1 instanceof Error ? error$1.message : String(error$1)
+			};
+		}
+	}
+	/**
+	* Establish connection in the background after OAuth completion
+	* This method is called asynchronously and doesn't block the OAuth callback response
+	* @param serverId The server ID to establish connection for
+	*/
+	async establishConnection(serverId) {
+		const conn = this.mcpConnections[serverId];
+		if (!conn) {
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:preconnect",
+				displayMessage: `Connection not found for serverId: ${serverId}`,
+				payload: { serverId },
+				timestamp: Date.now(),
+				id: nanoid()
+			});
+			return;
+		}
+		try {
+			await conn.establishConnection();
+			this._onConnected.fire(serverId);
+		} catch (error) {
+			const url = conn.url.toString();
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:connect",
+				displayMessage: `Failed to establish connection to server ${serverId} with url ${url}`,
+				payload: {
+					url,
+					transport: conn.options.transport.type ?? "auto",
+					state: conn.connectionState,
+					error: toErrorMessage(error)
+				},
+				timestamp: Date.now(),
+				id: nanoid()
+			});
+		}
+	}
+	/**
+	* Register a callback URL for OAuth handling
+	* @param url The callback URL to register
+	*/
+	registerCallbackUrl(url) {
+		if (!this._callbackUrls.includes(url)) this._callbackUrls.push(url);
+	}
+	/**
+	* Unregister a callback URL
+	* @param serverId The server ID whose callback URL should be removed
+	*/
+	unregisterCallbackUrl(serverId) {
+		this._callbackUrls = this._callbackUrls.filter((url) => !url.endsWith(`/${serverId}`));
+	}
+	/**
+	* Configure OAuth callback handling
+	* @param config OAuth callback configuration
+	*/
+	configureOAuthCallback(config) {
+		this._oauthCallbackConfig = config;
+	}
+	/**
+	* Get the current OAuth callback configuration
+	* @returns The current OAuth callback configuration
+	*/
+	getOAuthCallbackConfig() {
+		return this._oauthCallbackConfig;
+	}
+	/**
+	* @returns namespaced list of tools
+	*/
+	listTools() {
+		return getNamespacedData(this.mcpConnections, "tools");
+	}
+	/**
+	* @returns a set of tools that you can use with the AI SDK
+	*/
+	getAITools() {
+		return Object.fromEntries(getNamespacedData(this.mcpConnections, "tools").map((tool) => {
+			return [`tool_${tool.serverId.replace(/-/g, "")}_${tool.name}`, {
+				description: tool.description,
+				execute: async (args) => {
+					const result = await this.callTool({
+						arguments: args,
+						name: tool.name,
+						serverId: tool.serverId
+					});
+					if (result.isError) throw new Error(result.content[0].text);
+					return result;
+				},
+				inputSchema: this.jsonSchema(tool.inputSchema),
+				outputSchema: tool.outputSchema ? this.jsonSchema(tool.outputSchema) : void 0
+			}];
+		}));
+	}
+	/**
+	* @deprecated this has been renamed to getAITools(), and unstable_getAITools will be removed in the next major version
+	* @returns a set of tools that you can use with the AI SDK
+	*/
+	unstable_getAITools() {
+		if (!this._didWarnAboutUnstableGetAITools) {
+			this._didWarnAboutUnstableGetAITools = true;
+			console.warn("unstable_getAITools is deprecated, use getAITools instead. unstable_getAITools will be removed in the next major version.");
+		}
+		return this.getAITools();
+	}
+	/**
+	* Closes all connections to MCP servers
+	*/
+	async closeAllConnections() {
+		const ids = Object.keys(this.mcpConnections);
+		await Promise.all(ids.map(async (id) => {
+			await this.mcpConnections[id].client.close();
+		}));
+		for (const id of ids) {
+			const store = this._connectionDisposables.get(id);
+			if (store) store.dispose();
+			this._connectionDisposables.delete(id);
+			delete this.mcpConnections[id];
+		}
+	}
+	/**
+	* Closes a connection to an MCP server
+	* @param id The id of the connection to close
+	*/
+	async closeConnection(id) {
+		if (!this.mcpConnections[id]) throw new Error(`Connection with id "${id}" does not exist.`);
+		await this.mcpConnections[id].client.close();
+		delete this.mcpConnections[id];
+		const store = this._connectionDisposables.get(id);
+		if (store) store.dispose();
+		this._connectionDisposables.delete(id);
+	}
+	/**
+	* Dispose the manager and all resources.
+	*/
+	async dispose() {
+		try {
+			await this.closeAllConnections();
+		} finally {
+			this._onConnected.dispose();
+			this._onObservabilityEvent.dispose();
+		}
+	}
+	/**
+	* @returns namespaced list of prompts
+	*/
+	listPrompts() {
+		return getNamespacedData(this.mcpConnections, "prompts");
+	}
+	/**
+	* @returns namespaced list of tools
+	*/
+	listResources() {
+		return getNamespacedData(this.mcpConnections, "resources");
+	}
+	/**
+	* @returns namespaced list of resource templates
+	*/
+	listResourceTemplates() {
+		return getNamespacedData(this.mcpConnections, "resourceTemplates");
+	}
+	/**
+	* Namespaced version of callTool
+	*/
+	async callTool(params, resultSchema, options) {
+		const unqualifiedName = params.name.replace(`${params.serverId}.`, "");
+		return this.mcpConnections[params.serverId].client.callTool({
+			...params,
+			name: unqualifiedName
+		}, resultSchema, options);
+	}
+	/**
+	* Namespaced version of readResource
+	*/
+	readResource(params, options) {
+		return this.mcpConnections[params.serverId].client.readResource(params, options);
+	}
+	/**
+	* Namespaced version of getPrompt
+	*/
+	getPrompt(params, options) {
+		return this.mcpConnections[params.serverId].client.getPrompt(params, options);
+	}
+};
+function getNamespacedData(mcpClients, type) {
+	return Object.entries(mcpClients).map(([name, conn]) => {
+		return {
+			data: conn[type],
+			name
+		};
+	}).flatMap(({ name: serverId, data }) => {
+		return data.map((item) => {
+			return {
+				...item,
+				serverId
+			};
+		});
+	});
+}
+
+//#endregion
+//#region ../agents/dist/do-oauth-client-provider-CswoD5Lu.js
+var DurableObjectOAuthClientProvider = class {
+	constructor(storage, clientName, baseRedirectUrl) {
+		this.storage = storage;
+		this.clientName = clientName;
+		this.baseRedirectUrl = baseRedirectUrl;
+	}
+	get clientMetadata() {
+		return {
+			client_name: this.clientName,
+			client_uri: this.clientUri,
+			grant_types: ["authorization_code", "refresh_token"],
+			redirect_uris: [this.redirectUrl],
+			response_types: ["code"],
+			token_endpoint_auth_method: "none"
+		};
+	}
+	get clientUri() {
+		return new URL(this.redirectUrl).origin;
+	}
+	get redirectUrl() {
+		return `${this.baseRedirectUrl}/${this.serverId}`;
+	}
+	get clientId() {
+		if (!this._clientId_) throw new Error("Trying to access clientId before it was set");
+		return this._clientId_;
+	}
+	set clientId(clientId_) {
+		this._clientId_ = clientId_;
+	}
+	get serverId() {
+		if (!this._serverId_) throw new Error("Trying to access serverId before it was set");
+		return this._serverId_;
+	}
+	set serverId(serverId_) {
+		this._serverId_ = serverId_;
+	}
+	keyPrefix(clientId) {
+		return `/${this.clientName}/${this.serverId}/${clientId}`;
+	}
+	clientInfoKey(clientId) {
+		return `${this.keyPrefix(clientId)}/client_info/`;
+	}
+	async clientInformation() {
+		if (!this._clientId_) return;
+		return await this.storage.get(this.clientInfoKey(this.clientId)) ?? void 0;
+	}
+	async saveClientInformation(clientInformation) {
+		await this.storage.put(this.clientInfoKey(clientInformation.client_id), clientInformation);
+		this.clientId = clientInformation.client_id;
+	}
+	tokenKey(clientId) {
+		return `${this.keyPrefix(clientId)}/token`;
+	}
+	async tokens() {
+		if (!this._clientId_) return;
+		return await this.storage.get(this.tokenKey(this.clientId)) ?? void 0;
+	}
+	async saveTokens(tokens) {
+		await this.storage.put(this.tokenKey(this.clientId), tokens);
+	}
+	get authUrl() {
+		return this._authUrl_;
+	}
+	/**
+	* Because this operates on the server side (but we need browser auth), we send this url back to the user
+	* and require user interact to initiate the redirect flow
+	*/
+	async redirectToAuthorization(authUrl) {
+		const stateToken = nanoid();
+		authUrl.searchParams.set("state", stateToken);
+		this._authUrl_ = authUrl.toString();
+	}
+	codeVerifierKey(clientId) {
+		return `${this.keyPrefix(clientId)}/code_verifier`;
+	}
+	async saveCodeVerifier(verifier) {
+		const key = this.codeVerifierKey(this.clientId);
+		if (await this.storage.get(key)) return;
+		await this.storage.put(key, verifier);
+	}
+	async codeVerifier() {
+		const codeVerifier = await this.storage.get(this.codeVerifierKey(this.clientId));
+		if (!codeVerifier) throw new Error("No code verifier found");
+		return codeVerifier;
+	}
+};
+
+//#endregion
+//#region ../agents/dist/src-C8K3lu37.js
+/**
+* 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;
+}
+/**
+* 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();
+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$1 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$1) {
+		super(ctx, env$1);
+		this._state = DEFAULT_STATE;
+		this._disposables = new DisposableStore();
+		this._mcpStateRestored = false;
+		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 () => {
+				await this._ensureMcpStateRestored();
+				if (this.mcp.isCallbackRequest(request)) {
+					const result = await this.mcp.handleCallbackRequest(request);
+					this.broadcastMcpServers();
+					if (result.authSuccess) {
+						this.clearMcpServerAuthUrl(result.serverId);
+						this.mcp.establishConnection(result.serverId).catch((error) => {
+							console.error("Background connection failed:", error);
+						}).finally(() => {
+							this.broadcastMcpServers();
+						});
+					}
+					return this.handleOAuthCallbackResponse(result, request);
+				}
+				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(async () => {
+					await this._ensureMcpStateRestored();
+					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$1.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]);
+	}
+	async _ensureMcpStateRestored() {
+		if (this._mcpStateRestored) return;
+		this._mcpStateRestored = true;
+		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) return;
+		for (const server of servers) if (server.callback_url) this.mcp.registerCallbackUrl(`${server.callback_url}/${server.id}`);
+		for (const server of servers) if (!!server.auth_url) {
+			const authProvider = new DurableObjectOAuthClientProvider(this.ctx.storage, this.name, server.callback_url);
+			authProvider.serverId = server.id;
+			if (server.client_id) authProvider.clientId = server.client_id;
+			const parsedOptions = server.server_options ? JSON.parse(server.server_options) : void 0;
+			const conn = new MCPClientConnection(new URL(server.server_url), {
+				name: this.name,
+				version: "1.0.0"
+			}, {
+				client: parsedOptions?.client ?? {},
+				transport: {
+					...parsedOptions?.transport ?? {},
+					type: parsedOptions?.transport?.type ?? "auto",
+					authProvider
+				}
+			});
+			conn.connectionState = "authenticating";
+			this.mcp.mcpConnections[server.id] = conn;
+		} else {
+			const parsedOptions = server.server_options ? JSON.parse(server.server_options) : void 0;
+			this._connectToMcpServerInternal(server.name, server.server_url, server.callback_url, parsedOptions, {
+				id: server.id,
+				oauthClientId: server.client_id ?? void 0
+			}).catch((error) => {
+				console.error(`Error restoring ${server.id}:`, error);
+			});
+		}
+	}
+	/**
+	* 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 result = await this._connectToMcpServerInternal(serverName, url, callbackUrl, options);
+		this.sql`
+        INSERT
+        OR REPLACE INTO cf_agents_mcp_servers (id, name, server_url, client_id, auth_url, callback_url, server_options)
+      VALUES (
+        ${result.id},
+        ${serverName},
+        ${url},
+        ${result.clientId ?? null},
+        ${result.authUrl ?? null},
+        ${callbackUrl},
+        ${options ? JSON.stringify(options) : null}
+        );
+    `;
+		this.broadcastMcpServers();
+		return result;
+	}
+	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();
+	}
+	/**
+	* Clear the auth_url for an MCP server after successful OAuth authentication
+	* This prevents the agent from continuously asking for OAuth on reconnect
+	* @param id The server ID to clear auth_url for
+	*/
+	clearMcpServerAuthUrl(id) {
+		this.sql`
+      UPDATE cf_agents_mcp_servers
+      SET auth_url = NULL
+      WHERE id = ${id}
+    `;
+	}
+	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);
+		const baseOrigin = new URL(request.url).origin;
+		if (config?.successRedirect && result.authSuccess) try {
+			return Response.redirect(new URL(config.successRedirect, baseOrigin).href);
+		} catch (e) {
+			console.error("Invalid successRedirect URL:", config.successRedirect, e);
+			return Response.redirect(baseOrigin);
+		}
+		if (config?.errorRedirect && !result.authSuccess) try {
+			const errorUrl = `${config.errorRedirect}?error=${encodeURIComponent(result.authError || "Unknown error")}`;
+			return Response.redirect(new URL(errorUrl, baseOrigin).href);
+		} catch (e) {
+			console.error("Invalid errorRedirect URL:", config.errorRedirect, e);
+			return Response.redirect(baseOrigin);
+		}
+		return Response.redirect(baseOrigin);
+	}
+};
+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$1, options) {
+	const corsHeaders = 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) return new Response(null, { headers: corsHeaders });
+		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$1, {
+		prefix: "agents",
+		...options
+	});
+	if (response && corsHeaders && request.headers.get("upgrade")?.toLowerCase() !== "websocket" && request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
+		const newHeaders = new Headers(response.headers);
+		for (const [key, value] of Object.entries(corsHeaders)) newHeaders.set(key, value);
+		response = new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: newHeaders
+		});
+	}
+	return response;
+}
+/**
+* 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
+//#region src/index.ts
+/**
+* Creates a middleware for handling Cloudflare Agents WebSocket and HTTP requests
+* Processes both WebSocket upgrades and standard HTTP requests, delegating them to Cloudflare Agents
+*/
 function agentsMiddleware(ctx) {
-  return createMiddleware(async (c, next) => {
-    try {
-      const handler = isWebSocketUpgrade(c) ? handleWebSocketUpgrade : handleHttpRequest;
-      const response = await handler(c, ctx?.options);
-      return response === null ? await next() : response;
-    } catch (error) {
-      if (ctx?.onError) {
-        ctx.onError(error);
-        return next();
-      }
-      throw error;
-    }
-  });
+	return createMiddleware(async (c, next) => {
+		try {
+			const response = await (isWebSocketUpgrade(c) ? handleWebSocketUpgrade : handleHttpRequest)(c, ctx?.options);
+			return response === null ? await next() : response;
+		} catch (error) {
+			if (ctx?.onError) {
+				ctx.onError(error);
+				return next();
+			}
+			throw error;
+		}
+	});
 }
+/**
+* Checks if the incoming request is a WebSocket upgrade request
+* Looks for the 'upgrade' header with a value of 'websocket' (case-insensitive)
+*/
 function isWebSocketUpgrade(c) {
-  return c.req.header("upgrade")?.toLowerCase() === "websocket";
-}
-function createRequestFromContext(c) {
-  return new Request(c.req.url, {
-    method: c.req.method,
-    headers: c.req.header(),
-    body: c.req.raw.body
-  });
+	return c.req.header("upgrade")?.toLowerCase() === "websocket";
 }
+/**
+* Handles WebSocket upgrade requests
+* Returns a WebSocket upgrade response if successful, null otherwise
+*/
 async function handleWebSocketUpgrade(c, options) {
-  const req = createRequestFromContext(c);
-  const response = await routeAgentRequest(req, env(c), options);
-  if (!response?.webSocket) {
-    return null;
-  }
-  return new Response(null, {
-    status: 101,
-    webSocket: response.webSocket
-  });
+	const response = await routeAgentRequest(c.req.raw, env(c), options);
+	if (!response?.webSocket) return null;
+	return new Response(null, {
+		status: 101,
+		webSocket: response.webSocket
+	});
 }
+/**
+* Handles standard HTTP requests
+* Forwards the request to Cloudflare Agents and returns the response
+*/
 async function handleHttpRequest(c, options) {
-  const req = createRequestFromContext(c);
-  return routeAgentRequest(req, env(c), options);
+	return routeAgentRequest(c.req.raw, env(c), options);
 }
-export {
-  agentsMiddleware
-};
+
+//#endregion
+export { agentsMiddleware };
 //# sourceMappingURL=index.js.map