@copilotkit/core 1.70.0 → 1.70.2

package/dist/index.mjs

@@ -1,12 +1,88 @@
 import { Throttler } from "@tanstack/pacer";
-import { AbstractAgent, EventType, HttpAgent, buildResumeArray, isInterruptExpired, randomUUID, runHttpRequest, structuredClone_, transformChunks, transformHttpEventStream } from "@ag-ui/client";
+import { AGUIConnectNotImplementedError, AbstractAgent, EventType, HttpAgent, buildResumeArray, isInterruptExpired, randomUUID, runHttpRequest, structuredClone_, transformChunks, transformHttpEventStream } from "@ag-ui/client";
 import { RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE, logger, parseInspectorMetadataV1, partialJSONParse, phoenixExponentialBackoff, randomUUID as randomUUID$1, resolveDebugConfig, schemaToJsonSchema } from "@copilotkit/shared";
 import { BehaviorSubject, EMPTY, NEVER, Notification, Observable, Subject, Subscription, asapScheduler, combineLatest, concat, defer, dematerialize, firstValueFrom, from, lastValueFrom, merge, observeOn, of, switchMap, throwError } from "rxjs";
 import { catchError, concatWith, delay, distinctUntilChanged, endWith, filter, finalize, ignoreElements, map, mergeMap, observeOn as observeOn$1, scan, share, shareReplay, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
 import { Socket } from "phoenix";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { fromFetch } from "rxjs/fetch";
 
+//#region src/utils/connect-replay.ts
+/**
+* Runs an agent's `connect()` stream through the AbstractAgent apply pipeline
+* with the `verifyEvents` step omitted.
+*
+* `verifyEvents` enforces AG-UI's *single run* lifecycle rules: exactly one
+* RUN_STARTED opening the stream, no events after a terminal RUN_FINISHED /
+* RUN_ERROR. Those rules are correct for `/run`, but a `/connect` response is a
+* replay of a thread's history and can legitimately carry several past runs
+* back to back — including a run that ended in RUN_ERROR followed by a later
+* RUN_STARTED. Verifying a replay against single-run rules makes hydration of
+* an existing thread fail outright:
+*
+*   Cannot send event type 'RUN_STARTED': The run has already errored with
+*   'RUN_ERROR'. No further events can be sent.
+*
+* `transformChunks` is still applied — message reassembly is needed either way.
+*
+* This mirrors the base `AbstractAgent.connectAgent` implementation exactly
+* apart from that omission, so callers keep the same subscriber notifications,
+* detach semantics, and `{ result, newMessages }` return shape.
+*
+* TODO: Remove this in favour of the base implementation once AG-UI's
+* AbstractAgent supports opting out of `verifyEvents` for transports whose
+* connection life-cycle isn't a single run. As of `@ag-ui/client@0.0.57`
+* `connectAgent(parameters?, subscriber?)` takes no such option.
+*
+* @param agent - The agent whose `connect()` stream should be consumed.
+* @param parameters - Run parameters, forwarded to `prepareRunAgentInput`.
+* @param subscriber - Optional one-shot subscriber for this connect call.
+*/
+async function ɵconnectWithoutEventVerification(agent, parameters, subscriber) {
+	const self = agent;
+	try {
+		agent.isRunning = true;
+		agent.agentId = agent.agentId ?? randomUUID();
+		const input = self.prepareRunAgentInput(parameters);
+		let result;
+		const previousMessageIds = new Set(agent.messages.map((m) => m.id));
+		const subscribers = [
+			{ onRunFinishedEvent: (event) => {
+				if (event.outcome === "success") result = event.result;
+			} },
+			...agent.subscribers,
+			subscriber ?? {}
+		];
+		await self.onInitialize(input, subscribers);
+		self.activeRunDetach$ = new Subject();
+		let resolveCompletion;
+		self.activeRunCompletionPromise = new Promise((resolve) => {
+			resolveCompletion = resolve;
+		});
+		const source$ = defer(() => self.connect(input)).pipe(transformChunks(self.debugLogger), takeUntil(self.activeRunDetach$));
+		const applied$ = self.apply(input, source$, subscribers);
+		await lastValueFrom(self.processApplyEvents(input, applied$, subscribers).pipe(catchError((error) => {
+			agent.isRunning = false;
+			if (error instanceof AGUIConnectNotImplementedError) return EMPTY;
+			return self.onError(input, error, subscribers);
+		}), finalize(() => {
+			agent.isRunning = false;
+			self.onFinalize(input, subscribers);
+			resolveCompletion?.();
+			resolveCompletion = void 0;
+			self.activeRunCompletionPromise = void 0;
+			self.activeRunDetach$ = void 0;
+		})), { defaultValue: void 0 });
+		const newMessages = structuredClone_(agent.messages).filter((m) => !previousMessageIds.has(m.id));
+		return {
+			result,
+			newMessages
+		};
+	} finally {
+		agent.isRunning = false;
+	}
+}
+
+//#endregion
 //#region src/utils/phoenix-observable.ts
 /**
 * Adapt Phoenix socket open/error callbacks into an observable signal stream.
@@ -203,72 +279,22 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 	/**
 	* Override of AbstractAgent.connectAgent that removes the `verifyEvents` step.
 	*
-	* Background: AbstractAgent's connectAgent pipeline runs events through
-	* `verifyEvents`, which validates that the stream follows the AG-UI protocol
-	* lifecycle — specifically, it expects a RUN_STARTED event before any content
-	* events and a RUN_FINISHED/RUN_ERROR event to complete the stream.
-	*
 	* IntelligenceAgent uses long-lived WebSocket connections rather than
 	* request-scoped SSE streams. When connecting to replay historical messages
 	* for an existing thread, the connection semantics don't map to a single
-	* agent run start/stop cycle. The replayed events may not include
-	* RUN_STARTED/RUN_FINISHED bookends (or may contain events from multiple
-	* past runs), which causes verifyEvents to either never complete or to
-	* error out.
+	* agent run start/stop cycle: the replayed events may omit the
+	* RUN_STARTED/RUN_FINISHED bookends, or carry events from several past runs,
+	* either of which makes `verifyEvents` stall or error out.
 	*
-	* This override replicates the base connectAgent implementation exactly,
-	* substituting only `transformChunks` (which is still needed for message
-	* reassembly) and omitting `verifyEvents`.
-	*
-	* TODO: Remove this override once AG-UI's AbstractAgent supports opting out
-	* of verifyEvents for transports with different connection life-cycles.
+	* See {@link ɵconnectWithoutEventVerification} for the pipeline itself, which
+	* the self-hosted `/connect` path shares for the same reason.
 	*/
 	async connectAgent(parameters, subscriber) {
-		const self = this;
-		try {
-			this.isRunning = true;
-			this.agentId = this.agentId ?? randomUUID();
-			const effectiveParameters = parameters?.runId || !this.canonicalRunId ? parameters : {
-				...parameters,
-				runId: this.canonicalRunId
-			};
-			const input = this.prepareRunAgentInput(effectiveParameters);
-			let result;
-			const previousMessageIds = new Set(this.messages.map((m) => m.id));
-			const subscribers = [
-				{ onRunFinishedEvent: (event) => {
-					if (event.outcome === "success") result = event.result;
-				} },
-				...this.subscribers,
-				subscriber ?? {}
-			];
-			await this.onInitialize(input, subscribers);
-			self.activeRunDetach$ = new Subject();
-			let resolveCompletion;
-			self.activeRunCompletionPromise = new Promise((resolve) => {
-				resolveCompletion = resolve;
-			});
-			const source$ = defer(() => this.connect(input)).pipe(transformChunks(this.debugLogger), takeUntil(self.activeRunDetach$));
-			const applied$ = this.apply(input, source$, subscribers);
-			await lastValueFrom(this.processApplyEvents(input, applied$, subscribers).pipe(catchError((error) => {
-				this.isRunning = false;
-				return this.onError(input, error, subscribers);
-			}), finalize(() => {
-				this.isRunning = false;
-				this.onFinalize(input, subscribers);
-				resolveCompletion?.();
-				resolveCompletion = void 0;
-				self.activeRunCompletionPromise = void 0;
-				self.activeRunDetach$ = void 0;
-			})), { defaultValue: void 0 });
-			const newMessages = structuredClone_(this.messages).filter((m) => !previousMessageIds.has(m.id));
-			return {
-				result,
-				newMessages
-			};
-		} finally {
-			this.isRunning = false;
-		}
+		const effectiveParameters = parameters?.runId || !this.canonicalRunId ? parameters : {
+			...parameters,
+			runId: this.canonicalRunId
+		};
+		return ɵconnectWithoutEventVerification(this, effectiveParameters, subscriber);
 	}
 	abortRun() {
 		if (this.activeChannel && this.canonicalRunId) {
@@ -360,13 +386,7 @@ var IntelligenceAgent = class IntelligenceAgent extends AbstractAgent {
 						...this.headers
 					},
 					body: JSON.stringify({
-						threadId: input.threadId,
-						runId: input.runId,
-						messages: input.messages,
-						tools: input.tools,
-						context: input.context,
-						state: input.state,
-						forwardedProps: input.forwardedProps,
+						...input,
 						...mode === "connect" ? { lastSeenEventId: replayCursor === void 0 ? this.getReconnectCursor(input) : replayCursor } : {}
 					}),
 					...this.credentials ? { credentials: this.credentials } : {}
@@ -733,7 +753,7 @@ var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAg
 		});
 	}
 	async connectAgent(parameters, subscriber) {
-		if (this.runtimeMode !== RUNTIME_MODE_INTELLIGENCE) return super.connectAgent(parameters, subscriber);
+		if (this.runtimeMode !== RUNTIME_MODE_INTELLIGENCE) return ɵconnectWithoutEventVerification(this, parameters, subscriber);
 		if (this.delegate) await this.delegate.detachActiveRun();
 		await this.resolveDelegate();
 		const delegate = this.delegate;
@@ -985,6 +1005,74 @@ function runtimeRequestMeta(init) {
 	return init?.ɵruntimeRequest;
 }
 
+//#endregion
+//#region src/utils/single-route-resource-request.ts
+/** Returns true when a path belongs to an Intelligence resource API. */
+function isIntelligenceResourcePath(path) {
+	return path === "/threads" || path.startsWith("/threads/") || path === "/memories" || path.startsWith("/memories/") || path === "/annotate";
+}
+/** Reads a JSON resource body without changing invalid JSON error behavior. */
+async function readResourceBody(input, init, headers, method) {
+	if (method === "GET" || method === "HEAD") return void 0;
+	let text;
+	if (init?.body != null) text = await new Response(init.body).text();
+	else if (input instanceof Request) text = await input.clone().text();
+	if (!text) return void 0;
+	if (headers.get("content-type")?.toLowerCase().includes("application/json")) try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+	return text;
+}
+/**
+* Converts one Runtime resource fetch into a single-route JSON envelope.
+* Requests outside the mounted Runtime or outside its resource APIs pass
+* through unchanged.
+*/
+async function createSingleRouteResourceRequest(input, init, runtimeUrl) {
+	const runtime = new URL(runtimeUrl);
+	const inputUrl = input instanceof Request ? input.url : input instanceof URL ? input.href : input;
+	const target = new URL(inputUrl, runtime);
+	const runtimePath = runtime.pathname.replace(/\/$/, "");
+	if (target.origin !== runtime.origin) return null;
+	if (!target.pathname.startsWith(`${runtimePath}/`)) return null;
+	const resourcePath = target.pathname.slice(runtimePath.length);
+	if (!isIntelligenceResourcePath(resourcePath)) return null;
+	const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+	const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+	const body = await readResourceBody(input, init, headers, method);
+	headers.set("content-type", "application/json");
+	headers.delete("content-length");
+	return {
+		input: runtimeUrl,
+		init: {
+			...input instanceof Request ? {
+				cache: input.cache,
+				credentials: input.credentials,
+				integrity: input.integrity,
+				keepalive: input.keepalive,
+				mode: input.mode,
+				redirect: input.redirect,
+				referrer: input.referrer,
+				referrerPolicy: input.referrerPolicy,
+				signal: input.signal
+			} : {},
+			...init,
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				method: "resource/request",
+				params: {
+					path: `${resourcePath}${target.search}`,
+					httpMethod: method
+				},
+				...body === void 0 ? {} : { body }
+			})
+		}
+	};
+}
+
 //#endregion
 //#region src/core/agent-registry.ts
 /** Maximum wait for optional Inspector metadata before degrading to absence. */
@@ -1026,7 +1114,9 @@ var AgentRegistry = class {
 	_runtimeMode = RUNTIME_MODE_SSE;
 	_intelligence;
 	_threadEndpoints;
+	_singleRouteResourceOperations = false;
 	_suggestions;
+	_inspectorLearning = false;
 	_inspectorMetadata;
 	_inspectorMetadataSupported = false;
 	inspectorMetadataRefreshReady = false;
@@ -1097,6 +1187,9 @@ var AgentRegistry = class {
 	get suggestions() {
 		return this._suggestions;
 	}
+	get inspectorLearning() {
+		return this._inspectorLearning;
+	}
 	get inspectorMetadata() {
 		return this._inspectorMetadata;
 	}
@@ -1147,6 +1240,7 @@ var AgentRegistry = class {
 		this.resetRuntimeEntitlementRetry();
 		this._licenseStatus = void 0;
 		this._runtimeEntitlements = void 0;
+		this._singleRouteResourceOperations = false;
 		this._runtimeUrl = normalizedRuntimeUrl;
 		if (options?.deferConnection) return;
 		this.updateRuntimeConnection({ preserveOnFailure: this.hasLiveRuntimeKnowledgeToProtect() });
@@ -1175,6 +1269,7 @@ var AgentRegistry = class {
 		this.resetRuntimeEntitlementRetry();
 		this._requestedTransport = runtimeTransport;
 		this._runtimeTransport = runtimeTransport;
+		this._singleRouteResourceOperations = false;
 		this.updateRuntimeConnection({ preserveOnFailure: this.hasLiveRuntimeKnowledgeToProtect() });
 	}
 	hasLiveRuntimeKnowledgeToProtect() {
@@ -1346,7 +1441,8 @@ var AgentRegistry = class {
 			const meta = () => runtimeRequestMeta(init);
 			const watchdog = this.armRuntimeRequestWatchdog(meta());
 			try {
-				const response = await fetch(input, init);
+				const singleRouteRequest = this._runtimeTransport === "single" && this._singleRouteResourceOperations && this._runtimeUrl ? await createSingleRouteResourceRequest(input, init, this._runtimeUrl) : null;
+				const response = singleRouteRequest ? await fetch(singleRouteRequest.input, singleRouteRequest.init) : await fetch(input, init);
 				watchdog.clear();
 				this.handleRuntimeRequestOutcome(response.ok ? "ok" : meta()?.nonCritical ? "ignored" : "failed", watchdog.checked);
 				return response;
@@ -1495,6 +1591,7 @@ var AgentRegistry = class {
 	}
 	invalidateInspectorMetadataConnection() {
 		this._inspectorMetadataSupported = false;
+		this._inspectorLearning = false;
 		this.inspectorMetadataRefreshReady = false;
 		this.inspectorMetadataConnectionGeneration += 1;
 		this.inspectorMetadataGeneration += 1;
@@ -1693,7 +1790,9 @@ var AgentRegistry = class {
 			this._runtimeMode = RUNTIME_MODE_SSE;
 			this._intelligence = void 0;
 			this._threadEndpoints = void 0;
+			this._singleRouteResourceOperations = false;
 			this._suggestions = void 0;
+			this._inspectorLearning = false;
 			this._a2uiEnabled = false;
 			this._a2uiAgents = void 0;
 			this._openGenerativeUIEnabled = false;
@@ -1762,8 +1861,10 @@ var AgentRegistry = class {
 			this._audioFileTranscriptionEnabled = runtimeInfoResponse.audioFileTranscriptionEnabled ?? false;
 			this._runtimeMode = runtimeInfoResponse.mode ?? RUNTIME_MODE_SSE;
 			this._intelligence = runtimeInfoResponse.intelligence;
-			this._threadEndpoints = runtimeInfoResponse.threadEndpoints;
+			this._singleRouteResourceOperations = resolvedTransport === "single" && runtimeInfoResponse.singleRoute?.resourceOperations === true;
+			this._threadEndpoints = this._singleRouteResourceOperations ? runtimeInfoResponse.singleRoute?.threadEndpoints : runtimeInfoResponse.threadEndpoints;
 			this._suggestions = runtimeInfoResponse.suggestions;
+			this._inspectorLearning = runtimeInfoResponse.inspectorLearning === true;
 			this._inspectorMetadataSupported = runtimeInfoResponse.inspectorMetadata === true;
 			this.inspectorMetadataRefreshReady = false;
 			if (!this._inspectorMetadataSupported) this.setInspectorMetadata(void 0);
@@ -1797,7 +1898,9 @@ var AgentRegistry = class {
 				this._runtimeMode = RUNTIME_MODE_SSE;
 				this._intelligence = void 0;
 				this._threadEndpoints = void 0;
+				this._singleRouteResourceOperations = false;
 				this._suggestions = void 0;
+				this._inspectorLearning = false;
 				this._a2uiEnabled = false;
 				this._a2uiAgents = void 0;
 				this._openGenerativeUIEnabled = false;
@@ -2342,6 +2445,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 = schemaToJsonSchema(tool.parameters, { zodToJsonSchema: (schema, options) => 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: randomUUID$1(),
+					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);
+		logger.warn(`[CopilotKit] ${message}`);
+	}
+};
+
 //#endregion
 //#region src/core/run-handler.ts
 /**
@@ -2424,6 +2658,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
@@ -2494,6 +2734,7 @@ var RunHandler = class {
 	initialize(tools) {
 		this._propTools = [...tools];
 		this._cachedMergedTools = null;
+		this.syncWebMCP();
 	}
 	/**
 	* Add a tool to the registry. Survives provider re-syncs ({@link setTools}),
@@ -2507,6 +2748,7 @@ var RunHandler = class {
 		}
 		this._hookTools.set(key, tool);
 		this._cachedMergedTools = null;
+		this.syncWebMCP();
 	}
 	/**
 	* Remove a tool by name and optionally by agentId
@@ -2518,6 +2760,7 @@ var RunHandler = class {
 			return !(tool.name === id && !tool.agentId);
 		});
 		this._cachedMergedTools = null;
+		this.syncWebMCP();
 	}
 	/**
 	* Get a tool by name and optionally by agentId.
@@ -2540,6 +2783,7 @@ var RunHandler = class {
 	setTools(tools) {
 		this._propTools = [...tools];
 		this._cachedMergedTools = null;
+		this.syncWebMCP();
 	}
 	/**
 	* Return the registered A2UI catalog components (readonly).
@@ -3061,6 +3305,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) {
@@ -3077,6 +3322,32 @@ var RunHandler = class {
 		}));
 	}
 	/**
+	* 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);
+					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) {
@@ -3109,36 +3380,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 = schemaToJsonSchema(tool.parameters, { zodToJsonSchema: (schema, options) => 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.
@@ -4161,8 +4402,24 @@ const selectMemoriesAvailable = createSelector((state) => state.available);
 */
 const selectMemoriesRealtimeStatus = createSelector((state) => state.realtimeStatus);
 const MEMORY_METADATA_EVENT = "memory_metadata";
+/** Runs a memory request through the injected fetch and aborts on unsubscribe. */
 function memoryFromFetch(input, init) {
-	return fromFetch(input, init);
+	const { selector, fetch: fetchImplementation, signal: outerSignal, ...requestInit } = init;
+	return new Observable((subscriber) => {
+		const controller = new AbortController();
+		const abort = () => controller.abort();
+		if (outerSignal?.aborted) controller.abort();
+		else outerSignal?.addEventListener("abort", abort);
+		const subscription = from(fetchImplementation(input, {
+			...requestInit,
+			signal: controller.signal
+		})).pipe(mergeMap((response) => from(selector(response)))).subscribe(subscriber);
+		return () => {
+			outerSignal?.removeEventListener("abort", abort);
+			controller.abort();
+			subscription.unsubscribe();
+		};
+	});
 }
 /**
 * Fetches the memory snapshot and maps it to a success/failure action. Both
@@ -4920,6 +5177,10 @@ var CopilotKitCore = class {
 	get suggestions() {
 		return this.agentRegistry.suggestions;
 	}
+	/** Whether the connected Runtime exposes debug-authorized Learning data. */
+	get inspectorLearning() {
+		return this.agentRegistry.inspectorLearning;
+	}
 	/** Trusted, optional metadata advertised by the connected runtime. */
 	get inspectorMetadata() {
 		return this.agentRegistry.inspectorMetadata;
@@ -5109,12 +5370,12 @@ var CopilotKitCore = class {
 	/**
 	* Lazily creates, starts, and context-syncs the core-owned memory store on
 	* first access, then returns it. Subsequent calls return the existing store.
-	* The store is constructed with a bound `globalThis.fetch` and immediately
-	* has its runtime context synced from the current connection state.
+	* The store uses the Core Runtime fetch so REST and single-route transports
+	* share the same resource behavior. Its Runtime context is synced at once.
 	*/
 	ensureMemoryStore() {
 		if (!this._memoryStore) {
-			this._memoryStore = createMemoryStore({ fetch: globalThis.fetch.bind(globalThis) });
+			this._memoryStore = createMemoryStore({ fetch: this.ɵruntimeFetch });
 			this._memoryStore.start();
 			this.syncMemoryContext();
 		}
@@ -6552,5 +6813,5 @@ function onInspectorViewThreadResult(handler) {
 }
 
 //#endregion
-export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, INSPECTOR_THREAD_BRIDGE_PLUGIN_ID, IntelligenceAgent, MEMORY_ERROR_REGISTRY, MemoryError, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, completePartialMarkdown, createActionGroup, createEffect, createInspectorThreadRequestId, createReducer, createSelector, createStore, emitInspectorActiveThread, emitInspectorStopViewing, emitInspectorViewThread, emitInspectorViewThreadResult, empty, ensureObjectArgs, isAbortError, isInspectorThreadBridgeEnabled, isRunCompletionAware, ofType, on, onInspectorActiveThread, onInspectorStopViewing, onInspectorViewThread, onInspectorViewThreadResult, parseToolArguments, props, select, ɵCOPILOTKIT_FEATURES, ɵInterruptState, ɵMAX_SOCKET_RETRIES, ɵRUNTIME_PROBE_TIMEOUT_MS, ɵTHREAD_REQUEST_TIMEOUT_MS, createMemoryStore as ɵcreateMemoryStore, ɵcreateThreadSelectors, createThreadStore as ɵcreateThreadStore, ɵisCopilotKitFeature, isRetryableStatus as ɵisRetryableMemoryStatus, ɵjoinPhoenixChannel$, ɵmapMemoryMetadataEvent, ɵmemoryAdapterEvents, ɵmemoryDomainEvents, ɵmemoryReducer, ɵmemoryRestEvents, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesIsMutating, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
+export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, INSPECTOR_THREAD_BRIDGE_PLUGIN_ID, IntelligenceAgent, MEMORY_ERROR_REGISTRY, MemoryError, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, WebMCPRegistry, completePartialMarkdown, createActionGroup, createEffect, createInspectorThreadRequestId, createReducer, createSelector, createStore, emitInspectorActiveThread, emitInspectorStopViewing, emitInspectorViewThread, emitInspectorViewThreadResult, empty, ensureObjectArgs, getWebMCPModelContext, isAbortError, isInspectorThreadBridgeEnabled, isRunCompletionAware, ofType, on, onInspectorActiveThread, onInspectorStopViewing, onInspectorViewThread, onInspectorViewThreadResult, parseToolArguments, props, select, ɵCOPILOTKIT_FEATURES, ɵInterruptState, ɵMAX_SOCKET_RETRIES, ɵRUNTIME_PROBE_TIMEOUT_MS, ɵTHREAD_REQUEST_TIMEOUT_MS, createMemoryStore as ɵcreateMemoryStore, ɵcreateThreadSelectors, createThreadStore as ɵcreateThreadStore, ɵisCopilotKitFeature, isRetryableStatus as ɵisRetryableMemoryStatus, ɵjoinPhoenixChannel$, ɵmapMemoryMetadataEvent, ɵmemoryAdapterEvents, ɵmemoryDomainEvents, ɵmemoryReducer, ɵmemoryRestEvents, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesIsMutating, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
 //# sourceMappingURL=index.mjs.map