agents 0.17.4 → 0.19.0

package/dist/chat-sdk/index.d.ts

@@ -2,7 +2,7 @@ import {
   O as Agent,
   ct as SubAgentClass,
   lt as SubAgentStub
-} from "../agent-tool-types-OhWqAbCp.js";
+} from "../agent-tool-types-BNUGGBzQ.js";
 import { Lock, QueueEntry, StateAdapter } from "chat";
 
 //#region src/chat-sdk/agent.d.ts

package/dist/{client-C7F0MaVz.js → client-CcjiFpTf.js}

@@ -6,7 +6,7 @@ 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) {
@@ -550,6 +550,7 @@ var MCPClientConnection = class {
 			});
 			return {
 				success: false,
+				reason: "error",
 				error: `Discovery skipped - connection in ${this.connectionState} state`
 			};
 		}
@@ -587,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;
@@ -695,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";
@@ -935,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
 */
@@ -948,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;
@@ -1007,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;
@@ -1153,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);
@@ -1315,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);
@@ -1349,7 +1399,12 @@ 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]) {
-			delete this.mcpConnections[id];
+			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 ?? {}
@@ -1613,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 {
@@ -1633,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);
@@ -1676,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.
@@ -1717,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({
@@ -1800,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);
 	}
@@ -1982,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-C7F0MaVz.js.map
+//# sourceMappingURL=client-CcjiFpTf.js.map