@copilotkit/core 1.62.2 → 1.62.3

package/dist/index.mjs

@@ -1,10 +1,11 @@
 import { Throttler } from "@tanstack/pacer";
 import { AbstractAgent, EventType, HttpAgent, randomUUID, runHttpRequest, structuredClone_, transformChunks, transformHttpEventStream } from "@ag-ui/client";
 import { RUNTIME_MODE_INTELLIGENCE, RUNTIME_MODE_SSE, logger, partialJSONParse, phoenixExponentialBackoff, randomUUID as randomUUID$1, resolveDebugConfig, schemaToJsonSchema } from "@copilotkit/shared";
-import { BehaviorSubject, EMPTY, NEVER, Notification, Observable, Subject, Subscription, asapScheduler, combineLatest, concat, defer, dematerialize, firstValueFrom, from, lastValueFrom, merge, of, switchMap, throwError } from "rxjs";
-import { catchError, delay, distinctUntilChanged, endWith, filter, finalize, ignoreElements, map, mergeMap, observeOn, scan, share, shareReplay, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
+import { BehaviorSubject, EMPTY, NEVER, Notification, Observable, Subject, Subscription, asapScheduler, combineLatest, concat, defer, dematerialize, firstValueFrom, from, lastValueFrom, merge, observeOn, of, switchMap, throwError } from "rxjs";
+import { catchError, concatWith, delay, distinctUntilChanged, endWith, filter, finalize, ignoreElements, map, mergeMap, observeOn as observeOn$1, scan, share, shareReplay, switchMap as switchMap$1, take, takeUntil, tap, timeout, withLatestFrom } from "rxjs/operators";
 import { Socket } from "phoenix";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { fromFetch } from "rxjs/fetch";
 
 //#region src/utils/phoenix-observable.ts
 /**
@@ -542,12 +543,12 @@ function hasCredentials(agent) {
 function isZodError(error) {
 	return error !== null && typeof error === "object" && "name" in error && error.name === "ZodError";
 }
-function isAbortError(error) {
+function isAbortError$1(error) {
 	return (error instanceof DOMException || error instanceof Error) && error.name === "AbortError";
 }
 function withAbortErrorHandling(observable) {
 	return observable.pipe(catchError((error) => {
-		if (isZodError(error) || isAbortError(error)) return EMPTY;
+		if (isZodError(error) || isAbortError$1(error)) return EMPTY;
 		throw error;
 	}));
 }
@@ -895,6 +896,7 @@ var AgentRegistry = class {
 	_runtimeMode = RUNTIME_MODE_SSE;
 	_intelligence;
 	_threadEndpoints;
+	_suggestions;
 	_a2uiEnabled = false;
 	_a2uiAgents;
 	_openGenerativeUIEnabled = false;
@@ -944,6 +946,9 @@ var AgentRegistry = class {
 	get threadEndpoints() {
 		return this._threadEndpoints;
 	}
+	get suggestions() {
+		return this._suggestions;
+	}
 	get a2uiEnabled() {
 		return this._a2uiEnabled;
 	}
@@ -1131,6 +1136,7 @@ var AgentRegistry = class {
 			this._runtimeMode = RUNTIME_MODE_SSE;
 			this._intelligence = void 0;
 			this._threadEndpoints = void 0;
+			this._suggestions = void 0;
 			this._a2uiEnabled = false;
 			this._a2uiAgents = void 0;
 			this._openGenerativeUIEnabled = false;
@@ -1178,6 +1184,7 @@ var AgentRegistry = class {
 			this._runtimeMode = runtimeInfoResponse.mode ?? RUNTIME_MODE_SSE;
 			this._intelligence = runtimeInfoResponse.intelligence;
 			this._threadEndpoints = runtimeInfoResponse.threadEndpoints;
+			this._suggestions = runtimeInfoResponse.suggestions;
 			const a2uiInfo = runtimeInfoResponse.a2ui;
 			this._a2uiEnabled = a2uiInfo?.enabled ?? runtimeInfoResponse.a2uiEnabled ?? false;
 			this._a2uiAgents = a2uiInfo?.enabled ? a2uiInfo.agents : void 0;
@@ -1193,6 +1200,7 @@ var AgentRegistry = class {
 			this._runtimeMode = RUNTIME_MODE_SSE;
 			this._intelligence = void 0;
 			this._threadEndpoints = void 0;
+			this._suggestions = void 0;
 			this._a2uiEnabled = false;
 			this._a2uiAgents = void 0;
 			this._openGenerativeUIEnabled = false;
@@ -1432,38 +1440,81 @@ var SuggestionEngine = class {
 		};
 	}
 	/**
-	* Generate suggestions using a provider agent
+	* Generate suggestions by running a provider agent and extracting the
+	* `copilotkitSuggest` tool call from its streamed messages.
+	*
+	* Two transports, one set of mechanics: both seed an agent with the
+	* consumer's messages + state and the instruction, then `runAgent` with
+	* forced `copilotkitSuggest` tool choice, parsing suggestions as messages
+	* stream in via `onMessagesChanged`.
+	*
+	* - **Stateless** (runtime advertises `suggestions` and transport isn't
+	*   `single`): a stock `HttpAgent` pointed at `/agent/:id/suggest`. That
+	*   endpoint runs the provider directly and streams AG-UI SSE **without**
+	*   persisting a thread, and a plain `HttpAgent` only ever speaks REST SSE —
+	*   it never routes through the Intelligence websocket delegate (which would
+	*   persist a thread). This is the path that removes the thread flood.
+	* - **Fallback** (capability absent → old runtime, or `single` transport):
+	*   clone the provider agent and run it client-side, as before.
+	*
+	* Gated to non-`single` transports because this client only builds the
+	* multi-route `/agent/:id/suggest` URL; single-route deployments (not the
+	* persisting-thread/Intelligence case) fall through to the clone fallback.
 	*/
 	async generateSuggestions(suggestionId, config, consumerAgentId) {
-		let agent = void 0;
+		let runHandle = void 0;
+		let aborted = false;
 		try {
-			const suggestionsProviderAgent = this.core.getAgent(config.providerAgentId ?? "default");
-			if (!suggestionsProviderAgent) throw new Error(`Suggestions provider agent not found: ${config.providerAgentId}`);
-			const suggestionsConsumerAgent = this.core.getAgent(consumerAgentId);
+			const friends = this.core;
+			const resolvedProviderAgentId = config.providerAgentId ?? "default";
+			const suggestionsProviderAgent = friends.getAgent(resolvedProviderAgentId);
+			if (!suggestionsProviderAgent) throw new Error(`Suggestions provider agent not found: ${resolvedProviderAgentId}`);
+			const suggestionsConsumerAgent = friends.getAgent(consumerAgentId);
 			if (!suggestionsConsumerAgent) throw new Error(`Suggestions consumer agent not found: ${consumerAgentId}`);
-			agent = suggestionsProviderAgent.clone();
-			agent.threadId = suggestionId;
-			agent.messages = JSON.parse(JSON.stringify(suggestionsConsumerAgent.messages));
-			agent.state = JSON.parse(JSON.stringify(suggestionsConsumerAgent.state));
+			const instructionContent = [
+				`Suggest what the user could say next. Provide clear, highly relevant suggestions by calling the \`copilotkitSuggest\` tool.`,
+				`Provide at least ${config.minSuggestions ?? 1} and at most ${config.maxSuggestions ?? 3} suggestions.`,
+				`The user has the following tools available: ${JSON.stringify(friends.buildFrontendTools(consumerAgentId))}.`,
+				` ${config.instructions}`
+			].join("\n");
 			this._suggestions[consumerAgentId] = {
 				...this._suggestions[consumerAgentId],
 				[suggestionId]: []
 			};
-			this._runningSuggestions[consumerAgentId] = [...this._runningSuggestions[consumerAgentId] ?? [], agent];
-			agent.addMessage({
+			const seededMessages = JSON.parse(JSON.stringify(suggestionsConsumerAgent.messages));
+			const seededState = JSON.parse(JSON.stringify(suggestionsConsumerAgent.state ?? {}));
+			const useStateless = this.core.suggestions === true && this.core.runtimeTransport !== "single";
+			let suggestionAgent;
+			if (useStateless) {
+				const suggestUrl = `${this.core.runtimeUrl}/agent/${encodeURIComponent(resolvedProviderAgentId)}/suggest`;
+				const credentials = this.core.credentials;
+				suggestionAgent = new HttpAgent({
+					agentId: resolvedProviderAgentId,
+					url: suggestUrl,
+					headers: { ...this.core.headers },
+					...credentials ? { fetch: (url, requestInit) => fetch(url, {
+						...requestInit,
+						credentials
+					}) } : {}
+				});
+			} else suggestionAgent = suggestionsProviderAgent.clone();
+			suggestionAgent.threadId = suggestionId;
+			suggestionAgent.setMessages(seededMessages);
+			suggestionAgent.setState(seededState);
+			runHandle = { abortRun: () => {
+				aborted = true;
+				suggestionAgent.abortRun();
+			} };
+			this._runningSuggestions[consumerAgentId] = [...this._runningSuggestions[consumerAgentId] ?? [], runHandle];
+			suggestionAgent.addMessage({
 				id: suggestionId,
 				role: "user",
-				content: [
-					`Suggest what the user could say next. Provide clear, highly relevant suggestions by calling the \`copilotkitSuggest\` tool.`,
-					`Provide at least ${config.minSuggestions ?? 1} and at most ${config.maxSuggestions ?? 3} suggestions.`,
-					`The user has the following tools available: ${JSON.stringify(this.core.buildFrontendTools(consumerAgentId))}.`,
-					` ${config.instructions}`
-				].join("\n")
+				content: instructionContent
 			});
-			await agent.runAgent({
-				context: this.core.getContextForAgent(consumerAgentId),
+			await suggestionAgent.runAgent({
+				context: friends.getContextForAgent(consumerAgentId),
 				forwardedProps: {
-					...this.core.properties,
+					...friends.properties,
 					toolChoice: {
 						type: "function",
 						function: { name: "copilotkitSuggest" }
@@ -1474,18 +1525,15 @@ var SuggestionEngine = class {
 				this.extractSuggestions(messages, suggestionId, consumerAgentId, true);
 			} });
 		} catch (error) {
-			console.warn("Error generating suggestions:", error);
+			if (!isAbortError(error) && !aborted) console.warn("Error generating suggestions:", error);
 		} finally {
 			this.finalizeSuggestions(suggestionId, consumerAgentId);
 			const runningAgents = this._runningSuggestions[consumerAgentId];
-			if (agent && runningAgents) {
-				const filteredAgents = runningAgents.filter((a) => a !== agent);
-				this._runningSuggestions[consumerAgentId] = filteredAgents;
-				if (filteredAgents.length === 0) {
-					delete this._runningSuggestions[consumerAgentId];
-					await this.notifySuggestionsFinishedLoading(consumerAgentId);
-				}
-			}
+			const remaining = runHandle ? (runningAgents ?? []).filter((a) => a !== runHandle) : runningAgents ?? [];
+			if (remaining.length === 0) {
+				delete this._runningSuggestions[consumerAgentId];
+				await this.notifySuggestionsFinishedLoading(consumerAgentId);
+			} else this._runningSuggestions[consumerAgentId] = remaining;
 		}
 	}
 	/**
@@ -1605,6 +1653,13 @@ var SuggestionEngine = class {
 	}
 };
 /**
+* Detects an `AbortController`-driven cancellation so the stateless path can
+* treat it as an expected (non-error) outcome on clear/reload.
+*/
+function isAbortError(error) {
+	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+/**
 * Type guard for dynamic suggestions config
 */
 function isDynamicSuggestionsConfig(config) {
@@ -2564,162 +2619,1144 @@ 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:");
+	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);
 	}
-	/**
-	* 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);
-		});
+	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;
+		};
 	}
-	/**
-	* Snapshot accessors
-	*/
+	const projector = args[args.length - 1];
+	const selectors = args.slice(0, -1);
+	let hasCached = false;
+	let lastInputs = [];
+	let lastResult;
+	return (state) => {
+		const inputs = selectors.map((selector) => selector(state));
+		if (hasCached && inputs.length === lastInputs.length && inputs.every((value, index) => value === lastInputs[index])) return lastResult;
+		lastInputs = inputs;
+		lastResult = projector(...inputs);
+		hasCached = true;
+		return lastResult;
+	};
+}
+/**
+* RxJS operator that maps state emissions through a selector and suppresses
+* unchanged projected values via reference equality.
+*/
+function select(selector) {
+	return (source$) => source$.pipe(map(selector), distinctUntilChanged());
+}
+/**
+* RxJS operator that filters an action stream by action creators and narrows
+* the output action type to the matched creator union.
+*
+* @throws Error when called without at least one action creator.
+*/
+function ofType(...creators) {
+	if (creators.length === 0) throw new Error("ofType requires at least one action creator");
+	const actionTypes = new Set(creators.map((creator) => creator.type));
+	return (source$) => {
+		return source$.pipe(filter((action) => {
+			return actionTypes.has(action.type);
+		}));
+	};
+}
+/**
+* Creates an effect descriptor consumed by `createStore`.
+*/
+function createEffect(factory, options = {}) {
+	if (options.dispatch === false) return {
+		run: factory,
+		dispatch: false
+	};
+	return {
+		run: factory,
+		dispatch: true
+	};
+}
+/**
+* Creates a small observable store with reducer + effects.
+*
+* Behavior:
+* - `init()` starts effects and dispatches `@@micro-redux/init`.
+* - `stop()` dispatches `@@micro-redux/stop` and unsubscribes all effects.
+* - Effect action observation is scheduled on `asapScheduler` to avoid
+*   synchronous re-entrancy in the effect loop.
+* - Any effect error triggers fail-fast teardown and errors both `actions$`
+*   and `state$`.
+*/
+function createStore(options) {
+	const reducer = options.reducer;
+	const effects = options.effects ?? [];
+	let hasFatalError = false;
+	let isRunning = false;
+	let effectSubscriptions = new Subscription();
+	let currentState = reducer(void 0, INTERNAL_BOOT_ACTION);
+	const stateSubject = new BehaviorSubject(currentState);
+	const actionsSubject = new Subject();
+	const dispatchInternal = (action) => {
+		if (hasFatalError) throw new Error("Store is in a failed state due to an effect error");
+		currentState = reducer(currentState, action);
+		stateSubject.next(currentState);
+		actionsSubject.next(action);
+	};
+	const failFast = (error) => {
+		if (hasFatalError) return;
+		hasFatalError = true;
+		isRunning = false;
+		effectSubscriptions.unsubscribe();
+		effectSubscriptions = new Subscription();
+		actionsSubject.error(error);
+		stateSubject.error(error);
+	};
+	const startEffects = () => {
+		for (const effect of effects) {
+			const scheduledActions$ = actionsSubject.asObservable().pipe(observeOn$1(asapScheduler));
+			const state$ = stateSubject.asObservable();
+			if (effect.dispatch) {
+				const subscription = effect.run(scheduledActions$, state$).subscribe({
+					next: (effectAction) => {
+						if (hasFatalError) return;
+						dispatchInternal(effectAction);
+					},
+					error: (error) => {
+						failFast(error);
+					}
+				});
+				effectSubscriptions.add(subscription);
+				continue;
+			}
+			const subscription = effect.run(scheduledActions$, state$).subscribe({ error: (error) => {
+				failFast(error);
+			} });
+			effectSubscriptions.add(subscription);
+		}
+	};
+	return {
+		dispatch(action) {
+			dispatchInternal(action);
+		},
+		getState() {
+			return currentState;
+		},
+		get state$() {
+			return stateSubject.asObservable();
+		},
+		get actions$() {
+			return actionsSubject.asObservable();
+		},
+		select(selector) {
+			return stateSubject.asObservable().pipe(select(selector));
+		},
+		init() {
+			if (hasFatalError || isRunning) return;
+			isRunning = true;
+			startEffects();
+			if (hasFatalError) return;
+			dispatchInternal({ type: INTERNAL_ACTION_TYPES.init });
+		},
+		stop() {
+			if (hasFatalError || !isRunning) return;
+			dispatchInternal({ type: INTERNAL_ACTION_TYPES.stop });
+			effectSubscriptions.unsubscribe();
+			effectSubscriptions = new Subscription();
+			isRunning = false;
+		}
+	};
+}
+
+//#endregion
+//#region src/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;
+	/**
+	* @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.
+	*/
+	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);
+	}
+};
+/**
+* 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 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 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(timeout({
+			first: REQUEST_TIMEOUT_MS$1,
+			with: () => {
+				throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+			}
+		}), map((data) => memoryRestEvents.listSucceeded({
+			sessionId,
+			memories: data.memories.filter((memory) => memory.scope === "user")
+		})), catchError((error) => {
+			if (error instanceof MemoryRouteUnavailableError) return of(memoryRestEvents.listUnavailable({ sessionId }));
+			return 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 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(timeout({
+		first: REQUEST_TIMEOUT_MS$1,
+		with: () => {
+			throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+		}
+	}), 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
+		});
+	}), catchError((error) => {
+		if (error instanceof MemoryRouteUnavailableError) return of(memoryRestEvents.credentialsUnavailable({ sessionId }));
+		return 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 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(timeout({
+		first: REQUEST_TIMEOUT_MS$1,
+		with: () => {
+			throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+		}
+	}), mergeMap((data) => of(...buildMutationSuccessActions(request, data))), catchError((error) => 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), withLatestFrom(state$), filter(([, state]) => Boolean(state.context)), map(([, state]) => memoryRestEvents.listRequested({ sessionId: state.sessionId }))));
+	const credentialsBootstrapEffect = createEffect((actions$, state$) => actions$.pipe(ofType(memoryAdapterEvents.contextChanged), withLatestFrom(state$), filter(([, state]) => Boolean(state.context)), map(([, state]) => memoryRestEvents.credentialsRequested({ sessionId: state.sessionId }))));
+	const credentialsFetchEffect = createEffect((actions$, state$) => actions$.pipe(ofType(memoryRestEvents.credentialsRequested), switchMap$1((action) => state$.pipe(map((state) => state.context), filter((context) => Boolean(context)), take(1), map((context) => ({
+		action,
+		context
+	})), takeUntil(actions$.pipe(ofType(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped))), switchMap$1(({ action: currentAction, context }) => createMemoryCredentialsFetchObservable(environment, context, currentAction.sessionId))))));
+	const store = createStore({
+		reducer: memoryReducer,
+		effects: [
+			bootstrapEffect,
+			credentialsBootstrapEffect,
+			createEffect((actions$, state$) => actions$.pipe(ofType(memoryRestEvents.listRequested), switchMap$1((action) => state$.pipe(map((state) => state.context), filter((context) => Boolean(context)), take(1), map((context) => ({
+				action,
+				context
+			})), takeUntil(actions$.pipe(ofType(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped))), switchMap$1(({ action: currentAction, context }) => createMemoryFetchObservable(environment, context, currentAction.sessionId)))))),
+			credentialsFetchEffect,
+			createEffect((actions$, state$) => actions$.pipe(ofType(memoryAdapterEvents.addRequested, memoryAdapterEvents.updateRequested, memoryAdapterEvents.removeRequested), withLatestFrom(state$), mergeMap(([action, state]) => {
+				const context = state.context;
+				const sessionId = state.sessionId;
+				if (!context?.runtimeUrl) return 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), withLatestFrom(state$), filter(([action, state]) => {
+				return action.sessionId === state.sessionId && Boolean(state.context?.wsUrl);
+			}), switchMap$1(([action, state]) => {
+				const context = state.context;
+				const { joinToken, joinCode } = action;
+				const sessionId = action.sessionId;
+				const shutdown$ = actions$.pipe(ofType(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped));
+				return defer(() => {
+					const socket$ = ɵphoenixSocket$({
+						url: context.wsUrl,
+						options: {
+							params: { join_token: joinToken },
+							reconnectAfterMs: phoenixExponentialBackoff(100, 1e4),
+							rejoinAfterMs: phoenixExponentialBackoff(1e3, 3e4)
+						}
+					}).pipe(shareReplay({
+						bufferSize: 1,
+						refCount: true
+					}));
+					const channel$ = ɵphoenixChannel$({
+						socket$,
+						topic: `user_meta:memories:${joinCode}`
+					}).pipe(shareReplay({
+						bufferSize: 1,
+						refCount: true
+					}));
+					const fatalSocketShutdown$ = ɵobservePhoenixSocketHealth$(ɵobservePhoenixSocketSignals$(socket$).pipe(share()), MAX_SOCKET_RETRIES$1).pipe(catchError(() => {
+						console.warn(`[memory] WebSocket failed after ${MAX_SOCKET_RETRIES$1} attempts, giving up`);
+						return of(void 0);
+					}), share());
+					const fatalStatus$ = fatalSocketShutdown$.pipe(map(() => memoryDomainEvents.realtimeUnavailable({ sessionId })));
+					const metadata$ = channel$.pipe(switchMap$1(({ channel }) => ɵobservePhoenixEvent$(channel, MEMORY_METADATA_EVENT)), map((event) => mapMemoryMetadataEvent(event, action.sessionId)));
+					const join$ = ɵjoinPhoenixChannel$(channel$).pipe(concatWith(of(memoryDomainEvents.realtimeConnected({ sessionId }))), catchError((error) => {
+						console.warn(`[memory] failed to join user_meta:memories:${joinCode}`, error);
+						return of(memoryDomainEvents.realtimeUnavailable({ sessionId }));
+					}));
+					return merge(of(memoryDomainEvents.realtimeConnecting({ sessionId })), metadata$, join$, fatalStatus$).pipe(takeUntil(merge(shutdown$, fatalSocketShutdown$.pipe(observeOn(asapScheduler)))), finalize(() => {}));
+				});
+			})))
+		]
+	});
+	function trackMutation(dispatchAction, extract) {
+		const { requestId } = dispatchAction;
+		const resultPromise = firstValueFrom(merge(store.actions$.pipe(ofType(memoryRestEvents.mutationFinished), filter((action) => action.outcome.requestId === requestId), map((action) => action.outcome)), store.actions$.pipe(ofType(memoryAdapterEvents.stopped), map(() => ({
+			requestId,
+			sessionId: store.getState().sessionId,
+			ok: false,
+			error: /* @__PURE__ */ new Error("Memory store stopped before mutation completed")
+		})))).pipe(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 = firstValueFrom(merge(store.actions$.pipe(ofType(memoryRestEvents.listSucceeded, memoryRestEvents.listFailed, memoryRestEvents.listUnavailable), filter((action) => action.sessionId === sessionId)), store.actions$.pipe(ofType(memoryAdapterEvents.stopped)), store.actions$.pipe(ofType(memoryAdapterEvents.contextChanged))).pipe(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;
+	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.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);
+				});
+				const currentAgentIds = new Set(Object.keys(agents));
+				for (const agentId of Object.keys(this.threadStoreRegistry.getAll())) if (this.previousAgentIds.has(agentId) && !currentAgentIds.has(agentId)) try {
+					this.threadStoreRegistry.unregister(agentId);
+				} catch (err) {
+					console.error(`CopilotKitCore.onAgentsChanged: threadStoreRegistry.unregister failed for "${agentId}":`, err);
+				}
+				for (const agentId of this.previousAgentIds) if (!currentAgentIds.has(agentId)) try {
+					this.stateManager.unsubscribeFromAgent(agentId);
+				} catch (err) {
+					console.error(`CopilotKitCore.onAgentsChanged: stateManager.unsubscribeFromAgent failed for "${agentId}":`, err);
+				}
+				this.previousAgentIds = currentAgentIds;
+			}
+		});
+	}
+	/**
+	* Internal method used by delegate classes and subclasses to notify subscribers
+	*/
+	async notifySubscribers(handler, errorMessage) {
+		await Promise.all(Array.from(this.subscribers).map(async (subscriber) => {
+			try {
+				await handler(subscriber);
+			} catch (error) {
+				console.error(errorMessage, error);
+			}
+		}));
+	}
+	/**
+	* Internal method used by delegate classes to emit errors
+	*/
+	async emitError({ error, code, context = {} }) {
+		await this.notifySubscribers((subscriber) => 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;
 	}
@@ -2803,6 +3840,9 @@ var CopilotKitCore = class {
 	get threadEndpoints() {
 		return this.agentRegistry.threadEndpoints;
 	}
+	get suggestions() {
+		return this.agentRegistry.suggestions;
+	}
 	get a2uiEnabled() {
 		return this.agentRegistry.a2uiEnabled;
 	}
@@ -2856,6 +3896,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,
@@ -2961,6 +4002,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) {
@@ -3123,510 +4204,253 @@ 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
-			});
-		}
+			latestStateParams = params;
+			throttler.maybeExecute();
+		};
+		const subscription = agent.subscribe(wrappedSubscriber);
+		return { unsubscribe: () => {
+			active = false;
+			throttler.cancel();
+			subscription.unsubscribe();
+		} };
 	}
-	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;
-		}
+	/**
+	* Agent connectivity (delegated to RunHandler)
+	*/
+	async connectAgent(params) {
+		return this.runHandler.connectAgent(params);
 	}
-	if (shouldCloseParens) {
-		const openParens = (result.match(/\(/g) || []).length;
-		const closeParens = (result.match(/\)/g) || []).length;
-		if (openParens > closeParens) result += ")".repeat(openParens - closeParens);
+	stopAgent(params) {
+		this.runHandler.abortCurrentRun();
+		params.agent.abortRun();
 	}
-	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, () => ({}));
+	async runAgent(params) {
+		return this.runHandler.runAgent(params);
 	}
-	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);
+	/**
+	* 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);
 	}
-	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;
-		};
+	/**
+	* State management (delegated to StateManager)
+	*/
+	getStateByRun(agentId, threadId, runId) {
+		return this.stateManager.getStateByRun(agentId, threadId, runId);
 	}
-	const projector = args[args.length - 1];
-	const selectors = args.slice(0, -1);
-	let hasCached = false;
-	let lastInputs = [];
-	let lastResult;
-	return (state) => {
-		const inputs = selectors.map((selector) => selector(state));
-		if (hasCached && inputs.length === lastInputs.length && inputs.every((value, index) => value === lastInputs[index])) return lastResult;
-		lastInputs = inputs;
-		lastResult = projector(...inputs);
-		hasCached = true;
-		return lastResult;
-	};
-}
-/**
-* RxJS operator that maps state emissions through a selector and suppresses
-* unchanged projected values via reference equality.
-*/
-function select(selector) {
-	return (source$) => source$.pipe(map(selector), distinctUntilChanged());
-}
-/**
-* RxJS operator that filters an action stream by action creators and narrows
-* the output action type to the matched creator union.
-*
-* @throws Error when called without at least one action creator.
-*/
-function ofType(...creators) {
-	if (creators.length === 0) throw new Error("ofType requires at least one action creator");
-	const actionTypes = new Set(creators.map((creator) => creator.type));
-	return (source$) => {
-		return source$.pipe(filter((action) => {
-			return actionTypes.has(action.type);
-		}));
-	};
-}
-/**
-* Creates an effect descriptor consumed by `createStore`.
-*/
-function createEffect(factory, options = {}) {
-	if (options.dispatch === false) return {
-		run: factory,
-		dispatch: false
-	};
-	return {
-		run: factory,
-		dispatch: true
-	};
-}
+	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
 /**
-* 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$`.
+* Status of a tool call execution
 */
-function createStore(options) {
-	const reducer = options.reducer;
-	const effects = options.effects ?? [];
-	let hasFatalError = false;
-	let isRunning = false;
-	let effectSubscriptions = new Subscription();
-	let currentState = reducer(void 0, INTERNAL_BOOT_ACTION);
-	const stateSubject = new BehaviorSubject(currentState);
-	const actionsSubject = new Subject();
-	const dispatchInternal = (action) => {
-		if (hasFatalError) throw new Error("Store is in a failed state due to an effect error");
-		currentState = reducer(currentState, action);
-		stateSubject.next(currentState);
-		actionsSubject.next(action);
-	};
-	const failFast = (error) => {
-		if (hasFatalError) return;
-		hasFatalError = true;
-		isRunning = false;
-		effectSubscriptions.unsubscribe();
-		effectSubscriptions = new Subscription();
-		actionsSubject.error(error);
-		stateSubject.error(error);
-	};
-	const startEffects = () => {
-		for (const effect of effects) {
-			const scheduledActions$ = actionsSubject.asObservable().pipe(observeOn(asapScheduler));
-			const state$ = stateSubject.asObservable();
-			if (effect.dispatch) {
-				const subscription = effect.run(scheduledActions$, state$).subscribe({
-					next: (effectAction) => {
-						if (hasFatalError) return;
-						dispatchInternal(effectAction);
-					},
-					error: (error) => {
-						failFast(error);
-					}
+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 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
@@ -3641,6 +4465,7 @@ const initialThreadState = {
 	isLoading: false,
 	isFetchingNextPage: false,
 	error: null,
+	fetchMoreError: null,
 	context: null,
 	sessionId: 0,
 	metadataCredentialsRequested: false,
@@ -3726,6 +4551,7 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	isLoading: Boolean(context),
 	isFetchingNextPage: false,
 	error: null,
+	fetchMoreError: null,
 	metadataCredentialsRequested: false,
 	metadataJoinCode: null,
 	nextCursor: null,
@@ -3737,6 +4563,7 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 	isLoading: false,
 	isFetchingNextPage: false,
 	error: null,
+	fetchMoreError: null,
 	metadataCredentialsRequested: false,
 	metadataJoinCode: null,
 	nextCursor: null,
@@ -3747,7 +4574,8 @@ 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;
@@ -3757,6 +4585,7 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 		threads: sortThreadsByRecency(threads),
 		isLoading: false,
 		error: null,
+		fetchMoreError: null,
 		metadataJoinCode: joinCode,
 		metadataCredentialsRequested: joinCodeChanged ? false : state.metadataCredentialsRequested,
 		nextCursor
@@ -3776,6 +4605,7 @@ const threadReducer = createReducer(initialThreadState, on(threadAdapterEvents.c
 		...state,
 		threads: merged,
 		isFetchingNextPage: false,
+		fetchMoreError: null,
 		nextCursor
 	};
 }), on(threadRestEvents.nextPageFailed, (state, { sessionId, error }) => {
@@ -3783,7 +4613,7 @@ 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;
@@ -3801,7 +4631,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);
@@ -3930,6 +4761,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)
@@ -3939,6 +4771,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;
@@ -4312,6 +5145,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;
@@ -4369,5 +5203,5 @@ function ɵisCopilotKitFeature(name) {
 }
 
 //#endregion
-export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, IntelligenceAgent, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, completePartialMarkdown, createActionGroup, createEffect, createReducer, createSelector, createStore, empty, ensureObjectArgs, isRunCompletionAware, ofType, on, parseToolArguments, props, select, ɵCOPILOTKIT_FEATURES, ɵMAX_SOCKET_RETRIES, ɵcreateThreadSelectors, createThreadStore as ɵcreateThreadStore, ɵisCopilotKitFeature, ɵjoinPhoenixChannel$, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
+export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, IntelligenceAgent, MEMORY_ERROR_REGISTRY, MemoryError, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, completePartialMarkdown, createActionGroup, createEffect, createReducer, createSelector, createStore, empty, ensureObjectArgs, isAbortError, isRunCompletionAware, ofType, on, parseToolArguments, props, select, ɵCOPILOTKIT_FEATURES, ɵMAX_SOCKET_RETRIES, createMemoryStore as ɵcreateMemoryStore, ɵcreateThreadSelectors, createThreadStore as ɵcreateThreadStore, ɵisCopilotKitFeature, isRetryableStatus as ɵisRetryableMemoryStatus, ɵjoinPhoenixChannel$, ɵmapMemoryMetadataEvent, ɵmemoryAdapterEvents, ɵmemoryDomainEvents, ɵmemoryReducer, ɵmemoryRestEvents, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesIsMutating, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
 //# sourceMappingURL=index.mjs.map