@copilotkit/core 1.62.1 → 1.62.2-canary.1784333495

package/dist/index.umd.js

@@ -170,6 +170,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	const REPLAY_COMPLETE_EVENT = "replay_complete";
 	const STREAM_IDLE_EVENT = "stream_idle";
 	const STOP_RUN_EVENT = "stop_run";
+	const CONNECT_STREAM_IDLE_REPLAY_FALLBACK_MS = 100;
 	var AgentThreadLockedError = class extends Error {
 		constructor(threadId) {
 			super(threadId ? `Thread ${threadId} is locked` : "Thread is locked");
@@ -320,12 +321,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		connect(input) {
 			this.threadId = input.threadId;
 			this.canonicalRunId = null;
-			return (0, rxjs.defer)(() => this.requestJoinCredentials$("connect", input)).pipe((0, rxjs.switchMap)((credentials) => {
+			const replayCursor = this.getReconnectCursor(input);
+			return (0, rxjs.defer)(() => this.requestJoinCredentials$("connect", input, replayCursor)).pipe((0, rxjs.switchMap)((credentials) => {
 				if (credentials === null) return rxjs.EMPTY;
 				const canonicalInput = this.applyCanonicalRunIdentity(input, credentials, { fallbackToInputRunId: false });
 				return this.observeThread$(canonicalInput, credentials, {
 					completeOnRunError: false,
-					streamMode: "connect"
+					streamMode: "connect",
+					replayCursor
 				});
 			}));
 		}
@@ -348,7 +351,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		cleanup() {
 			this.cleanupOwned(this.activeChannel, this.socket);
 		}
-		requestJoinCredentials$(mode, input) {
+		requestJoinCredentials$(mode, input, replayCursor) {
 			return (0, rxjs.defer)(async () => {
 				try {
 					const response = await fetch(this.buildRuntimeUrl(mode), {
@@ -365,7 +368,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 							context: input.context,
 							state: input.state,
 							forwardedProps: input.forwardedProps,
-							...mode === "connect" ? { lastSeenEventId: this.getReconnectCursor(input) } : {}
+							...mode === "connect" ? { lastSeenEventId: replayCursor === void 0 ? this.getReconnectCursor(input) : replayCursor } : {}
 						}),
 						...this.config.credentials ? { credentials: this.config.credentials } : {}
 					});
@@ -401,16 +404,17 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		observeThread$(input, credentials, options) {
 			return this.observeThreadSession$(input, credentials, options).pipe((0, rxjs_operators.catchError)((error) => {
 				if (!this.isSocketReconnectExhaustedError(error)) return (0, rxjs.throwError)(() => error);
-				return this.requestJoinCredentials$("connect", input).pipe((0, rxjs.switchMap)((refreshedCredentials) => refreshedCredentials === null ? rxjs.EMPTY : this.observeThread$(this.applyCanonicalRunIdentity(input, refreshedCredentials, { fallbackToInputRunId: options.streamMode === "run" }), refreshedCredentials, {
+				const replayCursor = this.getReconnectCursor(input);
+				return this.requestJoinCredentials$("connect", input, replayCursor).pipe((0, rxjs.switchMap)((refreshedCredentials) => refreshedCredentials === null ? rxjs.EMPTY : this.observeThread$(this.applyCanonicalRunIdentity(input, refreshedCredentials, { fallbackToInputRunId: options.streamMode === "run" }), refreshedCredentials, {
 					...options,
 					channelMode: "connect",
-					replayCursor: this.getReconnectCursor(input)
+					replayCursor
 				})));
 			}));
 		}
 		observeThreadSession$(input, credentials, options) {
 			return (0, rxjs.defer)(() => {
-				var _options$channelMode;
+				var _options$channelMode, _options$replayCursor;
 				let ownSocket = null;
 				let ownChannel = null;
 				const socket$ = ɵphoenixSocket$({
@@ -442,15 +446,24 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					bufferSize: 1,
 					refCount: true
 				}));
-				const threadEvents$ = this.observeThreadEvents$(input.threadId, channel$, options).pipe((0, rxjs_operators.share)());
-				const replayComplete$ = this.observeControlEvent$(input.threadId, channel$, REPLAY_COMPLETE_EVENT).pipe((0, rxjs_operators.ignoreElements)(), (0, rxjs_operators.share)());
+				const reconnectCursor = this.readDurableEventId((_options$replayCursor = options.replayCursor) !== null && _options$replayCursor !== void 0 ? _options$replayCursor : this.getReconnectCursor(input));
+				let latestObservedReplayCursor = null;
+				const threadEvents$ = this.observeThreadEvents$(input.threadId, channel$, options).pipe((0, rxjs_operators.tap)((payload) => {
+					var _this$readEventId;
+					latestObservedReplayCursor = (_this$readEventId = this.readEventId(payload)) !== null && _this$readEventId !== void 0 ? _this$readEventId : latestObservedReplayCursor;
+				}), (0, rxjs_operators.share)());
+				const replayComplete$ = this.observeControlEvent$(input.threadId, channel$, REPLAY_COMPLETE_EVENT).pipe((0, rxjs_operators.shareReplay)({
+					bufferSize: 1,
+					refCount: true
+				}));
 				const streamIdle$ = this.observeControlEvent$(input.threadId, channel$, STREAM_IDLE_EVENT).pipe((0, rxjs_operators.shareReplay)({
 					bufferSize: 1,
 					refCount: true
 				}));
-				const streamIdleCompletion$ = options.streamMode === "connect" ? streamIdle$.pipe((0, rxjs_operators.take)(1)) : rxjs.EMPTY;
-				const terminal$ = (0, rxjs.merge)(threadEvents$.pipe((0, rxjs_operators.ignoreElements)(), (0, rxjs_operators.endWith)(null), (0, rxjs_operators.take)(1)), streamIdleCompletion$);
-				return (0, rxjs.merge)(this.joinThreadChannel$(channel$), this.observeSocketHealth$(socket$).pipe((0, rxjs_operators.takeUntil)(terminal$)), threadEvents$.pipe((0, rxjs_operators.takeUntil)(streamIdleCompletion$)), replayComplete$.pipe((0, rxjs_operators.takeUntil)(terminal$)), streamIdleCompletion$.pipe((0, rxjs_operators.ignoreElements)())).pipe((0, rxjs_operators.finalize)(() => this.cleanupOwned(ownChannel, ownSocket)));
+				const streamIdleCompletion$ = options.streamMode === "connect" ? (0, rxjs.merge)((0, rxjs.combineLatest)([replayComplete$.pipe((0, rxjs_operators.take)(1)), streamIdle$.pipe((0, rxjs_operators.take)(1))]), streamIdle$.pipe((0, rxjs_operators.take)(1), (0, rxjs_operators.filter)((payload) => this.canFallbackCompleteConnect(payload, reconnectCursor, latestObservedReplayCursor)), (0, rxjs_operators.delay)(CONNECT_STREAM_IDLE_REPLAY_FALLBACK_MS))).pipe((0, rxjs_operators.take)(1)) : rxjs.EMPTY;
+				const threadCompleted$ = threadEvents$.pipe((0, rxjs_operators.ignoreElements)(), (0, rxjs_operators.endWith)(null), (0, rxjs_operators.take)(1));
+				const terminal$ = (0, rxjs.merge)(threadCompleted$, streamIdleCompletion$);
+				return (0, rxjs.merge)(this.joinThreadChannel$(channel$), this.observeSocketHealth$(socket$).pipe((0, rxjs_operators.takeUntil)(terminal$)), threadEvents$.pipe((0, rxjs_operators.takeUntil)(streamIdleCompletion$)), replayComplete$.pipe((0, rxjs_operators.ignoreElements)(), (0, rxjs_operators.takeUntil)(terminal$)), streamIdleCompletion$.pipe((0, rxjs_operators.ignoreElements)(), (0, rxjs_operators.takeUntil)(threadCompleted$))).pipe((0, rxjs_operators.finalize)(() => this.cleanupOwned(ownChannel, ownSocket)));
 			});
 		}
 		joinThreadChannel$(channel$) {
@@ -518,23 +531,37 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		updateLastSeenEventId(threadId, payload) {
 			const eventId = this.readEventId(payload);
 			if (!eventId) return;
-			this.sharedState.lastSeenEventIds.set(threadId, eventId);
+			this.advanceLastSeenEventId(threadId, eventId);
 		}
 		updateLastSeenEventIdFromControl(threadId, payload) {
 			const eventId = this.readControlEventId(payload);
 			if (!eventId) return;
+			this.advanceLastSeenEventId(threadId, eventId);
+		}
+		advanceLastSeenEventId(threadId, eventId) {
 			this.sharedState.lastSeenEventIds.set(threadId, eventId);
 		}
 		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;
+			const eventMetadata = metadata;
+			return this.readDurableEventId(eventMetadata.cpki_event_id);
 		}
 		readControlEventId(payload) {
+			var _controlPayload$lates;
 			if (!payload || typeof payload !== "object") return null;
-			const latestEventId = payload.latestEventId;
-			return typeof latestEventId === "string" ? latestEventId : null;
+			const controlPayload = payload;
+			const latestEventId = (_controlPayload$lates = controlPayload.latestEventId) !== null && _controlPayload$lates !== void 0 ? _controlPayload$lates : controlPayload.latest_event_id;
+			return this.readDurableEventId(latestEventId);
+		}
+		readDurableEventId(eventId) {
+			if (typeof eventId !== "string" || eventId.trim() === "") return null;
+			return eventId.startsWith("cpki_ingested") ? null : eventId;
+		}
+		canFallbackCompleteConnect(streamIdlePayload, reconnectCursor, latestObservedReplayCursor) {
+			const idleCursor = this.readControlEventId(streamIdlePayload);
+			if (!idleCursor) return true;
+			return idleCursor === reconnectCursor || idleCursor === latestObservedReplayCursor;
 		}
 		applyCanonicalRunIdentity(input, credentials, options) {
 			var _credentials$runId;
@@ -1769,7 +1796,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			_defineProperty(this, "_tools", []);
 			_defineProperty(this, "_runAbortController", null);
 			_defineProperty(this, "_runDepth", 0);
-			_defineProperty(this, "_lastConnectedThreadId", null);
+			_defineProperty(this, "_lastConnectedThreadIdsByAgent", /* @__PURE__ */ new Map());
+			_defineProperty(this, "_anonymousAgentIds", /* @__PURE__ */ new WeakMap());
+			_defineProperty(this, "_nextAnonymousAgentId", 0);
 		}
 		/**
 		* Abort the current run. Called by `CopilotKitCore.stopAgent()` to signal
@@ -1788,6 +1817,20 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return this.core;
 		}
 		/**
+		* Return a stable restore-tracking key for the logical agent being
+		* connected. Named agents share their last-thread marker across proxy
+		* instances; anonymous agents fall back to object identity.
+		*/
+		getConnectRestoreKey(agent) {
+			if (agent.agentId) return `agent:${agent.agentId}`;
+			const existing = this._anonymousAgentIds.get(agent);
+			if (existing) return existing;
+			const anonymousId = `anonymous:${this._nextAnonymousAgentId}`;
+			this._nextAnonymousAgentId += 1;
+			this._anonymousAgentIds.set(agent, anonymousId);
+			return anonymousId;
+		}
+		/**
 		* Get all tools as a readonly array
 		*/
 		get tools() {
@@ -1842,16 +1885,20 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		*/
 		async connectAgent({ agent }) {
 			try {
-				var _agent$threadId;
+				var _agent$threadId, _this$_lastConnectedT;
 				const incomingThreadId = (_agent$threadId = agent.threadId) !== null && _agent$threadId !== void 0 ? _agent$threadId : null;
-				const isFreshRestore = incomingThreadId !== this._lastConnectedThreadId;
-				this._lastConnectedThreadId = incomingThreadId;
+				const restoreKey = this.getConnectRestoreKey(agent);
+				const isFreshRestore = incomingThreadId !== ((_this$_lastConnectedT = this._lastConnectedThreadIdsByAgent.get(restoreKey)) !== null && _this$_lastConnectedT !== void 0 ? _this$_lastConnectedT : null);
+				this._lastConnectedThreadIdsByAgent.set(restoreKey, incomingThreadId);
 				await agent.detachActiveRun();
 				if (isFreshRestore) {
 					agent.setMessages([]);
 					agent.setState({});
-					const proxied = agent;
-					if (incomingThreadId && typeof proxied.clearReplayCursor === "function") proxied.clearReplayCursor(incomingThreadId);
+					const cursorAware = agent;
+					if (incomingThreadId) {
+						if (typeof cursorAware.clearReplayCursor === "function") cursorAware.clearReplayCursor(incomingThreadId);
+						if (typeof cursorAware.clearReconnectCursor === "function") cursorAware.clearReconnectCursor(incomingThreadId);
+					}
 				}
 				this._internal.applyHeadersToAgent(agent);
 				await this._internal.notifySubscribers((subscriber) => {
@@ -1868,7 +1915,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				}, this.createAgentErrorSubscriber(agent));
 				return this.processAgentResult({
 					runAgentResult,
-					agent
+					agent,
+					executeFrontendTools: false
 				});
 			} catch (error) {
 				const connectError = error instanceof Error ? error : new Error(String(error));
@@ -1890,7 +1938,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		/**
 		* Run an agent
 		*/
-		async runAgent({ agent, forwardedProps, resume }) {
+		async runAgent({ agent, forwardedProps, resume, runId }) {
 			if (agent.agentId) this._internal.suggestionEngine.clearSuggestions(agent.agentId);
 			this._internal.applyHeadersToAgent(agent);
 			if (agent.detachActiveRun) await agent.detachActiveRun();
@@ -1920,6 +1968,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 						...forwardedProps
 					},
 					...resume !== void 0 ? { resume } : {},
+					...runId !== void 0 ? { runId } : {},
 					tools: this.buildFrontendTools(agent.agentId),
 					context: this._internal.getContextForAgent(agent.agentId)
 				}, this.createAgentErrorSubscriber(agent));
@@ -1948,26 +1997,28 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		/**
 		* Process agent result and execute tools
 		*/
-		async processAgentResult({ runAgentResult, agent }) {
+		async processAgentResult({ runAgentResult, agent, executeFrontendTools = true }) {
 			var _this$_runAbortContro2;
 			const { newMessages } = runAgentResult;
 			const agentId = agent.agentId;
 			let needsFollowUp = false;
-			for (const message of newMessages) if (message.role === "assistant") {
-				for (const toolCall of message.toolCalls || []) if (newMessages.findIndex((m) => m.role === "tool" && m.toolCallId === toolCall.id) === -1) {
-					const tool = this.getTool({
-						toolName: toolCall.function.name,
-						agentId: agent.agentId
-					});
-					if (tool) {
-						if (await this.executeSpecificTool(tool, toolCall, message, agent, agentId)) needsFollowUp = true;
-					} else {
-						const wildcardTool = this.getTool({
-							toolName: "*",
+			if (executeFrontendTools) {
+				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 (wildcardTool) {
-							if (await this.executeWildcardTool(wildcardTool, toolCall, message, agent, agentId)) needsFollowUp = true;
+						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;
+							}
 						}
 					}
 				}
@@ -2603,6 +2654,129 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		}
 	};
 
+//#endregion
+//#region src/core/subagent-registry.ts
+/**
+	* Tracks subagent lifecycle events (SUBAGENT_STARTED / FINISHED / ERROR) per
+	* owning agent so consumers can resolve a message's `subagentId` to a name,
+	* description, and running status.
+	*
+	* Modeled on {@link SuggestionEngine}: an in-memory `Record` keyed by (owning)
+	* agentId, mutated from streamed AG-UI events, made reactive by calling
+	* `notifySubscribers(onSubagentsChanged)` after every change. It owns its own
+	* per-agent `agent.subscribe` (like {@link StateManager}) so it is fully
+	* self-contained and adds no coupling to the state/message tracking path.
+	*
+	* No-op for runs without subagents (a normal LangGraph run never emits
+	* SUBAGENT_* events), so the registry simply stays empty.
+	*/
+	var SubagentRegistry = class {
+		constructor(core) {
+			this.core = core;
+			_defineProperty(this, "_subagents", {});
+			_defineProperty(this, "agentSubscriptions", /* @__PURE__ */ new Map());
+		}
+		/**
+		* Subscribe to an agent's subagent lifecycle events. Idempotent per agentId:
+		* an existing subscription for the same agent is revoked and replaced.
+		*/
+		subscribeToAgent(agent) {
+			if (!agent.agentId) return;
+			const agentId = agent.agentId;
+			const existingUnsubscribe = this.agentSubscriptions.get(agentId);
+			if (existingUnsubscribe) {
+				existingUnsubscribe();
+				this.agentSubscriptions.delete(agentId);
+			}
+			let revoked = false;
+			const { unsubscribe } = agent.subscribe({
+				onSubagentStartedEvent: ({ event }) => {
+					if (revoked) return;
+					this.handleStarted(agentId, event);
+				},
+				onSubagentFinishedEvent: ({ event }) => {
+					if (revoked) return;
+					this.handleFinished(agentId, event);
+				},
+				onSubagentErrorEvent: ({ event }) => {
+					if (revoked) return;
+					this.handleError(agentId, event);
+				}
+			});
+			this.agentSubscriptions.set(agentId, () => {
+				revoked = true;
+				unsubscribe();
+			});
+		}
+		/**
+		* Unsubscribe an agent's subscription (symmetric with StateManager cleanup).
+		*/
+		unsubscribeFromAgent(agentId) {
+			const unsubscribe = this.agentSubscriptions.get(agentId);
+			if (unsubscribe) {
+				unsubscribe();
+				this.agentSubscriptions.delete(agentId);
+			}
+		}
+		/**
+		* Get the subagents observed for an owning agent, keyed by subagentId.
+		* Returns a fresh shallow copy each call so consumers (and React state) see
+		* a new reference when anything changed.
+		*/
+		getSubagents(agentId) {
+			return { ...this._subagents[agentId] };
+		}
+		handleStarted(agentId, event) {
+			var _this$_subagents, _this$_subagents$agen;
+			const bucket = (_this$_subagents$agen = (_this$_subagents = this._subagents)[agentId]) !== null && _this$_subagents$agen !== void 0 ? _this$_subagents$agen : _this$_subagents[agentId] = {};
+			bucket[event.subagentId] = {
+				subagentId: event.subagentId,
+				name: event.name,
+				description: event.description,
+				parentSubagentId: event.parentSubagentId,
+				status: "running"
+			};
+			this.notifySubagentsChanged(agentId);
+		}
+		handleFinished(agentId, event) {
+			const bucket = this._subagents[agentId];
+			const existing = bucket === null || bucket === void 0 ? void 0 : bucket[event.subagentId];
+			if (!bucket || !existing) return;
+			bucket[event.subagentId] = {
+				...existing,
+				status: "finished"
+			};
+			this.notifySubagentsChanged(agentId);
+		}
+		handleError(agentId, event) {
+			var _this$_subagents2, _this$_subagents2$age;
+			const bucket = (_this$_subagents2$age = (_this$_subagents2 = this._subagents)[agentId]) !== null && _this$_subagents2$age !== void 0 ? _this$_subagents2$age : _this$_subagents2[agentId] = {};
+			const existing = bucket[event.subagentId];
+			bucket[event.subagentId] = existing ? {
+				...existing,
+				status: "error",
+				error: event.message
+			} : {
+				subagentId: event.subagentId,
+				name: event.subagentId,
+				status: "error",
+				error: event.message
+			};
+			this.notifySubagentsChanged(agentId);
+		}
+		async notifySubagentsChanged(agentId) {
+			const subagents = this.getSubagents(agentId);
+			await this.core.notifySubscribers((subscriber) => {
+				var _subscriber$onSubagen;
+				return (_subscriber$onSubagen = subscriber.onSubagentsChanged) === null || _subscriber$onSubagen === void 0 ? void 0 : _subscriber$onSubagen.call(subscriber, {
+					copilotkit: this.core,
+					agentId,
+					subagents
+				});
+			}, "Subscriber onSubagentsChanged error:");
+		}
+	};
+
 //#endregion
 //#region src/core/thread-store-registry.ts
 	var ThreadStoreRegistry = class {
@@ -2665,206 +2839,1196 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	};
 
 //#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";
-		CopilotKitCoreErrorCode["SUBSCRIBER_CALLBACK_FAILED"] = "subscriber_callback_failed";
-		return CopilotKitCoreErrorCode;
-	}({});
+//#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 };
 	/**
-	* Runtime allowlist derived from {@link SUBSCRIBE_TO_AGENT_KEYS}. Hoisted
-	* to module scope so the Set is allocated once, not per-subscription.
+	* Builds a typed action creator from a type string and payload factory.
 	*/
-	const ALLOWED_KEYS = new Set([
-		"onMessagesChanged",
-		"onStateChanged",
-		"onRunInitialized",
-		"onRunFinalized",
-		"onRunFailed",
-		"onRunErrorEvent"
-	]);
-	let CopilotKitCoreRuntimeConnectionStatus = /* @__PURE__ */ function(CopilotKitCoreRuntimeConnectionStatus) {
-		CopilotKitCoreRuntimeConnectionStatus["Disconnected"] = "disconnected";
-		CopilotKitCoreRuntimeConnectionStatus["Connected"] = "connected";
-		CopilotKitCoreRuntimeConnectionStatus["Connecting"] = "connecting";
-		CopilotKitCoreRuntimeConnectionStatus["Error"] = "error";
-		return CopilotKitCoreRuntimeConnectionStatus;
-	}({});
+	function createTypedActionCreator(type, factory) {
+		const creator = ((...args) => ({
+			...factory(...args),
+			type
+		}));
+		creator.type = type;
+		creator.match = (action) => action.type === type;
+		return creator;
+	}
 	/**
-	* Normalize a header map to the internal invariant: a `Record<string, string>`
-	* with no `null`/`undefined` values. Entries whose value is `null`/`undefined`
-	* are dropped (this is how a header is cleared). Shared by the constructor and
-	* `setHeaders` so both write paths into `_headers` enforce the same invariant.
+	* Declares a payload-based action config for `createActionGroup`.
+	*
+	* @example
+	* ```ts
+	* const actions = createActionGroup("User", {
+	*   loaded: props<{ id: string }>(),
+	* });
+	* ```
 	*/
-	function normalizeHeaders(headers) {
-		return Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] != null));
+	function props() {
+		return { kind: "props" };
 	}
-	var CopilotKitCore = class {
-		constructor({ runtimeUrl, runtimeTransport = "auto", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
-			_defineProperty(this, "_headers", void 0);
-			_defineProperty(this, "_credentials", void 0);
-			_defineProperty(this, "_properties", void 0);
-			_defineProperty(this, "_defaultThrottleMs", void 0);
-			_defineProperty(this, "_debug", void 0);
-			_defineProperty(this, "subscribers", /* @__PURE__ */ new Set());
-			_defineProperty(this, "agentRegistry", void 0);
-			_defineProperty(this, "contextStore", void 0);
-			_defineProperty(this, "suggestionEngine", void 0);
-			_defineProperty(this, "runHandler", void 0);
-			_defineProperty(this, "stateManager", void 0);
-			_defineProperty(this, "threadStoreRegistry", void 0);
-			_defineProperty(this, "previousAgentIds", /* @__PURE__ */ new Set());
-			this._headers = normalizeHeaders(headers);
-			this._credentials = credentials;
-			this._properties = properties;
-			this._debug = debug;
-			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.threadStoreRegistry = new ThreadStoreRegistry(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.previousAgentIds = new Set(Object.keys(agents__unsafe_dev_only));
-			this.subscribe({ onAgentsChanged: ({ agents }) => {
-				Object.values(agents).forEach((agent) => {
-					if (agent.agentId) this.stateManager.subscribeToAgent(agent);
-				});
-				const currentAgentIds = new Set(Object.keys(agents));
-				for (const agentId of Object.keys(this.threadStoreRegistry.getAll())) if (this.previousAgentIds.has(agentId) && !currentAgentIds.has(agentId)) try {
-					this.threadStoreRegistry.unregister(agentId);
-				} catch (err) {
-					console.error(`CopilotKitCore.onAgentsChanged: threadStoreRegistry.unregister failed for "${agentId}":`, err);
-				}
-				for (const agentId of this.previousAgentIds) if (!currentAgentIds.has(agentId)) try {
-					this.stateManager.unsubscribeFromAgent(agentId);
-				} catch (err) {
-					console.error(`CopilotKitCore.onAgentsChanged: stateManager.unsubscribeFromAgent failed for "${agentId}":`, err);
-				}
-				this.previousAgentIds = currentAgentIds;
-			} });
-		}
-		/**
-		* Internal method used by delegate classes and subclasses to notify subscribers
-		*/
-		async notifySubscribers(handler, errorMessage) {
-			await Promise.all(Array.from(this.subscribers).map(async (subscriber) => {
-				try {
-					await handler(subscriber);
-				} catch (error) {
-					console.error(errorMessage, error);
-				}
-			}));
-		}
-		/**
-		* Internal method used by delegate classes to emit errors
-		*/
-		async emitError({ error, code, context = {} }) {
-			await this.notifySubscribers((subscriber) => {
-				var _subscriber$onError;
-				return (_subscriber$onError = subscriber.onError) === null || _subscriber$onError === void 0 ? void 0 : _subscriber$onError.call(subscriber, {
-					copilotkit: this,
-					error,
-					code,
-					context
-				});
-			}, "Subscriber onError error:");
+	/**
+	* 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, () => ({}));
 		}
-		/**
-		* Log a message to the console and emit an error to subscribers.
-		* Catches failures from `emitError` itself to prevent unhandled rejections.
-		*/
-		logAndEmitError(message, params, logLevel = "error") {
-			console[logLevel](message, params.error);
-			this.emitError(params).catch((emitErr) => {
-				console.error(message + " — emitError itself failed:", emitErr);
-			});
-		}
-		/**
-		* 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;
+		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);
 		}
-		get credentials() {
-			return this._credentials;
+		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;
+			};
 		}
-		get properties() {
-			return this._properties;
+		const projector = args[args.length - 1];
+		const selectors = args.slice(0, -1);
+		let hasCached = false;
+		let lastInputs = [];
+		let lastResult;
+		return (state) => {
+			const inputs = selectors.map((selector) => selector(state));
+			if (hasCached && inputs.length === lastInputs.length && inputs.every((value, index) => value === lastInputs[index])) return lastResult;
+			lastInputs = inputs;
+			lastResult = projector(...inputs);
+			hasCached = true;
+			return lastResult;
+		};
+	}
+	/**
+	* RxJS operator that maps state emissions through a selector and suppresses
+	* unchanged projected values via reference equality.
+	*/
+	function select(selector) {
+		return (source$) => source$.pipe((0, rxjs_operators.map)(selector), (0, rxjs_operators.distinctUntilChanged)());
+	}
+	/**
+	* RxJS operator that filters an action stream by action creators and narrows
+	* the output action type to the matched creator union.
+	*
+	* @throws Error when called without at least one action creator.
+	*/
+	function ofType(...creators) {
+		if (creators.length === 0) throw new Error("ofType requires at least one action creator");
+		const actionTypes = new Set(creators.map((creator) => creator.type));
+		return (source$) => {
+			return source$.pipe((0, rxjs_operators.filter)((action) => {
+				return actionTypes.has(action.type);
+			}));
+		};
+	}
+	/**
+	* Creates an effect descriptor consumed by `createStore`.
+	*/
+	function createEffect(factory, options = {}) {
+		if (options.dispatch === false) return {
+			run: factory,
+			dispatch: false
+		};
+		return {
+			run: factory,
+			dispatch: true
+		};
+	}
+	/**
+	* Creates a small observable store with reducer + effects.
+	*
+	* Behavior:
+	* - `init()` starts effects and dispatches `@@micro-redux/init`.
+	* - `stop()` dispatches `@@micro-redux/stop` and unsubscribes all effects.
+	* - Effect action observation is scheduled on `asapScheduler` to avoid
+	*   synchronous re-entrancy in the effect loop.
+	* - Any effect error triggers fail-fast teardown and errors both `actions$`
+	*   and `state$`.
+	*/
+	function createStore(options) {
+		var _options$effects;
+		const reducer = options.reducer;
+		const effects = (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : [];
+		let hasFatalError = false;
+		let isRunning = false;
+		let effectSubscriptions = new rxjs.Subscription();
+		let currentState = reducer(void 0, INTERNAL_BOOT_ACTION);
+		const stateSubject = new rxjs.BehaviorSubject(currentState);
+		const actionsSubject = new rxjs.Subject();
+		const dispatchInternal = (action) => {
+			if (hasFatalError) throw new Error("Store is in a failed state due to an effect error");
+			currentState = reducer(currentState, action);
+			stateSubject.next(currentState);
+			actionsSubject.next(action);
+		};
+		const failFast = (error) => {
+			if (hasFatalError) return;
+			hasFatalError = true;
+			isRunning = false;
+			effectSubscriptions.unsubscribe();
+			effectSubscriptions = new rxjs.Subscription();
+			actionsSubject.error(error);
+			stateSubject.error(error);
+		};
+		const startEffects = () => {
+			for (const effect of effects) {
+				const scheduledActions$ = actionsSubject.asObservable().pipe((0, rxjs_operators.observeOn)(rxjs.asapScheduler));
+				const state$ = stateSubject.asObservable();
+				if (effect.dispatch) {
+					const subscription = effect.run(scheduledActions$, state$).subscribe({
+						next: (effectAction) => {
+							if (hasFatalError) return;
+							dispatchInternal(effectAction);
+						},
+						error: (error) => {
+							failFast(error);
+						}
+					});
+					effectSubscriptions.add(subscription);
+					continue;
+				}
+				const subscription = effect.run(scheduledActions$, state$).subscribe({ error: (error) => {
+					failFast(error);
+				} });
+				effectSubscriptions.add(subscription);
+			}
+		};
+		return {
+			dispatch(action) {
+				dispatchInternal(action);
+			},
+			getState() {
+				return currentState;
+			},
+			get state$() {
+				return stateSubject.asObservable();
+			},
+			get actions$() {
+				return actionsSubject.asObservable();
+			},
+			select(selector) {
+				return stateSubject.asObservable().pipe(select(selector));
+			},
+			init() {
+				if (hasFatalError || isRunning) return;
+				isRunning = true;
+				startEffects();
+				if (hasFatalError) return;
+				dispatchInternal({ type: INTERNAL_ACTION_TYPES.init });
+			},
+			stop() {
+				if (hasFatalError || !isRunning) return;
+				dispatchInternal({ type: INTERNAL_ACTION_TYPES.stop });
+				effectSubscriptions.unsubscribe();
+				effectSubscriptions = new rxjs.Subscription();
+				isRunning = false;
+			}
+		};
+	}
+
+//#endregion
+//#region src/memory-errors.ts
+/**
+	* The memory error registry: the single source of truth for memory error
+	* metadata. Keyed by `code` so a code maps to exactly one category/retryable
+	* default.
+	*
+	* Categories/retryable rationale:
+	* - List/credentials/mutation failures are `dependency` (the runtime/platform
+	*   the store calls failed). A 5xx is transient (`retryable: true`); a 4xx is
+	*   caller-caused, so the helpers below downgrade those to non-retryable.
+	* - Timeouts are `dependency` and `retryable: true` (the request may simply be
+	*   slow).
+	*/
+	const MEMORY_ERROR_REGISTRY = Object.freeze({
+		MEMORY_LIST_FAILED: {
+			code: "MEMORY_LIST_FAILED",
+			category: "dependency",
+			retryable: true,
+			message: "Failed to fetch memories",
+			docsPath: "docs/errors/memory.md#memory_list_failed"
+		},
+		MEMORY_CREDENTIALS_FAILED: {
+			code: "MEMORY_CREDENTIALS_FAILED",
+			category: "dependency",
+			retryable: true,
+			message: "Failed to fetch memory subscribe credentials",
+			docsPath: "docs/errors/memory.md#memory_credentials_failed"
+		},
+		MEMORY_MUTATION_FAILED: {
+			code: "MEMORY_MUTATION_FAILED",
+			category: "dependency",
+			retryable: true,
+			message: "Memory mutation request failed",
+			docsPath: "docs/errors/memory.md#memory_mutation_failed"
+		},
+		MEMORY_REQUEST_TIMEOUT: {
+			code: "MEMORY_REQUEST_TIMEOUT",
+			category: "dependency",
+			retryable: true,
+			message: "Request timed out",
+			docsPath: "docs/errors/memory.md#memory_request_timeout"
 		}
+	});
+	/**
+	* An `Error` carrying a stable memory error `code`, `category`, and `retryable`
+	* flag so consumers and observability can branch on it without string-matching
+	* the message.
+	*
+	* It is a real `Error` subclass: `instanceof Error` is true, so the public
+	* `MemoryState.error: Error | null` contract (and the `error: Error | null`
+	* surfaced by `useMemories` / `injectMemories`) holds unchanged. Existing
+	* consumers that only read `.message` keep working; the richer fields are
+	* additive.
+	*/
+	var MemoryError = class MemoryError extends Error {
 		/**
-		* Default throttle interval (ms) used by `subscribeToAgentWithOptions()`
-		* when the caller does not specify an explicit `throttleMs`.
-		* `undefined` means no default is configured; `0` means no throttling.
+		* @param code - Registry code identifying this error.
+		* @param options - Optional overrides:
+		*   - `message`: human-readable message (defaults to the registry message;
+		*     callers pass a status-bearing string to preserve prior wording).
+		*   - `retryable`: overrides the registry default (e.g. a 4xx list failure is
+		*     not retryable even though the code's default is).
+		*   - `cause`: the underlying error, preserved for debugging.
 		*/
-		get defaultThrottleMs() {
-			return this._defaultThrottleMs;
+		constructor(code, options) {
+			var _options$message, _options$retryable;
+			const entry = MEMORY_ERROR_REGISTRY[code];
+			super((_options$message = options === null || options === void 0 ? void 0 : options.message) !== null && _options$message !== void 0 ? _options$message : entry.message, { cause: options === null || options === void 0 ? void 0 : options.cause });
+			_defineProperty(this, "code", void 0);
+			_defineProperty(this, "category", void 0);
+			_defineProperty(this, "retryable", void 0);
+			this.name = "MemoryError";
+			this.code = code;
+			this.category = entry.category;
+			this.retryable = (_options$retryable = options === null || options === void 0 ? void 0 : options.retryable) !== null && _options$retryable !== void 0 ? _options$retryable : entry.retryable;
+			Object.setPrototypeOf(this, MemoryError.prototype);
 		}
-		/**
-		* Set the default throttle interval (ms) for `subscribeToAgentWithOptions()`.
-		*
-		* Accepts a non-negative finite number or `undefined` (to clear the
-		* default). Invalid values (NaN, Infinity, negative) are logged as
-		* errors and ignored — the previous valid value is preserved.
+	};
+	/**
+	* Narrows an HTTP status to whether the failure is worth retrying: a 5xx (or a
+	* missing/0 status) is a transient dependency failure and retryable; a 4xx is
+	* caller-caused and not. Used so a `MEMORY_LIST_FAILED`/`MEMORY_MUTATION_FAILED`
+	* carries an accurate `retryable` flag derived from the response status.
+	*/
+	function isRetryableStatus(status) {
+		return !(Number.isInteger(status) && status >= 400 && status <= 499);
+	}
+
+//#endregion
+//#region src/memory.ts
+	const MEMORIES_PATH = "/memories";
+	const MEMORIES_SUBSCRIBE_PATH = "/memories/subscribe";
+	const REQUEST_TIMEOUT_MS$1 = 15e3;
+	/** Consecutive socket errors tolerated before the realtime stream gives up. */
+	const MAX_SOCKET_RETRIES$1 = 5;
+	/**
+	* HTTP status codes that indicate memory routes are not configured (non-fatal).
+	* 404/501 mean the route is absent/unimplemented; 422 is the runtime's
+	* MISSING_INTELLIGENCE signal (intelligence not configured on the deployment —
+	* see packages/runtime/.../handlers/intelligence/memories.ts). All three map to
+	* the graceful "not available" locked-teaser path, not a hard error.
+	*/
+	const ROUTE_UNAVAILABLE_STATUSES = new Set([
+		404,
+		422,
+		501
+	]);
+	/**
+	* Thrown when a memory route returns a 404/422/501 — treated as "not
+	* configured" (422 is the runtime's MISSING_INTELLIGENCE signal).
+	*/
+	var MemoryRouteUnavailableError = class extends Error {};
+	const initialMemoryState = Object.freeze({
+		memories: Object.freeze([]),
+		isLoading: false,
+		inFlightMutationCount: 0,
+		error: null,
+		context: null,
+		sessionId: 0,
+		available: true,
+		realtimeStatus: "connecting"
+	});
+	const memoryAdapterEvents = createActionGroup("Memory Adapter", {
+		started: empty(),
+		stopped: empty(),
+		contextChanged: props(),
+		addRequested: props(),
+		updateRequested: props(),
+		removeRequested: props()
+	});
+	const memoryRestEvents = createActionGroup("Memory REST", {
+		listRequested: props(),
+		listSucceeded: props(),
+		listFailed: props(),
+		listUnavailable: props(),
+		mutationFinished: props(),
+		credentialsRequested: props(),
+		credentialsSucceeded: props(),
+		credentialsFailed: props(),
+		credentialsUnavailable: props()
+	});
+	const memoryDomainEvents = createActionGroup("Memory Domain", {
+		memoryUpserted: props(),
+		memoryInvalidated: props(),
+		realtimeConnecting: props(),
+		realtimeConnected: props(),
+		realtimeUnavailable: props()
+	});
+	/** Projects a wire memory to the public {@link Memory} shape (drops tenant ids). */
+	function toMemory(memory) {
+		return {
+			id: memory.id,
+			kind: memory.kind,
+			scope: memory.scope,
+			content: memory.content,
+			sourceThreadIds: memory.sourceThreadIds,
+			invalidatedAt: memory.invalidatedAt
+		};
+	}
+	/**
+	* Maps a realtime `memory_metadata` event to the domain action that applies it:
+	* `created`/`updated` upsert the projected memory, `invalidated` removes it by
+	* id. Carries the current `sessionId` so the reducer's session guard can drop
+	* deltas left over from a previous context.
+	*/
+	function mapMemoryMetadataEvent(event, sessionId) {
+		if (event.operation === "invalidated") return memoryDomainEvents.memoryInvalidated({
+			sessionId,
+			memoryId: event.invalidated.id
+		});
+		return memoryDomainEvents.memoryUpserted({
+			sessionId,
+			memory: toMemory(event.memory)
+		});
+	}
+	/**
+	* Inserts or replaces a memory by id. A new memory is prepended (newest first,
+	* matching the REST list's `created_at DESC` ordering without needing a date
+	* field on the public projection); an existing memory is replaced in place.
+	*/
+	function upsertMemory(memories, memory) {
+		const existingIndex = memories.findIndex((item) => item.id === memory.id);
+		if (existingIndex === -1) return [memory, ...memories];
+		const next = [...memories];
+		next[existingIndex] = memory;
+		return next;
+	}
+	const memoryReducer = createReducer(initialMemoryState, on(memoryAdapterEvents.contextChanged, (state, { context }) => ({
+		...state,
+		context,
+		sessionId: state.sessionId + 1,
+		memories: [],
+		isLoading: Boolean(context),
+		inFlightMutationCount: 0,
+		error: null,
+		available: true,
+		realtimeStatus: "connecting"
+	})), on(memoryAdapterEvents.stopped, (state) => ({
+		...state,
+		memories: [],
+		isLoading: false,
+		inFlightMutationCount: 0,
+		error: null,
+		available: true,
+		realtimeStatus: "connecting"
+	})), on(memoryRestEvents.listRequested, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId || !state.context) return state;
+		return {
+			...state,
+			isLoading: true,
+			error: null,
+			available: true
+		};
+	}), on(memoryRestEvents.listFailed, (state, { sessionId, error }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			isLoading: false,
+			error
+		};
+	}), on(memoryRestEvents.listUnavailable, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			memories: [],
+			isLoading: false,
+			error: null,
+			available: false
+		};
+	}), on(memoryAdapterEvents.addRequested, memoryAdapterEvents.updateRequested, memoryAdapterEvents.removeRequested, (state) => ({
+		...state,
+		inFlightMutationCount: state.inFlightMutationCount + 1
+	})), on(memoryRestEvents.mutationFinished, (state, { outcome }) => {
+		if (outcome.sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			inFlightMutationCount: Math.max(0, state.inFlightMutationCount - 1),
+			error: outcome.ok ? null : outcome.error
+		};
+	}), on(memoryRestEvents.listSucceeded, (state, { sessionId, memories }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			memories,
+			isLoading: false,
+			error: null,
+			available: true
+		};
+	}), on(memoryDomainEvents.memoryUpserted, (state, { sessionId, memory }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			memories: upsertMemory(state.memories, memory)
+		};
+	}), on(memoryDomainEvents.memoryInvalidated, (state, { sessionId, memoryId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			memories: state.memories.filter((memory) => memory.id !== memoryId)
+		};
+	}), on(memoryDomainEvents.realtimeConnecting, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			realtimeStatus: "connecting"
+		};
+	}), on(memoryDomainEvents.realtimeConnected, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			realtimeStatus: "connected"
+		};
+	}), on(memoryDomainEvents.realtimeUnavailable, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			realtimeStatus: "unavailable"
+		};
+	}));
+	const selectMemories = createSelector((state) => state.memories);
+	const selectMemoriesIsLoading = createSelector((state) => state.isLoading);
+	const selectMemoriesError = createSelector((state) => state.error);
+	/**
+	* Reports whether at least one mutation is in flight. Derived from
+	* `inFlightMutationCount` so concurrent mutations stay correct: the boolean
+	* only clears once every in-flight mutation has settled.
+	*/
+	const selectMemoriesIsMutating = createSelector((state) => state.inFlightMutationCount > 0);
+	/**
+	* Reports whether the memory routes are available. Becomes `false` after a
+	* 404, 422 (the runtime's MISSING_INTELLIGENCE signal), or 501 response during
+	* an auto-activation read; defaults to `true`.
+	*/
+	const selectMemoriesAvailable = createSelector((state) => state.available);
+	/**
+	* Reports the realtime-connection health (see {@link MemoryRealtimeStatus}).
+	* Distinct from `available`/`error`: it reflects ONLY the live socket/channel,
+	* so the UI can suppress a "live" indicator once realtime permanently dies even
+	* while the REST list route stays healthy. Defaults to `"connecting"`.
+	*/
+	const selectMemoriesRealtimeStatus = createSelector((state) => state.realtimeStatus);
+	const MEMORY_METADATA_EVENT = "memory_metadata";
+	function memoryFromFetch(input, init) {
+		return (0, rxjs_fetch.fromFetch)(input, init);
+	}
+	/**
+	* Fetches the memory snapshot and maps it to a success/failure action. Keeps
+	* only user-scoped memories (v1 surfaces user scope only; the realtime stream
+	* is user-scoped too), so project-scoped rows visible to the caller are
+	* dropped from the store.
+	*/
+	function createMemoryFetchObservable(environment, context, sessionId) {
+		return (0, rxjs.defer)(() => {
+			const qs = context.includeInvalidated ? "?includeInvalidated=true" : "";
+			return memoryFromFetch(`${context.runtimeUrl}${MEMORIES_PATH}${qs}`, {
+				selector: (response) => {
+					if (!response.ok) {
+						if (ROUTE_UNAVAILABLE_STATUSES.has(response.status)) throw new MemoryRouteUnavailableError(String(response.status));
+						throw new MemoryError("MEMORY_LIST_FAILED", {
+							message: `Failed to fetch memories: ${response.status}`,
+							retryable: isRetryableStatus(response.status)
+						});
+					}
+					return response.json();
+				},
+				fetch: environment.fetch,
+				method: "GET",
+				headers: { ...context.headers }
+			}).pipe((0, rxjs_operators.timeout)({
+				first: REQUEST_TIMEOUT_MS$1,
+				with: () => {
+					throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+				}
+			}), (0, rxjs_operators.map)((data) => memoryRestEvents.listSucceeded({
+				sessionId,
+				memories: data.memories.filter((memory) => memory.scope === "user")
+			})), (0, rxjs_operators.catchError)((error) => {
+				if (error instanceof MemoryRouteUnavailableError) return (0, rxjs.of)(memoryRestEvents.listUnavailable({ sessionId }));
+				return (0, rxjs.of)(memoryRestEvents.listFailed({
+					sessionId,
+					error: error instanceof Error ? error : new Error(String(error))
+				}));
+			}));
+		});
+	}
+	/**
+	* Fetches join credentials from the `/memories/subscribe` endpoint and maps
+	* the response to a success/failure action. Requires both `joinToken` and
+	* `joinCode` to be non-empty strings; throws otherwise so the `catchError`
+	* path emits `credentialsFailed`.
+	*/
+	function createMemoryCredentialsFetchObservable(environment, context, sessionId) {
+		return (0, rxjs.defer)(() => memoryFromFetch(`${context.runtimeUrl}${MEMORIES_SUBSCRIBE_PATH}`, {
+			selector: async (response) => {
+				if (!response.ok) {
+					if (ROUTE_UNAVAILABLE_STATUSES.has(response.status)) throw new MemoryRouteUnavailableError(String(response.status));
+					throw new MemoryError("MEMORY_CREDENTIALS_FAILED", {
+						message: `Failed to fetch memory subscribe credentials: ${response.status}`,
+						retryable: isRetryableStatus(response.status)
+					});
+				}
+				return response.json();
+			},
+			fetch: environment.fetch,
+			method: "POST",
+			headers: {
+				...context.headers,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({})
+		}).pipe((0, rxjs_operators.timeout)({
+			first: REQUEST_TIMEOUT_MS$1,
+			with: () => {
+				throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+			}
+		}), (0, rxjs_operators.map)((data) => {
+			if (typeof data.joinToken !== "string" || data.joinToken.length === 0) throw new Error("missing joinToken");
+			if (typeof data.joinCode !== "string" || data.joinCode.length === 0) throw new Error("missing joinCode");
+			return memoryRestEvents.credentialsSucceeded({
+				sessionId,
+				joinToken: data.joinToken,
+				joinCode: data.joinCode
+			});
+		}), (0, rxjs_operators.catchError)((error) => {
+			if (error instanceof MemoryRouteUnavailableError) return (0, rxjs.of)(memoryRestEvents.credentialsUnavailable({ sessionId }));
+			return (0, rxjs.of)(memoryRestEvents.credentialsFailed({
+				sessionId,
+				error: error instanceof Error ? error : new Error(String(error))
+			}));
+		})));
+	}
+	/** Projects a REST mutation response to the public {@link Memory} shape. */
+	function responseToMemory(data) {
+		return {
+			id: data.id,
+			kind: data.kind,
+			scope: data.scope,
+			content: data.content,
+			sourceThreadIds: data.sourceThreadIds,
+			invalidatedAt: data.invalidatedAt
+		};
+	}
+	const MEMORY_KINDS = new Set([
+		"topical",
+		"episodic",
+		"operational"
+	]);
+	const MEMORY_SCOPES = new Set(["user", "project"]);
+	/**
+	* Validates the required fields of a create/supersede REST response before it is
+	* projected to a {@link Memory}. Returns an `Error` describing the first
+	* missing/invalid field, or `null` when the body is well-formed. Without this a
+	* malformed 200 body yields a Memory with undefined fields that gets upserted.
+	*/
+	function validateMutationResponse(data) {
+		if (!data || typeof data !== "object") return /* @__PURE__ */ new Error("memory mutation response missing/invalid body");
+		if (typeof data.id !== "string" || data.id.length === 0) return /* @__PURE__ */ new Error("memory mutation response missing/invalid id");
+		if (typeof data.kind !== "string" || !MEMORY_KINDS.has(data.kind)) return /* @__PURE__ */ new Error("memory mutation response missing/invalid kind");
+		if (typeof data.scope !== "string" || !MEMORY_SCOPES.has(data.scope)) return /* @__PURE__ */ new Error("memory mutation response missing/invalid scope");
+		if (typeof data.content !== "string") return /* @__PURE__ */ new Error("memory mutation response missing/invalid content");
+		if (!Array.isArray(data.sourceThreadIds) || !data.sourceThreadIds.every((id) => typeof id === "string")) return /* @__PURE__ */ new Error("memory mutation response missing/invalid sourceThreadIds");
+		if (data.invalidatedAt !== null && typeof data.invalidatedAt !== "string") return /* @__PURE__ */ new Error("memory mutation response missing/invalid invalidatedAt");
+		return null;
+	}
+	/**
+	* Request body for create/supersede. `scope` is forwarded only when the caller
+	* supplies it: the platform owns the default (`scope` defaults to `"user"` in
+	* the `/api/memories` schema), so the store does not second-guess it here —
+	* one default, at the contract owner. `sourceThreadIds` defaults to `[]`.
+	*/
+	function toMutationBody(input) {
+		var _input$sourceThreadId;
+		return {
+			content: input.content,
+			kind: input.kind,
+			...input.scope !== void 0 ? { scope: input.scope } : {},
+			sourceThreadIds: (_input$sourceThreadId = input.sourceThreadIds) !== null && _input$sourceThreadId !== void 0 ? _input$sourceThreadId : []
+		};
+	}
+	/**
+	* Builds the actions a successful mutation dispatches (server-authoritative):
+	* the REST response is applied to local state immediately, and the realtime
+	* event reconciles idempotently (upsert-by-id). `mutationFinished` resolves the
+	* caller's promise.
+	*/
+	function buildMutationSuccessActions(request, data) {
+		const { requestId, sessionId } = request;
+		if (request.kind === "remove") return [memoryDomainEvents.memoryInvalidated({
+			sessionId,
+			memoryId: request.id
+		}), memoryRestEvents.mutationFinished({ outcome: {
+			requestId,
+			sessionId,
+			ok: true,
+			memory: null
+		} })];
+		const validationError = validateMutationResponse(data);
+		if (validationError) return [memoryRestEvents.mutationFinished({ outcome: {
+			requestId,
+			sessionId,
+			ok: false,
+			error: validationError
+		} })];
+		const memory = responseToMemory(data);
+		if (request.kind === "update") {
+			const retiredId = data.retiredId;
+			if (typeof retiredId !== "string" || retiredId.length === 0) return [memoryRestEvents.mutationFinished({ outcome: {
+				requestId,
+				sessionId,
+				ok: false,
+				error: /* @__PURE__ */ new Error("supersede response missing retiredId")
+			} })];
+			return [
+				memoryDomainEvents.memoryInvalidated({
+					sessionId,
+					memoryId: retiredId
+				}),
+				memoryDomainEvents.memoryUpserted({
+					sessionId,
+					memory
+				}),
+				memoryRestEvents.mutationFinished({ outcome: {
+					requestId,
+					sessionId,
+					ok: true,
+					memory
+				} })
+			];
+		}
+		return [memoryDomainEvents.memoryUpserted({
+			sessionId,
+			memory
+		}), memoryRestEvents.mutationFinished({ outcome: {
+			requestId,
+			sessionId,
+			ok: true,
+			memory
+		} })];
+	}
+	/** Performs a create/supersede/retire HTTP call and emits its resulting actions. */
+	function createMemoryMutationObservable(environment, context, request) {
+		const method = request.kind === "add" ? "POST" : request.kind === "update" ? "PATCH" : "DELETE";
+		const path = request.kind === "add" ? MEMORIES_PATH : `${MEMORIES_PATH}/${encodeURIComponent(request.id)}`;
+		return (0, rxjs.defer)(() => memoryFromFetch(`${context.runtimeUrl}${path}`, {
+			selector: async (response) => {
+				if (!response.ok) throw new MemoryError("MEMORY_MUTATION_FAILED", {
+					message: `Request failed: ${response.status}`,
+					retryable: isRetryableStatus(response.status)
+				});
+				return request.kind === "remove" ? null : await response.json();
+			},
+			fetch: environment.fetch,
+			method,
+			headers: {
+				...context.headers,
+				"Content-Type": "application/json"
+			},
+			body: request.kind === "remove" ? void 0 : JSON.stringify(request.body)
+		}).pipe((0, rxjs_operators.timeout)({
+			first: REQUEST_TIMEOUT_MS$1,
+			with: () => {
+				throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+			}
+		}), (0, rxjs_operators.mergeMap)((data) => (0, rxjs.of)(...buildMutationSuccessActions(request, data))), (0, rxjs_operators.catchError)((error) => (0, rxjs.of)(memoryRestEvents.mutationFinished({ outcome: {
+			requestId: request.requestId,
+			sessionId: request.sessionId,
+			ok: false,
+			error: error instanceof Error ? error : new Error(String(error))
+		} })))));
+	}
+	/**
+	* Creates the framework-agnostic memory store: a REST snapshot on `setContext`,
+	* server-authoritative add/update/remove mutations, and realtime
+	* `memory_metadata` deltas off the injected `user_meta` event source — all
+	* reduced into observable state.
+	*/
+	function createMemoryStore(environment) {
+		let memoryRequestId = 0;
+		const createMemoryRequestId = () => {
+			memoryRequestId += 1;
+			return `memory-request-${memoryRequestId}`;
+		};
+		const bootstrapEffect = createEffect((actions$, state$) => actions$.pipe(ofType(memoryAdapterEvents.contextChanged), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([, state]) => Boolean(state.context)), (0, rxjs_operators.map)(([, state]) => memoryRestEvents.listRequested({ sessionId: state.sessionId }))));
+		const credentialsBootstrapEffect = createEffect((actions$, state$) => actions$.pipe(ofType(memoryAdapterEvents.contextChanged), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([, state]) => Boolean(state.context)), (0, rxjs_operators.map)(([, state]) => memoryRestEvents.credentialsRequested({ sessionId: state.sessionId }))));
+		const credentialsFetchEffect = createEffect((actions$, state$) => actions$.pipe(ofType(memoryRestEvents.credentialsRequested), (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(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped))), (0, rxjs_operators.switchMap)(({ action: currentAction, context }) => createMemoryCredentialsFetchObservable(environment, context, currentAction.sessionId))))));
+		const store = createStore({
+			reducer: memoryReducer,
+			effects: [
+				bootstrapEffect,
+				credentialsBootstrapEffect,
+				createEffect((actions$, state$) => actions$.pipe(ofType(memoryRestEvents.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(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped))), (0, rxjs_operators.switchMap)(({ action: currentAction, context }) => createMemoryFetchObservable(environment, context, currentAction.sessionId)))))),
+				credentialsFetchEffect,
+				createEffect((actions$, state$) => actions$.pipe(ofType(memoryAdapterEvents.addRequested, memoryAdapterEvents.updateRequested, memoryAdapterEvents.removeRequested), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.mergeMap)(([action, state]) => {
+					const context = state.context;
+					const sessionId = state.sessionId;
+					if (!(context === null || context === void 0 ? void 0 : context.runtimeUrl)) return (0, rxjs.of)(memoryRestEvents.mutationFinished({ outcome: {
+						requestId: action.requestId,
+						sessionId,
+						ok: false,
+						error: /* @__PURE__ */ new Error("Runtime URL is not configured")
+					} }));
+					if (memoryAdapterEvents.addRequested.match(action)) return createMemoryMutationObservable(environment, context, {
+						requestId: action.requestId,
+						sessionId,
+						kind: "add",
+						body: toMutationBody(action.input)
+					});
+					if (memoryAdapterEvents.updateRequested.match(action)) return createMemoryMutationObservable(environment, context, {
+						requestId: action.requestId,
+						sessionId,
+						kind: "update",
+						id: action.id,
+						body: toMutationBody(action.changes)
+					});
+					return createMemoryMutationObservable(environment, context, {
+						requestId: action.requestId,
+						sessionId,
+						kind: "remove",
+						id: action.id
+					});
+				}))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(memoryRestEvents.credentialsSucceeded), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([action, state]) => {
+					var _state$context;
+					return action.sessionId === state.sessionId && Boolean((_state$context = state.context) === null || _state$context === void 0 ? void 0 : _state$context.wsUrl);
+				}), (0, rxjs_operators.switchMap)(([action, state]) => {
+					const context = state.context;
+					const { joinToken, joinCode } = action;
+					const sessionId = action.sessionId;
+					const shutdown$ = actions$.pipe(ofType(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped));
+					return (0, rxjs.defer)(() => {
+						const socket$ = ɵphoenixSocket$({
+							url: context.wsUrl,
+							options: {
+								params: { join_token: joinToken },
+								reconnectAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(100, 1e4),
+								rejoinAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(1e3, 3e4)
+							}
+						}).pipe((0, rxjs_operators.shareReplay)({
+							bufferSize: 1,
+							refCount: true
+						}));
+						const channel$ = ɵphoenixChannel$({
+							socket$,
+							topic: `user_meta:memories:${joinCode}`
+						}).pipe((0, rxjs_operators.shareReplay)({
+							bufferSize: 1,
+							refCount: true
+						}));
+						const fatalSocketShutdown$ = ɵobservePhoenixSocketHealth$(ɵobservePhoenixSocketSignals$(socket$).pipe((0, rxjs_operators.share)()), MAX_SOCKET_RETRIES$1).pipe((0, rxjs_operators.catchError)(() => {
+							console.warn(`[memory] WebSocket failed after ${MAX_SOCKET_RETRIES$1} attempts, giving up`);
+							return (0, rxjs.of)(void 0);
+						}), (0, rxjs_operators.share)());
+						const fatalStatus$ = fatalSocketShutdown$.pipe((0, rxjs_operators.map)(() => memoryDomainEvents.realtimeUnavailable({ sessionId })));
+						const metadata$ = channel$.pipe((0, rxjs_operators.switchMap)(({ channel }) => ɵobservePhoenixEvent$(channel, MEMORY_METADATA_EVENT)), (0, rxjs_operators.map)((event) => mapMemoryMetadataEvent(event, action.sessionId)));
+						const join$ = ɵjoinPhoenixChannel$(channel$).pipe((0, rxjs_operators.concatWith)((0, rxjs.of)(memoryDomainEvents.realtimeConnected({ sessionId }))), (0, rxjs_operators.catchError)((error) => {
+							console.warn(`[memory] failed to join user_meta:memories:${joinCode}`, error);
+							return (0, rxjs.of)(memoryDomainEvents.realtimeUnavailable({ sessionId }));
+						}));
+						return (0, rxjs.merge)((0, rxjs.of)(memoryDomainEvents.realtimeConnecting({ sessionId })), metadata$, join$, fatalStatus$).pipe((0, rxjs_operators.takeUntil)((0, rxjs.merge)(shutdown$, fatalSocketShutdown$.pipe((0, rxjs.observeOn)(rxjs.asapScheduler)))), (0, rxjs_operators.finalize)(() => {}));
+					});
+				})))
+			]
+		});
+		function trackMutation(dispatchAction, extract) {
+			const { requestId } = dispatchAction;
+			const resultPromise = (0, rxjs.firstValueFrom)((0, rxjs.merge)(store.actions$.pipe(ofType(memoryRestEvents.mutationFinished), (0, rxjs_operators.filter)((action) => action.outcome.requestId === requestId), (0, rxjs_operators.map)((action) => action.outcome)), store.actions$.pipe(ofType(memoryAdapterEvents.stopped), (0, rxjs_operators.map)(() => ({
+				requestId,
+				sessionId: store.getState().sessionId,
+				ok: false,
+				error: /* @__PURE__ */ new Error("Memory store stopped before mutation completed")
+			})))).pipe((0, rxjs_operators.take)(1))).then((outcome) => {
+				if (!outcome.ok) throw outcome.error;
+				return extract(outcome);
+			});
+			store.dispatch(dispatchAction);
+			return resultPromise;
+		}
+		return {
+			start() {
+				store.init();
+				store.dispatch(memoryAdapterEvents.started());
+			},
+			stop() {
+				store.dispatch(memoryAdapterEvents.stopped());
+				store.stop();
+			},
+			setContext(context) {
+				store.dispatch(memoryAdapterEvents.contextChanged({ context }));
+			},
+			refresh() {
+				const { sessionId, context } = store.getState();
+				if (!context) return Promise.resolve();
+				const done = (0, rxjs.firstValueFrom)((0, rxjs.merge)(store.actions$.pipe(ofType(memoryRestEvents.listSucceeded, memoryRestEvents.listFailed, memoryRestEvents.listUnavailable), (0, rxjs_operators.filter)((action) => action.sessionId === sessionId)), store.actions$.pipe(ofType(memoryAdapterEvents.stopped)), store.actions$.pipe(ofType(memoryAdapterEvents.contextChanged))).pipe((0, rxjs_operators.take)(1))).then((action) => {
+					if (memoryRestEvents.listFailed.match(action)) throw action.error;
+					if (memoryAdapterEvents.stopped.match(action)) throw new Error("Memory store stopped before refresh completed");
+					if (memoryAdapterEvents.contextChanged.match(action)) return;
+				});
+				store.dispatch(memoryRestEvents.listRequested({ sessionId }));
+				return done;
+			},
+			addMemory(input) {
+				return trackMutation(memoryAdapterEvents.addRequested({
+					requestId: createMemoryRequestId(),
+					input
+				}), (outcome) => {
+					if (outcome.memory == null) throw new Error("add resolved without a memory");
+					return outcome.memory;
+				});
+			},
+			updateMemory(id, changes) {
+				return trackMutation(memoryAdapterEvents.updateRequested({
+					requestId: createMemoryRequestId(),
+					id,
+					changes
+				}), (outcome) => {
+					if (outcome.memory == null) throw new Error("update resolved without a memory");
+					return outcome.memory;
+				});
+			},
+			removeMemory(id) {
+				return trackMutation(memoryAdapterEvents.removeRequested({
+					requestId: createMemoryRequestId(),
+					id
+				}), () => void 0);
+			},
+			getState() {
+				return store.getState();
+			},
+			getServerState() {
+				return initialMemoryState;
+			},
+			select: store.select.bind(store)
+		};
+	}
+	const ɵmemoryAdapterEvents = memoryAdapterEvents;
+	const ɵmemoryRestEvents = memoryRestEvents;
+	const ɵmemoryDomainEvents = memoryDomainEvents;
+	const ɵmemoryReducer = memoryReducer;
+	const ɵmapMemoryMetadataEvent = mapMemoryMetadataEvent;
+	const ɵselectMemories = selectMemories;
+	const ɵselectMemoriesIsLoading = selectMemoriesIsLoading;
+	const ɵselectMemoriesError = selectMemoriesError;
+	const ɵselectMemoriesIsMutating = selectMemoriesIsMutating;
+	const ɵselectMemoriesAvailable = selectMemoriesAvailable;
+	const ɵselectMemoriesRealtimeStatus = selectMemoriesRealtimeStatus;
+
+//#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";
+		CopilotKitCoreErrorCode["SUBSCRIBER_CALLBACK_FAILED"] = "subscriber_callback_failed";
+		return CopilotKitCoreErrorCode;
+	}({});
+	/**
+	* Runtime allowlist derived from {@link SUBSCRIBE_TO_AGENT_KEYS}. Hoisted
+	* to module scope so the Set is allocated once, not per-subscription.
+	*/
+	const ALLOWED_KEYS = new Set([
+		"onMessagesChanged",
+		"onStateChanged",
+		"onRunInitialized",
+		"onRunFinalized",
+		"onRunFailed",
+		"onRunErrorEvent"
+	]);
+	let CopilotKitCoreRuntimeConnectionStatus = /* @__PURE__ */ function(CopilotKitCoreRuntimeConnectionStatus) {
+		CopilotKitCoreRuntimeConnectionStatus["Disconnected"] = "disconnected";
+		CopilotKitCoreRuntimeConnectionStatus["Connected"] = "connected";
+		CopilotKitCoreRuntimeConnectionStatus["Connecting"] = "connecting";
+		CopilotKitCoreRuntimeConnectionStatus["Error"] = "error";
+		return CopilotKitCoreRuntimeConnectionStatus;
+	}({});
+	/**
+	* Normalize a header map to the internal invariant: a `Record<string, string>`
+	* with no `null`/`undefined` values. Entries whose value is `null`/`undefined`
+	* are dropped (this is how a header is cleared). Shared by the constructor and
+	* `setHeaders` so both write paths into `_headers` enforce the same invariant.
+	*/
+	function normalizeHeaders(headers) {
+		return Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] != null));
+	}
+	var CopilotKitCore = class {
+		constructor({ runtimeUrl, runtimeTransport = "auto", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
+			_defineProperty(this, "_headers", void 0);
+			_defineProperty(this, "_credentials", void 0);
+			_defineProperty(this, "_properties", void 0);
+			_defineProperty(this, "_defaultThrottleMs", void 0);
+			_defineProperty(this, "_debug", void 0);
+			_defineProperty(this, "subscribers", /* @__PURE__ */ new Set());
+			_defineProperty(this, "agentRegistry", void 0);
+			_defineProperty(this, "contextStore", void 0);
+			_defineProperty(this, "suggestionEngine", void 0);
+			_defineProperty(this, "runHandler", void 0);
+			_defineProperty(this, "stateManager", void 0);
+			_defineProperty(this, "subagentRegistry", void 0);
+			_defineProperty(this, "threadStoreRegistry", void 0);
+			_defineProperty(this, "_memoryStore", void 0);
+			_defineProperty(this, "previousAgentIds", /* @__PURE__ */ new Set());
+			this._headers = normalizeHeaders(headers);
+			this._credentials = credentials;
+			this._properties = properties;
+			this._debug = debug;
+			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.subagentRegistry = new SubagentRegistry(this);
+			this.threadStoreRegistry = new ThreadStoreRegistry(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.previousAgentIds = new Set(Object.keys(agents__unsafe_dev_only));
+			this.subscribe({
+				onRuntimeConnectionStatusChanged: () => {
+					if (this._memoryStore) this.syncMemoryContext();
+				},
+				onAgentsChanged: ({ agents }) => {
+					Object.values(agents).forEach((agent) => {
+						if (agent.agentId) {
+							this.stateManager.subscribeToAgent(agent);
+							this.subagentRegistry.subscribeToAgent(agent);
+						}
+					});
+					const currentAgentIds = new Set(Object.keys(agents));
+					for (const agentId of Object.keys(this.threadStoreRegistry.getAll())) if (this.previousAgentIds.has(agentId) && !currentAgentIds.has(agentId)) try {
+						this.threadStoreRegistry.unregister(agentId);
+					} catch (err) {
+						console.error(`CopilotKitCore.onAgentsChanged: threadStoreRegistry.unregister failed for "${agentId}":`, err);
+					}
+					for (const agentId of this.previousAgentIds) if (!currentAgentIds.has(agentId)) {
+						try {
+							this.stateManager.unsubscribeFromAgent(agentId);
+						} catch (err) {
+							console.error(`CopilotKitCore.onAgentsChanged: stateManager.unsubscribeFromAgent failed for "${agentId}":`, err);
+						}
+						try {
+							this.subagentRegistry.unsubscribeFromAgent(agentId);
+						} catch (err) {
+							console.error(`CopilotKitCore.onAgentsChanged: subagentRegistry.unsubscribeFromAgent failed for "${agentId}":`, err);
+						}
+					}
+					this.previousAgentIds = currentAgentIds;
+				}
+			});
+		}
+		/**
+		* Internal method used by delegate classes and subclasses to notify subscribers
+		*/
+		async notifySubscribers(handler, errorMessage) {
+			await Promise.all(Array.from(this.subscribers).map(async (subscriber) => {
+				try {
+					await handler(subscriber);
+				} catch (error) {
+					console.error(errorMessage, error);
+				}
+			}));
+		}
+		/**
+		* Internal method used by delegate classes to emit errors
+		*/
+		async emitError({ error, code, context = {} }) {
+			await this.notifySubscribers((subscriber) => {
+				var _subscriber$onError;
+				return (_subscriber$onError = subscriber.onError) === null || _subscriber$onError === void 0 ? void 0 : _subscriber$onError.call(subscriber, {
+					copilotkit: this,
+					error,
+					code,
+					context
+				});
+			}, "Subscriber onError error:");
+		}
+		/**
+		* Log a message to the console and emit an error to subscribers.
+		* Catches failures from `emitError` itself to prevent unhandled rejections.
+		*/
+		logAndEmitError(message, params, logLevel = "error") {
+			console[logLevel](message, params.error);
+			this.emitError(params).catch((emitErr) => {
+				console.error(message + " — emitError itself failed:", emitErr);
+			});
+		}
+		/**
+		* 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;
+		}
+		/**
+		* Default throttle interval (ms) used by `subscribeToAgentWithOptions()`
+		* when the caller does not specify an explicit `throttleMs`.
+		* `undefined` means no default is configured; `0` means no throttling.
+		*/
+		get defaultThrottleMs() {
+			return this._defaultThrottleMs;
+		}
+		/**
+		* Set the default throttle interval (ms) for `subscribeToAgentWithOptions()`.
+		*
+		* Accepts a non-negative finite number or `undefined` (to clear the
+		* default). Invalid values (NaN, Infinity, negative) are logged as
+		* errors and ignored — the previous valid value is preserved.
 		*/
 		setDefaultThrottleMs(value) {
 			if (value !== void 0 && (!Number.isFinite(value) || value < 0)) {
@@ -2954,6 +4118,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		*/
 		setHeaders(headers) {
 			this._headers = normalizeHeaders(headers);
+			if (this._memoryStore) this.syncMemoryContext();
 			this.agentRegistry.applyHeadersToAgents(this.agentRegistry.agents);
 			this.notifySubscribers((subscriber) => {
 				var _subscriber$onHeaders;
@@ -3065,6 +4230,47 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return this.threadStoreRegistry.getAll();
 		}
 		/**
+		* Returns the single core-owned, user-scoped memory store, creating and
+		* starting it on first access. Unlike thread stores, memory is not scoped per
+		* agent: there is exactly one store whose runtime context the core wires
+		* itself (see `syncMemoryContext`), so consumers (e.g. a `useMemories`
+		* binding) just read this store rather than registering one.
+		*/
+		getMemoryStore() {
+			return this.ensureMemoryStore();
+		}
+		/**
+		* Lazily creates, starts, and context-syncs the core-owned memory store on
+		* first access, then returns it. Subsequent calls return the existing store.
+		* The store is constructed with a bound `globalThis.fetch` and immediately
+		* has its runtime context synced from the current connection state.
+		*/
+		ensureMemoryStore() {
+			if (!this._memoryStore) {
+				this._memoryStore = createMemoryStore({ fetch: globalThis.fetch.bind(globalThis) });
+				this._memoryStore.start();
+				this.syncMemoryContext();
+			}
+			return this._memoryStore;
+		}
+		/**
+		* Pushes the current runtime wiring into the memory store. When the runtime
+		* is connected and both the intelligence WebSocket URL and runtime URL are
+		* available, the store receives a context (runtime URL, WebSocket URL, and a
+		* copy of the current headers); otherwise its context is cleared. No-op when
+		* the store has not been created yet.
+		*/
+		syncMemoryContext() {
+			var _this$intelligence;
+			if (!this._memoryStore) return;
+			if (this.runtimeConnectionStatus === CopilotKitCoreRuntimeConnectionStatus.Connected && ((_this$intelligence = this.intelligence) === null || _this$intelligence === void 0 ? void 0 : _this$intelligence.wsUrl) && this.runtimeUrl) this._memoryStore.setContext({
+				runtimeUrl: this.runtimeUrl,
+				wsUrl: this.intelligence.wsUrl,
+				headers: { ...this.headers }
+			});
+			else this._memoryStore.setContext(null);
+		}
+		/**
 		* Suggestions management (delegated to SuggestionEngine)
 		*/
 		addSuggestionsConfig(config) {
@@ -3083,6 +4289,16 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return this.suggestionEngine.getSuggestions(agentId);
 		}
 		/**
+		* Subagent registry (delegated to SubagentRegistry).
+		*
+		* Returns the subagents observed for an owning agent during its run(s),
+		* keyed by `subagentId`, each carrying `name` / `description` / `status`.
+		* Empty for runs that never emit SUBAGENT_* events.
+		*/
+		getSubagents(agentId) {
+			return this.subagentRegistry.getSubagents(agentId);
+		}
+		/**
 		* Tool management (delegated to RunHandler)
 		*/
 		addTool(tool) {
@@ -3230,515 +4446,257 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			if (subscriber.onStateChanged) wrappedSubscriber.onStateChanged = (params) => {
 				latestStateParams = params;
 				throttler.maybeExecute();
-			};
-			const subscription = agent.subscribe(wrappedSubscriber);
-			return { unsubscribe: () => {
-				active = false;
-				throttler.cancel();
-				subscription.unsubscribe();
-			} };
-		}
-		/**
-		* 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;
-			}
+			};
+			const subscription = agent.subscribe(wrappedSubscriber);
+			return { unsubscribe: () => {
+				active = false;
+				throttler.cancel();
+				subscription.unsubscribe();
+			} };
 		}
-		if (shouldCloseParens) {
-			const openParens = (result.match(/\(/g) || []).length;
-			const closeParens = (result.match(/\)/g) || []).length;
-			if (openParens > closeParens) result += ")".repeat(openParens - closeParens);
+		/**
+		* Agent connectivity (delegated to RunHandler)
+		*/
+		async connectAgent(params) {
+			return this.runHandler.connectAgent(params);
 		}
-		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, () => ({}));
+		stopAgent(params) {
+			this.runHandler.abortCurrentRun();
+			params.agent.abortRun();
 		}
-		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);
+		async runAgent(params) {
+			return this.runHandler.runAgent(params);
 		}
-		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;
-			};
+		/**
+		* 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);
 		}
-		const projector = args[args.length - 1];
-		const selectors = args.slice(0, -1);
-		let hasCached = false;
-		let lastInputs = [];
-		let lastResult;
-		return (state) => {
-			const inputs = selectors.map((selector) => selector(state));
-			if (hasCached && inputs.length === lastInputs.length && inputs.every((value, index) => value === lastInputs[index])) return lastResult;
-			lastInputs = inputs;
-			lastResult = projector(...inputs);
-			hasCached = true;
-			return lastResult;
-		};
-	}
-	/**
-	* RxJS operator that maps state emissions through a selector and suppresses
-	* unchanged projected values via reference equality.
-	*/
-	function select(selector) {
-		return (source$) => source$.pipe((0, rxjs_operators.map)(selector), (0, rxjs_operators.distinctUntilChanged)());
-	}
-	/**
-	* RxJS operator that filters an action stream by action creators and narrows
-	* the output action type to the matched creator union.
-	*
-	* @throws Error when called without at least one action creator.
-	*/
-	function ofType(...creators) {
-		if (creators.length === 0) throw new Error("ofType requires at least one action creator");
-		const actionTypes = new Set(creators.map((creator) => creator.type));
-		return (source$) => {
-			return source$.pipe((0, rxjs_operators.filter)((action) => {
-				return actionTypes.has(action.type);
-			}));
-		};
-	}
-	/**
-	* Creates an effect descriptor consumed by `createStore`.
-	*/
-	function createEffect(factory, options = {}) {
-		if (options.dispatch === false) return {
-			run: factory,
-			dispatch: false
-		};
-		return {
-			run: factory,
-			dispatch: true
-		};
-	}
-	/**
-	* Creates a small observable store with reducer + effects.
-	*
-	* Behavior:
-	* - `init()` starts effects and dispatches `@@micro-redux/init`.
-	* - `stop()` dispatches `@@micro-redux/stop` and unsubscribes all effects.
-	* - Effect action observation is scheduled on `asapScheduler` to avoid
-	*   synchronous re-entrancy in the effect loop.
-	* - Any effect error triggers fail-fast teardown and errors both `actions$`
-	*   and `state$`.
-	*/
-	function createStore(options) {
-		var _options$effects;
-		const reducer = options.reducer;
-		const effects = (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : [];
-		let hasFatalError = false;
-		let isRunning = false;
-		let effectSubscriptions = new rxjs.Subscription();
-		let currentState = reducer(void 0, INTERNAL_BOOT_ACTION);
-		const stateSubject = new rxjs.BehaviorSubject(currentState);
-		const actionsSubject = new rxjs.Subject();
-		const dispatchInternal = (action) => {
-			if (hasFatalError) throw new Error("Store is in a failed state due to an effect error");
-			currentState = reducer(currentState, action);
-			stateSubject.next(currentState);
-			actionsSubject.next(action);
-		};
-		const failFast = (error) => {
-			if (hasFatalError) return;
-			hasFatalError = true;
-			isRunning = false;
-			effectSubscriptions.unsubscribe();
-			effectSubscriptions = new rxjs.Subscription();
-			actionsSubject.error(error);
-			stateSubject.error(error);
-		};
-		const startEffects = () => {
-			for (const effect of effects) {
-				const scheduledActions$ = actionsSubject.asObservable().pipe((0, rxjs_operators.observeOn)(rxjs.asapScheduler));
-				const state$ = stateSubject.asObservable();
-				if (effect.dispatch) {
-					const subscription = effect.run(scheduledActions$, state$).subscribe({
-						next: (effectAction) => {
-							if (hasFatalError) return;
-							dispatchInternal(effectAction);
-						},
-						error: (error) => {
-							failFast(error);
-						}
+		/**
+		* 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
 					});
-					effectSubscriptions.add(subscription);
-					continue;
+					currentCodeBlockStart = -1;
 				}
-				const subscription = effect.run(scheduledActions$, state$).subscribe({ error: (error) => {
-					failFast(error);
-				} });
-				effectSubscriptions.add(subscription);
+				i += lineMatch[0].length - 1;
 			}
-		};
-		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;
+		}
+		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/threads.ts
 	const THREADS_CHANNEL_EVENT = "thread_metadata";
+	const THREAD_RUN_ACTIVITY_CHANNEL_EVENT = "thread_run_activity";
 	const THREAD_SUBSCRIBE_PATH = "/threads/subscribe";
 	const MAX_SOCKET_RETRIES = 5;
 	const REQUEST_TIMEOUT_MS = 15e3;
@@ -3747,6 +4705,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		isLoading: false,
 		isFetchingNextPage: false,
 		error: null,
+		fetchMoreError: null,
 		context: null,
 		sessionId: 0,
 		metadataCredentialsRequested: false,
@@ -3782,7 +4741,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		errored: props(),
 		joinFailed: props(),
 		joinTimedOut: props(),
-		metadataReceived: props()
+		metadataReceived: props(),
+		runActivityReceived: props()
 	});
 	const threadDomainEvents = createActionGroup("Thread Domain", {
 		threadUpserted: props(),
@@ -3802,6 +4762,29 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		next[existingIndex] = thread;
 		return sortThreadsByRecency(next);
 	}
+	/**
+	* Returns a non-empty string payload field or undefined for absent fields.
+	*/
+	function optionalString(value) {
+		return typeof value === "string" && value.length > 0 ? value : void 0;
+	}
+	/**
+	* Converts gateway run-activity payloads into the internal TypeScript shape.
+	*/
+	function normalizeThreadRunActivityNotification(payload) {
+		var _payload$threadId, _payload$eventType, _payload$agentId, _payload$runId, _payload$latestEventI;
+		const threadId = optionalString((_payload$threadId = payload.threadId) !== null && _payload$threadId !== void 0 ? _payload$threadId : payload.thread_id);
+		const eventType = optionalString((_payload$eventType = payload.eventType) !== null && _payload$eventType !== void 0 ? _payload$eventType : payload.event_type);
+		if (!threadId || !eventType) return null;
+		return {
+			type: "thread_run_activity",
+			threadId,
+			agentId: optionalString((_payload$agentId = payload.agentId) !== null && _payload$agentId !== void 0 ? _payload$agentId : payload.agent_id),
+			runId: optionalString((_payload$runId = payload.runId) !== null && _payload$runId !== void 0 ? _payload$runId : payload.run_id),
+			eventType,
+			latestEventId: optionalString((_payload$latestEventI = payload.latestEventId) !== null && _payload$latestEventI !== void 0 ? _payload$latestEventI : payload.latest_event_id)
+		};
+	}
 	const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.contextChanged, (state, { context }) => ({
 		...state,
 		context,
@@ -3810,6 +4793,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		isLoading: Boolean(context),
 		isFetchingNextPage: false,
 		error: null,
+		fetchMoreError: null,
 		metadataCredentialsRequested: false,
 		metadataJoinCode: null,
 		nextCursor: null,
@@ -3821,6 +4805,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		isLoading: false,
 		isFetchingNextPage: false,
 		error: null,
+		fetchMoreError: null,
 		metadataCredentialsRequested: false,
 		metadataJoinCode: null,
 		nextCursor: null,
@@ -3831,16 +4816,20 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return {
 			...state,
 			isLoading: true,
-			error: null
+			error: null,
+			fetchMoreError: null
 		};
 	}), on(threadRestEvents.listSucceeded, (state, { sessionId, threads, joinCode, nextCursor }) => {
 		if (sessionId !== state.sessionId) return state;
+		const joinCodeChanged = joinCode !== state.metadataJoinCode;
 		return {
 			...state,
 			threads: sortThreadsByRecency(threads),
 			isLoading: false,
 			error: null,
+			fetchMoreError: null,
 			metadataJoinCode: joinCode,
+			metadataCredentialsRequested: joinCodeChanged ? false : state.metadataCredentialsRequested,
 			nextCursor
 		};
 	}), on(threadRestEvents.listFailed, (state, { sessionId, error }) => {
@@ -3858,6 +4847,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			...state,
 			threads: merged,
 			isFetchingNextPage: false,
+			fetchMoreError: null,
 			nextCursor
 		};
 	}), on(threadRestEvents.nextPageFailed, (state, { sessionId, error }) => {
@@ -3865,11 +4855,14 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return {
 			...state,
 			isFetchingNextPage: false,
-			error
+			fetchMoreError: error
 		};
 	}), on(threadRestEvents.metadataCredentialsFailed, (state, { sessionId }) => {
 		if (sessionId !== state.sessionId) return state;
-		return state;
+		return {
+			...state,
+			metadataCredentialsRequested: false
+		};
 	}), on(threadRestEvents.metadataCredentialsRequested, (state, { sessionId }) => {
 		if (sessionId !== state.sessionId) return state;
 		return {
@@ -3880,7 +4873,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		if (!state.nextCursor || state.isFetchingNextPage) return state;
 		return {
 			...state,
-			isFetchingNextPage: true
+			isFetchingNextPage: true,
+			fetchMoreError: null
 		};
 	}), on(threadAdapterEvents.renameRequested, (state, { threadId, name }) => {
 		const existing = state.threads.find((thread) => thread.id === threadId);
@@ -4010,6 +5004,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			threads: createSelector((state) => state.threads),
 			isLoading: createSelector((state) => state.isLoading),
 			error: createSelector((state) => state.error),
+			fetchMoreError: createSelector((state) => state.fetchMoreError),
 			hasNextPage: createSelector((state) => state.nextCursor != null),
 			isFetchingNextPage: createSelector((state) => state.isFetchingNextPage),
 			isMutating: createSelector((state) => state.inFlightMutationCount > 0)
@@ -4019,6 +5014,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	const selectThreads = standaloneSelectors.threads;
 	const selectThreadsIsLoading = standaloneSelectors.isLoading;
 	const selectThreadsError = standaloneSelectors.error;
+	const selectFetchMoreError = standaloneSelectors.fetchMoreError;
 	const selectHasNextPage = standaloneSelectors.hasNextPage;
 	const selectIsFetchingNextPage = standaloneSelectors.isFetchingNextPage;
 	const selectIsMutating = standaloneSelectors.isMutating;
@@ -4028,7 +5024,27 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return `thread-request-${threadRequestId}`;
 	}
 	function threadFromFetch(input, init) {
-		return (0, rxjs_fetch.fromFetch)(input, init);
+		return new rxjs.Observable((subscriber) => {
+			const { fetch: fetchImpl, selector, signal, ...requestInit } = init;
+			const controller = new AbortController();
+			const abortRequest = () => controller.abort();
+			if (signal === null || signal === void 0 ? void 0 : signal.aborted) abortRequest();
+			else signal === null || signal === void 0 || signal.addEventListener("abort", abortRequest, { once: true });
+			fetchImpl(input, {
+				...requestInit,
+				signal: controller.signal
+			}).then((response) => selector(response)).then((value) => {
+				if (subscriber.closed) return;
+				subscriber.next(value);
+				subscriber.complete();
+			}).catch((error) => {
+				if (!subscriber.closed) subscriber.error(error);
+			});
+			return () => {
+				signal === null || signal === void 0 || signal.removeEventListener("abort", abortRequest);
+				abortRequest();
+			};
+		});
 	}
 	function createThreadFetchObservable(environment, context, sessionId) {
 		return (0, rxjs.defer)(() => {
@@ -4179,6 +5195,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 						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
+						}))), channel$.pipe((0, rxjs_operators.switchMap)(({ channel }) => ɵobservePhoenixEvent$(channel, THREAD_RUN_ACTIVITY_CHANNEL_EVENT)), (0, rxjs_operators.map)((payload) => normalizeThreadRunActivityNotification(payload)), (0, rxjs_operators.filter)((notification) => notification !== null), (0, rxjs_operators.map)((notification) => threadSocketEvents.runActivityReceived({
+							sessionId: action.sessionId,
+							notification
 						}))), ɵ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$)));
 					});
 				}))),
@@ -4363,6 +5382,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					threadId
 				}));
 			},
+			subscribeToRunActivity(callback) {
+				return store.actions$.pipe(ofType(threadSocketEvents.runActivityReceived), (0, rxjs_operators.filter)((action) => action.sessionId === store.getState().sessionId), (0, rxjs_operators.map)((action) => action.notification)).subscribe(callback);
+			},
 			getState() {
 				return store.getState();
 			},
@@ -4378,6 +5400,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	const ɵselectThreads = selectThreads;
 	const ɵselectThreadsIsLoading = selectThreadsIsLoading;
 	const ɵselectThreadsError = selectThreadsError;
+	const ɵselectFetchMoreError = selectFetchMoreError;
 	const ɵselectHasNextPage = selectHasNextPage;
 	const ɵselectIsFetchingNextPage = selectIsFetchingNextPage;
 	const ɵselectIsMutating = selectIsMutating;
@@ -4442,9 +5465,12 @@ exports.CopilotKitCore = CopilotKitCore;
 exports.CopilotKitCoreErrorCode = CopilotKitCoreErrorCode;
 exports.CopilotKitCoreRuntimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus;
 exports.IntelligenceAgent = IntelligenceAgent;
+exports.MEMORY_ERROR_REGISTRY = MEMORY_ERROR_REGISTRY;
+exports.MemoryError = MemoryError;
 exports.ProxiedCopilotRuntimeAgent = ProxiedCopilotRuntimeAgent;
 exports.RunHandler = RunHandler;
 exports.StateManager = StateManager;
+exports.SubagentRegistry = SubagentRegistry;
 exports.SuggestionEngine = SuggestionEngine;
 exports.ToolCallStatus = ToolCallStatus;
 exports.completePartialMarkdown = completePartialMarkdown;
@@ -4463,19 +5489,33 @@ exports.props = props;
 exports.select = select;
 exports.ɵCOPILOTKIT_FEATURES = ɵCOPILOTKIT_FEATURES;
 exports.ɵMAX_SOCKET_RETRIES = ɵMAX_SOCKET_RETRIES;
+exports.ɵcreateMemoryStore = createMemoryStore;
 exports.ɵcreateThreadSelectors = ɵcreateThreadSelectors;
 exports.ɵcreateThreadStore = createThreadStore;
 exports.ɵisCopilotKitFeature = ɵisCopilotKitFeature;
+exports.ɵisRetryableMemoryStatus = isRetryableStatus;
 exports.ɵjoinPhoenixChannel$ = ɵjoinPhoenixChannel$;
+exports.ɵmapMemoryMetadataEvent = ɵmapMemoryMetadataEvent;
+exports.ɵmemoryAdapterEvents = ɵmemoryAdapterEvents;
+exports.ɵmemoryDomainEvents = ɵmemoryDomainEvents;
+exports.ɵmemoryReducer = ɵmemoryReducer;
+exports.ɵmemoryRestEvents = ɵmemoryRestEvents;
 exports.ɵobservePhoenixEvent$ = ɵobservePhoenixEvent$;
 exports.ɵobservePhoenixJoinOutcome$ = ɵobservePhoenixJoinOutcome$;
 exports.ɵobservePhoenixSocketHealth$ = ɵobservePhoenixSocketHealth$;
 exports.ɵobservePhoenixSocketSignals$ = ɵobservePhoenixSocketSignals$;
 exports.ɵphoenixChannel$ = ɵphoenixChannel$;
 exports.ɵphoenixSocket$ = ɵphoenixSocket$;
+exports.ɵselectFetchMoreError = ɵselectFetchMoreError;
 exports.ɵselectHasNextPage = ɵselectHasNextPage;
 exports.ɵselectIsFetchingNextPage = ɵselectIsFetchingNextPage;
 exports.ɵselectIsMutating = ɵselectIsMutating;
+exports.ɵselectMemories = ɵselectMemories;
+exports.ɵselectMemoriesAvailable = ɵselectMemoriesAvailable;
+exports.ɵselectMemoriesError = ɵselectMemoriesError;
+exports.ɵselectMemoriesIsLoading = ɵselectMemoriesIsLoading;
+exports.ɵselectMemoriesIsMutating = ɵselectMemoriesIsMutating;
+exports.ɵselectMemoriesRealtimeStatus = ɵselectMemoriesRealtimeStatus;
 exports.ɵselectThreads = ɵselectThreads;
 exports.ɵselectThreadsError = ɵselectThreadsError;
 exports.ɵselectThreadsIsLoading = ɵselectThreadsIsLoading;