@copilotkit/core 1.69.3 → 1.70.1

package/dist/index.cjs

@@ -127,6 +127,7 @@ function ɵobservePhoenixSocketHealth$(socketSignals$, maxConsecutiveErrors) {
 
 //#endregion
 //#region src/intelligence-agent.ts
+const globalFetch = (...args) => fetch(...args);
 const CLIENT_AG_UI_EVENT = "ag_ui_event";
 const REPLAY_COMPLETE_EVENT = "replay_complete";
 const STREAM_IDLE_EVENT = "stream_idle";
@@ -353,7 +354,7 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 	requestJoinCredentials$(mode, input, replayCursor) {
 		return (0, rxjs.defer)(async () => {
 			try {
-				const response = await fetch(this.buildRuntimeUrl(mode), {
+				const response = await (this.config.fetch ?? globalFetch)(this.buildRuntimeUrl(mode), {
 					method: "POST",
 					headers: {
 						"Content-Type": "application/json",
@@ -594,7 +595,12 @@ async function runtimeInfoError(response) {
 		const message = (await response.clone().json())?.message;
 		if (typeof message === "string" && message.trim().length > 0) detail = message.trim();
 	} catch {}
-	return new Error(detail ? `${base}: ${detail}` : base);
+	const error = new Error(detail ? `${base}: ${detail}` : base);
+	error.runtimeInfoStatus = response.status;
+	return error;
+}
+function isRuntimeInfoRequestError(error) {
+	return typeof error === "object" && error !== null && typeof error.runtimeInfoStatus === "number";
 }
 
 //#endregion
@@ -608,12 +614,12 @@ function hasCredentials(agent) {
 function isZodError(error) {
 	return error !== null && typeof error === "object" && "name" in error && error.name === "ZodError";
 }
-function isAbortError$1(error) {
+function isAbortError$2(error) {
 	return (error instanceof DOMException || error instanceof Error) && error.name === "AbortError";
 }
 function withAbortErrorHandling(observable) {
 	return observable.pipe((0, rxjs_operators.catchError)((error) => {
-		if (isZodError(error) || isAbortError$1(error)) return rxjs.EMPTY;
+		if (isZodError(error) || isAbortError$2(error)) return rxjs.EMPTY;
 		throw error;
 	}));
 }
@@ -811,7 +817,8 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 			runtimeMode: this.runtimeMode,
 			intelligence: this.intelligence,
 			capabilities: this._capabilities,
-			debug: this.debug
+			debug: this.debug,
+			fetch: this.fetch
 		});
 		cloned.threadId = this.threadId;
 		cloned.setState(this.state);
@@ -881,7 +888,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 			url = `${this.runtimeUrl}/info`;
 			init = {};
 		}
-		const response = await fetch(url, {
+		const response = await this.fetch(url, {
 			...init,
 			headers,
 			...this.credentials ? { credentials: this.credentials } : {}
@@ -891,7 +898,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 	}
 	async fetchRuntimeInfoAutoDetect(headers) {
 		try {
-			const response = await fetch(`${this.runtimeUrl}/info`, {
+			const response = await this.fetch(`${this.runtimeUrl}/info`, {
 				headers: { ...headers },
 				...this.credentials ? { credentials: this.credentials } : {}
 			});
@@ -902,7 +909,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 		} catch {}
 		const singleHeaders = { ...headers };
 		if (!singleHeaders["Content-Type"]) singleHeaders["Content-Type"] = "application/json";
-		const response = await fetch(this.runtimeUrl, {
+		const response = await this.fetch(this.runtimeUrl, {
 			method: "POST",
 			headers: singleHeaders,
 			body: JSON.stringify({ method: "info" }),
@@ -943,7 +950,8 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 			runtimeUrl: this.runtimeUrl,
 			agentId: routedId,
 			headers: { ...this.headers },
-			credentials: this.credentials
+			credentials: this.credentials,
+			fetch: this.fetch
 		});
 	}
 	syncDelegate(delegate) {
@@ -957,16 +965,44 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui
 	}
 };
 
+//#endregion
+//#region src/utils/abort-error.ts
+const ABORT_MESSAGES = new Set([
+	"Fetch is aborted",
+	"signal is aborted without reason",
+	"component unmounted"
+]);
+function isAbortError$1(error) {
+	if (typeof error !== "object" || error === null) return false;
+	const { name, message } = error;
+	if (name === "AbortError") return true;
+	return typeof message === "string" && ABORT_MESSAGES.has(message);
+}
+
+//#endregion
+//#region src/utils/runtime-request.ts
+const RUNTIME_REQUEST_WATCHDOG_MS = 1e4;
+function runtimeRequestMeta(init) {
+	return init?.ɵruntimeRequest;
+}
+
 //#endregion
 //#region src/core/agent-registry.ts
 /** Maximum wait for optional Inspector metadata before degrading to absence. */
 const INSPECTOR_METADATA_REQUEST_TIMEOUT_MS = 5e3;
+const ɵRUNTIME_PROBE_TIMEOUT_MS = 5e3;
+function classifyRuntimeRequestFailure(error, meta) {
+	if (meta?.nonCritical) return "ignored";
+	if (isAbortError$1(error) && !meta?.timedOut) return "aborted";
+	return "failed";
+}
 /** Build case-insensitive JSON headers without mutating the Core snapshot. */
 function withJsonContentType(headers) {
 	const requestHeaders = new Headers(headers);
 	if (!requestHeaders.has("content-type")) requestHeaders.set("content-type", "application/json");
 	return requestHeaders;
 }
+const RUNTIME_ENTITLEMENT_RETRY_DELAY_MS = 5e3;
 /**
 * Manages agent registration, lifecycle, and runtime connectivity for CopilotKitCore.
 * Handles both local development agents and remote runtime agents.
@@ -975,8 +1011,14 @@ var AgentRegistry = class {
 	_agents = {};
 	localAgents = {};
 	remoteAgents = {};
+	mintedThreadIds = /* @__PURE__ */ new WeakMap();
 	_runtimeUrl;
 	_connectionInFlight;
+	_runtimeConnectionGeneration = 0;
+	_activeRuntimeConnectionAttempt;
+	_runtimeEntitlementRetryTimer;
+	_runtimeEntitlementRetryAttemptedKey;
+	_runtimeEntitlementRetryPendingKey;
 	_runtimeVersion;
 	_runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Disconnected;
 	_runtimeTransport = "auto";
@@ -999,7 +1041,16 @@ var AgentRegistry = class {
 	_a2uiAgents;
 	_openGenerativeUIEnabled = false;
 	_licenseStatus;
+	_runtimeEntitlements;
 	_telemetryDisabled = false;
+	remoteAgentConnections = /* @__PURE__ */ new WeakMap();
+	runtimeFetch;
+	runtimeProbeInFlight = false;
+	runtimeProbeToken = 0;
+	runtimeProbeAbortController;
+	runtimeRecoveryRunning = false;
+	runtimeRecoveryPending = false;
+	runtimeHealthGeneration = 0;
 	/**
 	* The headers each HttpAgent was constructed with, captured on the first
 	* `applyHeadersToAgent` call for that agent (which, for agents the registry
@@ -1066,6 +1117,13 @@ var AgentRegistry = class {
 	get licenseStatus() {
 		return this._licenseStatus;
 	}
+	/** Structured Runtime entitlement authority advertised by `/info`. */
+	get runtimeEntitlements() {
+		return this._runtimeEntitlements;
+	}
+	get runtimeEntitlementRetryPending() {
+		return this._runtimeEntitlementRetryPendingKey === this.runtimeConnectionKey();
+	}
 	get telemetryDisabled() {
 		return this._telemetryDisabled;
 	}
@@ -1076,6 +1134,7 @@ var AgentRegistry = class {
 		this.localAgents = this.assignAgentIds(agents);
 		this.applyHeadersToAgents(this.localAgents);
 		this.applyCredentialsToAgents(this.localAgents);
+		this.applyRuntimeFetchToAgents(this.localAgents);
 		this._agents = this.localAgents;
 	}
 	/**
@@ -1085,9 +1144,13 @@ var AgentRegistry = class {
 		const normalizedRuntimeUrl = runtimeUrl ? runtimeUrl.replace(/\/$/, "") : void 0;
 		if (this._runtimeUrl === normalizedRuntimeUrl) return;
 		this.invalidateInspectorMetadataConnection();
+		this.abandonRuntimeHealthProbe();
+		this.resetRuntimeEntitlementRetry();
+		this._licenseStatus = void 0;
+		this._runtimeEntitlements = void 0;
 		this._runtimeUrl = normalizedRuntimeUrl;
 		if (options?.deferConnection) return;
-		this.updateRuntimeConnection();
+		this.updateRuntimeConnection({ preserveOnFailure: this.hasLiveRuntimeKnowledgeToProtect() });
 	}
 	/**
 	* Start the initial runtime connection if it has not been started yet.
@@ -1109,9 +1172,40 @@ var AgentRegistry = class {
 	setRuntimeTransport(runtimeTransport) {
 		if (this._requestedTransport === runtimeTransport) return;
 		this.invalidateInspectorMetadataConnection();
+		this.abandonRuntimeHealthProbe();
+		this.resetRuntimeEntitlementRetry();
 		this._requestedTransport = runtimeTransport;
 		this._runtimeTransport = runtimeTransport;
-		this.updateRuntimeConnection();
+		this.updateRuntimeConnection({ preserveOnFailure: this.hasLiveRuntimeKnowledgeToProtect() });
+	}
+	hasLiveRuntimeKnowledgeToProtect() {
+		if (Object.keys(this.remoteAgents).length === 0) return false;
+		return this._runtimeConnectionStatus !== CopilotKitCoreRuntimeConnectionStatus.Connected;
+	}
+	reconcileRecoveredAgents(reported) {
+		const merged = {
+			...this.remoteAgents,
+			...reported
+		};
+		if (Object.keys(reported).length === 0) return merged;
+		for (const [id, agent] of Object.entries(merged)) {
+			if (Object.prototype.hasOwnProperty.call(reported, id)) continue;
+			if (this.carriesConversationState(agent)) continue;
+			delete merged[id];
+		}
+		return merged;
+	}
+	carriesConversationState(agent) {
+		if (agent.messages.length > 0) return true;
+		const mintedThreadId = this.mintedThreadIds.get(agent);
+		return mintedThreadId === void 0 || agent.threadId !== mintedThreadId;
+	}
+	abandonRuntimeHealthProbe() {
+		this.runtimeProbeToken += 1;
+		this.runtimeProbeInFlight = false;
+		this.runtimeHealthGeneration += 1;
+		this.runtimeProbeAbortController?.abort();
+		this.runtimeProbeAbortController = void 0;
 	}
 	/**
 	* Set all agents at once (for development use)
@@ -1127,6 +1221,7 @@ var AgentRegistry = class {
 		};
 		this.applyHeadersToAgents(this._agents);
 		this.applyCredentialsToAgents(this._agents);
+		this.applyRuntimeFetchToAgents(this._agents);
 		this.notifyAgentsChanged();
 	}
 	/**
@@ -1137,6 +1232,7 @@ var AgentRegistry = class {
 		this.localAgents[id] = agent;
 		this.applyHeadersToAgent(agent);
 		this.applyCredentialsToAgent(agent);
+		this.applyRuntimeFetchToAgent(agent);
 		this._agents = {
 			...this.localAgents,
 			...this.remoteAgents
@@ -1180,6 +1276,7 @@ var AgentRegistry = class {
 			debug: debug ? (0, _copilotkit_shared.resolveDebugConfig)(debug) : void 0
 		});
 		this.applyHeadersToAgent(agent);
+		this.applyRuntimeFetchToAgent(agent);
 		this.localAgents[agentId] = agent;
 		this._agents = {
 			...this.localAgents,
@@ -1245,6 +1342,45 @@ var AgentRegistry = class {
 			this.applyCredentialsToAgent(agent);
 		});
 	}
+	createRuntimeFetch() {
+		if (!this.runtimeFetch) this.runtimeFetch = (async (input, init) => {
+			const meta = () => runtimeRequestMeta(init);
+			const watchdog = this.armRuntimeRequestWatchdog(meta());
+			try {
+				const response = await fetch(input, init);
+				watchdog.clear();
+				this.handleRuntimeRequestOutcome(response.ok ? "ok" : meta()?.nonCritical ? "ignored" : "failed", watchdog.checked);
+				return response;
+			} catch (error) {
+				watchdog.clear();
+				this.handleRuntimeRequestOutcome(classifyRuntimeRequestFailure(error, meta()), watchdog.checked);
+				throw error;
+			}
+		});
+		return this.runtimeFetch;
+	}
+	armRuntimeRequestWatchdog(meta) {
+		if (typeof window === "undefined" || meta?.nonCritical || meta?.selfBounded) return {
+			clear: () => {},
+			checked: () => false
+		};
+		let checked = false;
+		const timeoutId = setTimeout(() => {
+			checked = this.handleRuntimeRequestOutcome("failed");
+		}, RUNTIME_REQUEST_WATCHDOG_MS);
+		return {
+			clear: () => clearTimeout(timeoutId),
+			checked: () => checked
+		};
+	}
+	applyRuntimeFetchToAgent(agent) {
+		if (agent instanceof ProxiedCopilotRuntimeAgent) agent.fetch = this.createRuntimeFetch();
+	}
+	applyRuntimeFetchToAgents(agents) {
+		Object.values(agents).forEach((agent) => {
+			this.applyRuntimeFetchToAgent(agent);
+		});
+	}
 	/** Refresh metadata after the Core header snapshot changes. */
 	handleHeadersChanged() {
 		this.inspectorMetadataHeadersGeneration += 1;
@@ -1380,17 +1516,114 @@ var AgentRegistry = class {
 			console.error("Subscriber onInspectorMetadataChanged queue error:", error);
 		});
 	}
+	setRuntimeConnectionStatus(status) {
+		this._runtimeConnectionStatus = status;
+		this.runtimeHealthGeneration += 1;
+	}
+	handleRuntimeRequestOutcome(outcome, alreadyChecked = () => false) {
+		if (outcome === "aborted" || outcome === "ignored") return false;
+		if (outcome === "failed" && alreadyChecked()) return false;
+		if (typeof window === "undefined") return false;
+		if (!this._runtimeUrl) return false;
+		if (outcome === "ok") {
+			this.runtimeHealthGeneration += 1;
+			if (this.runtimeRecoveryRunning) this.runtimeRecoveryPending = true;
+			if (this._runtimeConnectionStatus === CopilotKitCoreRuntimeConnectionStatus.Error) this.recoverRuntimeConnection();
+			return false;
+		}
+		if (this._runtimeConnectionStatus !== CopilotKitCoreRuntimeConnectionStatus.Connected) return false;
+		if (this.runtimeProbeInFlight) return false;
+		this.probeRuntimeReachability();
+		return true;
+	}
+	async fetchRuntimeInfoWithTimeout(abortController, runtimeUrl = this.runtimeUrl, runtimeTransport = this._runtimeTransport) {
+		if (!runtimeUrl) throw new Error("Runtime URL is not set");
+		let timeoutId;
+		const request = this.fetchRuntimeInfo(runtimeUrl, runtimeTransport, abortController.signal);
+		request.catch(() => {});
+		try {
+			const timedOut = new Promise((_resolve, reject) => {
+				timeoutId = setTimeout(() => {
+					abortController.abort();
+					reject(/* @__PURE__ */ new Error(`Runtime did not answer within ${ɵRUNTIME_PROBE_TIMEOUT_MS}ms`));
+				}, ɵRUNTIME_PROBE_TIMEOUT_MS);
+			});
+			return await Promise.race([request, timedOut]);
+		} finally {
+			if (timeoutId !== void 0) clearTimeout(timeoutId);
+		}
+	}
+	async probeRuntimeReachability() {
+		const generation = this.runtimeHealthGeneration;
+		const token = ++this.runtimeProbeToken;
+		this.runtimeProbeInFlight = true;
+		const abortController = new AbortController();
+		this.runtimeProbeAbortController = abortController;
+		try {
+			await this.fetchRuntimeInfoWithTimeout(abortController);
+		} catch (error) {
+			if (generation !== this.runtimeHealthGeneration) return;
+			await this.markRuntimeUnreachable(error instanceof Error ? error : new Error(String(error)));
+		} finally {
+			if (this.runtimeProbeAbortController === abortController) this.runtimeProbeAbortController = void 0;
+			if (this.runtimeProbeToken === token) this.runtimeProbeInFlight = false;
+		}
+	}
+	async markRuntimeUnreachable(error) {
+		this.setRuntimeConnectionStatus(CopilotKitCoreRuntimeConnectionStatus.Error);
+		await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Error);
+		const runtimeStatus = isRuntimeInfoRequestError(error) ? error.runtimeInfoStatus : void 0;
+		_copilotkit_shared.logger.warn(runtimeStatus === void 0 ? `Runtime did not answer the identification request (${this._runtimeUrl}/info): ${error.message}. The runtime appears to be unreachable.` : `Runtime answered the identification request with status ${runtimeStatus} (${this._runtimeUrl}/info): ${error.message}. The runtime is reachable but refused the request — check credentials and authorisation before addresses and ports.`);
+		await this.core.emitError({
+			error,
+			code: CopilotKitCoreErrorCode.RUNTIME_INFO_FETCH_FAILED,
+			context: {
+				runtimeUrl: this._runtimeUrl,
+				reason: runtimeStatus === void 0 ? "no-answer" : "answered",
+				...runtimeStatus === void 0 ? {} : { runtimeStatus }
+			}
+		});
+	}
+	async recoverRuntimeConnection() {
+		if (this.runtimeRecoveryRunning) {
+			this.runtimeRecoveryPending = true;
+			return;
+		}
+		this.runtimeRecoveryRunning = true;
+		try {
+			do {
+				this.runtimeRecoveryPending = false;
+				await this.updateRuntimeConnection({
+					preserveOnFailure: true,
+					recovery: true
+				});
+			} while (this.runtimeRecoveryPending && this._runtimeConnectionStatus !== CopilotKitCoreRuntimeConnectionStatus.Connected);
+		} finally {
+			this.runtimeRecoveryRunning = false;
+			this.runtimeRecoveryPending = false;
+		}
+	}
 	/**
 	* Update runtime connection and fetch remote agents
 	*/
-	async updateRuntimeConnection() {
+	async updateRuntimeConnection(options) {
 		if (typeof window === "undefined") return;
-		const key = `${this._runtimeUrl ?? ""}::${this._requestedTransport}`;
+		const key = this.runtimeConnectionKey();
 		const inFlight = this._connectionInFlight;
-		if (inFlight && inFlight.key === key) return inFlight.promise;
-		const promise = this.performRuntimeConnection();
-		this._connectionInFlight = {
+		if (inFlight && inFlight.attempt.key === key && this.isCurrentRuntimeConnection(inFlight.attempt)) return inFlight.promise;
+		const attempt = {
 			key,
+			generation: ++this._runtimeConnectionGeneration
+		};
+		this._activeRuntimeConnectionAttempt = attempt;
+		const promise = this.performRuntimeConnection({
+			attempt,
+			runtimeUrl: this._runtimeUrl,
+			transport: this._runtimeTransport,
+			options
+		});
+		this._connectionInFlight = {
+			attempt,
 			promise
 		};
 		promise.finally(() => {
@@ -1398,10 +1631,64 @@ var AgentRegistry = class {
 		});
 		return promise;
 	}
-	async performRuntimeConnection() {
-		if (!this.runtimeUrl) {
+	/** Return the stable key that scopes connection and entitlement retries. */
+	runtimeConnectionKey() {
+		return `${this._runtimeUrl ?? ""}::${this._requestedTransport}`;
+	}
+	/** Return whether a proxy still targets this Runtime connection. */
+	canReuseRuntimeAgent(agent, runtimeUrl, transport) {
+		if (!runtimeUrl) return false;
+		const connection = this.remoteAgentConnections.get(agent);
+		return connection?.runtimeUrl === runtimeUrl.replace(/\/$/, "") && connection.transport === transport;
+	}
+	/** Return whether an async attempt still owns the active Runtime state. */
+	isCurrentRuntimeConnection(attempt) {
+		return this._activeRuntimeConnectionAttempt?.generation === attempt.generation && this.runtimeConnectionKey() === attempt.key;
+	}
+	/** Cancel a pending entitlement retry and allow a new target to retry. */
+	resetRuntimeEntitlementRetry() {
+		if (this._runtimeEntitlementRetryTimer !== void 0) {
+			clearTimeout(this._runtimeEntitlementRetryTimer);
+			this._runtimeEntitlementRetryTimer = void 0;
+		}
+		this._runtimeEntitlementRetryAttemptedKey = void 0;
+		this._runtimeEntitlementRetryPendingKey = void 0;
+	}
+	/** Schedule one retry after Runtime's short failed-entitlement cache. */
+	updateRuntimeEntitlementRetry(runtimeEntitlements, attempt) {
+		if (!this.isCurrentRuntimeConnection(attempt)) return;
+		const { key } = attempt;
+		if (runtimeEntitlements?.status === "ready" || runtimeEntitlements?.error.retryable !== true) {
+			this.resetRuntimeEntitlementRetry();
+			return;
+		}
+		if (this._runtimeEntitlementRetryTimer !== void 0) return;
+		if (this._runtimeEntitlementRetryAttemptedKey === key) {
+			this._runtimeEntitlementRetryPendingKey = void 0;
+			return;
+		}
+		this._runtimeEntitlementRetryAttemptedKey = key;
+		this._runtimeEntitlementRetryPendingKey = key;
+		this._runtimeEntitlementRetryTimer = setTimeout(() => {
+			this._runtimeEntitlementRetryTimer = void 0;
+			this.executeRuntimeEntitlementRetry(attempt).catch((error) => {
+				const message = error instanceof Error ? error.message : JSON.stringify(error);
+				_copilotkit_shared.logger.warn(`Failed to retry runtime info (${this.runtimeUrl}/info): ${message}`);
+			});
+		}, RUNTIME_ENTITLEMENT_RETRY_DELAY_MS);
+	}
+	/** Start the bounded retry after the original connection has settled. */
+	async executeRuntimeEntitlementRetry(attempt) {
+		const inFlight = this._connectionInFlight;
+		if (inFlight?.attempt.generation === attempt.generation) await inFlight.promise;
+		if (!this._runtimeUrl || !this.isCurrentRuntimeConnection(attempt)) return;
+		await this.updateRuntimeConnection();
+	}
+	async performRuntimeConnection({ attempt, runtimeUrl, transport, options }) {
+		const { key } = attempt;
+		if (!runtimeUrl) {
 			this.invalidateInspectorMetadataConnection();
-			this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Disconnected;
+			this.setRuntimeConnectionStatus(CopilotKitCoreRuntimeConnectionStatus.Disconnected);
 			this._runtimeVersion = void 0;
 			this._audioFileTranscriptionEnabled = false;
 			this._runtimeMode = _copilotkit_shared.RUNTIME_MODE_SSE;
@@ -1411,32 +1698,38 @@ var AgentRegistry = class {
 			this._a2uiEnabled = false;
 			this._a2uiAgents = void 0;
 			this._openGenerativeUIEnabled = false;
+			this._licenseStatus = void 0;
+			this._runtimeEntitlements = void 0;
 			this.remoteAgents = {};
 			this._agents = this.localAgents;
 			await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Disconnected);
+			if (!this.isCurrentRuntimeConnection(attempt)) return;
 			await this.notifyAgentsChanged();
 			return;
 		}
 		const inspectorMetadataConnectionGeneration = this.inspectorMetadataConnectionGeneration;
-		this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Connecting;
+		this.setRuntimeConnectionStatus(CopilotKitCoreRuntimeConnectionStatus.Connecting);
+		const runtimeHealthGeneration = this.runtimeHealthGeneration;
 		await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Connecting);
+		if (!this.isCurrentRuntimeConnection(attempt)) return;
 		try {
 			if (inspectorMetadataConnectionGeneration !== this.inspectorMetadataConnectionGeneration) return;
-			const { runtimeInfo: runtimeInfoResponse, resolvedTransport } = await this.fetchRuntimeInfo();
-			if (inspectorMetadataConnectionGeneration !== this.inspectorMetadataConnectionGeneration) return;
+			const { runtimeInfo: runtimeInfoResponse, resolvedTransport } = options?.recovery ? await this.fetchRuntimeInfoWithTimeout(new AbortController(), runtimeUrl, transport) : await this.fetchRuntimeInfo(runtimeUrl, transport);
+			if (!this.isCurrentRuntimeConnection(attempt) || inspectorMetadataConnectionGeneration !== this.inspectorMetadataConnectionGeneration) return;
 			this._runtimeTransport = resolvedTransport;
 			const { version, ...runtimeInfo } = runtimeInfoResponse;
 			const credentials = this.core.credentials;
 			const rawDebug = this.core.debug;
-			this.remoteAgents = Object.fromEntries(Object.entries(runtimeInfo.agents).map(([id, { description, capabilities }]) => {
+			const agents = Object.fromEntries(Object.entries(runtimeInfo.agents).map(([id, { description, capabilities }]) => {
 				const existing = Object.prototype.hasOwnProperty.call(this.remoteAgents, id) ? this.remoteAgents[id] : void 0;
-				if (existing instanceof ProxiedCopilotRuntimeAgent) {
+				if (existing instanceof ProxiedCopilotRuntimeAgent && this.canReuseRuntimeAgent(existing, runtimeUrl, this._runtimeTransport)) {
 					this.applyHeadersToAgent(existing);
 					this.applyCredentialsToAgent(existing);
+					this.applyRuntimeFetchToAgent(existing);
 					return [id, existing];
 				}
 				const agent = new ProxiedCopilotRuntimeAgent({
-					runtimeUrl: this.runtimeUrl,
+					runtimeUrl,
 					agentId: id,
 					description,
 					transport: this._runtimeTransport,
@@ -1447,13 +1740,25 @@ var AgentRegistry = class {
 					debug: rawDebug ? (0, _copilotkit_shared.resolveDebugConfig)(rawDebug) : void 0
 				});
 				this.applyHeadersToAgent(agent);
+				this.applyRuntimeFetchToAgent(agent);
+				this.mintedThreadIds.set(agent, agent.threadId);
+				if (options?.preserveOnFailure === true && existing) {
+					agent.threadId = existing.threadId;
+					agent.setState(existing.state);
+					agent.setMessages([...existing.messages]);
+				}
+				this.remoteAgentConnections.set(agent, {
+					runtimeUrl,
+					transport: this._runtimeTransport
+				});
 				return [id, agent];
 			}));
+			this.remoteAgents = options?.recovery ? this.reconcileRecoveredAgents(agents) : agents;
 			this._agents = {
 				...this.localAgents,
 				...this.remoteAgents
 			};
-			this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Connected;
+			this.setRuntimeConnectionStatus(CopilotKitCoreRuntimeConnectionStatus.Connected);
 			this._runtimeVersion = version;
 			this._audioFileTranscriptionEnabled = runtimeInfoResponse.audioFileTranscriptionEnabled ?? false;
 			this._runtimeMode = runtimeInfoResponse.mode ?? _copilotkit_shared.RUNTIME_MODE_SSE;
@@ -1468,54 +1773,67 @@ var AgentRegistry = class {
 			this._a2uiAgents = a2uiInfo?.enabled ? a2uiInfo.agents : void 0;
 			this._openGenerativeUIEnabled = runtimeInfoResponse.openGenerativeUIEnabled ?? false;
 			this._licenseStatus = runtimeInfoResponse.licenseStatus;
+			this._runtimeEntitlements = runtimeInfoResponse.runtimeEntitlements;
+			this.updateRuntimeEntitlementRetry(runtimeInfoResponse.runtimeEntitlements, attempt);
 			this._telemetryDisabled = runtimeInfoResponse.telemetryDisabled ?? false;
 			await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Connected);
+			if (!this.isCurrentRuntimeConnection(attempt)) return;
 			await this.notifyAgentsChanged();
 			if (inspectorMetadataConnectionGeneration !== this.inspectorMetadataConnectionGeneration || this._runtimeConnectionStatus !== CopilotKitCoreRuntimeConnectionStatus.Connected) return;
 			this.inspectorMetadataRefreshReady = true;
 			if (this._inspectorMetadataSupported) this.refreshInspectorMetadata();
 		} catch (error) {
-			if (inspectorMetadataConnectionGeneration !== this.inspectorMetadataConnectionGeneration) return;
-			this.invalidateInspectorMetadataConnection();
-			this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Error;
-			this._runtimeVersion = void 0;
-			this._audioFileTranscriptionEnabled = false;
-			this._runtimeMode = _copilotkit_shared.RUNTIME_MODE_SSE;
-			this._intelligence = void 0;
-			this._threadEndpoints = void 0;
-			this._suggestions = void 0;
-			this._a2uiEnabled = false;
-			this._a2uiAgents = void 0;
-			this._openGenerativeUIEnabled = false;
-			this.remoteAgents = {};
-			this._agents = this.localAgents;
-			await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Error);
-			await this.notifyAgentsChanged();
+			if (!this.isCurrentRuntimeConnection(attempt) || inspectorMetadataConnectionGeneration !== this.inspectorMetadataConnectionGeneration) return;
+			const boundedEntitlementRetryFailed = this._runtimeEntitlementRetryTimer === void 0 && this._runtimeEntitlementRetryAttemptedKey === key && this._runtimeEntitlementRetryPendingKey === key;
+			if (boundedEntitlementRetryFailed) this._runtimeEntitlementRetryPendingKey = void 0;
+			if (options?.preserveOnFailure) {
+				if (options?.recovery && runtimeHealthGeneration !== this.runtimeHealthGeneration) return;
+				this.setRuntimeConnectionStatus(CopilotKitCoreRuntimeConnectionStatus.Error);
+				await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Error);
+			} else {
+				this.invalidateInspectorMetadataConnection();
+				this.setRuntimeConnectionStatus(CopilotKitCoreRuntimeConnectionStatus.Error);
+				this._runtimeVersion = void 0;
+				this._audioFileTranscriptionEnabled = false;
+				this._runtimeMode = _copilotkit_shared.RUNTIME_MODE_SSE;
+				this._intelligence = void 0;
+				this._threadEndpoints = void 0;
+				this._suggestions = void 0;
+				this._a2uiEnabled = false;
+				this._a2uiAgents = void 0;
+				this._openGenerativeUIEnabled = false;
+				if (!boundedEntitlementRetryFailed) {
+					this._licenseStatus = void 0;
+					this._runtimeEntitlements = void 0;
+				}
+				this.remoteAgents = {};
+				this._agents = this.localAgents;
+				await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Error);
+				await this.notifyAgentsChanged();
+			}
 			const message = error instanceof Error ? error.message : JSON.stringify(error);
-			_copilotkit_shared.logger.warn(`Failed to load runtime info (${this.runtimeUrl}/info): ${message}`);
+			_copilotkit_shared.logger.warn(`Failed to load runtime info (${runtimeUrl}/info): ${message}`);
 			const runtimeError = error instanceof Error ? error : new Error(String(error));
 			await this.core.emitError({
 				error: runtimeError,
 				code: CopilotKitCoreErrorCode.RUNTIME_INFO_FETCH_FAILED,
-				context: { runtimeUrl: this.runtimeUrl }
+				context: { runtimeUrl }
 			});
 		}
 	}
-	async fetchRuntimeInfo() {
-		const runtimeUrl = this.runtimeUrl;
-		if (!runtimeUrl) throw new Error("Runtime URL is not set");
+	async fetchRuntimeInfo(runtimeUrl, runtimeTransport, signal) {
 		const baseHeaders = this.core.headers;
 		const credentials = this.core.credentials;
 		const headers = { ...baseHeaders };
-		const runtimeTransport = this._runtimeTransport;
 		if (runtimeTransport === "single") return {
-			runtimeInfo: await this.fetchRuntimeInfoSingle(runtimeUrl, headers, credentials),
+			runtimeInfo: await this.fetchRuntimeInfoSingle(runtimeUrl, headers, credentials, signal),
 			resolvedTransport: "single"
 		};
-		if (runtimeTransport === "auto") return this.fetchRuntimeInfoAutoDetect(runtimeUrl, headers, credentials);
+		if (runtimeTransport === "auto") return this.fetchRuntimeInfoAutoDetect(runtimeUrl, headers, credentials, signal);
 		const response = await fetch(`${runtimeUrl}/info`, {
 			headers,
-			...credentials ? { credentials } : {}
+			...credentials ? { credentials } : {},
+			...signal ? { signal } : {}
 		});
 		if (!response.ok) throw await runtimeInfoError(response);
 		return {
@@ -1523,12 +1841,13 @@ var AgentRegistry = class {
 			resolvedTransport: "rest"
 		};
 	}
-	async fetchRuntimeInfoSingle(runtimeUrl, headers, credentials) {
+	async fetchRuntimeInfoSingle(runtimeUrl, headers, credentials, signal) {
 		const response = await fetch(runtimeUrl, {
 			method: "POST",
 			headers: withJsonContentType(headers),
 			body: JSON.stringify({ method: "info" }),
-			...credentials ? { credentials } : {}
+			...credentials ? { credentials } : {},
+			...signal ? { signal } : {}
 		});
 		if (!response.ok) throw await runtimeInfoError(response);
 		return await response.json();
@@ -1538,11 +1857,12 @@ var AgentRegistry = class {
 	* The caller commits the detected transport only after confirming this
 	* connection attempt is still current.
 	*/
-	async fetchRuntimeInfoAutoDetect(runtimeUrl, headers, credentials) {
+	async fetchRuntimeInfoAutoDetect(runtimeUrl, headers, credentials, signal) {
 		try {
 			const response = await fetch(`${runtimeUrl}/info`, {
 				headers: { ...headers },
-				...credentials ? { credentials } : {}
+				...credentials ? { credentials } : {},
+				...signal ? { signal } : {}
 			});
 			if (response.status >= 200 && response.status < 300) return {
 				runtimeInfo: await response.json(),
@@ -1550,7 +1870,7 @@ var AgentRegistry = class {
 			};
 		} catch {}
 		return {
-			runtimeInfo: await this.fetchRuntimeInfoSingle(runtimeUrl, { ...headers }, credentials),
+			runtimeInfo: await this.fetchRuntimeInfoSingle(runtimeUrl, { ...headers }, credentials, signal),
 			resolvedTransport: "single"
 		};
 	}
@@ -2023,6 +2343,137 @@ function isForwardedToClientPlaceholder(content) {
 	return normalizeToolResultContent(content) === FORWARDED_TO_CLIENT;
 }
 
+//#endregion
+//#region src/core/tool-schema.ts
+/**
+* Empty tool schema constant
+*/
+const EMPTY_TOOL_SCHEMA = {
+	type: "object",
+	properties: {}
+};
+/**
+* Create a JSON schema from a tool's parameters
+*/
+function createToolSchema(tool) {
+	if (!tool.parameters) return { ...EMPTY_TOOL_SCHEMA };
+	const rawSchema = (0, _copilotkit_shared.schemaToJsonSchema)(tool.parameters, { zodToJsonSchema: (schema, options) => (0, zod_to_json_schema.zodToJsonSchema)(schema, options) });
+	if (!rawSchema || typeof rawSchema !== "object") return { ...EMPTY_TOOL_SCHEMA };
+	const { $schema: _$schema, ...schema } = rawSchema;
+	if (typeof schema.type !== "string") schema.type = "object";
+	if (typeof schema.properties !== "object" || schema.properties === null) schema.properties = {};
+	stripAdditionalProperties(schema);
+	return schema;
+}
+/**
+* Remove every `additionalProperties` key from a JSON schema tree, in place.
+* Some LLM providers reject schemas that carry it.
+*/
+function stripAdditionalProperties(schema) {
+	if (!schema || typeof schema !== "object") return;
+	if (Array.isArray(schema)) {
+		schema.forEach(stripAdditionalProperties);
+		return;
+	}
+	const record = schema;
+	if (record.additionalProperties !== void 0) delete record.additionalProperties;
+	for (const value of Object.values(record)) stripAdditionalProperties(value);
+}
+
+//#endregion
+//#region src/core/webmcp.ts
+/**
+* Return the page's `document.modelContext`, or null when WebMCP is not
+* available (SSR, React Native, browsers without the API enabled).
+*/
+function getWebMCPModelContext() {
+	if (typeof document === "undefined") return null;
+	return document.modelContext ?? null;
+}
+/**
+* Keeps a set of frontend tools registered on the page's WebMCP model context.
+*
+* `sync(desired)` reconciles the registrations with the desired set: tools that
+* are gone (or were re-registered with a new tool object) are unregistered by
+* aborting their registration signal, and new tools are registered with an
+* `execute` that delegates to the frontend tool's own handler.
+*
+* All WebMCP-API constraints live here so callers only supply the desired set:
+* a tool without a description is skipped with a warning (the spec rejects
+* empty descriptions), and failures from `registerTool` (duplicate name,
+* unsupported context, ...) are warned rather than thrown.
+*/
+var WebMCPRegistry = class {
+	entries = /* @__PURE__ */ new Map();
+	warnedNames = /* @__PURE__ */ new Set();
+	/** Names currently kept registered on the model context. */
+	get registeredNames() {
+		return [...this.entries.keys()];
+	}
+	/** Reconcile the registered tools with the desired set. */
+	sync(desired) {
+		const modelContext = getWebMCPModelContext();
+		if (!modelContext) return;
+		for (const [name, entry] of [...this.entries]) if (desired.get(name) !== entry.tool) {
+			entry.controller.abort();
+			this.entries.delete(name);
+		}
+		for (const [name, tool] of desired) {
+			if (this.entries.has(name)) continue;
+			if (!tool.description) {
+				this.warnOnce(name, `Skipping WebMCP registration for tool '${name}': WebMCP requires a description.`);
+				continue;
+			}
+			const controller = new AbortController();
+			this.entries.set(name, {
+				tool,
+				controller
+			});
+			modelContext.registerTool(this.buildModelContextTool(tool), { signal: controller.signal }).catch((error) => {
+				if (this.entries.get(name)?.controller !== controller) return;
+				this.entries.delete(name);
+				const message = error instanceof Error ? error.message : String(error);
+				this.warnOnce(name, `WebMCP registration failed for tool '${name}': ${message}`);
+			});
+		}
+	}
+	/**
+	* Build the WebMCP model-context tool for a frontend tool. The `execute`
+	* callback delegates to the frontend tool's own handler, so a browser agent
+	* call runs the same application code as an agent call.
+	*/
+	buildModelContextTool(tool) {
+		const annotations = typeof tool.webmcp === "object" ? tool.webmcp.annotations : void 0;
+		return {
+			name: tool.name,
+			description: tool.description,
+			inputSchema: createToolSchema(tool),
+			execute: async (args, options) => {
+				if (!tool.handler) return "";
+				const toolCall = {
+					id: (0, _copilotkit_shared.randomUUID)(),
+					type: "function",
+					function: {
+						name: tool.name,
+						arguments: JSON.stringify(args ?? {})
+					}
+				};
+				return await tool.handler(args, {
+					toolCall,
+					signal: options?.signal
+				});
+			},
+			...annotations ? { annotations } : {}
+		};
+	}
+	/** Log `message` once per tool name. Repeated syncs must not spam the log. */
+	warnOnce(name, message) {
+		if (this.warnedNames.has(name)) return;
+		this.warnedNames.add(name);
+		_copilotkit_shared.logger.warn(`[CopilotKit] ${message}`);
+	}
+};
+
 //#endregion
 //#region src/core/run-handler.ts
 /**
@@ -2039,11 +2490,40 @@ function isForwardedToClientPlaceholder(content) {
 */
 const MAX_FOLLOW_UP_DEPTH = 100;
 /**
+* Name of the catch-all frontend tool. A tool registered under this name
+* handles any tool call that has no exact match (see `executeWildcardTool`),
+* and is never advertised to the agent.
+*/
+const WILDCARD_TOOL_NAME = "*";
+/**
 * Handles agent execution, tool calling, and agent connectivity for CopilotKitCore.
 * Manages the complete lifecycle of agent runs including tool execution and follow-ups.
 */
 var RunHandler = class {
-	_tools = [];
+	/**
+	* Tools owned by the framework provider, replaced wholesale by
+	* {@link initialize} and {@link setTools} whenever the provider re-syncs its
+	* props or runtime feature flags.
+	*/
+	_propTools = [];
+	/**
+	* Tools registered imperatively via {@link addTool} — `useFrontendTool`,
+	* `useHumanInTheLoop`, and direct `core.addTool()` callers. Held separately
+	* from {@link _propTools} so a provider re-sync cannot wipe them: they shared
+	* one array before, so the `/info` response flipping `openGenerativeUI` (or
+	* any other provider-prop change) silently dropped every hook-registered
+	* tool (#4952). Key = `capabilityKey(name, agentId)`.
+	*/
+	_hookTools = /* @__PURE__ */ new Map();
+	/**
+	* Memoized merge of both buckets, invalidated on every registry write.
+	*
+	* This is about identity, not speed: `tools` is public and used to return the
+	* same array instance until something mutated the registry, so consumers can
+	* hold it or use it as an effect dependency. Rebuilding the merge on every
+	* read would hand out a new array each time.
+	*/
+	_cachedMergedTools = null;
 	/**
 	* The full list of A2UI catalog components registered by the provider.
 	* Order is preserved for display in the inspector.
@@ -2076,6 +2556,12 @@ var RunHandler = class {
 	*/
 	_runDepth = 0;
 	/**
+	* Keeps tools that opt in via `webmcp` registered on the page's WebMCP model
+	* context (`document.modelContext`), in addition to the normal agent
+	* registration. Reconciled on every tool registry mutation.
+	*/
+	_webmcpRegistry = new WebMCPRegistry();
+	/**
 	* Tracks the threadId of the most recent `connectAgent` call so we
 	* can distinguish a fresh thread restore (different threadId than
 	* last time — chat is rebuilding state from scratch, must clear
@@ -2127,35 +2613,52 @@ var RunHandler = class {
 		return anonymousId;
 	}
 	/**
-	* Get all tools as a readonly array
+	* Get all tools as a readonly array: provider-owned tools in registration
+	* order, with imperatively-added tools appended and taking precedence over a
+	* provider tool of the same name + agentId.
 	*/
 	get tools() {
-		return this._tools;
+		if (this._hookTools.size === 0) return this._propTools;
+		if (this._cachedMergedTools) return this._cachedMergedTools;
+		const merged = /* @__PURE__ */ new Map();
+		for (const tool of this._propTools) merged.set(this.capabilityKey(tool.name, tool.agentId), tool);
+		for (const [key, tool] of this._hookTools) merged.set(key, tool);
+		this._cachedMergedTools = Array.from(merged.values());
+		return this._cachedMergedTools;
 	}
 	/**
 	* Initialize with tools
 	*/
 	initialize(tools) {
-		this._tools = tools;
+		this._propTools = [...tools];
+		this._cachedMergedTools = null;
+		this.syncWebMCP();
 	}
 	/**
-	* Add a tool to the registry
+	* Add a tool to the registry. Survives provider re-syncs ({@link setTools}),
+	* and shadows a provider tool of the same name + agentId.
 	*/
 	addTool(tool) {
-		if (this._tools.findIndex((t) => t.name === tool.name && t.agentId === tool.agentId) !== -1) {
+		const key = this.capabilityKey(tool.name, tool.agentId);
+		if (this._hookTools.has(key)) {
 			_copilotkit_shared.logger.warn(`Tool already exists: '${tool.name}' for agent '${tool.agentId || "global"}', skipping.`);
 			return;
 		}
-		this._tools.push(tool);
+		this._hookTools.set(key, tool);
+		this._cachedMergedTools = null;
+		this.syncWebMCP();
 	}
 	/**
 	* Remove a tool by name and optionally by agentId
 	*/
 	removeTool(id, agentId) {
-		this._tools = this._tools.filter((tool) => {
+		this._hookTools.delete(this.capabilityKey(id, agentId));
+		this._propTools = this._propTools.filter((tool) => {
 			if (agentId !== void 0) return !(tool.name === id && tool.agentId === agentId);
 			return !(tool.name === id && !tool.agentId);
 		});
+		this._cachedMergedTools = null;
+		this.syncWebMCP();
 	}
 	/**
 	* Get a tool by name and optionally by agentId.
@@ -2164,17 +2667,21 @@ var RunHandler = class {
 	*/
 	getTool(params) {
 		const { toolName, agentId } = params;
+		const tools = this.tools;
 		if (agentId) {
-			const agentTool = this._tools.find((tool) => tool.name === toolName && tool.agentId === agentId);
+			const agentTool = tools.find((tool) => tool.name === toolName && tool.agentId === agentId);
 			if (agentTool) return agentTool;
 		}
-		return this._tools.find((tool) => tool.name === toolName && !tool.agentId);
+		return tools.find((tool) => tool.name === toolName && !tool.agentId);
 	}
 	/**
-	* Set all tools at once. Replaces existing tools.
+	* Set all provider-owned tools at once. Replaces the previous provider set;
+	* tools registered via {@link addTool} are unaffected.
 	*/
 	setTools(tools) {
-		this._tools = [...tools];
+		this._propTools = [...tools];
+		this._cachedMergedTools = null;
+		this.syncWebMCP();
 	}
 	/**
 	* Return the registered A2UI catalog components (readonly).
@@ -2238,7 +2745,7 @@ var RunHandler = class {
 			});
 		} catch (error) {
 			const connectError = error instanceof Error ? error : new Error(String(error));
-			if (!(connectError.name === "AbortError" || connectError.message === "Fetch is aborted" || connectError.message === "signal is aborted without reason" || connectError.message === "component unmounted")) {
+			if (!isAbortError$1(connectError)) {
 				const context = {};
 				if (agent.agentId) context.agentId = agent.agentId;
 				if (incomingThreadId) context.threadId = incomingThreadId;
@@ -2351,7 +2858,7 @@ var RunHandler = class {
 				const getWildcardTool = () => {
 					if (tool || wildcardTool) return wildcardTool;
 					wildcardTool = this.getTool({
-						toolName: "*",
+						toolName: WILDCARD_TOOL_NAME,
 						agentId: agent.agentId
 					});
 					return wildcardTool;
@@ -2696,6 +3203,7 @@ var RunHandler = class {
 		const key = this.capabilityKey(name, agentId);
 		if (enabled) this._disabledToolKeys.delete(key);
 		else this._disabledToolKeys.add(key);
+		this.syncWebMCP();
 	}
 	/** Whether a tool is currently enabled (not overridden off). Defaults true. */
 	isToolEnabled(name, agentId) {
@@ -2705,13 +3213,39 @@ var RunHandler = class {
 	* Build frontend tools for an agent
 	*/
 	buildFrontendTools(agentId) {
-		return this._tools.filter((tool) => tool.available !== false && tool.available !== "disabled" && (!tool.agentId || tool.agentId === agentId) && this.isToolEnabled(tool.name, tool.agentId)).map((tool) => ({
+		return this.tools.filter((tool) => tool.name !== WILDCARD_TOOL_NAME && tool.available !== false && tool.available !== "disabled" && (!tool.agentId || tool.agentId === agentId) && this.isToolEnabled(tool.name, tool.agentId)).map((tool) => ({
 			name: tool.name,
 			description: tool.description ?? "",
 			parameters: createToolSchema(tool)
 		}));
 	}
 	/**
+	* Reconcile the WebMCP registrations with the current tool registry. Tools
+	* opt in via `webmcp: true` or `webmcp: { annotations }`; the same
+	* availability rules as `buildFrontendTools` apply. WebMCP tools are
+	* page-level, so unlike the agent tool list they are not filtered by
+	* agentId — a name collision across agentIds keeps the first registration.
+	*/
+	syncWebMCP() {
+		const desired = /* @__PURE__ */ new Map();
+		const warnedCollisions = /* @__PURE__ */ new Set();
+		for (const tool of this.tools) {
+			if (!tool.webmcp) continue;
+			if (tool.name === WILDCARD_TOOL_NAME) continue;
+			if (tool.available === false || tool.available === "disabled") continue;
+			if (!this.isToolEnabled(tool.name, tool.agentId)) continue;
+			if (desired.has(tool.name)) {
+				if (!warnedCollisions.has(tool.name)) {
+					warnedCollisions.add(tool.name);
+					_copilotkit_shared.logger.warn(`[CopilotKit] Multiple WebMCP tools share the name '${tool.name}'. Only the first registration is exposed to browser agents.`);
+				}
+				continue;
+			}
+			desired.set(tool.name, tool);
+		}
+		this._webmcpRegistry.sync(desired);
+	}
+	/**
 	* Create an agent error subscriber
 	*/
 	createAgentErrorSubscriber(agent) {
@@ -2744,36 +3278,6 @@ var RunHandler = class {
 	}
 };
 /**
-* Empty tool schema constant
-*/
-const EMPTY_TOOL_SCHEMA = {
-	type: "object",
-	properties: {}
-};
-/**
-* Create a JSON schema from a tool's parameters
-*/
-function createToolSchema(tool) {
-	if (!tool.parameters) return { ...EMPTY_TOOL_SCHEMA };
-	const rawSchema = (0, _copilotkit_shared.schemaToJsonSchema)(tool.parameters, { zodToJsonSchema: (schema, options) => (0, zod_to_json_schema.zodToJsonSchema)(schema, options) });
-	if (!rawSchema || typeof rawSchema !== "object") return { ...EMPTY_TOOL_SCHEMA };
-	const { $schema: _$schema, ...schema } = rawSchema;
-	if (typeof schema.type !== "string") schema.type = "object";
-	if (typeof schema.properties !== "object" || schema.properties === null) schema.properties = {};
-	stripAdditionalProperties(schema);
-	return schema;
-}
-function stripAdditionalProperties(schema) {
-	if (!schema || typeof schema !== "object") return;
-	if (Array.isArray(schema)) {
-		schema.forEach(stripAdditionalProperties);
-		return;
-	}
-	const record = schema;
-	if (record.additionalProperties !== void 0) delete record.additionalProperties;
-	for (const value of Object.values(record)) stripAdditionalProperties(value);
-}
-/**
 * Ensures parsed tool arguments are a plain object.
 * Throws for non-object values so the caller's catch block can emit
 * a structured TOOL_ARGUMENT_PARSE_FAILED error.
@@ -2853,9 +3357,10 @@ var StateManager = class {
 	subscribeToAgent(agent) {
 		if (!agent.agentId) return;
 		const agentId = agent.agentId;
-		const existingUnsubscribe = this.agentSubscriptions.get(agentId);
-		if (existingUnsubscribe) {
-			existingUnsubscribe();
+		const existing = this.agentSubscriptions.get(agentId);
+		if (existing) {
+			if (existing.agent === agent) return;
+			existing.unsubscribe();
 			this.agentSubscriptions.delete(agentId);
 		}
 		let revoked = false;
@@ -2991,19 +3496,22 @@ var StateManager = class {
 				if (!input) this.pruneRawEvents(agent.agentId, agent.threadId, messages);
 			}
 		});
-		this.agentSubscriptions.set(agentId, () => {
-			revoked = true;
-			this.pendingContinuations.delete(agent);
-			unsubscribe();
+		this.agentSubscriptions.set(agentId, {
+			agent,
+			unsubscribe: () => {
+				revoked = true;
+				this.pendingContinuations.delete(agent);
+				unsubscribe();
+			}
 		});
 	}
 	/**
 	* Unsubscribe an agent's subscription.
 	*/
 	unsubscribeFromAgent(agentId) {
-		const unsubscribe = this.agentSubscriptions.get(agentId);
-		if (unsubscribe) {
-			unsubscribe();
+		const existing = this.agentSubscriptions.get(agentId);
+		if (existing) {
+			existing.unsubscribe();
 			this.agentSubscriptions.delete(agentId);
 		}
 		this.rawEventByMessage.delete(agentId);
@@ -4533,6 +5041,9 @@ var CopilotKitCore = class {
 	get runtimeConnectionStatus() {
 		return this.agentRegistry.runtimeConnectionStatus;
 	}
+	get ɵruntimeFetch() {
+		return this.agentRegistry.createRuntimeFetch();
+	}
 	get audioFileTranscriptionEnabled() {
 		return this.agentRegistry.audioFileTranscriptionEnabled;
 	}
@@ -4572,6 +5083,14 @@ var CopilotKitCore = class {
 	get licenseStatus() {
 		return this.agentRegistry.licenseStatus;
 	}
+	/** Structured Runtime entitlement authority advertised by `/info`. */
+	get runtimeEntitlements() {
+		return this.agentRegistry.runtimeEntitlements;
+	}
+	/** Whether Core still has a bounded Runtime entitlement retry to settle. */
+	get runtimeEntitlementRetryPending() {
+		return this.agentRegistry.runtimeEntitlementRetryPending;
+	}
 	get telemetryDisabled() {
 		return this.agentRegistry.telemetryDisabled;
 	}
@@ -5544,22 +6063,34 @@ function createThreadRequestId() {
 }
 function threadFromFetch(input, init) {
 	return new rxjs.Observable((subscriber) => {
-		const { fetch: fetchImpl, selector, signal, ...requestInit } = init;
+		const { fetch: fetchImpl, selector, signal, timeoutMs, nonCritical, ...requestInit } = init;
 		const controller = new AbortController();
+		const runtimeRequest = {
+			...nonCritical ? { nonCritical: true } : {},
+			...timeoutMs === void 0 ? {} : { selfBounded: true }
+		};
+		let timedOut = false;
 		const abortRequest = () => controller.abort();
 		if (signal?.aborted) abortRequest();
 		else signal?.addEventListener("abort", abortRequest, { once: true });
+		const timeoutId = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+			timedOut = true;
+			runtimeRequest.timedOut = true;
+			abortRequest();
+		}, timeoutMs);
 		fetchImpl(input, {
 			...requestInit,
-			signal: controller.signal
+			signal: controller.signal,
+			ɵruntimeRequest: runtimeRequest
 		}).then((response) => selector(response)).then((value) => {
 			if (subscriber.closed) return;
 			subscriber.next(value);
 			subscriber.complete();
 		}).catch((error) => {
-			if (!subscriber.closed) subscriber.error(error);
+			if (!subscriber.closed) subscriber.error(timedOut ? /* @__PURE__ */ new Error("Request timed out") : error);
 		});
 		return () => {
+			if (timeoutId !== void 0) clearTimeout(timeoutId);
 			signal?.removeEventListener("abort", abortRequest);
 			abortRequest();
 		};
@@ -5577,14 +6108,10 @@ function createThreadFetchObservable(environment, context, sessionId) {
 				return response.json();
 			},
 			fetch: environment.fetch,
+			timeoutMs: REQUEST_TIMEOUT_MS,
 			method: "GET",
 			headers: { ...context.headers }
-		}).pipe((0, rxjs_operators.timeout)({
-			first: REQUEST_TIMEOUT_MS,
-			with: () => {
-				throw new Error("Request timed out");
-			}
-		}), (0, rxjs_operators.map)((data) => threadRestEvents.listSucceeded({
+		}).pipe((0, rxjs_operators.map)((data) => threadRestEvents.listSucceeded({
 			sessionId,
 			threads: data.threads,
 			joinCode: typeof data.joinCode === "string" && data.joinCode.length > 0 ? data.joinCode : null,
@@ -5605,18 +6132,15 @@ function createThreadMetadataCredentialsObservable(environment, context, session
 				return response.json();
 			},
 			fetch: environment.fetch,
+			timeoutMs: REQUEST_TIMEOUT_MS,
+			nonCritical: true,
 			method: "POST",
 			headers: {
 				...context.headers,
 				"Content-Type": "application/json"
 			},
 			body: JSON.stringify({})
-		}).pipe((0, rxjs_operators.timeout)({
-			first: REQUEST_TIMEOUT_MS,
-			with: () => {
-				throw new Error("Request timed out");
-			}
-		}), (0, rxjs_operators.map)((data) => {
+		}).pipe((0, rxjs_operators.map)((data) => {
 			if (typeof data.joinToken !== "string" || data.joinToken.length === 0) throw new Error("missing joinToken");
 			return threadRestEvents.metadataCredentialsSucceeded({
 				sessionId,
@@ -5747,14 +6271,10 @@ function createThreadStore(environment) {
 						return response.json();
 					},
 					fetch: environment.fetch,
+					timeoutMs: REQUEST_TIMEOUT_MS,
 					method: "GET",
 					headers: { ...context.headers }
-				}).pipe((0, rxjs_operators.timeout)({
-					first: REQUEST_TIMEOUT_MS,
-					with: () => {
-						throw new Error("Request timed out");
-					}
-				}), (0, rxjs_operators.map)((data) => threadRestEvents.nextPageSucceeded({
+				}).pipe((0, rxjs_operators.map)((data) => threadRestEvents.nextPageSucceeded({
 					sessionId: state.sessionId,
 					threads: data.threads,
 					nextCursor: data.nextCursor ?? null
@@ -5918,6 +6438,12 @@ const ɵselectIsMutating = selectIsMutating;
 * hardcoding the threshold separately from production.
 */
 const ɵMAX_SOCKET_RETRIES = MAX_SOCKET_RETRIES;
+/**
+* How long a thread REST request is given before the store gives up on it.
+* Exposed for tests for the same reason as {@link ɵMAX_SOCKET_RETRIES}: a
+* separately hardcoded copy silently drifts away from this one.
+*/
+const ɵTHREAD_REQUEST_TIMEOUT_MS = REQUEST_TIMEOUT_MS;
 
 //#endregion
 //#region src/features.ts
@@ -6180,6 +6706,7 @@ exports.RunHandler = RunHandler;
 exports.StateManager = StateManager;
 exports.SuggestionEngine = SuggestionEngine;
 exports.ToolCallStatus = ToolCallStatus;
+exports.WebMCPRegistry = WebMCPRegistry;
 exports.completePartialMarkdown = completePartialMarkdown;
 exports.createActionGroup = createActionGroup;
 exports.createEffect = createEffect;
@@ -6193,6 +6720,7 @@ exports.emitInspectorViewThread = emitInspectorViewThread;
 exports.emitInspectorViewThreadResult = emitInspectorViewThreadResult;
 exports.empty = empty;
 exports.ensureObjectArgs = ensureObjectArgs;
+exports.getWebMCPModelContext = getWebMCPModelContext;
 exports.isAbortError = isAbortError;
 exports.isInspectorThreadBridgeEnabled = isInspectorThreadBridgeEnabled;
 exports.isRunCompletionAware = isRunCompletionAware;
@@ -6208,6 +6736,8 @@ exports.select = select;
 exports.ɵCOPILOTKIT_FEATURES = ɵCOPILOTKIT_FEATURES;
 exports.ɵInterruptState = ɵInterruptState;
 exports.ɵMAX_SOCKET_RETRIES = ɵMAX_SOCKET_RETRIES;
+exports.ɵRUNTIME_PROBE_TIMEOUT_MS = ɵRUNTIME_PROBE_TIMEOUT_MS;
+exports.ɵTHREAD_REQUEST_TIMEOUT_MS = ɵTHREAD_REQUEST_TIMEOUT_MS;
 exports.ɵcreateMemoryStore = createMemoryStore;
 exports.ɵcreateThreadSelectors = ɵcreateThreadSelectors;
 exports.ɵcreateThreadStore = createThreadStore;