agents 0.7.4 → 0.7.6

package/dist/client-K8Z-u76l.js

@@ -0,0 +1,1468 @@
+import { tryN } from "./retries.js";
+import { DurableObjectOAuthClientProvider } from "./mcp/do-oauth-client-provider.js";
+import { nanoid } from "nanoid";
+import { getServerByName } from "partyserver";
+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, JSONRPCMessageSchema, PromptListChangedNotificationSchema, ResourceListChangedNotificationSchema, ToolListChangedNotificationSchema } from "@modelcontextprotocol/sdk/types.js";
+//#region src/core/events.ts
+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();
+	}
+};
+//#endregion
+//#region src/mcp/errors.ts
+function toErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function getErrorCode(error) {
+	if (error && typeof error === "object" && "code" in error && typeof error.code === "number") return error.code;
+}
+function isUnauthorized(error) {
+	if (getErrorCode(error) === 401) return true;
+	const msg = toErrorMessage(error);
+	return msg.includes("Unauthorized") || msg.includes("401");
+}
+function isTransportNotImplemented(error) {
+	const code = getErrorCode(error);
+	if (code === 404 || code === 405) return true;
+	const msg = toErrorMessage(error);
+	return msg.includes("404") || msg.includes("405") || msg.includes("Not Implemented") || msg.includes("not implemented");
+}
+//#endregion
+//#region src/mcp/rpc.ts
+const RPC_DO_PREFIX = "rpc:";
+function makeInvalidRequestError(id) {
+	return {
+		jsonrpc: "2.0",
+		id: id ?? null,
+		error: {
+			code: -32600,
+			message: "Invalid Request"
+		}
+	};
+}
+function validateBatch(batch) {
+	if (batch.length === 0) throw new Error("Invalid JSON-RPC batch: array must not be empty");
+}
+var RPCClientTransport = class {
+	constructor(options) {
+		this._started = false;
+		this._namespace = options.namespace;
+		this._name = options.name;
+		this._props = options.props;
+	}
+	setProtocolVersion(version) {
+		this._protocolVersion = version;
+	}
+	getProtocolVersion() {
+		return this._protocolVersion;
+	}
+	async start() {
+		if (this._started) throw new Error("Transport already started");
+		const doName = `${RPC_DO_PREFIX}${this._name}`;
+		this._stub = await getServerByName(this._namespace, doName, { props: this._props });
+		this._started = true;
+	}
+	async close() {
+		this._started = false;
+		this._stub = void 0;
+		this.onclose?.();
+	}
+	async send(message, options) {
+		if (!this._started || !this._stub) throw new Error("Transport not started");
+		try {
+			const result = await this._stub.handleMcpMessage(message);
+			if (!result) return;
+			const extra = options?.relatedRequestId ? { requestInfo: { headers: {} } } : void 0;
+			const messages = Array.isArray(result) ? result : [result];
+			for (const msg of messages) this.onmessage?.(msg, extra);
+		} catch (error) {
+			this.onerror?.(error);
+			throw error;
+		}
+	}
+};
+var RPCServerTransport = class {
+	constructor(options) {
+		this._started = false;
+		this._pendingResponse = null;
+		this._responseResolver = null;
+		this._timeout = options?.timeout ?? 6e4;
+	}
+	setProtocolVersion(version) {
+		this._protocolVersion = version;
+	}
+	getProtocolVersion() {
+		return this._protocolVersion;
+	}
+	async start() {
+		if (this._started) throw new Error("Transport already started");
+		this._started = true;
+	}
+	async close() {
+		this._started = false;
+		this.onclose?.();
+		if (this._responseResolver) {
+			this._responseResolver();
+			this._responseResolver = null;
+		}
+	}
+	async send(message, _options) {
+		if (!this._started) throw new Error("Transport not started");
+		if (!this._pendingResponse) this._pendingResponse = message;
+		else if (Array.isArray(this._pendingResponse)) this._pendingResponse.push(message);
+		else this._pendingResponse = [this._pendingResponse, message];
+		if (this._responseResolver) {
+			const resolver = this._responseResolver;
+			queueMicrotask(() => resolver());
+		}
+	}
+	async handle(message) {
+		if (!this._started) throw new Error("Transport not started");
+		if (Array.isArray(message)) {
+			validateBatch(message);
+			const responses = [];
+			for (const msg of message) {
+				const response = await this.handle(msg);
+				if (response !== void 0) if (Array.isArray(response)) responses.push(...response);
+				else responses.push(response);
+			}
+			return responses.length === 0 ? void 0 : responses;
+		}
+		try {
+			JSONRPCMessageSchema.parse(message);
+		} catch {
+			return makeInvalidRequestError(typeof message === "object" && message !== null && "id" in message ? message.id : null);
+		}
+		this._pendingResponse = null;
+		if (!("id" in message)) {
+			this.onmessage?.(message);
+			return;
+		}
+		let timeoutId = null;
+		const responsePromise = new Promise((resolve, reject) => {
+			timeoutId = setTimeout(() => {
+				this._responseResolver = null;
+				reject(/* @__PURE__ */ new Error(`Request timeout: No response received within ${this._timeout}ms`));
+			}, this._timeout);
+			this._responseResolver = () => {
+				if (timeoutId) {
+					clearTimeout(timeoutId);
+					timeoutId = null;
+				}
+				this._responseResolver = null;
+				resolve();
+			};
+		});
+		this.onmessage?.(message);
+		try {
+			await responsePromise;
+		} catch (error) {
+			this._pendingResponse = null;
+			this._responseResolver = null;
+			throw error;
+		}
+		const response = this._pendingResponse;
+		this._pendingResponse = null;
+		return response ?? void 0;
+	}
+};
+//#endregion
+//#region src/mcp/client-connection.ts
+/**
+* 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.connectionError = null;
+		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",
+				payload: {
+					url: this.url.toString(),
+					transport: res.transport,
+					state: this.connectionState
+				},
+				timestamp: Date.now()
+			});
+			return;
+		} else if (res.state === MCPConnectionState.FAILED && res.error) {
+			const errorMessage = toErrorMessage(res.error);
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:connect",
+				payload: {
+					url: this.url.toString(),
+					transport: transportType,
+					state: this.connectionState,
+					error: errorMessage
+				},
+				timestamp: Date.now()
+			});
+			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) => {
+			const transport = this.getTransport(base);
+			if ("finishAuth" in transport && typeof transport.finishAuth === "function") await transport.finishAuth(code);
+		};
+		if (configuredType === "rpc") throw new Error("RPC transport does not support authentication");
+		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",
+				payload: {
+					url: this.url.toString(),
+					error: toErrorMessage(error)
+				},
+				timestamp: Date.now()
+			});
+			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",
+				payload: {
+					url: this.url.toString(),
+					state: this.connectionState
+				},
+				timestamp: Date.now()
+			});
+			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",
+				payload: { url: this.url.toString() },
+				timestamp: Date.now()
+			});
+			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);
+			case "rpc": return new RPCClientTransport(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",
+					payload: {
+						url,
+						capability: method.split("/")[0],
+						error: toErrorMessage(e)
+					},
+					timestamp: Date.now()
+				});
+				return empty;
+			}
+			throw e;
+		};
+	}
+};
+//#endregion
+//#region src/mcp/client.ts
+const defaultClientOptions = { jsonSchemaValidator: new CfWorkerJsonSchemaValidator() };
+/**
+* Blocked hostname patterns for SSRF protection.
+* Prevents MCP client from connecting to internal/private network addresses
+* while allowing loopback hosts for local development.
+*/
+const BLOCKED_HOSTNAMES = new Set([
+	"0.0.0.0",
+	"[::]",
+	"metadata.google.internal"
+]);
+/**
+* Check whether four IPv4 octets belong to a private/reserved range.
+* Blocks RFC 1918, link-local, cloud metadata, and unspecified addresses.
+*/
+function isPrivateIPv4(octets) {
+	const [a, b] = octets;
+	if (a === 10) return true;
+	if (a === 172 && b >= 16 && b <= 31) return true;
+	if (a === 192 && b === 168) return true;
+	if (a === 169 && b === 254) return true;
+	if (a === 0) return true;
+	return false;
+}
+/**
+* Check whether a hostname looks like a private/internal IP address.
+* Blocks RFC 1918, link-local, unique-local, unspecified,
+* and cloud metadata endpoints. Also detects IPv4-mapped IPv6 addresses.
+*/
+function isBlockedUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return true;
+	}
+	const hostname = parsed.hostname;
+	if (BLOCKED_HOSTNAMES.has(hostname)) return true;
+	const ipv4Parts = hostname.split(".");
+	if (ipv4Parts.length === 4 && ipv4Parts.every((p) => /^\d{1,3}$/.test(p))) {
+		if (isPrivateIPv4(ipv4Parts.map(Number))) return true;
+	}
+	if (hostname.startsWith("[") && hostname.endsWith("]")) {
+		const addr = hostname.slice(1, -1).toLowerCase();
+		if (addr.startsWith("fc") || addr.startsWith("fd")) return true;
+		if (addr.startsWith("fe80")) return true;
+		if (addr.startsWith("::ffff:")) {
+			const mapped = addr.slice(7);
+			const dotParts = mapped.split(".");
+			if (dotParts.length === 4 && dotParts.every((p) => /^\d{1,3}$/.test(p))) {
+				if (isPrivateIPv4(dotParts.map(Number))) return true;
+			} else {
+				const hexParts = mapped.split(":");
+				if (hexParts.length === 2) {
+					const hi = parseInt(hexParts[0], 16);
+					const lo = parseInt(hexParts[1], 16);
+					if (isPrivateIPv4([
+						hi >> 8 & 255,
+						hi & 255,
+						lo >> 8 & 255,
+						lo & 255
+					])) return true;
+				}
+			}
+		}
+	}
+	return false;
+}
+/**
+* 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._pendingConnections = /* @__PURE__ */ new Map();
+		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;
+		this._createAuthProviderFn = options.createAuthProvider;
+	}
+	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");
+	}
+	/**
+	* Get the retry options for a server from stored server_options
+	*/
+	getServerRetryOptions(serverId) {
+		const rows = this.sql("SELECT server_options FROM cf_agents_mcp_servers WHERE id = ?", serverId);
+		if (!rows.length || !rows[0].server_options) return void 0;
+		return JSON.parse(rows[0].server_options).retry;
+	}
+	clearServerAuthUrl(serverId) {
+		this.sql("UPDATE cf_agents_mcp_servers SET auth_url = NULL WHERE id = ?", serverId);
+	}
+	failConnection(serverId, error) {
+		this.clearServerAuthUrl(serverId);
+		if (this.mcpConnections[serverId]) {
+			this.mcpConnections[serverId].connectionState = MCPConnectionState.FAILED;
+			this.mcpConnections[serverId].connectionError = error;
+		}
+		this._onServerStateChanged.fire();
+		return {
+			serverId,
+			authSuccess: false,
+			authError: error
+		};
+	}
+	/**
+	* 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;
+	}
+	/**
+	* Get saved RPC servers from storage (servers with rpc:// URLs).
+	* These are restored separately by the Agent class since they need env bindings.
+	*/
+	getRpcServersFromStorage() {
+		return this.getServersFromStorage().filter((s) => s.server_url.startsWith(RPC_DO_PREFIX));
+	}
+	/**
+	* Save an RPC server to storage for hibernation recovery.
+	* The bindingName is stored in server_options so the Agent can look up
+	* the namespace from env during restore.
+	*/
+	saveRpcServerToStorage(id, name, normalizedName, bindingName, props) {
+		this.saveServerToStorage({
+			id,
+			name,
+			server_url: `${RPC_DO_PREFIX}${normalizedName}`,
+			client_id: null,
+			auth_url: null,
+			callback_url: "",
+			server_options: JSON.stringify({
+				bindingName,
+				props
+			})
+		});
+	}
+	/**
+	* Restore MCP server connections from storage
+	* This method is called on Agent initialization to restore previously connected servers.
+	* RPC servers (rpc:// URLs) are skipped here -- they are restored by the Agent class
+	* which has access to env bindings.
+	*
+	* @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) {
+			if (server.server_url.startsWith("rpc:")) continue;
+			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;
+			let authProvider;
+			if (server.callback_url) {
+				authProvider = this._createAuthProviderFn ? this._createAuthProviderFn(server.callback_url) : this.createAuthProvider(server.id, server.callback_url, clientName, server.client_id ?? void 0);
+				authProvider.serverId = server.id;
+				if (server.client_id) authProvider.clientId = server.client_id;
+			}
+			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._trackConnection(server.id, this._restoreServer(server.id, parsedOptions?.retry));
+		}
+		this._isRestored = true;
+	}
+	/**
+	* Track a pending connection promise for a server.
+	* The promise is removed from the map when it settles.
+	*/
+	_trackConnection(serverId, promise) {
+		const tracked = promise.finally(() => {
+			if (this._pendingConnections.get(serverId) === tracked) this._pendingConnections.delete(serverId);
+		});
+		this._pendingConnections.set(serverId, tracked);
+	}
+	/**
+	* Wait for all in-flight connection and discovery operations to settle.
+	* This is useful when you need MCP tools to be available before proceeding,
+	* e.g. before calling getAITools() after the agent wakes from hibernation.
+	*
+	* Returns once every pending connection has either connected and discovered,
+	* failed, or timed out. Never rejects.
+	*
+	* @param options.timeout - Maximum time in milliseconds to wait.
+	*   `0` returns immediately without waiting.
+	*   `undefined` (default) waits indefinitely.
+	*/
+	async waitForConnections(options) {
+		if (this._pendingConnections.size === 0) return;
+		if (options?.timeout != null && options.timeout <= 0) return;
+		const settled = Promise.allSettled(this._pendingConnections.values());
+		if (options?.timeout != null && options.timeout > 0) {
+			let timerId;
+			const timer = new Promise((resolve) => {
+				timerId = setTimeout(resolve, options.timeout);
+			});
+			await Promise.race([settled, timer]);
+			clearTimeout(timerId);
+		} else await settled;
+	}
+	/**
+	* Internal method to restore a single server connection and discovery
+	*/
+	async _restoreServer(serverId, retry) {
+		const maxAttempts = retry?.maxAttempts ?? 3;
+		if ((await tryN(maxAttempts, async () => this.connectToServer(serverId), {
+			baseDelayMs: retry?.baseDelayMs ?? 500,
+			maxDelayMs: retry?.maxDelayMs ?? 5e3
+		}).catch((error) => {
+			console.error(`Error connecting to ${serverId} after ${maxAttempts} attempts:`, 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 (isBlockedUrl(url)) throw new Error(`Blocked URL: ${url} — MCP client connections to private/internal addresses are not allowed`);
+		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",
+				payload: {
+					url,
+					transport: options.transport?.type ?? "auto",
+					state: this.mcpConnections[id].connectionState,
+					error: toErrorMessage(error)
+				},
+				timestamp: Date.now()
+			});
+			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) {
+		if (isBlockedUrl(options.url)) throw new Error(`Blocked URL: ${options.url} — MCP client connections to private/internal addresses are not allowed`);
+		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,
+				retry: options.retry
+			})
+		});
+		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
+					});
+					this._onServerStateChanged.fire();
+				}
+				this._onObservabilityEvent.fire({
+					type: "mcp:client:authorize",
+					payload: {
+						serverId: id,
+						authUrl,
+						clientId
+					},
+					timestamp: Date.now()
+				});
+				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}`
+			};
+		}
+	}
+	extractServerIdFromState(state) {
+		if (!state) return null;
+		const parts = state.split(".");
+		return parts.length === 2 ? parts[1] : null;
+	}
+	isCallbackRequest(req) {
+		if (req.method !== "GET") return false;
+		const url = new URL(req.url);
+		const state = url.searchParams.get("state");
+		const serverId = this.extractServerIdFromState(state);
+		if (!serverId) return false;
+		return this.getServersFromStorage().some((server) => {
+			if (server.id !== serverId) return false;
+			try {
+				const storedUrl = new URL(server.callback_url);
+				return storedUrl.origin === url.origin && storedUrl.pathname === url.pathname;
+			} catch {
+				return false;
+			}
+		});
+	}
+	validateCallbackRequest(req) {
+		const url = new URL(req.url);
+		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 (!state) return {
+			valid: false,
+			error: "Unauthorized: no state provided"
+		};
+		const serverId = this.extractServerIdFromState(state);
+		if (!serverId) return {
+			valid: false,
+			error: "No serverId found in state parameter. Expected format: {nonce}.{serverId}"
+		};
+		if (error) return {
+			serverId,
+			valid: false,
+			error: errorDescription || error
+		};
+		if (!code) return {
+			serverId,
+			valid: false,
+			error: "Unauthorized: no code provided"
+		};
+		if (!this.getServersFromStorage().some((server) => server.id === serverId)) return {
+			serverId,
+			valid: false,
+			error: `No server found with id "${serverId}". Was the request matched with \`isCallbackRequest()\`?`
+		};
+		if (this.mcpConnections[serverId] === void 0) return {
+			serverId,
+			valid: false,
+			error: `No connection found for serverId "${serverId}".`
+		};
+		return {
+			valid: true,
+			serverId,
+			code,
+			state
+		};
+	}
+	async handleCallbackRequest(req) {
+		const validation = this.validateCallbackRequest(req);
+		if (!validation.valid) {
+			if (validation.serverId && this.mcpConnections[validation.serverId]) return this.failConnection(validation.serverId, validation.error);
+			return {
+				serverId: validation.serverId,
+				authSuccess: false,
+				authError: validation.error
+			};
+		}
+		const { serverId, code, state } = validation;
+		const conn = this.mcpConnections[serverId];
+		try {
+			if (!conn.options.transport.authProvider) throw new Error("Trying to finalize authentication for a server connection without an authProvider");
+			const authProvider = conn.options.transport.authProvider;
+			authProvider.serverId = serverId;
+			const stateValidation = await authProvider.checkState(state);
+			if (!stateValidation.valid) throw new Error(stateValidation.error || "Invalid state");
+			if (conn.connectionState === MCPConnectionState.READY || conn.connectionState === MCPConnectionState.CONNECTED) {
+				this.clearServerAuthUrl(serverId);
+				return {
+					serverId,
+					authSuccess: true
+				};
+			}
+			if (conn.connectionState !== MCPConnectionState.AUTHENTICATING) throw new Error(`Failed to authenticate: the client is in "${conn.connectionState}" state, expected "authenticating"`);
+			await authProvider.consumeState(state);
+			await conn.completeAuthorization(code);
+			await authProvider.deleteCodeVerifier();
+			this.clearServerAuthUrl(serverId);
+			conn.connectionError = null;
+			this._onServerStateChanged.fire();
+			return {
+				serverId,
+				authSuccess: true
+			};
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			return this.failConnection(serverId, message);
+		}
+	}
+	/**
+	* 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",
+				payload: {},
+				timestamp: Date.now()
+			});
+			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.
+	* The connection is automatically tracked so that `waitForConnections()`
+	* will include it.
+	* @param serverId The server ID to establish connection for
+	*/
+	async establishConnection(serverId) {
+		const promise = this._doEstablishConnection(serverId);
+		this._trackConnection(serverId, promise);
+		return promise;
+	}
+	async _doEstablishConnection(serverId) {
+		const conn = this.mcpConnections[serverId];
+		if (!conn) {
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:preconnect",
+				payload: { serverId },
+				timestamp: Date.now()
+			});
+			return;
+		}
+		if (conn.connectionState === MCPConnectionState.DISCOVERING || conn.connectionState === MCPConnectionState.READY) {
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:connect",
+				payload: {
+					url: conn.url.toString(),
+					transport: conn.options.transport.type || "unknown",
+					state: conn.connectionState
+				},
+				timestamp: Date.now()
+			});
+			return;
+		}
+		const retry = this.getServerRetryOptions(serverId);
+		const connectResult = await tryN(retry?.maxAttempts ?? 3, async () => this.connectToServer(serverId), {
+			baseDelayMs: retry?.baseDelayMs ?? 500,
+			maxDelayMs: retry?.maxDelayMs ?? 5e3
+		});
+		this._onServerStateChanged.fire();
+		if (connectResult.state === MCPConnectionState.CONNECTED) await this.discoverIfConnected(serverId);
+		this._onObservabilityEvent.fire({
+			type: "mcp:client:connect",
+			payload: {
+				url: conn.url.toString(),
+				transport: conn.options.transport.type || "unknown",
+				state: conn.connectionState
+			},
+			timestamp: Date.now()
+		});
+	}
+	/**
+	* 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.`);
+		const entries = [];
+		for (const tool of getNamespacedData(this.mcpConnections, "tools")) try {
+			const toolKey = `tool_${tool.serverId.replace(/-/g, "")}_${tool.name}`;
+			entries.push([toolKey, {
+				description: tool.description,
+				execute: async (args) => {
+					const result = await this.callTool({
+						arguments: args,
+						name: tool.name,
+						serverId: tool.serverId
+					});
+					if (result.isError) {
+						const textContent = result.content?.[0];
+						const message = textContent?.type === "text" && textContent.text ? textContent.text : "Tool call failed";
+						throw new Error(message);
+					}
+					return result;
+				},
+				inputSchema: tool.inputSchema ? this.jsonSchema(tool.inputSchema) : this.jsonSchema({ type: "object" }),
+				outputSchema: tool.outputSchema ? this.jsonSchema(tool.outputSchema) : void 0
+			}]);
+		} catch (e) {
+			console.warn(`[getAITools] Skipping tool "${tool.name}" from "${tool.serverId}": ${e}`);
+		}
+		return Object.fromEntries(entries);
+	}
+	/**
+	* @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);
+		this._pendingConnections.clear();
+		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();
+		this._pendingConnections.delete(id);
+		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 { serverId, ...mcpParams } = params;
+		const unqualifiedName = mcpParams.name.replace(`${serverId}.`, "");
+		return this.mcpConnections[serverId].client.callTool({
+			...mcpParams,
+			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
+export { RPCServerTransport as a, RPCClientTransport as i, getNamespacedData as n, RPC_DO_PREFIX as o, MCPConnectionState as r, DisposableStore as s, MCPClientManager as t };
+
+//# sourceMappingURL=client-K8Z-u76l.js.map