agents 0.19.0 → 0.20.0

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

@@ -1,13 +1,12 @@
 import { tryN } from "./retries.js";
+import { n as callV2Tool } from "./client-invoker-VNZ7X0nn.js";
 import { DurableObjectOAuthClientProvider } from "./mcp/do-oauth-client-provider.js";
 import { nanoid } from "nanoid";
 import { getServerByName } from "partyserver";
 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, StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { ElicitRequestSchema, JSONRPCMessageSchema, PromptListChangedNotificationSchema, ResourceListChangedNotificationSchema, ToolListChangedNotificationSchema, isJSONRPCErrorResponse, isJSONRPCResultResponse } from "@modelcontextprotocol/sdk/types.js";
+import { Client, SSEClientTransport, SdkHttpError, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/client/validators/cf-worker";
+import { JSONRPCMessageSchema, isJSONRPCErrorResponse, isJSONRPCResultResponse } from "@modelcontextprotocol/sdk/types.js";
 //#region src/core/events.ts
 function toDisposable(fn) {
 	return { dispose: fn };
@@ -46,23 +45,187 @@ var Emitter = class {
 	}
 };
 //#endregion
+//#region src/mcp/abort.ts
+function abortError(signal) {
+	return signal.reason instanceof Error ? signal.reason : new Error(String(signal.reason ?? "Aborted"));
+}
+/**
+* Stop awaiting an operation when its owner aborts. The underlying operation
+* remains responsible for observing the same signal and cancelling its work.
+*/
+async function raceWithSignal(promise, signal) {
+	if (!signal) return promise;
+	if (signal.aborted) throw abortError(signal);
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(abortError(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(resolve, reject).finally(() => {
+			signal.removeEventListener("abort", onAbort);
+		});
+	});
+}
+//#endregion
+//#region src/mcp/client-catalog.ts
+async function fetchMcpTools(client, options) {
+	let aggregate = [];
+	let page = { tools: [] };
+	do {
+		const params = { cursor: page.nextCursor };
+		page = await (options.probing ? client.request({
+			method: "tools/list",
+			params
+		}) : client.listTools(params)).catch(options.onCapabilityError({ tools: [] }, "tools/list"));
+		aggregate = aggregate.concat(page.tools);
+	} while (page.nextCursor);
+	return aggregate;
+}
+async function fetchMcpResources(client, options) {
+	let aggregate = [];
+	let page = { resources: [] };
+	do {
+		const params = { cursor: page.nextCursor };
+		page = await (options.probing ? client.request({
+			method: "resources/list",
+			params
+		}) : client.listResources(params)).catch(options.onCapabilityError({ resources: [] }, "resources/list"));
+		aggregate = aggregate.concat(page.resources);
+	} while (page.nextCursor);
+	return aggregate;
+}
+async function fetchMcpPrompts(client, options) {
+	let aggregate = [];
+	let page = { prompts: [] };
+	do {
+		const params = { cursor: page.nextCursor };
+		page = await (options.probing ? client.request({
+			method: "prompts/list",
+			params
+		}) : client.listPrompts(params)).catch(options.onCapabilityError({ prompts: [] }, "prompts/list"));
+		aggregate = aggregate.concat(page.prompts);
+	} while (page.nextCursor);
+	return aggregate;
+}
+async function fetchMcpResourceTemplates(client, options) {
+	let aggregate = [];
+	let page = { resourceTemplates: [] };
+	do {
+		const params = { cursor: page.nextCursor };
+		page = await (options.probing ? client.request({
+			method: "resources/templates/list",
+			params
+		}) : client.listResourceTemplates(params)).catch(options.onCapabilityError({ resourceTemplates: [] }, "resources/templates/list"));
+		aggregate = aggregate.concat(page.resourceTemplates);
+	} while (page.nextCursor);
+	return aggregate;
+}
+//#endregion
+//#region src/mcp/client-runtime.ts
+var CompatibleWorkerJsonSchemaValidator = class extends CfWorkerJsonSchemaValidator {
+	constructor(..._args) {
+		super(..._args);
+		this.legacy = new CfWorkerJsonSchemaValidator({ draft: "7" });
+	}
+	getValidator(schema) {
+		const dialect = schema.$schema;
+		return typeof dialect === "string" && /draft-0?7/i.test(dialect) ? this.legacy.getValidator(schema) : super.getValidator(schema);
+	}
+};
+const DEFAULT_CLIENT_OPTIONS = {
+	jsonSchemaValidator: new CompatibleWorkerJsonSchemaValidator(),
+	versionNegotiation: { mode: "auto" },
+	inputRequired: { autoFulfill: true }
+};
+function normalizeMcpClientOptions(options) {
+	return {
+		...DEFAULT_CLIENT_OPTIONS,
+		...options,
+		versionNegotiation: {
+			...DEFAULT_CLIENT_OPTIONS.versionNegotiation,
+			...options?.versionNegotiation
+		},
+		inputRequired: {
+			...DEFAULT_CLIENT_OPTIONS.inputRequired,
+			...options?.inputRequired
+		}
+	};
+}
+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;
+}
+function listChangedHandlers(configured, callbacks) {
+	return {
+		tools: {
+			...configured?.tools,
+			onChanged: (error, tools) => {
+				callbacks.tools(error, tools);
+				configured?.tools?.onChanged(error, tools);
+			}
+		},
+		prompts: {
+			...configured?.prompts,
+			onChanged: (error, prompts) => {
+				callbacks.prompts(error, prompts);
+				configured?.prompts?.onChanged(error, prompts);
+			}
+		},
+		resources: {
+			...configured?.resources,
+			onChanged: (error, resources) => {
+				callbacks.resources(error, resources);
+				configured?.resources?.onChanged(error, resources);
+			}
+		}
+	};
+}
+function createMcpSdkClient(info, options, capabilitySeed, handlerModes, callbacks) {
+	const elicitation = options.capabilities?.elicitation ?? elicitationCapabilitiesFromHandlers(handlerModes) ?? capabilitySeed?.elicitation;
+	return {
+		client: new Client(info, {
+			...options,
+			capabilities: {
+				...capabilitySeed,
+				...options.capabilities,
+				...elicitation ? { elicitation } : {}
+			},
+			listChanged: listChangedHandlers(options.listChanged, callbacks)
+		}),
+		elicitationEnabled: elicitation !== void 0
+	};
+}
+//#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 getErrorStatus(error) {
+	if (!error || typeof error !== "object") return void 0;
+	const record = error;
+	if (typeof record.code === "number") return record.code;
+	if (typeof record.status === "number") return record.status;
+	if (typeof record.data?.status === "number") return record.data.status;
+}
+function getErrorCause(error) {
+	if (!error || typeof error !== "object") return void 0;
+	return error.cause ?? error.data?.cause;
 }
 function isUnauthorized(error) {
-	if (getErrorCode(error) === 401) return true;
+	if (getErrorStatus(error) === 401) return true;
+	const cause = getErrorCause(error);
+	if (cause && cause !== error && isUnauthorized(cause)) 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 status = getErrorStatus(error);
+	if (status === 404 || status === 405) return true;
+	const cause = getErrorCause(error);
+	if (cause && cause !== error && isTransportNotImplemented(cause)) return true;
 	const msg = toErrorMessage(error);
-	return msg.includes("404") || msg.includes("405") || msg.includes("Not Implemented") || msg.includes("not implemented");
+	return msg.includes("404") || msg.includes("405") || msg.includes("Error POSTing to endpoint: Not Found") || msg.includes("Not Implemented") || msg.includes("not implemented");
 }
 //#endregion
 //#region src/mcp/rpc.ts
@@ -107,9 +270,9 @@ var RPCClientTransport = class {
 	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 result = await raceWithSignal(this._stub.handleMcpMessage(message), options?.requestSignal);
+			if (!result || options?.requestSignal?.aborted) return;
+			const extra = void 0;
 			const messages = Array.isArray(result) ? result : [result];
 			for (const msg of messages) this.onmessage?.(msg, extra);
 		} catch (error) {
@@ -282,7 +445,6 @@ var RPCServerTransport = class {
 };
 //#endregion
 //#region src/mcp/client-connection.ts
-const defaultClientOptions = { jsonSchemaValidator: new CfWorkerJsonSchemaValidator() };
 /**
 * Connection state machine for MCP client connections.
 *
@@ -305,14 +467,6 @@ 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 = {
 		client: {},
@@ -330,29 +484,32 @@ var MCPClientConnection = class {
 		this._probingCapabilities = false;
 		this._onObservabilityEvent = new Emitter();
 		this.onObservabilityEvent = this._onObservabilityEvent.event;
+		this._onListChanged = new Emitter();
+		this.onListChanged = this._onListChanged.event;
 		this._elicitationEnabled = false;
 		this.options = {
 			...options,
-			client: {
-				...defaultClientOptions,
-				...options.client
-			}
+			client: normalizeMcpClientOptions(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 = {
-			...this.options.client,
-			capabilities: {
-				...seed,
-				...this.options.client?.capabilities,
-				...elicitation ? { elicitation } : {}
+		const created = createMcpSdkClient(this._info, this.options.client, this.options.capabilitySeed, this.options.elicitationHandlers, {
+			tools: (error, tools) => {
+				if (!error && tools) this.tools = tools;
+				this._onListChanged.fire();
+			},
+			prompts: (error, prompts) => {
+				if (!error && prompts) this.prompts = prompts;
+				this._onListChanged.fire();
+			},
+			resources: (error, resources) => {
+				if (!error && resources) this.resources = resources;
+				this._onListChanged.fire();
 			}
-		};
-		return new Client(this._info, clientOptions);
+		});
+		this._elicitationEnabled = created.elicitationEnabled;
+		return created.client;
 	}
 	/**
 	* Configure the handler used for server-initiated elicitation requests.
@@ -367,7 +524,7 @@ var MCPClientConnection = class {
 	configureElicitationHandlers(handlers) {
 		this.options.elicitationHandlers = handlers;
 		this.options.capabilitySeed = void 0;
-		if (!this.client.transport) this.client = this.createClient();
+		if (!this._transport) this.client = this.createClient();
 	}
 	/**
 	* Initialize a client connection, if authentication is required, the connection will be in the AUTHENTICATING state
@@ -378,7 +535,7 @@ var MCPClientConnection = class {
 	async init() {
 		const transportType = this.options.transport.type;
 		if (!transportType) throw new Error("Transport type must be specified");
-		if (this.client.transport) {
+		if (this._transport) {
 			this._transport = void 0;
 			try {
 				await this.client.close();
@@ -388,9 +545,7 @@ var MCPClientConnection = class {
 		const res = await this.tryConnect(transportType);
 		this.connectionState = res.state;
 		if (res.state === MCPConnectionState.CONNECTED && res.transport) {
-			if (this._elicitationEnabled) this.client.setRequestHandler(ElicitRequestSchema, async (request) => {
-				return await this.handleElicitationRequest(request);
-			});
+			if (this._elicitationEnabled) this.client.setRequestHandler("elicitation/create", async (request, context) => await this.handleElicitationRequest(request, context.mcpReq.signal));
 			this.lastConnectedTransport = res.transport;
 			this._onObservabilityEvent.fire({
 				type: "mcp:client:connect",
@@ -422,19 +577,36 @@ var MCPClientConnection = class {
 	* - Explicit: finish on that transport
 	* - Auto: try streamable-http, then sse on 404/405/Not Implemented
 	*/
-	async finishAuthProbe(code) {
+	async finishAuthProbe(callbackParams) {
 		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);
+			let completed = false;
+			try {
+				if ("finishAuth" in transport && typeof transport.finishAuth === "function") {
+					await transport.finishAuth(callbackParams);
+					completed = true;
+				}
+			} finally {
+				if (typeof transport.close === "function") await transport.close().catch(() => {});
+			}
+			if (completed) this.client = this.createClient();
 		};
 		if (configuredType === "rpc") throw new Error("RPC transport does not support authentication");
 		const authTransport = this._pendingAuthTransport ?? this._transport;
 		this._pendingAuthTransport = void 0;
 		if (authTransport && "finishAuth" in authTransport && typeof authTransport.finishAuth === "function") {
-			await authTransport.finishAuth(code);
+			let completed = false;
+			try {
+				await authTransport.finishAuth(callbackParams);
+				completed = true;
+			} finally {
+				if (typeof authTransport.close === "function") await authTransport.close().catch(() => {});
+				if (this._transport === authTransport) this._transport = void 0;
+			}
+			if (completed) this.client = this.createClient();
 			return;
 		}
 		if (configuredType === "sse" || configuredType === "streamable-http") {
@@ -454,12 +626,13 @@ var MCPClientConnection = class {
 	/**
 	* Complete OAuth authorization
 	*/
-	async completeAuthorization(code, options = {}) {
+	async completeAuthorization(callback, options = {}) {
 		const expectedState = options.alreadyAccepted ? MCPConnectionState.CONNECTING : MCPConnectionState.AUTHENTICATING;
 		if (this.connectionState !== expectedState) throw new Error(`Connection must be in ${expectedState} state to complete authorization`);
 		if (!options.alreadyAccepted) this.connectionState = MCPConnectionState.CONNECTING;
 		try {
-			await this.finishAuthProbe(code);
+			const callbackParams = typeof callback === "string" ? new URLSearchParams({ code: callback }) : callback;
+			await this.finishAuthProbe(callbackParams);
 		} catch (error) {
 			this.connectionState = MCPConnectionState.FAILED;
 			throw error;
@@ -587,11 +760,11 @@ var MCPClientConnection = class {
 			return { success: true };
 		} catch (e) {
 			if (timeoutId !== void 0) clearTimeout(timeoutId);
-			this.connectionState = MCPConnectionState.CONNECTED;
+			this.connectionState = isUnauthorized(e) ? MCPConnectionState.AUTHENTICATING : MCPConnectionState.CONNECTED;
 			const error = e instanceof Error ? e.message : String(e);
 			return {
 				success: false,
-				reason: this._probingCapabilities && e instanceof StreamableHTTPError && e.code === 404 ? "stale-session" : "error",
+				reason: this._probingCapabilities && e instanceof SdkHttpError && e.status === 404 ? "stale-session" : "error",
 				error
 			};
 		} finally {
@@ -613,8 +786,9 @@ var MCPClientConnection = class {
 	* Should only be called if serverCapabilities.tools exists
 	*/
 	async registerTools() {
-		if (this.serverCapabilities?.tools?.listChanged || this._probingCapabilities) this.client.setNotificationHandler(ToolListChangedNotificationSchema, async (_notification) => {
+		if (this._probingCapabilities) this.client.setNotificationHandler("notifications/tools/list_changed", async () => {
 			this.tools = await this.fetchTools();
+			this._onListChanged.fire();
 		});
 		return this.fetchTools();
 	}
@@ -623,8 +797,9 @@ var MCPClientConnection = class {
 	* Should only be called if serverCapabilities.resources exists
 	*/
 	async registerResources() {
-		if (this.serverCapabilities?.resources?.listChanged || this._probingCapabilities) this.client.setNotificationHandler(ResourceListChangedNotificationSchema, async (_notification) => {
+		if (this._probingCapabilities) this.client.setNotificationHandler("notifications/resources/list_changed", async () => {
 			this.resources = await this.fetchResources();
+			this._onListChanged.fire();
 		});
 		return this.fetchResources();
 	}
@@ -633,49 +808,32 @@ var MCPClientConnection = class {
 	* Should only be called if serverCapabilities.prompts exists
 	*/
 	async registerPrompts() {
-		if (this.serverCapabilities?.prompts?.listChanged || this._probingCapabilities) this.client.setNotificationHandler(PromptListChangedNotificationSchema, async (_notification) => {
+		if (this._probingCapabilities) this.client.setNotificationHandler("notifications/prompts/list_changed", async () => {
 			this.prompts = await this.fetchPrompts();
+			this._onListChanged.fire();
 		});
 		return this.fetchPrompts();
 	}
 	async registerResourceTemplates() {
 		return this.fetchResourceTemplates();
 	}
+	catalogFetchOptions() {
+		return {
+			probing: this._probingCapabilities,
+			onCapabilityError: this._capabilityErrorHandler.bind(this)
+		};
+	}
 	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;
+		return fetchMcpTools(this.client, this.catalogFetchOptions());
 	}
 	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;
+		return fetchMcpResources(this.client, this.catalogFetchOptions());
 	}
 	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;
+		return fetchMcpPrompts(this.client, this.catalogFetchOptions());
 	}
 	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;
+		return fetchMcpResourceTemplates(this.client, this.catalogFetchOptions());
 	}
 	/**
 	* Handle elicitation request from server.
@@ -685,10 +843,10 @@ var MCPClientConnection = class {
 	* @deprecated Overriding or instance-patching this method directly is
 	* deprecated — pass the `elicitationHandlers` connection option instead.
 	*/
-	async handleElicitationRequest(request) {
+	async handleElicitationRequest(request, signal) {
 		const mode = request.params.mode === "url" ? "url" : "form";
 		const handler = this.options.elicitationHandlers?.[mode];
-		if (handler) return handler(request);
+		if (handler) return raceWithSignal(signal ? handler(request, signal) : handler(request), signal);
 		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.");
 	}
@@ -702,6 +860,26 @@ var MCPClientConnection = class {
 	clearResumedSession() {
 		if ("sessionId" in this.options.transport) delete this.options.transport.sessionId;
 	}
+	get protocolVersion() {
+		if (this._transport instanceof StreamableHTTPClientTransport) return this._transport.protocolVersion;
+	}
+	get discoverResult() {
+		return this.client.getDiscoverResult();
+	}
+	async openRestoredListSubscription() {
+		const capabilities = this.client.getServerCapabilities();
+		const filter = {
+			...capabilities?.tools?.listChanged && { toolsListChanged: true },
+			...capabilities?.prompts?.listChanged && { promptsListChanged: true },
+			...capabilities?.resources?.listChanged && { resourcesListChanged: true }
+		};
+		if (Object.keys(filter).length === 0) return;
+		try {
+			this._restoredListSubscription = await this.client.listen(filter);
+		} catch (error) {
+			this.client.onerror?.(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
 	getTransportName(transport) {
 		if (transport instanceof StreamableHTTPClientTransport) return "streamable-http";
 		if (transport instanceof SSEClientTransport) return "sse";
@@ -711,6 +889,8 @@ var MCPClientConnection = class {
 	async close() {
 		const transport = this._transport;
 		this._transport = void 0;
+		await this._restoredListSubscription?.close().catch(() => {});
+		this._restoredListSubscription = void 0;
 		const url = this.url.toString();
 		const transportName = this.getTransportName(transport);
 		if (transport instanceof StreamableHTTPClientTransport && transport.sessionId) try {
@@ -774,9 +954,14 @@ var MCPClientConnection = class {
 			const hasFallback = transportType === "auto" && currentTransportType === "streamable-http" && !isLastTransport;
 			const transport = this.getTransport(currentTransportType);
 			try {
-				await this.client.connect(transport);
+				const prior = transport instanceof StreamableHTTPClientTransport && transport.sessionId && this.options.discoverResult ? {
+					kind: "modern",
+					discover: this.options.discoverResult
+				} : void 0;
+				await this.client.connect(transport, prior ? { prior } : void 0);
 				this._transport = transport;
 				this._pendingAuthTransport = void 0;
+				if (prior) await this.openRestoredListSubscription();
 				return {
 					state: MCPConnectionState.CONNECTED,
 					transport: currentTransportType
@@ -819,6 +1004,87 @@ var MCPClientConnection = class {
 	}
 };
 //#endregion
+//#region src/mcp/client-storage.ts
+function persistClientOptions(client) {
+	if (!client) return void 0;
+	return {
+		capabilities: client.capabilities,
+		supportedProtocolVersions: client.supportedProtocolVersions,
+		enforceStrictCapabilities: client.enforceStrictCapabilities,
+		debouncedNotificationMethods: client.debouncedNotificationMethods,
+		versionNegotiation: client.versionNegotiation,
+		inputRequired: client.inputRequired,
+		listMaxPages: client.listMaxPages,
+		cachePartition: client.cachePartition,
+		defaultCacheTtlMs: client.defaultCacheTtlMs
+	};
+}
+function persistTransportOptions(value) {
+	if (!value) return void 0;
+	return {
+		type: value.type,
+		headers: value.headers,
+		requestInit: value.requestInit,
+		reconnectionOptions: value.reconnectionOptions,
+		skipIssuerMetadataValidation: value.skipIssuerMetadataValidation,
+		onInsufficientScope: value.onInsufficientScope,
+		maxStepUpRetries: value.maxStepUpRetries,
+		sessionId: value.sessionId,
+		protocolVersion: value.protocolVersion
+	};
+}
+function encodeMcpServerOptions(options) {
+	return JSON.stringify({
+		client: persistClientOptions(options.client),
+		transport: persistTransportOptions(options.transport),
+		discoverResult: options.discoverResult,
+		retry: options.retry,
+		bindingName: options.bindingName,
+		props: options.props,
+		capabilities: options.capabilities
+	});
+}
+function decodeMcpServerOptions(value) {
+	if (!value) return {};
+	const parsed = JSON.parse(value);
+	const transport = persistTransportOptions(parsed.transport);
+	const statelessWithoutPrior = transport?.protocolVersion === "2026-07-28" && !parsed.discoverResult;
+	if (transport?.sessionId && (!transport.protocolVersion || statelessWithoutPrior)) {
+		delete transport.sessionId;
+		delete transport.protocolVersion;
+		delete parsed.discoverResult;
+	}
+	return {
+		client: persistClientOptions(parsed.client),
+		transport,
+		discoverResult: parsed.discoverResult,
+		retry: parsed.retry,
+		...parsed.bindingName !== void 0 && { bindingName: parsed.bindingName },
+		...parsed.props !== void 0 && { props: parsed.props },
+		capabilities: parsed.capabilities
+	};
+}
+function withMcpSession(options, session) {
+	const transport = { ...options.transport ?? {} };
+	if (!session) {
+		delete transport.sessionId;
+		delete transport.protocolVersion;
+		const next = {
+			...options,
+			transport
+		};
+		delete next.discoverResult;
+		return next;
+	}
+	transport.sessionId = session.id;
+	transport.protocolVersion = session.protocolVersion;
+	return {
+		...options,
+		transport,
+		...session.discoverResult ? { discoverResult: session.discoverResult } : { discoverResult: void 0 }
+	};
+}
+//#endregion
 //#region src/mcp/client.ts
 /** Maximum length of a normalized MCP server id. */
 const MCP_SERVER_ID_MAX_LENGTH = 64;
@@ -986,8 +1252,8 @@ var MCPClientManager = class {
 		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
+			form: form ? (request, signal) => signal ? form(request, serverId, signal) : form(request, serverId) : void 0,
+			url: url ? (request, signal) => signal ? url(request, serverId, signal) : url(request, serverId) : void 0
 		};
 	}
 	sql(query, ...bindings) {
@@ -1097,7 +1363,7 @@ var MCPClientManager = class {
 	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);
+		return decodeMcpServerOptions(rows[0].server_options);
 	}
 	/**
 	* Clear the capabilities persisted on a stored server row. Called once a
@@ -1110,12 +1376,12 @@ var MCPClientManager = class {
 	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);
+		const options = decodeMcpServerOptions(row.server_options);
 		if (!options.capabilities) return;
 		options.capabilities = void 0;
 		this.saveServerToStorage({
 			...row,
-			server_options: JSON.stringify(options)
+			server_options: encodeMcpServerOptions(options)
 		});
 	}
 	/**
@@ -1127,22 +1393,18 @@ var MCPClientManager = class {
 	clearServerAuthUrl(serverId) {
 		this.sql("UPDATE cf_agents_mcp_servers SET auth_url = NULL WHERE id = ?", serverId);
 	}
-	updateStoredSessionId(id, sessionId) {
+	updateStoredSession(id, sessionId, protocolVersion, discoverResult) {
 		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;
+		const options = decodeMcpServerOptions(serverRow.server_options);
+		const next = sessionId && protocolVersion ? withMcpSession(options, {
+			id: sessionId,
+			protocolVersion,
+			discoverResult
+		}) : withMcpSession(options);
 		this.saveServerToStorage({
 			...serverRow,
-			server_options: JSON.stringify({
-				...parsedOptions,
-				transport: nextTransport
-			})
+			server_options: encodeMcpServerOptions(next)
 		});
 	}
 	failConnection(serverId, error) {
@@ -1201,12 +1463,12 @@ var MCPClientManager = class {
 			console.warn(`[MCPClientManager] Failed to clean up stale OAuth callback state for server "${serverId}":`, cleanupError);
 		}
 	}
-	async completeAuthorizationAndCleanupVerifier(serverId, conn, authProvider, state, code) {
+	async completeAuthorizationAndCleanupVerifier(serverId, conn, authProvider, state, callbackParams) {
 		await this.runWithCodeVerifierState(authProvider, state, async () => {
 			let completeError;
 			let cleanupError;
 			try {
-				await conn.completeAuthorization(code, { alreadyAccepted: true });
+				await conn.completeAuthorization(callbackParams, { alreadyAccepted: true });
 			} catch (error) {
 				completeError = error;
 			}
@@ -1253,7 +1515,7 @@ var MCPClientManager = class {
 			client_id: null,
 			auth_url: null,
 			callback_url: "",
-			server_options: JSON.stringify({
+			server_options: encodeMcpServerOptions({
 				bindingName,
 				props,
 				capabilities: this.advertisedHandlerCapabilities()
@@ -1292,8 +1554,7 @@ var MCPClientManager = class {
 					this.cleanupClosedConnection(server.id);
 				}
 			}
-			const parsedOptions = server.server_options ? JSON.parse(server.server_options) : null;
-			if (parsedOptions?.client) delete parsedOptions.client.jsonSchemaValidator;
+			const parsedOptions = decodeMcpServerOptions(server.server_options);
 			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);
@@ -1306,7 +1567,8 @@ var MCPClientManager = class {
 					...parsedOptions?.transport ?? {},
 					type: parsedOptions?.transport?.type ?? "auto",
 					authProvider
-				}
+				},
+				discoverResult: parsedOptions?.discoverResult
 			});
 			if (server.auth_url) {
 				conn.connectionState = MCPConnectionState.AUTHENTICATING;
@@ -1403,7 +1665,7 @@ var MCPClientManager = class {
 			if (replaced) {
 				delete this.mcpConnections[id];
 				await replaced.close().catch(() => {});
-				this.updateStoredSessionId(id, void 0);
+				this.updateStoredSession(id, void 0);
 			}
 			this.createConnection(id, url, {
 				client: options.client,
@@ -1468,7 +1730,8 @@ var MCPClientManager = class {
 			client: options.client ?? {},
 			transport: normalizedTransport,
 			elicitationHandlers: this.scopedElicitationHandlers(id),
-			capabilitySeed
+			capabilitySeed,
+			discoverResult: options.discoverResult
 		});
 		const store = new DisposableStore();
 		const existing = this._connectionDisposables.get(id);
@@ -1477,6 +1740,9 @@ var MCPClientManager = class {
 		store.add(this.mcpConnections[id].onObservabilityEvent((event) => {
 			this._onObservabilityEvent.fire(event);
 		}));
+		store.add(this.mcpConnections[id].onListChanged(() => {
+			this._onServerStateChanged.fire();
+		}));
 		if (capabilitySeed) {
 			const conn = this.mcpConnections[id];
 			const seedClear = conn.onObservabilityEvent((event) => {
@@ -1507,8 +1773,6 @@ var MCPClientManager = class {
 				type: options.transport?.type ?? "auto"
 			}
 		});
-		const { authProvider: _, ...transportWithoutAuth } = options.transport ?? {};
-		const { jsonSchemaValidator: _validator, ...serializableClient } = options.client ?? {};
 		this.saveServerToStorage({
 			id,
 			name: options.name,
@@ -1516,9 +1780,9 @@ var MCPClientManager = class {
 			callback_url: options.callbackUrl ?? "",
 			client_id: options.clientId ?? null,
 			auth_url: options.authUrl ?? null,
-			server_options: JSON.stringify({
-				client: serializableClient,
-				transport: transportWithoutAuth,
+			server_options: encodeMcpServerOptions({
+				client: options.client,
+				transport: options.transport,
 				retry: options.retry,
 				capabilities: this.advertisedHandlerCapabilities()
 			})
@@ -1526,6 +1790,32 @@ var MCPClientManager = class {
 		this._onServerStateChanged.fire();
 		return id;
 	}
+	/** Persist and emit an OAuth continuation produced by connect or discovery. */
+	persistAuthContinuation(id, conn) {
+		const authProvider = conn.options.transport.authProvider;
+		const authUrl = authProvider?.authUrl;
+		if (!authUrl || !authProvider.redirectUrl) return void 0;
+		const clientId = authProvider.clientId;
+		const serverRow = this.getServersFromStorage().find((s) => s.id === id);
+		if (serverRow) this.saveServerToStorage({
+			...serverRow,
+			auth_url: authUrl,
+			client_id: clientId ?? null
+		});
+		this._onObservabilityEvent.fire({
+			type: "mcp:client:authorize",
+			payload: {
+				serverId: id,
+				authUrl,
+				clientId
+			},
+			timestamp: Date.now()
+		});
+		return {
+			authUrl,
+			clientId
+		};
+	}
 	/**
 	* Connect to an already registered MCP server and initialize the connection.
 	*
@@ -1544,7 +1834,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.updateStoredSession(id, conn.sessionId, conn.protocolVersion, conn.discoverResult);
 		this._onServerStateChanged.fire();
 		switch (conn.connectionState) {
 			case MCPConnectionState.FAILED: return {
@@ -1552,35 +1842,18 @@ var MCPClientManager = class {
 				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();
+				const auth = this.persistAuthContinuation(id, conn);
+				if (!auth) {
+					const provider = conn.options.transport.authProvider;
+					return {
+						state: MCPConnectionState.FAILED,
+						error: `OAuth configuration incomplete: missing ${!provider?.authUrl ? "authUrl" : "redirectUrl"}`
+					};
 				}
-				this._onObservabilityEvent.fire({
-					type: "mcp:client:authorize",
-					payload: {
-						serverId: id,
-						authUrl,
-						clientId
-					},
-					timestamp: Date.now()
-				});
+				this._onServerStateChanged.fire();
 				return {
 					state: conn.connectionState,
-					authUrl,
-					clientId
+					...auth
 				};
 			}
 			case MCPConnectionState.CONNECTED: return { state: conn.connectionState };
@@ -1616,7 +1889,6 @@ var MCPClientManager = class {
 		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"
@@ -1626,13 +1898,7 @@ var MCPClientManager = class {
 			valid: false,
 			error: "No serverId found in state parameter. Expected format: {nonce}.{serverId}"
 		};
-		if (error) return {
-			serverId,
-			state,
-			valid: false,
-			error: errorDescription || error
-		};
-		if (!code) return {
+		if (!code && !error) return {
 			serverId,
 			state,
 			valid: false,
@@ -1651,8 +1917,8 @@ var MCPClientManager = class {
 		return {
 			valid: true,
 			serverId,
-			code,
-			state
+			state,
+			callbackParams: url.searchParams
 		};
 	}
 	async handleCallbackRequest(req) {
@@ -1678,7 +1944,7 @@ var MCPClientManager = class {
 				authError: validation.error
 			};
 		}
-		const { serverId, code, state } = validation;
+		const { serverId, state, callbackParams } = 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");
@@ -1690,7 +1956,7 @@ var MCPClientManager = class {
 					await this.consumeStaleOAuthState(serverId, authProvider, state);
 					return this.oauthCallbackSuccess(serverId, conn);
 				}
-				return this.ignoreUnverifiedCallback(serverId, stateValidation.error || "Invalid state");
+				return this.ignoreUnverifiedCallback(serverId, callbackParams.get("error_description") ?? callbackParams.get("error") ?? stateValidation.error ?? "Invalid state");
 			}
 			if (this.isAuthAcceptedConnection(conn)) {
 				await this.consumeStaleOAuthState(serverId, authProvider, state);
@@ -1699,8 +1965,8 @@ var MCPClientManager = class {
 			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);
-			this.updateStoredSessionId(serverId, conn.sessionId);
+			await this.completeAuthorizationAndCleanupVerifier(serverId, conn, authProvider, state, callbackParams);
+			this.updateStoredSession(serverId, conn.sessionId, conn.protocolVersion, conn.discoverResult);
 			const result = this.oauthCallbackSuccess(serverId, conn);
 			this._onServerStateChanged.fire();
 			return result;
@@ -1734,6 +2000,7 @@ var MCPClientManager = class {
 		}
 		const result = await conn.discover(options);
 		if (!result.success && result.reason === "stale-session") return this._recoverStaleSession(conn, serverId, options);
+		if (conn.connectionState === MCPConnectionState.AUTHENTICATING) this.persistAuthContinuation(serverId, conn);
 		this._onServerStateChanged.fire();
 		return this._toDiscoverResult(conn, result);
 	}
@@ -1749,7 +2016,7 @@ var MCPClientManager = class {
 	}
 	async _recoverStaleSession(conn, serverId, options) {
 		conn.clearResumedSession();
-		this.updateStoredSessionId(serverId, void 0);
+		this.updateStoredSession(serverId, void 0);
 		let connectResult;
 		try {
 			connectResult = await this.connectToServer(serverId);
@@ -1860,12 +2127,12 @@ var MCPClientManager = class {
 	persistAdvertisedCapabilities() {
 		const capabilities = this.advertisedHandlerCapabilities();
 		for (const server of this.getServersFromStorage()) {
-			const options = server.server_options ? JSON.parse(server.server_options) : {};
+			const options = decodeMcpServerOptions(server.server_options);
 			if (JSON.stringify(options.capabilities) === JSON.stringify(capabilities)) continue;
 			options.capabilities = capabilities;
 			this.saveServerToStorage({
 				...server,
-				server_options: JSON.stringify(options)
+				server_options: encodeMcpServerOptions(options)
 			});
 		}
 	}
@@ -1991,7 +2258,7 @@ var MCPClientManager = class {
 	* (closes connection AND removes from storage).
 	*/
 	cleanupClosedConnection(id) {
-		this.updateStoredSessionId(id, void 0);
+		this.updateStoredSession(id, void 0);
 		const store = this._connectionDisposables.get(id);
 		if (store) store.dispose();
 		this._connectionDisposables.delete(id);
@@ -2074,28 +2341,27 @@ var MCPClientManager = class {
 	listResourceTemplates(filter) {
 		return getNamespacedData(this.filterConnections(filter), "resourceTemplates");
 	}
-	/**
-	* Namespaced version of callTool
-	*/
-	async callTool(params, resultSchema, options) {
+	async callTool(params, schemaOrOptions, options) {
 		const { serverId, ...mcpParams } = params;
 		const unqualifiedName = mcpParams.name.replace(`${serverId}.`, "");
-		return this.mcpConnections[serverId].client.callTool({
+		return callV2Tool(this.mcpConnections[serverId].client, {
 			...mcpParams,
 			name: unqualifiedName
-		}, resultSchema, options);
+		}, schemaOrOptions, options);
 	}
 	/**
 	* Namespaced version of readResource
 	*/
 	readResource(params, options) {
-		return this.mcpConnections[params.serverId].client.readResource(params, options);
+		const { serverId, ...mcpParams } = params;
+		return this.mcpConnections[serverId].client.readResource(mcpParams, options);
 	}
 	/**
 	* Namespaced version of getPrompt
 	*/
 	getPrompt(params, options) {
-		return this.mcpConnections[params.serverId].client.getPrompt(params, options);
+		const { serverId, ...mcpParams } = params;
+		return this.mcpConnections[serverId].client.getPrompt(mcpParams, options);
 	}
 };
 function getNamespacedData(mcpClients, type) {
@@ -2116,4 +2382,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-CcjiFpTf.js.map
+//# sourceMappingURL=client-zqKcsyFa.js.map