agents 0.17.3 → 0.18.0

package/dist/{client-BZ-B3NhC.js → client-CcjiFpTf.js}

@@ -2,11 +2,11 @@ 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 { z } from "zod";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker-provider.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StreamableHTTPClientTransport, StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { ElicitRequestSchema, JSONRPCMessageSchema, PromptListChangedNotificationSchema, ResourceListChangedNotificationSchema, ToolListChangedNotificationSchema, isJSONRPCErrorResponse, isJSONRPCResultResponse } from "@modelcontextprotocol/sdk/types.js";
 //#region src/core/events.ts
 function toDisposable(fn) {
@@ -282,6 +282,7 @@ var RPCServerTransport = class {
 };
 //#endregion
 //#region src/mcp/client-connection.ts
+const defaultClientOptions = { jsonSchemaValidator: new CfWorkerJsonSchemaValidator() };
 /**
 * Connection state machine for MCP client connections.
 *
@@ -304,12 +305,21 @@ const MCPConnectionState = {
 	/** Connection failed at some point */
 	FAILED: "failed"
 };
+/** Derive the elicitation capability to advertise from the handler keys. */
+function elicitationCapabilitiesFromHandlers(handlers) {
+	if (!handlers) return void 0;
+	const elicitation = {};
+	if (handlers.form) elicitation.form = {};
+	if (handlers.url) elicitation.url = {};
+	return elicitation.form || elicitation.url ? elicitation : void 0;
+}
 var MCPClientConnection = class {
-	constructor(url, info, options = {
+	constructor(url, _info, options = {
 		client: {},
 		transport: {}
 	}) {
 		this.url = url;
+		this._info = _info;
 		this.options = options;
 		this.connectionState = MCPConnectionState.CONNECTING;
 		this.connectionError = null;
@@ -320,14 +330,44 @@ var MCPClientConnection = class {
 		this._probingCapabilities = false;
 		this._onObservabilityEvent = new Emitter();
 		this.onObservabilityEvent = this._onObservabilityEvent.event;
+		this._elicitationEnabled = false;
+		this.options = {
+			...options,
+			client: {
+				...defaultClientOptions,
+				...options.client
+			}
+		};
+		this.client = this.createClient();
+	}
+	createClient() {
+		const seed = this.options.capabilitySeed;
+		const elicitation = this.options.client?.capabilities?.elicitation ?? elicitationCapabilitiesFromHandlers(this.options.elicitationHandlers) ?? seed?.elicitation;
+		this._elicitationEnabled = elicitation !== void 0;
 		const clientOptions = {
-			...options.client,
+			...this.options.client,
 			capabilities: {
-				...options.client?.capabilities,
-				elicitation: {}
+				...seed,
+				...this.options.client?.capabilities,
+				...elicitation ? { elicitation } : {}
 			}
 		};
-		this.client = new Client(info, clientOptions);
+		return new Client(this._info, clientOptions);
+	}
+	/**
+	* Configure the handler used for server-initiated elicitation requests.
+	*
+	* If the connection has not been initialized yet, rebuild the SDK client so
+	* handler-driven elicitation capabilities are reflected in the initial
+	* handshake. A rebuild (rather than `Client.registerCapabilities`) is
+	* required because SDK capability registration is merge-only — it cannot
+	* un-advertise a mode when handlers are cleared before connecting. Active
+	* connections keep their negotiated capabilities until they reconnect.
+	*/
+	configureElicitationHandlers(handlers) {
+		this.options.elicitationHandlers = handlers;
+		this.options.capabilitySeed = void 0;
+		if (!this.client.transport) this.client = this.createClient();
 	}
 	/**
 	* Initialize a client connection, if authentication is required, the connection will be in the AUTHENTICATING state
@@ -343,11 +383,12 @@ var MCPClientConnection = class {
 			try {
 				await this.client.close();
 			} catch {}
+			this.client = this.createClient();
 		}
 		const res = await this.tryConnect(transportType);
 		this.connectionState = res.state;
 		if (res.state === MCPConnectionState.CONNECTED && res.transport) {
-			this.client.setRequestHandler(ElicitRequestSchema, async (request) => {
+			if (this._elicitationEnabled) this.client.setRequestHandler(ElicitRequestSchema, async (request) => {
 				return await this.handleElicitationRequest(request);
 			});
 			this.lastConnectedTransport = res.transport;
@@ -509,6 +550,7 @@ var MCPClientConnection = class {
 			});
 			return {
 				success: false,
+				reason: "error",
 				error: `Discovery skipped - connection in ${this.connectionState} state`
 			};
 		}
@@ -546,9 +588,11 @@ var MCPClientConnection = class {
 		} catch (e) {
 			if (timeoutId !== void 0) clearTimeout(timeoutId);
 			this.connectionState = MCPConnectionState.CONNECTED;
+			const error = e instanceof Error ? e.message : String(e);
 			return {
 				success: false,
-				error: e instanceof Error ? e.message : String(e)
+				reason: this._probingCapabilities && e instanceof StreamableHTTPError && e.code === 404 ? "stale-session" : "error",
+				error
 			};
 		} finally {
 			this._discoveryAbortController = void 0;
@@ -634,11 +678,19 @@ var MCPClientConnection = class {
 		return templatesAgg;
 	}
 	/**
-	* Handle elicitation request from server
-	* Automatically uses the Agent's built-in elicitation handling if available
+	* Handle elicitation request from server.
+	*
+	* Delegates to the `elicitationHandlers` connection option when provided.
+	*
+	* @deprecated Overriding or instance-patching this method directly is
+	* deprecated — pass the `elicitationHandlers` connection option instead.
 	*/
-	async handleElicitationRequest(_request) {
-		throw new Error("Elicitation handler must be implemented for your platform. Override handleElicitationRequest method.");
+	async handleElicitationRequest(request) {
+		const mode = request.params.mode === "url" ? "url" : "form";
+		const handler = this.options.elicitationHandlers?.[mode];
+		if (handler) return handler(request);
+		if (this.options.elicitationHandlers) throw new Error(`No MCP ${mode}-mode elicitation handler configured for this connection.`);
+		throw new Error("Elicitation handler must be implemented for your platform. Provide the MCPClientConnection elicitationHandlers option, or register handlers through the MCP client manager before connecting.");
 	}
 	isResumedStreamableHttpSession() {
 		return this._transport instanceof StreamableHTTPClientTransport && typeof this._transport.sessionId === "string";
@@ -646,6 +698,10 @@ var MCPClientConnection = class {
 	get sessionId() {
 		if (this._transport instanceof StreamableHTTPClientTransport) return this._transport.sessionId;
 	}
+	/** @internal Clear a restored session before reconnecting. */
+	clearResumedSession() {
+		if ("sessionId" in this.options.transport) delete this.options.transport.sessionId;
+	}
 	getTransportName(transport) {
 		if (transport instanceof StreamableHTTPClientTransport) return "streamable-http";
 		if (transport instanceof SSEClientTransport) return "sse";
@@ -764,7 +820,6 @@ var MCPClientConnection = class {
 };
 //#endregion
 //#region src/mcp/client.ts
-const defaultClientOptions = { jsonSchemaValidator: new CfWorkerJsonSchemaValidator() };
 /** Maximum length of a normalized MCP server id. */
 const MCP_SERVER_ID_MAX_LENGTH = 64;
 /**
@@ -887,6 +942,13 @@ function isBlockedUrl(url) {
 	}
 	return false;
 }
+/** Converts a resolved connection failure into a retry signal. */
+var ConnectRetryError = class extends Error {
+	constructor(result) {
+		super("MCP connection attempt failed");
+		this.result = result;
+	}
+};
 /**
 * Utility class that aggregates multiple MCP clients into one
 */
@@ -900,6 +962,7 @@ var MCPClientManager = class {
 		this._name = _name;
 		this._version = _version;
 		this.mcpConnections = {};
+		this._aiToolSchemas = /* @__PURE__ */ new WeakMap();
 		this._didWarnAboutUnstableGetAITools = false;
 		this._connectionDisposables = /* @__PURE__ */ new Map();
 		this._isRestored = false;
@@ -912,6 +975,21 @@ var MCPClientManager = class {
 		this._storage = options.storage;
 		this._createAuthProviderFn = options.createAuthProvider;
 	}
+	/**
+	* Scope the manager-level elicitation handler to a single connection.
+	* Returns undefined when no handler is configured so the connection keeps
+	* its default throwing behavior.
+	*/
+	scopedElicitationHandlers(serverId) {
+		const handlers = this._elicitationHandlers;
+		if (!handlers) return void 0;
+		const form = handlers.form;
+		const url = handlers.url;
+		return {
+			form: form ? (request) => form(request, serverId) : void 0,
+			url: url ? (request) => url(request, serverId) : void 0
+		};
+	}
 	sql(query, ...bindings) {
 		return [...this._storage.sql.exec(query, ...bindings)];
 	}
@@ -944,6 +1022,11 @@ var MCPClientManager = class {
 	*/
 	async migrateServerId(oldId, newId, clientName) {
 		if (oldId === newId) return;
+		while (true) {
+			const pending = this._pendingConnections.get(oldId);
+			if (!pending) break;
+			await pending.catch(() => {});
+		}
 		if (this.sql("SELECT id FROM cf_agents_mcp_servers WHERE id = ?", oldId).length === 0) {
 			this._renameInMemoryConnection(oldId, newId);
 			return;
@@ -979,6 +1062,8 @@ var MCPClientManager = class {
 			delete this.mcpConnections[oldId];
 			const authProvider = conn.options.transport.authProvider;
 			if (authProvider) authProvider.serverId = newId;
+			const scoped = this.scopedElicitationHandlers(newId);
+			if (scoped) conn.configureElicitationHandlers(scoped);
 		}
 		const disposables = this._connectionDisposables.get(oldId);
 		if (disposables) {
@@ -1007,12 +1092,37 @@ var MCPClientManager = class {
 		}));
 	}
 	/**
-	* Get the retry options for a server from stored server_options
+	* Get the parsed server_options for a stored server, if any.
 	*/
-	getServerRetryOptions(serverId) {
+	getStoredServerOptions(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;
+		return JSON.parse(rows[0].server_options);
+	}
+	/**
+	* Clear the capabilities persisted on a stored server row. Called once a
+	* seeded connection's handshake completes (see `createConnection`): the
+	* stamp is valid for one successful restore — sessions that configure
+	* handlers re-stamp every row, so a deploy that stops configuring them
+	* stops advertising stale modes after its first connected wake instead of
+	* forever, while wakes that never handshake don't burn the stamp.
+	*/
+	clearStoredCapabilities(serverId) {
+		const row = this.sql("SELECT id, name, server_url, client_id, auth_url, callback_url, server_options FROM cf_agents_mcp_servers WHERE id = ?", serverId)[0];
+		if (!row?.server_options) return;
+		const options = JSON.parse(row.server_options);
+		if (!options.capabilities) return;
+		options.capabilities = void 0;
+		this.saveServerToStorage({
+			...row,
+			server_options: JSON.stringify(options)
+		});
+	}
+	/**
+	* Get the retry options for a server from stored server_options
+	*/
+	getServerRetryOptions(serverId) {
+		return this.getStoredServerOptions(serverId)?.retry;
 	}
 	clearServerAuthUrl(serverId) {
 		this.sql("UPDATE cf_agents_mcp_servers SET auth_url = NULL WHERE id = ?", serverId);
@@ -1063,6 +1173,22 @@ var MCPClientManager = class {
 		if (authProvider.runWithCodeVerifierState) return authProvider.runWithCodeVerifierState(state, callback);
 		return callback();
 	}
+	async hasRedeemableOAuthState(serverId, authProvider, state) {
+		authProvider.serverId = serverId;
+		try {
+			return (await authProvider.checkState(state)).valid;
+		} catch {
+			return false;
+		}
+	}
+	ignoreUnverifiedCallback(serverId, error) {
+		console.warn(`[MCPClientManager] Ignoring OAuth callback with unverified state for server "${serverId}": ${error}`);
+		return {
+			serverId,
+			authSuccess: false,
+			authError: error
+		};
+	}
 	async consumeStaleOAuthState(serverId, authProvider, state) {
 		try {
 			const stateValidation = await authProvider.checkState(state);
@@ -1129,7 +1255,8 @@ var MCPClientManager = class {
 			callback_url: "",
 			server_options: JSON.stringify({
 				bindingName,
-				props
+				props,
+				capabilities: this.advertisedHandlerCapabilities()
 			})
 		});
 	}
@@ -1166,6 +1293,7 @@ var MCPClientManager = class {
 				}
 			}
 			const parsedOptions = server.server_options ? JSON.parse(server.server_options) : null;
+			if (parsedOptions?.client) delete parsedOptions.client.jsonSchemaValidator;
 			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);
@@ -1223,16 +1351,30 @@ var MCPClientManager = class {
 			clearTimeout(timerId);
 		} else await settled;
 	}
+	async _connectWithRetry(serverId, retry) {
+		const maxAttempts = retry?.maxAttempts ?? 3;
+		const baseDelayMs = retry?.baseDelayMs ?? 500;
+		const maxDelayMs = retry?.maxDelayMs ?? 5e3;
+		try {
+			return await tryN(maxAttempts, async () => {
+				const result = await this.connectToServer(serverId);
+				if (result.state === MCPConnectionState.FAILED) throw new ConnectRetryError(result);
+				return result;
+			}, {
+				baseDelayMs,
+				maxDelayMs
+			});
+		} catch (error) {
+			if (error instanceof ConnectRetryError) return error.result;
+			throw error;
+		}
+	}
 	/**
 	* 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);
+		if ((await this._connectWithRetry(serverId, retry).catch((error) => {
+			console.error(`Error connecting to ${serverId}:`, error);
 			return null;
 		}))?.state === MCPConnectionState.CONNECTED) {
 			const discoverResult = await this.discoverIfConnected(serverId);
@@ -1257,24 +1399,16 @@ var MCPClientManager = class {
 		}
 		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 replaced = this.mcpConnections[id];
+			if (replaced) {
+				delete this.mcpConnections[id];
+				await replaced.close().catch(() => {});
+				this.updateStoredSessionId(id, void 0);
+			}
+			this.createConnection(id, url, {
+				client: options.client,
+				transport: options.transport ?? {}
 			});
-			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 {
@@ -1326,15 +1460,15 @@ var MCPClientManager = class {
 			...options.transport,
 			type: options.transport?.type ?? "auto"
 		};
+		const capabilitySeed = this.getStoredServerOptions(id)?.capabilities;
 		this.mcpConnections[id] = new MCPClientConnection(new URL(url), {
 			name: this._name,
 			version: this._version
 		}, {
-			client: {
-				...defaultClientOptions,
-				...options.client
-			},
-			transport: normalizedTransport
+			client: options.client ?? {},
+			transport: normalizedTransport,
+			elicitationHandlers: this.scopedElicitationHandlers(id),
+			capabilitySeed
 		});
 		const store = new DisposableStore();
 		const existing = this._connectionDisposables.get(id);
@@ -1343,6 +1477,17 @@ var MCPClientManager = class {
 		store.add(this.mcpConnections[id].onObservabilityEvent((event) => {
 			this._onObservabilityEvent.fire(event);
 		}));
+		if (capabilitySeed) {
+			const conn = this.mcpConnections[id];
+			const seedClear = conn.onObservabilityEvent((event) => {
+				if (event.type !== "mcp:client:connect" || event.payload.state !== MCPConnectionState.CONNECTED) return;
+				seedClear.dispose();
+				if (this._elicitationHandlers || !conn.options.capabilitySeed) return;
+				const currentId = Object.keys(this.mcpConnections).find((key) => this.mcpConnections[key] === conn);
+				if (currentId) this.clearStoredCapabilities(currentId);
+			});
+			store.add(seedClear);
+		}
 		return this.mcpConnections[id];
 	}
 	/**
@@ -1363,6 +1508,7 @@ var MCPClientManager = class {
 			}
 		});
 		const { authProvider: _, ...transportWithoutAuth } = options.transport ?? {};
+		const { jsonSchemaValidator: _validator, ...serializableClient } = options.client ?? {};
 		this.saveServerToStorage({
 			id,
 			name: options.name,
@@ -1371,9 +1517,10 @@ var MCPClientManager = class {
 			client_id: options.clientId ?? null,
 			auth_url: options.authUrl ?? null,
 			server_options: JSON.stringify({
-				client: options.client,
+				client: serializableClient,
 				transport: transportWithoutAuth,
-				retry: options.retry
+				retry: options.retry,
+				capabilities: this.advertisedHandlerCapabilities()
 			})
 		});
 		this._onServerStateChanged.fire();
@@ -1521,6 +1668,8 @@ var MCPClientManager = class {
 					}
 					return this.oauthCallbackSuccess(validation.serverId, conn);
 				}
+				const authProvider = conn.options.transport.authProvider;
+				if (validation.state && authProvider && !await this.hasRedeemableOAuthState(validation.serverId, authProvider, validation.state)) return this.ignoreUnverifiedCallback(validation.serverId, validation.error);
 				return this.failConnection(validation.serverId, validation.error);
 			}
 			return {
@@ -1541,13 +1690,13 @@ var MCPClientManager = class {
 					await this.consumeStaleOAuthState(serverId, authProvider, state);
 					return this.oauthCallbackSuccess(serverId, conn);
 				}
-				throw new Error(stateValidation.error || "Invalid state");
+				return this.ignoreUnverifiedCallback(serverId, stateValidation.error || "Invalid state");
 			}
 			if (this.isAuthAcceptedConnection(conn)) {
 				await this.consumeStaleOAuthState(serverId, authProvider, state);
 				return this.oauthCallbackSuccess(serverId, conn);
 			}
-			if (conn.connectionState !== MCPConnectionState.AUTHENTICATING) throw new Error(`Failed to authenticate: the client is in "${conn.connectionState}" state, expected "authenticating"`);
+			if (conn.connectionState !== MCPConnectionState.AUTHENTICATING && conn.connectionState !== MCPConnectionState.FAILED) throw new Error(`Failed to authenticate from "${conn.connectionState}" state`);
 			conn.connectionState = MCPConnectionState.CONNECTING;
 			await authProvider.consumeState(state);
 			await this.completeAuthorizationAndCleanupVerifier(serverId, conn, authProvider, state, code);
@@ -1584,11 +1733,41 @@ var MCPClientManager = class {
 			return;
 		}
 		const result = await conn.discover(options);
+		if (!result.success && result.reason === "stale-session") return this._recoverStaleSession(conn, serverId, options);
 		this._onServerStateChanged.fire();
-		return {
-			...result,
+		return this._toDiscoverResult(conn, result);
+	}
+	_toDiscoverResult(conn, result) {
+		return result.success ? {
+			success: true,
+			state: conn.connectionState
+		} : {
+			success: false,
+			error: result.error,
+			state: conn.connectionState
+		};
+	}
+	async _recoverStaleSession(conn, serverId, options) {
+		conn.clearResumedSession();
+		this.updateStoredSessionId(serverId, void 0);
+		let connectResult;
+		try {
+			connectResult = await this.connectToServer(serverId);
+		} catch (error) {
+			return {
+				success: false,
+				error: toErrorMessage(error),
+				state: conn.connectionState
+			};
+		}
+		if (connectResult.state !== MCPConnectionState.CONNECTED) return {
+			success: false,
+			error: connectResult.state === MCPConnectionState.FAILED ? connectResult.error : `Connection in ${connectResult.state} state after session re-initialization`,
 			state: conn.connectionState
 		};
+		const result = await conn.discover(options);
+		this._onServerStateChanged.fire();
+		return this._toDiscoverResult(conn, result);
 	}
 	/**
 	* Establish connection in the background after OAuth completion.
@@ -1625,10 +1804,7 @@ var MCPClientManager = class {
 			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
-		});
+		const connectResult = await this._connectWithRetry(serverId, retry);
 		this._onServerStateChanged.fire();
 		if (connectResult.state === MCPConnectionState.CONNECTED) await this.discoverIfConnected(serverId);
 		this._onObservabilityEvent.fire({
@@ -1649,6 +1825,51 @@ var MCPClientManager = class {
 		this._oauthCallbackConfig = config;
 	}
 	/**
+	* Configure handling for server-initiated `elicitation/create` requests.
+	*
+	* The handler is held in memory only and applied to every MCP connection
+	* created or restored by this manager. Call this before registering
+	* connections when you want the initial MCP handshake to advertise
+	* handler-driven form- and url-mode elicitation. Existing active connections
+	* keep their negotiated capabilities until they reconnect.
+	*
+	* The advertised modes are persisted with each stored server, so
+	* connections restored after hibernation re-advertise them at the handshake
+	* even when this is called later in the wake-up (e.g. from onStart) — the
+	* handlers attach to the live connections as soon as this runs.
+	*
+	* Pass undefined to clear the handler.
+	*
+	* @param handlers Elicitation handlers keyed by mode, each scoped with the server id that sent the request
+	*/
+	configureElicitationHandlers(handlers) {
+		this._elicitationHandlers = handlers && (handlers.form || handlers.url) ? handlers : void 0;
+		this.persistAdvertisedCapabilities();
+		for (const [id, connection] of Object.entries(this.mcpConnections)) connection.configureElicitationHandlers(this.scopedElicitationHandlers(id));
+	}
+	/** Client capabilities advertised from the currently configured handlers. */
+	advertisedHandlerCapabilities() {
+		const elicitation = elicitationCapabilitiesFromHandlers(this._elicitationHandlers);
+		return elicitation ? { elicitation } : void 0;
+	}
+	/**
+	* Record the handler-derived capabilities on every stored server row so a
+	* restore after hibernation re-advertises them before the handlers
+	* themselves are reconfigured.
+	*/
+	persistAdvertisedCapabilities() {
+		const capabilities = this.advertisedHandlerCapabilities();
+		for (const server of this.getServersFromStorage()) {
+			const options = server.server_options ? JSON.parse(server.server_options) : {};
+			if (JSON.stringify(options.capabilities) === JSON.stringify(capabilities)) continue;
+			options.capabilities = capabilities;
+			this.saveServerToStorage({
+				...server,
+				server_options: JSON.stringify(options)
+			});
+		}
+	}
+	/**
 	* Get the current OAuth callback configuration
 	* @returns The current OAuth callback configuration
 	*/
@@ -1663,37 +1884,87 @@ var MCPClientManager = class {
 		return getNamespacedData(this.filterConnections(filter), "tools");
 	}
 	/**
+	* Convert connected MCP tools for the AI SDK. Converted schemas are reused
+	* while a live connection retains the same catalog array and schema-source
+	* identities; tool records and execute closures are rebuilt on every call.
+	*
 	* @param filter - Optional filter to scope results to specific servers
 	* @returns a set of tools that you can use with the AI SDK
 	*/
 	getAITools(filter) {
 		const connections = this.filterConnections(filter);
-		for (const [id, conn] of Object.entries(connections)) 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(connections, "tools")) try {
-			const toolKey = `tool_${tool.serverId.replace(/-/g, "")}_${tool.name}`;
-			const title = tool.title ?? tool.annotations?.title;
-			entries.push([toolKey, {
-				description: tool.description,
-				title,
-				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);
+		for (const [serverId, conn] of Object.entries(connections)) {
+			if (conn.connectionState !== MCPConnectionState.READY && conn.connectionState !== MCPConnectionState.AUTHENTICATING) console.warn(`[getAITools] WARNING: Reading tools from connection ${serverId} in state "${conn.connectionState}". Tools may not be loaded yet.`);
+			const catalog = conn.tools;
+			let cache = this._aiToolSchemas.get(conn);
+			if (!cache || cache.catalog !== catalog) {
+				cache = {
+					catalog,
+					converted: []
+				};
+				this._aiToolSchemas.set(conn, cache);
+			}
+			for (const [index, tool] of catalog.entries()) {
+				const toolName = tool.name;
+				try {
+					const sourceInputSchema = tool.inputSchema;
+					const sourceOutputSchema = tool.outputSchema;
+					let slot = cache.converted[index];
+					if (!slot || slot.tool !== tool || slot.inputSchema !== sourceInputSchema || slot.outputSchema !== sourceOutputSchema) {
+						try {
+							slot = {
+								status: "converted",
+								tool,
+								inputSchema: sourceInputSchema,
+								outputSchema: sourceOutputSchema,
+								converted: {
+									inputSchema: sourceInputSchema ? z.fromJSONSchema(sourceInputSchema) : z.fromJSONSchema({ type: "object" }),
+									outputSchema: sourceOutputSchema ? z.fromJSONSchema(sourceOutputSchema) : void 0
+								}
+							};
+						} catch (error) {
+							const errorText = String(error);
+							cache.converted[index] = {
+								status: "failed",
+								tool,
+								inputSchema: sourceInputSchema,
+								outputSchema: sourceOutputSchema,
+								error: errorText
+							};
+							console.warn(`[getAITools] Skipping tool "${toolName}" from "${serverId}": ${errorText}`);
+							continue;
+						}
+						cache.converted[index] = slot;
 					}
-					return result;
-				},
-				inputSchema: tool.inputSchema ? z.fromJSONSchema(tool.inputSchema) : z.fromJSONSchema({ type: "object" }),
-				outputSchema: tool.outputSchema ? z.fromJSONSchema(tool.outputSchema) : void 0
-			}]);
-		} catch (e) {
-			console.warn(`[getAITools] Skipping tool "${tool.name}" from "${tool.serverId}": ${e}`);
+					if (slot.status === "failed") continue;
+					const toolKey = `tool_${serverId.replace(/-/g, "")}_${toolName}`;
+					const title = tool.title ?? tool.annotations?.title;
+					const description = tool.description;
+					entries.push([toolKey, {
+						description,
+						title,
+						execute: async (args) => {
+							const result = await this.callTool({
+								arguments: args,
+								name: toolName,
+								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: slot.converted.inputSchema,
+						outputSchema: slot.converted.outputSchema
+					}]);
+				} catch (error) {
+					console.warn(`[getAITools] Skipping tool "${toolName}" from "${serverId}": ${error}`);
+				}
+			}
+			cache.converted.length = catalog.length;
 		}
 		return Object.fromEntries(entries);
 	}
@@ -1845,4 +2116,4 @@ function getNamespacedData(mcpClients, type) {
 //#endregion
 export { MCPConnectionState as a, RPC_DO_PREFIX as c, normalizeServerId as i, DisposableStore as l, MCP_SERVER_ID_MAX_LENGTH as n, RPCClientTransport as o, getNamespacedData as r, RPCServerTransport as s, MCPClientManager as t };
 
-//# sourceMappingURL=client-BZ-B3NhC.js.map
+//# sourceMappingURL=client-CcjiFpTf.js.map