@copilotkit/core 0.0.0-fix-license-verifier-client-bundle-20260402220111

package/dist/index.umd.js

@@ -0,0 +1,3592 @@
+(function(global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('@ag-ui/client'), require('@copilotkit/shared'), require('rxjs'), require('rxjs/operators'), require('phoenix'), require('zod-to-json-schema'), require('rxjs/fetch')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@ag-ui/client', '@copilotkit/shared', 'rxjs', 'rxjs/operators', 'phoenix', 'zod-to-json-schema', 'rxjs/fetch'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitCore = {}), global.AgUIClient,global.CopilotKitShared,global.rxjs,global.rxjs.operators,global.phoenix,global.zodToJsonSchema,global.rxjs_fetch));
+})(this, function(exports, _ag_ui_client, _copilotkit_shared, rxjs, rxjs_operators, phoenix, zod_to_json_schema, rxjs_fetch) {
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/utils/phoenix-observable.ts
+/**
+	* Adapt Phoenix socket open/error callbacks into an observable signal stream.
+	*
+	* The returned observable is shared and replayable by the caller when needed,
+	* but this helper itself does not own socket connection teardown.
+	*/
+	function ɵcreatePhoenixSocketSignals$(socket) {
+		return new rxjs.Observable((observer) => {
+			socket.onOpen(() => observer.next({ type: "open" }));
+			socket.onError((error) => observer.next({
+				type: "error",
+				error
+			}));
+		});
+	}
+	/**
+	* Adapt a Phoenix channel join attempt into a single-outcome observable.
+	*/
+	function ɵcreatePhoenixJoinOutcome$(channel) {
+		return new rxjs.Observable((observer) => {
+			channel.join().receive("ok", () => {
+				observer.next({ type: "joined" });
+				observer.complete();
+			}).receive("error", (response) => {
+				observer.next({
+					type: "error",
+					response
+				});
+				observer.complete();
+			}).receive("timeout", () => {
+				observer.next({ type: "timeout" });
+				observer.complete();
+			});
+		});
+	}
+	/**
+	* Create a cold Phoenix socket session.
+	*
+	* The socket is constructed and connected on subscription, and disconnected on
+	* teardown. Each subscription creates an isolated socket instance.
+	*/
+	function ɵphoenixSocket$(options) {
+		return (0, rxjs.defer)(() => {
+			const socket = new phoenix.Socket(options.url, options.options);
+			const signals$ = ɵcreatePhoenixSocketSignals$(socket).pipe((0, rxjs_operators.shareReplay)({
+				bufferSize: 1,
+				refCount: true
+			}));
+			socket.connect();
+			return (0, rxjs.concat)((0, rxjs.of)({
+				socket,
+				signals$
+			}), rxjs.NEVER).pipe((0, rxjs_operators.finalize)(() => socket.disconnect()));
+		});
+	}
+	/**
+	* Create a cold Phoenix channel session from a socket session stream.
+	*
+	* A channel is created and joined for each active socket session. If the
+	* upstream socket session changes, the previous channel is left before the
+	* next one becomes active.
+	*/
+	function ɵphoenixChannel$(options) {
+		return options.socket$.pipe((0, rxjs_operators.switchMap)(({ socket }) => (0, rxjs.defer)(() => {
+			const channel = socket.channel(options.topic, options.params);
+			return (0, rxjs.concat)((0, rxjs.of)({
+				channel,
+				joinOutcome$: ɵcreatePhoenixJoinOutcome$(channel).pipe((0, rxjs_operators.shareReplay)({
+					bufferSize: 1,
+					refCount: true
+				}))
+			}), rxjs.NEVER).pipe((0, rxjs_operators.finalize)(() => {
+				if (options.leaveOnUnsubscribe !== false) channel.leave();
+			}));
+		})));
+	}
+	/**
+	* Observe a named Phoenix channel event as an observable payload stream.
+	*/
+	function ɵobservePhoenixEvent$(channel, eventName) {
+		return new rxjs.Observable((observer) => {
+			const ref = channel.on(eventName, (payload) => observer.next(payload));
+			return () => {
+				channel.off(eventName, ref);
+			};
+		});
+	}
+	/**
+	* Flatten channel sessions into their join-outcome stream.
+	*/
+	function ɵobservePhoenixJoinOutcome$(channel$) {
+		return channel$.pipe((0, rxjs_operators.switchMap)((session) => session.joinOutcome$));
+	}
+	/**
+	* Complete when a channel joins successfully, or error if the join fails.
+	*/
+	function ɵjoinPhoenixChannel$(channel$) {
+		return ɵobservePhoenixJoinOutcome$(channel$).pipe((0, rxjs_operators.take)(1), (0, rxjs_operators.mergeMap)((outcome) => {
+			if (outcome.type === "joined") return rxjs.EMPTY;
+			throw outcome.type === "timeout" ? /* @__PURE__ */ new Error("Timed out joining channel") : /* @__PURE__ */ new Error(`Failed to join channel: ${JSON.stringify(outcome.response)}`);
+		}));
+	}
+	/**
+	* Flatten socket sessions into their lifecycle signal stream.
+	*/
+	function ɵobservePhoenixSocketSignals$(socket$) {
+		return socket$.pipe((0, rxjs_operators.switchMap)((session) => session.signals$));
+	}
+	/**
+	* Error after a socket emits the configured number of consecutive error
+	* signals, resetting the counter after each successful open signal.
+	*/
+	function ɵobservePhoenixSocketHealth$(socketSignals$, maxConsecutiveErrors) {
+		return socketSignals$.pipe((0, rxjs_operators.scan)((consecutiveErrors, signal) => signal.type === "open" ? 0 : consecutiveErrors + 1, 0), (0, rxjs_operators.filter)((consecutiveErrors) => consecutiveErrors >= maxConsecutiveErrors), (0, rxjs_operators.take)(1), (0, rxjs_operators.mergeMap)((consecutiveErrors) => (0, rxjs.throwError)(() => /* @__PURE__ */ new Error(`WebSocket connection failed after ${consecutiveErrors} consecutive errors`))));
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/typeof.js
+	function _typeof(o) {
+		"@babel/helpers - typeof";
+		return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+			return typeof o;
+		} : function(o) {
+			return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+		}, _typeof(o);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPrimitive.js
+	function toPrimitive(t, r) {
+		if ("object" != _typeof(t) || !t) return t;
+		var e = t[Symbol.toPrimitive];
+		if (void 0 !== e) {
+			var i = e.call(t, r || "default");
+			if ("object" != _typeof(i)) return i;
+			throw new TypeError("@@toPrimitive must return a primitive value.");
+		}
+		return ("string" === r ? String : Number)(t);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPropertyKey.js
+	function toPropertyKey(t) {
+		var i = toPrimitive(t, "string");
+		return "symbol" == _typeof(i) ? i : i + "";
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/defineProperty.js
+	function _defineProperty(e, r, t) {
+		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+			value: t,
+			enumerable: !0,
+			configurable: !0,
+			writable: !0
+		}) : e[r] = t, e;
+	}
+
+//#endregion
+//#region src/intelligence-agent.ts
+	const CLIENT_AG_UI_EVENT = "ag_ui_event";
+	const STOP_RUN_EVENT = "stop_run";
+	var AgentThreadLockedError = class extends Error {
+		constructor(threadId) {
+			super(threadId ? `Thread ${threadId} is locked` : "Thread is locked");
+			this.name = "AgentThreadLockedError";
+		}
+	};
+	var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAgent {
+		constructor(config, sharedState = { lastSeenEventIds: /* @__PURE__ */ new Map() }) {
+			super();
+			_defineProperty(this, "config", void 0);
+			_defineProperty(this, "socket", null);
+			_defineProperty(this, "activeChannel", null);
+			_defineProperty(this, "runId", null);
+			_defineProperty(this, "sharedState", void 0);
+			this.config = config;
+			this.sharedState = sharedState;
+		}
+		clone() {
+			return new IntelligenceAgent(this.config, this.sharedState);
+		}
+		/**
+		* 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.
+		*
+		* 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.
+		*/
+		async connectAgent(parameters, subscriber) {
+			const self = this;
+			try {
+				var _this$agentId;
+				this.isRunning = true;
+				this.agentId = (_this$agentId = this.agentId) !== null && _this$agentId !== void 0 ? _this$agentId : (0, _ag_ui_client.randomUUID)();
+				const input = this.prepareRunAgentInput(parameters);
+				let result;
+				const previousMessageIds = new Set(this.messages.map((m) => m.id));
+				const subscribers = [
+					{ onRunFinishedEvent: (event) => {
+						result = event.result;
+					} },
+					...this.subscribers,
+					subscriber !== null && subscriber !== void 0 ? subscriber : {}
+				];
+				await this.onInitialize(input, subscribers);
+				self.activeRunDetach$ = new rxjs.Subject();
+				let resolveCompletion;
+				self.activeRunCompletionPromise = new Promise((resolve) => {
+					resolveCompletion = resolve;
+				});
+				const source$ = (0, rxjs.defer)(() => this.connect(input)).pipe((0, _ag_ui_client.transformChunks)(this.debug), (0, rxjs_operators.takeUntil)(self.activeRunDetach$));
+				const applied$ = this.apply(input, source$, subscribers);
+				await (0, rxjs.lastValueFrom)(this.processApplyEvents(input, applied$, subscribers).pipe((0, rxjs_operators.catchError)((error) => {
+					this.isRunning = false;
+					return this.onError(input, error, subscribers);
+				}), (0, rxjs_operators.finalize)(() => {
+					this.isRunning = false;
+					this.onFinalize(input, subscribers);
+					resolveCompletion === null || resolveCompletion === void 0 || resolveCompletion();
+					resolveCompletion = void 0;
+					self.activeRunCompletionPromise = void 0;
+					self.activeRunDetach$ = void 0;
+				})), { defaultValue: void 0 });
+				const newMessages = (0, _ag_ui_client.structuredClone_)(this.messages).filter((m) => !previousMessageIds.has(m.id));
+				return {
+					result,
+					newMessages
+				};
+			} finally {
+				this.isRunning = false;
+			}
+		}
+		abortRun() {
+			if (this.activeChannel && this.runId) {
+				const fallback = setTimeout(() => clear(), 5e3);
+				const clear = () => {
+					clearTimeout(fallback);
+					this.detachActiveRun();
+					this.cleanup();
+				};
+				this.activeChannel.push(STOP_RUN_EVENT, { run_id: this.runId }).receive("ok", clear).receive("error", clear).receive("timeout", clear);
+			} else {
+				this.detachActiveRun();
+				this.cleanup();
+			}
+		}
+		/**
+		* Trigger the run via REST, then join the realtime thread channel and relay
+		* server-pushed AG-UI events to the Observable subscriber.
+		*/
+		run(input) {
+			this.threadId = input.threadId;
+			this.runId = input.runId;
+			return (0, rxjs.defer)(() => this.requestJoinCredentials$("run", input)).pipe((0, rxjs.switchMap)((credentials) => this.observeThread$(input, credentials, {
+				completeOnRunError: false,
+				streamMode: "run"
+			})));
+		}
+		/**
+		* Reconnect to an existing thread by fetching websocket credentials and
+		* joining the realtime thread channel.
+		*/
+		connect(input) {
+			this.threadId = input.threadId;
+			this.runId = input.runId;
+			return (0, rxjs.defer)(() => this.requestConnectPlan$(input)).pipe((0, rxjs.switchMap)((plan) => {
+				if (plan === null) return rxjs.EMPTY;
+				if (plan.mode === "bootstrap") {
+					this.setLastSeenEventId(input.threadId, plan.latestEventId);
+					for (const event of plan.events) this.updateRunIdFromEvent(event);
+					return (0, rxjs.from)(plan.events);
+				}
+				this.setLastSeenEventId(input.threadId, plan.joinFromEventId);
+				for (const event of plan.events) this.updateRunIdFromEvent(event);
+				return (0, rxjs.concat)((0, rxjs.from)(plan.events), this.observeThread$(input, { joinToken: plan.joinToken }, {
+					completeOnRunError: true,
+					streamMode: "connect",
+					replayCursor: plan.joinFromEventId
+				}));
+			}));
+		}
+		/**
+		* Tear down a specific channel + socket pair that belongs to one pipeline.
+		* Only nulls instance references when they still point to the owned resource,
+		* so a concurrent pipeline's resources are never clobbered.
+		*/
+		cleanupOwned(ownChannel, ownSocket) {
+			if (ownChannel) {
+				ownChannel.leave();
+				if (this.activeChannel === ownChannel) this.activeChannel = null;
+			}
+			if (ownSocket) {
+				ownSocket.disconnect();
+				if (this.socket === ownSocket) this.socket = null;
+			}
+			if (this.threadId) this.sharedState.lastSeenEventIds.delete(this.threadId);
+			this.runId = null;
+		}
+		cleanup() {
+			this.cleanupOwned(this.activeChannel, this.socket);
+		}
+		requestJoinCredentials$(mode, input) {
+			return (0, rxjs.defer)(async () => {
+				try {
+					const response = await fetch(this.buildRuntimeUrl(mode), {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							...this.config.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
+						}),
+						...this.config.credentials ? { credentials: this.config.credentials } : {}
+					});
+					if (response.status === 409) throw new AgentThreadLockedError(input.threadId);
+					if (!response.ok) {
+						const text = await response.text().catch(() => "");
+						throw new Error(text || response.statusText || String(response.status));
+					}
+					const payload = await response.json();
+					if (!payload.joinToken) throw new Error("missing joinToken");
+					return { joinToken: payload.joinToken };
+				} catch (error) {
+					if (error instanceof AgentThreadLockedError) throw error;
+					throw new Error(`REST ${mode} request failed: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+		}
+		requestConnectPlan$(input) {
+			return (0, rxjs.defer)(async () => {
+				try {
+					const response = await fetch(this.buildRuntimeUrl("connect"), {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							...this.config.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,
+							lastSeenEventId: this.getReconnectCursor(input)
+						}),
+						...this.config.credentials ? { credentials: this.config.credentials } : {}
+					});
+					if (response.status === 204) return null;
+					if (!response.ok) {
+						const text = await response.text().catch(() => "");
+						throw new Error(text || response.statusText || String(response.status));
+					}
+					return this.normalizeConnectPlan(await response.json());
+				} catch (error) {
+					throw new Error(`REST connect request failed: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+		}
+		normalizeConnectPlan(payload) {
+			const envelope = payload && typeof payload === "object" ? payload : null;
+			if ((envelope === null || envelope === void 0 ? void 0 : envelope.mode) === "bootstrap") return {
+				mode: "bootstrap",
+				latestEventId: typeof envelope.latestEventId === "string" ? envelope.latestEventId : null,
+				events: Array.isArray(envelope.events) ? envelope.events : []
+			};
+			if ((envelope === null || envelope === void 0 ? void 0 : envelope.mode) === "live") {
+				if (typeof envelope.joinToken !== "string" || envelope.joinToken.length === 0) throw new Error("missing joinToken");
+				return {
+					mode: "live",
+					joinToken: envelope.joinToken,
+					joinFromEventId: typeof envelope.joinFromEventId === "string" ? envelope.joinFromEventId : null,
+					events: Array.isArray(envelope.events) ? envelope.events : []
+				};
+			}
+			throw new Error("invalid connect plan");
+		}
+		observeThread$(input, credentials, options) {
+			return (0, rxjs.defer)(() => {
+				var _this$config$socketPa;
+				let ownSocket = null;
+				let ownChannel = null;
+				const socket$ = ɵphoenixSocket$({
+					url: this.config.url,
+					options: {
+						params: {
+							...(_this$config$socketPa = this.config.socketParams) !== null && _this$config$socketPa !== void 0 ? _this$config$socketPa : {},
+							join_token: credentials.joinToken
+						},
+						reconnectAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(100, 1e4),
+						rejoinAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(1e3, 3e4)
+					}
+				}).pipe((0, rxjs_operators.tap)(({ socket }) => {
+					ownSocket = socket;
+					this.socket = ownSocket;
+				}), (0, rxjs_operators.shareReplay)({
+					bufferSize: 1,
+					refCount: true
+				}));
+				const { topic, params } = this.createThreadChannelDescriptor(input, options.streamMode, options.replayCursor);
+				const channel$ = ɵphoenixChannel$({
+					socket$,
+					topic,
+					params
+				}).pipe((0, rxjs_operators.tap)(({ channel }) => {
+					ownChannel = channel;
+					this.activeChannel = ownChannel;
+				}), (0, rxjs_operators.shareReplay)({
+					bufferSize: 1,
+					refCount: true
+				}));
+				const threadEvents$ = this.observeThreadEvents$(input.threadId, channel$, options).pipe((0, rxjs_operators.share)());
+				const threadCompleted$ = threadEvents$.pipe((0, rxjs_operators.ignoreElements)(), (0, rxjs_operators.endWith)(null), (0, rxjs_operators.take)(1));
+				return (0, rxjs.merge)(this.joinThreadChannel$(channel$), this.observeSocketHealth$(socket$).pipe((0, rxjs_operators.takeUntil)(threadCompleted$)), threadEvents$).pipe((0, rxjs_operators.finalize)(() => this.cleanupOwned(ownChannel, ownSocket)));
+			});
+		}
+		joinThreadChannel$(channel$) {
+			return ɵjoinPhoenixChannel$(channel$);
+		}
+		observeSocketHealth$(socket$) {
+			return ɵobservePhoenixSocketHealth$(ɵobservePhoenixSocketSignals$(socket$), 5);
+		}
+		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);
+				this.updateRunIdFromEvent(payload);
+			}), (0, rxjs_operators.mergeMap)((payload) => (0, rxjs.from)(this.createThreadNotifications(payload, options.completeOnRunError))), (0, rxjs.dematerialize)());
+		}
+		observeChannelEvent$(channel, eventName) {
+			return ɵobservePhoenixEvent$(channel, eventName);
+		}
+		createThreadNotifications(payload, completeOnRunError) {
+			if (payload.type === _ag_ui_client.EventType.RUN_FINISHED) return [rxjs.Notification.createNext(payload), rxjs.Notification.createComplete()];
+			if (payload.type === _ag_ui_client.EventType.RUN_ERROR) {
+				var _message;
+				const errorMessage = (_message = payload.message) !== null && _message !== void 0 ? _message : "Run error";
+				return completeOnRunError ? [rxjs.Notification.createNext(payload), rxjs.Notification.createComplete()] : [rxjs.Notification.createNext(payload), rxjs.Notification.createError(new Error(errorMessage))];
+			}
+			return [rxjs.Notification.createNext(payload)];
+		}
+		buildRuntimeUrl(mode) {
+			const path = `${this.config.runtimeUrl}/agent/${encodeURIComponent(this.config.agentId)}/${mode}`;
+			const origin = typeof window !== "undefined" && window.location ? window.location.origin : "http://localhost";
+			return new URL(path, new URL(this.config.runtimeUrl, origin)).toString();
+		}
+		createThreadChannelDescriptor(input, streamMode, replayCursor) {
+			const params = streamMode === "run" ? {
+				stream_mode: "run",
+				run_id: input.runId
+			} : {
+				stream_mode: "connect",
+				last_seen_event_id: replayCursor === void 0 ? this.getReconnectCursor(input) : replayCursor
+			};
+			return {
+				topic: `thread:${input.threadId}`,
+				params
+			};
+		}
+		getLastSeenEventId(threadId) {
+			var _this$sharedState$las;
+			return (_this$sharedState$las = this.sharedState.lastSeenEventIds.get(threadId)) !== null && _this$sharedState$las !== void 0 ? _this$sharedState$las : null;
+		}
+		getReconnectCursor(input) {
+			return this.hasLocalThreadMessages(input) ? this.getLastSeenEventId(input.threadId) : null;
+		}
+		hasLocalThreadMessages(input) {
+			return Array.isArray(input.messages) && input.messages.length > 0;
+		}
+		updateLastSeenEventId(threadId, payload) {
+			const eventId = this.readEventId(payload);
+			if (!eventId) return;
+			this.sharedState.lastSeenEventIds.set(threadId, eventId);
+		}
+		setLastSeenEventId(threadId, eventId) {
+			if (!eventId) return;
+			this.sharedState.lastSeenEventIds.set(threadId, eventId);
+		}
+		/**
+		* Keep `this.runId` in sync with the backend's actual run ID.
+		*
+		* During a `connect` (resume) flow the client generates a fresh `runId`
+		* via `prepareRunAgentInput`, but the backend is running under its own
+		* run ID.  If the client later sends `STOP_RUN_EVENT` with the wrong
+		* `runId`, the gateway's runner channel will not match it and the agent
+		* keeps running.  Extracting the run ID from live events fixes this.
+		*
+		* The runner normalises events to `run_id` (snake_case) before pushing
+		* to the gateway, so we check both `runId` and `run_id`.
+		*/
+		updateRunIdFromEvent(payload) {
+			var _record$runId;
+			const record = payload;
+			const eventRunId = (_record$runId = record.runId) !== null && _record$runId !== void 0 ? _record$runId : record.run_id;
+			if (typeof eventRunId === "string" && eventRunId.length > 0) this.runId = eventRunId;
+		}
+		readEventId(payload) {
+			const metadata = payload.metadata;
+			if (!metadata || typeof metadata !== "object") return null;
+			const runnerEventId = metadata.cpki_event_id;
+			return typeof runnerEventId === "string" ? runnerEventId : null;
+		}
+	};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/checkPrivateRedeclaration.js
+	function _checkPrivateRedeclaration(e, t) {
+		if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/classPrivateMethodInitSpec.js
+	function _classPrivateMethodInitSpec(e, a) {
+		_checkPrivateRedeclaration(e, a), a.add(e);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/assertClassBrand.js
+	function _assertClassBrand(e, t, n) {
+		if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+		throw new TypeError("Private element is not present on this object");
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/getPrototypeOf.js
+	function _getPrototypeOf(t) {
+		return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t) {
+			return t.__proto__ || Object.getPrototypeOf(t);
+		}, _getPrototypeOf(t);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/superPropBase.js
+	function _superPropBase(t, o) {
+		for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t)););
+		return t;
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/get.js
+	function _get() {
+		return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function(e, t, r) {
+			var p = _superPropBase(e, t);
+			if (p) {
+				var n = Object.getOwnPropertyDescriptor(p, t);
+				return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
+			}
+		}, _get.apply(null, arguments);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/superPropGet.js
+	function _superPropGet(t, o, e, r) {
+		var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e);
+		return 2 & r && "function" == typeof p ? function(t) {
+			return p.apply(e, t);
+		} : p;
+	}
+
+//#endregion
+//#region src/agent.ts
+	var _ProxiedCopilotRuntimeAgent;
+	function hasHeaders(agent) {
+		return "headers" in agent;
+	}
+	function hasCredentials(agent) {
+		return "credentials" in agent;
+	}
+	function isZodError(error) {
+		return error !== null && typeof error === "object" && "name" in error && error.name === "ZodError";
+	}
+	function isAbortError(error) {
+		return (error instanceof DOMException || error instanceof Error) && error.name === "AbortError";
+	}
+	function withAbortErrorHandling(observable) {
+		return observable.pipe((0, rxjs_operators.catchError)((error) => {
+			if (isZodError(error) || isAbortError(error)) return rxjs.EMPTY;
+			throw error;
+		}));
+	}
+	var _ProxiedCopilotRuntimeAgent_brand = /* @__PURE__ */ new WeakSet();
+	var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui_client.HttpAgent {
+		constructor(config) {
+			var _config$transport, _ref, _config$agentId, _config$runtimeMode;
+			const normalizedRuntimeUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/$/, "") : void 0;
+			const transport = (_config$transport = config.transport) !== null && _config$transport !== void 0 ? _config$transport : "rest";
+			const runUrl = transport === "single" ? (_ref = normalizedRuntimeUrl !== null && normalizedRuntimeUrl !== void 0 ? normalizedRuntimeUrl : config.runtimeUrl) !== null && _ref !== void 0 ? _ref : "" : `${normalizedRuntimeUrl !== null && normalizedRuntimeUrl !== void 0 ? normalizedRuntimeUrl : config.runtimeUrl}/agent/${encodeURIComponent((_config$agentId = config.agentId) !== null && _config$agentId !== void 0 ? _config$agentId : "")}/run`;
+			if (!runUrl) throw new Error("ProxiedCopilotRuntimeAgent requires a runtimeUrl when transport is set to 'single'.");
+			super({
+				...config,
+				url: runUrl
+			});
+			_classPrivateMethodInitSpec(this, _ProxiedCopilotRuntimeAgent_brand);
+			_defineProperty(this, "runtimeUrl", void 0);
+			_defineProperty(this, "credentials", void 0);
+			_defineProperty(this, "transport", void 0);
+			_defineProperty(this, "singleEndpointUrl", void 0);
+			_defineProperty(this, "runtimeMode", void 0);
+			_defineProperty(this, "intelligence", void 0);
+			_defineProperty(this, "delegate", void 0);
+			_defineProperty(this, "runtimeInfoPromise", void 0);
+			this.runtimeUrl = normalizedRuntimeUrl !== null && normalizedRuntimeUrl !== void 0 ? normalizedRuntimeUrl : config.runtimeUrl;
+			this.credentials = config.credentials;
+			this.transport = transport;
+			this.runtimeMode = (_config$runtimeMode = config.runtimeMode) !== null && _config$runtimeMode !== void 0 ? _config$runtimeMode : _copilotkit_shared.RUNTIME_MODE_SSE;
+			this.intelligence = config.intelligence;
+			if (this.transport === "single") this.singleEndpointUrl = this.runtimeUrl;
+		}
+		async detachActiveRun() {
+			if (this.delegate) await this.delegate.detachActiveRun();
+			await super.detachActiveRun();
+		}
+		abortRun() {
+			if (this.delegate) {
+				this.syncDelegate(this.delegate);
+				this.delegate.abortRun();
+				this.detachActiveRun();
+				return;
+			}
+			if (!this.agentId || !this.threadId) return;
+			if (typeof fetch === "undefined") return;
+			if (this.transport === "single") {
+				if (!this.singleEndpointUrl) return;
+				const headers = new Headers({
+					...this.headers,
+					"Content-Type": "application/json"
+				});
+				fetch(this.singleEndpointUrl, {
+					method: "POST",
+					headers,
+					body: JSON.stringify({
+						method: "agent/stop",
+						params: {
+							agentId: this.agentId,
+							threadId: this.threadId
+						}
+					}),
+					...this.credentials ? { credentials: this.credentials } : {}
+				}).catch((error) => {
+					console.error("ProxiedCopilotRuntimeAgent: stop request failed", error);
+				});
+				return;
+			}
+			if (!this.runtimeUrl) return;
+			const stopPath = `${this.runtimeUrl}/agent/${encodeURIComponent(this.agentId)}/stop/${encodeURIComponent(this.threadId)}`;
+			const origin = typeof window !== "undefined" && window.location ? window.location.origin : "http://localhost";
+			const base = new URL(this.runtimeUrl, origin);
+			const stopUrl = new URL(stopPath, base);
+			fetch(stopUrl.toString(), {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...this.headers
+				},
+				...this.credentials ? { credentials: this.credentials } : {}
+			}).catch((error) => {
+				console.error("ProxiedCopilotRuntimeAgent: stop request failed", error);
+			});
+		}
+		async connectAgent(parameters, subscriber) {
+			if (this.runtimeMode !== _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) return super.connectAgent(parameters, subscriber);
+			if (this.delegate) await this.delegate.detachActiveRun();
+			await this.resolveDelegate();
+			const delegate = this.delegate;
+			const bridgeSub = delegate.subscribe({
+				onMessagesChanged: () => {
+					this.setMessages([...delegate.messages]);
+				},
+				onStateChanged: () => {
+					this.setState({ ...delegate.state });
+				},
+				onRunInitialized: () => {
+					this.isRunning = true;
+				},
+				onRunFinalized: () => {
+					this.isRunning = false;
+				},
+				onRunFailed: () => {
+					this.isRunning = false;
+				}
+			});
+			const forwardedSubs = this.subscribers.map((s) => delegate.subscribe(s));
+			try {
+				const result = await delegate.connectAgent(parameters, subscriber);
+				this.setMessages([...delegate.messages]);
+				this.setState({ ...delegate.state });
+				return result;
+			} finally {
+				this.isRunning = false;
+				bridgeSub.unsubscribe();
+				for (const sub of forwardedSubs) sub.unsubscribe();
+			}
+		}
+		connect(input) {
+			if (this.runtimeMode === _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) return _assertClassBrand(_ProxiedCopilotRuntimeAgent_brand, this, _connectViaDelegate).call(this, input);
+			return _assertClassBrand(_ProxiedCopilotRuntimeAgent_brand, this, _connectViaHttp).call(this, input);
+		}
+		run(input) {
+			if (this.runtimeMode === _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) return _assertClassBrand(_ProxiedCopilotRuntimeAgent_brand, this, _runViaDelegate).call(this, input);
+			return _assertClassBrand(_ProxiedCopilotRuntimeAgent_brand, this, _runViaHttp).call(this, input);
+		}
+		clone() {
+			const cloned = new ProxiedCopilotRuntimeAgent({
+				runtimeUrl: this.runtimeUrl,
+				agentId: this.agentId,
+				description: this.description,
+				headers: { ...this.headers },
+				credentials: this.credentials,
+				transport: this.transport,
+				runtimeMode: this.runtimeMode,
+				intelligence: this.intelligence
+			});
+			cloned.threadId = this.threadId;
+			cloned.setState(this.state);
+			cloned.setMessages(this.messages);
+			if (this.delegate) {
+				cloned.delegate = this.delegate.clone();
+				cloned.syncDelegate(cloned.delegate);
+			}
+			return cloned;
+		}
+		async resolveDelegate() {
+			await this.ensureRuntimeMode();
+			if (!this.delegate) {
+				if (this.runtimeMode !== _copilotkit_shared.RUNTIME_MODE_INTELLIGENCE) throw new Error("A delegate is only created for Intelligence mode");
+				this.delegate = this.createIntelligenceDelegate();
+			}
+			this.syncDelegate(this.delegate);
+			return this.delegate;
+		}
+		async ensureRuntimeMode() {
+			var _this$runtimeInfoProm;
+			if (this.runtimeMode !== "pending") return;
+			if (!this.runtimeUrl) throw new Error("Runtime URL is not set");
+			(_this$runtimeInfoProm = this.runtimeInfoPromise) !== null && _this$runtimeInfoProm !== void 0 || (this.runtimeInfoPromise = this.fetchRuntimeInfo().then((runtimeInfo) => {
+				var _runtimeInfo$mode;
+				this.runtimeMode = (_runtimeInfo$mode = runtimeInfo.mode) !== null && _runtimeInfo$mode !== void 0 ? _runtimeInfo$mode : _copilotkit_shared.RUNTIME_MODE_SSE;
+				this.intelligence = runtimeInfo.intelligence;
+			}));
+			await this.runtimeInfoPromise;
+		}
+		async fetchRuntimeInfo() {
+			const headers = { ...this.headers };
+			let init;
+			let url;
+			if (this.transport === "single") {
+				if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
+				if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+				url = this.runtimeUrl;
+				init = {
+					method: "POST",
+					body: JSON.stringify({ method: "info" })
+				};
+			} else {
+				url = `${this.runtimeUrl}/info`;
+				init = {};
+			}
+			const response = await fetch(url, {
+				...init,
+				headers,
+				...this.credentials ? { credentials: this.credentials } : {}
+			});
+			if (!response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
+			return await response.json();
+		}
+		createSingleRouteRequestInit(input, method, params) {
+			var _baseInit$headers, _headers$get;
+			if (!this.agentId) throw new Error("ProxiedCopilotRuntimeAgent requires agentId to make runtime requests");
+			const baseInit = super.requestInit(input);
+			const headers = new Headers((_baseInit$headers = baseInit.headers) !== null && _baseInit$headers !== void 0 ? _baseInit$headers : {});
+			headers.set("Content-Type", "application/json");
+			headers.set("Accept", (_headers$get = headers.get("Accept")) !== null && _headers$get !== void 0 ? _headers$get : "text/event-stream");
+			let originalBody = void 0;
+			if (typeof baseInit.body === "string") try {
+				originalBody = JSON.parse(baseInit.body);
+			} catch (error) {
+				console.warn("ProxiedCopilotRuntimeAgent: failed to parse request body for single route transport", error);
+			}
+			const envelope = { method };
+			if (params && Object.keys(params).length > 0) envelope.params = params;
+			if (originalBody !== void 0) envelope.body = originalBody;
+			return {
+				...baseInit,
+				headers,
+				body: JSON.stringify(envelope),
+				...this.credentials ? { credentials: this.credentials } : {}
+			};
+		}
+		createIntelligenceDelegate() {
+			var _this$intelligence;
+			if (!this.runtimeUrl || !this.agentId || !((_this$intelligence = this.intelligence) === null || _this$intelligence === void 0 ? void 0 : _this$intelligence.wsUrl)) throw new Error("Intelligence mode requires runtimeUrl, agentId, and intelligence websocket metadata");
+			return new IntelligenceAgent({
+				url: this.intelligence.wsUrl,
+				runtimeUrl: this.runtimeUrl,
+				agentId: this.agentId,
+				headers: { ...this.headers },
+				credentials: this.credentials
+			});
+		}
+		syncDelegate(delegate) {
+			delegate.agentId = this.agentId;
+			delegate.description = this.description;
+			delegate.threadId = this.threadId;
+			delegate.setMessages(this.messages);
+			delegate.setState(this.state);
+			if (hasHeaders(delegate)) delegate.headers = { ...this.headers };
+			if (hasCredentials(delegate)) delegate.credentials = this.credentials;
+		}
+	};
+	_ProxiedCopilotRuntimeAgent = ProxiedCopilotRuntimeAgent;
+	function _connectViaDelegate(input) {
+		return (0, rxjs.defer)(() => (0, rxjs.from)(this.resolveDelegate())).pipe((0, rxjs_operators.switchMap)((delegate) => withAbortErrorHandling(delegate.connect(input))));
+	}
+	function _connectViaHttp(input) {
+		if (this.transport === "single") {
+			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
+			const requestInit = this.createSingleRouteRequestInit(input, "agent/connect", { agentId: this.agentId });
+			return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(this.singleEndpointUrl, requestInit)));
+		}
+		return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(`${this.runtimeUrl}/agent/${this.agentId}/connect`, this.requestInit(input))));
+	}
+	function _runViaDelegate(input) {
+		return (0, rxjs.defer)(() => (0, rxjs.from)(this.resolveDelegate())).pipe((0, rxjs_operators.switchMap)((delegate) => withAbortErrorHandling(delegate.run(input))));
+	}
+	function _runViaHttp(input) {
+		if (this.transport === "single") {
+			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
+			const requestInit = this.createSingleRouteRequestInit(input, "agent/run", { agentId: this.agentId });
+			return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(this.singleEndpointUrl, requestInit)));
+		}
+		return withAbortErrorHandling(_superPropGet(_ProxiedCopilotRuntimeAgent.prototype, "run", this, 2)([input]));
+	}
+
+//#endregion
+//#region src/core/agent-registry.ts
+/**
+	* Manages agent registration, lifecycle, and runtime connectivity for CopilotKitCore.
+	* Handles both local development agents and remote runtime agents.
+	*/
+	var AgentRegistry = class {
+		constructor(core) {
+			this.core = core;
+			_defineProperty(this, "_agents", {});
+			_defineProperty(this, "localAgents", {});
+			_defineProperty(this, "remoteAgents", {});
+			_defineProperty(this, "_runtimeUrl", void 0);
+			_defineProperty(this, "_runtimeVersion", void 0);
+			_defineProperty(this, "_runtimeConnectionStatus", CopilotKitCoreRuntimeConnectionStatus.Disconnected);
+			_defineProperty(this, "_runtimeTransport", "rest");
+			_defineProperty(this, "_audioFileTranscriptionEnabled", false);
+			_defineProperty(this, "_runtimeMode", _copilotkit_shared.RUNTIME_MODE_SSE);
+			_defineProperty(this, "_intelligence", void 0);
+			_defineProperty(this, "_a2uiEnabled", false);
+			_defineProperty(this, "_licenseStatus", void 0);
+		}
+		/**
+		* Get all agents as a readonly record
+		*/
+		get agents() {
+			return this._agents;
+		}
+		get runtimeUrl() {
+			return this._runtimeUrl;
+		}
+		get runtimeVersion() {
+			return this._runtimeVersion;
+		}
+		get runtimeConnectionStatus() {
+			return this._runtimeConnectionStatus;
+		}
+		get runtimeTransport() {
+			return this._runtimeTransport;
+		}
+		get audioFileTranscriptionEnabled() {
+			return this._audioFileTranscriptionEnabled;
+		}
+		get runtimeMode() {
+			return this._runtimeMode;
+		}
+		get intelligence() {
+			return this._intelligence;
+		}
+		get a2uiEnabled() {
+			return this._a2uiEnabled;
+		}
+		get licenseStatus() {
+			return this._licenseStatus;
+		}
+		/**
+		* Initialize agents from configuration
+		*/
+		initialize(agents) {
+			this.localAgents = this.assignAgentIds(agents);
+			this.applyHeadersToAgents(this.localAgents);
+			this._agents = this.localAgents;
+		}
+		/**
+		* Set the runtime URL and update connection
+		*/
+		setRuntimeUrl(runtimeUrl) {
+			const normalizedRuntimeUrl = runtimeUrl ? runtimeUrl.replace(/\/$/, "") : void 0;
+			if (this._runtimeUrl === normalizedRuntimeUrl) return;
+			this._runtimeUrl = normalizedRuntimeUrl;
+			this.updateRuntimeConnection();
+		}
+		setRuntimeTransport(runtimeTransport) {
+			if (this._runtimeTransport === runtimeTransport) return;
+			this._runtimeTransport = runtimeTransport;
+			this.updateRuntimeConnection();
+		}
+		/**
+		* Set all agents at once (for development use)
+		*/
+		setAgents__unsafe_dev_only(agents) {
+			Object.entries(agents).forEach(([id, agent]) => {
+				if (agent) this.validateAndAssignAgentId(id, agent);
+			});
+			this.localAgents = agents;
+			this._agents = {
+				...this.localAgents,
+				...this.remoteAgents
+			};
+			this.applyHeadersToAgents(this._agents);
+			this.notifyAgentsChanged();
+		}
+		/**
+		* Add a single agent (for development use)
+		*/
+		addAgent__unsafe_dev_only({ id, agent }) {
+			this.validateAndAssignAgentId(id, agent);
+			this.localAgents[id] = agent;
+			this.applyHeadersToAgent(agent);
+			this._agents = {
+				...this.localAgents,
+				...this.remoteAgents
+			};
+			this.notifyAgentsChanged();
+		}
+		/**
+		* Remove an agent by ID (for development use)
+		*/
+		removeAgent__unsafe_dev_only(id) {
+			delete this.localAgents[id];
+			this._agents = {
+				...this.localAgents,
+				...this.remoteAgents
+			};
+			this.notifyAgentsChanged();
+		}
+		/**
+		* Get an agent by ID
+		*/
+		getAgent(id) {
+			if (id in this._agents) return this._agents[id];
+			if (this.runtimeUrl !== void 0 && (this.runtimeConnectionStatus === CopilotKitCoreRuntimeConnectionStatus.Disconnected || this.runtimeConnectionStatus === CopilotKitCoreRuntimeConnectionStatus.Connecting)) return;
+			console.warn(`Agent ${id} not found`);
+		}
+		/**
+		* Apply current headers to an agent
+		*/
+		applyHeadersToAgent(agent) {
+			if (agent instanceof _ag_ui_client.HttpAgent) agent.headers = { ...this.core.headers };
+		}
+		/**
+		* Apply current headers to all agents
+		*/
+		applyHeadersToAgents(agents) {
+			Object.values(agents).forEach((agent) => {
+				this.applyHeadersToAgent(agent);
+			});
+		}
+		/**
+		* Apply current credentials to an agent
+		*/
+		applyCredentialsToAgent(agent) {
+			if (agent instanceof ProxiedCopilotRuntimeAgent) agent.credentials = this.core.credentials;
+		}
+		/**
+		* Apply current credentials to all agents
+		*/
+		applyCredentialsToAgents(agents) {
+			Object.values(agents).forEach((agent) => {
+				this.applyCredentialsToAgent(agent);
+			});
+		}
+		/**
+		* Update runtime connection and fetch remote agents
+		*/
+		async updateRuntimeConnection() {
+			if (typeof window === "undefined") return;
+			if (!this.runtimeUrl) {
+				this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Disconnected;
+				this._runtimeVersion = void 0;
+				this._audioFileTranscriptionEnabled = false;
+				this._runtimeMode = _copilotkit_shared.RUNTIME_MODE_SSE;
+				this._intelligence = void 0;
+				this._a2uiEnabled = false;
+				this.remoteAgents = {};
+				this._agents = this.localAgents;
+				await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Disconnected);
+				await this.notifyAgentsChanged();
+				return;
+			}
+			this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Connecting;
+			await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Connecting);
+			try {
+				var _runtimeInfoResponse$2, _runtimeInfoResponse$3, _runtimeInfoResponse$4;
+				const runtimeInfoResponse = await this.fetchRuntimeInfo();
+				const { version, ...runtimeInfo } = runtimeInfoResponse;
+				const credentials = this.core.credentials;
+				this.remoteAgents = Object.fromEntries(Object.entries(runtimeInfo.agents).map(([id, { description }]) => {
+					var _runtimeInfoResponse$;
+					const agent = new ProxiedCopilotRuntimeAgent({
+						runtimeUrl: this.runtimeUrl,
+						agentId: id,
+						description,
+						transport: this._runtimeTransport,
+						credentials,
+						runtimeMode: (_runtimeInfoResponse$ = runtimeInfoResponse.mode) !== null && _runtimeInfoResponse$ !== void 0 ? _runtimeInfoResponse$ : _copilotkit_shared.RUNTIME_MODE_SSE,
+						intelligence: runtimeInfoResponse.intelligence
+					});
+					this.applyHeadersToAgent(agent);
+					return [id, agent];
+				}));
+				this._agents = {
+					...this.localAgents,
+					...this.remoteAgents
+				};
+				this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Connected;
+				this._runtimeVersion = version;
+				this._audioFileTranscriptionEnabled = (_runtimeInfoResponse$2 = runtimeInfoResponse.audioFileTranscriptionEnabled) !== null && _runtimeInfoResponse$2 !== void 0 ? _runtimeInfoResponse$2 : false;
+				this._runtimeMode = (_runtimeInfoResponse$3 = runtimeInfoResponse.mode) !== null && _runtimeInfoResponse$3 !== void 0 ? _runtimeInfoResponse$3 : _copilotkit_shared.RUNTIME_MODE_SSE;
+				this._intelligence = runtimeInfoResponse.intelligence;
+				this._a2uiEnabled = (_runtimeInfoResponse$4 = runtimeInfoResponse.a2uiEnabled) !== null && _runtimeInfoResponse$4 !== void 0 ? _runtimeInfoResponse$4 : false;
+				this._licenseStatus = runtimeInfoResponse.licenseStatus;
+				await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Connected);
+				await this.notifyAgentsChanged();
+			} catch (error) {
+				this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Error;
+				this._runtimeVersion = void 0;
+				this._audioFileTranscriptionEnabled = false;
+				this._runtimeMode = _copilotkit_shared.RUNTIME_MODE_SSE;
+				this._intelligence = void 0;
+				this._a2uiEnabled = false;
+				this.remoteAgents = {};
+				this._agents = this.localAgents;
+				await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Error);
+				await this.notifyAgentsChanged();
+				const message = error instanceof Error ? error.message : JSON.stringify(error);
+				_copilotkit_shared.logger.warn(`Failed to load runtime info (${this.runtimeUrl}/info): ${message}`);
+				const runtimeError = error instanceof Error ? error : new Error(String(error));
+				await this.core.emitError({
+					error: runtimeError,
+					code: CopilotKitCoreErrorCode.RUNTIME_INFO_FETCH_FAILED,
+					context: { runtimeUrl: this.runtimeUrl }
+				});
+			}
+		}
+		async fetchRuntimeInfo() {
+			if (!this.runtimeUrl) throw new Error("Runtime URL is not set");
+			const baseHeaders = this.core.headers;
+			const credentials = this.core.credentials;
+			const headers = { ...baseHeaders };
+			if (this._runtimeTransport === "single") {
+				if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+				const response = await fetch(this.runtimeUrl, {
+					method: "POST",
+					headers,
+					body: JSON.stringify({ method: "info" }),
+					...credentials ? { credentials } : {}
+				});
+				if ("ok" in response && !response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
+				return await response.json();
+			}
+			const response = await fetch(`${this.runtimeUrl}/info`, {
+				headers,
+				...credentials ? { credentials } : {}
+			});
+			if ("ok" in response && !response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
+			return await response.json();
+		}
+		/**
+		* Assign agent IDs to a record of agents
+		*/
+		assignAgentIds(agents) {
+			Object.entries(agents).forEach(([id, agent]) => {
+				if (agent) this.validateAndAssignAgentId(id, agent);
+			});
+			return agents;
+		}
+		/**
+		* Validate and assign an agent ID
+		*/
+		validateAndAssignAgentId(registrationId, agent) {
+			if (agent.agentId && agent.agentId !== registrationId) throw new Error(`Agent registration mismatch: Agent with ID "${agent.agentId}" cannot be registered under key "${registrationId}". The agent ID must match the registration key or be undefined.`);
+			if (!agent.agentId) agent.agentId = registrationId;
+		}
+		/**
+		* Notify subscribers of runtime status changes
+		*/
+		async notifyRuntimeStatusChanged(status) {
+			await this.core.notifySubscribers((subscriber) => {
+				var _subscriber$onRuntime;
+				return (_subscriber$onRuntime = subscriber.onRuntimeConnectionStatusChanged) === null || _subscriber$onRuntime === void 0 ? void 0 : _subscriber$onRuntime.call(subscriber, {
+					copilotkit: this.core,
+					status
+				});
+			}, "Error in CopilotKitCore subscriber (onRuntimeConnectionStatusChanged):");
+		}
+		/**
+		* Notify subscribers of agent changes
+		*/
+		async notifyAgentsChanged() {
+			await this.core.notifySubscribers((subscriber) => {
+				var _subscriber$onAgentsC;
+				return (_subscriber$onAgentsC = subscriber.onAgentsChanged) === null || _subscriber$onAgentsC === void 0 ? void 0 : _subscriber$onAgentsC.call(subscriber, {
+					copilotkit: this.core,
+					agents: this._agents
+				});
+			}, "Subscriber onAgentsChanged error:");
+		}
+	};
+
+//#endregion
+//#region src/core/context-store.ts
+/**
+	* Manages context storage and lifecycle for CopilotKitCore.
+	* Context represents additional information available to agents during execution.
+	*/
+	var ContextStore = class {
+		constructor(core) {
+			this.core = core;
+			_defineProperty(this, "_context", {});
+		}
+		/**
+		* Get all context entries as a readonly record
+		*/
+		get context() {
+			return this._context;
+		}
+		/**
+		* Add a new context entry
+		* @returns The ID of the created context entry
+		*/
+		addContext({ description, value }) {
+			const id = (0, _copilotkit_shared.randomUUID)();
+			this._context[id] = {
+				description,
+				value
+			};
+			this.notifySubscribers();
+			return id;
+		}
+		/**
+		* Remove a context entry by ID
+		*/
+		removeContext(id) {
+			delete this._context[id];
+			this.notifySubscribers();
+		}
+		/**
+		* Notify all subscribers of context changes
+		*/
+		async notifySubscribers() {
+			await this.core.notifySubscribers((subscriber) => {
+				var _subscriber$onContext;
+				return (_subscriber$onContext = subscriber.onContextChanged) === null || _subscriber$onContext === void 0 ? void 0 : _subscriber$onContext.call(subscriber, {
+					copilotkit: this.core,
+					context: this._context
+				});
+			}, "Subscriber onContextChanged error:");
+		}
+	};
+
+//#endregion
+//#region src/core/suggestion-engine.ts
+/**
+	* Manages suggestion generation, streaming, and lifecycle for CopilotKitCore.
+	* Handles both dynamic (AI-generated) and static suggestions.
+	*/
+	var SuggestionEngine = class {
+		constructor(core) {
+			this.core = core;
+			_defineProperty(this, "_suggestionsConfig", {});
+			_defineProperty(this, "_suggestions", {});
+			_defineProperty(this, "_runningSuggestions", {});
+		}
+		/**
+		* Initialize with suggestion configs
+		*/
+		initialize(suggestionsConfig) {
+			for (const config of suggestionsConfig) this._suggestionsConfig[(0, _copilotkit_shared.randomUUID)()] = config;
+		}
+		/**
+		* Add a suggestion configuration
+		* @returns The ID of the created config
+		*/
+		addSuggestionsConfig(config) {
+			const id = (0, _copilotkit_shared.randomUUID)();
+			this._suggestionsConfig[id] = config;
+			this.notifySuggestionsConfigChanged();
+			return id;
+		}
+		/**
+		* Remove a suggestion configuration by ID
+		*/
+		removeSuggestionsConfig(id) {
+			delete this._suggestionsConfig[id];
+			this.notifySuggestionsConfigChanged();
+		}
+		/**
+		* Reload suggestions for a specific agent
+		* This triggers generation of new suggestions based on current configs
+		*
+		* @param agentId - The consumer agent ID
+		* @param consumerAgent - Optional: the specific agent instance whose messages should be used
+		*   for availability filtering and context. When running with per-thread clones, the thread
+		*   clone holds the conversation messages; passing it here ensures dynamic suggestions fire
+		*   after the first message even though the registry agent has an empty message list.
+		*/
+		reloadSuggestions(agentId, consumerAgent) {
+			var _agent$messages$lengt, _agent$messages;
+			this.clearSuggestions(agentId);
+			const agent = consumerAgent !== null && consumerAgent !== void 0 ? consumerAgent : this.core.getAgent(agentId);
+			if (!agent) return;
+			const messageCount = (_agent$messages$lengt = (_agent$messages = agent.messages) === null || _agent$messages === void 0 ? void 0 : _agent$messages.length) !== null && _agent$messages$lengt !== void 0 ? _agent$messages$lengt : 0;
+			let hasAnySuggestions = false;
+			for (const config of Object.values(this._suggestionsConfig)) {
+				if (config.consumerAgentId !== void 0 && config.consumerAgentId !== "*" && config.consumerAgentId !== agentId) continue;
+				if (!this.shouldShowSuggestions(config, messageCount)) continue;
+				const suggestionId = (0, _copilotkit_shared.randomUUID)();
+				if (isDynamicSuggestionsConfig(config)) {
+					if (!hasAnySuggestions) {
+						hasAnySuggestions = true;
+						this.notifySuggestionsStartedLoading(agentId);
+					}
+					this.generateSuggestions(suggestionId, config, agentId, agent);
+				} else if (isStaticSuggestionsConfig(config)) this.addStaticSuggestions(suggestionId, config, agentId);
+			}
+		}
+		/**
+		* Clear all suggestions for a specific agent
+		*/
+		clearSuggestions(agentId) {
+			const runningAgents = this._runningSuggestions[agentId];
+			if (runningAgents) {
+				for (const agent of runningAgents) agent.abortRun();
+				delete this._runningSuggestions[agentId];
+			}
+			this._suggestions[agentId] = {};
+			this.notifySuggestionsChanged(agentId, []);
+		}
+		/**
+		* Get current suggestions for an agent
+		*/
+		getSuggestions(agentId) {
+			var _this$_suggestions$ag, _this$_runningSuggest, _this$_runningSuggest2;
+			return {
+				suggestions: Object.values((_this$_suggestions$ag = this._suggestions[agentId]) !== null && _this$_suggestions$ag !== void 0 ? _this$_suggestions$ag : {}).flat(),
+				isLoading: ((_this$_runningSuggest = (_this$_runningSuggest2 = this._runningSuggestions[agentId]) === null || _this$_runningSuggest2 === void 0 ? void 0 : _this$_runningSuggest2.length) !== null && _this$_runningSuggest !== void 0 ? _this$_runningSuggest : 0) > 0
+			};
+		}
+		/**
+		* Generate suggestions using a provider agent
+		*/
+		async generateSuggestions(suggestionId, config, consumerAgentId, consumerAgent) {
+			let agent = void 0;
+			try {
+				var _config$providerAgent, _this$_suggestions$co, _this$_runningSuggest3, _config$minSuggestion, _config$maxSuggestion;
+				const suggestionsProviderAgent = this.core.getAgent((_config$providerAgent = config.providerAgentId) !== null && _config$providerAgent !== void 0 ? _config$providerAgent : "default");
+				if (!suggestionsProviderAgent) throw new Error(`Suggestions provider agent not found: ${config.providerAgentId}`);
+				const suggestionsConsumerAgent = consumerAgent !== null && consumerAgent !== void 0 ? consumerAgent : this.core.getAgent(consumerAgentId);
+				if (!suggestionsConsumerAgent) throw new Error(`Suggestions consumer agent not found: ${consumerAgentId}`);
+				agent = suggestionsProviderAgent.clone();
+				agent.threadId = suggestionId;
+				agent.messages = JSON.parse(JSON.stringify(suggestionsConsumerAgent.messages));
+				agent.state = JSON.parse(JSON.stringify(suggestionsConsumerAgent.state));
+				this._suggestions[consumerAgentId] = {
+					...(_this$_suggestions$co = this._suggestions[consumerAgentId]) !== null && _this$_suggestions$co !== void 0 ? _this$_suggestions$co : {},
+					[suggestionId]: []
+				};
+				this._runningSuggestions[consumerAgentId] = [...(_this$_runningSuggest3 = this._runningSuggestions[consumerAgentId]) !== null && _this$_runningSuggest3 !== void 0 ? _this$_runningSuggest3 : [], agent];
+				agent.addMessage({
+					id: suggestionId,
+					role: "user",
+					content: [
+						`Suggest what the user could say next. Provide clear, highly relevant suggestions by calling the \`copilotkitSuggest\` tool.`,
+						`Provide at least ${(_config$minSuggestion = config.minSuggestions) !== null && _config$minSuggestion !== void 0 ? _config$minSuggestion : 1} and at most ${(_config$maxSuggestion = config.maxSuggestions) !== null && _config$maxSuggestion !== void 0 ? _config$maxSuggestion : 3} suggestions.`,
+						`The user has the following tools available: ${JSON.stringify(this.core.buildFrontendTools(consumerAgentId))}.`,
+						` ${config.instructions}`
+					].join("\n")
+				});
+				await agent.runAgent({
+					context: Object.values(this.core.context),
+					forwardedProps: {
+						...this.core.properties,
+						toolChoice: {
+							type: "function",
+							function: { name: "copilotkitSuggest" }
+						}
+					},
+					tools: [SUGGEST_TOOL]
+				}, { onMessagesChanged: ({ messages }) => {
+					this.extractSuggestions(messages, suggestionId, consumerAgentId, true);
+				} });
+			} catch (error) {
+				console.warn("Error generating suggestions:", error);
+			} finally {
+				this.finalizeSuggestions(suggestionId, consumerAgentId);
+				const runningAgents = this._runningSuggestions[consumerAgentId];
+				if (agent && runningAgents) {
+					const filteredAgents = runningAgents.filter((a) => a !== agent);
+					this._runningSuggestions[consumerAgentId] = filteredAgents;
+					if (filteredAgents.length === 0) {
+						delete this._runningSuggestions[consumerAgentId];
+						await this.notifySuggestionsFinishedLoading(consumerAgentId);
+					}
+				}
+			}
+		}
+		/**
+		* Finalize suggestions by marking them as no longer loading
+		*/
+		finalizeSuggestions(suggestionId, consumerAgentId) {
+			const agentSuggestions = this._suggestions[consumerAgentId];
+			const currentSuggestions = agentSuggestions === null || agentSuggestions === void 0 ? void 0 : agentSuggestions[suggestionId];
+			if (agentSuggestions && currentSuggestions && currentSuggestions.length > 0) {
+				var _this$_suggestions$co2;
+				const finalizedSuggestions = currentSuggestions.filter((suggestion) => suggestion.title !== "" || suggestion.message !== "").map((suggestion) => ({
+					...suggestion,
+					isLoading: false
+				}));
+				if (finalizedSuggestions.length > 0) agentSuggestions[suggestionId] = finalizedSuggestions;
+				else delete agentSuggestions[suggestionId];
+				const allSuggestions = Object.values((_this$_suggestions$co2 = this._suggestions[consumerAgentId]) !== null && _this$_suggestions$co2 !== void 0 ? _this$_suggestions$co2 : {}).flat();
+				this.notifySuggestionsChanged(consumerAgentId, allSuggestions, "finalized");
+			}
+		}
+		/**
+		* Extract suggestions from messages (called during streaming)
+		*/
+		extractSuggestions(messages, suggestionId, consumerAgentId, isRunning) {
+			const idx = messages.findIndex((message) => message.id === suggestionId);
+			if (idx == -1) return;
+			const suggestions = [];
+			const newMessages = messages.slice(idx + 1);
+			for (const message of newMessages) if (message.role === "assistant" && message.toolCalls) {
+				for (const toolCall of message.toolCalls) if (toolCall.function.name === "copilotkitSuggest") {
+					const parsed = (0, _copilotkit_shared.partialJSONParse)(Array.isArray(toolCall.function.arguments) ? toolCall.function.arguments.join("") : toolCall.function.arguments);
+					if (parsed && typeof parsed === "object" && "suggestions" in parsed) {
+						const parsedSuggestions = parsed.suggestions;
+						if (Array.isArray(parsedSuggestions)) {
+							for (const item of parsedSuggestions) if (item && typeof item === "object" && "title" in item) {
+								var _item$title, _item$message;
+								suggestions.push({
+									title: (_item$title = item.title) !== null && _item$title !== void 0 ? _item$title : "",
+									message: (_item$message = item.message) !== null && _item$message !== void 0 ? _item$message : "",
+									isLoading: false
+								});
+							}
+						}
+					}
+				}
+			}
+			if (isRunning && suggestions.length > 0) suggestions[suggestions.length - 1].isLoading = true;
+			const agentSuggestions = this._suggestions[consumerAgentId];
+			if (agentSuggestions) {
+				var _this$_suggestions$co3;
+				agentSuggestions[suggestionId] = suggestions;
+				const allSuggestions = Object.values((_this$_suggestions$co3 = this._suggestions[consumerAgentId]) !== null && _this$_suggestions$co3 !== void 0 ? _this$_suggestions$co3 : {}).flat();
+				this.notifySuggestionsChanged(consumerAgentId, allSuggestions, "suggestions changed");
+			}
+		}
+		/**
+		* Notify subscribers of suggestions config changes
+		*/
+		async notifySuggestionsConfigChanged() {
+			await this.core.notifySubscribers((subscriber) => {
+				var _subscriber$onSuggest;
+				return (_subscriber$onSuggest = subscriber.onSuggestionsConfigChanged) === null || _subscriber$onSuggest === void 0 ? void 0 : _subscriber$onSuggest.call(subscriber, {
+					copilotkit: this.core,
+					suggestionsConfig: this._suggestionsConfig
+				});
+			}, "Subscriber onSuggestionsConfigChanged error:");
+		}
+		/**
+		* Notify subscribers of suggestions changes
+		*/
+		async notifySuggestionsChanged(agentId, suggestions, context = "") {
+			await this.core.notifySubscribers((subscriber) => {
+				var _subscriber$onSuggest2;
+				return (_subscriber$onSuggest2 = subscriber.onSuggestionsChanged) === null || _subscriber$onSuggest2 === void 0 ? void 0 : _subscriber$onSuggest2.call(subscriber, {
+					copilotkit: this.core,
+					agentId,
+					suggestions
+				});
+			}, `Subscriber onSuggestionsChanged error: ${context}`);
+		}
+		/**
+		* Notify subscribers that suggestions started loading
+		*/
+		async notifySuggestionsStartedLoading(agentId) {
+			await this.core.notifySubscribers((subscriber) => {
+				var _subscriber$onSuggest3;
+				return (_subscriber$onSuggest3 = subscriber.onSuggestionsStartedLoading) === null || _subscriber$onSuggest3 === void 0 ? void 0 : _subscriber$onSuggest3.call(subscriber, {
+					copilotkit: this.core,
+					agentId
+				});
+			}, "Subscriber onSuggestionsStartedLoading error:");
+		}
+		/**
+		* Notify subscribers that suggestions finished loading
+		*/
+		async notifySuggestionsFinishedLoading(agentId) {
+			await this.core.notifySubscribers((subscriber) => {
+				var _subscriber$onSuggest4;
+				return (_subscriber$onSuggest4 = subscriber.onSuggestionsFinishedLoading) === null || _subscriber$onSuggest4 === void 0 ? void 0 : _subscriber$onSuggest4.call(subscriber, {
+					copilotkit: this.core,
+					agentId
+				});
+			}, "Subscriber onSuggestionsFinishedLoading error:");
+		}
+		/**
+		* Check if suggestions should be shown based on availability and message count
+		*/
+		shouldShowSuggestions(config, messageCount) {
+			const availability = config.available;
+			if (!availability) if (isDynamicSuggestionsConfig(config)) return messageCount > 0;
+			else return messageCount === 0;
+			switch (availability) {
+				case "disabled": return false;
+				case "before-first-message": return messageCount === 0;
+				case "after-first-message": return messageCount > 0;
+				case "always": return true;
+				default: return false;
+			}
+		}
+		/**
+		* Add static suggestions directly without AI generation
+		*/
+		addStaticSuggestions(suggestionId, config, consumerAgentId) {
+			var _this$_suggestions$co4, _this$_suggestions$co5;
+			const suggestions = config.suggestions.map((s) => ({
+				...s,
+				isLoading: false
+			}));
+			this._suggestions[consumerAgentId] = {
+				...(_this$_suggestions$co4 = this._suggestions[consumerAgentId]) !== null && _this$_suggestions$co4 !== void 0 ? _this$_suggestions$co4 : {},
+				[suggestionId]: suggestions
+			};
+			const allSuggestions = Object.values((_this$_suggestions$co5 = this._suggestions[consumerAgentId]) !== null && _this$_suggestions$co5 !== void 0 ? _this$_suggestions$co5 : {}).flat();
+			this.notifySuggestionsChanged(consumerAgentId, allSuggestions, "static suggestions added");
+		}
+	};
+	/**
+	* Type guard for dynamic suggestions config
+	*/
+	function isDynamicSuggestionsConfig(config) {
+		return "instructions" in config;
+	}
+	/**
+	* Type guard for static suggestions config
+	*/
+	function isStaticSuggestionsConfig(config) {
+		return "suggestions" in config;
+	}
+	/**
+	* The tool definition for AI-generated suggestions
+	*/
+	const SUGGEST_TOOL = {
+		name: "copilotkitSuggest",
+		description: "Suggest what the user could say next",
+		parameters: {
+			type: "object",
+			properties: { suggestions: {
+				type: "array",
+				description: "List of suggestions shown to the user as buttons.",
+				items: {
+					type: "object",
+					properties: {
+						title: {
+							type: "string",
+							description: "The title of the suggestion. This is shown as a button and should be short."
+						},
+						message: {
+							type: "string",
+							description: "The message to send when the suggestion is clicked. This should be a clear, complete sentence and will be sent as an instruction to the AI."
+						}
+					},
+					required: ["title", "message"]
+				}
+			} },
+			required: ["suggestions"]
+		}
+	};
+
+//#endregion
+//#region src/core/run-handler.ts
+/**
+	* Handles agent execution, tool calling, and agent connectivity for CopilotKitCore.
+	* Manages the complete lifecycle of agent runs including tool execution and follow-ups.
+	*/
+	var RunHandler = class {
+		constructor(core) {
+			this.core = core;
+			_defineProperty(this, "_tools", []);
+			_defineProperty(this, "_runAbortController", null);
+			_defineProperty(this, "_runDepth", 0);
+		}
+		/**
+		* Abort the current run. Called by `CopilotKitCore.stopAgent()` to signal
+		* that in-flight tool handlers should stop and `processAgentResult` should
+		* not start a follow-up run.
+		*/
+		abortCurrentRun() {
+			var _this$_runAbortContro;
+			(_this$_runAbortContro = this._runAbortController) === null || _this$_runAbortContro === void 0 || _this$_runAbortContro.abort();
+		}
+		/**
+		* Typed access to CopilotKitCore's internal ("friend") methods.
+		* Centralises the single unavoidable cast so call-sites stay clean.
+		*/
+		get _internal() {
+			return this.core;
+		}
+		/**
+		* Get all tools as a readonly array
+		*/
+		get tools() {
+			return this._tools;
+		}
+		/**
+		* Initialize with tools
+		*/
+		initialize(tools) {
+			this._tools = tools;
+		}
+		/**
+		* Add a tool to the registry
+		*/
+		addTool(tool) {
+			if (this._tools.findIndex((t) => t.name === tool.name && t.agentId === tool.agentId) !== -1) {
+				_copilotkit_shared.logger.warn(`Tool already exists: '${tool.name}' for agent '${tool.agentId || "global"}', skipping.`);
+				return;
+			}
+			this._tools.push(tool);
+		}
+		/**
+		* Remove a tool by name and optionally by agentId
+		*/
+		removeTool(id, agentId) {
+			this._tools = this._tools.filter((tool) => {
+				if (agentId !== void 0) return !(tool.name === id && tool.agentId === agentId);
+				return !(tool.name === id && !tool.agentId);
+			});
+		}
+		/**
+		* Get a tool by name and optionally by agentId.
+		* If agentId is provided, it will first look for an agent-specific tool,
+		* then fall back to a global tool with the same name.
+		*/
+		getTool(params) {
+			const { toolName, agentId } = params;
+			if (agentId) {
+				const agentTool = this._tools.find((tool) => tool.name === toolName && tool.agentId === agentId);
+				if (agentTool) return agentTool;
+			}
+			return this._tools.find((tool) => tool.name === toolName && !tool.agentId);
+		}
+		/**
+		* Set all tools at once. Replaces existing tools.
+		*/
+		setTools(tools) {
+			this._tools = [...tools];
+		}
+		/**
+		* Connect an agent (establish initial connection)
+		*/
+		async connectAgent({ agent }) {
+			try {
+				await agent.detachActiveRun();
+				agent.setMessages([]);
+				agent.setState({});
+				if (agent instanceof _ag_ui_client.HttpAgent) agent.headers = { ...this._internal.headers };
+				const runAgentResult = await agent.connectAgent({
+					forwardedProps: this._internal.properties,
+					tools: this.buildFrontendTools(agent.agentId),
+					context: Object.values(this._internal.context)
+				}, this.createAgentErrorSubscriber(agent));
+				return this.processAgentResult({
+					runAgentResult,
+					agent
+				});
+			} catch (error) {
+				const connectError = error instanceof Error ? error : new Error(String(error));
+				const context = {};
+				if (agent.agentId) context.agentId = agent.agentId;
+				await this._internal.emitError({
+					error: connectError,
+					code: CopilotKitCoreErrorCode.AGENT_CONNECT_FAILED,
+					context
+				});
+				return { newMessages: [] };
+			}
+		}
+		/**
+		* Run an agent
+		*/
+		async runAgent({ agent, forwardedProps }) {
+			if (agent.agentId) this._internal.suggestionEngine.clearSuggestions(agent.agentId);
+			if (agent instanceof _ag_ui_client.HttpAgent) agent.headers = { ...this._internal.headers };
+			if (agent.detachActiveRun) await agent.detachActiveRun();
+			this._internal.subscribeAgentToStateManager(agent);
+			const isTopLevel = this._runDepth === 0;
+			let originalAbortRun;
+			if (isTopLevel) {
+				this._runAbortController = new AbortController();
+				const controller = this._runAbortController;
+				originalAbortRun = agent.abortRun.bind(agent);
+				agent.abortRun = () => {
+					controller.abort();
+					originalAbortRun();
+				};
+			}
+			this._runDepth++;
+			try {
+				const runAgentResult = await agent.runAgent({
+					forwardedProps: {
+						...this._internal.properties,
+						...forwardedProps
+					},
+					tools: this.buildFrontendTools(agent.agentId),
+					context: Object.values(this._internal.context)
+				}, this.createAgentErrorSubscriber(agent));
+				return await this.processAgentResult({
+					runAgentResult,
+					agent
+				});
+			} catch (error) {
+				const runError = error instanceof Error ? error : new Error(String(error));
+				const context = {};
+				if (agent.agentId) context.agentId = agent.agentId;
+				await this._internal.emitError({
+					error: runError,
+					code: CopilotKitCoreErrorCode.AGENT_RUN_FAILED,
+					context
+				});
+				return { newMessages: [] };
+			} finally {
+				this._runDepth--;
+				if (isTopLevel && originalAbortRun) agent.abortRun = originalAbortRun;
+			}
+		}
+		/**
+		* Process agent result and execute tools
+		*/
+		async processAgentResult({ runAgentResult, agent }) {
+			var _this$_runAbortContro2;
+			const { newMessages } = runAgentResult;
+			const agentId = agent.agentId;
+			let needsFollowUp = false;
+			for (const message of newMessages) if (message.role === "assistant") {
+				for (const toolCall of message.toolCalls || []) if (newMessages.findIndex((m) => m.role === "tool" && m.toolCallId === toolCall.id) === -1) {
+					const tool = this.getTool({
+						toolName: toolCall.function.name,
+						agentId: agent.agentId
+					});
+					if (tool) {
+						if (await this.executeSpecificTool(tool, toolCall, message, agent, agentId)) needsFollowUp = true;
+					} else {
+						const wildcardTool = this.getTool({
+							toolName: "*",
+							agentId: agent.agentId
+						});
+						if (wildcardTool) {
+							if (await this.executeWildcardTool(wildcardTool, toolCall, message, agent, agentId)) needsFollowUp = true;
+						}
+					}
+				}
+			}
+			if (needsFollowUp && !((_this$_runAbortContro2 = this._runAbortController) === null || _this$_runAbortContro2 === void 0 ? void 0 : _this$_runAbortContro2.signal.aborted)) {
+				await this._internal.waitForPendingFrameworkUpdates();
+				return await this.runAgent({ agent });
+			}
+			this._internal.suggestionEngine.reloadSuggestions(agentId, agent);
+			return runAgentResult;
+		}
+		/**
+		* Shared handler execution logic used by executeSpecificTool, executeWildcardTool, and runTool.
+		* Handles arg parsing, subscriber notifications, handler invocation, result stringification,
+		* and error handling.
+		*/
+		async executeToolHandler({ tool, toolCall, agent, agentId, handlerArgs, toolType, messageId }) {
+			let toolCallResult = "";
+			let errorMessage;
+			let isArgumentError = false;
+			let parsedArgs;
+			try {
+				parsedArgs = parseToolArguments(handlerArgs, toolCall.function.name);
+			} catch (error) {
+				const parseError = error instanceof Error ? error : new Error(String(error));
+				errorMessage = parseError.message;
+				isArgumentError = true;
+				await this._internal.emitError({
+					error: parseError,
+					code: CopilotKitCoreErrorCode.TOOL_ARGUMENT_PARSE_FAILED,
+					context: {
+						agentId,
+						toolCallId: toolCall.id,
+						toolName: toolCall.function.name,
+						rawArguments: handlerArgs,
+						toolType,
+						...messageId ? { messageId } : {}
+					}
+				});
+			}
+			await this._internal.notifySubscribers((subscriber) => {
+				var _subscriber$onToolExe;
+				return (_subscriber$onToolExe = subscriber.onToolExecutionStart) === null || _subscriber$onToolExe === void 0 ? void 0 : _subscriber$onToolExe.call(subscriber, {
+					copilotkit: this.core,
+					toolCallId: toolCall.id,
+					agentId,
+					toolName: toolCall.function.name,
+					args: parsedArgs
+				});
+			}, "Subscriber onToolExecutionStart error:");
+			if (!errorMessage) try {
+				var _this$_runAbortContro3;
+				const result = await tool.handler(parsedArgs, {
+					toolCall,
+					agent,
+					signal: (_this$_runAbortContro3 = this._runAbortController) === null || _this$_runAbortContro3 === void 0 ? void 0 : _this$_runAbortContro3.signal
+				});
+				if (result === void 0 || result === null) toolCallResult = "";
+				else if (typeof result === "string") toolCallResult = result;
+				else toolCallResult = JSON.stringify(result);
+			} catch (error) {
+				const handlerError = error instanceof Error ? error : new Error(String(error));
+				errorMessage = handlerError.message;
+				await this._internal.emitError({
+					error: handlerError,
+					code: CopilotKitCoreErrorCode.TOOL_HANDLER_FAILED,
+					context: {
+						agentId,
+						toolCallId: toolCall.id,
+						toolName: toolCall.function.name,
+						parsedArgs,
+						toolType,
+						...messageId ? { messageId } : {}
+					}
+				});
+			}
+			if (errorMessage) toolCallResult = `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, {
+					copilotkit: this.core,
+					toolCallId: toolCall.id,
+					agentId,
+					toolName: toolCall.function.name,
+					result: errorMessage ? "" : toolCallResult,
+					error: errorMessage
+				});
+			}, "Subscriber onToolExecutionEnd error:");
+			return {
+				result: toolCallResult,
+				error: errorMessage,
+				isArgumentError
+			};
+		}
+		/**
+		* Execute a specific tool
+		*/
+		async executeSpecificTool(tool, toolCall, message, agent, agentId) {
+			if ((tool === null || tool === void 0 ? void 0 : tool.agentId) && tool.agentId !== agent.agentId) return false;
+			let handlerResult = {
+				result: "",
+				error: void 0,
+				isArgumentError: false
+			};
+			if (tool === null || tool === void 0 ? void 0 : tool.handler) handlerResult = await this.executeToolHandler({
+				tool,
+				toolCall,
+				agent,
+				agentId,
+				handlerArgs: toolCall.function.arguments,
+				toolType: "specific",
+				messageId: message.id
+			});
+			{
+				const messageIndex = agent.messages.findIndex((m) => m.id === message.id);
+				if (messageIndex === -1) return false;
+				const toolMessage = {
+					id: (0, _copilotkit_shared.randomUUID)(),
+					role: "tool",
+					toolCallId: toolCall.id,
+					content: handlerResult.result
+				};
+				agent.messages.splice(messageIndex + 1, 0, toolMessage);
+				if (!handlerResult.error && (tool === null || tool === void 0 ? void 0 : tool.followUp) !== false) return true;
+			}
+			return false;
+		}
+		/**
+		* Execute a wildcard tool.
+		* Wildcard tools receive args wrapped as `{toolName, args}`, which differs from
+		* specific tools, so this method keeps its own arg-wrapping logic rather than
+		* delegating to `executeToolHandler`.
+		*/
+		async executeWildcardTool(wildcardTool, toolCall, message, agent, agentId) {
+			if ((wildcardTool === null || wildcardTool === void 0 ? void 0 : wildcardTool.agentId) && wildcardTool.agentId !== agent.agentId) return false;
+			let toolCallResult = "";
+			let errorMessage;
+			if (wildcardTool === null || wildcardTool === void 0 ? void 0 : wildcardTool.handler) {
+				let parsedArgs;
+				try {
+					parsedArgs = parseToolArguments(toolCall.function.arguments, toolCall.function.name);
+				} catch (error) {
+					const parseError = error instanceof Error ? error : new Error(String(error));
+					errorMessage = parseError.message;
+					await this._internal.emitError({
+						error: parseError,
+						code: CopilotKitCoreErrorCode.TOOL_ARGUMENT_PARSE_FAILED,
+						context: {
+							agentId,
+							toolCallId: toolCall.id,
+							toolName: toolCall.function.name,
+							rawArguments: toolCall.function.arguments,
+							toolType: "wildcard",
+							messageId: message.id
+						}
+					});
+				}
+				const wildcardArgs = {
+					toolName: toolCall.function.name,
+					args: parsedArgs
+				};
+				await this._internal.notifySubscribers((subscriber) => {
+					var _subscriber$onToolExe3;
+					return (_subscriber$onToolExe3 = subscriber.onToolExecutionStart) === null || _subscriber$onToolExe3 === void 0 ? void 0 : _subscriber$onToolExe3.call(subscriber, {
+						copilotkit: this.core,
+						toolCallId: toolCall.id,
+						agentId,
+						toolName: toolCall.function.name,
+						args: wildcardArgs
+					});
+				}, "Subscriber onToolExecutionStart error:");
+				if (!errorMessage) try {
+					const result = await wildcardTool.handler(wildcardArgs, {
+						toolCall,
+						agent
+					});
+					if (result === void 0 || result === null) toolCallResult = "";
+					else if (typeof result === "string") toolCallResult = result;
+					else toolCallResult = JSON.stringify(result);
+				} catch (error) {
+					const handlerError = error instanceof Error ? error : new Error(String(error));
+					errorMessage = handlerError.message;
+					await this._internal.emitError({
+						error: handlerError,
+						code: CopilotKitCoreErrorCode.TOOL_HANDLER_FAILED,
+						context: {
+							agentId,
+							toolCallId: toolCall.id,
+							toolName: toolCall.function.name,
+							parsedArgs: wildcardArgs,
+							toolType: "wildcard",
+							messageId: message.id
+						}
+					});
+				}
+				if (errorMessage) toolCallResult = `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, {
+						copilotkit: this.core,
+						toolCallId: toolCall.id,
+						agentId,
+						toolName: toolCall.function.name,
+						result: errorMessage ? "" : toolCallResult,
+						error: errorMessage
+					});
+				}, "Subscriber onToolExecutionEnd error:");
+			}
+			{
+				const messageIndex = agent.messages.findIndex((m) => m.id === message.id);
+				if (messageIndex === -1) return false;
+				const toolMessage = {
+					id: (0, _copilotkit_shared.randomUUID)(),
+					role: "tool",
+					toolCallId: toolCall.id,
+					content: toolCallResult
+				};
+				agent.messages.splice(messageIndex + 1, 0, toolMessage);
+				if (!errorMessage && (wildcardTool === null || wildcardTool === void 0 ? void 0 : wildcardTool.followUp) !== false) return true;
+			}
+			return false;
+		}
+		/**
+		* Programmatically execute a registered frontend tool without going through an LLM turn.
+		* The handler runs, render components show up in the UI, and both the tool call and
+		* result messages are added to `agent.messages`.
+		*/
+		async runTool(params) {
+			const { name, agentId, parameters = {}, followUp = false } = params;
+			const tool = this.getTool({
+				toolName: name,
+				agentId
+			});
+			if (!tool) {
+				const error = /* @__PURE__ */ new Error(`Tool not found: ${name}`);
+				await this._internal.emitError({
+					error,
+					code: CopilotKitCoreErrorCode.TOOL_NOT_FOUND,
+					context: {
+						toolName: name,
+						agentId
+					}
+				});
+				throw error;
+			}
+			const resolvedAgentId = agentId !== null && agentId !== void 0 ? agentId : "default";
+			const agent = this._internal.getAgent(resolvedAgentId);
+			if (!agent) {
+				const error = /* @__PURE__ */ new Error(`Agent not found: ${resolvedAgentId}`);
+				await this._internal.emitError({
+					error,
+					code: CopilotKitCoreErrorCode.AGENT_NOT_FOUND,
+					context: { agentId: resolvedAgentId }
+				});
+				throw error;
+			}
+			const toolCallId = (0, _copilotkit_shared.randomUUID)();
+			const assistantMessage = {
+				id: (0, _copilotkit_shared.randomUUID)(),
+				role: "assistant",
+				content: "",
+				toolCalls: [{
+					id: toolCallId,
+					type: "function",
+					function: {
+						name,
+						arguments: JSON.stringify(parameters)
+					}
+				}]
+			};
+			agent.messages.push(assistantMessage);
+			let handlerResult = {
+				result: "",
+				error: void 0,
+				isArgumentError: false
+			};
+			if (tool.handler) handlerResult = await this.executeToolHandler({
+				tool,
+				toolCall: assistantMessage.toolCalls[0],
+				agent,
+				agentId: resolvedAgentId,
+				handlerArgs: parameters,
+				toolType: "runTool"
+			});
+			const toolResultMessage = {
+				id: (0, _copilotkit_shared.randomUUID)(),
+				role: "tool",
+				toolCallId,
+				content: handlerResult.result
+			};
+			const assistantIndex = agent.messages.findIndex((m) => m.id === assistantMessage.id);
+			if (assistantIndex !== -1) agent.messages.splice(assistantIndex + 1, 0, toolResultMessage);
+			else agent.messages.push(toolResultMessage);
+			if (!handlerResult.error && followUp !== false) {
+				if (typeof followUp === "string" && followUp !== "generate") {
+					const userMessage = {
+						id: (0, _copilotkit_shared.randomUUID)(),
+						role: "user",
+						content: followUp
+					};
+					agent.messages.push(userMessage);
+				}
+				await this._internal.waitForPendingFrameworkUpdates();
+				await this.runAgent({ agent });
+			}
+			return {
+				toolCallId,
+				result: handlerResult.result,
+				error: handlerResult.error
+			};
+		}
+		/**
+		* Build frontend tools for an agent
+		*/
+		buildFrontendTools(agentId) {
+			return this._tools.filter((tool) => tool.available !== false && (!tool.agentId || tool.agentId === agentId)).map((tool) => {
+				var _tool$description;
+				return {
+					name: tool.name,
+					description: (_tool$description = tool.description) !== null && _tool$description !== void 0 ? _tool$description : "",
+					parameters: createToolSchema(tool)
+				};
+			});
+		}
+		/**
+		* Create an agent error subscriber
+		*/
+		createAgentErrorSubscriber(agent) {
+			const emitAgentError = async (error, code, extraContext = {}) => {
+				const context = { ...extraContext };
+				if (agent.agentId) context.agentId = agent.agentId;
+				await this._internal.emitError({
+					error,
+					code,
+					context
+				});
+			};
+			return {
+				onRunFailed: async ({ error }) => {
+					await emitAgentError(error, error instanceof AgentThreadLockedError ? CopilotKitCoreErrorCode.AGENT_THREAD_LOCKED : CopilotKitCoreErrorCode.AGENT_RUN_FAILED_EVENT, { source: "onRunFailed" });
+				},
+				onRunErrorEvent: async ({ event }) => {
+					var _event$rawEvent, _event$rawEvent2, _event$message;
+					const eventError = (event === null || event === void 0 ? void 0 : event.rawEvent) instanceof Error ? event.rawEvent : (event === null || event === void 0 || (_event$rawEvent = event.rawEvent) === null || _event$rawEvent === void 0 ? void 0 : _event$rawEvent.error) instanceof Error ? event.rawEvent.error : void 0;
+					const errorMessage = typeof (event === null || event === void 0 || (_event$rawEvent2 = event.rawEvent) === null || _event$rawEvent2 === void 0 ? void 0 : _event$rawEvent2.error) === "string" ? event.rawEvent.error : (_event$message = event === null || event === void 0 ? void 0 : event.message) !== null && _event$message !== void 0 ? _event$message : "Agent run error";
+					const rawError = eventError !== null && eventError !== void 0 ? eventError : new Error(errorMessage);
+					if ((event === null || event === void 0 ? void 0 : event.code) && !rawError.code) rawError.code = event.code;
+					await emitAgentError(rawError, CopilotKitCoreErrorCode.AGENT_RUN_ERROR_EVENT, {
+						source: "onRunErrorEvent",
+						event,
+						runtimeErrorCode: event === null || event === void 0 ? void 0 : event.code
+					});
+				}
+			};
+		}
+	};
+	/**
+	* Empty tool schema constant
+	*/
+	const EMPTY_TOOL_SCHEMA = {
+		type: "object",
+		properties: {}
+	};
+	/**
+	* Create a JSON schema from a tool's parameters
+	*/
+	function createToolSchema(tool) {
+		if (!tool.parameters) return { ...EMPTY_TOOL_SCHEMA };
+		const rawSchema = (0, _copilotkit_shared.schemaToJsonSchema)(tool.parameters, { zodToJsonSchema: zod_to_json_schema.zodToJsonSchema });
+		if (!rawSchema || typeof rawSchema !== "object") return { ...EMPTY_TOOL_SCHEMA };
+		const { $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.
+	*
+	* @internal Exported for testing only.
+	*/
+	function ensureObjectArgs(parsed, toolName) {
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return parsed;
+		throw new Error(`Tool arguments for ${toolName} parsed to non-object (${typeof parsed})`);
+	}
+	/**
+	* Parses raw tool call arguments into a validated object.
+	*
+	* Some LLM providers (e.g. @ai-sdk/openai-compatible) may send empty string "",
+	* null, or undefined instead of "{}". This function normalises those cases to an
+	* empty object so callers don't crash on JSON.parse("").
+	*
+	* A debug-level warning is emitted when the fallback triggers so silent coercion
+	* is observable in logs.
+	*
+	* @internal Exported for testing only.
+	*/
+	function parseToolArguments(rawArgs, toolName) {
+		if (rawArgs === "" || rawArgs === null || rawArgs === void 0) {
+			_copilotkit_shared.logger.debug(`[parseToolArguments] Tool "${toolName}" received empty/null/undefined arguments — defaulting to {}`);
+			return {};
+		}
+		return ensureObjectArgs(typeof rawArgs === "string" ? JSON.parse(rawArgs) : rawArgs, toolName);
+	}
+
+//#endregion
+//#region src/core/state-manager.ts
+/**
+	* Manages state and message tracking by run for CopilotKitCore.
+	* Tracks agent state snapshots and message-to-run associations.
+	*/
+	var StateManager = class {
+		constructor(core) {
+			this.core = core;
+			_defineProperty(this, "stateByRun", /* @__PURE__ */ new Map());
+			_defineProperty(this, "messageToRun", /* @__PURE__ */ new Map());
+			_defineProperty(this, "activeRun", /* @__PURE__ */ new Map());
+			_defineProperty(this, "agentSubscriptions", /* @__PURE__ */ new Map());
+		}
+		/**
+		* Initialize state tracking for an agent
+		*/
+		initialize() {}
+		/**
+		* Subscribe to an agent's events to track state and messages.
+		*
+		* Registry agents (subscribed via `onAgentsChanged`) use the bare `agentId`
+		* key so that `unsubscribeFromAgent(agentId)` can remove them when they
+		* are replaced. Per-thread clones (subscribed via `subscribeAgentToStateManager`)
+		* pass `{ isClone: true }` to use a composite `agentId:threadId` key, keeping
+		* their subscription independent of the registry agent's.
+		*/
+		subscribeToAgent(agent, { isClone = false } = {}) {
+			if (!agent.agentId) return;
+			const agentId = agent.agentId;
+			const subscriptionKey = isClone && agent.threadId ? `${agentId}:${agent.threadId}` : agentId;
+			const existingUnsubscribe = this.agentSubscriptions.get(subscriptionKey);
+			if (existingUnsubscribe) {
+				existingUnsubscribe();
+				this.agentSubscriptions.delete(subscriptionKey);
+			}
+			let revoked = false;
+			let subRunId;
+			let runFinished = false;
+			const effectiveInput = (input) => {
+				var _subRunId;
+				return {
+					...input,
+					runId: (_subRunId = subRunId) !== null && _subRunId !== void 0 ? _subRunId : input.runId
+				};
+			};
+			const { unsubscribe } = agent.subscribe({
+				onRunStartedEvent: ({ input, state }) => {
+					if (revoked) return;
+					if (runFinished && input.runId === subRunId) subRunId = (0, _ag_ui_client.randomUUID)();
+					else subRunId = input.runId;
+					runFinished = false;
+					this.handleRunStarted(agent, effectiveInput(input), state);
+				},
+				onRunFinishedEvent: ({ input, state }) => {
+					if (revoked) return;
+					runFinished = true;
+					this.handleRunFinished(agent, effectiveInput(input), state);
+				},
+				onStateSnapshotEvent: ({ event, input, state }) => {
+					if (revoked) return;
+					this.handleStateSnapshot(agent, event, effectiveInput(input), state);
+				},
+				onStateDeltaEvent: ({ event, input, state }) => {
+					if (revoked) return;
+					this.handleStateDelta(agent, event, effectiveInput(input), state);
+				},
+				onMessagesSnapshotEvent: ({ event, input, messages }) => {
+					if (revoked) return;
+					this.handleMessagesSnapshot(agent, event, effectiveInput(input), messages);
+				},
+				onNewMessage: ({ message, input }) => {
+					if (revoked) return;
+					this.handleNewMessage(agent, message, input ? effectiveInput(input) : void 0);
+				}
+			});
+			this.agentSubscriptions.set(subscriptionKey, () => {
+				revoked = true;
+				unsubscribe();
+			});
+		}
+		/**
+		* Unsubscribe a registry agent's subscription (bare `agentId` key).
+		* Per-thread clone subscriptions use composite `agentId:threadId` keys and
+		* are replaced (not removed) by subsequent subscribeToAgent(agent, { isClone: true })
+		* calls for the same (agentId, threadId) pair.
+		*/
+		unsubscribeFromAgent(agentId) {
+			const unsubscribe = this.agentSubscriptions.get(agentId);
+			if (unsubscribe) {
+				unsubscribe();
+				this.agentSubscriptions.delete(agentId);
+			}
+		}
+		/**
+		* Get state for a specific run
+		* Returns a deep copy to prevent external mutations
+		*/
+		getStateByRun(agentId, threadId, runId) {
+			var _this$stateByRun$get;
+			const state = (_this$stateByRun$get = this.stateByRun.get(agentId)) === null || _this$stateByRun$get === void 0 || (_this$stateByRun$get = _this$stateByRun$get.get(threadId)) === null || _this$stateByRun$get === void 0 ? void 0 : _this$stateByRun$get.get(runId);
+			if (!state) return void 0;
+			return JSON.parse(JSON.stringify(state));
+		}
+		/**
+		* Get runId associated with a message
+		*/
+		getRunIdForMessage(agentId, threadId, messageId) {
+			var _this$messageToRun$ge;
+			return (_this$messageToRun$ge = this.messageToRun.get(agentId)) === null || _this$messageToRun$ge === void 0 || (_this$messageToRun$ge = _this$messageToRun$ge.get(threadId)) === null || _this$messageToRun$ge === void 0 ? void 0 : _this$messageToRun$ge.get(messageId);
+		}
+		/**
+		* Get all states for an agent's thread
+		*/
+		getStatesForThread(agentId, threadId) {
+			var _this$stateByRun$get$, _this$stateByRun$get2;
+			return (_this$stateByRun$get$ = (_this$stateByRun$get2 = this.stateByRun.get(agentId)) === null || _this$stateByRun$get2 === void 0 ? void 0 : _this$stateByRun$get2.get(threadId)) !== null && _this$stateByRun$get$ !== void 0 ? _this$stateByRun$get$ : /* @__PURE__ */ new Map();
+		}
+		/**
+		* Get all run IDs for an agent's thread
+		*/
+		getRunIdsForThread(agentId, threadId) {
+			var _this$stateByRun$get3;
+			const threadStates = (_this$stateByRun$get3 = this.stateByRun.get(agentId)) === null || _this$stateByRun$get3 === void 0 ? void 0 : _this$stateByRun$get3.get(threadId);
+			return threadStates ? Array.from(threadStates.keys()) : [];
+		}
+		/**
+		* Handle run started event
+		*/
+		handleRunStarted(agent, input, state) {
+			if (!agent.agentId) return;
+			const { threadId, runId } = input;
+			this.activeRun.set(`${agent.agentId}:${threadId}`, runId);
+			if (state && Object.keys(state).length > 0) this.saveState(agent.agentId, threadId, runId, state);
+		}
+		/**
+		* Handle run finished event
+		*/
+		handleRunFinished(agent, input, state) {
+			if (!agent.agentId) return;
+			const { threadId, runId } = input;
+			this.activeRun.delete(`${agent.agentId}:${threadId}`);
+			if (state && Object.keys(state).length > 0) this.saveState(agent.agentId, threadId, runId, state);
+		}
+		/**
+		* Handle state snapshot event
+		*/
+		handleStateSnapshot(agent, event, input, state) {
+			if (!agent.agentId) return;
+			const { threadId, runId } = input;
+			const mergedState = {
+				...state,
+				...event.snapshot
+			};
+			this.saveState(agent.agentId, threadId, runId, mergedState);
+		}
+		/**
+		* Handle state delta event
+		*/
+		handleStateDelta(agent, event, input, state) {
+			if (!agent.agentId) return;
+			const { threadId, runId } = input;
+			this.saveState(agent.agentId, threadId, runId, state);
+		}
+		/**
+		* Handle messages snapshot event
+		*/
+		handleMessagesSnapshot(agent, event, input, messages) {
+			if (!agent.agentId) return;
+			const { threadId, runId } = input;
+			for (const message of event.messages) this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
+		}
+		/**
+		* Handle new message event
+		*/
+		handleNewMessage(agent, message, input) {
+			if (!agent.agentId) return;
+			if (!input) {
+				var _agent$threadId;
+				const threadId = (_agent$threadId = agent.threadId) !== null && _agent$threadId !== void 0 ? _agent$threadId : "";
+				const runId = this.activeRun.get(`${agent.agentId}:${threadId}`);
+				if (runId) this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
+				return;
+			}
+			const { threadId, runId } = input;
+			this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
+		}
+		/**
+		* Save state for a specific run
+		*/
+		saveState(agentId, threadId, runId, state) {
+			if (!this.stateByRun.has(agentId)) this.stateByRun.set(agentId, /* @__PURE__ */ new Map());
+			const agentStates = this.stateByRun.get(agentId);
+			if (!agentStates.has(threadId)) agentStates.set(threadId, /* @__PURE__ */ new Map());
+			agentStates.get(threadId).set(runId, JSON.parse(JSON.stringify(state)));
+		}
+		/**
+		* Associate a message with a run
+		*/
+		associateMessageWithRun(agentId, threadId, messageId, runId) {
+			if (!this.messageToRun.has(agentId)) this.messageToRun.set(agentId, /* @__PURE__ */ new Map());
+			const agentMessages = this.messageToRun.get(agentId);
+			if (!agentMessages.has(threadId)) agentMessages.set(threadId, /* @__PURE__ */ new Map());
+			agentMessages.get(threadId).set(messageId, runId);
+		}
+		/**
+		* Clear all state for an agent
+		*/
+		clearAgentState(agentId) {
+			this.stateByRun.delete(agentId);
+			this.messageToRun.delete(agentId);
+		}
+		/**
+		* Clear all state for a thread
+		*/
+		clearThreadState(agentId, threadId) {
+			var _this$stateByRun$get4, _this$messageToRun$ge2;
+			(_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);
+		}
+	};
+
+//#endregion
+//#region src/core/core.ts
+	let CopilotKitCoreErrorCode = /* @__PURE__ */ function(CopilotKitCoreErrorCode) {
+		CopilotKitCoreErrorCode["RUNTIME_INFO_FETCH_FAILED"] = "runtime_info_fetch_failed";
+		CopilotKitCoreErrorCode["AGENT_CONNECT_FAILED"] = "agent_connect_failed";
+		CopilotKitCoreErrorCode["AGENT_RUN_FAILED"] = "agent_run_failed";
+		CopilotKitCoreErrorCode["AGENT_RUN_FAILED_EVENT"] = "agent_run_failed_event";
+		CopilotKitCoreErrorCode["AGENT_RUN_ERROR_EVENT"] = "agent_run_error_event";
+		CopilotKitCoreErrorCode["TOOL_ARGUMENT_PARSE_FAILED"] = "tool_argument_parse_failed";
+		CopilotKitCoreErrorCode["TOOL_HANDLER_FAILED"] = "tool_handler_failed";
+		CopilotKitCoreErrorCode["TOOL_NOT_FOUND"] = "tool_not_found";
+		CopilotKitCoreErrorCode["AGENT_NOT_FOUND"] = "agent_not_found";
+		/**
+		* Emitted when an agent run fails because the thread is already locked
+		* by another active run.
+		*
+		* @example
+		* ```tsx
+		* <CopilotKitProvider
+		*   onError={({ code, error, context }) => {
+		*     if (code === "agent_thread_locked") {
+		*       // Show "Agent is busy, retry?" UI
+		*     }
+		*   }}
+		* />
+		* ```
+		*/
+		CopilotKitCoreErrorCode["AGENT_THREAD_LOCKED"] = "agent_thread_locked";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_FAILED"] = "transcription_failed";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_SERVICE_NOT_CONFIGURED"] = "transcription_service_not_configured";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_INVALID_AUDIO"] = "transcription_invalid_audio";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_RATE_LIMITED"] = "transcription_rate_limited";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_AUTH_FAILED"] = "transcription_auth_failed";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_NETWORK_ERROR"] = "transcription_network_error";
+		return CopilotKitCoreErrorCode;
+	}({});
+	let CopilotKitCoreRuntimeConnectionStatus = /* @__PURE__ */ function(CopilotKitCoreRuntimeConnectionStatus) {
+		CopilotKitCoreRuntimeConnectionStatus["Disconnected"] = "disconnected";
+		CopilotKitCoreRuntimeConnectionStatus["Connected"] = "connected";
+		CopilotKitCoreRuntimeConnectionStatus["Connecting"] = "connecting";
+		CopilotKitCoreRuntimeConnectionStatus["Error"] = "error";
+		return CopilotKitCoreRuntimeConnectionStatus;
+	}({});
+	var CopilotKitCore = class {
+		constructor({ runtimeUrl, runtimeTransport = "rest", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [] }) {
+			_defineProperty(this, "_headers", void 0);
+			_defineProperty(this, "_credentials", void 0);
+			_defineProperty(this, "_properties", void 0);
+			_defineProperty(this, "subscribers", /* @__PURE__ */ new Set());
+			_defineProperty(this, "agentRegistry", void 0);
+			_defineProperty(this, "contextStore", void 0);
+			_defineProperty(this, "suggestionEngine", void 0);
+			_defineProperty(this, "runHandler", void 0);
+			_defineProperty(this, "stateManager", void 0);
+			this._headers = headers;
+			this._credentials = credentials;
+			this._properties = properties;
+			this.agentRegistry = new AgentRegistry(this);
+			this.contextStore = new ContextStore(this);
+			this.suggestionEngine = new SuggestionEngine(this);
+			this.runHandler = new RunHandler(this);
+			this.stateManager = new StateManager(this);
+			this.agentRegistry.initialize(agents__unsafe_dev_only);
+			this.runHandler.initialize(tools);
+			this.suggestionEngine.initialize(suggestionsConfig);
+			this.stateManager.initialize();
+			this.agentRegistry.setRuntimeTransport(runtimeTransport);
+			this.agentRegistry.setRuntimeUrl(runtimeUrl);
+			this.subscribe({ onAgentsChanged: ({ agents }) => {
+				Object.values(agents).forEach((agent) => {
+					if (agent.agentId) this.stateManager.subscribeToAgent(agent);
+				});
+			} });
+		}
+		/**
+		* Internal method used by delegate classes and subclasses to notify subscribers
+		*/
+		async notifySubscribers(handler, errorMessage) {
+			await Promise.all(Array.from(this.subscribers).map(async (subscriber) => {
+				try {
+					await handler(subscriber);
+				} catch (error) {
+					console.error(errorMessage, error);
+				}
+			}));
+		}
+		/**
+		* Internal method used by delegate classes to emit errors
+		*/
+		async emitError({ error, code, context = {} }) {
+			await this.notifySubscribers((subscriber) => {
+				var _subscriber$onError;
+				return (_subscriber$onError = subscriber.onError) === null || _subscriber$onError === void 0 ? void 0 : _subscriber$onError.call(subscriber, {
+					copilotkit: this,
+					error,
+					code,
+					context
+				});
+			}, "Subscriber onError error:");
+		}
+		/**
+		* Snapshot accessors
+		*/
+		get context() {
+			return this.contextStore.context;
+		}
+		get agents() {
+			return this.agentRegistry.agents;
+		}
+		get tools() {
+			return this.runHandler.tools;
+		}
+		get runtimeUrl() {
+			return this.agentRegistry.runtimeUrl;
+		}
+		setRuntimeUrl(runtimeUrl) {
+			this.agentRegistry.setRuntimeUrl(runtimeUrl);
+		}
+		get runtimeTransport() {
+			return this.agentRegistry.runtimeTransport;
+		}
+		setRuntimeTransport(runtimeTransport) {
+			this.agentRegistry.setRuntimeTransport(runtimeTransport);
+		}
+		get runtimeVersion() {
+			return this.agentRegistry.runtimeVersion;
+		}
+		get headers() {
+			return this._headers;
+		}
+		get credentials() {
+			return this._credentials;
+		}
+		get properties() {
+			return this._properties;
+		}
+		get runtimeConnectionStatus() {
+			return this.agentRegistry.runtimeConnectionStatus;
+		}
+		get audioFileTranscriptionEnabled() {
+			return this.agentRegistry.audioFileTranscriptionEnabled;
+		}
+		get runtimeMode() {
+			return this.agentRegistry.runtimeMode;
+		}
+		get intelligence() {
+			return this.agentRegistry.intelligence;
+		}
+		get a2uiEnabled() {
+			return this.agentRegistry.a2uiEnabled;
+		}
+		get licenseStatus() {
+			return this.agentRegistry.licenseStatus;
+		}
+		/**
+		* Configuration updates
+		*/
+		setHeaders(headers) {
+			this._headers = headers;
+			this.agentRegistry.applyHeadersToAgents(this.agentRegistry.agents);
+			this.notifySubscribers((subscriber) => {
+				var _subscriber$onHeaders;
+				return (_subscriber$onHeaders = subscriber.onHeadersChanged) === null || _subscriber$onHeaders === void 0 ? void 0 : _subscriber$onHeaders.call(subscriber, {
+					copilotkit: this,
+					headers: this.headers
+				});
+			}, "Subscriber onHeadersChanged error:");
+		}
+		setCredentials(credentials) {
+			this._credentials = credentials;
+			this.agentRegistry.applyCredentialsToAgents(this.agentRegistry.agents);
+		}
+		setProperties(properties) {
+			this._properties = properties;
+			this.notifySubscribers((subscriber) => {
+				var _subscriber$onPropert;
+				return (_subscriber$onPropert = subscriber.onPropertiesChanged) === null || _subscriber$onPropert === void 0 ? void 0 : _subscriber$onPropert.call(subscriber, {
+					copilotkit: this,
+					properties: this.properties
+				});
+			}, "Subscriber onPropertiesChanged error:");
+		}
+		/**
+		* Agent management (delegated to AgentRegistry)
+		*/
+		setAgents__unsafe_dev_only(agents) {
+			this.agentRegistry.setAgents__unsafe_dev_only(agents);
+		}
+		addAgent__unsafe_dev_only(params) {
+			this.agentRegistry.addAgent__unsafe_dev_only(params);
+		}
+		removeAgent__unsafe_dev_only(id) {
+			this.agentRegistry.removeAgent__unsafe_dev_only(id);
+		}
+		getAgent(id) {
+			return this.agentRegistry.getAgent(id);
+		}
+		/**
+		* Context management (delegated to ContextStore)
+		*/
+		addContext(context) {
+			return this.contextStore.addContext(context);
+		}
+		removeContext(id) {
+			this.contextStore.removeContext(id);
+		}
+		/**
+		* Suggestions management (delegated to SuggestionEngine)
+		*/
+		addSuggestionsConfig(config) {
+			return this.suggestionEngine.addSuggestionsConfig(config);
+		}
+		removeSuggestionsConfig(id) {
+			this.suggestionEngine.removeSuggestionsConfig(id);
+		}
+		reloadSuggestions(agentId) {
+			this.suggestionEngine.reloadSuggestions(agentId);
+		}
+		clearSuggestions(agentId) {
+			this.suggestionEngine.clearSuggestions(agentId);
+		}
+		getSuggestions(agentId) {
+			return this.suggestionEngine.getSuggestions(agentId);
+		}
+		/**
+		* Tool management (delegated to RunHandler)
+		*/
+		addTool(tool) {
+			this.runHandler.addTool(tool);
+		}
+		removeTool(id, agentId) {
+			this.runHandler.removeTool(id, agentId);
+		}
+		getTool(params) {
+			return this.runHandler.getTool(params);
+		}
+		setTools(tools) {
+			this.runHandler.setTools(tools);
+		}
+		/**
+		* Subscription lifecycle
+		*/
+		subscribe(subscriber) {
+			this.subscribers.add(subscriber);
+			return { unsubscribe: () => {
+				this.subscribers.delete(subscriber);
+			} };
+		}
+		/**
+		* Agent connectivity (delegated to RunHandler)
+		*/
+		async connectAgent(params) {
+			return this.runHandler.connectAgent(params);
+		}
+		stopAgent(params) {
+			this.runHandler.abortCurrentRun();
+			params.agent.abortRun();
+		}
+		async runAgent(params) {
+			return this.runHandler.runAgent(params);
+		}
+		/**
+		* Programmatically execute a registered frontend tool without going through an LLM turn.
+		* The handler runs, render components show up in the UI, and both the tool call and
+		* result messages are added to `agent.messages`.
+		*/
+		async runTool(params) {
+			return this.runHandler.runTool(params);
+		}
+		/**
+		* State management (delegated to StateManager)
+		*/
+		getStateByRun(agentId, threadId, runId) {
+			return this.stateManager.getStateByRun(agentId, threadId, runId);
+		}
+		getRunIdForMessage(agentId, threadId, messageId) {
+			return this.stateManager.getRunIdForMessage(agentId, threadId, messageId);
+		}
+		getRunIdsForThread(agentId, threadId) {
+			return this.stateManager.getRunIdsForThread(agentId, threadId);
+		}
+		subscribeAgentToStateManager(agent) {
+			this.stateManager.subscribeToAgent(agent, { isClone: true });
+		}
+		/**
+		* Internal method used by RunHandler to build frontend tools
+		*/
+		buildFrontendTools(agentId) {
+			return this.runHandler.buildFrontendTools(agentId);
+		}
+		/**
+		* Called before each follow-up agent run (after tool execution).
+		*
+		* When a frontend tool handler calls framework state setters (e.g. React's
+		* setState), those updates are batched and deferred — they do not take effect
+		* until the framework's scheduler runs (React uses MessageChannel).
+		* useAgentContext registers context via useLayoutEffect, which runs
+		* synchronously after React commits that deferred batch.
+		*
+		* Without yielding here, the follow-up runAgent reads the context store
+		* synchronously while the deferred updates are still pending, producing stale
+		* context for the next agent turn.
+		*
+		* Override in framework-specific subclasses to yield to the framework
+		* scheduler before the follow-up run. The base implementation is a no-op
+		* because non-React environments have no deferred state to flush.
+		*/
+		async waitForPendingFrameworkUpdates() {}
+	};
+
+//#endregion
+//#region src/types.ts
+/**
+	* Status of a tool call execution
+	*/
+	let ToolCallStatus = /* @__PURE__ */ function(ToolCallStatus) {
+		ToolCallStatus["InProgress"] = "inProgress";
+		ToolCallStatus["Executing"] = "executing";
+		ToolCallStatus["Complete"] = "complete";
+		return ToolCallStatus;
+	}({});
+
+//#endregion
+//#region src/utils/markdown.ts
+	function completePartialMarkdown(input) {
+		let s = input;
+		const fenceMatches = Array.from(s.matchAll(/^(\s*)(`{3,}|~{3,})/gm));
+		if (fenceMatches.length % 2 === 1) {
+			const [, indent, fence] = fenceMatches[0];
+			s += `\n${indent}${fence}`;
+		}
+		if (s.match(/\[([^\]]*)\]\(([^)]*)$/)) s += ")";
+		const openElements = [];
+		const chars = Array.from(s);
+		const codeBlockRanges = [];
+		const inlineCodeRanges = [];
+		let tempCodeFenceCount = 0;
+		let currentCodeBlockStart = -1;
+		for (let i = 0; i < chars.length; i++) if (i === 0 || chars[i - 1] === "\n") {
+			const lineMatch = s.substring(i).match(/^(\s*)(`{3,}|~{3,})/);
+			if (lineMatch) {
+				tempCodeFenceCount++;
+				if (tempCodeFenceCount % 2 === 1) currentCodeBlockStart = i;
+				else if (currentCodeBlockStart !== -1) {
+					codeBlockRanges.push({
+						start: currentCodeBlockStart,
+						end: i + lineMatch[0].length
+					});
+					currentCodeBlockStart = -1;
+				}
+				i += lineMatch[0].length - 1;
+			}
+		}
+		for (let i = 0; i < chars.length; i++) if (chars[i] === "`") {
+			let backslashCount = 0;
+			for (let j = i - 1; j >= 0 && chars[j] === "\\"; j--) backslashCount++;
+			if (backslashCount % 2 === 0) {
+				for (let j = i + 1; j < chars.length; j++) if (chars[j] === "`") {
+					let closingBackslashCount = 0;
+					for (let k = j - 1; k >= 0 && chars[k] === "\\"; k--) closingBackslashCount++;
+					if (closingBackslashCount % 2 === 0) {
+						inlineCodeRanges.push({
+							start: i,
+							end: j + 1
+						});
+						i = j;
+						break;
+					}
+				}
+			}
+		}
+		const isInCode = (pos) => {
+			return codeBlockRanges.some((range) => pos >= range.start && pos < range.end) || inlineCodeRanges.some((range) => pos >= range.start && pos < range.end);
+		};
+		for (let i = 0; i < chars.length; i++) {
+			const char = chars[i];
+			const nextChar = chars[i + 1];
+			const prevChar = chars[i - 1];
+			if (isInCode(i)) continue;
+			if (char === "[") {
+				let isCompleteLink = false;
+				let bracketDepth = 1;
+				let j = i + 1;
+				while (j < chars.length && bracketDepth > 0) {
+					if (chars[j] === "[" && !isInCode(j)) bracketDepth++;
+					if (chars[j] === "]" && !isInCode(j)) bracketDepth--;
+					j++;
+				}
+				if (bracketDepth === 0 && chars[j] === "(") {
+					let parenDepth = 1;
+					j++;
+					while (j < chars.length && parenDepth > 0) {
+						if (chars[j] === "(" && !isInCode(j)) parenDepth++;
+						if (chars[j] === ")" && !isInCode(j)) parenDepth--;
+						j++;
+					}
+					if (parenDepth === 0) {
+						isCompleteLink = true;
+						i = j - 1;
+						continue;
+					}
+				}
+				if (!isCompleteLink) {
+					const existingIndex = openElements.findIndex((el) => el.type === "bracket");
+					if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+					else openElements.push({
+						type: "bracket",
+						marker: "[",
+						position: i
+					});
+				}
+			} else if (char === "*" && nextChar === "*") {
+				const existingIndex = openElements.findIndex((el) => el.type === "bold_star");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "bold_star",
+					marker: "**",
+					position: i
+				});
+				i++;
+			} else if (char === "_" && nextChar === "_") {
+				const existingIndex = openElements.findIndex((el) => el.type === "bold_underscore");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "bold_underscore",
+					marker: "__",
+					position: i
+				});
+				i++;
+			} else if (char === "~" && nextChar === "~") {
+				const existingIndex = openElements.findIndex((el) => el.type === "strike");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "strike",
+					marker: "~~",
+					position: i
+				});
+				i++;
+			} else if (char === "*" && prevChar !== "*" && nextChar !== "*") {
+				const existingIndex = openElements.findIndex((el) => el.type === "italic_star");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "italic_star",
+					marker: "*",
+					position: i
+				});
+			} else if (char === "_" && prevChar !== "_" && nextChar !== "_") {
+				const existingIndex = openElements.findIndex((el) => el.type === "italic_underscore");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "italic_underscore",
+					marker: "_",
+					position: i
+				});
+			}
+		}
+		let backtickCount = 0;
+		for (let i = 0; i < chars.length; i++) if (chars[i] === "`" && !isInCode(i)) backtickCount++;
+		if (backtickCount % 2 === 1) s += "`";
+		openElements.sort((a, b) => b.position - a.position);
+		const closers = openElements.map((el) => {
+			switch (el.type) {
+				case "bracket": return "]";
+				case "bold_star": return "**";
+				case "bold_underscore": return "__";
+				case "strike": return "~~";
+				case "italic_star": return "*";
+				case "italic_underscore": return "_";
+				default: return "";
+			}
+		});
+		let result = s + closers.join("");
+		const finalFenceMatches = Array.from(result.matchAll(/^(\s*)(`{3,}|~{3,})/gm));
+		const hasUnclosedBacktick = (result.match(/`/g) || []).length % 2 === 1;
+		const hasUnclosedCodeFence = finalFenceMatches.length % 2 === 1;
+		let shouldCloseParens = !hasUnclosedBacktick && !hasUnclosedCodeFence;
+		if (shouldCloseParens) {
+			const lastOpenParen = result.lastIndexOf("(");
+			if (lastOpenParen !== -1) {
+				if ((result.substring(0, lastOpenParen).match(/`/g) || []).length % 2 === 1) shouldCloseParens = false;
+			}
+		}
+		if (shouldCloseParens) {
+			const openParens = (result.match(/\(/g) || []).length;
+			const closeParens = (result.match(/\)/g) || []).length;
+			if (openParens > closeParens) result += ")".repeat(openParens - closeParens);
+		}
+		return result;
+	}
+
+//#endregion
+//#region src/utils/micro-redux.ts
+	const INTERNAL_ACTION_TYPES = {
+		boot: "@@micro-redux/boot",
+		init: "@@micro-redux/init",
+		stop: "@@micro-redux/stop"
+	};
+	const INTERNAL_BOOT_ACTION = { type: INTERNAL_ACTION_TYPES.boot };
+	/**
+	* Builds a typed action creator from a type string and payload factory.
+	*/
+	function createTypedActionCreator(type, factory) {
+		const creator = ((...args) => ({
+			...factory(...args),
+			type
+		}));
+		creator.type = type;
+		creator.match = (action) => action.type === type;
+		return creator;
+	}
+	/**
+	* Declares a payload-based action config for `createActionGroup`.
+	*
+	* @example
+	* ```ts
+	* const actions = createActionGroup("User", {
+	*   loaded: props<{ id: string }>(),
+	* });
+	* ```
+	*/
+	function props() {
+		return { kind: "props" };
+	}
+	/**
+	* Declares a no-payload action config for `createActionGroup`.
+	*
+	* @example
+	* ```ts
+	* const actions = createActionGroup("User", {
+	*   reset: empty(),
+	* });
+	* ```
+	*/
+	function empty() {
+		return { kind: "empty" };
+	}
+	/**
+	* Creates a namespaced group of typed action creators.
+	*
+	* Action types are formatted as: `[Source] actionName`.
+	*/
+	function createActionGroup(source, config) {
+		const group = {};
+		for (const eventName of Object.keys(config)) {
+			const eventConfig = config[eventName];
+			if (!eventConfig) continue;
+			const actionType = `[${source}] ${eventName}`;
+			if (eventConfig.kind === "props") {
+				group[eventName] = createTypedActionCreator(actionType, (payload) => ({ ...payload }));
+				continue;
+			}
+			group[eventName] = createTypedActionCreator(actionType, () => ({}));
+		}
+		return group;
+	}
+	/**
+	* Registers one reducer handler for one or more action creators.
+	*
+	* @throws Error when called without at least one action creator and reducer.
+	*/
+	function on(...args) {
+		if (args.length < 2) throw new Error("on requires at least one action creator and one reducer");
+		const reducer = args[args.length - 1];
+		return {
+			creators: args.slice(0, -1),
+			reducer
+		};
+	}
+	/**
+	* Creates a reducer from an initial state and `on(...)` handler entries.
+	*
+	* Unknown action types return the current state unchanged.
+	*/
+	function createReducer(initialState, ...entries) {
+		const reducerMap = /* @__PURE__ */ new Map();
+		for (const entry of entries) for (const creator of entry.creators) {
+			var _reducerMap$get;
+			const handlers = (_reducerMap$get = reducerMap.get(creator.type)) !== null && _reducerMap$get !== void 0 ? _reducerMap$get : [];
+			handlers.push(entry.reducer);
+			reducerMap.set(creator.type, handlers);
+		}
+		return (state, action) => {
+			const currentState = state !== null && state !== void 0 ? state : initialState;
+			const handlers = reducerMap.get(action.type);
+			if (!handlers || handlers.length === 0) return currentState;
+			let nextState = currentState;
+			for (const handler of handlers) nextState = handler(nextState, action);
+			return nextState;
+		};
+	}
+	/**
+	* Creates a selector that caches and reuses the last computed result
+	* when all input references are unchanged.
+	*/
+	function createSelector(...args) {
+		if (args.length === 1) {
+			const projector = args[0];
+			let hasCached = false;
+			let lastState;
+			let lastResult;
+			return (state) => {
+				if (hasCached && state === lastState) return lastResult;
+				lastState = state;
+				lastResult = projector(state);
+				hasCached = true;
+				return lastResult;
+			};
+		}
+		const projector = args[args.length - 1];
+		const selectors = args.slice(0, -1);
+		let hasCached = false;
+		let lastInputs = [];
+		let lastResult;
+		return (state) => {
+			const inputs = selectors.map((selector) => selector(state));
+			if (hasCached && inputs.length === lastInputs.length && inputs.every((value, index) => value === lastInputs[index])) return lastResult;
+			lastInputs = inputs;
+			lastResult = projector(...inputs);
+			hasCached = true;
+			return lastResult;
+		};
+	}
+	/**
+	* RxJS operator that maps state emissions through a selector and suppresses
+	* unchanged projected values via reference equality.
+	*/
+	function select(selector) {
+		return (source$) => source$.pipe((0, rxjs_operators.map)(selector), (0, rxjs_operators.distinctUntilChanged)());
+	}
+	/**
+	* RxJS operator that filters an action stream by action creators and narrows
+	* the output action type to the matched creator union.
+	*
+	* @throws Error when called without at least one action creator.
+	*/
+	function ofType(...creators) {
+		if (creators.length === 0) throw new Error("ofType requires at least one action creator");
+		const actionTypes = new Set(creators.map((creator) => creator.type));
+		return (source$) => {
+			return source$.pipe((0, rxjs_operators.filter)((action) => {
+				return actionTypes.has(action.type);
+			}));
+		};
+	}
+	/**
+	* Creates an effect descriptor consumed by `createStore`.
+	*/
+	function createEffect(factory, options = {}) {
+		if (options.dispatch === false) return {
+			run: factory,
+			dispatch: false
+		};
+		return {
+			run: factory,
+			dispatch: true
+		};
+	}
+	/**
+	* Creates a small observable store with reducer + effects.
+	*
+	* Behavior:
+	* - `init()` starts effects and dispatches `@@micro-redux/init`.
+	* - `stop()` dispatches `@@micro-redux/stop` and unsubscribes all effects.
+	* - Effect action observation is scheduled on `asapScheduler` to avoid
+	*   synchronous re-entrancy in the effect loop.
+	* - Any effect error triggers fail-fast teardown and errors both `actions$`
+	*   and `state$`.
+	*/
+	function createStore(options) {
+		var _options$effects;
+		const reducer = options.reducer;
+		const effects = (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : [];
+		let hasFatalError = false;
+		let isRunning = false;
+		let effectSubscriptions = new rxjs.Subscription();
+		let currentState = reducer(void 0, INTERNAL_BOOT_ACTION);
+		const stateSubject = new rxjs.BehaviorSubject(currentState);
+		const actionsSubject = new rxjs.Subject();
+		const dispatchInternal = (action) => {
+			if (hasFatalError) throw new Error("Store is in a failed state due to an effect error");
+			currentState = reducer(currentState, action);
+			stateSubject.next(currentState);
+			actionsSubject.next(action);
+		};
+		const failFast = (error) => {
+			if (hasFatalError) return;
+			hasFatalError = true;
+			isRunning = false;
+			effectSubscriptions.unsubscribe();
+			effectSubscriptions = new rxjs.Subscription();
+			actionsSubject.error(error);
+			stateSubject.error(error);
+		};
+		const startEffects = () => {
+			for (const effect of effects) {
+				const scheduledActions$ = actionsSubject.asObservable().pipe((0, rxjs_operators.observeOn)(rxjs.asapScheduler));
+				const state$ = stateSubject.asObservable();
+				if (effect.dispatch) {
+					const subscription = effect.run(scheduledActions$, state$).subscribe({
+						next: (effectAction) => {
+							if (hasFatalError) return;
+							dispatchInternal(effectAction);
+						},
+						error: (error) => {
+							failFast(error);
+						}
+					});
+					effectSubscriptions.add(subscription);
+					continue;
+				}
+				const subscription = effect.run(scheduledActions$, state$).subscribe({ error: (error) => {
+					failFast(error);
+				} });
+				effectSubscriptions.add(subscription);
+			}
+		};
+		return {
+			dispatch(action) {
+				dispatchInternal(action);
+			},
+			getState() {
+				return currentState;
+			},
+			get state$() {
+				return stateSubject.asObservable();
+			},
+			get actions$() {
+				return actionsSubject.asObservable();
+			},
+			select(selector) {
+				return stateSubject.asObservable().pipe(select(selector));
+			},
+			init() {
+				if (hasFatalError || isRunning) return;
+				isRunning = true;
+				startEffects();
+				if (hasFatalError) return;
+				dispatchInternal({ type: INTERNAL_ACTION_TYPES.init });
+			},
+			stop() {
+				if (hasFatalError || !isRunning) return;
+				dispatchInternal({ type: INTERNAL_ACTION_TYPES.stop });
+				effectSubscriptions.unsubscribe();
+				effectSubscriptions = new rxjs.Subscription();
+				isRunning = false;
+			}
+		};
+	}
+
+//#endregion
+//#region src/threads.ts
+	const THREADS_CHANNEL_EVENT = "thread_metadata";
+	const THREAD_SUBSCRIBE_PATH = "/threads/subscribe";
+	const MAX_SOCKET_RETRIES = 5;
+	const REQUEST_TIMEOUT_MS = 15e3;
+	const initialThreadState = {
+		threads: [],
+		isLoading: false,
+		isFetchingNextPage: false,
+		error: null,
+		context: null,
+		sessionId: 0,
+		metadataCredentialsRequested: false,
+		metadataJoinCode: null,
+		nextCursor: null
+	};
+	const threadAdapterEvents = createActionGroup("Thread Adapter", {
+		started: empty(),
+		stopped: empty(),
+		contextChanged: props(),
+		fetchNextPageRequested: empty(),
+		renameRequested: props(),
+		archiveRequested: props(),
+		deleteRequested: props()
+	});
+	const threadRestEvents = createActionGroup("Thread REST", {
+		listRequested: props(),
+		listSucceeded: props(),
+		listFailed: props(),
+		nextPageSucceeded: props(),
+		nextPageFailed: props(),
+		metadataCredentialsRequested: props(),
+		metadataCredentialsSucceeded: props(),
+		metadataCredentialsFailed: props(),
+		mutationFinished: props()
+	});
+	const threadSocketEvents = createActionGroup("Thread Socket", {
+		opened: props(),
+		errored: props(),
+		joinFailed: props(),
+		joinTimedOut: props(),
+		metadataReceived: props()
+	});
+	const threadDomainEvents = createActionGroup("Thread Domain", {
+		threadUpserted: props(),
+		threadDeleted: props()
+	});
+	function sortThreadsByUpdatedAt(threads) {
+		return [...threads].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+	}
+	function upsertThread(threads, thread) {
+		const existingIndex = threads.findIndex((item) => item.id === thread.id);
+		if (existingIndex === -1) return sortThreadsByUpdatedAt([...threads, thread]);
+		const next = [...threads];
+		next[existingIndex] = thread;
+		return sortThreadsByUpdatedAt(next);
+	}
+	const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.contextChanged, (state, { context }) => ({
+		...state,
+		context,
+		sessionId: state.sessionId + 1,
+		threads: [],
+		isLoading: Boolean(context),
+		isFetchingNextPage: false,
+		error: null,
+		metadataCredentialsRequested: false,
+		metadataJoinCode: null,
+		nextCursor: null
+	})), on(threadAdapterEvents.stopped, (state) => ({
+		...state,
+		threads: [],
+		isLoading: false,
+		isFetchingNextPage: false,
+		error: null,
+		metadataCredentialsRequested: false,
+		metadataJoinCode: null,
+		nextCursor: null
+	})), on(threadRestEvents.listRequested, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId || !state.context) return state;
+		return {
+			...state,
+			isLoading: true,
+			error: null
+		};
+	}), on(threadRestEvents.listSucceeded, (state, { sessionId, threads, joinCode, nextCursor }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			threads: sortThreadsByUpdatedAt(threads),
+			isLoading: false,
+			error: null,
+			metadataJoinCode: joinCode,
+			nextCursor
+		};
+	}), on(threadRestEvents.listFailed, (state, { sessionId, error }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			isLoading: false,
+			error
+		};
+	}), on(threadRestEvents.nextPageSucceeded, (state, { sessionId, threads, nextCursor }) => {
+		if (sessionId !== state.sessionId) return state;
+		let merged = state.threads;
+		for (const thread of threads) merged = upsertThread(merged, thread);
+		return {
+			...state,
+			threads: merged,
+			isFetchingNextPage: false,
+			nextCursor
+		};
+	}), on(threadRestEvents.nextPageFailed, (state, { sessionId, error }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			isFetchingNextPage: false,
+			error
+		};
+	}), on(threadRestEvents.metadataCredentialsFailed, (state, { sessionId, error }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			error
+		};
+	}), on(threadRestEvents.metadataCredentialsRequested, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			metadataCredentialsRequested: true
+		};
+	}), on(threadAdapterEvents.fetchNextPageRequested, (state) => {
+		if (!state.nextCursor || state.isFetchingNextPage) return state;
+		return {
+			...state,
+			isFetchingNextPage: true
+		};
+	}), on(threadRestEvents.mutationFinished, (state, { outcome }) => ({
+		...state,
+		error: outcome.ok ? state.error : outcome.error
+	})), on(threadDomainEvents.threadUpserted, (state, { sessionId, thread }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			threads: upsertThread(state.threads, thread)
+		};
+	}), on(threadDomainEvents.threadDeleted, (state, { sessionId, threadId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			threads: state.threads.filter((thread) => thread.id !== threadId)
+		};
+	}));
+	const selectThreads = createSelector((state) => state.threads);
+	const selectThreadsIsLoading = createSelector((state) => state.isLoading);
+	const selectThreadsError = createSelector((state) => state.error);
+	const selectHasNextPage = createSelector((state) => state.nextCursor != null);
+	const selectIsFetchingNextPage = createSelector((state) => state.isFetchingNextPage);
+	let threadRequestId = 0;
+	function createThreadRequestId() {
+		threadRequestId += 1;
+		return `thread-request-${threadRequestId}`;
+	}
+	function createThreadFetchObservable(environment, context, sessionId) {
+		return (0, rxjs.defer)(() => {
+			const params = { agentId: context.agentId };
+			if (context.includeArchived) params.includeArchived = "true";
+			if (context.limit != null) params.limit = String(context.limit);
+			const qs = new URLSearchParams(params);
+			return (0, rxjs_fetch.fromFetch)(`${context.runtimeUrl}/threads?${qs.toString()}`, {
+				selector: (response) => {
+					if (!response.ok) throw new Error(`Failed to fetch threads: ${response.status}`);
+					return response.json();
+				},
+				fetch: environment.fetch,
+				method: "GET",
+				headers: { ...context.headers }
+			}).pipe((0, rxjs_operators.timeout)({
+				first: REQUEST_TIMEOUT_MS,
+				with: () => {
+					throw new Error("Request timed out");
+				}
+			}), (0, rxjs_operators.map)((data) => {
+				var _data$nextCursor;
+				return threadRestEvents.listSucceeded({
+					sessionId,
+					threads: data.threads,
+					joinCode: typeof data.joinCode === "string" && data.joinCode.length > 0 ? data.joinCode : null,
+					nextCursor: (_data$nextCursor = data.nextCursor) !== null && _data$nextCursor !== void 0 ? _data$nextCursor : null
+				});
+			}), (0, rxjs_operators.catchError)((error) => {
+				return (0, rxjs.of)(threadRestEvents.listFailed({
+					sessionId,
+					error: error instanceof Error ? error : new Error(String(error))
+				}));
+			}));
+		});
+	}
+	function createThreadMetadataCredentialsObservable(environment, context, sessionId) {
+		return (0, rxjs.defer)(() => {
+			return (0, rxjs_fetch.fromFetch)(`${context.runtimeUrl}${THREAD_SUBSCRIBE_PATH}`, {
+				selector: async (response) => {
+					if (!response.ok) throw new Error(`Failed to fetch thread metadata credentials: ${response.status}`);
+					return response.json();
+				},
+				fetch: environment.fetch,
+				method: "POST",
+				headers: {
+					...context.headers,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({})
+			}).pipe((0, rxjs_operators.timeout)({
+				first: REQUEST_TIMEOUT_MS,
+				with: () => {
+					throw new Error("Request timed out");
+				}
+			}), (0, rxjs_operators.map)((data) => {
+				if (typeof data.joinToken !== "string" || data.joinToken.length === 0) throw new Error("missing joinToken");
+				return threadRestEvents.metadataCredentialsSucceeded({
+					sessionId,
+					joinToken: data.joinToken
+				});
+			}), (0, rxjs_operators.catchError)((error) => {
+				return (0, rxjs.of)(threadRestEvents.metadataCredentialsFailed({
+					sessionId,
+					error: error instanceof Error ? error : new Error(String(error))
+				}));
+			}));
+		});
+	}
+	function createThreadMutationObservable(environment, context, request) {
+		return (0, rxjs.defer)(() => {
+			return (0, rxjs_fetch.fromFetch)(`${context.runtimeUrl}${request.path}`, {
+				selector: async (response) => {
+					if (!response.ok) throw new Error(`Request failed: ${response.status}`);
+					return null;
+				},
+				fetch: environment.fetch,
+				method: request.method,
+				headers: {
+					...context.headers,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify(request.body)
+			}).pipe((0, rxjs_operators.map)(() => threadRestEvents.mutationFinished({ outcome: {
+				requestId: request.requestId,
+				ok: true
+			} })), (0, rxjs_operators.catchError)((error) => {
+				return (0, rxjs.of)(threadRestEvents.mutationFinished({ outcome: {
+					requestId: request.requestId,
+					ok: false,
+					error: error instanceof Error ? error : new Error(String(error))
+				} }));
+			}));
+		});
+	}
+	function createThreadStore(environment) {
+		const store = createStore({
+			reducer: threadReducer,
+			effects: [
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadAdapterEvents.contextChanged), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([, state]) => Boolean(state.context)), (0, rxjs_operators.map)(([, state]) => threadRestEvents.listRequested({ sessionId: state.sessionId })))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.listRequested), (0, rxjs_operators.switchMap)((action) => state$.pipe((0, rxjs_operators.map)((state) => state.context), (0, rxjs_operators.filter)((context) => Boolean(context)), (0, rxjs_operators.take)(1), (0, rxjs_operators.map)((context) => ({
+					action,
+					context
+				})), (0, rxjs_operators.takeUntil)(actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped))), (0, rxjs_operators.switchMap)(({ action: currentAction, context }) => createThreadFetchObservable(environment, context, currentAction.sessionId)))))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.listSucceeded), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([action, state]) => {
+					var _state$context;
+					return action.sessionId === state.sessionId && !state.metadataCredentialsRequested && Boolean((_state$context = state.context) === null || _state$context === void 0 ? void 0 : _state$context.wsUrl) && Boolean(state.metadataJoinCode);
+				}), (0, rxjs_operators.map)(([action]) => threadRestEvents.metadataCredentialsRequested({ sessionId: action.sessionId })))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.metadataCredentialsRequested), (0, rxjs_operators.switchMap)((action) => state$.pipe((0, rxjs_operators.map)((state) => state.context), (0, rxjs_operators.filter)((context) => Boolean(context)), (0, rxjs_operators.take)(1), (0, rxjs_operators.map)((context) => ({
+					action,
+					context
+				})), (0, rxjs_operators.takeUntil)(actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped))), (0, rxjs_operators.switchMap)(({ action: currentAction, context }) => createThreadMetadataCredentialsObservable(environment, context, currentAction.sessionId)))))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.metadataCredentialsSucceeded), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([action, state]) => {
+					var _state$context2;
+					return action.sessionId === state.sessionId && Boolean((_state$context2 = state.context) === null || _state$context2 === void 0 ? void 0 : _state$context2.wsUrl);
+				}), (0, rxjs_operators.switchMap)(([action, state]) => {
+					const context = state.context;
+					const joinToken = action.joinToken;
+					const joinCode = state.metadataJoinCode;
+					const shutdown$ = actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped));
+					return (0, rxjs.defer)(() => {
+						const socket$ = ɵphoenixSocket$({
+							url: context.wsUrl,
+							options: {
+								params: { join_token: joinToken },
+								reconnectAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(100, 1e4),
+								rejoinAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(1e3, 3e4)
+							}
+						}).pipe((0, rxjs_operators.shareReplay)({
+							bufferSize: 1,
+							refCount: true
+						}));
+						const channel$ = ɵphoenixChannel$({
+							socket$,
+							topic: `user_meta:${joinCode}`
+						}).pipe((0, rxjs_operators.shareReplay)({
+							bufferSize: 1,
+							refCount: true
+						}));
+						const socketSignals$ = ɵobservePhoenixSocketSignals$(socket$).pipe((0, rxjs_operators.share)());
+						const fatalSocketShutdown$ = ɵobservePhoenixSocketHealth$(socketSignals$, MAX_SOCKET_RETRIES).pipe((0, rxjs_operators.catchError)(() => {
+							console.warn(`[threads] WebSocket failed after ${MAX_SOCKET_RETRIES} attempts, giving up`);
+							return (0, rxjs.of)(void 0);
+						}), (0, rxjs_operators.share)());
+						return (0, rxjs.merge)(socketSignals$.pipe((0, rxjs_operators.map)((signal) => signal.type === "open" ? threadSocketEvents.opened({ sessionId: action.sessionId }) : threadSocketEvents.errored({ sessionId: action.sessionId }))), channel$.pipe((0, rxjs_operators.switchMap)(({ channel }) => ɵobservePhoenixEvent$(channel, THREADS_CHANNEL_EVENT)), (0, rxjs_operators.map)((payload) => threadSocketEvents.metadataReceived({
+							sessionId: action.sessionId,
+							payload
+						}))), ɵobservePhoenixJoinOutcome$(channel$).pipe((0, rxjs_operators.filter)((outcome) => outcome.type !== "joined"), (0, rxjs_operators.map)((outcome) => outcome.type === "timeout" ? threadSocketEvents.joinTimedOut({ sessionId: action.sessionId }) : threadSocketEvents.joinFailed({ sessionId: action.sessionId })))).pipe((0, rxjs_operators.takeUntil)((0, rxjs.merge)(shutdown$, fatalSocketShutdown$)));
+					});
+				}))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadSocketEvents.metadataReceived), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([action, state]) => action.sessionId === state.sessionId), (0, rxjs_operators.map)(([action, state]) => {
+					var _state$context3;
+					if (action.payload.operation === "deleted") return threadDomainEvents.threadDeleted({
+						sessionId: action.sessionId,
+						threadId: action.payload.deleted.id
+					});
+					if (action.payload.operation === "archived" && !((_state$context3 = state.context) === null || _state$context3 === void 0 ? void 0 : _state$context3.includeArchived)) return threadDomainEvents.threadDeleted({
+						sessionId: action.sessionId,
+						threadId: action.payload.threadId
+					});
+					return threadDomainEvents.threadUpserted({
+						sessionId: action.sessionId,
+						thread: action.payload.thread
+					});
+				}))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadAdapterEvents.fetchNextPageRequested), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([, state]) => Boolean(state.context) && Boolean(state.nextCursor)), (0, rxjs_operators.switchMap)(([, state]) => {
+					const context = state.context;
+					const params = {
+						agentId: context.agentId,
+						cursor: state.nextCursor
+					};
+					if (context.includeArchived) params.includeArchived = "true";
+					if (context.limit != null) params.limit = String(context.limit);
+					return (0, rxjs_fetch.fromFetch)(`${context.runtimeUrl}/threads?${new URLSearchParams(params).toString()}`, {
+						selector: (response) => {
+							if (!response.ok) throw new Error(`Failed to fetch next page: ${response.status}`);
+							return response.json();
+						},
+						fetch: environment.fetch,
+						method: "GET",
+						headers: { ...context.headers }
+					}).pipe((0, rxjs_operators.timeout)({
+						first: REQUEST_TIMEOUT_MS,
+						with: () => {
+							throw new Error("Request timed out");
+						}
+					}), (0, rxjs_operators.map)((data) => {
+						var _data$nextCursor2;
+						return threadRestEvents.nextPageSucceeded({
+							sessionId: state.sessionId,
+							threads: data.threads,
+							nextCursor: (_data$nextCursor2 = data.nextCursor) !== null && _data$nextCursor2 !== void 0 ? _data$nextCursor2 : null
+						});
+					}), (0, rxjs_operators.catchError)((error) => (0, rxjs.of)(threadRestEvents.nextPageFailed({
+						sessionId: state.sessionId,
+						error: error instanceof Error ? error : new Error(String(error))
+					}))), (0, rxjs_operators.takeUntil)(actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped))));
+				}))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadAdapterEvents.renameRequested, threadAdapterEvents.archiveRequested, threadAdapterEvents.deleteRequested), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.mergeMap)(([action, state]) => {
+					const context = state.context;
+					if (!(context === null || context === void 0 ? void 0 : context.runtimeUrl)) {
+						const requestId = action.requestId;
+						return (0, rxjs.of)(threadRestEvents.mutationFinished({ outcome: {
+							requestId,
+							ok: false,
+							error: /* @__PURE__ */ new Error("Runtime URL is not configured")
+						} }));
+					}
+					const commonBody = { agentId: context.agentId };
+					if (threadAdapterEvents.renameRequested.match(action)) return createThreadMutationObservable(environment, context, {
+						requestId: action.requestId,
+						method: "PATCH",
+						path: `/threads/${encodeURIComponent(action.threadId)}`,
+						body: {
+							...commonBody,
+							name: action.name
+						}
+					});
+					if (threadAdapterEvents.archiveRequested.match(action)) return createThreadMutationObservable(environment, context, {
+						requestId: action.requestId,
+						method: "POST",
+						path: `/threads/${encodeURIComponent(action.threadId)}/archive`,
+						body: commonBody
+					});
+					return createThreadMutationObservable(environment, context, {
+						requestId: action.requestId,
+						method: "DELETE",
+						path: `/threads/${encodeURIComponent(action.threadId)}`,
+						body: commonBody
+					});
+				})))
+			]
+		});
+		function trackMutation(dispatchAction) {
+			const resultPromise = (0, rxjs.firstValueFrom)((0, rxjs.merge)(store.actions$.pipe(ofType(threadRestEvents.mutationFinished), (0, rxjs_operators.filter)((action) => action.outcome.requestId === dispatchAction.requestId), (0, rxjs_operators.map)((action) => action.outcome)), store.actions$.pipe(ofType(threadAdapterEvents.stopped), (0, rxjs_operators.map)(() => ({
+				requestId: dispatchAction.requestId,
+				ok: false,
+				error: /* @__PURE__ */ new Error("Thread store stopped before mutation completed")
+			})))).pipe((0, rxjs_operators.take)(1))).then((outcome) => {
+				if (outcome.ok) return;
+				throw outcome.error;
+			});
+			store.dispatch(dispatchAction);
+			return resultPromise;
+		}
+		return {
+			start() {
+				store.init();
+				store.dispatch(threadAdapterEvents.started());
+			},
+			stop() {
+				store.dispatch(threadAdapterEvents.stopped());
+				store.stop();
+			},
+			setContext(context) {
+				store.dispatch(threadAdapterEvents.contextChanged({ context }));
+			},
+			fetchNextPage() {
+				store.dispatch(threadAdapterEvents.fetchNextPageRequested());
+			},
+			renameThread(threadId, name) {
+				return trackMutation(threadAdapterEvents.renameRequested({
+					requestId: createThreadRequestId(),
+					threadId,
+					name
+				}));
+			},
+			archiveThread(threadId) {
+				return trackMutation(threadAdapterEvents.archiveRequested({
+					requestId: createThreadRequestId(),
+					threadId
+				}));
+			},
+			deleteThread(threadId) {
+				return trackMutation(threadAdapterEvents.deleteRequested({
+					requestId: createThreadRequestId(),
+					threadId
+				}));
+			},
+			getState() {
+				return store.getState();
+			},
+			select: store.select.bind(store)
+		};
+	}
+	const ɵthreadAdapterEvents = threadAdapterEvents;
+	const ɵselectThreads = selectThreads;
+	const ɵselectThreadsIsLoading = selectThreadsIsLoading;
+	const ɵselectThreadsError = selectThreadsError;
+	const ɵselectHasNextPage = selectHasNextPage;
+	const ɵselectIsFetchingNextPage = selectIsFetchingNextPage;
+
+//#endregion
+exports.AgentRegistry = AgentRegistry;
+exports.AgentThreadLockedError = AgentThreadLockedError;
+exports.ContextStore = ContextStore;
+exports.CopilotKitCore = CopilotKitCore;
+exports.CopilotKitCoreErrorCode = CopilotKitCoreErrorCode;
+exports.CopilotKitCoreRuntimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus;
+exports.IntelligenceAgent = IntelligenceAgent;
+exports.ProxiedCopilotRuntimeAgent = ProxiedCopilotRuntimeAgent;
+exports.RunHandler = RunHandler;
+exports.StateManager = StateManager;
+exports.SuggestionEngine = SuggestionEngine;
+exports.ToolCallStatus = ToolCallStatus;
+exports.completePartialMarkdown = completePartialMarkdown;
+exports.createActionGroup = createActionGroup;
+exports.createEffect = createEffect;
+exports.createReducer = createReducer;
+exports.createSelector = createSelector;
+exports.createStore = createStore;
+exports.empty = empty;
+exports.ensureObjectArgs = ensureObjectArgs;
+exports.ofType = ofType;
+exports.on = on;
+exports.parseToolArguments = parseToolArguments;
+exports.props = props;
+exports.select = select;
+exports.ɵcreateThreadStore = createThreadStore;
+exports.ɵjoinPhoenixChannel$ = ɵjoinPhoenixChannel$;
+exports.ɵobservePhoenixEvent$ = ɵobservePhoenixEvent$;
+exports.ɵobservePhoenixJoinOutcome$ = ɵobservePhoenixJoinOutcome$;
+exports.ɵobservePhoenixSocketHealth$ = ɵobservePhoenixSocketHealth$;
+exports.ɵobservePhoenixSocketSignals$ = ɵobservePhoenixSocketSignals$;
+exports.ɵphoenixChannel$ = ɵphoenixChannel$;
+exports.ɵphoenixSocket$ = ɵphoenixSocket$;
+exports.ɵselectHasNextPage = ɵselectHasNextPage;
+exports.ɵselectIsFetchingNextPage = ɵselectIsFetchingNextPage;
+exports.ɵselectThreads = ɵselectThreads;
+exports.ɵselectThreadsError = ɵselectThreadsError;
+exports.ɵselectThreadsIsLoading = ɵselectThreadsIsLoading;
+exports.ɵthreadAdapterEvents = ɵthreadAdapterEvents;
+});
+//# sourceMappingURL=index.umd.js.map