hono-agents 2.0.6 → 2.0.8

package/dist/index.js

@@ -1,2217 +1,7 @@
-import "partysocket";
-import { nanoid } from "nanoid";
-import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker-provider.js";
-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 { routeAgentRequest } from "agents";
 import { env } from "hono/adapter";
 import { createMiddleware } from "hono/factory";
 
-//#region ../agents/dist/ai-types-CrMqkwc_.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";
-	/** Sent by server when client connects and there's an active stream to resume */
-	MessageType$1["CF_AGENT_STREAM_RESUMING"] = "cf_agent_stream_resuming";
-	/** Sent by client to acknowledge stream resuming notification and request chunks */
-	MessageType$1["CF_AGENT_STREAM_RESUME_ACK"] = "cf_agent_stream_resume_ack";
-	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-B3SR12TQ.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/do-oauth-client-provider-CwqK5SXm.js
-var DurableObjectOAuthClientProvider = class {
-	constructor(storage, clientName, baseRedirectUrl) {
-		this.storage = storage;
-		this.clientName = clientName;
-		this.baseRedirectUrl = baseRedirectUrl;
-		if (!storage) throw new Error("DurableObjectOAuthClientProvider requires a valid DurableObjectStorage instance");
-	}
-	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/client-BZq9qau2.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");
-}
-/**
-* Connection state machine for MCP client connections.
-*
-* State transitions:
-* - Non-OAuth: init() → CONNECTING → DISCOVERING → READY
-* - OAuth: init() → AUTHENTICATING → (callback) → CONNECTING → DISCOVERING → READY
-* - Any state can transition to FAILED on error
-*/
-const MCPConnectionState = {
-	AUTHENTICATING: "authenticating",
-	CONNECTING: "connecting",
-	CONNECTED: "connected",
-	DISCOVERING: "discovering",
-	READY: "ready",
-	FAILED: "failed"
-};
-var MCPClientConnection = class {
-	constructor(url, info, options = {
-		client: {},
-		transport: {}
-	}) {
-		this.url = url;
-		this.options = options;
-		this.connectionState = MCPConnectionState.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, if authentication is required, the connection will be in the AUTHENTICATING state
-	* Sets connection state based on the result and emits observability events
-	*
-	* @returns Error message if connection failed, undefined otherwise
-	*/
-	async init() {
-		const transportType = this.options.transport.type;
-		if (!transportType) throw new Error("Transport type must be specified");
-		const res = await this.tryConnect(transportType);
-		this.connectionState = res.state;
-		if (res.state === MCPConnectionState.CONNECTED && res.transport) {
-			this.client.setRequestHandler(ElicitRequestSchema, async (request) => {
-				return await this.handleElicitationRequest(request);
-			});
-			this.lastConnectedTransport = res.transport;
-			this._onObservabilityEvent.fire({
-				type: "mcp:client:connect",
-				displayMessage: `Connected successfully using ${res.transport} transport for ${this.url.toString()}`,
-				payload: {
-					url: this.url.toString(),
-					transport: res.transport,
-					state: this.connectionState
-				},
-				timestamp: Date.now(),
-				id: nanoid()
-			});
-			return;
-		} else if (res.state === MCPConnectionState.FAILED && res.error) {
-			const errorMessage = toErrorMessage(res.error);
-			this._onObservabilityEvent.fire({
-				type: "mcp:client:connect",
-				displayMessage: `Failed to connect to ${this.url.toString()}: ${errorMessage}`,
-				payload: {
-					url: this.url.toString(),
-					transport: transportType,
-					state: this.connectionState,
-					error: errorMessage
-				},
-				timestamp: Date.now(),
-				id: nanoid()
-			});
-			return errorMessage;
-		}
-	}
-	/**
-	* 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 !== MCPConnectionState.AUTHENTICATING) throw new Error("Connection must be in authenticating state to complete authorization");
-		try {
-			await this.finishAuthProbe(code);
-			this.connectionState = MCPConnectionState.CONNECTING;
-		} catch (error) {
-			this.connectionState = MCPConnectionState.FAILED;
-			throw error;
-		}
-	}
-	/**
-	* Discover server capabilities and register tools, resources, prompts, and templates.
-	* This method does the work but does not manage connection state - that's handled by discover().
-	*/
-	async discoverAndRegister() {
-		this.serverCapabilities = this.client.getServerCapabilities();
-		if (!this.serverCapabilities) throw new Error("The MCP Server failed to return server capabilities");
-		const operations = [];
-		const operationNames = [];
-		operations.push(Promise.resolve(this.client.getInstructions()));
-		operationNames.push("instructions");
-		if (this.serverCapabilities.tools) {
-			operations.push(this.registerTools());
-			operationNames.push("tools");
-		}
-		if (this.serverCapabilities.resources) {
-			operations.push(this.registerResources());
-			operationNames.push("resources");
-		}
-		if (this.serverCapabilities.prompts) {
-			operations.push(this.registerPrompts());
-			operationNames.push("prompts");
-		}
-		if (this.serverCapabilities.resources) {
-			operations.push(this.registerResourceTemplates());
-			operationNames.push("resource templates");
-		}
-		try {
-			const results = await Promise.all(operations);
-			for (let i = 0; i < results.length; i++) {
-				const result = results[i];
-				switch (operationNames[i]) {
-					case "instructions":
-						this.instructions = result;
-						break;
-					case "tools":
-						this.tools = result;
-						break;
-					case "resources":
-						this.resources = result;
-						break;
-					case "prompts":
-						this.prompts = result;
-						break;
-					case "resource templates":
-						this.resourceTemplates = result;
-						break;
-				}
-			}
-		} catch (error) {
-			this._onObservabilityEvent.fire({
-				type: "mcp:client:discover",
-				displayMessage: `Failed to discover capabilities for ${this.url.toString()}: ${toErrorMessage(error)}`,
-				payload: {
-					url: this.url.toString(),
-					error: toErrorMessage(error)
-				},
-				timestamp: Date.now(),
-				id: nanoid()
-			});
-			throw error;
-		}
-	}
-	/**
-	* Discover server capabilities with timeout and cancellation support.
-	* If called while a previous discovery is in-flight, the previous discovery will be aborted.
-	*
-	* @param options Optional configuration
-	* @param options.timeoutMs Timeout in milliseconds (default: 15000)
-	* @returns Result indicating success/failure with optional error message
-	*/
-	async discover(options = {}) {
-		const { timeoutMs = 15e3 } = options;
-		if (this.connectionState !== MCPConnectionState.CONNECTED && this.connectionState !== MCPConnectionState.READY) {
-			this._onObservabilityEvent.fire({
-				type: "mcp:client:discover",
-				displayMessage: `Discovery skipped for ${this.url.toString()}, state is ${this.connectionState}`,
-				payload: {
-					url: this.url.toString(),
-					state: this.connectionState
-				},
-				timestamp: Date.now(),
-				id: nanoid()
-			});
-			return {
-				success: false,
-				error: `Discovery skipped - connection in ${this.connectionState} state`
-			};
-		}
-		if (this._discoveryAbortController) {
-			this._discoveryAbortController.abort();
-			this._discoveryAbortController = void 0;
-		}
-		const abortController = new AbortController();
-		this._discoveryAbortController = abortController;
-		this.connectionState = MCPConnectionState.DISCOVERING;
-		let timeoutId;
-		try {
-			const timeoutPromise = new Promise((_, reject) => {
-				timeoutId = setTimeout(() => reject(/* @__PURE__ */ new Error(`Discovery timed out after ${timeoutMs}ms`)), timeoutMs);
-			});
-			if (abortController.signal.aborted) throw new Error("Discovery was cancelled");
-			const abortPromise = new Promise((_, reject) => {
-				abortController.signal.addEventListener("abort", () => {
-					reject(/* @__PURE__ */ new Error("Discovery was cancelled"));
-				});
-			});
-			await Promise.race([
-				this.discoverAndRegister(),
-				timeoutPromise,
-				abortPromise
-			]);
-			if (timeoutId !== void 0) clearTimeout(timeoutId);
-			this.connectionState = MCPConnectionState.READY;
-			this._onObservabilityEvent.fire({
-				type: "mcp:client:discover",
-				displayMessage: `Discovery completed for ${this.url.toString()}`,
-				payload: { url: this.url.toString() },
-				timestamp: Date.now(),
-				id: nanoid()
-			});
-			return { success: true };
-		} catch (e) {
-			if (timeoutId !== void 0) clearTimeout(timeoutId);
-			this.connectionState = MCPConnectionState.CONNECTED;
-			return {
-				success: false,
-				error: e instanceof Error ? e.message : String(e)
-			};
-		} finally {
-			this._discoveryAbortController = void 0;
-		}
-	}
-	/**
-	* Cancel any in-flight discovery operation.
-	* Called when closing the connection.
-	*/
-	cancelDiscovery() {
-		if (this._discoveryAbortController) {
-			this._discoveryAbortController.abort();
-			this._discoveryAbortController = void 0;
-		}
-	}
-	/**
-	* Notification handler registration for tools
-	* Should only be called if serverCapabilities.tools exists
-	*/
-	async registerTools() {
-		if (this.serverCapabilities?.tools?.listChanged) this.client.setNotificationHandler(ToolListChangedNotificationSchema, async (_notification) => {
-			this.tools = await this.fetchTools();
-		});
-		return this.fetchTools();
-	}
-	/**
-	* Notification handler registration for resources
-	* Should only be called if serverCapabilities.resources exists
-	*/
-	async registerResources() {
-		if (this.serverCapabilities?.resources?.listChanged) this.client.setNotificationHandler(ResourceListChangedNotificationSchema, async (_notification) => {
-			this.resources = await this.fetchResources();
-		});
-		return this.fetchResources();
-	}
-	/**
-	* Notification handler registration for prompts
-	* Should only be called if serverCapabilities.prompts exists
-	*/
-	async registerPrompts() {
-		if (this.serverCapabilities?.prompts?.listChanged) this.client.setNotificationHandler(PromptListChangedNotificationSchema, async (_notification) => {
-			this.prompts = await this.fetchPrompts();
-		});
-		return this.fetchPrompts();
-	}
-	async registerResourceTemplates() {
-		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);
-				return {
-					state: MCPConnectionState.CONNECTED,
-					transport: currentTransportType
-				};
-			} catch (e) {
-				const error = e instanceof Error ? e : new Error(String(e));
-				if (isUnauthorized(error)) return { state: MCPConnectionState.AUTHENTICATING };
-				if (isTransportNotImplemented(error) && hasFallback) continue;
-				return {
-					state: MCPConnectionState.FAILED,
-					error
-				};
-			}
-		}
-		return {
-			state: MCPConnectionState.FAILED,
-			error: /* @__PURE__ */ new Error("No transports available")
-		};
-	}
-	_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;
-		};
-	}
-};
-const defaultClientOptions = { jsonSchemaValidator: new CfWorkerJsonSchemaValidator() };
-/**
-* 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 options Storage adapter for persisting MCP server state
-	*/
-	constructor(_name, _version, options) {
-		this._name = _name;
-		this._version = _version;
-		this.mcpConnections = {};
-		this._didWarnAboutUnstableGetAITools = false;
-		this._connectionDisposables = /* @__PURE__ */ new Map();
-		this._isRestored = false;
-		this._onObservabilityEvent = new Emitter();
-		this.onObservabilityEvent = this._onObservabilityEvent.event;
-		this._onServerStateChanged = new Emitter();
-		this.onServerStateChanged = this._onServerStateChanged.event;
-		if (!options.storage) throw new Error("MCPClientManager requires a valid DurableObjectStorage instance");
-		this._storage = options.storage;
-	}
-	sql(query, ...bindings) {
-		return [...this._storage.sql.exec(query, ...bindings)];
-	}
-	saveServerToStorage(server) {
-		this.sql(`INSERT OR REPLACE INTO cf_agents_mcp_servers (
-        id, name, server_url, client_id, auth_url, callback_url, server_options
-      ) VALUES (?, ?, ?, ?, ?, ?, ?)`, server.id, server.name, server.server_url, server.client_id ?? null, server.auth_url ?? null, server.callback_url, server.server_options ?? null);
-	}
-	removeServerFromStorage(serverId) {
-		this.sql("DELETE FROM cf_agents_mcp_servers WHERE id = ?", serverId);
-	}
-	getServersFromStorage() {
-		return this.sql("SELECT id, name, server_url, client_id, auth_url, callback_url, server_options FROM cf_agents_mcp_servers");
-	}
-	clearServerAuthUrl(serverId) {
-		this.sql("UPDATE cf_agents_mcp_servers SET auth_url = NULL WHERE id = ?", serverId);
-	}
-	/**
-	* Create an auth provider for a server
-	* @internal
-	*/
-	createAuthProvider(serverId, callbackUrl, clientName, clientId) {
-		if (!this._storage) throw new Error("Cannot create auth provider: storage is not initialized");
-		const authProvider = new DurableObjectOAuthClientProvider(this._storage, clientName, callbackUrl);
-		authProvider.serverId = serverId;
-		if (clientId) authProvider.clientId = clientId;
-		return authProvider;
-	}
-	/**
-	* Restore MCP server connections from storage
-	* This method is called on Agent initialization to restore previously connected servers
-	*
-	* @param clientName Name to use for OAuth client (typically the agent instance name)
-	*/
-	async restoreConnectionsFromStorage(clientName) {
-		if (this._isRestored) return;
-		const servers = this.getServersFromStorage();
-		if (!servers || servers.length === 0) {
-			this._isRestored = true;
-			return;
-		}
-		for (const server of servers) {
-			const existingConn = this.mcpConnections[server.id];
-			if (existingConn) {
-				if (existingConn.connectionState === MCPConnectionState.READY) {
-					console.warn(`[MCPClientManager] Server ${server.id} already has a ready connection. Skipping recreation.`);
-					continue;
-				}
-				if (existingConn.connectionState === MCPConnectionState.AUTHENTICATING || existingConn.connectionState === MCPConnectionState.CONNECTING || existingConn.connectionState === MCPConnectionState.DISCOVERING) continue;
-				if (existingConn.connectionState === MCPConnectionState.FAILED) {
-					try {
-						await existingConn.client.close();
-					} catch (error) {
-						console.warn(`[MCPClientManager] Error closing failed connection ${server.id}:`, error);
-					}
-					delete this.mcpConnections[server.id];
-					this._connectionDisposables.get(server.id)?.dispose();
-					this._connectionDisposables.delete(server.id);
-				}
-			}
-			const parsedOptions = server.server_options ? JSON.parse(server.server_options) : null;
-			const authProvider = this.createAuthProvider(server.id, server.callback_url, clientName, server.client_id ?? void 0);
-			const conn = this.createConnection(server.id, server.server_url, {
-				client: parsedOptions?.client ?? {},
-				transport: {
-					...parsedOptions?.transport ?? {},
-					type: parsedOptions?.transport?.type ?? "auto",
-					authProvider
-				}
-			});
-			if (server.auth_url) {
-				conn.connectionState = MCPConnectionState.AUTHENTICATING;
-				continue;
-			}
-			this._restoreServer(server.id);
-		}
-		this._isRestored = true;
-	}
-	/**
-	* Internal method to restore a single server connection and discovery
-	*/
-	async _restoreServer(serverId) {
-		if ((await this.connectToServer(serverId).catch((error) => {
-			console.error(`Error connecting to ${serverId}:`, error);
-			return null;
-		}))?.state === MCPConnectionState.CONNECTED) {
-			const discoverResult = await this.discoverIfConnected(serverId);
-			if (discoverResult && !discoverResult.success) console.error(`Error discovering ${serverId}:`, discoverResult.error);
-		}
-	}
-	/**
-	* Connect to and register an MCP server
-	*
-	* @deprecated This method is maintained for backward compatibility.
-	* For new code, use registerServer() and connectToServer() separately.
-	*
-	* @param url Server URL
-	* @param options Connection options
-	* @returns Object with server ID, auth URL (if OAuth), and client ID (if OAuth)
-	*/
-	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.
-		*/
-		await this.ensureJsonSchema();
-		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].init();
-		} 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 === MCPConnectionState.AUTHENTICATING && authUrl && options.transport?.authProvider?.redirectUrl) return {
-			authUrl,
-			clientId: options.transport?.authProvider?.clientId,
-			id
-		};
-		const discoverResult = await this.discoverIfConnected(id);
-		if (discoverResult && !discoverResult.success) throw new Error(`Failed to discover server capabilities: ${discoverResult.error}`);
-		return { id };
-	}
-	/**
-	* Create an in-memory connection object and set up observability
-	* Does NOT save to storage - use registerServer() for that
-	* @returns The connection object (existing or newly created)
-	*/
-	createConnection(id, url, options) {
-		if (this.mcpConnections[id]) return 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: {
-				...defaultClientOptions,
-				...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);
-		}));
-		return this.mcpConnections[id];
-	}
-	/**
-	* Register an MCP server connection without connecting
-	* Creates the connection object, sets up observability, and saves to storage
-	*
-	* @param id Server ID
-	* @param options Registration options including URL, name, callback URL, and connection config
-	* @returns Server ID
-	*/
-	async registerServer(id, options) {
-		this.createConnection(id, options.url, {
-			client: options.client,
-			transport: {
-				...options.transport,
-				type: options.transport?.type ?? "auto"
-			}
-		});
-		const { authProvider: _, ...transportWithoutAuth } = options.transport ?? {};
-		this.saveServerToStorage({
-			id,
-			name: options.name,
-			server_url: options.url,
-			callback_url: options.callbackUrl,
-			client_id: options.clientId ?? null,
-			auth_url: options.authUrl ?? null,
-			server_options: JSON.stringify({
-				client: options.client,
-				transport: transportWithoutAuth
-			})
-		});
-		this._onServerStateChanged.fire();
-		return id;
-	}
-	/**
-	* Connect to an already registered MCP server and initialize the connection.
-	*
-	* For OAuth servers, returns `{ state: "authenticating", authUrl, clientId? }`.
-	* The user must complete the OAuth flow via the authUrl, which triggers a
-	* callback handled by `handleCallbackRequest()`.
-	*
-	* For non-OAuth servers, establishes the transport connection and returns
-	* `{ state: "connected" }`. Call `discoverIfConnected()` afterwards to
-	* discover capabilities and transition to "ready" state.
-	*
-	* @param id Server ID (must be registered first via registerServer())
-	* @returns Connection result with current state and OAuth info (if applicable)
-	*/
-	async connectToServer(id) {
-		const conn = this.mcpConnections[id];
-		if (!conn) throw new Error(`Server ${id} is not registered. Call registerServer() first.`);
-		const error = await conn.init();
-		this._onServerStateChanged.fire();
-		switch (conn.connectionState) {
-			case MCPConnectionState.FAILED: return {
-				state: conn.connectionState,
-				error: error ?? "Unknown connection error"
-			};
-			case MCPConnectionState.AUTHENTICATING: {
-				const authUrl = conn.options.transport.authProvider?.authUrl;
-				const redirectUrl = conn.options.transport.authProvider?.redirectUrl;
-				if (!authUrl || !redirectUrl) return {
-					state: MCPConnectionState.FAILED,
-					error: `OAuth configuration incomplete: missing ${!authUrl ? "authUrl" : "redirectUrl"}`
-				};
-				const clientId = conn.options.transport.authProvider?.clientId;
-				const serverRow = this.getServersFromStorage().find((s) => s.id === id);
-				if (serverRow) this.saveServerToStorage({
-					...serverRow,
-					auth_url: authUrl,
-					client_id: clientId ?? null
-				});
-				return {
-					state: conn.connectionState,
-					authUrl,
-					clientId
-				};
-			}
-			case MCPConnectionState.CONNECTED: return { state: conn.connectionState };
-			default: return {
-				state: MCPConnectionState.FAILED,
-				error: `Unexpected connection state after init: ${conn.connectionState}`
-			};
-		}
-	}
-	isCallbackRequest(req) {
-		if (req.method !== "GET") return false;
-		if (!req.url.includes("/callback")) return false;
-		return this.getServersFromStorage().some((server) => server.callback_url && req.url.startsWith(server.callback_url));
-	}
-	async handleCallbackRequest(req) {
-		const url = new URL(req.url);
-		const matchingServer = this.getServersFromStorage().find((server) => {
-			return server.callback_url && req.url.startsWith(server.callback_url);
-		});
-		if (!matchingServer) throw new Error(`No callback URI match found for the request url: ${req.url}. Was the request matched with \`isCallbackRequest()\`?`);
-		const serverId = matchingServer.id;
-		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");
-		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 === MCPConnectionState.READY || this.mcpConnections[serverId].connectionState === MCPConnectionState.CONNECTED) {
-			this.clearServerAuthUrl(serverId);
-			return {
-				serverId,
-				authSuccess: true
-			};
-		}
-		if (this.mcpConnections[serverId].connectionState !== MCPConnectionState.AUTHENTICATING) throw new Error(`Failed to authenticate: the client is in "${this.mcpConnections[serverId].connectionState}" state, expected "authenticating"`);
-		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);
-			this.clearServerAuthUrl(serverId);
-			this._onServerStateChanged.fire();
-			return {
-				serverId,
-				authSuccess: true
-			};
-		} catch (error$1) {
-			const errorMessage = error$1 instanceof Error ? error$1.message : String(error$1);
-			this._onServerStateChanged.fire();
-			return {
-				serverId,
-				authSuccess: false,
-				authError: errorMessage
-			};
-		}
-	}
-	/**
-	* Discover server capabilities if connection is in CONNECTED or READY state.
-	* Transitions to DISCOVERING then READY (or CONNECTED on error).
-	* Can be called to refresh server capabilities (e.g., from a UI refresh button).
-	*
-	* If called while a previous discovery is in-flight for the same server,
-	* the previous discovery will be aborted.
-	*
-	* @param serverId The server ID to discover
-	* @param options Optional configuration
-	* @param options.timeoutMs Timeout in milliseconds (default: 30000)
-	* @returns Result with current state and optional error, or undefined if connection not found
-	*/
-	async discoverIfConnected(serverId, options = {}) {
-		const conn = this.mcpConnections[serverId];
-		if (!conn) {
-			this._onObservabilityEvent.fire({
-				type: "mcp:client:discover",
-				displayMessage: `Connection not found for ${serverId}`,
-				payload: {},
-				timestamp: Date.now(),
-				id: nanoid()
-			});
-			return;
-		}
-		const result = await conn.discover(options);
-		this._onServerStateChanged.fire();
-		return {
-			...result,
-			state: conn.connectionState
-		};
-	}
-	/**
-	* Establish connection in the background after OAuth completion
-	* This method connects to the server and discovers its capabilities
-	* @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;
-		}
-		if (conn.connectionState === MCPConnectionState.DISCOVERING || conn.connectionState === MCPConnectionState.READY) {
-			this._onObservabilityEvent.fire({
-				type: "mcp:client:connect",
-				displayMessage: `establishConnection skipped for ${serverId}, already in ${conn.connectionState} state`,
-				payload: {
-					url: conn.url.toString(),
-					transport: conn.options.transport.type || "unknown",
-					state: conn.connectionState
-				},
-				timestamp: Date.now(),
-				id: nanoid()
-			});
-			return;
-		}
-		const connectResult = await this.connectToServer(serverId);
-		this._onServerStateChanged.fire();
-		if (connectResult.state === MCPConnectionState.CONNECTED) await this.discoverIfConnected(serverId);
-		this._onObservabilityEvent.fire({
-			type: "mcp:client:connect",
-			displayMessage: `establishConnection completed for ${serverId}, final state: ${conn.connectionState}`,
-			payload: {
-				url: conn.url.toString(),
-				transport: conn.options.transport.type || "unknown",
-				state: conn.connectionState
-			},
-			timestamp: Date.now(),
-			id: nanoid()
-		});
-	}
-	/**
-	* 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");
-	}
-	/**
-	* Lazy-loads the jsonSchema function from the AI SDK.
-	*
-	* This defers importing the "ai" package until it's actually needed, which helps reduce
-	* initial bundle size and startup time. The jsonSchema function is required for converting
-	* MCP tools into AI SDK tool definitions via getAITools().
-	*
-	* @internal This method is for internal use only. It's automatically called before operations
-	* that need jsonSchema (like getAITools() or OAuth flows). External consumers should not need
-	* to call this directly.
-	*/
-	async ensureJsonSchema() {
-		if (!this.jsonSchema) {
-			const { jsonSchema } = await import("ai");
-			this.jsonSchema = jsonSchema;
-		}
-	}
-	/**
-	* @returns a set of tools that you can use with the AI SDK
-	*/
-	getAITools() {
-		if (!this.jsonSchema) throw new Error("jsonSchema not initialized.");
-		for (const [id, conn] of Object.entries(this.mcpConnections)) if (conn.connectionState !== MCPConnectionState.READY && conn.connectionState !== MCPConnectionState.AUTHENTICATING) console.warn(`[getAITools] WARNING: Reading tools from connection ${id} in state "${conn.connectionState}". Tools may not be loaded yet.`);
-		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 active in-memory connections to MCP servers.
-	*
-	* Note: This only closes the transport connections - it does NOT remove
-	* servers from storage. Servers will still be listed and their callback
-	* URLs will still match incoming OAuth requests.
-	*
-	* Use removeServer() instead if you want to fully clean up a server
-	* (closes connection AND removes from storage).
-	*/
-	async closeAllConnections() {
-		const ids = Object.keys(this.mcpConnections);
-		for (const id of ids) this.mcpConnections[id].cancelDiscovery();
-		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.`);
-		this.mcpConnections[id].cancelDiscovery();
-		await this.mcpConnections[id].client.close();
-		delete this.mcpConnections[id];
-		const store = this._connectionDisposables.get(id);
-		if (store) store.dispose();
-		this._connectionDisposables.delete(id);
-	}
-	/**
-	* Remove an MCP server - closes connection if active and removes from storage.
-	*/
-	async removeServer(serverId) {
-		if (this.mcpConnections[serverId]) try {
-			await this.closeConnection(serverId);
-		} catch (e) {}
-		this.removeServerFromStorage(serverId);
-		this._onServerStateChanged.fire();
-	}
-	/**
-	* List all MCP servers from storage
-	*/
-	listServers() {
-		return this.getServersFromStorage();
-	}
-	/**
-	* Dispose the manager and all resources.
-	*/
-	async dispose() {
-		try {
-			await this.closeAllConnections();
-		} finally {
-			this._onServerStateChanged.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/src-D_KKH_4c.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._destroyed = false;
-		this._ParentClass = Object.getPrototypeOf(this).constructor;
-		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") {
-					if (this._destroyed) return;
-					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 {
-					if (this._destroyed) return;
-					this.sql`
-          DELETE FROM cf_agents_schedules WHERE id = ${row.id}
-        `;
-				}
-			}
-			if (this._destroyed) return;
-			await this._scheduleNextAlarm();
-		};
-		if (!wrappedClasses.has(this.constructor)) {
-			this._autoWrapCustomMethods();
-			wrappedClasses.add(this.constructor);
-		}
-		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
-        )
-      `;
-		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.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())
-      )
-    `;
-		this.mcp = new MCPClientManager(this._ParentClass.name, "0.0.1", { storage: this.ctx.storage });
-		this._disposables.add(this.mcp.onServerStateChanged(async () => {
-			this.broadcastMcpServers();
-		}));
-		this._disposables.add(this.mcp.onObservabilityEvent((event) => {
-			this.observability?.emit(event);
-		}));
-		const _onRequest = this.onRequest.bind(this);
-		this.onRequest = (request) => {
-			return agentContext.run({
-				agent: this,
-				connection: void 0,
-				request,
-				email: void 0
-			}, async () => {
-				await this.mcp.ensureJsonSchema();
-				const oauthResponse = await this.handleMcpOAuthCallback(request);
-				if (oauthResponse) return oauthResponse;
-				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 () => {
-				await this.mcp.ensureJsonSchema();
-				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
-			}, async () => {
-				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.mcp.restoreConnectionsFromStorage(this.name);
-					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_mcp_servers`;
-		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_queues`;
-		await this.ctx.storage.deleteAlarm();
-		await this.ctx.storage.deleteAll();
-		this._disposables.dispose();
-		await this.mcp.dispose();
-		this._destroyed = true;
-		setTimeout(() => {
-			this.ctx.abort("destroyed");
-		}, 0);
-		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 Server id and state - either "authenticating" with authUrl, or "ready"
-	* @throws If connection or discovery fails
-	*/
-	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`;
-		await this.mcp.ensureJsonSchema();
-		const id = nanoid(8);
-		const authProvider = new DurableObjectOAuthClientProvider(this.ctx.storage, this.name, callbackUrl);
-		authProvider.serverId = id;
-		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 }
-		};
-		await this.mcp.registerServer(id, {
-			url,
-			name: serverName,
-			callbackUrl,
-			client: options?.client,
-			transport: {
-				...headerTransportOpts,
-				authProvider,
-				type: transportType
-			}
-		});
-		const result = await this.mcp.connectToServer(id);
-		if (result.state === MCPConnectionState.FAILED) throw new Error(`Failed to connect to MCP server at ${url}: ${result.error}`);
-		if (result.state === MCPConnectionState.AUTHENTICATING) return {
-			id,
-			state: result.state,
-			authUrl: result.authUrl
-		};
-		const discoverResult = await this.mcp.discoverIfConnected(id);
-		if (discoverResult && !discoverResult.success) throw new Error(`Failed to discover MCP server capabilities: ${discoverResult.error}`);
-		return {
-			id,
-			state: MCPConnectionState.READY
-		};
-	}
-	async removeMcpServer(id) {
-		await this.mcp.removeServer(id);
-	}
-	getMcpServers() {
-		const mcpState = {
-			prompts: this.mcp.listPrompts(),
-			resources: this.mcp.listResources(),
-			servers: {},
-			tools: this.mcp.listTools()
-		};
-		const servers = this.mcp.listServers();
-		if (servers && Array.isArray(servers) && servers.length > 0) for (const server of servers) {
-			const serverConn = this.mcp.mcpConnections[server.id];
-			let defaultState = "not-connected";
-			if (!serverConn && server.auth_url) defaultState = "authenticating";
-			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 ?? defaultState
-			};
-		}
-		return mcpState;
-	}
-	broadcastMcpServers() {
-		this.broadcast(JSON.stringify({
-			mcp: this.getMcpServers(),
-			type: MessageType.CF_AGENT_MCP_SERVERS
-		}));
-	}
-	/**
-	* Handle MCP OAuth callback request if it's an OAuth callback.
-	*
-	* This method encapsulates the entire OAuth callback flow:
-	* 1. Checks if the request is an MCP OAuth callback
-	* 2. Processes the OAuth code exchange
-	* 3. Establishes the connection if successful
-	* 4. Broadcasts MCP server state updates
-	* 5. Returns the appropriate HTTP response
-	*
-	* @param request The incoming HTTP request
-	* @returns Response if this was an OAuth callback, null otherwise
-	*/
-	async handleMcpOAuthCallback(request) {
-		if (!this.mcp.isCallbackRequest(request)) return null;
-		const result = await this.mcp.handleCallbackRequest(request);
-		if (result.authSuccess) this.mcp.establishConnection(result.serverId).catch((error) => {
-			console.error("[Agent handleMcpOAuthCallback] Connection establishment failed:", error);
-		});
-		this.broadcastMcpServers();
-		return this.handleOAuthCallbackResponse(result, request);
-	}
-	/**
-	* 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