@copilotkit/core 1.55.0-next.7

package/dist/index.mjs

@@ -0,0 +1,3321 @@
+import { AbstractAgent, EventType, HttpAgent, randomUUID, runHttpRequest, structuredClone_, transformChunks, transformHttpEventStream } from "@ag-ui/client";
+import { RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE, logger, partialJSONParse, phoenixExponentialBackoff, randomUUID as randomUUID$1, schemaToJsonSchema } from "@copilotkit/shared";
+import { BehaviorSubject, EMPTY, NEVER, Notification, Observable, Subject, Subscription, asapScheduler, concat, defer, dematerialize, firstValueFrom, from, lastValueFrom, merge, of, switchMap, throwError } from "rxjs";
+import { catchError, distinctUntilChanged, endWith, filter, finalize, ignoreElements, map, mergeMap, observeOn, scan, share, shareReplay, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
+import { Socket } from "phoenix";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { fromFetch } from "rxjs/fetch";
+
+//#region src/utils/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 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 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 defer(() => {
+		const socket = new Socket(options.url, options.options);
+		const signals$ = ɵcreatePhoenixSocketSignals$(socket).pipe(shareReplay({
+			bufferSize: 1,
+			refCount: true
+		}));
+		socket.connect();
+		return concat(of({
+			socket,
+			signals$
+		}), NEVER).pipe(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(switchMap$1(({ socket }) => defer(() => {
+		const channel = socket.channel(options.topic, options.params);
+		return concat(of({
+			channel,
+			joinOutcome$: ɵcreatePhoenixJoinOutcome$(channel).pipe(shareReplay({
+				bufferSize: 1,
+				refCount: true
+			}))
+		}), NEVER).pipe(finalize(() => {
+			if (options.leaveOnUnsubscribe !== false) channel.leave();
+		}));
+	})));
+}
+/**
+* Observe a named Phoenix channel event as an observable payload stream.
+*/
+function ɵobservePhoenixEvent$(channel, eventName) {
+	return new 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(switchMap$1((session) => session.joinOutcome$));
+}
+/**
+* Complete when a channel joins successfully, or error if the join fails.
+*/
+function ɵjoinPhoenixChannel$(channel$) {
+	return ɵobservePhoenixJoinOutcome$(channel$).pipe(take(1), mergeMap((outcome) => {
+		if (outcome.type === "joined") return 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(switchMap$1((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(scan((consecutiveErrors, signal) => signal.type === "open" ? 0 : consecutiveErrors + 1, 0), filter((consecutiveErrors) => consecutiveErrors >= maxConsecutiveErrors), take(1), mergeMap((consecutiveErrors) => throwError(() => /* @__PURE__ */ new Error(`WebSocket connection failed after ${consecutiveErrors} consecutive errors`))));
+}
+
+//#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 AbstractAgent {
+	config;
+	socket = null;
+	activeChannel = null;
+	runId = null;
+	sharedState;
+	constructor(config, sharedState = { lastSeenEventIds: /* @__PURE__ */ new Map() }) {
+		super();
+		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 {
+			this.isRunning = true;
+			this.agentId = this.agentId ?? 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 ?? {}
+			];
+			await this.onInitialize(input, subscribers);
+			self.activeRunDetach$ = new Subject();
+			let resolveCompletion;
+			self.activeRunCompletionPromise = new Promise((resolve) => {
+				resolveCompletion = resolve;
+			});
+			const source$ = defer(() => this.connect(input)).pipe(transformChunks(this.debug), takeUntil(self.activeRunDetach$));
+			const applied$ = this.apply(input, source$, subscribers);
+			await lastValueFrom(this.processApplyEvents(input, applied$, subscribers).pipe(catchError((error) => {
+				this.isRunning = false;
+				return this.onError(input, error, subscribers);
+			}), finalize(() => {
+				this.isRunning = false;
+				this.onFinalize(input, subscribers);
+				resolveCompletion?.();
+				resolveCompletion = void 0;
+				self.activeRunCompletionPromise = void 0;
+				self.activeRunDetach$ = void 0;
+			})), { defaultValue: void 0 });
+			const newMessages = structuredClone_(this.messages).filter((m) => !previousMessageIds.has(m.id));
+			return {
+				result,
+				newMessages
+			};
+		} finally {
+			this.isRunning = false;
+		}
+	}
+	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 defer(() => this.requestJoinCredentials$("run", input)).pipe(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 defer(() => this.requestConnectPlan$(input)).pipe(switchMap((plan) => {
+			if (plan === null) return EMPTY;
+			if (plan.mode === "bootstrap") {
+				this.setLastSeenEventId(input.threadId, plan.latestEventId);
+				for (const event of plan.events) this.updateRunIdFromEvent(event);
+				return from(plan.events);
+			}
+			this.setLastSeenEventId(input.threadId, plan.joinFromEventId);
+			for (const event of plan.events) this.updateRunIdFromEvent(event);
+			return concat(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 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 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?.mode === "bootstrap") return {
+			mode: "bootstrap",
+			latestEventId: typeof envelope.latestEventId === "string" ? envelope.latestEventId : null,
+			events: Array.isArray(envelope.events) ? envelope.events : []
+		};
+		if (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 defer(() => {
+			let ownSocket = null;
+			let ownChannel = null;
+			const socket$ = ɵphoenixSocket$({
+				url: this.config.url,
+				options: {
+					params: {
+						...this.config.socketParams ?? {},
+						join_token: credentials.joinToken
+					},
+					reconnectAfterMs: phoenixExponentialBackoff(100, 1e4),
+					rejoinAfterMs: phoenixExponentialBackoff(1e3, 3e4)
+				}
+			}).pipe(tap(({ socket }) => {
+				ownSocket = socket;
+				this.socket = ownSocket;
+			}), shareReplay({
+				bufferSize: 1,
+				refCount: true
+			}));
+			const { topic, params } = this.createThreadChannelDescriptor(input, options.streamMode, options.replayCursor);
+			const channel$ = ɵphoenixChannel$({
+				socket$,
+				topic,
+				params
+			}).pipe(tap(({ channel }) => {
+				ownChannel = channel;
+				this.activeChannel = ownChannel;
+			}), shareReplay({
+				bufferSize: 1,
+				refCount: true
+			}));
+			const threadEvents$ = this.observeThreadEvents$(input.threadId, channel$, options).pipe(share());
+			const threadCompleted$ = threadEvents$.pipe(ignoreElements(), endWith(null), take(1));
+			return merge(this.joinThreadChannel$(channel$), this.observeSocketHealth$(socket$).pipe(takeUntil(threadCompleted$)), threadEvents$).pipe(finalize(() => this.cleanupOwned(ownChannel, ownSocket)));
+		});
+	}
+	joinThreadChannel$(channel$) {
+		return ɵjoinPhoenixChannel$(channel$);
+	}
+	observeSocketHealth$(socket$) {
+		return ɵobservePhoenixSocketHealth$(ɵobservePhoenixSocketSignals$(socket$), 5);
+	}
+	observeThreadEvents$(threadId, channel$, options) {
+		return channel$.pipe(switchMap$1(({ channel }) => this.observeChannelEvent$(channel, CLIENT_AG_UI_EVENT)), tap((payload) => {
+			this.updateLastSeenEventId(threadId, payload);
+			this.updateRunIdFromEvent(payload);
+		}), mergeMap((payload) => from(this.createThreadNotifications(payload, options.completeOnRunError))), dematerialize());
+	}
+	observeChannelEvent$(channel, eventName) {
+		return ɵobservePhoenixEvent$(channel, eventName);
+	}
+	createThreadNotifications(payload, completeOnRunError) {
+		if (payload.type === EventType.RUN_FINISHED) return [Notification.createNext(payload), Notification.createComplete()];
+		if (payload.type === EventType.RUN_ERROR) {
+			const errorMessage = payload.message ?? "Run error";
+			return completeOnRunError ? [Notification.createNext(payload), Notification.createComplete()] : [Notification.createNext(payload), Notification.createError(new Error(errorMessage))];
+		}
+		return [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) {
+		return this.sharedState.lastSeenEventIds.get(threadId) ?? 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) {
+		const record = payload;
+		const eventRunId = 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 src/agent.ts
+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(catchError((error) => {
+		if (isZodError(error) || isAbortError(error)) return EMPTY;
+		throw error;
+	}));
+}
+var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends HttpAgent {
+	runtimeUrl;
+	credentials;
+	transport;
+	singleEndpointUrl;
+	runtimeMode;
+	intelligence;
+	delegate;
+	runtimeInfoPromise;
+	constructor(config) {
+		const normalizedRuntimeUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/$/, "") : void 0;
+		const transport = config.transport ?? "rest";
+		const runUrl = transport === "single" ? normalizedRuntimeUrl ?? config.runtimeUrl ?? "" : `${normalizedRuntimeUrl ?? config.runtimeUrl}/agent/${encodeURIComponent(config.agentId ?? "")}/run`;
+		if (!runUrl) throw new Error("ProxiedCopilotRuntimeAgent requires a runtimeUrl when transport is set to 'single'.");
+		super({
+			...config,
+			url: runUrl
+		});
+		this.runtimeUrl = normalizedRuntimeUrl ?? config.runtimeUrl;
+		this.credentials = config.credentials;
+		this.transport = transport;
+		this.runtimeMode = config.runtimeMode ?? 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 !== 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 === RUNTIME_MODE_INTELLIGENCE) return this.#connectViaDelegate(input);
+		return this.#connectViaHttp(input);
+	}
+	run(input) {
+		if (this.runtimeMode === RUNTIME_MODE_INTELLIGENCE) return this.#runViaDelegate(input);
+		return this.#runViaHttp(input);
+	}
+	#connectViaDelegate(input) {
+		return defer(() => from(this.resolveDelegate())).pipe(switchMap$1((delegate) => withAbortErrorHandling(delegate.connect(input))));
+	}
+	#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(transformHttpEventStream(runHttpRequest(this.singleEndpointUrl, requestInit)));
+		}
+		return withAbortErrorHandling(transformHttpEventStream(runHttpRequest(`${this.runtimeUrl}/agent/${this.agentId}/connect`, this.requestInit(input))));
+	}
+	#runViaDelegate(input) {
+		return defer(() => from(this.resolveDelegate())).pipe(switchMap$1((delegate) => withAbortErrorHandling(delegate.run(input))));
+	}
+	#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(transformHttpEventStream(runHttpRequest(this.singleEndpointUrl, requestInit)));
+		}
+		return withAbortErrorHandling(super.run(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 !== 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() {
+		if (this.runtimeMode !== "pending") return;
+		if (!this.runtimeUrl) throw new Error("Runtime URL is not set");
+		this.runtimeInfoPromise ??= this.fetchRuntimeInfo().then((runtimeInfo) => {
+			this.runtimeMode = runtimeInfo.mode ?? 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) {
+		if (!this.agentId) throw new Error("ProxiedCopilotRuntimeAgent requires agentId to make runtime requests");
+		const baseInit = super.requestInit(input);
+		const headers = new Headers(baseInit.headers ?? {});
+		headers.set("Content-Type", "application/json");
+		headers.set("Accept", headers.get("Accept") ?? "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() {
+		if (!this.runtimeUrl || !this.agentId || !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;
+	}
+};
+
+//#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 {
+	_agents = {};
+	localAgents = {};
+	remoteAgents = {};
+	_runtimeUrl;
+	_runtimeVersion;
+	_runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Disconnected;
+	_runtimeTransport = "rest";
+	_audioFileTranscriptionEnabled = false;
+	_runtimeMode = RUNTIME_MODE_SSE;
+	_intelligence;
+	_a2uiEnabled = false;
+	_licenseStatus;
+	constructor(core) {
+		this.core = core;
+	}
+	/**
+	* 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 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 = 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 {
+			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 }]) => {
+				const agent = new ProxiedCopilotRuntimeAgent({
+					runtimeUrl: this.runtimeUrl,
+					agentId: id,
+					description,
+					transport: this._runtimeTransport,
+					credentials,
+					runtimeMode: runtimeInfoResponse.mode ?? 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.audioFileTranscriptionEnabled ?? false;
+			this._runtimeMode = runtimeInfoResponse.mode ?? RUNTIME_MODE_SSE;
+			this._intelligence = runtimeInfoResponse.intelligence;
+			this._a2uiEnabled = runtimeInfoResponse.a2uiEnabled ?? 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 = 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);
+			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) => subscriber.onRuntimeConnectionStatusChanged?.({
+			copilotkit: this.core,
+			status
+		}), "Error in CopilotKitCore subscriber (onRuntimeConnectionStatusChanged):");
+	}
+	/**
+	* Notify subscribers of agent changes
+	*/
+	async notifyAgentsChanged() {
+		await this.core.notifySubscribers((subscriber) => subscriber.onAgentsChanged?.({
+			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 {
+	_context = {};
+	constructor(core) {
+		this.core = core;
+	}
+	/**
+	* 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 = randomUUID$1();
+		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) => subscriber.onContextChanged?.({
+			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 {
+	_suggestionsConfig = {};
+	_suggestions = {};
+	_runningSuggestions = {};
+	constructor(core) {
+		this.core = core;
+	}
+	/**
+	* Initialize with suggestion configs
+	*/
+	initialize(suggestionsConfig) {
+		for (const config of suggestionsConfig) this._suggestionsConfig[randomUUID$1()] = config;
+	}
+	/**
+	* Add a suggestion configuration
+	* @returns The ID of the created config
+	*/
+	addSuggestionsConfig(config) {
+		const id = randomUUID$1();
+		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
+	*/
+	reloadSuggestions(agentId) {
+		this.clearSuggestions(agentId);
+		const agent = this.core.getAgent(agentId);
+		if (!agent) return;
+		const messageCount = agent.messages?.length ?? 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 = randomUUID$1();
+			if (isDynamicSuggestionsConfig(config)) {
+				if (!hasAnySuggestions) {
+					hasAnySuggestions = true;
+					this.notifySuggestionsStartedLoading(agentId);
+				}
+				this.generateSuggestions(suggestionId, config, agentId);
+			} 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) {
+		return {
+			suggestions: Object.values(this._suggestions[agentId] ?? {}).flat(),
+			isLoading: (this._runningSuggestions[agentId]?.length ?? 0) > 0
+		};
+	}
+	/**
+	* Generate suggestions using a provider agent
+	*/
+	async generateSuggestions(suggestionId, config, consumerAgentId) {
+		let agent = void 0;
+		try {
+			const suggestionsProviderAgent = this.core.getAgent(config.providerAgentId ?? "default");
+			if (!suggestionsProviderAgent) throw new Error(`Suggestions provider agent not found: ${config.providerAgentId}`);
+			const suggestionsConsumerAgent = 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[consumerAgentId] ?? {},
+				[suggestionId]: []
+			};
+			this._runningSuggestions[consumerAgentId] = [...this._runningSuggestions[consumerAgentId] ?? [], 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.minSuggestions ?? 1} and at most ${config.maxSuggestions ?? 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?.[suggestionId];
+		if (agentSuggestions && currentSuggestions && currentSuggestions.length > 0) {
+			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[consumerAgentId] ?? {}).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 = 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) suggestions.push({
+							title: item.title ?? "",
+							message: item.message ?? "",
+							isLoading: false
+						});
+					}
+				}
+			}
+		}
+		if (isRunning && suggestions.length > 0) suggestions[suggestions.length - 1].isLoading = true;
+		const agentSuggestions = this._suggestions[consumerAgentId];
+		if (agentSuggestions) {
+			agentSuggestions[suggestionId] = suggestions;
+			const allSuggestions = Object.values(this._suggestions[consumerAgentId] ?? {}).flat();
+			this.notifySuggestionsChanged(consumerAgentId, allSuggestions, "suggestions changed");
+		}
+	}
+	/**
+	* Notify subscribers of suggestions config changes
+	*/
+	async notifySuggestionsConfigChanged() {
+		await this.core.notifySubscribers((subscriber) => subscriber.onSuggestionsConfigChanged?.({
+			copilotkit: this.core,
+			suggestionsConfig: this._suggestionsConfig
+		}), "Subscriber onSuggestionsConfigChanged error:");
+	}
+	/**
+	* Notify subscribers of suggestions changes
+	*/
+	async notifySuggestionsChanged(agentId, suggestions, context = "") {
+		await this.core.notifySubscribers((subscriber) => subscriber.onSuggestionsChanged?.({
+			copilotkit: this.core,
+			agentId,
+			suggestions
+		}), `Subscriber onSuggestionsChanged error: ${context}`);
+	}
+	/**
+	* Notify subscribers that suggestions started loading
+	*/
+	async notifySuggestionsStartedLoading(agentId) {
+		await this.core.notifySubscribers((subscriber) => subscriber.onSuggestionsStartedLoading?.({
+			copilotkit: this.core,
+			agentId
+		}), "Subscriber onSuggestionsStartedLoading error:");
+	}
+	/**
+	* Notify subscribers that suggestions finished loading
+	*/
+	async notifySuggestionsFinishedLoading(agentId) {
+		await this.core.notifySubscribers((subscriber) => subscriber.onSuggestionsFinishedLoading?.({
+			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) {
+		const suggestions = config.suggestions.map((s) => ({
+			...s,
+			isLoading: false
+		}));
+		this._suggestions[consumerAgentId] = {
+			...this._suggestions[consumerAgentId] ?? {},
+			[suggestionId]: suggestions
+		};
+		const allSuggestions = Object.values(this._suggestions[consumerAgentId] ?? {}).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 {
+	_tools = [];
+	/**
+	* Tracks whether the current run (including in-flight tool execution)
+	* has been aborted via `stopAgent()` or `agent.abortRun()`. Created
+	* fresh in `runAgent()`, aborted by `abortCurrentRun()`.
+	*/
+	_runAbortController = null;
+	/**
+	* Tracks recursive `runAgent` depth so that the abort controller and
+	* `agent.abortRun()` intercept are only set up / torn down at the
+	* top-level call, not on follow-up recursive calls from
+	* `processAgentResult`.
+	*/
+	_runDepth = 0;
+	constructor(core) {
+		this.core = core;
+	}
+	/**
+	* 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() {
+		this._runAbortController?.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) {
+			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 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 HttpAgent) agent.headers = { ...this._internal.headers };
+		if (agent.detachActiveRun) await agent.detachActiveRun();
+		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 }) {
+		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._runAbortController?.signal.aborted) {
+			await this._internal.waitForPendingFrameworkUpdates();
+			return await this.runAgent({ agent });
+		}
+		this._internal.suggestionEngine.reloadSuggestions(agentId);
+		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) => subscriber.onToolExecutionStart?.({
+			copilotkit: this.core,
+			toolCallId: toolCall.id,
+			agentId,
+			toolName: toolCall.function.name,
+			args: parsedArgs
+		}), "Subscriber onToolExecutionStart error:");
+		if (!errorMessage) try {
+			const result = await tool.handler(parsedArgs, {
+				toolCall,
+				agent,
+				signal: this._runAbortController?.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) => subscriber.onToolExecutionEnd?.({
+			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?.agentId && tool.agentId !== agent.agentId) return false;
+		let handlerResult = {
+			result: "",
+			error: void 0,
+			isArgumentError: false
+		};
+		if (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: randomUUID$1(),
+				role: "tool",
+				toolCallId: toolCall.id,
+				content: handlerResult.result
+			};
+			agent.messages.splice(messageIndex + 1, 0, toolMessage);
+			if (!handlerResult.error && 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?.agentId && wildcardTool.agentId !== agent.agentId) return false;
+		let toolCallResult = "";
+		let errorMessage;
+		if (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) => subscriber.onToolExecutionStart?.({
+				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) => subscriber.onToolExecutionEnd?.({
+				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: randomUUID$1(),
+				role: "tool",
+				toolCallId: toolCall.id,
+				content: toolCallResult
+			};
+			agent.messages.splice(messageIndex + 1, 0, toolMessage);
+			if (!errorMessage && 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 ?? "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 = randomUUID$1();
+		const assistantMessage = {
+			id: randomUUID$1(),
+			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: randomUUID$1(),
+			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: randomUUID$1(),
+					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) => ({
+			name: tool.name,
+			description: 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 }) => {
+				const eventError = event?.rawEvent instanceof Error ? event.rawEvent : event?.rawEvent?.error instanceof Error ? event.rawEvent.error : void 0;
+				const errorMessage = typeof event?.rawEvent?.error === "string" ? event.rawEvent.error : event?.message ?? "Agent run error";
+				const rawError = eventError ?? new Error(errorMessage);
+				if (event?.code && !rawError.code) rawError.code = event.code;
+				await emitAgentError(rawError, CopilotKitCoreErrorCode.AGENT_RUN_ERROR_EVENT, {
+					source: "onRunErrorEvent",
+					event,
+					runtimeErrorCode: 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 = schemaToJsonSchema(tool.parameters, { 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) {
+		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 {
+	stateByRun = /* @__PURE__ */ new Map();
+	messageToRun = /* @__PURE__ */ new Map();
+	agentSubscriptions = /* @__PURE__ */ new Map();
+	constructor(core) {
+		this.core = core;
+	}
+	/**
+	* Initialize state tracking for an agent
+	*/
+	initialize() {}
+	/**
+	* Subscribe to an agent's events to track state and messages
+	*/
+	subscribeToAgent(agent) {
+		if (!agent.agentId) return;
+		const agentId = agent.agentId;
+		this.unsubscribeFromAgent(agentId);
+		const { unsubscribe } = agent.subscribe({
+			onRunStartedEvent: ({ event, state }) => {
+				this.handleRunStarted(agent, event, state);
+			},
+			onRunFinishedEvent: ({ event, state }) => {
+				this.handleRunFinished(agent, event, state);
+			},
+			onStateSnapshotEvent: ({ event, input, state }) => {
+				this.handleStateSnapshot(agent, event, input, state);
+			},
+			onStateDeltaEvent: ({ event, input, state }) => {
+				this.handleStateDelta(agent, event, input, state);
+			},
+			onMessagesSnapshotEvent: ({ event, input, messages }) => {
+				this.handleMessagesSnapshot(agent, event, input, messages);
+			},
+			onNewMessage: ({ message, input }) => {
+				this.handleNewMessage(agent, message, input);
+			}
+		});
+		this.agentSubscriptions.set(agentId, unsubscribe);
+	}
+	/**
+	* Unsubscribe from an agent's events
+	*/
+	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) {
+		const state = this.stateByRun.get(agentId)?.get(threadId)?.get(runId);
+		if (!state) return void 0;
+		return JSON.parse(JSON.stringify(state));
+	}
+	/**
+	* Get runId associated with a message
+	*/
+	getRunIdForMessage(agentId, threadId, messageId) {
+		return this.messageToRun.get(agentId)?.get(threadId)?.get(messageId);
+	}
+	/**
+	* Get all states for an agent's thread
+	*/
+	getStatesForThread(agentId, threadId) {
+		return this.stateByRun.get(agentId)?.get(threadId) ?? /* @__PURE__ */ new Map();
+	}
+	/**
+	* Get all run IDs for an agent's thread
+	*/
+	getRunIdsForThread(agentId, threadId) {
+		const threadStates = this.stateByRun.get(agentId)?.get(threadId);
+		return threadStates ? Array.from(threadStates.keys()) : [];
+	}
+	/**
+	* Handle run started event
+	*/
+	handleRunStarted(agent, event, state) {
+		if (!agent.agentId) return;
+		const { threadId, runId } = event;
+		this.saveState(agent.agentId, threadId, runId, state);
+	}
+	/**
+	* Handle run finished event
+	*/
+	handleRunFinished(agent, event, state) {
+		if (!agent.agentId) return;
+		const { threadId, runId } = event;
+		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 || !input) 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) {
+		this.stateByRun.get(agentId)?.delete(threadId);
+		this.messageToRun.get(agentId)?.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 {
+	_headers;
+	_credentials;
+	_properties;
+	subscribers = /* @__PURE__ */ new Set();
+	agentRegistry;
+	contextStore;
+	suggestionEngine;
+	runHandler;
+	stateManager;
+	constructor({ runtimeUrl, runtimeTransport = "rest", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [] }) {
+		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) => subscriber.onError?.({
+			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) => subscriber.onHeadersChanged?.({
+			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) => subscriber.onPropertiesChanged?.({
+			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);
+	}
+	/**
+	* 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) {
+		const handlers = reducerMap.get(creator.type) ?? [];
+		handlers.push(entry.reducer);
+		reducerMap.set(creator.type, handlers);
+	}
+	return (state, action) => {
+		const currentState = 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(map(selector), 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(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) {
+	const reducer = options.reducer;
+	const effects = options.effects ?? [];
+	let hasFatalError = false;
+	let isRunning = false;
+	let effectSubscriptions = new Subscription();
+	let currentState = reducer(void 0, INTERNAL_BOOT_ACTION);
+	const stateSubject = new BehaviorSubject(currentState);
+	const actionsSubject = new 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 Subscription();
+		actionsSubject.error(error);
+		stateSubject.error(error);
+	};
+	const startEffects = () => {
+		for (const effect of effects) {
+			const scheduledActions$ = actionsSubject.asObservable().pipe(observeOn(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 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 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 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(timeout({
+			first: REQUEST_TIMEOUT_MS,
+			with: () => {
+				throw new Error("Request timed out");
+			}
+		}), map((data) => threadRestEvents.listSucceeded({
+			sessionId,
+			threads: data.threads,
+			joinCode: typeof data.joinCode === "string" && data.joinCode.length > 0 ? data.joinCode : null,
+			nextCursor: data.nextCursor ?? null
+		})), catchError((error) => {
+			return of(threadRestEvents.listFailed({
+				sessionId,
+				error: error instanceof Error ? error : new Error(String(error))
+			}));
+		}));
+	});
+}
+function createThreadMetadataCredentialsObservable(environment, context, sessionId) {
+	return defer(() => {
+		return 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(timeout({
+			first: REQUEST_TIMEOUT_MS,
+			with: () => {
+				throw new Error("Request timed out");
+			}
+		}), map((data) => {
+			if (typeof data.joinToken !== "string" || data.joinToken.length === 0) throw new Error("missing joinToken");
+			return threadRestEvents.metadataCredentialsSucceeded({
+				sessionId,
+				joinToken: data.joinToken
+			});
+		}), catchError((error) => {
+			return of(threadRestEvents.metadataCredentialsFailed({
+				sessionId,
+				error: error instanceof Error ? error : new Error(String(error))
+			}));
+		}));
+	});
+}
+function createThreadMutationObservable(environment, context, request) {
+	return defer(() => {
+		return 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(map(() => threadRestEvents.mutationFinished({ outcome: {
+			requestId: request.requestId,
+			ok: true
+		} })), catchError((error) => {
+			return 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), withLatestFrom(state$), filter(([, state]) => Boolean(state.context)), map(([, state]) => threadRestEvents.listRequested({ sessionId: state.sessionId })))),
+			createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.listRequested), switchMap$1((action) => state$.pipe(map((state) => state.context), filter((context) => Boolean(context)), take(1), map((context) => ({
+				action,
+				context
+			})), takeUntil(actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped))), switchMap$1(({ action: currentAction, context }) => createThreadFetchObservable(environment, context, currentAction.sessionId)))))),
+			createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.listSucceeded), withLatestFrom(state$), filter(([action, state]) => {
+				return action.sessionId === state.sessionId && !state.metadataCredentialsRequested && Boolean(state.context?.wsUrl) && Boolean(state.metadataJoinCode);
+			}), map(([action]) => threadRestEvents.metadataCredentialsRequested({ sessionId: action.sessionId })))),
+			createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.metadataCredentialsRequested), switchMap$1((action) => state$.pipe(map((state) => state.context), filter((context) => Boolean(context)), take(1), map((context) => ({
+				action,
+				context
+			})), takeUntil(actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped))), switchMap$1(({ action: currentAction, context }) => createThreadMetadataCredentialsObservable(environment, context, currentAction.sessionId)))))),
+			createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.metadataCredentialsSucceeded), withLatestFrom(state$), filter(([action, state]) => {
+				return action.sessionId === state.sessionId && Boolean(state.context?.wsUrl);
+			}), switchMap$1(([action, state]) => {
+				const context = state.context;
+				const joinToken = action.joinToken;
+				const joinCode = state.metadataJoinCode;
+				const shutdown$ = actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped));
+				return defer(() => {
+					const socket$ = ɵphoenixSocket$({
+						url: context.wsUrl,
+						options: {
+							params: { join_token: joinToken },
+							reconnectAfterMs: phoenixExponentialBackoff(100, 1e4),
+							rejoinAfterMs: phoenixExponentialBackoff(1e3, 3e4)
+						}
+					}).pipe(shareReplay({
+						bufferSize: 1,
+						refCount: true
+					}));
+					const channel$ = ɵphoenixChannel$({
+						socket$,
+						topic: `user_meta:${joinCode}`
+					}).pipe(shareReplay({
+						bufferSize: 1,
+						refCount: true
+					}));
+					const socketSignals$ = ɵobservePhoenixSocketSignals$(socket$).pipe(share());
+					const fatalSocketShutdown$ = ɵobservePhoenixSocketHealth$(socketSignals$, MAX_SOCKET_RETRIES).pipe(catchError(() => {
+						console.warn(`[threads] WebSocket failed after ${MAX_SOCKET_RETRIES} attempts, giving up`);
+						return of(void 0);
+					}), share());
+					return merge(socketSignals$.pipe(map((signal) => signal.type === "open" ? threadSocketEvents.opened({ sessionId: action.sessionId }) : threadSocketEvents.errored({ sessionId: action.sessionId }))), channel$.pipe(switchMap$1(({ channel }) => ɵobservePhoenixEvent$(channel, THREADS_CHANNEL_EVENT)), map((payload) => threadSocketEvents.metadataReceived({
+						sessionId: action.sessionId,
+						payload
+					}))), ɵobservePhoenixJoinOutcome$(channel$).pipe(filter((outcome) => outcome.type !== "joined"), map((outcome) => outcome.type === "timeout" ? threadSocketEvents.joinTimedOut({ sessionId: action.sessionId }) : threadSocketEvents.joinFailed({ sessionId: action.sessionId })))).pipe(takeUntil(merge(shutdown$, fatalSocketShutdown$)));
+				});
+			}))),
+			createEffect((actions$, state$) => actions$.pipe(ofType(threadSocketEvents.metadataReceived), withLatestFrom(state$), filter(([action, state]) => action.sessionId === state.sessionId), map(([action, state]) => {
+				if (action.payload.operation === "deleted") return threadDomainEvents.threadDeleted({
+					sessionId: action.sessionId,
+					threadId: action.payload.deleted.id
+				});
+				if (action.payload.operation === "archived" && !state.context?.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), withLatestFrom(state$), filter(([, state]) => Boolean(state.context) && Boolean(state.nextCursor)), switchMap$1(([, 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 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(timeout({
+					first: REQUEST_TIMEOUT_MS,
+					with: () => {
+						throw new Error("Request timed out");
+					}
+				}), map((data) => threadRestEvents.nextPageSucceeded({
+					sessionId: state.sessionId,
+					threads: data.threads,
+					nextCursor: data.nextCursor ?? null
+				})), catchError((error) => of(threadRestEvents.nextPageFailed({
+					sessionId: state.sessionId,
+					error: error instanceof Error ? error : new Error(String(error))
+				}))), takeUntil(actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped))));
+			}))),
+			createEffect((actions$, state$) => actions$.pipe(ofType(threadAdapterEvents.renameRequested, threadAdapterEvents.archiveRequested, threadAdapterEvents.deleteRequested), withLatestFrom(state$), mergeMap(([action, state]) => {
+				const context = state.context;
+				if (!context?.runtimeUrl) {
+					const requestId = action.requestId;
+					return 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 = firstValueFrom(merge(store.actions$.pipe(ofType(threadRestEvents.mutationFinished), filter((action) => action.outcome.requestId === dispatchAction.requestId), map((action) => action.outcome)), store.actions$.pipe(ofType(threadAdapterEvents.stopped), map(() => ({
+			requestId: dispatchAction.requestId,
+			ok: false,
+			error: /* @__PURE__ */ new Error("Thread store stopped before mutation completed")
+		})))).pipe(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
+export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, IntelligenceAgent, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, completePartialMarkdown, createActionGroup, createEffect, createReducer, createSelector, createStore, empty, ensureObjectArgs, ofType, on, parseToolArguments, props, select, createThreadStore as ɵcreateThreadStore, ɵjoinPhoenixChannel$, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
+//# sourceMappingURL=index.mjs.map