@copilotkitnext/core 1.54.0 → 1.54.1-next.0

package/dist/index.umd.js

@@ -1,10 +1,128 @@
 (function(global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('@ag-ui/client'), require('@copilotkitnext/shared'), require('rxjs'), require('rxjs/operators'), require('zod-to-json-schema'), require('phoenix')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@ag-ui/client', '@copilotkitnext/shared', 'rxjs', 'rxjs/operators', 'zod-to-json-schema', 'phoenix'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitNextCore = {}), global.AgUIClient,global.CopilotKitNextShared,global.rxjs,global.rxjs.operators,global.zodToJsonSchema,global.phoenix));
-})(this, function(exports, _ag_ui_client, _copilotkitnext_shared, rxjs, rxjs_operators, zod_to_json_schema, phoenix) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('@ag-ui/client'), require('@copilotkitnext/shared'), require('rxjs'), require('rxjs/operators'), require('phoenix'), require('zod-to-json-schema'), require('rxjs/fetch')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@ag-ui/client', '@copilotkitnext/shared', 'rxjs', 'rxjs/operators', 'phoenix', 'zod-to-json-schema', 'rxjs/fetch'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitNextCore = {}), global.AgUIClient,global.CopilotKitNextShared,global.rxjs,global.rxjs.operators,global.phoenix,global.zodToJsonSchema,global.rxjs_fetch));
+})(this, function(exports, _ag_ui_client, _copilotkitnext_shared, rxjs, rxjs_operators, phoenix, zod_to_json_schema, rxjs_fetch) {
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+//#region src/utils/phoenix-observable.ts
+/**
+	* Adapt Phoenix socket open/error callbacks into an observable signal stream.
+	*
+	* The returned observable is shared and replayable by the caller when needed,
+	* but this helper itself does not own socket connection teardown.
+	*/
+	function ɵcreatePhoenixSocketSignals$(socket) {
+		return new rxjs.Observable((observer) => {
+			socket.onOpen(() => observer.next({ type: "open" }));
+			socket.onError((error) => observer.next({
+				type: "error",
+				error
+			}));
+		});
+	}
+	/**
+	* Adapt a Phoenix channel join attempt into a single-outcome observable.
+	*/
+	function ɵcreatePhoenixJoinOutcome$(channel) {
+		return new rxjs.Observable((observer) => {
+			channel.join().receive("ok", () => {
+				observer.next({ type: "joined" });
+				observer.complete();
+			}).receive("error", (response) => {
+				observer.next({
+					type: "error",
+					response
+				});
+				observer.complete();
+			}).receive("timeout", () => {
+				observer.next({ type: "timeout" });
+				observer.complete();
+			});
+		});
+	}
+	/**
+	* Create a cold Phoenix socket session.
+	*
+	* The socket is constructed and connected on subscription, and disconnected on
+	* teardown. Each subscription creates an isolated socket instance.
+	*/
+	function ɵphoenixSocket$(options) {
+		return (0, rxjs.defer)(() => {
+			const socket = new phoenix.Socket(options.url, options.options);
+			const signals$ = ɵcreatePhoenixSocketSignals$(socket).pipe((0, rxjs_operators.shareReplay)({
+				bufferSize: 1,
+				refCount: true
+			}));
+			socket.connect();
+			return (0, rxjs.concat)((0, rxjs.of)({
+				socket,
+				signals$
+			}), rxjs.NEVER).pipe((0, rxjs_operators.finalize)(() => socket.disconnect()));
+		});
+	}
+	/**
+	* Create a cold Phoenix channel session from a socket session stream.
+	*
+	* A channel is created and joined for each active socket session. If the
+	* upstream socket session changes, the previous channel is left before the
+	* next one becomes active.
+	*/
+	function ɵphoenixChannel$(options) {
+		return options.socket$.pipe((0, rxjs_operators.switchMap)(({ socket }) => (0, rxjs.defer)(() => {
+			const channel = socket.channel(options.topic, options.params);
+			return (0, rxjs.concat)((0, rxjs.of)({
+				channel,
+				joinOutcome$: ɵcreatePhoenixJoinOutcome$(channel).pipe((0, rxjs_operators.shareReplay)({
+					bufferSize: 1,
+					refCount: true
+				}))
+			}), rxjs.NEVER).pipe((0, rxjs_operators.finalize)(() => {
+				if (options.leaveOnUnsubscribe !== false) channel.leave();
+			}));
+		})));
+	}
+	/**
+	* Observe a named Phoenix channel event as an observable payload stream.
+	*/
+	function ɵobservePhoenixEvent$(channel, eventName) {
+		return new rxjs.Observable((observer) => {
+			const ref = channel.on(eventName, (payload) => observer.next(payload));
+			return () => {
+				channel.off(eventName, ref);
+			};
+		});
+	}
+	/**
+	* Flatten channel sessions into their join-outcome stream.
+	*/
+	function ɵobservePhoenixJoinOutcome$(channel$) {
+		return channel$.pipe((0, rxjs_operators.switchMap)((session) => session.joinOutcome$));
+	}
+	/**
+	* Complete when a channel joins successfully, or error if the join fails.
+	*/
+	function ɵjoinPhoenixChannel$(channel$) {
+		return ɵobservePhoenixJoinOutcome$(channel$).pipe((0, rxjs_operators.take)(1), (0, rxjs_operators.mergeMap)((outcome) => {
+			if (outcome.type === "joined") return rxjs.EMPTY;
+			throw outcome.type === "timeout" ? /* @__PURE__ */ new Error("Timed out joining channel") : /* @__PURE__ */ new Error(`Failed to join channel: ${JSON.stringify(outcome.response)}`);
+		}));
+	}
+	/**
+	* Flatten socket sessions into their lifecycle signal stream.
+	*/
+	function ɵobservePhoenixSocketSignals$(socket$) {
+		return socket$.pipe((0, rxjs_operators.switchMap)((session) => session.signals$));
+	}
+	/**
+	* Error after a socket emits the configured number of consecutive error
+	* signals, resetting the counter after each successful open signal.
+	*/
+	function ɵobservePhoenixSocketHealth$(socketSignals$, maxConsecutiveErrors) {
+		return socketSignals$.pipe((0, rxjs_operators.scan)((consecutiveErrors, signal) => signal.type === "open" ? 0 : consecutiveErrors + 1, 0), (0, rxjs_operators.filter)((consecutiveErrors) => consecutiveErrors >= maxConsecutiveErrors), (0, rxjs_operators.take)(1), (0, rxjs_operators.mergeMap)((consecutiveErrors) => (0, rxjs.throwError)(() => /* @__PURE__ */ new Error(`WebSocket connection failed after ${consecutiveErrors} consecutive errors`))));
+	}
+
+//#endregion
 //#region \0@oxc-project+runtime@0.112.0/helpers/typeof.js
 	function _typeof(o) {
 		"@babel/helpers - typeof";
@@ -46,28 +164,445 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		}) : e[r] = t, e;
 	}
 
+//#endregion
+//#region src/intelligence-agent.ts
+	const CLIENT_AG_UI_EVENT = "ag_ui_event";
+	const STOP_RUN_EVENT = "stop_run";
+	var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAgent {
+		constructor(config, sharedState = { lastSeenEventIds: /* @__PURE__ */ new Map() }) {
+			super();
+			_defineProperty(this, "config", void 0);
+			_defineProperty(this, "socket", null);
+			_defineProperty(this, "activeChannel", null);
+			_defineProperty(this, "runId", null);
+			_defineProperty(this, "sharedState", void 0);
+			this.config = config;
+			this.sharedState = sharedState;
+		}
+		clone() {
+			return new IntelligenceAgent(this.config, this.sharedState);
+		}
+		/**
+		* Override of AbstractAgent.connectAgent that removes the `verifyEvents` step.
+		*
+		* Background: AbstractAgent's connectAgent pipeline runs events through
+		* `verifyEvents`, which validates that the stream follows the AG-UI protocol
+		* lifecycle — specifically, it expects a RUN_STARTED event before any content
+		* events and a RUN_FINISHED/RUN_ERROR event to complete the stream.
+		*
+		* IntelligenceAgent uses long-lived WebSocket connections rather than
+		* request-scoped SSE streams. When connecting to replay historical messages
+		* for an existing thread, the connection semantics don't map to a single
+		* agent run start/stop cycle. The replayed events may not include
+		* RUN_STARTED/RUN_FINISHED bookends (or may contain events from multiple
+		* past runs), which causes verifyEvents to either never complete or to
+		* error out.
+		*
+		* This override replicates the base connectAgent implementation exactly,
+		* substituting only `transformChunks` (which is still needed for message
+		* reassembly) and omitting `verifyEvents`.
+		*
+		* TODO: Remove this override once AG-UI's AbstractAgent supports opting out
+		* of verifyEvents for transports with different connection life-cycles.
+		*/
+		async connectAgent(parameters, subscriber) {
+			const self = this;
+			try {
+				var _this$agentId;
+				this.isRunning = true;
+				this.agentId = (_this$agentId = this.agentId) !== null && _this$agentId !== void 0 ? _this$agentId : (0, _ag_ui_client.randomUUID)();
+				const input = this.prepareRunAgentInput(parameters);
+				let result;
+				const previousMessageIds = new Set(this.messages.map((m) => m.id));
+				const subscribers = [
+					{ onRunFinishedEvent: (event) => {
+						result = event.result;
+					} },
+					...this.subscribers,
+					subscriber !== null && subscriber !== void 0 ? subscriber : {}
+				];
+				await this.onInitialize(input, subscribers);
+				self.activeRunDetach$ = new rxjs.Subject();
+				let resolveCompletion;
+				self.activeRunCompletionPromise = new Promise((resolve) => {
+					resolveCompletion = resolve;
+				});
+				const source$ = (0, rxjs.defer)(() => this.connect(input)).pipe((0, _ag_ui_client.transformChunks)(this.debug), (0, rxjs_operators.takeUntil)(self.activeRunDetach$));
+				const applied$ = this.apply(input, source$, subscribers);
+				await (0, rxjs.lastValueFrom)(this.processApplyEvents(input, applied$, subscribers).pipe((0, rxjs_operators.catchError)((error) => {
+					this.isRunning = false;
+					return this.onError(input, error, subscribers);
+				}), (0, rxjs_operators.finalize)(() => {
+					this.isRunning = false;
+					this.onFinalize(input, subscribers);
+					resolveCompletion === null || resolveCompletion === void 0 || resolveCompletion();
+					resolveCompletion = void 0;
+					self.activeRunCompletionPromise = void 0;
+					self.activeRunDetach$ = void 0;
+				})), { defaultValue: void 0 });
+				const newMessages = (0, _ag_ui_client.structuredClone_)(this.messages).filter((m) => !previousMessageIds.has(m.id));
+				return {
+					result,
+					newMessages
+				};
+			} finally {
+				this.isRunning = false;
+			}
+		}
+		abortRun() {
+			if (this.activeChannel && this.runId) {
+				const fallback = setTimeout(() => clear(), 5e3);
+				const clear = () => {
+					clearTimeout(fallback);
+					this.detachActiveRun();
+					this.cleanup();
+				};
+				this.activeChannel.push(STOP_RUN_EVENT, { run_id: this.runId }).receive("ok", clear).receive("error", clear).receive("timeout", clear);
+			} else {
+				this.detachActiveRun();
+				this.cleanup();
+			}
+		}
+		/**
+		* Trigger the run via REST, then join the realtime thread channel and relay
+		* server-pushed AG-UI events to the Observable subscriber.
+		*/
+		run(input) {
+			this.threadId = input.threadId;
+			this.runId = input.runId;
+			return (0, rxjs.defer)(() => this.requestJoinCredentials$("run", input)).pipe((0, rxjs.switchMap)((credentials) => this.observeThread$(input, credentials, {
+				completeOnRunError: false,
+				streamMode: "run"
+			})));
+		}
+		/**
+		* Reconnect to an existing thread by fetching websocket credentials and
+		* joining the realtime thread channel.
+		*/
+		connect(input) {
+			this.threadId = input.threadId;
+			this.runId = input.runId;
+			return (0, rxjs.defer)(() => this.requestConnectPlan$(input)).pipe((0, rxjs.switchMap)((plan) => {
+				if (plan === null) return rxjs.EMPTY;
+				if (plan.mode === "bootstrap") {
+					this.setLastSeenEventId(input.threadId, plan.latestEventId);
+					for (const event of plan.events) this.updateRunIdFromEvent(event);
+					return (0, rxjs.from)(plan.events);
+				}
+				this.setLastSeenEventId(input.threadId, plan.joinFromEventId);
+				for (const event of plan.events) this.updateRunIdFromEvent(event);
+				return (0, rxjs.concat)((0, rxjs.from)(plan.events), this.observeThread$(input, { joinToken: plan.joinToken }, {
+					completeOnRunError: true,
+					streamMode: "connect",
+					replayCursor: plan.joinFromEventId
+				}));
+			}));
+		}
+		/**
+		* Tear down a specific channel + socket pair that belongs to one pipeline.
+		* Only nulls instance references when they still point to the owned resource,
+		* so a concurrent pipeline's resources are never clobbered.
+		*/
+		cleanupOwned(ownChannel, ownSocket) {
+			if (ownChannel) {
+				ownChannel.leave();
+				if (this.activeChannel === ownChannel) this.activeChannel = null;
+			}
+			if (ownSocket) {
+				ownSocket.disconnect();
+				if (this.socket === ownSocket) this.socket = null;
+			}
+			if (this.threadId) this.sharedState.lastSeenEventIds.delete(this.threadId);
+			this.runId = null;
+		}
+		cleanup() {
+			this.cleanupOwned(this.activeChannel, this.socket);
+		}
+		requestJoinCredentials$(mode, input) {
+			return (0, rxjs.defer)(async () => {
+				try {
+					const response = await fetch(this.buildRuntimeUrl(mode), {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							...this.config.headers
+						},
+						body: JSON.stringify({
+							threadId: input.threadId,
+							runId: input.runId,
+							messages: input.messages,
+							tools: input.tools,
+							context: input.context,
+							state: input.state,
+							forwardedProps: input.forwardedProps
+						}),
+						...this.config.credentials ? { credentials: this.config.credentials } : {}
+					});
+					if (!response.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) {
+					throw new Error(`REST ${mode} request failed: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+		}
+		requestConnectPlan$(input) {
+			return (0, rxjs.defer)(async () => {
+				try {
+					const response = await fetch(this.buildRuntimeUrl("connect"), {
+						method: "POST",
+						headers: {
+							"Content-Type": "application/json",
+							...this.config.headers
+						},
+						body: JSON.stringify({
+							threadId: input.threadId,
+							runId: input.runId,
+							messages: input.messages,
+							tools: input.tools,
+							context: input.context,
+							state: input.state,
+							forwardedProps: input.forwardedProps,
+							lastSeenEventId: this.getReconnectCursor(input)
+						}),
+						...this.config.credentials ? { credentials: this.config.credentials } : {}
+					});
+					if (response.status === 204) return null;
+					if (!response.ok) {
+						const text = await response.text().catch(() => "");
+						throw new Error(text || response.statusText || String(response.status));
+					}
+					return this.normalizeConnectPlan(await response.json());
+				} catch (error) {
+					throw new Error(`REST connect request failed: ${error instanceof Error ? error.message : String(error)}`);
+				}
+			});
+		}
+		normalizeConnectPlan(payload) {
+			const envelope = payload && typeof payload === "object" ? payload : null;
+			if ((envelope === null || envelope === void 0 ? void 0 : envelope.mode) === "bootstrap") return {
+				mode: "bootstrap",
+				latestEventId: typeof envelope.latestEventId === "string" ? envelope.latestEventId : null,
+				events: Array.isArray(envelope.events) ? envelope.events : []
+			};
+			if ((envelope === null || envelope === void 0 ? void 0 : envelope.mode) === "live") {
+				if (typeof envelope.joinToken !== "string" || envelope.joinToken.length === 0) throw new Error("missing joinToken");
+				return {
+					mode: "live",
+					joinToken: envelope.joinToken,
+					joinFromEventId: typeof envelope.joinFromEventId === "string" ? envelope.joinFromEventId : null,
+					events: Array.isArray(envelope.events) ? envelope.events : []
+				};
+			}
+			throw new Error("invalid connect plan");
+		}
+		observeThread$(input, credentials, options) {
+			return (0, rxjs.defer)(() => {
+				var _this$config$socketPa;
+				let ownSocket = null;
+				let ownChannel = null;
+				const socket$ = ɵphoenixSocket$({
+					url: this.config.url,
+					options: {
+						params: {
+							...(_this$config$socketPa = this.config.socketParams) !== null && _this$config$socketPa !== void 0 ? _this$config$socketPa : {},
+							join_token: credentials.joinToken
+						},
+						reconnectAfterMs: (0, _copilotkitnext_shared.phoenixExponentialBackoff)(100, 1e4),
+						rejoinAfterMs: (0, _copilotkitnext_shared.phoenixExponentialBackoff)(1e3, 3e4)
+					}
+				}).pipe((0, rxjs_operators.tap)(({ socket }) => {
+					ownSocket = socket;
+					this.socket = ownSocket;
+				}), (0, rxjs_operators.shareReplay)({
+					bufferSize: 1,
+					refCount: true
+				}));
+				const { topic, params } = this.createThreadChannelDescriptor(input, options.streamMode, options.replayCursor);
+				const channel$ = ɵphoenixChannel$({
+					socket$,
+					topic,
+					params
+				}).pipe((0, rxjs_operators.tap)(({ channel }) => {
+					ownChannel = channel;
+					this.activeChannel = ownChannel;
+				}), (0, rxjs_operators.shareReplay)({
+					bufferSize: 1,
+					refCount: true
+				}));
+				const threadEvents$ = this.observeThreadEvents$(input.threadId, channel$, options).pipe((0, rxjs_operators.share)());
+				const threadCompleted$ = threadEvents$.pipe((0, rxjs_operators.ignoreElements)(), (0, rxjs_operators.endWith)(null), (0, rxjs_operators.take)(1));
+				return (0, rxjs.merge)(this.joinThreadChannel$(channel$), this.observeSocketHealth$(socket$).pipe((0, rxjs_operators.takeUntil)(threadCompleted$)), threadEvents$).pipe((0, rxjs_operators.finalize)(() => this.cleanupOwned(ownChannel, ownSocket)));
+			});
+		}
+		joinThreadChannel$(channel$) {
+			return ɵjoinPhoenixChannel$(channel$);
+		}
+		observeSocketHealth$(socket$) {
+			return ɵobservePhoenixSocketHealth$(ɵobservePhoenixSocketSignals$(socket$), 5);
+		}
+		observeThreadEvents$(threadId, channel$, options) {
+			return channel$.pipe((0, rxjs_operators.switchMap)(({ channel }) => this.observeChannelEvent$(channel, CLIENT_AG_UI_EVENT)), (0, rxjs_operators.tap)((payload) => {
+				this.updateLastSeenEventId(threadId, payload);
+				this.updateRunIdFromEvent(payload);
+			}), (0, rxjs_operators.mergeMap)((payload) => (0, rxjs.from)(this.createThreadNotifications(payload, options.completeOnRunError))), (0, rxjs.dematerialize)());
+		}
+		observeChannelEvent$(channel, eventName) {
+			return ɵobservePhoenixEvent$(channel, eventName);
+		}
+		createThreadNotifications(payload, completeOnRunError) {
+			if (payload.type === _ag_ui_client.EventType.RUN_FINISHED) return [rxjs.Notification.createNext(payload), rxjs.Notification.createComplete()];
+			if (payload.type === _ag_ui_client.EventType.RUN_ERROR) {
+				var _message;
+				const errorMessage = (_message = payload.message) !== null && _message !== void 0 ? _message : "Run error";
+				return completeOnRunError ? [rxjs.Notification.createNext(payload), rxjs.Notification.createComplete()] : [rxjs.Notification.createNext(payload), rxjs.Notification.createError(new Error(errorMessage))];
+			}
+			return [rxjs.Notification.createNext(payload)];
+		}
+		buildRuntimeUrl(mode) {
+			const path = `${this.config.runtimeUrl}/agent/${encodeURIComponent(this.config.agentId)}/${mode}`;
+			const origin = typeof window !== "undefined" && window.location ? window.location.origin : "http://localhost";
+			return new URL(path, new URL(this.config.runtimeUrl, origin)).toString();
+		}
+		createThreadChannelDescriptor(input, streamMode, replayCursor) {
+			const params = streamMode === "run" ? {
+				stream_mode: "run",
+				run_id: input.runId
+			} : {
+				stream_mode: "connect",
+				last_seen_event_id: replayCursor === void 0 ? this.getReconnectCursor(input) : replayCursor
+			};
+			return {
+				topic: `thread:${input.threadId}`,
+				params
+			};
+		}
+		getLastSeenEventId(threadId) {
+			var _this$sharedState$las;
+			return (_this$sharedState$las = this.sharedState.lastSeenEventIds.get(threadId)) !== null && _this$sharedState$las !== void 0 ? _this$sharedState$las : null;
+		}
+		getReconnectCursor(input) {
+			return this.hasLocalThreadMessages(input) ? this.getLastSeenEventId(input.threadId) : null;
+		}
+		hasLocalThreadMessages(input) {
+			return Array.isArray(input.messages) && input.messages.length > 0;
+		}
+		updateLastSeenEventId(threadId, payload) {
+			const eventId = this.readEventId(payload);
+			if (!eventId) return;
+			this.sharedState.lastSeenEventIds.set(threadId, eventId);
+		}
+		setLastSeenEventId(threadId, eventId) {
+			if (!eventId) return;
+			this.sharedState.lastSeenEventIds.set(threadId, eventId);
+		}
+		/**
+		* Keep `this.runId` in sync with the backend's actual run ID.
+		*
+		* During a `connect` (resume) flow the client generates a fresh `runId`
+		* via `prepareRunAgentInput`, but the backend is running under its own
+		* run ID.  If the client later sends `STOP_RUN_EVENT` with the wrong
+		* `runId`, the gateway's runner channel will not match it and the agent
+		* keeps running.  Extracting the run ID from live events fixes this.
+		*
+		* The runner normalises events to `run_id` (snake_case) before pushing
+		* to the gateway, so we check both `runId` and `run_id`.
+		*/
+		updateRunIdFromEvent(payload) {
+			var _record$runId;
+			const record = payload;
+			const eventRunId = (_record$runId = record.runId) !== null && _record$runId !== void 0 ? _record$runId : record.run_id;
+			if (typeof eventRunId === "string" && eventRunId.length > 0) this.runId = eventRunId;
+		}
+		readEventId(payload) {
+			const metadata = payload.metadata;
+			if (!metadata || typeof metadata !== "object") return null;
+			const runnerEventId = metadata.cpki_event_id;
+			return typeof runnerEventId === "string" ? runnerEventId : null;
+		}
+	};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/checkPrivateRedeclaration.js
+	function _checkPrivateRedeclaration(e, t) {
+		if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/classPrivateMethodInitSpec.js
+	function _classPrivateMethodInitSpec(e, a) {
+		_checkPrivateRedeclaration(e, a), a.add(e);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/assertClassBrand.js
+	function _assertClassBrand(e, t, n) {
+		if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+		throw new TypeError("Private element is not present on this object");
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/getPrototypeOf.js
+	function _getPrototypeOf(t) {
+		return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t) {
+			return t.__proto__ || Object.getPrototypeOf(t);
+		}, _getPrototypeOf(t);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/superPropBase.js
+	function _superPropBase(t, o) {
+		for (; !{}.hasOwnProperty.call(t, o) && null !== (t = _getPrototypeOf(t)););
+		return t;
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/get.js
+	function _get() {
+		return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function(e, t, r) {
+			var p = _superPropBase(e, t);
+			if (p) {
+				var n = Object.getOwnPropertyDescriptor(p, t);
+				return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;
+			}
+		}, _get.apply(null, arguments);
+	}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.112.0/helpers/superPropGet.js
+	function _superPropGet(t, o, e, r) {
+		var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e);
+		return 2 & r && "function" == typeof p ? function(t) {
+			return p.apply(e, t);
+		} : p;
+	}
+
 //#endregion
 //#region src/agent.ts
-/**
-	* Check if an error is a ZodError (validation error).
-	* These can occur when the SSE stream is aborted/truncated mid-event.
-	*/
+	var _ProxiedCopilotRuntimeAgent;
+	function hasHeaders(agent) {
+		return "headers" in agent;
+	}
+	function hasCredentials(agent) {
+		return "credentials" in agent;
+	}
 	function isZodError(error) {
 		return error !== null && typeof error === "object" && "name" in error && error.name === "ZodError";
 	}
-	/**
-	* Wrap an Observable to catch and suppress ZodErrors that occur during stream abort.
-	* These errors are expected when the connection is cancelled mid-stream.
-	*/
 	function withAbortErrorHandling(observable) {
 		return observable.pipe((0, rxjs_operators.catchError)((error) => {
 			if (isZodError(error)) return rxjs.EMPTY;
 			throw error;
 		}));
 	}
-	var ProxiedCopilotRuntimeAgent = class extends _ag_ui_client.HttpAgent {
+	var _ProxiedCopilotRuntimeAgent_brand = /* @__PURE__ */ new WeakSet();
+	var ProxiedCopilotRuntimeAgent = class ProxiedCopilotRuntimeAgent extends _ag_ui_client.HttpAgent {
 		constructor(config) {
-			var _config$transport, _ref, _config$agentId;
+			var _config$transport, _ref, _config$agentId, _config$runtimeMode;
 			const normalizedRuntimeUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/$/, "") : void 0;
 			const transport = (_config$transport = config.transport) !== null && _config$transport !== void 0 ? _config$transport : "rest";
 			const runUrl = transport === "single" ? (_ref = normalizedRuntimeUrl !== null && normalizedRuntimeUrl !== void 0 ? normalizedRuntimeUrl : config.runtimeUrl) !== null && _ref !== void 0 ? _ref : "" : `${normalizedRuntimeUrl !== null && normalizedRuntimeUrl !== void 0 ? normalizedRuntimeUrl : config.runtimeUrl}/agent/${encodeURIComponent((_config$agentId = config.agentId) !== null && _config$agentId !== void 0 ? _config$agentId : "")}/run`;
@@ -76,16 +611,33 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				...config,
 				url: runUrl
 			});
+			_classPrivateMethodInitSpec(this, _ProxiedCopilotRuntimeAgent_brand);
 			_defineProperty(this, "runtimeUrl", void 0);
 			_defineProperty(this, "credentials", void 0);
 			_defineProperty(this, "transport", void 0);
 			_defineProperty(this, "singleEndpointUrl", void 0);
+			_defineProperty(this, "runtimeMode", void 0);
+			_defineProperty(this, "intelligence", void 0);
+			_defineProperty(this, "delegate", void 0);
+			_defineProperty(this, "runtimeInfoPromise", void 0);
 			this.runtimeUrl = normalizedRuntimeUrl !== null && normalizedRuntimeUrl !== void 0 ? normalizedRuntimeUrl : config.runtimeUrl;
 			this.credentials = config.credentials;
 			this.transport = transport;
+			this.runtimeMode = (_config$runtimeMode = config.runtimeMode) !== null && _config$runtimeMode !== void 0 ? _config$runtimeMode : _copilotkitnext_shared.RUNTIME_MODE_SSE;
+			this.intelligence = config.intelligence;
 			if (this.transport === "single") this.singleEndpointUrl = this.runtimeUrl;
 		}
+		async detachActiveRun() {
+			if (this.delegate) await this.delegate.detachActiveRun();
+			await super.detachActiveRun();
+		}
 		abortRun() {
+			if (this.delegate) {
+				this.syncDelegate(this.delegate);
+				this.delegate.abortRun();
+				this.detachActiveRun();
+				return;
+			}
 			if (!this.agentId || !this.threadId) return;
 			if (typeof fetch === "undefined") return;
 			if (this.transport === "single") {
@@ -126,30 +678,112 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				console.error("ProxiedCopilotRuntimeAgent: stop request failed", error);
 			});
 		}
-		connect(input) {
-			if (this.transport === "single") {
-				if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
-				const requestInit = this.createSingleRouteRequestInit(input, "agent/connect", { agentId: this.agentId });
-				return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(this.singleEndpointUrl, requestInit)));
+		async connectAgent(parameters, subscriber) {
+			if (this.runtimeMode !== _copilotkitnext_shared.RUNTIME_MODE_INTELLIGENCE) return super.connectAgent(parameters, subscriber);
+			if (this.delegate) await this.delegate.detachActiveRun();
+			await this.resolveDelegate();
+			const delegate = this.delegate;
+			const bridgeSub = delegate.subscribe({
+				onMessagesChanged: () => {
+					this.setMessages([...delegate.messages]);
+				},
+				onStateChanged: () => {
+					this.setState({ ...delegate.state });
+				},
+				onRunInitialized: () => {
+					this.isRunning = true;
+				},
+				onRunFinalized: () => {
+					this.isRunning = false;
+				},
+				onRunFailed: () => {
+					this.isRunning = false;
+				}
+			});
+			const forwardedSubs = this.subscribers.map((s) => delegate.subscribe(s));
+			try {
+				const result = await delegate.connectAgent(parameters, subscriber);
+				this.setMessages([...delegate.messages]);
+				this.setState({ ...delegate.state });
+				return result;
+			} finally {
+				this.isRunning = false;
+				bridgeSub.unsubscribe();
+				for (const sub of forwardedSubs) sub.unsubscribe();
 			}
-			return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(`${this.runtimeUrl}/agent/${this.agentId}/connect`, this.requestInit(input))));
+		}
+		connect(input) {
+			if (this.runtimeMode === _copilotkitnext_shared.RUNTIME_MODE_INTELLIGENCE) return _assertClassBrand(_ProxiedCopilotRuntimeAgent_brand, this, _connectViaDelegate).call(this, input);
+			return _assertClassBrand(_ProxiedCopilotRuntimeAgent_brand, this, _connectViaHttp).call(this, input);
 		}
 		run(input) {
-			if (this.transport === "single") {
-				if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
-				const requestInit = this.createSingleRouteRequestInit(input, "agent/run", { agentId: this.agentId });
-				return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(this.singleEndpointUrl, requestInit)));
-			}
-			return withAbortErrorHandling(super.run(input));
+			if (this.runtimeMode === _copilotkitnext_shared.RUNTIME_MODE_INTELLIGENCE) return _assertClassBrand(_ProxiedCopilotRuntimeAgent_brand, this, _runViaDelegate).call(this, input);
+			return _assertClassBrand(_ProxiedCopilotRuntimeAgent_brand, this, _runViaHttp).call(this, input);
 		}
 		clone() {
-			const cloned = super.clone();
-			cloned.runtimeUrl = this.runtimeUrl;
-			cloned.credentials = this.credentials;
-			cloned.transport = this.transport;
-			cloned.singleEndpointUrl = this.singleEndpointUrl;
+			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 !== _copilotkitnext_shared.RUNTIME_MODE_INTELLIGENCE) throw new Error("A delegate is only created for Intelligence mode");
+				this.delegate = this.createIntelligenceDelegate();
+			}
+			this.syncDelegate(this.delegate);
+			return this.delegate;
+		}
+		async ensureRuntimeMode() {
+			var _this$runtimeInfoProm;
+			if (this.runtimeMode !== "pending") return;
+			if (!this.runtimeUrl) throw new Error("Runtime URL is not set");
+			(_this$runtimeInfoProm = this.runtimeInfoPromise) !== null && _this$runtimeInfoProm !== void 0 || (this.runtimeInfoPromise = this.fetchRuntimeInfo().then((runtimeInfo) => {
+				var _runtimeInfo$mode;
+				this.runtimeMode = (_runtimeInfo$mode = runtimeInfo.mode) !== null && _runtimeInfo$mode !== void 0 ? _runtimeInfo$mode : _copilotkitnext_shared.RUNTIME_MODE_SSE;
+				this.intelligence = runtimeInfo.intelligence;
+			}));
+			await this.runtimeInfoPromise;
+		}
+		async fetchRuntimeInfo() {
+			const headers = { ...this.headers };
+			let init;
+			let url;
+			if (this.transport === "single") {
+				if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
+				if (!headers["Content-Type"]) headers["Content-Type"] = "application/json";
+				url = this.runtimeUrl;
+				init = {
+					method: "POST",
+					body: JSON.stringify({ method: "info" })
+				};
+			} else {
+				url = `${this.runtimeUrl}/info`;
+				init = {};
+			}
+			const response = await fetch(url, {
+				...init,
+				headers,
+				...this.credentials ? { credentials: this.credentials } : {}
+			});
+			if (!response.ok) throw new Error(`Runtime info request failed with status ${response.status}`);
+			return await response.json();
+		}
 		createSingleRouteRequestInit(input, method, params) {
 			var _baseInit$headers, _headers$get;
 			if (!this.agentId) throw new Error("ProxiedCopilotRuntimeAgent requires agentId to make runtime requests");
@@ -162,7 +796,6 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				originalBody = JSON.parse(baseInit.body);
 			} catch (error) {
 				console.warn("ProxiedCopilotRuntimeAgent: failed to parse request body for single route transport", error);
-				originalBody = void 0;
 			}
 			const envelope = { method };
 			if (params && Object.keys(params).length > 0) envelope.params = params;
@@ -174,7 +807,50 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				...this.credentials ? { credentials: this.credentials } : {}
 			};
 		}
+		createIntelligenceDelegate() {
+			var _this$intelligence;
+			if (!this.runtimeUrl || !this.agentId || !((_this$intelligence = this.intelligence) === null || _this$intelligence === void 0 ? void 0 : _this$intelligence.wsUrl)) throw new Error("Intelligence mode requires runtimeUrl, agentId, and intelligence websocket metadata");
+			return new IntelligenceAgent({
+				url: this.intelligence.wsUrl,
+				runtimeUrl: this.runtimeUrl,
+				agentId: this.agentId,
+				headers: { ...this.headers },
+				credentials: this.credentials
+			});
+		}
+		syncDelegate(delegate) {
+			delegate.agentId = this.agentId;
+			delegate.description = this.description;
+			delegate.threadId = this.threadId;
+			delegate.setMessages(this.messages);
+			delegate.setState(this.state);
+			if (hasHeaders(delegate)) delegate.headers = { ...this.headers };
+			if (hasCredentials(delegate)) delegate.credentials = this.credentials;
+		}
 	};
+	_ProxiedCopilotRuntimeAgent = ProxiedCopilotRuntimeAgent;
+	function _connectViaDelegate(input) {
+		return (0, rxjs.defer)(() => (0, rxjs.from)(this.resolveDelegate())).pipe((0, rxjs_operators.switchMap)((delegate) => withAbortErrorHandling(delegate.connect(input))));
+	}
+	function _connectViaHttp(input) {
+		if (this.transport === "single") {
+			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
+			const requestInit = this.createSingleRouteRequestInit(input, "agent/connect", { agentId: this.agentId });
+			return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(this.singleEndpointUrl, requestInit)));
+		}
+		return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(`${this.runtimeUrl}/agent/${this.agentId}/connect`, this.requestInit(input))));
+	}
+	function _runViaDelegate(input) {
+		return (0, rxjs.defer)(() => (0, rxjs.from)(this.resolveDelegate())).pipe((0, rxjs_operators.switchMap)((delegate) => withAbortErrorHandling(delegate.run(input))));
+	}
+	function _runViaHttp(input) {
+		if (this.transport === "single") {
+			if (!this.singleEndpointUrl) throw new Error("Single endpoint transport requires a runtimeUrl");
+			const requestInit = this.createSingleRouteRequestInit(input, "agent/run", { agentId: this.agentId });
+			return withAbortErrorHandling((0, _ag_ui_client.transformHttpEventStream)((0, _ag_ui_client.runHttpRequest)(this.singleEndpointUrl, requestInit)));
+		}
+		return withAbortErrorHandling(_superPropGet(_ProxiedCopilotRuntimeAgent.prototype, "run", this, 2)([input]));
+	}
 
 //#endregion
 //#region src/core/agent-registry.ts
@@ -193,6 +869,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			_defineProperty(this, "_runtimeConnectionStatus", CopilotKitCoreRuntimeConnectionStatus.Disconnected);
 			_defineProperty(this, "_runtimeTransport", "rest");
 			_defineProperty(this, "_audioFileTranscriptionEnabled", false);
+			_defineProperty(this, "_runtimeMode", _copilotkitnext_shared.RUNTIME_MODE_SSE);
+			_defineProperty(this, "_intelligence", void 0);
 			_defineProperty(this, "_a2uiEnabled", false);
 		}
 		/**
@@ -216,6 +894,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		get audioFileTranscriptionEnabled() {
 			return this._audioFileTranscriptionEnabled;
 		}
+		get runtimeMode() {
+			return this._runtimeMode;
+		}
+		get intelligence() {
+			return this._intelligence;
+		}
 		get a2uiEnabled() {
 			return this._a2uiEnabled;
 		}
@@ -325,6 +1009,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Disconnected;
 				this._runtimeVersion = void 0;
 				this._audioFileTranscriptionEnabled = false;
+				this._runtimeMode = _copilotkitnext_shared.RUNTIME_MODE_SSE;
+				this._intelligence = void 0;
 				this._a2uiEnabled = false;
 				this.remoteAgents = {};
 				this._agents = this.localAgents;
@@ -335,17 +1021,20 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Connecting;
 			await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Connecting);
 			try {
-				var _runtimeInfoResponse$, _runtimeInfoResponse$2;
+				var _runtimeInfoResponse$2, _runtimeInfoResponse$3, _runtimeInfoResponse$4;
 				const runtimeInfoResponse = await this.fetchRuntimeInfo();
 				const { version, ...runtimeInfo } = runtimeInfoResponse;
 				const credentials = this.core.credentials;
 				this.remoteAgents = Object.fromEntries(Object.entries(runtimeInfo.agents).map(([id, { description }]) => {
+					var _runtimeInfoResponse$;
 					const agent = new ProxiedCopilotRuntimeAgent({
 						runtimeUrl: this.runtimeUrl,
 						agentId: id,
 						description,
 						transport: this._runtimeTransport,
-						credentials
+						credentials,
+						runtimeMode: (_runtimeInfoResponse$ = runtimeInfoResponse.mode) !== null && _runtimeInfoResponse$ !== void 0 ? _runtimeInfoResponse$ : _copilotkitnext_shared.RUNTIME_MODE_SSE,
+						intelligence: runtimeInfoResponse.intelligence
 					});
 					this.applyHeadersToAgent(agent);
 					return [id, agent];
@@ -356,14 +1045,18 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				};
 				this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Connected;
 				this._runtimeVersion = version;
-				this._audioFileTranscriptionEnabled = (_runtimeInfoResponse$ = runtimeInfoResponse.audioFileTranscriptionEnabled) !== null && _runtimeInfoResponse$ !== void 0 ? _runtimeInfoResponse$ : false;
-				this._a2uiEnabled = (_runtimeInfoResponse$2 = runtimeInfoResponse.a2uiEnabled) !== null && _runtimeInfoResponse$2 !== void 0 ? _runtimeInfoResponse$2 : false;
+				this._audioFileTranscriptionEnabled = (_runtimeInfoResponse$2 = runtimeInfoResponse.audioFileTranscriptionEnabled) !== null && _runtimeInfoResponse$2 !== void 0 ? _runtimeInfoResponse$2 : false;
+				this._runtimeMode = (_runtimeInfoResponse$3 = runtimeInfoResponse.mode) !== null && _runtimeInfoResponse$3 !== void 0 ? _runtimeInfoResponse$3 : _copilotkitnext_shared.RUNTIME_MODE_SSE;
+				this._intelligence = runtimeInfoResponse.intelligence;
+				this._a2uiEnabled = (_runtimeInfoResponse$4 = runtimeInfoResponse.a2uiEnabled) !== null && _runtimeInfoResponse$4 !== void 0 ? _runtimeInfoResponse$4 : false;
 				await this.notifyRuntimeStatusChanged(CopilotKitCoreRuntimeConnectionStatus.Connected);
 				await this.notifyAgentsChanged();
 			} catch (error) {
 				this._runtimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus.Error;
 				this._runtimeVersion = void 0;
 				this._audioFileTranscriptionEnabled = false;
+				this._runtimeMode = _copilotkitnext_shared.RUNTIME_MODE_SSE;
+				this._intelligence = void 0;
 				this._a2uiEnabled = false;
 				this.remoteAgents = {};
 				this._agents = this.localAgents;
@@ -915,6 +1608,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		async runAgent({ agent, forwardedProps }) {
 			if (agent.agentId) this._internal.suggestionEngine.clearSuggestions(agent.agentId);
 			if (agent instanceof _ag_ui_client.HttpAgent) agent.headers = { ...this._internal.headers };
+			if (agent.detachActiveRun) agent.detachActiveRun();
 			try {
 				const runAgentResult = await agent.runAgent({
 					forwardedProps: {
@@ -1659,6 +2353,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		get audioFileTranscriptionEnabled() {
 			return this.agentRegistry.audioFileTranscriptionEnabled;
 		}
+		get runtimeMode() {
+			return this.agentRegistry.runtimeMode;
+		}
+		get intelligence() {
+			return this.agentRegistry.intelligence;
+		}
 		get a2uiEnabled() {
 			return this.agentRegistry.a2uiEnabled;
 		}
@@ -1995,183 +2695,635 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	}
 
 //#endregion
-//#region src/intelligence-agent.ts
-	var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAgent {
-		constructor(config) {
-			super();
-			_defineProperty(this, "config", void 0);
-			_defineProperty(this, "socket", null);
-			_defineProperty(this, "activeChannel", null);
-			_defineProperty(this, "threadId", null);
-			this.config = config;
-		}
-		clone() {
-			return new IntelligenceAgent(this.config);
+//#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, () => ({}));
 		}
-		abortRun() {
-			if (this.activeChannel && this.threadId) {
-				const fallback = setTimeout(() => this.cleanup(), 5e3);
-				const clear = () => {
-					clearTimeout(fallback);
-					this.cleanup();
-				};
-				this.activeChannel.push(_copilotkitnext_shared.AG_UI_CHANNEL_EVENT, {
-					type: _ag_ui_client.EventType.CUSTOM,
-					name: "stop",
-					value: { threadId: this.threadId }
-				}).receive("ok", clear).receive("error", clear).receive("timeout", clear);
-			} else this.cleanup();
+		return group;
+	}
+	/**
+	* Registers one reducer handler for one or more action creators.
+	*
+	* @throws Error when called without at least one action creator and reducer.
+	*/
+	function on(...args) {
+		if (args.length < 2) throw new Error("on requires at least one action creator and one reducer");
+		const reducer = args[args.length - 1];
+		return {
+			creators: args.slice(0, -1),
+			reducer
+		};
+	}
+	/**
+	* Creates a reducer from an initial state and `on(...)` handler entries.
+	*
+	* Unknown action types return the current state unchanged.
+	*/
+	function createReducer(initialState, ...entries) {
+		const reducerMap = /* @__PURE__ */ new Map();
+		for (const entry of entries) for (const creator of entry.creators) {
+			var _reducerMap$get;
+			const handlers = (_reducerMap$get = reducerMap.get(creator.type)) !== null && _reducerMap$get !== void 0 ? _reducerMap$get : [];
+			handlers.push(entry.reducer);
+			reducerMap.set(creator.type, handlers);
+		}
+		return (state, action) => {
+			const currentState = state !== null && state !== void 0 ? state : initialState;
+			const handlers = reducerMap.get(action.type);
+			if (!handlers || handlers.length === 0) return currentState;
+			let nextState = currentState;
+			for (const handler of handlers) nextState = handler(nextState, action);
+			return nextState;
+		};
+	}
+	/**
+	* Creates a selector that caches and reuses the last computed result
+	* when all input references are unchanged.
+	*/
+	function createSelector(...args) {
+		if (args.length === 1) {
+			const projector = args[0];
+			let hasCached = false;
+			let lastState;
+			let lastResult;
+			return (state) => {
+				if (hasCached && state === lastState) return lastResult;
+				lastState = state;
+				lastResult = projector(state);
+				hasCached = true;
+				return lastResult;
+			};
 		}
-		/**
-		* Connect to a Phoenix channel scoped to the thread, trigger the run via
-		* REST, and relay server-pushed AG-UI events to the Observable subscriber.
-		*
-		* The server pushes each AG-UI event using its EventType string as the
-		* Phoenix event name (e.g. "TEXT_MESSAGE_CHUNK", "TOOL_CALL_START"), with
-		* the full BaseEvent as payload. RUN_FINISHED and RUN_ERROR are terminal
-		* events that complete or error the Observable.
-		*/
-		run(input) {
-			return new rxjs.Observable((observer) => {
-				var _this$config$socketPa;
-				this.threadId = input.threadId;
-				const socket = new phoenix.Socket(this.config.url, {
-					params: (_this$config$socketPa = this.config.socketParams) !== null && _this$config$socketPa !== void 0 ? _this$config$socketPa : {},
-					reconnectAfterMs: (0, _copilotkitnext_shared.phoenixExponentialBackoff)(100, 1e4),
-					rejoinAfterMs: (0, _copilotkitnext_shared.phoenixExponentialBackoff)(1e3, 3e4)
-				});
-				this.socket = socket;
-				socket.connect();
-				const channel = socket.channel(`agent:${input.threadId}`, { runId: input.runId });
-				this.activeChannel = channel;
-				channel.on(_copilotkitnext_shared.AG_UI_CHANNEL_EVENT, (payload) => {
-					observer.next(payload);
-					if (payload.type === _ag_ui_client.EventType.RUN_FINISHED) {
-						observer.complete();
-						this.cleanup();
-					} else if (payload.type === _ag_ui_client.EventType.RUN_ERROR) {
-						var _message;
-						observer.error(new Error((_message = payload.message) !== null && _message !== void 0 ? _message : "Run error"));
-						this.cleanup();
-					}
-				});
-				const MAX_CONSECUTIVE_ERRORS = 5;
-				let consecutiveErrors = 0;
-				socket.onError(() => {
-					consecutiveErrors++;
-					if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-						observer.error(/* @__PURE__ */ new Error(`WebSocket connection failed after ${MAX_CONSECUTIVE_ERRORS} consecutive errors`));
-						this.cleanup();
-					}
-				});
-				socket.onOpen(() => {
-					consecutiveErrors = 0;
-				});
-				channel.onError(() => {});
-				channel.join().receive("ok", () => {
-					const { runtimeUrl, agentId, headers, credentials } = this.config;
-					const runPath = `${runtimeUrl}/agent/${encodeURIComponent(agentId)}/run`;
-					const origin = typeof window !== "undefined" && window.location ? window.location.origin : "http://localhost";
-					const runUrl = new URL(runPath, new URL(runtimeUrl, origin));
-					fetch(runUrl.toString(), {
-						method: "POST",
-						headers: {
-							"Content-Type": "application/json",
-							...headers
+		const projector = args[args.length - 1];
+		const selectors = args.slice(0, -1);
+		let hasCached = false;
+		let lastInputs = [];
+		let lastResult;
+		return (state) => {
+			const inputs = selectors.map((selector) => selector(state));
+			if (hasCached && inputs.length === lastInputs.length && inputs.every((value, index) => value === lastInputs[index])) return lastResult;
+			lastInputs = inputs;
+			lastResult = projector(...inputs);
+			hasCached = true;
+			return lastResult;
+		};
+	}
+	/**
+	* RxJS operator that maps state emissions through a selector and suppresses
+	* unchanged projected values via reference equality.
+	*/
+	function select(selector) {
+		return (source$) => source$.pipe((0, rxjs_operators.map)(selector), (0, rxjs_operators.distinctUntilChanged)());
+	}
+	/**
+	* RxJS operator that filters an action stream by action creators and narrows
+	* the output action type to the matched creator union.
+	*
+	* @throws Error when called without at least one action creator.
+	*/
+	function ofType(...creators) {
+		if (creators.length === 0) throw new Error("ofType requires at least one action creator");
+		const actionTypes = new Set(creators.map((creator) => creator.type));
+		return (source$) => {
+			return source$.pipe((0, rxjs_operators.filter)((action) => {
+				return actionTypes.has(action.type);
+			}));
+		};
+	}
+	/**
+	* Creates an effect descriptor consumed by `createStore`.
+	*/
+	function createEffect(factory, options = {}) {
+		if (options.dispatch === false) return {
+			run: factory,
+			dispatch: false
+		};
+		return {
+			run: factory,
+			dispatch: true
+		};
+	}
+	/**
+	* Creates a small observable store with reducer + effects.
+	*
+	* Behavior:
+	* - `init()` starts effects and dispatches `@@micro-redux/init`.
+	* - `stop()` dispatches `@@micro-redux/stop` and unsubscribes all effects.
+	* - Effect action observation is scheduled on `asapScheduler` to avoid
+	*   synchronous re-entrancy in the effect loop.
+	* - Any effect error triggers fail-fast teardown and errors both `actions$`
+	*   and `state$`.
+	*/
+	function createStore(options) {
+		var _options$effects;
+		const reducer = options.reducer;
+		const effects = (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : [];
+		let hasFatalError = false;
+		let isRunning = false;
+		let effectSubscriptions = new rxjs.Subscription();
+		let currentState = reducer(void 0, INTERNAL_BOOT_ACTION);
+		const stateSubject = new rxjs.BehaviorSubject(currentState);
+		const actionsSubject = new rxjs.Subject();
+		const dispatchInternal = (action) => {
+			if (hasFatalError) throw new Error("Store is in a failed state due to an effect error");
+			currentState = reducer(currentState, action);
+			stateSubject.next(currentState);
+			actionsSubject.next(action);
+		};
+		const failFast = (error) => {
+			if (hasFatalError) return;
+			hasFatalError = true;
+			isRunning = false;
+			effectSubscriptions.unsubscribe();
+			effectSubscriptions = new rxjs.Subscription();
+			actionsSubject.error(error);
+			stateSubject.error(error);
+		};
+		const startEffects = () => {
+			for (const effect of effects) {
+				const scheduledActions$ = actionsSubject.asObservable().pipe((0, rxjs_operators.observeOn)(rxjs.asapScheduler));
+				const state$ = stateSubject.asObservable();
+				if (effect.dispatch) {
+					const subscription = effect.run(scheduledActions$, state$).subscribe({
+						next: (effectAction) => {
+							if (hasFatalError) return;
+							dispatchInternal(effectAction);
 						},
-						body: JSON.stringify({
-							threadId: input.threadId,
-							runId: input.runId,
-							messages: input.messages,
-							tools: input.tools,
-							context: input.context,
-							state: input.state,
-							forwardedProps: input.forwardedProps
-						}),
-						...credentials ? { credentials } : {}
-					}).catch((error) => {
-						var _error$message;
-						observer.error(/* @__PURE__ */ new Error(`REST run request failed: ${(_error$message = error.message) !== null && _error$message !== void 0 ? _error$message : error}`));
-						this.cleanup();
+						error: (error) => {
+							failFast(error);
+						}
 					});
-				}).receive("error", (resp) => {
-					observer.error(/* @__PURE__ */ new Error(`Failed to join channel: ${JSON.stringify(resp)}`));
-					this.cleanup();
-				}).receive("timeout", () => {
-					observer.error(/* @__PURE__ */ new Error("Timed out joining channel"));
-					this.cleanup();
-				});
-				return () => {
-					this.cleanup();
-				};
+					effectSubscriptions.add(subscription);
+					continue;
+				}
+				const subscription = effect.run(scheduledActions$, state$).subscribe({ error: (error) => {
+					failFast(error);
+				} });
+				effectSubscriptions.add(subscription);
+			}
+		};
+		return {
+			dispatch(action) {
+				dispatchInternal(action);
+			},
+			getState() {
+				return currentState;
+			},
+			get state$() {
+				return stateSubject.asObservable();
+			},
+			get actions$() {
+				return actionsSubject.asObservable();
+			},
+			select(selector) {
+				return stateSubject.asObservable().pipe(select(selector));
+			},
+			init() {
+				if (hasFatalError || isRunning) return;
+				isRunning = true;
+				startEffects();
+				if (hasFatalError) return;
+				dispatchInternal({ type: INTERNAL_ACTION_TYPES.init });
+			},
+			stop() {
+				if (hasFatalError || !isRunning) return;
+				dispatchInternal({ type: INTERNAL_ACTION_TYPES.stop });
+				effectSubscriptions.unsubscribe();
+				effectSubscriptions = new rxjs.Subscription();
+				isRunning = false;
+			}
+		};
+	}
+
+//#endregion
+//#region src/threads.ts
+	const THREADS_CHANNEL_EVENT = "thread_metadata";
+	const THREAD_SUBSCRIBE_PATH = "/threads/subscribe";
+	const MAX_SOCKET_RETRIES = 5;
+	const REQUEST_TIMEOUT_MS = 15e3;
+	const initialThreadState = {
+		threads: [],
+		isLoading: false,
+		error: null,
+		context: null,
+		sessionId: 0,
+		metadataCredentialsRequested: false
+	};
+	const threadAdapterEvents = createActionGroup("Thread Adapter", {
+		started: empty(),
+		stopped: empty(),
+		contextChanged: props(),
+		renameRequested: props(),
+		archiveRequested: props(),
+		deleteRequested: props()
+	});
+	const threadRestEvents = createActionGroup("Thread REST", {
+		listRequested: props(),
+		listSucceeded: props(),
+		listFailed: 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),
+		error: null,
+		metadataCredentialsRequested: false
+	})), on(threadAdapterEvents.stopped, (state) => ({
+		...state,
+		threads: [],
+		isLoading: false,
+		error: null,
+		metadataCredentialsRequested: false
+	})), 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 }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			threads: sortThreadsByUpdatedAt(threads),
+			isLoading: false,
+			error: null
+		};
+	}), on(threadRestEvents.listFailed, (state, { sessionId, error }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			isLoading: 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(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);
+	let threadRequestId = 0;
+	function createThreadRequestId() {
+		threadRequestId += 1;
+		return `thread-request-${threadRequestId}`;
+	}
+	function createThreadFetchObservable(environment, context, sessionId) {
+		return (0, rxjs.defer)(() => {
+			const params = new URLSearchParams({
+				userId: context.userId,
+				agentId: context.agentId
 			});
-		}
-		/**
-		* Reconnect to an existing thread by joining the Phoenix channel in
-		* "connect" mode and requesting the server replay history.
-		*/
-		connect(input) {
-			return new rxjs.Observable((observer) => {
-				var _this$config$socketPa2;
-				this.threadId = input.threadId;
-				const socket = new phoenix.Socket(this.config.url, {
-					params: (_this$config$socketPa2 = this.config.socketParams) !== null && _this$config$socketPa2 !== void 0 ? _this$config$socketPa2 : {},
-					reconnectAfterMs: (0, _copilotkitnext_shared.phoenixExponentialBackoff)(100, 1e4),
-					rejoinAfterMs: (0, _copilotkitnext_shared.phoenixExponentialBackoff)(1e3, 3e4)
-				});
-				this.socket = socket;
-				socket.connect();
-				const channel = socket.channel(`agent:${input.threadId}`, { mode: "connect" });
-				this.activeChannel = channel;
-				channel.on(_copilotkitnext_shared.AG_UI_CHANNEL_EVENT, (payload) => {
-					observer.next(payload);
-					if (payload.type === _ag_ui_client.EventType.RUN_FINISHED || payload.type === _ag_ui_client.EventType.RUN_ERROR) {
-						observer.complete();
-						this.cleanup();
-					}
+			return (0, rxjs_fetch.fromFetch)(`${context.runtimeUrl}/threads?${params.toString()}`, {
+				selector: (response) => {
+					if (!response.ok) throw new Error(`Failed to fetch threads: ${response.status}`);
+					return response.json();
+				},
+				fetch: environment.fetch,
+				method: "GET",
+				headers: { ...context.headers }
+			}).pipe((0, rxjs_operators.timeout)({
+				first: REQUEST_TIMEOUT_MS,
+				with: () => {
+					throw new Error("Request timed out");
+				}
+			}), (0, rxjs_operators.map)((data) => threadRestEvents.listSucceeded({
+				sessionId,
+				threads: data.threads
+			})), (0, rxjs_operators.catchError)((error) => {
+				return (0, rxjs.of)(threadRestEvents.listFailed({
+					sessionId,
+					error: error instanceof Error ? error : new Error(String(error))
+				}));
+			}));
+		});
+	}
+	function createThreadMetadataCredentialsObservable(environment, context, sessionId) {
+		return (0, rxjs.defer)(() => {
+			return (0, rxjs_fetch.fromFetch)(`${context.runtimeUrl}${THREAD_SUBSCRIBE_PATH}`, {
+				selector: async (response) => {
+					if (!response.ok) throw new Error(`Failed to fetch thread metadata credentials: ${response.status}`);
+					return response.json();
+				},
+				fetch: environment.fetch,
+				method: "POST",
+				headers: {
+					...context.headers,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({ userId: context.userId })
+			}).pipe((0, rxjs_operators.timeout)({
+				first: REQUEST_TIMEOUT_MS,
+				with: () => {
+					throw new Error("Request timed out");
+				}
+			}), (0, rxjs_operators.map)((data) => {
+				if (typeof data.joinToken !== "string" || data.joinToken.length === 0) throw new Error("missing joinToken");
+				return threadRestEvents.metadataCredentialsSucceeded({
+					sessionId,
+					joinToken: data.joinToken
 				});
-				const MAX_CONSECUTIVE_ERRORS = 5;
-				let consecutiveErrors = 0;
-				socket.onError(() => {
-					consecutiveErrors++;
-					if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-						observer.error(/* @__PURE__ */ new Error(`WebSocket connection failed after ${MAX_CONSECUTIVE_ERRORS} consecutive errors`));
-						this.cleanup();
+			}), (0, rxjs_operators.catchError)((error) => {
+				return (0, rxjs.of)(threadRestEvents.metadataCredentialsFailed({
+					sessionId,
+					error: error instanceof Error ? error : new Error(String(error))
+				}));
+			}));
+		});
+	}
+	function createThreadMutationObservable(environment, context, request) {
+		return (0, rxjs.defer)(() => {
+			return (0, rxjs_fetch.fromFetch)(`${context.runtimeUrl}${request.path}`, {
+				selector: async (response) => {
+					if (!response.ok) throw new Error(`Request failed: ${response.status}`);
+					return null;
+				},
+				fetch: environment.fetch,
+				method: request.method,
+				headers: {
+					...context.headers,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify(request.body)
+			}).pipe((0, rxjs_operators.map)(() => threadRestEvents.mutationFinished({ outcome: {
+				requestId: request.requestId,
+				ok: true
+			} })), (0, rxjs_operators.catchError)((error) => {
+				return (0, rxjs.of)(threadRestEvents.mutationFinished({ outcome: {
+					requestId: request.requestId,
+					ok: false,
+					error: error instanceof Error ? error : new Error(String(error))
+				} }));
+			}));
+		});
+	}
+	function createThreadStore(environment) {
+		const store = createStore({
+			reducer: threadReducer,
+			effects: [
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadAdapterEvents.contextChanged), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([, state]) => Boolean(state.context)), (0, rxjs_operators.map)(([, state]) => threadRestEvents.listRequested({ sessionId: state.sessionId })))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.listRequested), (0, rxjs_operators.switchMap)((action) => state$.pipe((0, rxjs_operators.map)((state) => state.context), (0, rxjs_operators.filter)((context) => Boolean(context)), (0, rxjs_operators.take)(1), (0, rxjs_operators.map)((context) => ({
+					action,
+					context
+				})), (0, rxjs_operators.takeUntil)(actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped))), (0, rxjs_operators.switchMap)(({ action: currentAction, context }) => createThreadFetchObservable(environment, context, currentAction.sessionId)))))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.listSucceeded), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([action, state]) => {
+					var _state$context;
+					return action.sessionId === state.sessionId && !state.metadataCredentialsRequested && Boolean((_state$context = state.context) === null || _state$context === void 0 ? void 0 : _state$context.wsUrl);
+				}), (0, rxjs_operators.map)(([action]) => threadRestEvents.metadataCredentialsRequested({ sessionId: action.sessionId })))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.metadataCredentialsRequested), (0, rxjs_operators.switchMap)((action) => state$.pipe((0, rxjs_operators.map)((state) => state.context), (0, rxjs_operators.filter)((context) => Boolean(context)), (0, rxjs_operators.take)(1), (0, rxjs_operators.map)((context) => ({
+					action,
+					context
+				})), (0, rxjs_operators.takeUntil)(actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped))), (0, rxjs_operators.switchMap)(({ action: currentAction, context }) => createThreadMetadataCredentialsObservable(environment, context, currentAction.sessionId)))))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadRestEvents.metadataCredentialsSucceeded), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([action, state]) => {
+					var _state$context2;
+					return action.sessionId === state.sessionId && Boolean((_state$context2 = state.context) === null || _state$context2 === void 0 ? void 0 : _state$context2.wsUrl);
+				}), (0, rxjs_operators.switchMap)(([action, state]) => {
+					const context = state.context;
+					const joinToken = action.joinToken;
+					const shutdown$ = actions$.pipe(ofType(threadAdapterEvents.contextChanged, threadAdapterEvents.stopped));
+					return (0, rxjs.defer)(() => {
+						const socket$ = ɵphoenixSocket$({
+							url: context.wsUrl,
+							options: {
+								params: { join_token: joinToken },
+								reconnectAfterMs: (0, _copilotkitnext_shared.phoenixExponentialBackoff)(100, 1e4),
+								rejoinAfterMs: (0, _copilotkitnext_shared.phoenixExponentialBackoff)(1e3, 3e4)
+							}
+						}).pipe((0, rxjs_operators.shareReplay)({
+							bufferSize: 1,
+							refCount: true
+						}));
+						const channel$ = ɵphoenixChannel$({
+							socket$,
+							topic: `user_meta:${context.userId}`
+						}).pipe((0, rxjs_operators.shareReplay)({
+							bufferSize: 1,
+							refCount: true
+						}));
+						const socketSignals$ = ɵobservePhoenixSocketSignals$(socket$).pipe((0, rxjs_operators.share)());
+						const fatalSocketShutdown$ = ɵobservePhoenixSocketHealth$(socketSignals$, MAX_SOCKET_RETRIES).pipe((0, rxjs_operators.catchError)(() => {
+							console.warn(`[threads] WebSocket failed after ${MAX_SOCKET_RETRIES} attempts, giving up`);
+							return (0, rxjs.of)(void 0);
+						}), (0, rxjs_operators.share)());
+						return (0, rxjs.merge)(socketSignals$.pipe((0, rxjs_operators.map)((signal) => signal.type === "open" ? threadSocketEvents.opened({ sessionId: action.sessionId }) : threadSocketEvents.errored({ sessionId: action.sessionId }))), channel$.pipe((0, rxjs_operators.switchMap)(({ channel }) => ɵobservePhoenixEvent$(channel, THREADS_CHANNEL_EVENT)), (0, rxjs_operators.map)((payload) => threadSocketEvents.metadataReceived({
+							sessionId: action.sessionId,
+							payload
+						}))), ɵobservePhoenixJoinOutcome$(channel$).pipe((0, rxjs_operators.filter)((outcome) => outcome.type !== "joined"), (0, rxjs_operators.map)((outcome) => outcome.type === "timeout" ? threadSocketEvents.joinTimedOut({ sessionId: action.sessionId }) : threadSocketEvents.joinFailed({ sessionId: action.sessionId })))).pipe((0, rxjs_operators.takeUntil)((0, rxjs.merge)(shutdown$, fatalSocketShutdown$)));
+					});
+				}))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadSocketEvents.metadataReceived), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([action, state]) => {
+					var _state$context3;
+					return action.sessionId === state.sessionId && action.payload.userId === ((_state$context3 = state.context) === null || _state$context3 === void 0 ? void 0 : _state$context3.userId);
+				}), (0, rxjs_operators.map)(([action]) => {
+					if (action.payload.operation === "deleted") return threadDomainEvents.threadDeleted({
+						sessionId: action.sessionId,
+						threadId: action.payload.deleted.id
+					});
+					return threadDomainEvents.threadUpserted({
+						sessionId: action.sessionId,
+						thread: action.payload.thread
+					});
+				}))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(threadAdapterEvents.renameRequested, threadAdapterEvents.archiveRequested, threadAdapterEvents.deleteRequested), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.mergeMap)(([action, state]) => {
+					const context = state.context;
+					if (!(context === null || context === void 0 ? void 0 : context.runtimeUrl)) {
+						const requestId = action.requestId;
+						return (0, rxjs.of)(threadRestEvents.mutationFinished({ outcome: {
+							requestId,
+							ok: false,
+							error: /* @__PURE__ */ new Error("Runtime URL is not configured")
+						} }));
 					}
-				});
-				socket.onOpen(() => {
-					consecutiveErrors = 0;
-				});
-				channel.onError(() => {});
-				channel.join().receive("ok", () => {
-					channel.push(_ag_ui_client.EventType.CUSTOM, {
-						type: _ag_ui_client.EventType.CUSTOM,
-						name: "connect",
-						value: { threadId: input.threadId }
+					const commonBody = {
+						userId: context.userId,
+						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
+						}
 					});
-				}).receive("error", (resp) => {
-					observer.error(/* @__PURE__ */ new Error(`Failed to join channel: ${JSON.stringify(resp)}`));
-					this.cleanup();
-				}).receive("timeout", () => {
-					observer.error(/* @__PURE__ */ new Error("Timed out joining channel"));
-					this.cleanup();
-				});
-				return () => {
-					this.cleanup();
-				};
+					if (threadAdapterEvents.archiveRequested.match(action)) return createThreadMutationObservable(environment, context, {
+						requestId: action.requestId,
+						method: "POST",
+						path: `/threads/${encodeURIComponent(action.threadId)}/archive`,
+						body: commonBody
+					});
+					return createThreadMutationObservable(environment, context, {
+						requestId: action.requestId,
+						method: "DELETE",
+						path: `/threads/${encodeURIComponent(action.threadId)}`,
+						body: commonBody
+					});
+				})))
+			]
+		});
+		function trackMutation(dispatchAction) {
+			const resultPromise = (0, rxjs.firstValueFrom)((0, rxjs.merge)(store.actions$.pipe(ofType(threadRestEvents.mutationFinished), (0, rxjs_operators.filter)((action) => action.outcome.requestId === dispatchAction.requestId), (0, rxjs_operators.map)((action) => action.outcome)), store.actions$.pipe(ofType(threadAdapterEvents.stopped), (0, rxjs_operators.map)(() => ({
+				requestId: dispatchAction.requestId,
+				ok: false,
+				error: /* @__PURE__ */ new Error("Thread store stopped before mutation completed")
+			})))).pipe((0, rxjs_operators.take)(1))).then((outcome) => {
+				if (outcome.ok) return;
+				throw outcome.error;
 			});
-		}
-		cleanup() {
-			if (this.activeChannel) {
-				this.activeChannel.leave();
-				this.activeChannel = null;
-			}
-			if (this.socket) {
-				this.socket.disconnect();
-				this.socket = null;
-			}
-		}
-	};
+			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 }));
+			},
+			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;
 
 //#endregion
 exports.AgentRegistry = AgentRegistry;
@@ -2186,6 +3338,28 @@ exports.StateManager = StateManager;
 exports.SuggestionEngine = SuggestionEngine;
 exports.ToolCallStatus = ToolCallStatus;
 exports.completePartialMarkdown = completePartialMarkdown;
+exports.createActionGroup = createActionGroup;
+exports.createEffect = createEffect;
+exports.createReducer = createReducer;
+exports.createSelector = createSelector;
+exports.createStore = createStore;
+exports.empty = empty;
 exports.ensureObjectArgs = ensureObjectArgs;
+exports.ofType = ofType;
+exports.on = on;
+exports.props = props;
+exports.select = select;
+exports.ɵcreateThreadStore = createThreadStore;
+exports.ɵjoinPhoenixChannel$ = ɵjoinPhoenixChannel$;
+exports.ɵobservePhoenixEvent$ = ɵobservePhoenixEvent$;
+exports.ɵobservePhoenixJoinOutcome$ = ɵobservePhoenixJoinOutcome$;
+exports.ɵobservePhoenixSocketHealth$ = ɵobservePhoenixSocketHealth$;
+exports.ɵobservePhoenixSocketSignals$ = ɵobservePhoenixSocketSignals$;
+exports.ɵphoenixChannel$ = ɵphoenixChannel$;
+exports.ɵphoenixSocket$ = ɵphoenixSocket$;
+exports.ɵselectThreads = ɵselectThreads;
+exports.ɵselectThreadsError = ɵselectThreadsError;
+exports.ɵselectThreadsIsLoading = ɵselectThreadsIsLoading;
+exports.ɵthreadAdapterEvents = ɵthreadAdapterEvents;
 });
 //# sourceMappingURL=index.umd.js.map