@copilotkit/core 1.62.1 → 1.62.2-canary.1784333495

package/dist/index.cjs

@@ -131,6 +131,7 @@ const CLIENT_AG_UI_EVENT = "ag_ui_event";
 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");
@@ -280,12 +281,14 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 	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
 			});
 		}));
 	}
@@ -308,7 +311,7 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 	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), {
@@ -325,7 +328,7 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 						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 } : {}
 				});
@@ -361,10 +364,11 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 	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
 			})));
 		}));
 	}
@@ -401,15 +405,23 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 				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 ?? this.getReconnectCursor(input));
+			let latestObservedReplayCursor = null;
+			const threadEvents$ = this.observeThreadEvents$(input.threadId, channel$, options).pipe((0, rxjs_operators.tap)((payload) => {
+				latestObservedReplayCursor = this.readEventId(payload) ?? 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$) {
@@ -475,23 +487,36 @@ var IntelligenceAgent = class IntelligenceAgent extends _ag_ui_client.AbstractAg
 	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) {
 		if (!payload || typeof payload !== "object") return null;
-		const latestEventId = payload.latestEventId;
-		return typeof latestEventId === "string" ? latestEventId : null;
+		const controlPayload = payload;
+		const latestEventId = controlPayload.latestEventId ?? 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) {
 		this.threadId = credentials.threadId;
@@ -1660,7 +1685,9 @@ var RunHandler = class {
 	* downstream churn into duplicate `cpki_event_id` rows in the
 	* inspector and intermittent "Message not found" toasts.
 	*/
-	_lastConnectedThreadId = null;
+	_lastConnectedThreadIdsByAgent = /* @__PURE__ */ new Map();
+	_anonymousAgentIds = /* @__PURE__ */ new WeakMap();
+	_nextAnonymousAgentId = 0;
 	constructor(core) {
 		this.core = core;
 	}
@@ -1680,6 +1707,20 @@ var RunHandler = class {
 		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() {
@@ -1735,14 +1776,18 @@ var RunHandler = class {
 	async connectAgent({ agent }) {
 		try {
 			const incomingThreadId = agent.threadId ?? null;
-			const isFreshRestore = incomingThreadId !== this._lastConnectedThreadId;
-			this._lastConnectedThreadId = incomingThreadId;
+			const restoreKey = this.getConnectRestoreKey(agent);
+			const isFreshRestore = incomingThreadId !== (this._lastConnectedThreadIdsByAgent.get(restoreKey) ?? 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) => subscriber.onAgentRunStarted?.({
@@ -1756,7 +1801,8 @@ var RunHandler = class {
 			}, this.createAgentErrorSubscriber(agent));
 			return this.processAgentResult({
 				runAgentResult,
-				agent
+				agent,
+				executeFrontendTools: false
 			});
 		} catch (error) {
 			const connectError = error instanceof Error ? error : new Error(String(error));
@@ -1778,7 +1824,7 @@ var RunHandler = class {
 	/**
 	* 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();
@@ -1805,6 +1851,7 @@ var RunHandler = class {
 					...forwardedProps
 				},
 				...resume !== void 0 ? { resume } : {},
+				...runId !== void 0 ? { runId } : {},
 				tools: this.buildFrontendTools(agent.agentId),
 				context: this._internal.getContextForAgent(agent.agentId)
 			}, this.createAgentErrorSubscriber(agent));
@@ -1833,25 +1880,27 @@ var RunHandler = class {
 	/**
 	* Process agent result and execute tools
 	*/
-	async processAgentResult({ runAgentResult, agent }) {
+	async processAgentResult({ runAgentResult, agent, executeFrontendTools = true }) {
 		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;
+						}
 					}
 				}
 			}
@@ -2461,6 +2510,124 @@ var StateManager = class {
 	}
 };
 
+//#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 {
+	_subagents = {};
+	agentSubscriptions = /* @__PURE__ */ new Map();
+	constructor(core) {
+		this.core = core;
+	}
+	/**
+	* 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) {
+		const bucket = 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?.[event.subagentId];
+		if (!bucket || !existing) return;
+		bucket[event.subagentId] = {
+			...existing,
+			status: "finished"
+		};
+		this.notifySubagentsChanged(agentId);
+	}
+	handleError(agentId, event) {
+		const bucket = this._subagents[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) => subscriber.onSubagentsChanged?.({
+			copilotkit: this.core,
+			agentId,
+			subagents
+		}), "Subscriber onSubagentsChanged error:");
+	}
+};
+
 //#endregion
 //#region src/core/thread-store-registry.ts
 var ThreadStoreRegistry = class {
@@ -2517,210 +2684,1204 @@ var ThreadStoreRegistry = class {
 };
 
 //#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 {
-	_headers;
-	_credentials;
-	_properties;
-	_defaultThrottleMs;
-	_debug;
-	subscribers = /* @__PURE__ */ new Set();
-	agentRegistry;
-	contextStore;
-	suggestionEngine;
-	runHandler;
-	stateManager;
-	threadStoreRegistry;
-	/**
-	* Tracks the agent IDs from the most recent `onAgentsChanged` notification.
-	* Used to gate thread-store auto-unregister so the FIRST empty-agents
-	* notification (before published agents are merged in) does not rip out a
-	* store that was registered prior to that initial notification.
-	*/
-	previousAgentIds = /* @__PURE__ */ new Set();
-	constructor({ runtimeUrl, runtimeTransport = "auto", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
-		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);
-			}
-		}));
+/**
+* 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, () => ({}));
 	}
-	/**
-	* Internal method used by delegate classes to emit errors
-	*/
-	async emitError({ error, code, context = {} }) {
-		await this.notifySubscribers((subscriber) => subscriber.onError?.({
-			copilotkit: this,
-			error,
-			code,
-			context
-		}), "Subscriber onError error:");
-	}
-	/**
-	* 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) {
+		const handlers = reducerMap.get(creator.type) ?? [];
+		handlers.push(entry.reducer);
+		reducerMap.set(creator.type, handlers);
 	}
-	get credentials() {
-		return this._credentials;
+	return (state, action) => {
+		const currentState = state ?? initialState;
+		const handlers = reducerMap.get(action.type);
+		if (!handlers || handlers.length === 0) return currentState;
+		let nextState = currentState;
+		for (const handler of handlers) nextState = handler(nextState, action);
+		return nextState;
+	};
+}
+/**
+* Creates a selector that caches and reuses the last computed result
+* when all input references are unchanged.
+*/
+function createSelector(...args) {
+	if (args.length === 1) {
+		const projector = args[0];
+		let hasCached = false;
+		let lastState;
+		let lastResult;
+		return (state) => {
+			if (hasCached && state === lastState) return lastResult;
+			lastState = state;
+			lastResult = projector(state);
+			hasCached = true;
+			return lastResult;
+		};
 	}
-	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) {
+	const reducer = options.reducer;
+	const effects = 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 {
+	/** Stable, machine-readable error identifier. */
+	code;
+	/** Coarse error category for grouping/observability. */
+	category;
+	/** Whether retrying the operation could plausibly succeed. */
+	retryable;
 	/**
-	* 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) {
+		const entry = MEMORY_ERROR_REGISTRY[code];
+		super(options?.message ?? entry.message, { cause: options?.cause });
+		this.name = "MemoryError";
+		this.code = code;
+		this.category = entry.category;
+		this.retryable = 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) {
+	return {
+		content: input.content,
+		kind: input.kind,
+		...input.scope !== void 0 ? { scope: input.scope } : {},
+		sourceThreadIds: input.sourceThreadIds ?? []
+	};
+}
+/**
+* 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?.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]) => {
+				return action.sessionId === state.sessionId && Boolean(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 {
+	_headers;
+	_credentials;
+	_properties;
+	_defaultThrottleMs;
+	_debug;
+	subscribers = /* @__PURE__ */ new Set();
+	agentRegistry;
+	contextStore;
+	suggestionEngine;
+	runHandler;
+	stateManager;
+	subagentRegistry;
+	threadStoreRegistry;
+	/**
+	* The single core-owned memory store, created lazily on first
+	* `getMemoryStore()` and kept user-scoped for the lifetime of the core.
+	* Its runtime context is wired by the core itself (see `syncMemoryContext`),
+	* so callers never register or look it up by `agentId`.
+	*/
+	_memoryStore;
+	/**
+	* Tracks the agent IDs from the most recent `onAgentsChanged` notification.
+	* Used to gate thread-store auto-unregister so the FIRST empty-agents
+	* notification (before published agents are merged in) does not rip out a
+	* store that was registered prior to that initial notification.
+	*/
+	previousAgentIds = /* @__PURE__ */ new Set();
+	constructor({ runtimeUrl, runtimeTransport = "auto", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
+		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) => subscriber.onError?.({
+			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)) {
 			this.logAndEmitError(`CopilotKitCore.setDefaultThrottleMs: value must be a non-negative finite number or undefined, got ${value}. Keeping current value (${this._defaultThrottleMs}).`, {
@@ -2809,6 +3970,7 @@ var CopilotKitCore = class {
 	*/
 	setHeaders(headers) {
 		this._headers = normalizeHeaders(headers);
+		if (this._memoryStore) this.syncMemoryContext();
 		this.agentRegistry.applyHeadersToAgents(this.agentRegistry.agents);
 		this.notifySubscribers((subscriber) => subscriber.onHeadersChanged?.({
 			copilotkit: this,
@@ -2914,6 +4076,46 @@ var CopilotKitCore = class {
 		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() {
+		if (!this._memoryStore) return;
+		if (this.runtimeConnectionStatus === CopilotKitCoreRuntimeConnectionStatus.Connected && 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) {
@@ -2932,6 +4134,16 @@ var CopilotKitCore = class {
 		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) {
@@ -3076,515 +4288,259 @@ var CopilotKitCore = class {
 			throttler.maybeExecute();
 		};
 		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;
-		}
+			latestStateParams = params;
+			throttler.maybeExecute();
+		};
+		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) {
-		const handlers = reducerMap.get(creator.type) ?? [];
-		handlers.push(entry.reducer);
-		reducerMap.set(creator.type, handlers);
+	async runAgent(params) {
+		return this.runHandler.runAgent(params);
 	}
-	return (state, action) => {
-		const currentState = state ?? initialState;
-		const handlers = reducerMap.get(action.type);
-		if (!handlers || handlers.length === 0) return currentState;
-		let nextState = currentState;
-		for (const handler of handlers) nextState = handler(nextState, action);
-		return nextState;
-	};
-}
-/**
-* Creates a selector that caches and reuses the last computed result
-* when all input references are unchanged.
-*/
-function createSelector(...args) {
-	if (args.length === 1) {
-		const projector = args[0];
-		let hasCached = false;
-		let lastState;
-		let lastResult;
-		return (state) => {
-			if (hasCached && state === lastState) return lastResult;
-			lastState = state;
-			lastResult = projector(state);
-			hasCached = true;
-			return lastResult;
-		};
+	/**
+	* 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) {
-	const reducer = options.reducer;
-	const effects = 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;
@@ -3593,6 +4549,7 @@ const initialThreadState = {
 	isLoading: false,
 	isFetchingNextPage: false,
 	error: null,
+	fetchMoreError: null,
 	context: null,
 	sessionId: 0,
 	metadataCredentialsRequested: false,
@@ -3628,7 +4585,8 @@ const threadSocketEvents = createActionGroup("Thread Socket", {
 	errored: props(),
 	joinFailed: props(),
 	joinTimedOut: props(),
-	metadataReceived: props()
+	metadataReceived: props(),
+	runActivityReceived: props()
 });
 const threadDomainEvents = createActionGroup("Thread Domain", {
 	threadUpserted: props(),
@@ -3647,6 +4605,28 @@ function upsertThread(threads, thread) {
 	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) {
+	const threadId = optionalString(payload.threadId ?? payload.thread_id);
+	const eventType = optionalString(payload.eventType ?? payload.event_type);
+	if (!threadId || !eventType) return null;
+	return {
+		type: "thread_run_activity",
+		threadId,
+		agentId: optionalString(payload.agentId ?? payload.agent_id),
+		runId: optionalString(payload.runId ?? payload.run_id),
+		eventType,
+		latestEventId: optionalString(payload.latestEventId ?? payload.latest_event_id)
+	};
+}
 const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.contextChanged, (state, { context }) => ({
 	...state,
 	context,
@@ -3655,6 +4635,7 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	isLoading: Boolean(context),
 	isFetchingNextPage: false,
 	error: null,
+	fetchMoreError: null,
 	metadataCredentialsRequested: false,
 	metadataJoinCode: null,
 	nextCursor: null,
@@ -3666,6 +4647,7 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	isLoading: false,
 	isFetchingNextPage: false,
 	error: null,
+	fetchMoreError: null,
 	metadataCredentialsRequested: false,
 	metadataJoinCode: null,
 	nextCursor: null,
@@ -3676,16 +4658,20 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	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 }) => {
@@ -3703,6 +4689,7 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 		...state,
 		threads: merged,
 		isFetchingNextPage: false,
+		fetchMoreError: null,
 		nextCursor
 	};
 }), on(threadRestEvents.nextPageFailed, (state, { sessionId, error }) => {
@@ -3710,11 +4697,14 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	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 {
@@ -3725,7 +4715,8 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	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);
@@ -3854,6 +4845,7 @@ function createThreadSelectors() {
 		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)
@@ -3863,6 +4855,7 @@ const standaloneSelectors = createThreadSelectors();
 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;
@@ -3872,7 +4865,27 @@ function createThreadRequestId() {
 	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?.aborted) abortRequest();
+		else 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?.removeEventListener("abort", abortRequest);
+			abortRequest();
+		};
+	});
 }
 function createThreadFetchObservable(environment, context, sessionId) {
 	return (0, rxjs.defer)(() => {
@@ -4018,6 +5031,9 @@ function createThreadStore(environment) {
 					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$)));
 				});
 			}))),
@@ -4195,6 +5211,9 @@ function createThreadStore(environment) {
 				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();
 		},
@@ -4210,6 +5229,7 @@ const ɵcreateThreadSelectors = createThreadSelectors;
 const ɵselectThreads = selectThreads;
 const ɵselectThreadsIsLoading = selectThreadsIsLoading;
 const ɵselectThreadsError = selectThreadsError;
+const ɵselectFetchMoreError = selectFetchMoreError;
 const ɵselectHasNextPage = selectHasNextPage;
 const ɵselectIsFetchingNextPage = selectIsFetchingNextPage;
 const ɵselectIsMutating = selectIsMutating;
@@ -4274,9 +5294,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;
@@ -4295,19 +5318,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;