@copilotkit/core 1.75.2 → 1.77.0

package/dist/index.umd.js

@@ -1,10 +1,27 @@
 (function(global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('@tanstack/pacer'), require('@ag-ui/client'), require('@copilotkit/shared'), require('rxjs'), require('rxjs/operators'), require('phoenix'), require('zod-to-json-schema')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@tanstack/pacer', '@ag-ui/client', '@copilotkit/shared', 'rxjs', 'rxjs/operators', 'phoenix', 'zod-to-json-schema'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitCore = {}), global._tanstack_pacer,global.AgUIClient,global.CopilotKitShared,global.rxjs,global.rxjs.operators,global.phoenix,global.zodToJsonSchema));
-})(this, function(exports, _tanstack_pacer, _ag_ui_client, _copilotkit_shared, rxjs, rxjs_operators, phoenix, zod_to_json_schema) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('@tanstack/pacer'), require('@ag-ui/client'), require('@copilotkit/shared'), require('rxjs'), require('rxjs/operators'), require('phoenix'), require('zod-to-json-schema'), require('@copilotkit/learning')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@tanstack/pacer', '@ag-ui/client', '@copilotkit/shared', 'rxjs', 'rxjs/operators', 'phoenix', 'zod-to-json-schema', '@copilotkit/learning'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitCore = {}), global._tanstack_pacer,global.AgUIClient,global.CopilotKitShared,global.rxjs,global.rxjs.operators,global.phoenix,global.zodToJsonSchema,global._copilotkit_learning));
+})(this, function(exports, _tanstack_pacer, _ag_ui_client, _copilotkit_shared, rxjs, rxjs_operators, phoenix, zod_to_json_schema, _copilotkit_learning) {
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+//#region src/utils/http-agent.ts
+/**
+	* Whether an agent is an `HttpAgent`, including one built from another copy of
+	* `@ag-ui/client` (an app that pins its own 0.x version next to CopilotKit's
+	* 1.0, for example). `instanceof` is false across package copies, which made
+	* CopilotKit silently skip headers and abort wiring for those agents. The
+	* fallback checks the public fields CopilotKit uses, which every published
+	* `HttpAgent` has.
+	*/
+	function ɵisHttpAgent(agent) {
+		if (agent instanceof _ag_ui_client.HttpAgent) return true;
+		if (typeof agent !== "object" || agent === null) return false;
+		const candidate = agent;
+		return typeof candidate.url === "string" && typeof candidate.headers === "object" && candidate.headers !== null && candidate.abortController instanceof AbortController && typeof candidate.runAgent === "function";
+	}
+
+//#endregion
 //#region src/utils/connect-replay.ts
 /**
 	* Runs an agent's `connect()` stream through the AbstractAgent apply pipeline
@@ -21,18 +38,27 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	*   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.
+	* The AG-UI 1.0 compatibility boundary still runs first, so stored 0.x history
+	* is translated (THINKING_* events, `binary` parts, legacy nulls) exactly as in
+	* the base pipeline. `enforceEvents` is omitted too: a replay is stored
+	* history, and one event that the 1.0 schema rejects (the Intelligence gateway
+	* replays RUN_STARTED without `runId`, for example) must not stop the whole
+	* thread from hydrating. That keeps the leniency this path had before 1.0.
 	*
 	* Connection-local replay hooks track the phase before applying events. An
 	* explicitly live RUN_ERROR clears busy without closing the connection;
 	* historical errors remain data. Connections without hooks retain the existing
-	* completion behavior. Subscriber, detach, and result contracts are preserved.
+	* completion behavior.
+	*
+	* Apart from the above, this mirrors the base `AbstractAgent.connectAgent`
+	* implementation, 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 AND preserves the connection-local
 	* replay lifecycle and running-state behavior below. Skipping verification alone
-	* is insufficient. As of `@ag-ui/client@0.0.57`
+	* is insufficient. As of `@ag-ui/client@1.0.1`
 	* `connectAgent(parameters?, subscriber?)` takes no such option.
 	*
 	* @param agent - The agent whose `connect()` stream should be consumed.
@@ -41,6 +67,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	*/
 	async function ɵconnectWithoutEventVerification(agent, parameters, subscriber, connect) {
 		const self = agent;
+		let finalizeRun = () => {
+			agent.isRunning = false;
+		};
 		try {
 			var _agent$agentId;
 			agent.isRunning = true;
@@ -65,12 +94,35 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				...agent.subscribers,
 				subscriber !== null && subscriber !== void 0 ? subscriber : {}
 			];
-			await self.onInitialize(input, subscribers);
-			self.activeRunDetach$ = new rxjs.Subject();
+			const activeRunDetach$ = new rxjs.Subject();
+			self.activeRunDetach$ = activeRunDetach$;
 			let resolveCompletion;
 			self.activeRunCompletionPromise = new Promise((resolve) => {
 				resolveCompletion = resolve;
 			});
+			let detached = false;
+			let finalized = false;
+			const detachSubscription = activeRunDetach$.subscribe(() => {
+				detached = true;
+			});
+			finalizeRun = () => {
+				if (finalized) return;
+				finalized = true;
+				detachSubscription.unsubscribe();
+				if (self.activeRunDetach$ === activeRunDetach$) {
+					agent.isRunning = false;
+					self.activeRunCompletionPromise = void 0;
+					self.activeRunDetach$ = void 0;
+					self.onFinalize(input, subscribers);
+				}
+				resolveCompletion === null || resolveCompletion === void 0 || resolveCompletion();
+				resolveCompletion = void 0;
+			};
+			await self.onInitialize(input, subscribers);
+			if (detached) return {
+				result: void 0,
+				newMessages: []
+			};
 			const lifecycle = {
 				onReplayStarted: () => {
 					isReplaying = true;
@@ -80,29 +132,23 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					isReplaying = false;
 				}
 			};
-			const source$ = (0, rxjs.defer)(() => connect ? connect(input, lifecycle) : self.connect(input)).pipe((0, rxjs_operators.tap)((event) => {
+			const source$ = (0, rxjs.defer)(() => new _ag_ui_client.CompatibilityBoundary().run(input, { run: () => connect ? connect(input, lifecycle) : self.connect(input) })).pipe((0, rxjs_operators.tap)((event) => {
 				if (!isReplaying && event.type === _ag_ui_client.EventType.RUN_ERROR) liveErrors.add(event);
-			}), (0, _ag_ui_client.transformChunks)(self.debugLogger), (0, rxjs_operators.takeUntil)(self.activeRunDetach$));
+			}), (0, _ag_ui_client.transformChunks)(self.debugLogger), (0, rxjs_operators.takeUntil)(activeRunDetach$));
 			const applied$ = self.apply(input, source$, subscribers);
 			await (0, rxjs.lastValueFrom)(self.processApplyEvents(input, applied$, subscribers).pipe((0, rxjs_operators.catchError)((error) => {
+				if (self.activeRunDetach$ !== activeRunDetach$) return rxjs.EMPTY;
 				agent.isRunning = false;
 				if (error instanceof _ag_ui_client.AGUIConnectNotImplementedError) return rxjs.EMPTY;
 				return self.onError(input, error, subscribers);
-			}), (0, rxjs_operators.finalize)(() => {
-				agent.isRunning = false;
-				self.onFinalize(input, subscribers);
-				resolveCompletion === null || resolveCompletion === void 0 || resolveCompletion();
-				resolveCompletion = void 0;
-				self.activeRunCompletionPromise = void 0;
-				self.activeRunDetach$ = void 0;
-			})), { defaultValue: void 0 });
+			}), (0, rxjs_operators.finalize)(() => finalizeRun())), { defaultValue: void 0 });
 			const newMessages = (0, _ag_ui_client.structuredClone_)(agent.messages).filter((m) => !previousMessageIds.has(m.id));
 			return {
 				result,
 				newMessages
 			};
 		} finally {
-			agent.isRunning = false;
+			finalizeRun();
 		}
 	}
 
@@ -635,7 +681,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		observeThreadEvents$(threadId, channel$, options) {
 			return channel$.pipe((0, rxjs_operators.switchMap)(({ channel }) => this.observeChannelEvent$(channel, CLIENT_AG_UI_EVENT)), (0, rxjs_operators.tap)((payload) => {
 				this.updateLastSeenEventId(threadId, payload);
-			}), (0, rxjs_operators.mergeMap)((payload) => this.createThreadNotifications(payload, {
+			}), (0, rxjs_operators.map)((payload) => options.streamMode === "run" ? (0, _copilotkit_shared.stripIntelligenceRoutingFields)(payload) : payload), (0, rxjs_operators.mergeMap)((payload) => this.createThreadNotifications(payload, {
 				completeOnRunError: options.completeOnRunError,
 				completeOnRunFinished: options.streamMode === "run",
 				errorOnRunError: options.streamMode === "run"
@@ -957,6 +1003,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			_defineProperty(this, "_capabilities", void 0);
 			_defineProperty(this, "delegate", void 0);
 			_defineProperty(this, "runtimeInfoPromise", void 0);
+			_defineProperty(this, "connectionAttempt", void 0);
 			_defineProperty(this, "_messageFilter", void 0);
 			_defineProperty(this, "activeRun", void 0);
 			this.runtimeUrl = normalizedRuntimeUrl !== null && normalizedRuntimeUrl !== void 0 ? normalizedRuntimeUrl : config.runtimeUrl;
@@ -1000,13 +1047,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			this.runtimeMode = runtimeMode;
 			this.intelligence = intelligence;
 			if (unchanged) return;
+			this.connectionAttempt = void 0;
 			this.runtimeInfoPromise = void 0;
 			const staleDelegate = this.delegate;
 			this.delegate = void 0;
-			if (staleDelegate) {
-				staleDelegate.abortRun();
-				this.detachActiveRun();
-			}
+			if (staleDelegate) staleDelegate.abortRun();
+			this.detachActiveRun();
 		}
 		/**
 		* The agent id used for outbound runtime requests — `runtimeAgentId` when
@@ -1052,8 +1098,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return (_this$_capabilities = this._capabilities) !== null && _this$_capabilities !== void 0 ? _this$_capabilities : {};
 		}
 		async detachActiveRun() {
-			if (this.delegate) await this.delegate.detachActiveRun();
-			await super.detachActiveRun();
+			var _this$delegate;
+			this.connectionAttempt = void 0;
+			this.isRunning = false;
+			const delegateDetach = (_this$delegate = this.delegate) === null || _this$delegate === void 0 ? void 0 : _this$delegate.detachActiveRun();
+			const proxyDetach = super.detachActiveRun();
+			await Promise.all([delegateDetach, proxyDetach]);
 		}
 		abortRun() {
 			var _this$activeRun;
@@ -1108,41 +1158,74 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			});
 		}
 		async connectAgent(parameters, subscriber) {
+			const detached = this.detachActiveRun();
+			const connection = {};
+			const threadId = this.threadId;
+			this.connectionAttempt = connection;
+			const isCurrentConnection = () => this.connectionAttempt === connection && this.threadId === threadId;
+			await detached;
+			if (!isCurrentConnection()) return {
+				result: void 0,
+				newMessages: []
+			};
+			await this.ensureRuntimeConfiguration();
+			if (!isCurrentConnection()) return {
+				result: void 0,
+				newMessages: []
+			};
 			if (this.runtimeMode !== _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) return ɵconnectWithoutEventVerification(this, parameters, subscriber, (input, lifecycle) => this.connect(input, lifecycle));
-			if (this.delegate) await this.delegate.detachActiveRun();
 			await this.resolveDelegate();
+			if (!isCurrentConnection()) return {
+				result: void 0,
+				newMessages: []
+			};
 			const delegate = this.delegate;
 			const bridgeSub = delegate.subscribe({
 				onMessagesChanged: () => {
+					if (!isCurrentConnection()) return;
 					this.setMessages([...delegate.messages]);
 				},
 				onStateChanged: () => {
+					if (!isCurrentConnection()) return;
 					this.setState({ ...delegate.state });
 				},
 				onRunInitialized: () => {
+					if (!isCurrentConnection()) return;
 					this.isRunning = true;
 				},
 				onRunFinalized: () => {
+					if (!isCurrentConnection()) return;
+					this.pendingInterrupts = (0, _ag_ui_client.structuredClone_)(delegate.pendingInterrupts);
 					this.isRunning = false;
 				},
 				onRunFailed: () => {
+					if (!isCurrentConnection()) return;
 					this.isRunning = false;
 				},
 				onRunErrorEvent: () => {
+					if (!isCurrentConnection()) return;
 					this.isRunning = delegate.isRunning;
 				},
 				onRunStartedEvent: () => {
+					if (!isCurrentConnection()) return;
 					this.isRunning = delegate.isRunning;
 				}
 			});
-			const forwardedSubs = this.subscribers.map((s) => delegate.subscribe(s));
+			const forwardedSubs = [...this.subscribers, ...subscriber ? [subscriber] : []].map((subscriber) => delegate.subscribe(new Proxy(subscriber, { get(target, property, receiver) {
+				const callback = Reflect.get(target, property, receiver);
+				if (typeof callback !== "function") return callback;
+				return (...args) => isCurrentConnection() ? Reflect.apply(callback, target, args) : void 0;
+			} })));
 			try {
-				const result = await delegate.connectAgent(parameters, subscriber);
-				this.setMessages([...delegate.messages]);
-				this.setState({ ...delegate.state });
+				const result = await delegate.connectAgent(parameters);
+				if (isCurrentConnection()) {
+					this.setMessages([...delegate.messages]);
+					this.setState({ ...delegate.state });
+					this.pendingInterrupts = (0, _ag_ui_client.structuredClone_)(delegate.pendingInterrupts);
+				}
 				return result;
 			} finally {
-				this.isRunning = false;
+				if (isCurrentConnection()) this.isRunning = false;
 				bridgeSub.unsubscribe();
 				for (const sub of forwardedSubs) sub.unsubscribe();
 			}
@@ -1177,6 +1260,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			cloned.threadId = this.threadId;
 			cloned.setState(this.state);
 			cloned.setMessages(this.messages);
+			cloned.pendingInterrupts = (0, _ag_ui_client.structuredClone_)(this.pendingInterrupts);
 			if (this.delegate) {
 				const clonedDelegate = this.delegate.clone();
 				cloned.delegate = clonedDelegate;
@@ -1218,6 +1302,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			if (!this.runtimeUrl) throw new Error("Runtime URL is not set");
 			const runtimeInfoPromise = (_this$runtimeInfoProm = this.runtimeInfoPromise) !== null && _this$runtimeInfoProm !== void 0 ? _this$runtimeInfoProm : this.fetchRuntimeInfo().then((runtimeInfo) => {
 				var _runtimeInfo$mode;
+				if (this.runtimeInfoPromise !== runtimeInfoPromise) return;
 				this.runtimeMode = (_runtimeInfo$mode = runtimeInfo.mode) !== null && _runtimeInfo$mode !== void 0 ? _runtimeInfo$mode : _copilotkit_shared.RUNTIME_MODE_SSE;
 				this.intelligence = runtimeInfo.intelligence;
 			});
@@ -1325,6 +1410,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			delegate.debugLogger = this.debugLogger;
 			delegate.setMessages(this.messages);
 			delegate.setState(this.state);
+			delegate.pendingInterrupts = (0, _ag_ui_client.structuredClone_)(this.pendingInterrupts);
 			if (hasHeaders(delegate)) delegate.headers = { ...this.headers };
 			if (hasCredentials(delegate)) delegate.credentials = this.credentials;
 		}
@@ -1385,14 +1471,31 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		const input = _assertClassBrand(_ProxiedCopilotRuntimeAgent_brand, this, _applyMessageFilter).call(this, unfiltered);
 		this.activeRun = void 0;
 		const routedId = this.routedAgentId();
+		let httpEvents;
 		if (this.transport === "single") {
 			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
 			const requestInit = this.createSingleRouteRequestInit(input, "agent/connect", { agentId: routedId });
-			return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(() => this.fetch(this.singleEndpointUrl, requestInit))));
-		}
-		const connectUrl = `${this.runtimeUrl}/agent/${routedId}/connect`;
-		const connectRequestInit = this.requestInit(input);
-		return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(() => this.fetch(connectUrl, connectRequestInit))));
+			httpEvents = (0, _ag_ui_client.runHttpRequest)(() => this.fetch(this.singleEndpointUrl, requestInit));
+		} else {
+			const connectUrl = `${this.runtimeUrl}/agent/${routedId}/connect`;
+			const connectRequestInit = this.requestInit(input);
+			httpEvents = (0, _ag_ui_client.runHttpRequest)(() => this.fetch(connectUrl, connectRequestInit));
+		}
+		return withAbortErrorHandling((0, rxjs.defer)(() => {
+			let replayStarted = false;
+			const emptyHistory = [{
+				type: _ag_ui_client.EventType.MESSAGES_SNAPSHOT,
+				messages: []
+			}, {
+				type: _ag_ui_client.EventType.STATE_SNAPSHOT,
+				snapshot: {}
+			}];
+			return (0, _ag_ui_client.transformHttpEventStream)(httpEvents).pipe((0, rxjs_operators.concatMap)((event) => {
+				if (replayStarted) return (0, rxjs.of)(event);
+				replayStarted = true;
+				return (0, rxjs.from)([...emptyHistory, event]);
+			}), (0, rxjs_operators.concatWith)((0, rxjs.defer)(() => replayStarted ? rxjs.EMPTY : (0, rxjs.from)(emptyHistory))));
+		}));
 	}
 	function _runViaDelegate(input) {
 		return (0, rxjs.defer)(() => (0, rxjs.from)(this.resolveDelegate())).pipe((0, rxjs_operators.switchMap)((delegate) => withAbortErrorHandling(delegate.run(input))));
@@ -1840,7 +1943,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		* because only `HttpAgent` carries a `headers` field. See #5635.
 		*/
 		applyHeadersToAgent(agent) {
-			if (agent instanceof _ag_ui_client.HttpAgent) {
+			if (ɵisHttpAgent(agent)) {
 				if (!this.agentOwnHeaders.has(agent)) this.agentOwnHeaders.set(agent, { ...agent.headers });
 				agent.headers = {
 					...this.agentOwnHeaders.get(agent),
@@ -1912,6 +2015,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				this.applyMessageFilterToAgent(agent);
 			});
 		}
+		/** Preserve the exact configured URL when posting to a single endpoint. */
+		get runtimeEndpointUrl() {
+			return this._runtimeEndpointUrl;
+		}
 		createRuntimeFetch() {
 			if (!this.runtimeFetch) this.runtimeFetch = (async (input, init) => {
 				const meta = () => runtimeRequestMeta(init);
@@ -2977,6 +3084,68 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	function isForwardedToClientPlaceholder(content) {
 		return normalizeToolResultContent(content) === FORWARDED_TO_CLIENT;
 	}
+	const MEDIA_PART_TYPES = new Set([
+		"image",
+		"audio",
+		"video",
+		"document"
+	]);
+	function isOptionalString(value) {
+		return value === void 0 || typeof value === "string";
+	}
+	function isPartSource(value) {
+		if (!value || typeof value !== "object") return false;
+		const source = value;
+		if (typeof source.value !== "string") return false;
+		switch (source.type) {
+			case "data": return typeof source.mimeType === "string";
+			case "url": return isOptionalString(source.mimeType);
+			case "file": return isOptionalString(source.provider) && isOptionalString(source.mimeType);
+			default: return false;
+		}
+	}
+	/**
+	* Mirrors `ContentPartSchema` from `@ag-ui/core/schemas`. The runtime parses
+	* the request with that schema, and one invalid part there fails the whole run.
+	* Core does not import the schema because the UMD build has no global for it.
+	* A test checks this function against the schema.
+	*/
+	function isContentPart(value) {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+		const part = value;
+		if (!isOptionalString(part.id) || part.metadata === null) return false;
+		if (part.type === "text") return typeof part.text === "string";
+		return typeof part.type === "string" && MEDIA_PART_TYPES.has(part.type) && isPartSource(part.source);
+	}
+	/**
+	* Converts what a frontend tool handler returned into tool message content.
+	* A non-empty array of AG-UI content parts passes through unchanged, so an
+	* image reaches the model as media. Everything else becomes a string, as before.
+	*
+	* `text` is the string form, for surfaces typed as `result: string`
+	* (`runTool`, `onToolExecutionEnd`). For content parts it is the JSON text they
+	* received before. It is computed here, so a part that cannot be serialized
+	* throws inside the caller's handler error boundary.
+	*/
+	function toToolResultContent(result) {
+		if (result === void 0 || result === null) return {
+			content: "",
+			text: ""
+		};
+		if (typeof result === "string") return {
+			content: result,
+			text: result
+		};
+		const text = JSON.stringify(result);
+		if (Array.isArray(result) && result.length > 0 && result.every(isContentPart)) return {
+			content: result,
+			text
+		};
+		return {
+			content: text,
+			text
+		};
+	}
 
 //#endregion
 //#region src/core/tool-schema.ts
@@ -3166,6 +3335,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			_defineProperty(this, "_runDepth", 0);
 			_defineProperty(this, "_webmcpRegistry", new WebMCPRegistry());
 			_defineProperty(this, "_lastConnectedThreadIdsByAgent", /* @__PURE__ */ new Map());
+			_defineProperty(this, "_lastActiveThreadIdsByAgent", /* @__PURE__ */ new Map());
 			_defineProperty(this, "_anonymousAgentIds", /* @__PURE__ */ new WeakMap());
 			_defineProperty(this, "_nextAnonymousAgentId", 0);
 			_defineProperty(this, "_executingToolCalls", /* @__PURE__ */ new WeakMap());
@@ -3342,7 +3512,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		*/
 		async connectAgent({ agent }) {
 			var _agent$threadId;
-			this._connectionGenerations.set(agent, {});
+			const connection = {};
+			this._connectionGenerations.set(agent, connection);
 			const incomingThreadId = (_agent$threadId = agent.threadId) !== null && _agent$threadId !== void 0 ? _agent$threadId : null;
 			const previousReplay = this._interactionAbortControllers.get(agent);
 			if (previousReplay && previousReplay.threadId !== incomingThreadId) {
@@ -3351,14 +3522,21 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				this._executingToolCalls.delete(agent);
 			}
 			try {
-				var _this$_lastConnectedT, _agent$threadId2, _this$_interactionAbo;
+				var _ref, _agent$threadId2, _agent$threadId3, _agent$threadId4, _this$_interactionAbo;
 				const restoreKey = this.getConnectRestoreKey(agent);
-				const isFreshRestore = incomingThreadId !== ((_this$_lastConnectedT = this._lastConnectedThreadIdsByAgent.get(restoreKey)) !== null && _this$_lastConnectedT !== void 0 ? _this$_lastConnectedT : null);
-				this._lastConnectedThreadIdsByAgent.set(restoreKey, incomingThreadId);
+				const previousThreadId = this._lastActiveThreadIdsByAgent.get(restoreKey);
+				const isFreshRestore = incomingThreadId !== ((_ref = previousThreadId !== null && previousThreadId !== void 0 ? previousThreadId : this._lastConnectedThreadIdsByAgent.get(restoreKey)) !== null && _ref !== void 0 ? _ref : null);
 				await agent.detachActiveRun();
+				if (this._connectionGenerations.get(agent) !== connection || ((_agent$threadId2 = agent.threadId) !== null && _agent$threadId2 !== void 0 ? _agent$threadId2 : null) !== incomingThreadId) return {
+					result: void 0,
+					newMessages: []
+				};
+				this._lastConnectedThreadIdsByAgent.set(restoreKey, incomingThreadId);
+				this._lastActiveThreadIdsByAgent.set(restoreKey, incomingThreadId);
 				if (isFreshRestore) {
 					agent.setMessages([]);
 					agent.setState({});
+					if (previousThreadId !== void 0 && previousThreadId !== incomingThreadId) agent.pendingInterrupts = [];
 					const cursorAware = agent;
 					if (incomingThreadId) {
 						if (typeof cursorAware.clearReplayCursor === "function") cursorAware.clearReplayCursor(incomingThreadId);
@@ -3373,12 +3551,16 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 						agent
 					});
 				}, "Subscriber onAgentRunStarted error:");
+				if (this._connectionGenerations.get(agent) !== connection || ((_agent$threadId3 = agent.threadId) !== null && _agent$threadId3 !== void 0 ? _agent$threadId3 : null) !== incomingThreadId) return {
+					result: void 0,
+					newMessages: []
+				};
 				const runAgentResult = await agent.connectAgent({
 					forwardedProps: this._internal.properties,
 					tools: this.buildFrontendTools(agent.agentId),
 					context: this._internal.getContextForAgent(agent.agentId)
 				}, this.createAgentErrorSubscriber(agent));
-				if (((_agent$threadId2 = agent.threadId) !== null && _agent$threadId2 !== void 0 ? _agent$threadId2 : null) !== incomingThreadId) return runAgentResult;
+				if (this._connectionGenerations.get(agent) !== connection || ((_agent$threadId4 = agent.threadId) !== null && _agent$threadId4 !== void 0 ? _agent$threadId4 : null) !== incomingThreadId) return runAgentResult;
 				const controller = new AbortController();
 				const replay = (_this$_interactionAbo = this._interactionAbortControllers.get(agent)) !== null && _this$_interactionAbo !== void 0 ? _this$_interactionAbo : {
 					threadId: incomingThreadId,
@@ -3435,6 +3617,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				continuationHandoff === null || continuationHandoff === void 0 || continuationHandoff.cancel();
 				throw error;
 			}
+			const resumedRunId = this._internal.stateManager.getContinuationRunId(agent, {
+				threadId: agent.threadId,
+				resume,
+				forwardedProps
+			});
+			const logicalHandoff = continuationHandoff !== null && continuationHandoff !== void 0 ? continuationHandoff : resumedRunId ? this._internal.stateManager.markNextRunAsContinuation(agent, resumedRunId) : void 0;
 			const isTopLevel = this._runDepth === 0;
 			let originalAbortRun;
 			if (isTopLevel) {
@@ -3455,18 +3643,19 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			}
 			this._runDepth++;
 			try {
-				let logicalRunId = runId;
+				let logicalRunId = resumedRunId !== null && resumedRunId !== void 0 ? resumedRunId : runId;
 				const agentSubscriber = this.createAgentErrorSubscriber(agent);
 				let started = false;
 				const onRunStartedEvent = agentSubscriber.onRunStartedEvent;
 				const onRunInitialized = agentSubscriber.onRunInitialized;
 				agentSubscriber.onRunInitialized = async (params) => {
-					continuationHandoff === null || continuationHandoff === void 0 || continuationHandoff.bind(params.input);
+					this._lastActiveThreadIdsByAgent.set(this.getConnectRestoreKey(agent), params.input.threadId);
+					logicalHandoff === null || logicalHandoff === void 0 || logicalHandoff.bind(params.input);
 					return onRunInitialized === null || onRunInitialized === void 0 ? void 0 : onRunInitialized(params);
 				};
 				agentSubscriber.onRunStartedEvent = async (params) => {
 					started = true;
-					if (!continuationHandoff) logicalRunId = params.input.runId;
+					if (!logicalHandoff) logicalRunId = params.input.runId;
 					return onRunStartedEvent === null || onRunStartedEvent === void 0 ? void 0 : onRunStartedEvent(params);
 				};
 				const pinRunIdOnWire = runId !== void 0 && !continuationHandoff;
@@ -3481,14 +3670,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					context: this._internal.getContextForAgent(agent.agentId)
 				};
 				const runAgentResult = await agent.runAgent(agentRunInput, agentSubscriber);
-				if (!started) continuationHandoff === null || continuationHandoff === void 0 || continuationHandoff.cancel();
+				if (!started) logicalHandoff === null || logicalHandoff === void 0 || logicalHandoff.cancel();
 				return await this.processAgentResult({
 					runAgentResult,
 					agent,
 					runId: logicalRunId
 				});
 			} catch (error) {
-				continuationHandoff === null || continuationHandoff === void 0 || continuationHandoff.cancel();
+				logicalHandoff === null || logicalHandoff === void 0 || logicalHandoff.cancel();
 				const runError = error instanceof Error ? error : new Error(String(error));
 				const context = {};
 				if (agent.agentId) context.agentId = agent.agentId;
@@ -3619,6 +3808,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return (_this$_runAbortContro3 = this._runAbortController) === null || _this$_runAbortContro3 === void 0 ? void 0 : _this$_runAbortContro3.signal;
 		})(), discardOnAbort = false }) {
 			let toolCallResult = "";
+			let toolCallText = "";
 			let errorMessage;
 			let isArgumentError = false;
 			let parsedArgs;
@@ -3657,9 +3847,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					agent,
 					signal
 				});
-				if (result === void 0 || result === null) toolCallResult = "";
-				else if (typeof result === "string") toolCallResult = result;
-				else toolCallResult = JSON.stringify(result);
+				({content: toolCallResult, text: toolCallText} = toToolResultContent(result));
 			} catch (error) {
 				const handlerError = error instanceof Error ? error : new Error(String(error));
 				errorMessage = handlerError.message;
@@ -3676,7 +3864,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					}
 				});
 			}
-			if (errorMessage) toolCallResult = `Error: ${errorMessage}`;
+			if (errorMessage) toolCallResult = toolCallText = `Error: ${errorMessage}`;
 			await this._internal.notifySubscribers((subscriber) => {
 				var _subscriber$onToolExe2;
 				return (_subscriber$onToolExe2 = subscriber.onToolExecutionEnd) === null || _subscriber$onToolExe2 === void 0 ? void 0 : _subscriber$onToolExe2.call(subscriber, {
@@ -3684,12 +3872,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					toolCallId: toolCall.id,
 					agentId,
 					toolName: toolCall.function.name,
-					result: errorMessage ? "" : toolCallResult,
+					result: errorMessage ? "" : toolCallText,
 					error: errorMessage
 				});
 			}, "Subscriber onToolExecutionEnd error:");
 			return {
-				result: toolCallResult,
+				content: toolCallResult,
+				result: toolCallText,
 				error: errorMessage,
 				isArgumentError
 			};
@@ -3701,6 +3890,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			const threadId = agent.threadId;
 			if ((tool === null || tool === void 0 ? void 0 : tool.agentId) && tool.agentId !== agent.agentId) return false;
 			let handlerResult = {
+				content: "",
 				result: "",
 				error: void 0,
 				isArgumentError: false
@@ -3726,7 +3916,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					id: (0, _copilotkit_shared.randomUUID)(),
 					role: "tool",
 					toolCallId: toolCall.id,
-					content: handlerResult.result
+					content: handlerResult.content
 				};
 				agent.messages.splice(insertAt, 0, toolMessage);
 				if (!handlerResult.error && (tool === null || tool === void 0 ? void 0 : tool.followUp) !== false) return true;
@@ -3743,6 +3933,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			const threadId = agent.threadId;
 			if ((wildcardTool === null || wildcardTool === void 0 ? void 0 : wildcardTool.agentId) && wildcardTool.agentId !== agent.agentId) return false;
 			let toolCallResult = "";
+			let toolCallText = "";
 			let errorMessage;
 			if (wildcardTool === null || wildcardTool === void 0 ? void 0 : wildcardTool.handler) {
 				let parsedArgs;
@@ -3784,9 +3975,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 						agent,
 						signal
 					});
-					if (result === void 0 || result === null) toolCallResult = "";
-					else if (typeof result === "string") toolCallResult = result;
-					else toolCallResult = JSON.stringify(result);
+					({content: toolCallResult, text: toolCallText} = toToolResultContent(result));
 				} catch (error) {
 					const handlerError = error instanceof Error ? error : new Error(String(error));
 					errorMessage = handlerError.message;
@@ -3803,7 +3992,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 						}
 					});
 				}
-				if (errorMessage) toolCallResult = `Error: ${errorMessage}`;
+				if (errorMessage) toolCallResult = toolCallText = `Error: ${errorMessage}`;
 				await this._internal.notifySubscribers((subscriber) => {
 					var _subscriber$onToolExe4;
 					return (_subscriber$onToolExe4 = subscriber.onToolExecutionEnd) === null || _subscriber$onToolExe4 === void 0 ? void 0 : _subscriber$onToolExe4.call(subscriber, {
@@ -3811,7 +4000,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 						toolCallId: toolCall.id,
 						agentId,
 						toolName: toolCall.function.name,
-						result: errorMessage ? "" : toolCallResult,
+						result: errorMessage ? "" : toolCallText,
 						error: errorMessage
 					});
 				}, "Subscriber onToolExecutionEnd error:");
@@ -3884,6 +4073,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			};
 			agent.messages.push(assistantMessage);
 			let handlerResult = {
+				content: "",
 				result: "",
 				error: void 0,
 				isArgumentError: false
@@ -3900,7 +4090,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				id: (0, _copilotkit_shared.randomUUID)(),
 				role: "tool",
 				toolCallId,
-				content: handlerResult.result
+				content: handlerResult.content
 			};
 			const assistantIndex = agent.messages.findIndex((m) => m.id === assistantMessage.id);
 			if (assistantIndex !== -1) agent.messages.splice(assistantIndex + 1, 0, toolResultMessage);
@@ -4057,6 +4247,15 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	* Tracks agent state snapshots and message-to-run associations.
 	*/
 	var StateManager = class {
+		/** Find the interrupted logical run without consuming its pending answers. */
+		getContinuationRunId(agent, input) {
+			var _this$interruptedRuns, _input$resume, _input$resume2;
+			const pending = (_this$interruptedRuns = this.interruptedRuns.get(agent)) === null || _this$interruptedRuns === void 0 ? void 0 : _this$interruptedRuns.get(input.threadId);
+			if (!pending) return void 0;
+			if (pending.interruptIds === null) return input.resume === void 0 && isContinuation(input) ? pending.runId : void 0;
+			const submitted = new Set((_input$resume = input.resume) === null || _input$resume === void 0 ? void 0 : _input$resume.map((entry) => entry.interruptId));
+			return submitted.size > 0 && submitted.size === ((_input$resume2 = input.resume) === null || _input$resume2 === void 0 ? void 0 : _input$resume2.length) && submitted.size === pending.interruptIds.length && pending.interruptIds.every((id) => submitted.has(id)) ? pending.runId : void 0;
+		}
 		constructor(core) {
 			this.core = core;
 			_defineProperty(this, "stateByRun", /* @__PURE__ */ new Map());
@@ -4065,6 +4264,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			_defineProperty(this, "activeRun", /* @__PURE__ */ new Map());
 			_defineProperty(this, "agentSubscriptions", /* @__PURE__ */ new Map());
 			_defineProperty(this, "pendingContinuations", /* @__PURE__ */ new WeakMap());
+			_defineProperty(this, "interruptedRuns", /* @__PURE__ */ new WeakMap());
 		}
 		/**
 		* Initialize state tracking for an agent
@@ -4106,6 +4306,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			}
 			let revoked = false;
 			let subRunId;
+			let legacyInterrupted = false;
 			let runFinished = false;
 			const pendingResults = /* @__PURE__ */ new WeakMap();
 			const reconcilePendingResults = (historyMessages, input) => {
@@ -4184,27 +4385,52 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			};
 			const { unsubscribe } = agent.subscribe({
 				onRunStartedEvent: ({ event, input, state }) => {
+					var _event$input, _this$interruptedRuns2;
 					if (revoked) return;
 					const pendingForAgent = this.pendingContinuations.get(agent);
 					const internalContinuation = [...pendingForAgent !== null && pendingForAgent !== void 0 ? pendingForAgent : []].find((pending) => pending.expectedInput === input);
 					internalContinuation === null || internalContinuation === void 0 || internalContinuation.cancel();
+					const startedInput = (_event$input = event.input) !== null && _event$input !== void 0 ? _event$input : {
+						...input,
+						threadId: event.threadId
+					};
+					const resumedRunId = this.getContinuationRunId(agent, startedInput);
+					(_this$interruptedRuns2 = this.interruptedRuns.get(agent)) === null || _this$interruptedRuns2 === void 0 || _this$interruptedRuns2.delete(startedInput.threadId);
+					legacyInterrupted = false;
 					if (internalContinuation) {
 						var _ref, _internalContinuation;
 						subRunId = (_ref = (_internalContinuation = internalContinuation.expectedRunId) !== null && _internalContinuation !== void 0 ? _internalContinuation : event.runId) !== null && _ref !== void 0 ? _ref : input.runId;
-					} else if (runFinished && input.runId === subRunId && !isContinuation(input) && (event.runId == null || event.runId === subRunId)) subRunId = (0, _ag_ui_client.randomUUID)();
+					} else if (resumedRunId) subRunId = resumedRunId;
+					else if (runFinished && input.runId === subRunId && !isContinuation(input) && (event.runId == null || event.runId === subRunId)) subRunId = (0, _ag_ui_client.randomUUID)();
 					else subRunId = event.runId || input.runId;
 					runFinished = false;
 					this.handleRunStarted(agent, effectiveInput(input), state);
 				},
-				onRunFinishedEvent: ({ input, state, messages }) => {
+				onRunFinishedEvent: ({ event, input, state, messages }) => {
+					var _event$outcome;
 					if (revoked) return;
 					runFinished = true;
 					const effective = effectiveInput(input);
+					let interrupted = this.interruptedRuns.get(agent);
+					if (((_event$outcome = event.outcome) === null || _event$outcome === void 0 ? void 0 : _event$outcome.type) === "interrupt" || legacyInterrupted) {
+						var _event$outcome2;
+						if (!interrupted) {
+							interrupted = /* @__PURE__ */ new Map();
+							this.interruptedRuns.set(agent, interrupted);
+						}
+						interrupted.set(event.threadId, {
+							runId: effective.runId,
+							interruptIds: ((_event$outcome2 = event.outcome) === null || _event$outcome2 === void 0 ? void 0 : _event$outcome2.type) === "interrupt" ? event.outcome.interrupts.map((interrupt) => interrupt.id) : null
+						});
+					} else interrupted === null || interrupted === void 0 || interrupted.delete(event.threadId);
 					const mutation = reconcilePendingResults(messages, input);
 					clearPendingResults(input);
 					this.handleRunFinished(agent, effective, state);
 					return mutation;
 				},
+				onCustomEvent: ({ event }) => {
+					if (!revoked && event.name === "on_interrupt") legacyInterrupted = true;
+				},
 				onRunErrorEvent: ({ input, state, messages }) => {
 					if (revoked) return;
 					runFinished = true;
@@ -4261,6 +4487,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				unsubscribe: () => {
 					revoked = true;
 					this.pendingContinuations.delete(agent);
+					this.interruptedRuns.delete(agent);
 					unsubscribe();
 				}
 			});
@@ -4435,6 +4662,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		* Clear all state for an agent
 		*/
 		clearAgentState(agentId) {
+			var _this$agentSubscripti;
+			const agent = (_this$agentSubscripti = this.agentSubscriptions.get(agentId)) === null || _this$agentSubscripti === void 0 ? void 0 : _this$agentSubscripti.agent;
+			if (agent) this.interruptedRuns.delete(agent);
 			this.stateByRun.delete(agentId);
 			this.messageToRun.delete(agentId);
 			this.rawEventByMessage.delete(agentId);
@@ -4443,7 +4673,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		* Clear all state for a thread
 		*/
 		clearThreadState(agentId, threadId) {
-			var _this$stateByRun$get4, _this$messageToRun$ge2, _this$rawEventByMessa8;
+			var _this$agentSubscripti2, _this$interruptedRuns3, _this$stateByRun$get4, _this$messageToRun$ge2, _this$rawEventByMessa8;
+			const agent = (_this$agentSubscripti2 = this.agentSubscriptions.get(agentId)) === null || _this$agentSubscripti2 === void 0 ? void 0 : _this$agentSubscripti2.agent;
+			if (agent) (_this$interruptedRuns3 = this.interruptedRuns.get(agent)) === null || _this$interruptedRuns3 === void 0 || _this$interruptedRuns3.delete(threadId);
 			(_this$stateByRun$get4 = this.stateByRun.get(agentId)) === null || _this$stateByRun$get4 === void 0 || _this$stateByRun$get4.delete(threadId);
 			(_this$messageToRun$ge2 = this.messageToRun.get(agentId)) === null || _this$messageToRun$ge2 === void 0 || _this$messageToRun$ge2.delete(threadId);
 			(_this$rawEventByMessa8 = this.rawEventByMessage.get(agentId)) === null || _this$rawEventByMessa8 === void 0 || _this$rawEventByMessa8.delete(threadId);
@@ -4511,6 +4743,745 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		}
 	};
 
+//#endregion
+//#region src/core/trajectory-connection.ts
+	const TIMEOUT_MS = 1e4;
+	const BATCH_INTERVAL_MS = 2e3;
+	const MAX_BATCH_EVENTS = 50;
+	const MAX_BATCH_BYTES = 64 * 1024;
+	const MAX_EVENT_BYTES = 16 * 1024;
+	const byteLength = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+	const reconnectDelay = (0, _copilotkit_shared.phoenixExponentialBackoff)(1e3, 1e4);
+	function isObject(value) {
+		return typeof value === "object" && value !== null;
+	}
+	function isNonNegativeInteger(value) {
+		return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+	}
+	function isBatchAcknowledgement(value, eventCount) {
+		return isObject(value) && isNonNegativeInteger(value.accepted) && isNonNegativeInteger(value.rejected) && value.accepted + value.rejected === eventCount && (value.highestSeq === null || isNonNegativeInteger(value.highestSeq)) && (value.accepted === 0 || value.highestSeq !== null);
+	}
+	function isGrant(value) {
+		return isObject(value) && typeof value.joinToken === "string" && value.joinToken.length > 0 && isObject(value.realtime) && typeof value.realtime.clientUrl === "string" && value.realtime.clientUrl.length > 0 && typeof value.realtime.topic === "string" && value.realtime.topic.length > 0;
+	}
+	function errorCode(value, fallback) {
+		return isObject(value) && typeof value.code === "string" && /^[A-Z][A-Z0-9_]{0,63}$/.test(value.code) ? value.code : fallback;
+	}
+	/** Owns bounded, connected-only capture batches. Failed batches are never resent. */
+	var TrajectoryConnection = class {
+		constructor(core, onChange) {
+			this.core = core;
+			this.onChange = onChange;
+			_defineProperty(this, "session", void 0);
+			_defineProperty(this, "nextSeq", Math.floor(Date.now()) * 1e3);
+		}
+		get trajectoryId() {
+			var _this$session;
+			return ((_this$session = this.session) === null || _this$session === void 0 ? void 0 : _this$session.ready) ? this.session.trajectoryId : null;
+		}
+		start(trajectoryId, config) {
+			if (this.session && (trajectoryId === void 0 || trajectoryId === this.session.trajectoryId)) return this.session.promise;
+			this.stop();
+			const id = trajectoryId !== null && trajectoryId !== void 0 ? trajectoryId : crypto.randomUUID();
+			let resolveStart;
+			const promise = new Promise((resolve) => {
+				resolveStart = resolve;
+			});
+			const session = {
+				trajectoryId: id,
+				config,
+				promise,
+				resolve: resolveStart,
+				retries: 0,
+				queue: [],
+				dropped: 0,
+				ready: false,
+				started: false,
+				offline: typeof navigator !== "undefined" && navigator.onLine === false,
+				onOffline: () => {
+					if (this.session !== session) return;
+					session.offline = true;
+					if (session.connection) this.fail(session, session.connection, "CONNECTION_LOST");
+					clearTimeout(session.retry);
+					session.retry = void 0;
+				},
+				onOnline: () => {
+					if (this.session !== session) return;
+					session.offline = false;
+					if (!session.connection) {
+						clearTimeout(session.retry);
+						session.retry = void 0;
+						this.connect(session);
+					}
+				}
+			};
+			this.session = session;
+			if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+				window.addEventListener("offline", session.onOffline);
+				window.addEventListener("online", session.onOnline);
+			}
+			if (session.offline) {
+				this.report(session, "CONNECTION_LOST");
+				this.end(session, {
+					status: "error",
+					code: "CONNECTION_LOST"
+				});
+			} else this.connect(session);
+			return promise;
+		}
+		stop() {
+			const session = this.session;
+			if (!session) return;
+			if (session.ready && session.connection) this.flush(session, session.connection);
+			this.end(session, {
+				status: "error",
+				code: "CANCELLED"
+			});
+		}
+		emit(name, value) {
+			var _session$collector;
+			const session = this.session;
+			if (session === null || session === void 0 ? void 0 : session.ready) (_session$collector = session.collector) === null || _session$collector === void 0 || _session$collector.emit(name, value);
+			else if (session === null || session === void 0 ? void 0 : session.started) this.addDropped(session, 1, false);
+		}
+		report(session, code) {
+			try {
+				var _session$config$onErr, _session$config;
+				(_session$config$onErr = (_session$config = session.config).onError) === null || _session$config$onErr === void 0 || _session$config$onErr.call(_session$config, {
+					code,
+					message: `Trajectory capture: ${code}.`
+				});
+			} catch (_unused) {}
+		}
+		current(session, connection) {
+			return this.session === session && session.connection === connection;
+		}
+		end(session, result) {
+			var _session$collector2;
+			if (this.session !== session) return;
+			this.session = void 0;
+			clearTimeout(session.retry);
+			(_session$collector2 = session.collector) === null || _session$collector2 === void 0 || _session$collector2.stop();
+			session.ready = false;
+			if (session.queue.length > 0) this.report(session, "EVENTS_DROPPED");
+			this.discardQueue(session);
+			if (session.connection) {
+				for (const pending of session.connection.pending) {
+					pending.finish("PERSISTENCE_UNKNOWN");
+					this.report(session, "PERSISTENCE_UNKNOWN");
+				}
+				this.cleanup(session, session.connection);
+			}
+			if (typeof window !== "undefined" && typeof window.removeEventListener === "function") {
+				window.removeEventListener("offline", session.onOffline);
+				window.removeEventListener("online", session.onOnline);
+			}
+			session.resolve(result);
+			this.onChange();
+		}
+		cleanup(session, connection) {
+			session.connection = void 0;
+			clearTimeout(connection.timer);
+			connection.abort.abort();
+			for (const pending of connection.pending) clearTimeout(pending.timer);
+			connection.pending.clear();
+			const { socket, channel } = connection;
+			try {
+				if (channel) {
+					for (const [event, ref] of connection.channelRefs) channel.off(event, ref);
+					channel.leave();
+				}
+			} finally {
+				if (socket) {
+					socket.off(connection.socketRefs);
+					socket.disconnect();
+				}
+			}
+		}
+		fail(session, connection, code, retryable = true) {
+			var _session$collector3;
+			if (!this.current(session, connection)) return;
+			(_session$collector3 = session.collector) === null || _session$collector3 === void 0 || _session$collector3.stop();
+			session.collector = void 0;
+			if (session.ready && session.started) session.promise = new Promise((resolve) => {
+				session.resolve = resolve;
+			});
+			session.ready = false;
+			this.discardQueue(session);
+			for (const pending of connection.pending) pending.finish("PERSISTENCE_UNKNOWN");
+			if (!this.current(session, connection)) return;
+			this.cleanup(session, connection);
+			this.onChange();
+			this.report(session, code);
+			if (this.session !== session) return;
+			if (!session.started || !retryable) {
+				this.end(session, {
+					status: "error",
+					code
+				});
+				return;
+			}
+			if (session.offline || this.session !== session) return;
+			session.retry = setTimeout(() => {
+				session.retry = void 0;
+				if (this.session === session && !session.offline) this.connect(session);
+			}, reconnectDelay(++session.retries));
+		}
+		async connect(session) {
+			if (this.session !== session || session.offline || session.connection) return;
+			const connection = {
+				abort: new AbortController(),
+				socketRefs: [],
+				channelRefs: [],
+				pending: /* @__PURE__ */ new Set()
+			};
+			session.connection = connection;
+			connection.timer = setTimeout(() => this.fail(session, connection, "CONNECTION_TIMEOUT"), TIMEOUT_MS);
+			try {
+				var _this$core$ɵruntimeE;
+				const runtimeUrl = this.core.runtimeUrl;
+				if (!runtimeUrl) {
+					this.fail(session, connection, "RUNTIME_REQUIRED", false);
+					return;
+				}
+				let transport = this.core.runtimeTransport;
+				if (transport === "auto") {
+					transport = await this.detectedTransport(connection.abort.signal);
+					if (!this.current(session, connection)) return;
+				}
+				const rest = transport === "rest";
+				const response = await fetch(rest ? `${runtimeUrl}/trajectory/${encodeURIComponent(session.trajectoryId)}/connect` : (_this$core$ɵruntimeE = this.core.ɵruntimeEndpointUrl) !== null && _this$core$ɵruntimeE !== void 0 ? _this$core$ɵruntimeE : runtimeUrl, {
+					method: "POST",
+					redirect: "error",
+					signal: connection.abort.signal,
+					headers: {
+						...this.core.headers,
+						"Content-Type": "application/json"
+					},
+					credentials: this.core.credentials,
+					body: JSON.stringify(rest ? {} : {
+						method: "trajectory/connect",
+						params: { trajectoryId: session.trajectoryId },
+						body: {}
+					})
+				});
+				if (!this.current(session, connection)) return;
+				const payload = await response.json().catch(() => void 0);
+				if (!this.current(session, connection)) return;
+				if (!response.ok) {
+					this.fail(session, connection, errorCode(payload, "CONNECTION_FAILED"), response.status >= 500 || response.status === 408 || response.status === 429);
+					return;
+				}
+				if (!isGrant(payload)) {
+					this.fail(session, connection, "INVALID_GRANT", false);
+					return;
+				}
+				const socket = new phoenix.Socket(payload.realtime.clientUrl, {
+					params: { join_token: payload.joinToken },
+					timeout: TIMEOUT_MS
+				});
+				connection.socket = socket;
+				const lost = () => this.fail(session, connection, "CONNECTION_LOST");
+				connection.socketRefs.push(socket.onError(lost), socket.onClose(lost));
+				const channel = socket.channel(payload.realtime.topic, {});
+				connection.channel = channel;
+				connection.channelRefs.push(["phx_error", channel.onError(lost)], ["phx_close", channel.onClose(lost)]);
+				socket.connect();
+				if (!this.current(session, connection)) return;
+				channel.join(TIMEOUT_MS).receive("ok", () => {
+					if (!this.current(session, connection)) return;
+					try {
+						var _session$config$ignor;
+						clearTimeout(connection.timer);
+						session.ready = true;
+						session.retries = 0;
+						session.collector = (0, _copilotkit_learning.createTrajectoryCollector)({
+							...session.config,
+							ignoreUrls: [
+								...(_session$config$ignor = session.config.ignoreUrls) !== null && _session$config$ignor !== void 0 ? _session$config$ignor : [],
+								...this.core.runtimeUrl ? [this.core.runtimeUrl] : [],
+								...this.core.ɵruntimeEndpointUrl ? [this.core.ɵruntimeEndpointUrl] : [],
+								"https://telemetry.copilotkit.ai/",
+								"https://cdn.copilotkit.ai/"
+							],
+							onError: (error) => {
+								if (error.code === "CAPTURE_FAILED") this.fail(session, connection, error.code, false);
+								else {
+									var _session$config$onErr2, _session$config2;
+									if (error.code === "INVALID_EVENT" || error.code === "EVENT_TOO_LARGE") this.addDropped(session, 1);
+									(_session$config$onErr2 = (_session$config2 = session.config).onError) === null || _session$config$onErr2 === void 0 || _session$config$onErr2.call(_session$config2, error);
+								}
+							},
+							send: (event) => this.send(session, connection, event)
+						});
+						session.collector.start();
+						if (!this.current(session, connection)) return;
+						if (session.dropped > 0) this.scheduleFlush(session, connection);
+						session.started = true;
+						session.resolve({
+							status: "started",
+							trajectoryId: session.trajectoryId
+						});
+						this.onChange();
+					} catch (_unused2) {
+						this.fail(session, connection, "CAPTURE_FAILED", false);
+					}
+				}).receive("error", (joinError) => this.fail(session, connection, errorCode(joinError, "JOIN_FAILED"))).receive("timeout", () => this.fail(session, connection, "CONNECTION_TIMEOUT"));
+			} catch (_unused3) {
+				this.fail(session, connection, "CONNECTION_FAILED");
+			}
+		}
+		/** Resolves once auto-detection picks a transport, or with "auto" when the attempt is aborted. */
+		detectedTransport(signal) {
+			return new Promise((resolve) => {
+				const finish = () => {
+					subscription.unsubscribe();
+					signal.removeEventListener("abort", finish);
+					resolve(this.core.runtimeTransport);
+				};
+				const subscription = this.core.subscribe({ onRuntimeConnectionStatusChanged: () => {
+					if (this.core.runtimeTransport !== "auto") finish();
+				} });
+				signal.addEventListener("abort", finish, { once: true });
+			});
+		}
+		addDropped(session, count, schedule = true) {
+			session.dropped = Math.min(Number.MAX_SAFE_INTEGER, session.dropped + count);
+			if (schedule && count > 0 && session.ready && session.connection) this.scheduleFlush(session, session.connection);
+		}
+		scheduleFlush(session, connection) {
+			if (session.flushTimer !== void 0 || !this.current(session, connection)) return;
+			session.flushTimer = setTimeout(() => {
+				session.flushTimer = void 0;
+				this.flush(session, connection);
+			}, BATCH_INTERVAL_MS);
+		}
+		discardQueue(session) {
+			clearTimeout(session.flushTimer);
+			session.flushTimer = void 0;
+			this.addDropped(session, session.queue.length, false);
+			session.queue = [];
+		}
+		connected(connection) {
+			var _connection$socket, _connection$channel;
+			return ((_connection$socket = connection.socket) === null || _connection$socket === void 0 ? void 0 : _connection$socket.isConnected()) === true && ((_connection$channel = connection.channel) === null || _connection$channel === void 0 ? void 0 : _connection$channel.state) === "joined";
+		}
+		send(session, connection, event) {
+			if (!this.current(session, connection) || !session.ready) return;
+			if (!this.connected(connection)) {
+				this.addDropped(session, 1);
+				this.fail(session, connection, "CONNECTION_LOST");
+				return;
+			}
+			if (!Number.isSafeInteger(this.nextSeq)) {
+				this.addDropped(session, 1);
+				this.report(session, "SEQUENCE_EXHAUSTED");
+				return;
+			}
+			const original = event.value;
+			const fields = isObject(original) && !Array.isArray(original) && !Object.hasOwn(original, "seq") ? original : { data: original };
+			const wire = {
+				...event,
+				value: {
+					...fields,
+					seq: this.nextSeq++
+				}
+			};
+			if (byteLength(wire) > MAX_EVENT_BYTES) {
+				this.addDropped(session, 1);
+				this.report(session, "EVENT_TOO_LARGE");
+				return;
+			}
+			const fits = () => session.queue.length < MAX_BATCH_EVENTS && byteLength({
+				events: [...session.queue, wire],
+				dropped: Number.MAX_SAFE_INTEGER
+			}) <= MAX_BATCH_BYTES;
+			if (!fits()) this.flush(session, connection);
+			if (!this.current(session, connection) || !session.ready) return;
+			if (!fits()) {
+				this.addDropped(session, 1);
+				this.report(session, "EVENTS_DROPPED");
+				return;
+			}
+			session.queue.push(wire);
+			if (session.queue.length === MAX_BATCH_EVENTS) this.flush(session, connection);
+			else this.scheduleFlush(session, connection);
+		}
+		flush(session, connection) {
+			if (!this.current(session, connection) || !session.ready || session.queue.length === 0 && session.dropped === 0) return;
+			if (!this.connected(connection)) {
+				this.fail(session, connection, "CONNECTION_LOST");
+				return;
+			}
+			if (connection.pending.size > 0) return;
+			clearTimeout(session.flushTimer);
+			session.flushTimer = void 0;
+			const batch = {
+				events: session.queue,
+				dropped: session.dropped
+			};
+			session.queue = [];
+			session.dropped = 0;
+			let finished = false;
+			const pending = {
+				timer: setTimeout(() => pending.finish("PERSISTENCE_UNKNOWN"), TIMEOUT_MS),
+				finish: (code, knownRollback = false, flushNext = true) => {
+					if (finished) return;
+					finished = true;
+					clearTimeout(pending.timer);
+					connection.pending.delete(pending);
+					if (knownRollback) this.addDropped(session, batch.events.length + batch.dropped, false);
+					if (code && this.current(session, connection)) this.report(session, code);
+					if (flushNext && this.current(session, connection) && session.ready && (session.queue.length > 0 || !knownRollback && session.dropped > 0)) this.flush(session, connection);
+				}
+			};
+			connection.pending.add(pending);
+			try {
+				connection.channel.push("events", batch, TIMEOUT_MS).receive("ok", (payload) => {
+					pending.finish(!isBatchAcknowledgement(payload, batch.events.length) ? "PERSISTENCE_UNKNOWN" : payload.rejected > 0 ? "EVENTS_REJECTED" : void 0);
+				}).receive("error", (payload) => {
+					if (!this.current(session, connection)) return;
+					const reason = isObject(payload) ? payload.reason : void 0;
+					if (reason === "unauthorized" || reason === "trajectory_mismatch") {
+						pending.finish(void 0, true, false);
+						this.fail(session, connection, reason.toUpperCase(), false);
+						return;
+					}
+					const rollback = typeof reason === "string" && [
+						"invalid_batch",
+						"batch_too_large",
+						"batch_too_many_events",
+						"trajectory_over_share",
+						"trajectory_outbox_full",
+						"unsupported_event"
+					].includes(reason);
+					pending.finish(rollback ? reason.toUpperCase() : "PERSISTENCE_UNKNOWN", rollback);
+				}).receive("timeout", () => pending.finish("PERSISTENCE_UNKNOWN"));
+			} catch (_unused4) {
+				pending.finish("PERSISTENCE_UNKNOWN");
+			}
+		}
+	};
+
+//#endregion
+//#region src/core/learning-bridge.ts
+	const COPILOTKIT_OWN_URLS = ["https://telemetry.copilotkit.ai/", "https://cdn.copilotkit.ai/"];
+	/**
+	* Wires `@copilotkit/learning` into Core. Default capture uses Runtime and Phoenix;
+	* explicit legacy sinks also use agent events and open-Thread attribution.
+	*/
+	var LearningBridge = class {
+		constructor(core, config, onChange = () => {}) {
+			this.core = core;
+			this.config = config;
+			_defineProperty(this, "collector", null);
+			_defineProperty(this, "agents", /* @__PURE__ */ new Map());
+			_defineProperty(this, "openThreads", /* @__PURE__ */ new Set());
+			_defineProperty(this, "toolCalls", /* @__PURE__ */ new Map());
+			_defineProperty(this, "executingTools", /* @__PURE__ */ new Map());
+			_defineProperty(this, "lastRunIds", /* @__PURE__ */ new WeakMap());
+			_defineProperty(this, "lastLinkedThreadId", null);
+			_defineProperty(this, "coreSubscription", null);
+			_defineProperty(this, "seq", 0);
+			_defineProperty(this, "activeConfig", void 0);
+			_defineProperty(this, "connection", void 0);
+			this.connection = new TrajectoryConnection(core, onChange);
+			this.setConfig(config);
+		}
+		setConfig(config) {
+			this.config = config;
+			if (config === void 0) this.stop();
+		}
+		get isConfigured() {
+			return this.config !== void 0;
+		}
+		get isLegacyCaptureActive() {
+			return this.collector !== null && this.collector.trajectoryId !== null;
+		}
+		startTracking() {
+			if (this.coreSubscription !== null || !this.isLegacyCaptureActive) return;
+			this.coreSubscription = this.core.subscribe({
+				onAgentsChanged: ({ agents }) => {
+					for (const agent of Object.values(agents)) this.track(agent);
+				},
+				onAgentRunStarted: ({ agent }) => this.track(agent),
+				onToolExecutionStart: ({ toolCallId, agentId, toolName }) => {
+					if (!this.isLegacyCaptureActive) return;
+					this.executingTools.set(toolCallId, Date.now());
+					this.emitToolCall("executing", toolCallId, agentId, toolName, {});
+				},
+				onToolExecutionEnd: ({ toolCallId, agentId, toolName, error }) => {
+					if (!this.isLegacyCaptureActive) return;
+					const startedAt = this.executingTools.get(toolCallId);
+					this.executingTools.delete(toolCallId);
+					this.emitToolCall("completed", toolCallId, agentId, toolName, {
+						durationMs: startedAt === void 0 ? void 0 : Date.now() - startedAt,
+						outcome: error === void 0 ? "ok" : "error"
+					});
+					this.toolCalls.delete(toolCallId);
+				}
+			});
+			for (const agent of Object.values(this.core.agents)) this.track(agent);
+		}
+		get trajectoryId() {
+			var _ref, _this$connection$traj, _this$collector;
+			return (_ref = (_this$connection$traj = this.connection.trajectoryId) !== null && _this$connection$traj !== void 0 ? _this$connection$traj : (_this$collector = this.collector) === null || _this$collector === void 0 ? void 0 : _this$collector.trajectoryId) !== null && _ref !== void 0 ? _ref : null;
+		}
+		start(options = {}) {
+			var _ref2, _options$trajectoryId, _this$collector2;
+			const config = this.config;
+			if (config === void 0) {
+				console.warn("[CopilotKit] startTrajectory() needs the `learning` option on CopilotKitCore (or the CopilotKitProvider `learning` prop).");
+				return Promise.resolve({
+					status: "error",
+					code: "LEARNING_DISABLED"
+				});
+			}
+			if (config.sink === void 0) {
+				if (options.learningContainerIds !== void 0) console.warn("[CopilotKit] learningContainerIds is supported only with a custom sink. Authenticated Trajectory capture does not assign Learning Containers; remove learningContainerIds from the capture options.");
+				this.stopLegacy();
+				return this.connection.start(options.trajectoryId, config);
+			}
+			this.connection.stop();
+			const trajectoryId = (_ref2 = (_options$trajectoryId = options.trajectoryId) !== null && _options$trajectoryId !== void 0 ? _options$trajectoryId : (_this$collector2 = this.collector) === null || _this$collector2 === void 0 ? void 0 : _this$collector2.trajectoryId) !== null && _ref2 !== void 0 ? _ref2 : crypto.randomUUID();
+			if (this.collector === null) {
+				var _config$ignoreUrls;
+				this.activeConfig = config;
+				const runtimeUrl = this.core.runtimeUrl;
+				this.collector = (0, _copilotkit_learning.createCollector)({
+					...config,
+					beforeSend: (event) => {
+						const sequenced = {
+							...event,
+							value: {
+								...event.value,
+								seq: ++this.seq
+							}
+						};
+						return config.beforeSend === void 0 ? sequenced : config.beforeSend(sequenced);
+					},
+					ignoreUrls: [
+						...(_config$ignoreUrls = config.ignoreUrls) !== null && _config$ignoreUrls !== void 0 ? _config$ignoreUrls : [],
+						...COPILOTKIT_OWN_URLS,
+						...runtimeUrl === void 0 ? [] : [runtimeUrl]
+					],
+					enrich: (target) => this.enrich(target)
+				});
+			}
+			const wasActive = this.collector.trajectoryId !== null;
+			this.collector.start({
+				...options,
+				trajectoryId
+			});
+			if (wasActive) return Promise.resolve(this.collector.trajectoryId === trajectoryId ? {
+				status: "started",
+				trajectoryId
+			} : {
+				status: "error",
+				code: "TRAJECTORY_ACTIVE"
+			});
+			this.startTracking();
+			this.lastLinkedThreadId = null;
+			for (const threadId of this.distinctOpenThreadIds()) this.emitThreadLinked(threadId, "start");
+			return Promise.resolve({
+				status: "started",
+				trajectoryId
+			});
+		}
+		stop() {
+			this.connection.stop();
+			this.stopLegacy();
+		}
+		stopLegacy() {
+			var _this$collector3, _this$coreSubscriptio;
+			(_this$collector3 = this.collector) === null || _this$collector3 === void 0 || _this$collector3.stop();
+			this.collector = null;
+			this.activeConfig = void 0;
+			(_this$coreSubscriptio = this.coreSubscription) === null || _this$coreSubscriptio === void 0 || _this$coreSubscriptio.unsubscribe();
+			this.coreSubscription = null;
+			for (const subscription of this.agents.values()) subscription.unsubscribe();
+			this.agents.clear();
+			this.toolCalls.clear();
+			this.executingTools.clear();
+		}
+		/** A developer event. Only an explicit legacy sink adds open-Thread context. */
+		emit(name, value) {
+			this.connection.emit(name, value);
+			if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+				var _this$collector4;
+				(_this$collector4 = this.collector) === null || _this$collector4 === void 0 || _this$collector4.emit(name, {
+					...this.openThreadContext(),
+					...value
+				});
+			}
+		}
+		registerOpenThread(params) {
+			const entry = { ...params };
+			const isNew = !this.distinctOpenThreadIds().includes(entry.threadId);
+			this.openThreads.add(entry);
+			if (isNew) this.emitThreadLinked(entry.threadId, "open");
+			return {
+				update: (threadId) => {
+					if (threadId === entry.threadId) return;
+					entry.threadId = threadId;
+					if (![...this.openThreads].filter((other) => other !== entry).some((other) => other.threadId === threadId)) this.emitThreadLinked(threadId, "switch");
+				},
+				unregister: () => {
+					this.openThreads.delete(entry);
+				}
+			};
+		}
+		distinctOpenThreadIds() {
+			return [...new Set([...this.openThreads].map((open) => open.threadId))];
+		}
+		emitThreadLinked(threadId, reason) {
+			var _this$collector5, _ref3, _owner$agentId, _agent$messages$lengt;
+			if (!(this.collector !== null && this.collector.trajectoryId !== null) || threadId === this.lastLinkedThreadId) return;
+			this.lastLinkedThreadId = threadId;
+			const owner = [...this.openThreads].find((open) => open.threadId === threadId);
+			const agent = this.findAgentForThread(threadId);
+			(_this$collector5 = this.collector) === null || _this$collector5 === void 0 || _this$collector5.ɵemit("thread.linked", {
+				threadId,
+				agentId: (_ref3 = (_owner$agentId = owner === null || owner === void 0 ? void 0 : owner.agentId) !== null && _owner$agentId !== void 0 ? _owner$agentId : agent === null || agent === void 0 ? void 0 : agent.agentId) !== null && _ref3 !== void 0 ? _ref3 : null,
+				hasMessages: ((_agent$messages$lengt = agent === null || agent === void 0 ? void 0 : agent.messages.length) !== null && _agent$messages$lengt !== void 0 ? _agent$messages$lengt : 0) > 0,
+				reason
+			});
+		}
+		findAgentForThread(threadId) {
+			return [...this.agents.keys()].find((agent) => agent.threadId === threadId);
+		}
+		track(agent) {
+			const agentId = agent.agentId;
+			if (!this.isLegacyCaptureActive || this.agents.has(agent) || agentId === void 0) return;
+			this.agents.set(agent, agent.subscribe(this.agentSubscriber(agent, agentId)));
+		}
+		agentSubscriber(agent, agentId) {
+			const runIdFor = () => this.lastRunIds.get(agent);
+			return {
+				onRunStartedEvent: ({ event }) => {
+					this.lastRunIds.set(agent, event.runId);
+					this.emitRun("started", agent, event.threadId, event.runId);
+				},
+				onRunFinishedEvent: ({ event }) => {
+					this.emitRun("finished", agent, event.threadId, event.runId);
+				},
+				onRunErrorEvent: () => {
+					var _runIdFor;
+					this.emitRun("error", agent, agent.threadId, (_runIdFor = runIdFor()) !== null && _runIdFor !== void 0 ? _runIdFor : null);
+				},
+				onToolCallStartEvent: ({ event }) => {
+					if (!this.isLegacyCaptureActive) return;
+					const origin = {
+						agentId,
+						threadId: agent.threadId,
+						messageId: event.parentMessageId,
+						runId: runIdFor()
+					};
+					this.toolCalls.set(event.toolCallId, origin);
+					this.emitToolCall("started", event.toolCallId, origin.agentId, event.toolCallName, {});
+				},
+				onToolCallResultEvent: ({ event }) => {
+					if (!this.executingTools.has(event.toolCallId)) this.toolCalls.delete(event.toolCallId);
+				},
+				onNewMessage: ({ message }) => this.emitMessage(agent, message)
+			};
+		}
+		emitRun(phase, agent, threadId, runId) {
+			var _this$collector6;
+			(_this$collector6 = this.collector) === null || _this$collector6 === void 0 || _this$collector6.ɵemit("agent.run", {
+				phase,
+				runId,
+				threadId,
+				agentId: agent.agentId
+			});
+		}
+		emitMessage(agent, message) {
+			var _this$activeConfig, _this$collector7;
+			const content = typeof message.content === "string" ? message.content : "";
+			const includeText = ((_this$activeConfig = this.activeConfig) === null || _this$activeConfig === void 0 || (_this$activeConfig = _this$activeConfig.capture) === null || _this$activeConfig === void 0 ? void 0 : _this$activeConfig.agentText) !== false && typeof message.content === "string";
+			(_this$collector7 = this.collector) === null || _this$collector7 === void 0 || _this$collector7.ɵemit("agent.message", {
+				messageId: message.id,
+				runId: this.runIdForMessage(agent, message.id),
+				threadId: agent.threadId,
+				agentId: agent.agentId,
+				role: message.role,
+				textLength: content.length,
+				...includeText ? { text: content } : {}
+			});
+		}
+		emitToolCall(phase, toolCallId, agentId, toolName, extra) {
+			var _this$collector8, _origin$threadId;
+			const origin = this.toolCalls.get(toolCallId);
+			(_this$collector8 = this.collector) === null || _this$collector8 === void 0 || _this$collector8.ɵemit("tool.call", {
+				phase,
+				toolCallId,
+				toolName,
+				agentId,
+				threadId: (_origin$threadId = origin === null || origin === void 0 ? void 0 : origin.threadId) !== null && _origin$threadId !== void 0 ? _origin$threadId : null,
+				messageId: origin === null || origin === void 0 ? void 0 : origin.messageId,
+				runId: origin === null || origin === void 0 ? void 0 : origin.runId,
+				...extra
+			});
+		}
+		runIdForMessage(agent, messageId) {
+			var _ref4, _this$core$getRunIdFo;
+			const agentId = agent.agentId;
+			if (agentId === void 0) return null;
+			return (_ref4 = (_this$core$getRunIdFo = this.core.getRunIdForMessage(agentId, agent.threadId, messageId)) !== null && _this$core$getRunIdFo !== void 0 ? _this$core$getRunIdFo : this.lastRunIds.get(agent)) !== null && _ref4 !== void 0 ? _ref4 : null;
+		}
+		findMessage(messageId) {
+			for (const agent of this.agents.keys()) {
+				const message = agent.messages.find((candidate) => candidate.id === messageId);
+				if (message !== void 0) return {
+					agent,
+					message
+				};
+			}
+			return null;
+		}
+		toolStatus(agent, toolCallId) {
+			if (this.executingTools.has(toolCallId)) return "executing";
+			return agent.messages.some((message) => message.role === "tool" && message.toolCallId === toolCallId) ? "complete" : "inProgress";
+		}
+		/** Adds agent context to a click: exact message first, then the single open Thread. */
+		enrich(target) {
+			var _target$closest$getAt, _target$closest, _target$closest$getAt2, _target$closest2;
+			const messageId = (_target$closest$getAt = (_target$closest = target.closest("[data-message-id]")) === null || _target$closest === void 0 ? void 0 : _target$closest.getAttribute("data-message-id")) !== null && _target$closest$getAt !== void 0 ? _target$closest$getAt : null;
+			const toolCallId = (_target$closest$getAt2 = (_target$closest2 = target.closest("[data-tool-call-id]")) === null || _target$closest2 === void 0 ? void 0 : _target$closest2.getAttribute("data-tool-call-id")) !== null && _target$closest$getAt2 !== void 0 ? _target$closest$getAt2 : null;
+			const found = messageId === null ? null : this.findMessage(messageId);
+			if (found !== null) {
+				var _message$toolCalls;
+				const { agent, message } = found;
+				const toolCall = toolCallId !== null && message.role === "assistant" ? (_message$toolCalls = message.toolCalls) === null || _message$toolCalls === void 0 ? void 0 : _message$toolCalls.find((call) => call.id === toolCallId) : void 0;
+				return {
+					threadId: agent.threadId,
+					agentId: agent.agentId,
+					messageId: message.id,
+					runId: this.runIdForMessage(agent, message.id),
+					...toolCall === void 0 ? {} : {
+						toolCallId: toolCall.id,
+						toolName: toolCall.function.name,
+						toolStatus: this.toolStatus(agent, toolCall.id)
+					}
+				};
+			}
+			return this.openThreadContext();
+		}
+		/** The single open Thread, or `null` with the candidates when several are open. */
+		openThreadContext() {
+			var _openIds$;
+			const openIds = this.distinctOpenThreadIds();
+			if (openIds.length > 1) return {
+				threadId: null,
+				threadAmbiguity: {
+					reason: "multiple-open",
+					candidates: openIds
+				}
+			};
+			return { threadId: (_openIds$ = openIds[0]) !== null && _openIds$ !== void 0 ? _openIds$ : null };
+		}
+	};
+
 //#endregion
 //#region src/utils/micro-redux.ts
 	const INTERNAL_ACTION_TYPES = {
@@ -5655,7 +6626,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] != null));
 	}
 	var CopilotKitCore = class {
-		constructor({ runtimeUrl, runtimeTransport = "auto", deferInitialConnection = false, headers = {}, credentials, messageFilter, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
+		constructor({ runtimeUrl, runtimeTransport = "auto", deferInitialConnection = false, headers = {}, credentials, messageFilter, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug, learning }) {
 			_defineProperty(this, "_headers", void 0);
 			_defineProperty(this, "_credentials", void 0);
 			_defineProperty(this, "_messageFilter", void 0);
@@ -5669,6 +6640,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			_defineProperty(this, "runHandler", void 0);
 			_defineProperty(this, "stateManager", void 0);
 			_defineProperty(this, "threadStoreRegistry", void 0);
+			_defineProperty(this, "learningBridge", void 0);
+			_defineProperty(this, "notifiedTrajectoryId", null);
+			_defineProperty(this, "learningConfiguredListeners", /* @__PURE__ */ new Set());
 			_defineProperty(this, "_memoryStore", void 0);
 			_defineProperty(this, "previousAgentIds", /* @__PURE__ */ new Set());
 			this._headers = normalizeHeaders(headers);
@@ -5686,6 +6660,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			this.runHandler.initialize(tools);
 			this.suggestionEngine.initialize(suggestionsConfig);
 			this.stateManager.initialize();
+			this.learningBridge = new LearningBridge(this, learning, () => this.notifyTrajectoryChanged());
 			this.agentRegistry.setRuntimeTransport(runtimeTransport);
 			this.agentRegistry.setRuntimeUrl(runtimeUrl, { deferConnection: deferInitialConnection });
 			this.previousAgentIds = new Set(Object.keys(agents__unsafe_dev_only));
@@ -5840,6 +6815,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		get runtimeConnectionStatus() {
 			return this.agentRegistry.runtimeConnectionStatus;
 		}
+		/** @internal The verbatim single-endpoint URL, including any trailing slash. */
+		get ɵruntimeEndpointUrl() {
+			return this.agentRegistry.runtimeEndpointUrl;
+		}
 		get ɵruntimeFetch() {
 			return this.agentRegistry.createRuntimeFetch();
 		}
@@ -6005,6 +6984,86 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		getAgent(id) {
 			return this.agentRegistry.getAgent(id);
 		}
+		/** Updates settings for the next capture. Removing the config stops capture. */
+		setLearningConfig(config) {
+			const wasConfigured = this.ɵlearningConfigured;
+			this.learningBridge.setConfig(config);
+			this.notifyTrajectoryChanged();
+			if (this.ɵlearningConfigured === wasConfigured) return;
+			for (const listener of this.learningConfiguredListeners) try {
+				listener();
+			} catch (error) {
+				console.error("Learning configured listener error:", error);
+			}
+		}
+		/**
+		* @internal Whether a `learning` config is set. Unlike {@link trajectoryId},
+		* it does not change with capture start, connection failures or reconnects.
+		*/
+		get ɵlearningConfigured() {
+			return this.learningBridge.isConfigured;
+		}
+		/** @internal Calls `listener` when {@link ɵlearningConfigured} changes. */
+		ɵsubscribeToLearningConfigured(listener) {
+			this.learningConfiguredListeners.add(listener);
+			return () => {
+				this.learningConfiguredListeners.delete(listener);
+			};
+		}
+		/** The active capture's Trajectory ID, or null while capture is stopped. */
+		get trajectoryId() {
+			return this.learningBridge.trajectoryId;
+		}
+		notifyTrajectoryChanged() {
+			const trajectoryId = this.trajectoryId;
+			if (trajectoryId === this.notifiedTrajectoryId) return;
+			this.notifiedTrajectoryId = trajectoryId;
+			this.notifySubscribers((subscriber) => {
+				var _subscriber$onTraject;
+				return (_subscriber$onTraject = subscriber.onTrajectoryChanged) === null || _subscriber$onTraject === void 0 ? void 0 : _subscriber$onTraject.call(subscriber, {
+					copilotkit: this,
+					trajectoryId
+				});
+			}, "Subscriber onTrajectoryChanged error:");
+		}
+		/**
+		* Starts one Trajectory after Runtime authorization and the Gateway join.
+		* Omit the ID to create one. Repeated starts await the active connection;
+		* a different ID stops the previous capture. Explicit sinks retain the
+		* prototype's synchronous capture and require a stop before changing IDs.
+		*
+		* @example copilotkit.startTrajectory({ trajectoryId: crypto.randomUUID() })
+		*/
+		startTrajectory(options = {}) {
+			const result = this.learningBridge.start(options);
+			this.notifyTrajectoryChanged();
+			return result;
+		}
+		/** Cancels pending work and stops capture, attempting one final batch without waiting for its ACK. */
+		stopTrajectory() {
+			this.learningBridge.stop();
+			this.notifyTrajectoryChanged();
+		}
+		/**
+		* Records an outcome that clicks cannot show, such as a saved report or an
+		* approved deal. The wire adds `value.seq`; arrays, primitives, and objects
+		* already containing `seq` are preserved under `value.data`. Explicit legacy
+		* sinks retain object-only events with open-Thread enrichment.
+		* No-op while no Trajectory runs. Events emitted during connection recovery
+		* count as dropped. Built-in names such as `click` are rejected.
+		*
+		* @example copilotkit.emitTrajectoryEvent("deal.approved", { dealId: "deal-1" })
+		*/
+		emitTrajectoryEvent(name, value = {}) {
+			this.learningBridge.emit(name, value);
+		}
+		/**
+		* Tells Core that a view shows this Thread, so captured interactions can link to it.
+		* Framework bindings call this; call it yourself only without a CopilotKit provider.
+		*/
+		registerOpenThread(params) {
+			return this.learningBridge.registerOpenThread(params);
+		}
 		/**
 		* Re-apply the current headers to a single agent (delegated to
 		* AgentRegistry). Core headers are merged on top of the agent's own
@@ -7621,6 +8680,7 @@ exports.ɵcreateMemoryStore = createMemoryStore;
 exports.ɵcreateThreadSelectors = ɵcreateThreadSelectors;
 exports.ɵcreateThreadStore = createThreadStore;
 exports.ɵisCopilotKitFeature = ɵisCopilotKitFeature;
+exports.ɵisHttpAgent = ɵisHttpAgent;
 exports.ɵisRetryableMemoryStatus = isRetryableStatus;
 exports.ɵjoinPhoenixChannel$ = ɵjoinPhoenixChannel$;
 exports.ɵmapMemoryMetadataEvent = ɵmapMemoryMetadataEvent;