agents 0.21.0 → 0.22.0

package/dist/chat/transport.js

@@ -1,2 +1,2 @@
-import { t as WebSocketChatTransport } from "../ws-chat-transport-CIoOBbO7.js";
+import { t as WebSocketChatTransport } from "../ws-chat-transport-rWwta645.js";
 export { WebSocketChatTransport };

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

@@ -1,8 +1,8 @@
 import {
-  O as Agent,
-  ct as SubAgentClass,
-  lt as SubAgentStub
-} from "../agent-tool-types-CzGGB-20.js";
+  M as SubAgentClass,
+  N as SubAgentStub,
+  c as Agent
+} from "../agent-routing-CnkaHb-v.js";
 import { Lock, QueueEntry, StateAdapter } from "chat";
 
 //#region src/chat-sdk/agent.d.ts

package/dist/chat-sdk/index.js

@@ -1,4 +1,4 @@
-import { Agent, getCurrentAgent } from "../index.js";
+import { a as getCurrentAgent, t as Agent } from "../src-5W6JNKVb.js";
 //#region src/chat-sdk/agent.ts
 const NEXT_CLEANUP_AT_KEY = "next_cleanup_at";
 const CLEANUP_SCHEDULE_ID_KEY = "cleanup_schedule_id";

package/dist/{client-zqKcsyFa.js → client-jagG8a9_.js}

@@ -1,8 +1,9 @@
+import { getAgentByName } from "./agent-routing.js";
+import { t as LifecycleCapability } from "./capability-BjSKYpzg.js";
 import { tryN } from "./retries.js";
-import { n as callV2Tool } from "./client-invoker-VNZ7X0nn.js";
-import { DurableObjectOAuthClientProvider } from "./mcp/do-oauth-client-provider.js";
+import { n as callV2Tool } from "./invoker-CHMnoxIA.js";
+import { DurableObjectOAuthClientProvider } from "./mcp/client/do-oauth-client-provider.js";
 import { nanoid } from "nanoid";
-import { getServerByName } from "partyserver";
 import { z } from "zod";
 import { Client, SSEClientTransport, SdkHttpError, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/client/validators/cf-worker";
@@ -65,7 +66,7 @@ async function raceWithSignal(promise, signal) {
 	});
 }
 //#endregion
-//#region src/mcp/client-catalog.ts
+//#region src/mcp/client/catalog.ts
 async function fetchMcpTools(client, options) {
 	let aggregate = [];
 	let page = { tools: [] };
@@ -119,7 +120,7 @@ async function fetchMcpResourceTemplates(client, options) {
 	return aggregate;
 }
 //#endregion
-//#region src/mcp/client-runtime.ts
+//#region src/mcp/client/runtime.ts
 var CompatibleWorkerJsonSchemaValidator = class extends CfWorkerJsonSchemaValidator {
 	constructor(..._args) {
 		super(..._args);
@@ -197,7 +198,7 @@ function createMcpSdkClient(info, options, capabilitySeed, handlerModes, callbac
 	};
 }
 //#endregion
-//#region src/mcp/errors.ts
+//#region src/mcp/client/errors.ts
 function toErrorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -230,6 +231,10 @@ function isTransportNotImplemented(error) {
 //#endregion
 //#region src/mcp/rpc.ts
 const RPC_DO_PREFIX = "rpc:";
+/** Narrow an unknown runtime binding to an MCP Durable Object namespace. */
+function isDurableObjectNamespace(namespace) {
+	return typeof namespace === "object" && namespace !== null && "newUniqueId" in namespace && typeof namespace.newUniqueId === "function" && "idFromName" in namespace && typeof namespace.idFromName === "function";
+}
 function makeInvalidRequestError(id) {
 	return {
 		jsonrpc: "2.0",
@@ -259,7 +264,7 @@ var RPCClientTransport = class {
 	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._stub = await getAgentByName(this._namespace, doName, { props: this._props });
 		this._started = true;
 	}
 	async close() {
@@ -444,7 +449,7 @@ var RPCServerTransport = class {
 	}
 };
 //#endregion
-//#region src/mcp/client-connection.ts
+//#region src/mcp/client/connection.ts
 /**
 * Connection state machine for MCP client connections.
 *
@@ -1004,7 +1009,21 @@ var MCPClientConnection = class {
 	}
 };
 //#endregion
-//#region src/mcp/client-storage.ts
+//#region src/mcp/client/storage.ts
+/** Create the durable MCP server catalog table when it does not exist. */
+function ensureMcpServerTable(storage) {
+	storage.sql.exec(`
+    CREATE TABLE IF NOT EXISTS cf_agents_mcp_servers (
+      id TEXT PRIMARY KEY NOT NULL,
+      name TEXT NOT NULL,
+      server_url TEXT NOT NULL,
+      callback_url TEXT NOT NULL,
+      client_id TEXT,
+      auth_url TEXT,
+      server_options TEXT
+    )
+  `);
+}
 function persistClientOptions(client) {
 	if (!client) return void 0;
 	return {
@@ -1085,7 +1104,40 @@ function withMcpSession(options, session) {
 	};
 }
 //#endregion
-//#region src/mcp/client.ts
+//#region src/mcp/client/rpc.ts
+/** Restore persisted RPC connections through a manager's public transport API. */
+async function restoreRpcConnections(manager, env, servers) {
+	if (!env) {
+		for (const server of servers) console.warn(`[MCPClientManager] Cannot restore RPC MCP server "${server.name}": no env was provided; pass { env } when constructing MCPClientManager`);
+		return;
+	}
+	for (const server of servers) {
+		if (manager.mcpConnections[server.id]) continue;
+		const options = decodeMcpServerOptions(server.server_options);
+		const binding = options.bindingName ? Object.entries(env).find(([name]) => name === options.bindingName)?.[1] : void 0;
+		if (!isDurableObjectNamespace(binding)) {
+			console.warn(`[MCPClientManager] Cannot restore RPC MCP server "${server.name}": binding "${options.bindingName ?? "<missing>"}" not found in env`);
+			continue;
+		}
+		const normalizedName = server.server_url.replace(RPC_DO_PREFIX, "");
+		try {
+			await manager.connect(`${RPC_DO_PREFIX}${normalizedName}`, {
+				reconnect: { id: server.id },
+				transport: {
+					type: "rpc",
+					namespace: binding,
+					name: normalizedName,
+					props: options.props
+				}
+			});
+			if (manager.mcpConnections[server.id]?.connectionState === MCPConnectionState.CONNECTED) await manager.discoverIfConnected(server.id);
+		} catch (error) {
+			console.error(`[MCPClientManager] Error restoring RPC MCP server "${server.name}":`, error);
+		}
+	}
+}
+//#endregion
+//#region src/mcp/client/index.ts
 /** Maximum length of a normalized MCP server id. */
 const MCP_SERVER_ID_MAX_LENGTH = 64;
 /**
@@ -1215,16 +1267,23 @@ var ConnectRetryError = class extends Error {
 		this.result = result;
 	}
 };
+const MCP_SCHEMA_VERSION_KEY = "cf_agents:mcp_schema_version";
+const CURRENT_MCP_SCHEMA_VERSION = 1;
 /**
-* Utility class that aggregates multiple MCP clients into one
+* A Durable Object capability that persists and aggregates MCP client
+* connections. Installing it directly on a Lifecycle (outside `agent.mcp`)
+* is experimental: that capability surface may change before stabilizing.
 */
-var MCPClientManager = class {
+var MCPClientManager = class extends LifecycleCapability {
 	/**
-	* @param _name Name of the MCP client
-	* @param _version Version of the MCP Client
-	* @param options Storage adapter for persisting MCP server state
+	* Construct a reusable Durable Object MCP client capability.
+	*
+	* @param _name - MCP client implementation name sent during negotiation.
+	* @param _version - MCP client implementation version sent during negotiation.
+	* @param options - Optional runtime bindings and OAuth configuration.
 	*/
-	constructor(_name, _version, options) {
+	constructor(_name, _version, options = {}) {
+		super("mcp");
 		this._name = _name;
 		this._version = _version;
 		this.mcpConnections = {};
@@ -1237,10 +1296,44 @@ var MCPClientManager = class {
 		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._env = options.env;
 		this._createAuthProviderFn = options.createAuthProvider;
 	}
+	/** Restore persisted HTTP and RPC connections before the host handles work. */
+	async onStart() {
+		if ((await this.lifecycle.storage.get(MCP_SCHEMA_VERSION_KEY) ?? 0) < CURRENT_MCP_SCHEMA_VERSION) {
+			ensureMcpServerTable(this.lifecycle.storage);
+			await this.lifecycle.storage.put(MCP_SCHEMA_VERSION_KEY, CURRENT_MCP_SCHEMA_VERSION);
+		}
+		await this.restoreConnectionsFromStorage(this._name);
+		await restoreRpcConnections(this, this._env, this.getRpcServersFromStorage());
+		this._onServerStateChanged.fire();
+	}
+	/** Intercept a registered MCP OAuth callback request. */
+	async onRequest(context) {
+		const { request } = context;
+		if (!this.isCallbackRequest(request)) return void 0;
+		const result = await this.handleCallbackRequest(request);
+		if (result.authSuccess) this.establishConnection(result.serverId).catch((error) => {
+			console.error("[MCPClientManager] Connection establishment after OAuth failed:", error);
+		});
+		return this.oauthCallbackResponse(result, request);
+	}
+	oauthCallbackResponse(result, request) {
+		const config = this.getOAuthCallbackConfig();
+		if (config?.customHandler) return config.customHandler(result);
+		const baseOrigin = new URL(request.url).origin;
+		const redirect = result.authSuccess ? config?.successRedirect : config?.errorRedirect;
+		if (!redirect) return Response.redirect(baseOrigin);
+		try {
+			const target = new URL(redirect, baseOrigin);
+			if (!result.authSuccess) target.searchParams.set("error", result.authError);
+			return Response.redirect(target);
+		} catch (error) {
+			console.error("Invalid OAuth callback redirect URL:", redirect, error);
+			return Response.redirect(baseOrigin);
+		}
+	}
 	/**
 	* Scope the manager-level elicitation handler to a single connection.
 	* Returns undefined when no handler is configured so the connection keeps
@@ -1257,7 +1350,7 @@ var MCPClientManager = class {
 		};
 	}
 	sql(query, ...bindings) {
-		return [...this._storage.sql.exec(query, ...bindings)];
+		return [...this.lifecycle.storage.sql.exec(query, ...bindings)];
 	}
 	saveServerToStorage(server) {
 		this.sql(`INSERT OR REPLACE INTO cf_agents_mcp_servers (
@@ -1302,7 +1395,7 @@ var MCPClientManager = class {
 		const oldPrefix = `/${clientName}/${oldId}/`;
 		const newPrefix = `/${clientName}/${newId}/`;
 		try {
-			const keys = await this._storage.list({ prefix: oldPrefix });
+			const keys = await this.lifecycle.storage.list({ prefix: oldPrefix });
 			if (keys.size > 0) {
 				const writes = {};
 				const deletes = [];
@@ -1311,8 +1404,8 @@ var MCPClientManager = class {
 					writes[newKey] = value;
 					deletes.push(oldKey);
 				}
-				await this._storage.put(writes);
-				await this._storage.delete(deletes);
+				await this.lifecycle.storage.put(writes);
+				await this.lifecycle.storage.delete(deletes);
 			}
 		} catch (error) {
 			console.warn(`[MCPClientManager] OAuth key migration ${oldPrefix} → ${newPrefix} failed:`, error);
@@ -1489,23 +1582,19 @@ var MCPClientManager = class {
 	* @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);
+		const authProvider = new DurableObjectOAuthClientProvider(this.lifecycle.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.
-	*/
+	/** Get saved RPC servers from storage (servers with `rpc://` URLs). */
 	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.
+	* The binding name is stored so this manager can resolve the namespace from
+	* its runtime environment during restore.
 	*/
 	saveRpcServerToStorage(id, name, normalizedName, bindingName, props) {
 		this.saveServerToStorage({
@@ -1523,12 +1612,9 @@ var MCPClientManager = class {
 		});
 	}
 	/**
-	* 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.
+	* Restore persisted HTTP MCP connections.
 	*
-	* @param clientName Name to use for OAuth client (typically the agent instance name)
+	* @param clientName - Durable Object identity used to scope OAuth state.
 	*/
 	async restoreConnectionsFromStorage(clientName) {
 		if (this._isRestored) return;
@@ -1766,10 +1852,16 @@ var MCPClientManager = class {
 	*/
 	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`);
+		const authProvider = options.transport?.authProvider ?? (options.callbackUrl ? this._createAuthProviderFn?.(options.callbackUrl) ?? this.createAuthProvider(id, options.callbackUrl, this._name, options.clientId) : void 0);
+		if (authProvider) {
+			authProvider.serverId = id;
+			if (options.clientId) authProvider.clientId = options.clientId;
+		}
 		this.createConnection(id, options.url, {
 			client: options.client,
 			transport: {
 				...options.transport,
+				authProvider,
 				type: options.transport?.type ?? "auto"
 			}
 		});
@@ -2380,6 +2472,6 @@ 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 };
+export { ensureMcpServerTable as a, RPCServerTransport as c, DisposableStore as d, normalizeServerId as i, RPC_DO_PREFIX as l, MCP_SERVER_ID_MAX_LENGTH as n, MCPConnectionState as o, getNamespacedData as r, RPCClientTransport as s, MCPClientManager as t, isDurableObjectNamespace as u };
 
-//# sourceMappingURL=client-zqKcsyFa.js.map
+//# sourceMappingURL=client-jagG8a9_.js.map