agents 0.9.0 → 0.10.0

package/dist/{client-BwgM3cRz.js → client-QBjFV5de.js}

@@ -274,6 +274,7 @@ var MCPClientConnection = class {
 		this.prompts = [];
 		this.resources = [];
 		this.resourceTemplates = [];
+		this._probingCapabilities = false;
 		this._onObservabilityEvent = new Emitter();
 		this.onObservabilityEvent = this._onObservabilityEvent.event;
 		this.client = new Client(info, {
@@ -371,25 +372,28 @@ var MCPClientConnection = class {
 	* 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 discoveredCapabilities = this.client.getServerCapabilities();
+		const shouldProbeCapabilities = !discoveredCapabilities && this.isResumedStreamableHttpSession();
+		this.serverCapabilities = discoveredCapabilities;
+		this._probingCapabilities = shouldProbeCapabilities;
+		if (!discoveredCapabilities && !shouldProbeCapabilities) 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) {
+		if (discoveredCapabilities?.tools || shouldProbeCapabilities) {
 			operations.push(this.registerTools());
 			operationNames.push("tools");
 		}
-		if (this.serverCapabilities.resources) {
+		if (discoveredCapabilities?.resources || shouldProbeCapabilities) {
 			operations.push(this.registerResources());
 			operationNames.push("resources");
 		}
-		if (this.serverCapabilities.prompts) {
+		if (discoveredCapabilities?.prompts || shouldProbeCapabilities) {
 			operations.push(this.registerPrompts());
 			operationNames.push("prompts");
 		}
-		if (this.serverCapabilities.resources) {
+		if (discoveredCapabilities?.resources || shouldProbeCapabilities) {
 			operations.push(this.registerResourceTemplates());
 			operationNames.push("resource templates");
 		}
@@ -508,7 +512,7 @@ var MCPClientConnection = class {
 	* Should only be called if serverCapabilities.tools exists
 	*/
 	async registerTools() {
-		if (this.serverCapabilities?.tools?.listChanged) this.client.setNotificationHandler(ToolListChangedNotificationSchema, async (_notification) => {
+		if (this.serverCapabilities?.tools?.listChanged || this._probingCapabilities) this.client.setNotificationHandler(ToolListChangedNotificationSchema, async (_notification) => {
 			this.tools = await this.fetchTools();
 		});
 		return this.fetchTools();
@@ -518,7 +522,7 @@ var MCPClientConnection = class {
 	* Should only be called if serverCapabilities.resources exists
 	*/
 	async registerResources() {
-		if (this.serverCapabilities?.resources?.listChanged) this.client.setNotificationHandler(ResourceListChangedNotificationSchema, async (_notification) => {
+		if (this.serverCapabilities?.resources?.listChanged || this._probingCapabilities) this.client.setNotificationHandler(ResourceListChangedNotificationSchema, async (_notification) => {
 			this.resources = await this.fetchResources();
 		});
 		return this.fetchResources();
@@ -528,7 +532,7 @@ var MCPClientConnection = class {
 	* Should only be called if serverCapabilities.prompts exists
 	*/
 	async registerPrompts() {
-		if (this.serverCapabilities?.prompts?.listChanged) this.client.setNotificationHandler(PromptListChangedNotificationSchema, async (_notification) => {
+		if (this.serverCapabilities?.prompts?.listChanged || this._probingCapabilities) this.client.setNotificationHandler(PromptListChangedNotificationSchema, async (_notification) => {
 			this.prompts = await this.fetchPrompts();
 		});
 		return this.fetchPrompts();
@@ -579,6 +583,64 @@ var MCPClientConnection = class {
 	async handleElicitationRequest(_request) {
 		throw new Error("Elicitation handler must be implemented for your platform. Override handleElicitationRequest method.");
 	}
+	isResumedStreamableHttpSession() {
+		return this._transport instanceof StreamableHTTPClientTransport && typeof this._transport.sessionId === "string";
+	}
+	get sessionId() {
+		if (this._transport instanceof StreamableHTTPClientTransport) return this._transport.sessionId;
+	}
+	getTransportName(transport) {
+		if (transport instanceof StreamableHTTPClientTransport) return "streamable-http";
+		if (transport instanceof SSEClientTransport) return "sse";
+		if (transport instanceof RPCClientTransport) return "rpc";
+		return this.lastConnectedTransport;
+	}
+	async close() {
+		const transport = this._transport;
+		this._transport = void 0;
+		const url = this.url.toString();
+		const transportName = this.getTransportName(transport);
+		if (transport instanceof StreamableHTTPClientTransport && transport.sessionId) try {
+			await transport.terminateSession();
+		} catch (error) {
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:close",
+				payload: {
+					url,
+					transport: transportName,
+					state: "error",
+					error: toErrorMessage(error),
+					phase: "terminate-session"
+				},
+				timestamp: Date.now()
+			});
+		}
+		try {
+			await this.client.close();
+		} catch (error) {
+			this._onObservabilityEvent.fire({
+				type: "mcp:client:close",
+				payload: {
+					url,
+					transport: transportName,
+					state: "error",
+					error: toErrorMessage(error),
+					phase: "client-close"
+				},
+				timestamp: Date.now()
+			});
+			throw error;
+		}
+		this._onObservabilityEvent.fire({
+			type: "mcp:client:close",
+			payload: {
+				url,
+				transport: transportName,
+				state: "closed"
+			},
+			timestamp: Date.now()
+		});
+	}
 	/**
 	* Get the transport for the client
 	* @param transportType - The transport type to get
@@ -600,6 +662,7 @@ var MCPClientConnection = class {
 			const transport = this.getTransport(currentTransportType);
 			try {
 				await this.client.connect(transport);
+				this._transport = transport;
 				return {
 					state: MCPConnectionState.CONNECTED,
 					transport: currentTransportType
@@ -747,6 +810,23 @@ var MCPClientManager = class {
 	getServersFromStorage() {
 		return this.sql("SELECT id, name, server_url, client_id, auth_url, callback_url, server_options FROM cf_agents_mcp_servers");
 	}
+	filterConnections(filter) {
+		if (!filter) return this.mcpConnections;
+		const serverIds = filter.serverId ? Array.isArray(filter.serverId) ? filter.serverId : [filter.serverId] : void 0;
+		const serverNames = filter.serverName ? Array.isArray(filter.serverName) ? filter.serverName : [filter.serverName] : void 0;
+		const states = filter.state ? Array.isArray(filter.state) ? filter.state : [filter.state] : void 0;
+		let nameMatchedIds;
+		if (serverNames) {
+			const servers = this.getServersFromStorage();
+			nameMatchedIds = new Set(servers.filter((s) => serverNames.includes(s.name)).map((s) => s.id));
+		}
+		return Object.fromEntries(Object.entries(this.mcpConnections).filter(([id, conn]) => {
+			if (serverIds && !serverIds.includes(id)) return false;
+			if (nameMatchedIds && !nameMatchedIds.has(id)) return false;
+			if (states && !states.includes(conn.connectionState)) return false;
+			return true;
+		}));
+	}
 	/**
 	* Get the retry options for a server from stored server_options
 	*/
@@ -758,6 +838,24 @@ var MCPClientManager = class {
 	clearServerAuthUrl(serverId) {
 		this.sql("UPDATE cf_agents_mcp_servers SET auth_url = NULL WHERE id = ?", serverId);
 	}
+	updateStoredSessionId(id, sessionId) {
+		const serverRow = this.getServersFromStorage().find((server) => server.id === id);
+		if (!serverRow) return;
+		const parsedOptions = serverRow.server_options ? JSON.parse(serverRow.server_options) : {};
+		if (parsedOptions.transport?.sessionId === sessionId) return;
+		const nextTransport = {
+			...parsedOptions.transport ?? {},
+			...sessionId ? { sessionId } : {}
+		};
+		if (!sessionId) delete nextTransport.sessionId;
+		this.saveServerToStorage({
+			...serverRow,
+			server_options: JSON.stringify({
+				...parsedOptions,
+				transport: nextTransport
+			})
+		});
+	}
 	failConnection(serverId, error) {
 		this.clearServerAuthUrl(serverId);
 		if (this.mcpConnections[serverId]) {
@@ -832,15 +930,12 @@ var MCPClientManager = class {
 					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);
+				if (existingConn.connectionState === MCPConnectionState.FAILED) try {
+					await existingConn.close();
+				} catch (error) {
+					console.warn(`[MCPClientManager] Error closing failed connection ${server.id}:`, error);
+				} finally {
+					this.cleanupClosedConnection(server.id);
 				}
 			}
 			const parsedOptions = server.server_options ? JSON.parse(server.server_options) : null;
@@ -1063,6 +1158,7 @@ var MCPClientManager = class {
 		const conn = this.mcpConnections[id];
 		if (!conn) throw new Error(`Server ${id} is not registered. Call registerServer() first.`);
 		const error = await conn.init();
+		this.updateStoredSessionId(id, conn.sessionId);
 		this._onServerStateChanged.fire();
 		switch (conn.connectionState) {
 			case MCPConnectionState.FAILED: return {
@@ -1199,6 +1295,7 @@ var MCPClientManager = class {
 			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);
+			this.updateStoredSessionId(serverId, conn.sessionId);
 			await authProvider.deleteCodeVerifier();
 			this.clearServerAuthUrl(serverId);
 			conn.connectionError = null;
@@ -1308,18 +1405,21 @@ var MCPClientManager = class {
 		return this._oauthCallbackConfig;
 	}
 	/**
+	* @param filter - Optional filter to scope results to specific servers
 	* @returns namespaced list of tools
 	*/
-	listTools() {
-		return getNamespacedData(this.mcpConnections, "tools");
+	listTools(filter) {
+		return getNamespacedData(this.filterConnections(filter), "tools");
 	}
 	/**
+	* @param filter - Optional filter to scope results to specific servers
 	* @returns a set of tools that you can use with the AI SDK
 	*/
-	getAITools() {
-		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.`);
+	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(this.mcpConnections, "tools")) try {
+		for (const tool of getNamespacedData(connections, "tools")) try {
 			const toolKey = `tool_${tool.serverId.replace(/-/g, "")}_${tool.name}`;
 			entries.push([toolKey, {
 				description: tool.description,
@@ -1346,14 +1446,15 @@ var MCPClientManager = class {
 	}
 	/**
 	* @deprecated this has been renamed to getAITools(), and unstable_getAITools will be removed in the next major version
+	* @param filter - Optional filter to scope results to specific servers
 	* @returns a set of tools that you can use with the AI SDK
 	*/
-	unstable_getAITools() {
+	unstable_getAITools(filter) {
 		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();
+		return this.getAITools(filter);
 	}
 	/**
 	* Closes all active in-memory connections to MCP servers.
@@ -1365,33 +1466,41 @@ var MCPClientManager = class {
 	* Use removeServer() instead if you want to fully clean up a server
 	* (closes connection AND removes from storage).
 	*/
+	cleanupClosedConnection(id) {
+		this.updateStoredSessionId(id, void 0);
+		const store = this._connectionDisposables.get(id);
+		if (store) store.dispose();
+		this._connectionDisposables.delete(id);
+		delete this.mcpConnections[id];
+	}
 	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];
-		}
+		const errors = (await Promise.allSettled(ids.map(async (id) => {
+			try {
+				await this.mcpConnections[id].close();
+			} finally {
+				this.cleanupClosedConnection(id);
+			}
+		}))).flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Failed to close one or more MCP connections");
 	}
 	/**
 	* 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();
+		const connection = this.mcpConnections[id];
+		if (!connection) throw new Error(`Connection with id "${id}" does not exist.`);
+		connection.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);
+		try {
+			await connection.close();
+		} finally {
+			this.cleanupClosedConnection(id);
+		}
 	}
 	/**
 	* Remove an MCP server - closes connection if active and removes from storage.
@@ -1421,22 +1530,25 @@ var MCPClientManager = class {
 		}
 	}
 	/**
+	* @param filter - Optional filter to scope results to specific servers
 	* @returns namespaced list of prompts
 	*/
-	listPrompts() {
-		return getNamespacedData(this.mcpConnections, "prompts");
+	listPrompts(filter) {
+		return getNamespacedData(this.filterConnections(filter), "prompts");
 	}
 	/**
-	* @returns namespaced list of tools
+	* @param filter - Optional filter to scope results to specific servers
+	* @returns namespaced list of resources
 	*/
-	listResources() {
-		return getNamespacedData(this.mcpConnections, "resources");
+	listResources(filter) {
+		return getNamespacedData(this.filterConnections(filter), "resources");
 	}
 	/**
+	* @param filter - Optional filter to scope results to specific servers
 	* @returns namespaced list of resource templates
 	*/
-	listResourceTemplates() {
-		return getNamespacedData(this.mcpConnections, "resourceTemplates");
+	listResourceTemplates(filter) {
+		return getNamespacedData(this.filterConnections(filter), "resourceTemplates");
 	}
 	/**
 	* Namespaced version of callTool
@@ -1480,4 +1592,4 @@ function getNamespacedData(mcpClients, type) {
 //#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-BwgM3cRz.js.map
+//# sourceMappingURL=client-QBjFV5de.js.map