@copilotkit/core 1.62.2 → 1.62.3

package/dist/index.umd.js

@@ -1,8 +1,8 @@
 (function(global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('@tanstack/pacer'), require('@ag-ui/client'), require('@copilotkit/shared'), require('rxjs'), require('rxjs/operators'), require('phoenix'), require('zod-to-json-schema')) :
-  typeof define === 'function' && define.amd ? define(['exports', '@tanstack/pacer', '@ag-ui/client', '@copilotkit/shared', 'rxjs', 'rxjs/operators', 'phoenix', 'zod-to-json-schema'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitCore = {}), global._tanstack_pacer,global.AgUIClient,global.CopilotKitShared,global.rxjs,global.rxjs.operators,global.phoenix,global.zodToJsonSchema));
-})(this, function(exports, _tanstack_pacer, _ag_ui_client, _copilotkit_shared, rxjs, rxjs_operators, phoenix, zod_to_json_schema) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('@tanstack/pacer'), require('@ag-ui/client'), require('@copilotkit/shared'), require('rxjs'), require('rxjs/operators'), require('phoenix'), require('zod-to-json-schema'), require('rxjs/fetch')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@tanstack/pacer', '@ag-ui/client', '@copilotkit/shared', 'rxjs', 'rxjs/operators', 'phoenix', 'zod-to-json-schema', 'rxjs/fetch'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitCore = {}), global._tanstack_pacer,global.AgUIClient,global.CopilotKitShared,global.rxjs,global.rxjs.operators,global.phoenix,global.zodToJsonSchema,global.rxjs_fetch));
+})(this, function(exports, _tanstack_pacer, _ag_ui_client, _copilotkit_shared, rxjs, rxjs_operators, phoenix, zod_to_json_schema, rxjs_fetch) {
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/utils/phoenix-observable.ts
@@ -646,12 +646,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	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((0, rxjs_operators.catchError)((error) => {
-			if (isZodError(error) || isAbortError(error)) return rxjs.EMPTY;
+			if (isZodError(error) || isAbortError$1(error)) return rxjs.EMPTY;
 			throw error;
 		}));
 	}
@@ -1013,6 +1013,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			_defineProperty(this, "_runtimeMode", _copilotkit_shared.RUNTIME_MODE_SSE);
 			_defineProperty(this, "_intelligence", void 0);
 			_defineProperty(this, "_threadEndpoints", void 0);
+			_defineProperty(this, "_suggestions", void 0);
 			_defineProperty(this, "_a2uiEnabled", false);
 			_defineProperty(this, "_a2uiAgents", void 0);
 			_defineProperty(this, "_openGenerativeUIEnabled", false);
@@ -1050,6 +1051,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		get threadEndpoints() {
 			return this._threadEndpoints;
 		}
+		get suggestions() {
+			return this._suggestions;
+		}
 		get a2uiEnabled() {
 			return this._a2uiEnabled;
 		}
@@ -1237,6 +1241,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				this._runtimeMode = _copilotkit_shared.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;
@@ -1286,6 +1291,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				this._runtimeMode = (_runtimeInfoResponse$3 = runtimeInfoResponse.mode) !== null && _runtimeInfoResponse$3 !== void 0 ? _runtimeInfoResponse$3 : _copilotkit_shared.RUNTIME_MODE_SSE;
 				this._intelligence = runtimeInfoResponse.intelligence;
 				this._threadEndpoints = runtimeInfoResponse.threadEndpoints;
+				this._suggestions = runtimeInfoResponse.suggestions;
 				const a2uiInfo = runtimeInfoResponse.a2ui;
 				this._a2uiEnabled = (_ref = (_a2uiInfo$enabled = a2uiInfo === null || a2uiInfo === void 0 ? void 0 : a2uiInfo.enabled) !== null && _a2uiInfo$enabled !== void 0 ? _a2uiInfo$enabled : runtimeInfoResponse.a2uiEnabled) !== null && _ref !== void 0 ? _ref : false;
 				this._a2uiAgents = (a2uiInfo === null || a2uiInfo === void 0 ? void 0 : a2uiInfo.enabled) ? a2uiInfo.agents : void 0;
@@ -1301,6 +1307,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 				this._runtimeMode = _copilotkit_shared.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;
@@ -1551,39 +1558,82 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			};
 		}
 		/**
-		* 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 {
-				var _config$providerAgent, _this$_runningSuggest3, _config$minSuggestion, _config$maxSuggestion;
-				const suggestionsProviderAgent = this.core.getAgent((_config$providerAgent = config.providerAgentId) !== null && _config$providerAgent !== void 0 ? _config$providerAgent : "default");
-				if (!suggestionsProviderAgent) throw new Error(`Suggestions provider agent not found: ${config.providerAgentId}`);
-				const suggestionsConsumerAgent = this.core.getAgent(consumerAgentId);
+				var _config$providerAgent, _config$minSuggestion, _config$maxSuggestion, _suggestionsConsumerA, _this$_runningSuggest3;
+				const friends = this.core;
+				const resolvedProviderAgentId = (_config$providerAgent = config.providerAgentId) !== null && _config$providerAgent !== void 0 ? _config$providerAgent : "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$minSuggestion = config.minSuggestions) !== null && _config$minSuggestion !== void 0 ? _config$minSuggestion : 1} and at most ${(_config$maxSuggestion = config.maxSuggestions) !== null && _config$maxSuggestion !== void 0 ? _config$maxSuggestion : 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$_runningSuggest3 = this._runningSuggestions[consumerAgentId]) !== null && _this$_runningSuggest3 !== void 0 ? _this$_runningSuggest3 : [], agent];
-				agent.addMessage({
+				const seededMessages = JSON.parse(JSON.stringify(suggestionsConsumerAgent.messages));
+				const seededState = JSON.parse(JSON.stringify((_suggestionsConsumerA = suggestionsConsumerAgent.state) !== null && _suggestionsConsumerA !== void 0 ? _suggestionsConsumerA : {}));
+				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 _ag_ui_client.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$_runningSuggest3 = this._runningSuggestions[consumerAgentId]) !== null && _this$_runningSuggest3 !== void 0 ? _this$_runningSuggest3 : [], 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$minSuggestion = config.minSuggestions) !== null && _config$minSuggestion !== void 0 ? _config$minSuggestion : 1} and at most ${(_config$maxSuggestion = config.maxSuggestions) !== null && _config$maxSuggestion !== void 0 ? _config$maxSuggestion : 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" }
@@ -1594,18 +1644,15 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 					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 !== null && runningAgents !== void 0 ? runningAgents : []).filter((a) => a !== runHandle) : runningAgents !== null && runningAgents !== void 0 ? runningAgents : [];
+				if (remaining.length === 0) {
+					delete this._runningSuggestions[consumerAgentId];
+					await this.notifySuggestionsFinishedLoading(consumerAgentId);
+				} else this._runningSuggestions[consumerAgentId] = remaining;
 			}
 		}
 		/**
@@ -1743,6 +1790,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		}
 	};
 	/**
+	* 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) {
@@ -2716,161 +2770,1139 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	};
 
 //#endregion
-//#region src/core/core.ts
-	let CopilotKitCoreErrorCode = /* @__PURE__ */ function(CopilotKitCoreErrorCode) {
-		CopilotKitCoreErrorCode["RUNTIME_INFO_FETCH_FAILED"] = "runtime_info_fetch_failed";
-		CopilotKitCoreErrorCode["AGENT_CONNECT_FAILED"] = "agent_connect_failed";
-		CopilotKitCoreErrorCode["AGENT_RUN_FAILED"] = "agent_run_failed";
-		CopilotKitCoreErrorCode["AGENT_RUN_FAILED_EVENT"] = "agent_run_failed_event";
-		CopilotKitCoreErrorCode["AGENT_RUN_ERROR_EVENT"] = "agent_run_error_event";
-		CopilotKitCoreErrorCode["TOOL_ARGUMENT_PARSE_FAILED"] = "tool_argument_parse_failed";
-		CopilotKitCoreErrorCode["TOOL_HANDLER_FAILED"] = "tool_handler_failed";
-		CopilotKitCoreErrorCode["TOOL_NOT_FOUND"] = "tool_not_found";
-		CopilotKitCoreErrorCode["AGENT_NOT_FOUND"] = "agent_not_found";
-		/**
-		* Emitted when an agent run fails because the thread is already locked
-		* by another active run.
-		*
-		* @example
-		* ```tsx
-		* <CopilotKitProvider
-		*   onError={({ code, error, context }) => {
-		*     if (code === "agent_thread_locked") {
-		*       // Show "Agent is busy, retry?" UI
-		*     }
-		*   }}
-		* />
-		* ```
-		*/
-		CopilotKitCoreErrorCode["AGENT_THREAD_LOCKED"] = "agent_thread_locked";
-		CopilotKitCoreErrorCode["TRANSCRIPTION_FAILED"] = "transcription_failed";
-		CopilotKitCoreErrorCode["TRANSCRIPTION_SERVICE_NOT_CONFIGURED"] = "transcription_service_not_configured";
-		CopilotKitCoreErrorCode["TRANSCRIPTION_INVALID_AUDIO"] = "transcription_invalid_audio";
-		CopilotKitCoreErrorCode["TRANSCRIPTION_RATE_LIMITED"] = "transcription_rate_limited";
-		CopilotKitCoreErrorCode["TRANSCRIPTION_AUTH_FAILED"] = "transcription_auth_failed";
-		CopilotKitCoreErrorCode["TRANSCRIPTION_NETWORK_ERROR"] = "transcription_network_error";
-		CopilotKitCoreErrorCode["SUBSCRIBER_CALLBACK_FAILED"] = "subscriber_callback_failed";
-		return CopilotKitCoreErrorCode;
-	}({});
+//#region src/utils/micro-redux.ts
+	const INTERNAL_ACTION_TYPES = {
+		boot: "@@micro-redux/boot",
+		init: "@@micro-redux/init",
+		stop: "@@micro-redux/stop"
+	};
+	const INTERNAL_BOOT_ACTION = { type: INTERNAL_ACTION_TYPES.boot };
 	/**
-	* Runtime allowlist derived from {@link SUBSCRIBE_TO_AGENT_KEYS}. Hoisted
-	* to module scope so the Set is allocated once, not per-subscription.
+	* Builds a typed action creator from a type string and payload factory.
 	*/
-	const ALLOWED_KEYS = new Set([
-		"onMessagesChanged",
-		"onStateChanged",
-		"onRunInitialized",
-		"onRunFinalized",
-		"onRunFailed",
-		"onRunErrorEvent"
-	]);
-	let CopilotKitCoreRuntimeConnectionStatus = /* @__PURE__ */ function(CopilotKitCoreRuntimeConnectionStatus) {
-		CopilotKitCoreRuntimeConnectionStatus["Disconnected"] = "disconnected";
-		CopilotKitCoreRuntimeConnectionStatus["Connected"] = "connected";
-		CopilotKitCoreRuntimeConnectionStatus["Connecting"] = "connecting";
-		CopilotKitCoreRuntimeConnectionStatus["Error"] = "error";
-		return CopilotKitCoreRuntimeConnectionStatus;
-	}({});
+	function createTypedActionCreator(type, factory) {
+		const creator = ((...args) => ({
+			...factory(...args),
+			type
+		}));
+		creator.type = type;
+		creator.match = (action) => action.type === type;
+		return creator;
+	}
 	/**
-	* Normalize a header map to the internal invariant: a `Record<string, string>`
-	* with no `null`/`undefined` values. Entries whose value is `null`/`undefined`
-	* are dropped (this is how a header is cleared). Shared by the constructor and
-	* `setHeaders` so both write paths into `_headers` enforce the same invariant.
+	* Declares a payload-based action config for `createActionGroup`.
+	*
+	* @example
+	* ```ts
+	* const actions = createActionGroup("User", {
+	*   loaded: props<{ id: string }>(),
+	* });
+	* ```
 	*/
-	function normalizeHeaders(headers) {
-		return Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] != null));
+	function props() {
+		return { kind: "props" };
 	}
-	var CopilotKitCore = class {
-		constructor({ runtimeUrl, runtimeTransport = "auto", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
-			_defineProperty(this, "_headers", void 0);
-			_defineProperty(this, "_credentials", void 0);
-			_defineProperty(this, "_properties", void 0);
-			_defineProperty(this, "_defaultThrottleMs", void 0);
-			_defineProperty(this, "_debug", void 0);
-			_defineProperty(this, "subscribers", /* @__PURE__ */ new Set());
-			_defineProperty(this, "agentRegistry", void 0);
-			_defineProperty(this, "contextStore", void 0);
-			_defineProperty(this, "suggestionEngine", void 0);
-			_defineProperty(this, "runHandler", void 0);
-			_defineProperty(this, "stateManager", void 0);
-			_defineProperty(this, "threadStoreRegistry", void 0);
-			_defineProperty(this, "previousAgentIds", /* @__PURE__ */ new Set());
-			this._headers = normalizeHeaders(headers);
-			this._credentials = credentials;
-			this._properties = properties;
-			this._debug = debug;
-			this.agentRegistry = new AgentRegistry(this);
-			this.contextStore = new ContextStore(this);
-			this.suggestionEngine = new SuggestionEngine(this);
-			this.runHandler = new RunHandler(this);
-			this.stateManager = new StateManager(this);
-			this.threadStoreRegistry = new ThreadStoreRegistry(this);
-			this.agentRegistry.initialize(agents__unsafe_dev_only);
-			this.runHandler.initialize(tools);
-			this.suggestionEngine.initialize(suggestionsConfig);
-			this.stateManager.initialize();
-			this.agentRegistry.setRuntimeTransport(runtimeTransport);
-			this.agentRegistry.setRuntimeUrl(runtimeUrl);
-			this.previousAgentIds = new Set(Object.keys(agents__unsafe_dev_only));
-			this.subscribe({ onAgentsChanged: ({ agents }) => {
-				Object.values(agents).forEach((agent) => {
-					if (agent.agentId) this.stateManager.subscribeToAgent(agent);
-				});
-				const currentAgentIds = new Set(Object.keys(agents));
-				for (const agentId of Object.keys(this.threadStoreRegistry.getAll())) if (this.previousAgentIds.has(agentId) && !currentAgentIds.has(agentId)) try {
-					this.threadStoreRegistry.unregister(agentId);
-				} catch (err) {
-					console.error(`CopilotKitCore.onAgentsChanged: threadStoreRegistry.unregister failed for "${agentId}":`, err);
-				}
-				for (const agentId of this.previousAgentIds) if (!currentAgentIds.has(agentId)) try {
-					this.stateManager.unsubscribeFromAgent(agentId);
-				} catch (err) {
-					console.error(`CopilotKitCore.onAgentsChanged: stateManager.unsubscribeFromAgent failed for "${agentId}":`, err);
-				}
-				this.previousAgentIds = currentAgentIds;
-			} });
-		}
-		/**
-		* Internal method used by delegate classes and subclasses to notify subscribers
-		*/
-		async notifySubscribers(handler, errorMessage) {
-			await Promise.all(Array.from(this.subscribers).map(async (subscriber) => {
-				try {
-					await handler(subscriber);
-				} catch (error) {
-					console.error(errorMessage, error);
-				}
-			}));
+	/**
+	* 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) => {
-				var _subscriber$onError;
-				return (_subscriber$onError = subscriber.onError) === null || _subscriber$onError === void 0 ? void 0 : _subscriber$onError.call(subscriber, {
-					copilotkit: this,
-					error,
-					code,
-					context
-				});
-			}, "Subscriber onError error:");
+		return group;
+	}
+	/**
+	* Registers one reducer handler for one or more action creators.
+	*
+	* @throws Error when called without at least one action creator and reducer.
+	*/
+	function on(...args) {
+		if (args.length < 2) throw new Error("on requires at least one action creator and one reducer");
+		const reducer = args[args.length - 1];
+		return {
+			creators: args.slice(0, -1),
+			reducer
+		};
+	}
+	/**
+	* Creates a reducer from an initial state and `on(...)` handler entries.
+	*
+	* Unknown action types return the current state unchanged.
+	*/
+	function createReducer(initialState, ...entries) {
+		const reducerMap = /* @__PURE__ */ new Map();
+		for (const entry of entries) for (const creator of entry.creators) {
+			var _reducerMap$get;
+			const handlers = (_reducerMap$get = reducerMap.get(creator.type)) !== null && _reducerMap$get !== void 0 ? _reducerMap$get : [];
+			handlers.push(entry.reducer);
+			reducerMap.set(creator.type, handlers);
 		}
-		/**
-		* 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 !== null && state !== void 0 ? state : initialState;
+			const handlers = reducerMap.get(action.type);
+			if (!handlers || handlers.length === 0) return currentState;
+			let nextState = currentState;
+			for (const handler of handlers) nextState = handler(nextState, action);
+			return nextState;
+		};
+	}
+	/**
+	* Creates a selector that caches and reuses the last computed result
+	* when all input references are unchanged.
+	*/
+	function createSelector(...args) {
+		if (args.length === 1) {
+			const projector = args[0];
+			let hasCached = false;
+			let lastState;
+			let lastResult;
+			return (state) => {
+				if (hasCached && state === lastState) return lastResult;
+				lastState = state;
+				lastResult = projector(state);
+				hasCached = true;
+				return lastResult;
+			};
 		}
-		/**
-		* Snapshot accessors
-		*/
-		get context() {
-			return this.contextStore.context;
+		const projector = args[args.length - 1];
+		const selectors = args.slice(0, -1);
+		let hasCached = false;
+		let lastInputs = [];
+		let lastResult;
+		return (state) => {
+			const inputs = selectors.map((selector) => selector(state));
+			if (hasCached && inputs.length === lastInputs.length && inputs.every((value, index) => value === lastInputs[index])) return lastResult;
+			lastInputs = inputs;
+			lastResult = projector(...inputs);
+			hasCached = true;
+			return lastResult;
+		};
+	}
+	/**
+	* RxJS operator that maps state emissions through a selector and suppresses
+	* unchanged projected values via reference equality.
+	*/
+	function select(selector) {
+		return (source$) => source$.pipe((0, rxjs_operators.map)(selector), (0, rxjs_operators.distinctUntilChanged)());
+	}
+	/**
+	* RxJS operator that filters an action stream by action creators and narrows
+	* the output action type to the matched creator union.
+	*
+	* @throws Error when called without at least one action creator.
+	*/
+	function ofType(...creators) {
+		if (creators.length === 0) throw new Error("ofType requires at least one action creator");
+		const actionTypes = new Set(creators.map((creator) => creator.type));
+		return (source$) => {
+			return source$.pipe((0, rxjs_operators.filter)((action) => {
+				return actionTypes.has(action.type);
+			}));
+		};
+	}
+	/**
+	* Creates an effect descriptor consumed by `createStore`.
+	*/
+	function createEffect(factory, options = {}) {
+		if (options.dispatch === false) return {
+			run: factory,
+			dispatch: false
+		};
+		return {
+			run: factory,
+			dispatch: true
+		};
+	}
+	/**
+	* Creates a small observable store with reducer + effects.
+	*
+	* Behavior:
+	* - `init()` starts effects and dispatches `@@micro-redux/init`.
+	* - `stop()` dispatches `@@micro-redux/stop` and unsubscribes all effects.
+	* - Effect action observation is scheduled on `asapScheduler` to avoid
+	*   synchronous re-entrancy in the effect loop.
+	* - Any effect error triggers fail-fast teardown and errors both `actions$`
+	*   and `state$`.
+	*/
+	function createStore(options) {
+		var _options$effects;
+		const reducer = options.reducer;
+		const effects = (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : [];
+		let hasFatalError = false;
+		let isRunning = false;
+		let effectSubscriptions = new rxjs.Subscription();
+		let currentState = reducer(void 0, INTERNAL_BOOT_ACTION);
+		const stateSubject = new rxjs.BehaviorSubject(currentState);
+		const actionsSubject = new rxjs.Subject();
+		const dispatchInternal = (action) => {
+			if (hasFatalError) throw new Error("Store is in a failed state due to an effect error");
+			currentState = reducer(currentState, action);
+			stateSubject.next(currentState);
+			actionsSubject.next(action);
+		};
+		const failFast = (error) => {
+			if (hasFatalError) return;
+			hasFatalError = true;
+			isRunning = false;
+			effectSubscriptions.unsubscribe();
+			effectSubscriptions = new rxjs.Subscription();
+			actionsSubject.error(error);
+			stateSubject.error(error);
+		};
+		const startEffects = () => {
+			for (const effect of effects) {
+				const scheduledActions$ = actionsSubject.asObservable().pipe((0, rxjs_operators.observeOn)(rxjs.asapScheduler));
+				const state$ = stateSubject.asObservable();
+				if (effect.dispatch) {
+					const subscription = effect.run(scheduledActions$, state$).subscribe({
+						next: (effectAction) => {
+							if (hasFatalError) return;
+							dispatchInternal(effectAction);
+						},
+						error: (error) => {
+							failFast(error);
+						}
+					});
+					effectSubscriptions.add(subscription);
+					continue;
+				}
+				const subscription = effect.run(scheduledActions$, state$).subscribe({ error: (error) => {
+					failFast(error);
+				} });
+				effectSubscriptions.add(subscription);
+			}
+		};
+		return {
+			dispatch(action) {
+				dispatchInternal(action);
+			},
+			getState() {
+				return currentState;
+			},
+			get state$() {
+				return stateSubject.asObservable();
+			},
+			get actions$() {
+				return actionsSubject.asObservable();
+			},
+			select(selector) {
+				return stateSubject.asObservable().pipe(select(selector));
+			},
+			init() {
+				if (hasFatalError || isRunning) return;
+				isRunning = true;
+				startEffects();
+				if (hasFatalError) return;
+				dispatchInternal({ type: INTERNAL_ACTION_TYPES.init });
+			},
+			stop() {
+				if (hasFatalError || !isRunning) return;
+				dispatchInternal({ type: INTERNAL_ACTION_TYPES.stop });
+				effectSubscriptions.unsubscribe();
+				effectSubscriptions = new rxjs.Subscription();
+				isRunning = false;
+			}
+		};
+	}
+
+//#endregion
+//#region src/memory-errors.ts
+/**
+	* The memory error registry: the single source of truth for memory error
+	* metadata. Keyed by `code` so a code maps to exactly one category/retryable
+	* default.
+	*
+	* Categories/retryable rationale:
+	* - List/credentials/mutation failures are `dependency` (the runtime/platform
+	*   the store calls failed). A 5xx is transient (`retryable: true`); a 4xx is
+	*   caller-caused, so the helpers below downgrade those to non-retryable.
+	* - Timeouts are `dependency` and `retryable: true` (the request may simply be
+	*   slow).
+	*/
+	const MEMORY_ERROR_REGISTRY = Object.freeze({
+		MEMORY_LIST_FAILED: {
+			code: "MEMORY_LIST_FAILED",
+			category: "dependency",
+			retryable: true,
+			message: "Failed to fetch memories",
+			docsPath: "docs/errors/memory.md#memory_list_failed"
+		},
+		MEMORY_CREDENTIALS_FAILED: {
+			code: "MEMORY_CREDENTIALS_FAILED",
+			category: "dependency",
+			retryable: true,
+			message: "Failed to fetch memory subscribe credentials",
+			docsPath: "docs/errors/memory.md#memory_credentials_failed"
+		},
+		MEMORY_MUTATION_FAILED: {
+			code: "MEMORY_MUTATION_FAILED",
+			category: "dependency",
+			retryable: true,
+			message: "Memory mutation request failed",
+			docsPath: "docs/errors/memory.md#memory_mutation_failed"
+		},
+		MEMORY_REQUEST_TIMEOUT: {
+			code: "MEMORY_REQUEST_TIMEOUT",
+			category: "dependency",
+			retryable: true,
+			message: "Request timed out",
+			docsPath: "docs/errors/memory.md#memory_request_timeout"
+		}
+	});
+	/**
+	* An `Error` carrying a stable memory error `code`, `category`, and `retryable`
+	* flag so consumers and observability can branch on it without string-matching
+	* the message.
+	*
+	* It is a real `Error` subclass: `instanceof Error` is true, so the public
+	* `MemoryState.error: Error | null` contract (and the `error: Error | null`
+	* surfaced by `useMemories` / `injectMemories`) holds unchanged. Existing
+	* consumers that only read `.message` keep working; the richer fields are
+	* additive.
+	*/
+	var MemoryError = class MemoryError extends Error {
+		/**
+		* @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) {
+			var _options$message, _options$retryable;
+			const entry = MEMORY_ERROR_REGISTRY[code];
+			super((_options$message = options === null || options === void 0 ? void 0 : options.message) !== null && _options$message !== void 0 ? _options$message : entry.message, { cause: options === null || options === void 0 ? void 0 : options.cause });
+			_defineProperty(this, "code", void 0);
+			_defineProperty(this, "category", void 0);
+			_defineProperty(this, "retryable", void 0);
+			this.name = "MemoryError";
+			this.code = code;
+			this.category = entry.category;
+			this.retryable = (_options$retryable = options === null || options === void 0 ? void 0 : options.retryable) !== null && _options$retryable !== void 0 ? _options$retryable : entry.retryable;
+			Object.setPrototypeOf(this, MemoryError.prototype);
+		}
+	};
+	/**
+	* Narrows an HTTP status to whether the failure is worth retrying: a 5xx (or a
+	* missing/0 status) is a transient dependency failure and retryable; a 4xx is
+	* caller-caused and not. Used so a `MEMORY_LIST_FAILED`/`MEMORY_MUTATION_FAILED`
+	* carries an accurate `retryable` flag derived from the response status.
+	*/
+	function isRetryableStatus(status) {
+		return !(Number.isInteger(status) && status >= 400 && status <= 499);
+	}
+
+//#endregion
+//#region src/memory.ts
+	const MEMORIES_PATH = "/memories";
+	const MEMORIES_SUBSCRIBE_PATH = "/memories/subscribe";
+	const REQUEST_TIMEOUT_MS$1 = 15e3;
+	/** Consecutive socket errors tolerated before the realtime stream gives up. */
+	const MAX_SOCKET_RETRIES$1 = 5;
+	/**
+	* HTTP status codes that indicate memory routes are not configured (non-fatal).
+	* 404/501 mean the route is absent/unimplemented; 422 is the runtime's
+	* MISSING_INTELLIGENCE signal (intelligence not configured on the deployment —
+	* see packages/runtime/.../handlers/intelligence/memories.ts). All three map to
+	* the graceful "not available" locked-teaser path, not a hard error.
+	*/
+	const ROUTE_UNAVAILABLE_STATUSES = new Set([
+		404,
+		422,
+		501
+	]);
+	/**
+	* Thrown when a memory route returns a 404/422/501 — treated as "not
+	* configured" (422 is the runtime's MISSING_INTELLIGENCE signal).
+	*/
+	var MemoryRouteUnavailableError = class extends Error {};
+	const initialMemoryState = Object.freeze({
+		memories: Object.freeze([]),
+		isLoading: false,
+		inFlightMutationCount: 0,
+		error: null,
+		context: null,
+		sessionId: 0,
+		available: true,
+		realtimeStatus: "connecting"
+	});
+	const memoryAdapterEvents = createActionGroup("Memory Adapter", {
+		started: empty(),
+		stopped: empty(),
+		contextChanged: props(),
+		addRequested: props(),
+		updateRequested: props(),
+		removeRequested: props()
+	});
+	const memoryRestEvents = createActionGroup("Memory REST", {
+		listRequested: props(),
+		listSucceeded: props(),
+		listFailed: props(),
+		listUnavailable: props(),
+		mutationFinished: props(),
+		credentialsRequested: props(),
+		credentialsSucceeded: props(),
+		credentialsFailed: props(),
+		credentialsUnavailable: props()
+	});
+	const memoryDomainEvents = createActionGroup("Memory Domain", {
+		memoryUpserted: props(),
+		memoryInvalidated: props(),
+		realtimeConnecting: props(),
+		realtimeConnected: props(),
+		realtimeUnavailable: props()
+	});
+	/** Projects a wire memory to the public {@link Memory} shape (drops tenant ids). */
+	function toMemory(memory) {
+		return {
+			id: memory.id,
+			kind: memory.kind,
+			scope: memory.scope,
+			content: memory.content,
+			sourceThreadIds: memory.sourceThreadIds,
+			invalidatedAt: memory.invalidatedAt
+		};
+	}
+	/**
+	* Maps a realtime `memory_metadata` event to the domain action that applies it:
+	* `created`/`updated` upsert the projected memory, `invalidated` removes it by
+	* id. Carries the current `sessionId` so the reducer's session guard can drop
+	* deltas left over from a previous context.
+	*/
+	function mapMemoryMetadataEvent(event, sessionId) {
+		if (event.operation === "invalidated") return memoryDomainEvents.memoryInvalidated({
+			sessionId,
+			memoryId: event.invalidated.id
+		});
+		return memoryDomainEvents.memoryUpserted({
+			sessionId,
+			memory: toMemory(event.memory)
+		});
+	}
+	/**
+	* Inserts or replaces a memory by id. A new memory is prepended (newest first,
+	* matching the REST list's `created_at DESC` ordering without needing a date
+	* field on the public projection); an existing memory is replaced in place.
+	*/
+	function upsertMemory(memories, memory) {
+		const existingIndex = memories.findIndex((item) => item.id === memory.id);
+		if (existingIndex === -1) return [memory, ...memories];
+		const next = [...memories];
+		next[existingIndex] = memory;
+		return next;
+	}
+	const memoryReducer = createReducer(initialMemoryState, on(memoryAdapterEvents.contextChanged, (state, { context }) => ({
+		...state,
+		context,
+		sessionId: state.sessionId + 1,
+		memories: [],
+		isLoading: Boolean(context),
+		inFlightMutationCount: 0,
+		error: null,
+		available: true,
+		realtimeStatus: "connecting"
+	})), on(memoryAdapterEvents.stopped, (state) => ({
+		...state,
+		memories: [],
+		isLoading: false,
+		inFlightMutationCount: 0,
+		error: null,
+		available: true,
+		realtimeStatus: "connecting"
+	})), on(memoryRestEvents.listRequested, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId || !state.context) return state;
+		return {
+			...state,
+			isLoading: true,
+			error: null,
+			available: true
+		};
+	}), on(memoryRestEvents.listFailed, (state, { sessionId, error }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			isLoading: false,
+			error
+		};
+	}), on(memoryRestEvents.listUnavailable, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			memories: [],
+			isLoading: false,
+			error: null,
+			available: false
+		};
+	}), on(memoryAdapterEvents.addRequested, memoryAdapterEvents.updateRequested, memoryAdapterEvents.removeRequested, (state) => ({
+		...state,
+		inFlightMutationCount: state.inFlightMutationCount + 1
+	})), on(memoryRestEvents.mutationFinished, (state, { outcome }) => {
+		if (outcome.sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			inFlightMutationCount: Math.max(0, state.inFlightMutationCount - 1),
+			error: outcome.ok ? null : outcome.error
+		};
+	}), on(memoryRestEvents.listSucceeded, (state, { sessionId, memories }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			memories,
+			isLoading: false,
+			error: null,
+			available: true
+		};
+	}), on(memoryDomainEvents.memoryUpserted, (state, { sessionId, memory }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			memories: upsertMemory(state.memories, memory)
+		};
+	}), on(memoryDomainEvents.memoryInvalidated, (state, { sessionId, memoryId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			memories: state.memories.filter((memory) => memory.id !== memoryId)
+		};
+	}), on(memoryDomainEvents.realtimeConnecting, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			realtimeStatus: "connecting"
+		};
+	}), on(memoryDomainEvents.realtimeConnected, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			realtimeStatus: "connected"
+		};
+	}), on(memoryDomainEvents.realtimeUnavailable, (state, { sessionId }) => {
+		if (sessionId !== state.sessionId) return state;
+		return {
+			...state,
+			realtimeStatus: "unavailable"
+		};
+	}));
+	const selectMemories = createSelector((state) => state.memories);
+	const selectMemoriesIsLoading = createSelector((state) => state.isLoading);
+	const selectMemoriesError = createSelector((state) => state.error);
+	/**
+	* Reports whether at least one mutation is in flight. Derived from
+	* `inFlightMutationCount` so concurrent mutations stay correct: the boolean
+	* only clears once every in-flight mutation has settled.
+	*/
+	const selectMemoriesIsMutating = createSelector((state) => state.inFlightMutationCount > 0);
+	/**
+	* Reports whether the memory routes are available. Becomes `false` after a
+	* 404, 422 (the runtime's MISSING_INTELLIGENCE signal), or 501 response during
+	* an auto-activation read; defaults to `true`.
+	*/
+	const selectMemoriesAvailable = createSelector((state) => state.available);
+	/**
+	* Reports the realtime-connection health (see {@link MemoryRealtimeStatus}).
+	* Distinct from `available`/`error`: it reflects ONLY the live socket/channel,
+	* so the UI can suppress a "live" indicator once realtime permanently dies even
+	* while the REST list route stays healthy. Defaults to `"connecting"`.
+	*/
+	const selectMemoriesRealtimeStatus = createSelector((state) => state.realtimeStatus);
+	const MEMORY_METADATA_EVENT = "memory_metadata";
+	function memoryFromFetch(input, init) {
+		return (0, rxjs_fetch.fromFetch)(input, init);
+	}
+	/**
+	* Fetches the memory snapshot and maps it to a success/failure action. Keeps
+	* only user-scoped memories (v1 surfaces user scope only; the realtime stream
+	* is user-scoped too), so project-scoped rows visible to the caller are
+	* dropped from the store.
+	*/
+	function createMemoryFetchObservable(environment, context, sessionId) {
+		return (0, rxjs.defer)(() => {
+			const qs = context.includeInvalidated ? "?includeInvalidated=true" : "";
+			return memoryFromFetch(`${context.runtimeUrl}${MEMORIES_PATH}${qs}`, {
+				selector: (response) => {
+					if (!response.ok) {
+						if (ROUTE_UNAVAILABLE_STATUSES.has(response.status)) throw new MemoryRouteUnavailableError(String(response.status));
+						throw new MemoryError("MEMORY_LIST_FAILED", {
+							message: `Failed to fetch memories: ${response.status}`,
+							retryable: isRetryableStatus(response.status)
+						});
+					}
+					return response.json();
+				},
+				fetch: environment.fetch,
+				method: "GET",
+				headers: { ...context.headers }
+			}).pipe((0, rxjs_operators.timeout)({
+				first: REQUEST_TIMEOUT_MS$1,
+				with: () => {
+					throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+				}
+			}), (0, rxjs_operators.map)((data) => memoryRestEvents.listSucceeded({
+				sessionId,
+				memories: data.memories.filter((memory) => memory.scope === "user")
+			})), (0, rxjs_operators.catchError)((error) => {
+				if (error instanceof MemoryRouteUnavailableError) return (0, rxjs.of)(memoryRestEvents.listUnavailable({ sessionId }));
+				return (0, rxjs.of)(memoryRestEvents.listFailed({
+					sessionId,
+					error: error instanceof Error ? error : new Error(String(error))
+				}));
+			}));
+		});
+	}
+	/**
+	* Fetches join credentials from the `/memories/subscribe` endpoint and maps
+	* the response to a success/failure action. Requires both `joinToken` and
+	* `joinCode` to be non-empty strings; throws otherwise so the `catchError`
+	* path emits `credentialsFailed`.
+	*/
+	function createMemoryCredentialsFetchObservable(environment, context, sessionId) {
+		return (0, rxjs.defer)(() => memoryFromFetch(`${context.runtimeUrl}${MEMORIES_SUBSCRIBE_PATH}`, {
+			selector: async (response) => {
+				if (!response.ok) {
+					if (ROUTE_UNAVAILABLE_STATUSES.has(response.status)) throw new MemoryRouteUnavailableError(String(response.status));
+					throw new MemoryError("MEMORY_CREDENTIALS_FAILED", {
+						message: `Failed to fetch memory subscribe credentials: ${response.status}`,
+						retryable: isRetryableStatus(response.status)
+					});
+				}
+				return response.json();
+			},
+			fetch: environment.fetch,
+			method: "POST",
+			headers: {
+				...context.headers,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({})
+		}).pipe((0, rxjs_operators.timeout)({
+			first: REQUEST_TIMEOUT_MS$1,
+			with: () => {
+				throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+			}
+		}), (0, rxjs_operators.map)((data) => {
+			if (typeof data.joinToken !== "string" || data.joinToken.length === 0) throw new Error("missing joinToken");
+			if (typeof data.joinCode !== "string" || data.joinCode.length === 0) throw new Error("missing joinCode");
+			return memoryRestEvents.credentialsSucceeded({
+				sessionId,
+				joinToken: data.joinToken,
+				joinCode: data.joinCode
+			});
+		}), (0, rxjs_operators.catchError)((error) => {
+			if (error instanceof MemoryRouteUnavailableError) return (0, rxjs.of)(memoryRestEvents.credentialsUnavailable({ sessionId }));
+			return (0, rxjs.of)(memoryRestEvents.credentialsFailed({
+				sessionId,
+				error: error instanceof Error ? error : new Error(String(error))
+			}));
+		})));
+	}
+	/** Projects a REST mutation response to the public {@link Memory} shape. */
+	function responseToMemory(data) {
+		return {
+			id: data.id,
+			kind: data.kind,
+			scope: data.scope,
+			content: data.content,
+			sourceThreadIds: data.sourceThreadIds,
+			invalidatedAt: data.invalidatedAt
+		};
+	}
+	const MEMORY_KINDS = new Set([
+		"topical",
+		"episodic",
+		"operational"
+	]);
+	const MEMORY_SCOPES = new Set(["user", "project"]);
+	/**
+	* Validates the required fields of a create/supersede REST response before it is
+	* projected to a {@link Memory}. Returns an `Error` describing the first
+	* missing/invalid field, or `null` when the body is well-formed. Without this a
+	* malformed 200 body yields a Memory with undefined fields that gets upserted.
+	*/
+	function validateMutationResponse(data) {
+		if (!data || typeof data !== "object") return /* @__PURE__ */ new Error("memory mutation response missing/invalid body");
+		if (typeof data.id !== "string" || data.id.length === 0) return /* @__PURE__ */ new Error("memory mutation response missing/invalid id");
+		if (typeof data.kind !== "string" || !MEMORY_KINDS.has(data.kind)) return /* @__PURE__ */ new Error("memory mutation response missing/invalid kind");
+		if (typeof data.scope !== "string" || !MEMORY_SCOPES.has(data.scope)) return /* @__PURE__ */ new Error("memory mutation response missing/invalid scope");
+		if (typeof data.content !== "string") return /* @__PURE__ */ new Error("memory mutation response missing/invalid content");
+		if (!Array.isArray(data.sourceThreadIds) || !data.sourceThreadIds.every((id) => typeof id === "string")) return /* @__PURE__ */ new Error("memory mutation response missing/invalid sourceThreadIds");
+		if (data.invalidatedAt !== null && typeof data.invalidatedAt !== "string") return /* @__PURE__ */ new Error("memory mutation response missing/invalid invalidatedAt");
+		return null;
+	}
+	/**
+	* Request body for create/supersede. `scope` is forwarded only when the caller
+	* supplies it: the platform owns the default (`scope` defaults to `"user"` in
+	* the `/api/memories` schema), so the store does not second-guess it here —
+	* one default, at the contract owner. `sourceThreadIds` defaults to `[]`.
+	*/
+	function toMutationBody(input) {
+		var _input$sourceThreadId;
+		return {
+			content: input.content,
+			kind: input.kind,
+			...input.scope !== void 0 ? { scope: input.scope } : {},
+			sourceThreadIds: (_input$sourceThreadId = input.sourceThreadIds) !== null && _input$sourceThreadId !== void 0 ? _input$sourceThreadId : []
+		};
+	}
+	/**
+	* Builds the actions a successful mutation dispatches (server-authoritative):
+	* the REST response is applied to local state immediately, and the realtime
+	* event reconciles idempotently (upsert-by-id). `mutationFinished` resolves the
+	* caller's promise.
+	*/
+	function buildMutationSuccessActions(request, data) {
+		const { requestId, sessionId } = request;
+		if (request.kind === "remove") return [memoryDomainEvents.memoryInvalidated({
+			sessionId,
+			memoryId: request.id
+		}), memoryRestEvents.mutationFinished({ outcome: {
+			requestId,
+			sessionId,
+			ok: true,
+			memory: null
+		} })];
+		const validationError = validateMutationResponse(data);
+		if (validationError) return [memoryRestEvents.mutationFinished({ outcome: {
+			requestId,
+			sessionId,
+			ok: false,
+			error: validationError
+		} })];
+		const memory = responseToMemory(data);
+		if (request.kind === "update") {
+			const retiredId = data.retiredId;
+			if (typeof retiredId !== "string" || retiredId.length === 0) return [memoryRestEvents.mutationFinished({ outcome: {
+				requestId,
+				sessionId,
+				ok: false,
+				error: /* @__PURE__ */ new Error("supersede response missing retiredId")
+			} })];
+			return [
+				memoryDomainEvents.memoryInvalidated({
+					sessionId,
+					memoryId: retiredId
+				}),
+				memoryDomainEvents.memoryUpserted({
+					sessionId,
+					memory
+				}),
+				memoryRestEvents.mutationFinished({ outcome: {
+					requestId,
+					sessionId,
+					ok: true,
+					memory
+				} })
+			];
+		}
+		return [memoryDomainEvents.memoryUpserted({
+			sessionId,
+			memory
+		}), memoryRestEvents.mutationFinished({ outcome: {
+			requestId,
+			sessionId,
+			ok: true,
+			memory
+		} })];
+	}
+	/** Performs a create/supersede/retire HTTP call and emits its resulting actions. */
+	function createMemoryMutationObservable(environment, context, request) {
+		const method = request.kind === "add" ? "POST" : request.kind === "update" ? "PATCH" : "DELETE";
+		const path = request.kind === "add" ? MEMORIES_PATH : `${MEMORIES_PATH}/${encodeURIComponent(request.id)}`;
+		return (0, rxjs.defer)(() => memoryFromFetch(`${context.runtimeUrl}${path}`, {
+			selector: async (response) => {
+				if (!response.ok) throw new MemoryError("MEMORY_MUTATION_FAILED", {
+					message: `Request failed: ${response.status}`,
+					retryable: isRetryableStatus(response.status)
+				});
+				return request.kind === "remove" ? null : await response.json();
+			},
+			fetch: environment.fetch,
+			method,
+			headers: {
+				...context.headers,
+				"Content-Type": "application/json"
+			},
+			body: request.kind === "remove" ? void 0 : JSON.stringify(request.body)
+		}).pipe((0, rxjs_operators.timeout)({
+			first: REQUEST_TIMEOUT_MS$1,
+			with: () => {
+				throw new MemoryError("MEMORY_REQUEST_TIMEOUT");
+			}
+		}), (0, rxjs_operators.mergeMap)((data) => (0, rxjs.of)(...buildMutationSuccessActions(request, data))), (0, rxjs_operators.catchError)((error) => (0, rxjs.of)(memoryRestEvents.mutationFinished({ outcome: {
+			requestId: request.requestId,
+			sessionId: request.sessionId,
+			ok: false,
+			error: error instanceof Error ? error : new Error(String(error))
+		} })))));
+	}
+	/**
+	* Creates the framework-agnostic memory store: a REST snapshot on `setContext`,
+	* server-authoritative add/update/remove mutations, and realtime
+	* `memory_metadata` deltas off the injected `user_meta` event source — all
+	* reduced into observable state.
+	*/
+	function createMemoryStore(environment) {
+		let memoryRequestId = 0;
+		const createMemoryRequestId = () => {
+			memoryRequestId += 1;
+			return `memory-request-${memoryRequestId}`;
+		};
+		const bootstrapEffect = createEffect((actions$, state$) => actions$.pipe(ofType(memoryAdapterEvents.contextChanged), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([, state]) => Boolean(state.context)), (0, rxjs_operators.map)(([, state]) => memoryRestEvents.listRequested({ sessionId: state.sessionId }))));
+		const credentialsBootstrapEffect = createEffect((actions$, state$) => actions$.pipe(ofType(memoryAdapterEvents.contextChanged), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([, state]) => Boolean(state.context)), (0, rxjs_operators.map)(([, state]) => memoryRestEvents.credentialsRequested({ sessionId: state.sessionId }))));
+		const credentialsFetchEffect = createEffect((actions$, state$) => actions$.pipe(ofType(memoryRestEvents.credentialsRequested), (0, rxjs_operators.switchMap)((action) => state$.pipe((0, rxjs_operators.map)((state) => state.context), (0, rxjs_operators.filter)((context) => Boolean(context)), (0, rxjs_operators.take)(1), (0, rxjs_operators.map)((context) => ({
+			action,
+			context
+		})), (0, rxjs_operators.takeUntil)(actions$.pipe(ofType(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped))), (0, rxjs_operators.switchMap)(({ action: currentAction, context }) => createMemoryCredentialsFetchObservable(environment, context, currentAction.sessionId))))));
+		const store = createStore({
+			reducer: memoryReducer,
+			effects: [
+				bootstrapEffect,
+				credentialsBootstrapEffect,
+				createEffect((actions$, state$) => actions$.pipe(ofType(memoryRestEvents.listRequested), (0, rxjs_operators.switchMap)((action) => state$.pipe((0, rxjs_operators.map)((state) => state.context), (0, rxjs_operators.filter)((context) => Boolean(context)), (0, rxjs_operators.take)(1), (0, rxjs_operators.map)((context) => ({
+					action,
+					context
+				})), (0, rxjs_operators.takeUntil)(actions$.pipe(ofType(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped))), (0, rxjs_operators.switchMap)(({ action: currentAction, context }) => createMemoryFetchObservable(environment, context, currentAction.sessionId)))))),
+				credentialsFetchEffect,
+				createEffect((actions$, state$) => actions$.pipe(ofType(memoryAdapterEvents.addRequested, memoryAdapterEvents.updateRequested, memoryAdapterEvents.removeRequested), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.mergeMap)(([action, state]) => {
+					const context = state.context;
+					const sessionId = state.sessionId;
+					if (!(context === null || context === void 0 ? void 0 : context.runtimeUrl)) return (0, rxjs.of)(memoryRestEvents.mutationFinished({ outcome: {
+						requestId: action.requestId,
+						sessionId,
+						ok: false,
+						error: /* @__PURE__ */ new Error("Runtime URL is not configured")
+					} }));
+					if (memoryAdapterEvents.addRequested.match(action)) return createMemoryMutationObservable(environment, context, {
+						requestId: action.requestId,
+						sessionId,
+						kind: "add",
+						body: toMutationBody(action.input)
+					});
+					if (memoryAdapterEvents.updateRequested.match(action)) return createMemoryMutationObservable(environment, context, {
+						requestId: action.requestId,
+						sessionId,
+						kind: "update",
+						id: action.id,
+						body: toMutationBody(action.changes)
+					});
+					return createMemoryMutationObservable(environment, context, {
+						requestId: action.requestId,
+						sessionId,
+						kind: "remove",
+						id: action.id
+					});
+				}))),
+				createEffect((actions$, state$) => actions$.pipe(ofType(memoryRestEvents.credentialsSucceeded), (0, rxjs_operators.withLatestFrom)(state$), (0, rxjs_operators.filter)(([action, state]) => {
+					var _state$context;
+					return action.sessionId === state.sessionId && Boolean((_state$context = state.context) === null || _state$context === void 0 ? void 0 : _state$context.wsUrl);
+				}), (0, rxjs_operators.switchMap)(([action, state]) => {
+					const context = state.context;
+					const { joinToken, joinCode } = action;
+					const sessionId = action.sessionId;
+					const shutdown$ = actions$.pipe(ofType(memoryAdapterEvents.contextChanged, memoryAdapterEvents.stopped));
+					return (0, rxjs.defer)(() => {
+						const socket$ = ɵphoenixSocket$({
+							url: context.wsUrl,
+							options: {
+								params: { join_token: joinToken },
+								reconnectAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(100, 1e4),
+								rejoinAfterMs: (0, _copilotkit_shared.phoenixExponentialBackoff)(1e3, 3e4)
+							}
+						}).pipe((0, rxjs_operators.shareReplay)({
+							bufferSize: 1,
+							refCount: true
+						}));
+						const channel$ = ɵphoenixChannel$({
+							socket$,
+							topic: `user_meta:memories:${joinCode}`
+						}).pipe((0, rxjs_operators.shareReplay)({
+							bufferSize: 1,
+							refCount: true
+						}));
+						const fatalSocketShutdown$ = ɵobservePhoenixSocketHealth$(ɵobservePhoenixSocketSignals$(socket$).pipe((0, rxjs_operators.share)()), MAX_SOCKET_RETRIES$1).pipe((0, rxjs_operators.catchError)(() => {
+							console.warn(`[memory] WebSocket failed after ${MAX_SOCKET_RETRIES$1} attempts, giving up`);
+							return (0, rxjs.of)(void 0);
+						}), (0, rxjs_operators.share)());
+						const fatalStatus$ = fatalSocketShutdown$.pipe((0, rxjs_operators.map)(() => memoryDomainEvents.realtimeUnavailable({ sessionId })));
+						const metadata$ = channel$.pipe((0, rxjs_operators.switchMap)(({ channel }) => ɵobservePhoenixEvent$(channel, MEMORY_METADATA_EVENT)), (0, rxjs_operators.map)((event) => mapMemoryMetadataEvent(event, action.sessionId)));
+						const join$ = ɵjoinPhoenixChannel$(channel$).pipe((0, rxjs_operators.concatWith)((0, rxjs.of)(memoryDomainEvents.realtimeConnected({ sessionId }))), (0, rxjs_operators.catchError)((error) => {
+							console.warn(`[memory] failed to join user_meta:memories:${joinCode}`, error);
+							return (0, rxjs.of)(memoryDomainEvents.realtimeUnavailable({ sessionId }));
+						}));
+						return (0, rxjs.merge)((0, rxjs.of)(memoryDomainEvents.realtimeConnecting({ sessionId })), metadata$, join$, fatalStatus$).pipe((0, rxjs_operators.takeUntil)((0, rxjs.merge)(shutdown$, fatalSocketShutdown$.pipe((0, rxjs.observeOn)(rxjs.asapScheduler)))), (0, rxjs_operators.finalize)(() => {}));
+					});
+				})))
+			]
+		});
+		function trackMutation(dispatchAction, extract) {
+			const { requestId } = dispatchAction;
+			const resultPromise = (0, rxjs.firstValueFrom)((0, rxjs.merge)(store.actions$.pipe(ofType(memoryRestEvents.mutationFinished), (0, rxjs_operators.filter)((action) => action.outcome.requestId === requestId), (0, rxjs_operators.map)((action) => action.outcome)), store.actions$.pipe(ofType(memoryAdapterEvents.stopped), (0, rxjs_operators.map)(() => ({
+				requestId,
+				sessionId: store.getState().sessionId,
+				ok: false,
+				error: /* @__PURE__ */ new Error("Memory store stopped before mutation completed")
+			})))).pipe((0, rxjs_operators.take)(1))).then((outcome) => {
+				if (!outcome.ok) throw outcome.error;
+				return extract(outcome);
+			});
+			store.dispatch(dispatchAction);
+			return resultPromise;
+		}
+		return {
+			start() {
+				store.init();
+				store.dispatch(memoryAdapterEvents.started());
+			},
+			stop() {
+				store.dispatch(memoryAdapterEvents.stopped());
+				store.stop();
+			},
+			setContext(context) {
+				store.dispatch(memoryAdapterEvents.contextChanged({ context }));
+			},
+			refresh() {
+				const { sessionId, context } = store.getState();
+				if (!context) return Promise.resolve();
+				const done = (0, rxjs.firstValueFrom)((0, rxjs.merge)(store.actions$.pipe(ofType(memoryRestEvents.listSucceeded, memoryRestEvents.listFailed, memoryRestEvents.listUnavailable), (0, rxjs_operators.filter)((action) => action.sessionId === sessionId)), store.actions$.pipe(ofType(memoryAdapterEvents.stopped)), store.actions$.pipe(ofType(memoryAdapterEvents.contextChanged))).pipe((0, rxjs_operators.take)(1))).then((action) => {
+					if (memoryRestEvents.listFailed.match(action)) throw action.error;
+					if (memoryAdapterEvents.stopped.match(action)) throw new Error("Memory store stopped before refresh completed");
+					if (memoryAdapterEvents.contextChanged.match(action)) return;
+				});
+				store.dispatch(memoryRestEvents.listRequested({ sessionId }));
+				return done;
+			},
+			addMemory(input) {
+				return trackMutation(memoryAdapterEvents.addRequested({
+					requestId: createMemoryRequestId(),
+					input
+				}), (outcome) => {
+					if (outcome.memory == null) throw new Error("add resolved without a memory");
+					return outcome.memory;
+				});
+			},
+			updateMemory(id, changes) {
+				return trackMutation(memoryAdapterEvents.updateRequested({
+					requestId: createMemoryRequestId(),
+					id,
+					changes
+				}), (outcome) => {
+					if (outcome.memory == null) throw new Error("update resolved without a memory");
+					return outcome.memory;
+				});
+			},
+			removeMemory(id) {
+				return trackMutation(memoryAdapterEvents.removeRequested({
+					requestId: createMemoryRequestId(),
+					id
+				}), () => void 0);
+			},
+			getState() {
+				return store.getState();
+			},
+			getServerState() {
+				return initialMemoryState;
+			},
+			select: store.select.bind(store)
+		};
+	}
+	const ɵmemoryAdapterEvents = memoryAdapterEvents;
+	const ɵmemoryRestEvents = memoryRestEvents;
+	const ɵmemoryDomainEvents = memoryDomainEvents;
+	const ɵmemoryReducer = memoryReducer;
+	const ɵmapMemoryMetadataEvent = mapMemoryMetadataEvent;
+	const ɵselectMemories = selectMemories;
+	const ɵselectMemoriesIsLoading = selectMemoriesIsLoading;
+	const ɵselectMemoriesError = selectMemoriesError;
+	const ɵselectMemoriesIsMutating = selectMemoriesIsMutating;
+	const ɵselectMemoriesAvailable = selectMemoriesAvailable;
+	const ɵselectMemoriesRealtimeStatus = selectMemoriesRealtimeStatus;
+
+//#endregion
+//#region src/core/core.ts
+	let CopilotKitCoreErrorCode = /* @__PURE__ */ function(CopilotKitCoreErrorCode) {
+		CopilotKitCoreErrorCode["RUNTIME_INFO_FETCH_FAILED"] = "runtime_info_fetch_failed";
+		CopilotKitCoreErrorCode["AGENT_CONNECT_FAILED"] = "agent_connect_failed";
+		CopilotKitCoreErrorCode["AGENT_RUN_FAILED"] = "agent_run_failed";
+		CopilotKitCoreErrorCode["AGENT_RUN_FAILED_EVENT"] = "agent_run_failed_event";
+		CopilotKitCoreErrorCode["AGENT_RUN_ERROR_EVENT"] = "agent_run_error_event";
+		CopilotKitCoreErrorCode["TOOL_ARGUMENT_PARSE_FAILED"] = "tool_argument_parse_failed";
+		CopilotKitCoreErrorCode["TOOL_HANDLER_FAILED"] = "tool_handler_failed";
+		CopilotKitCoreErrorCode["TOOL_NOT_FOUND"] = "tool_not_found";
+		CopilotKitCoreErrorCode["AGENT_NOT_FOUND"] = "agent_not_found";
+		/**
+		* Emitted when an agent run fails because the thread is already locked
+		* by another active run.
+		*
+		* @example
+		* ```tsx
+		* <CopilotKitProvider
+		*   onError={({ code, error, context }) => {
+		*     if (code === "agent_thread_locked") {
+		*       // Show "Agent is busy, retry?" UI
+		*     }
+		*   }}
+		* />
+		* ```
+		*/
+		CopilotKitCoreErrorCode["AGENT_THREAD_LOCKED"] = "agent_thread_locked";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_FAILED"] = "transcription_failed";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_SERVICE_NOT_CONFIGURED"] = "transcription_service_not_configured";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_INVALID_AUDIO"] = "transcription_invalid_audio";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_RATE_LIMITED"] = "transcription_rate_limited";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_AUTH_FAILED"] = "transcription_auth_failed";
+		CopilotKitCoreErrorCode["TRANSCRIPTION_NETWORK_ERROR"] = "transcription_network_error";
+		CopilotKitCoreErrorCode["SUBSCRIBER_CALLBACK_FAILED"] = "subscriber_callback_failed";
+		return CopilotKitCoreErrorCode;
+	}({});
+	/**
+	* Runtime allowlist derived from {@link SUBSCRIBE_TO_AGENT_KEYS}. Hoisted
+	* to module scope so the Set is allocated once, not per-subscription.
+	*/
+	const ALLOWED_KEYS = new Set([
+		"onMessagesChanged",
+		"onStateChanged",
+		"onRunInitialized",
+		"onRunFinalized",
+		"onRunFailed",
+		"onRunErrorEvent"
+	]);
+	let CopilotKitCoreRuntimeConnectionStatus = /* @__PURE__ */ function(CopilotKitCoreRuntimeConnectionStatus) {
+		CopilotKitCoreRuntimeConnectionStatus["Disconnected"] = "disconnected";
+		CopilotKitCoreRuntimeConnectionStatus["Connected"] = "connected";
+		CopilotKitCoreRuntimeConnectionStatus["Connecting"] = "connecting";
+		CopilotKitCoreRuntimeConnectionStatus["Error"] = "error";
+		return CopilotKitCoreRuntimeConnectionStatus;
+	}({});
+	/**
+	* Normalize a header map to the internal invariant: a `Record<string, string>`
+	* with no `null`/`undefined` values. Entries whose value is `null`/`undefined`
+	* are dropped (this is how a header is cleared). Shared by the constructor and
+	* `setHeaders` so both write paths into `_headers` enforce the same invariant.
+	*/
+	function normalizeHeaders(headers) {
+		return Object.fromEntries(Object.entries(headers).filter((entry) => entry[1] != null));
+	}
+	var CopilotKitCore = class {
+		constructor({ runtimeUrl, runtimeTransport = "auto", headers = {}, credentials, properties = {}, agents__unsafe_dev_only = {}, tools = [], suggestionsConfig = [], debug }) {
+			_defineProperty(this, "_headers", void 0);
+			_defineProperty(this, "_credentials", void 0);
+			_defineProperty(this, "_properties", void 0);
+			_defineProperty(this, "_defaultThrottleMs", void 0);
+			_defineProperty(this, "_debug", void 0);
+			_defineProperty(this, "subscribers", /* @__PURE__ */ new Set());
+			_defineProperty(this, "agentRegistry", void 0);
+			_defineProperty(this, "contextStore", void 0);
+			_defineProperty(this, "suggestionEngine", void 0);
+			_defineProperty(this, "runHandler", void 0);
+			_defineProperty(this, "stateManager", void 0);
+			_defineProperty(this, "threadStoreRegistry", void 0);
+			_defineProperty(this, "_memoryStore", void 0);
+			_defineProperty(this, "previousAgentIds", /* @__PURE__ */ new Set());
+			this._headers = normalizeHeaders(headers);
+			this._credentials = credentials;
+			this._properties = properties;
+			this._debug = debug;
+			this.agentRegistry = new AgentRegistry(this);
+			this.contextStore = new ContextStore(this);
+			this.suggestionEngine = new SuggestionEngine(this);
+			this.runHandler = new RunHandler(this);
+			this.stateManager = new StateManager(this);
+			this.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) => {
+				var _subscriber$onError;
+				return (_subscriber$onError = subscriber.onError) === null || _subscriber$onError === void 0 ? void 0 : _subscriber$onError.call(subscriber, {
+					copilotkit: this,
+					error,
+					code,
+					context
+				});
+			}, "Subscriber onError error:");
+		}
+		/**
+		* Log a message to the console and emit an error to subscribers.
+		* Catches failures from `emitError` itself to prevent unhandled rejections.
+		*/
+		logAndEmitError(message, params, logLevel = "error") {
+			console[logLevel](message, params.error);
+			this.emitError(params).catch((emitErr) => {
+				console.error(message + " — emitError itself failed:", emitErr);
+			});
+		}
+		/**
+		* Snapshot accessors
+		*/
+		get context() {
+			return this.contextStore.context;
 		}
 		get agents() {
 			return this.agentRegistry.agents;
@@ -2952,6 +3984,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		get threadEndpoints() {
 			return this.agentRegistry.threadEndpoints;
 		}
+		get suggestions() {
+			return this.agentRegistry.suggestions;
+		}
 		get a2uiEnabled() {
 			return this.agentRegistry.a2uiEnabled;
 		}
@@ -3005,6 +4040,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		*/
 		setHeaders(headers) {
 			this._headers = normalizeHeaders(headers);
+			if (this._memoryStore) this.syncMemoryContext();
 			this.agentRegistry.applyHeadersToAgents(this.agentRegistry.agents);
 			this.notifySubscribers((subscriber) => {
 				var _subscriber$onHeaders;
@@ -3116,6 +4152,47 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			return this.threadStoreRegistry.getAll();
 		}
 		/**
+		* Returns the single core-owned, user-scoped memory store, creating and
+		* starting it on first access. Unlike thread stores, memory is not scoped per
+		* agent: there is exactly one store whose runtime context the core wires
+		* itself (see `syncMemoryContext`), so consumers (e.g. a `useMemories`
+		* binding) just read this store rather than registering one.
+		*/
+		getMemoryStore() {
+			return this.ensureMemoryStore();
+		}
+		/**
+		* Lazily creates, starts, and context-syncs the core-owned memory store on
+		* first access, then returns it. Subsequent calls return the existing store.
+		* The store is constructed with a bound `globalThis.fetch` and immediately
+		* has its runtime context synced from the current connection state.
+		*/
+		ensureMemoryStore() {
+			if (!this._memoryStore) {
+				this._memoryStore = createMemoryStore({ fetch: globalThis.fetch.bind(globalThis) });
+				this._memoryStore.start();
+				this.syncMemoryContext();
+			}
+			return this._memoryStore;
+		}
+		/**
+		* Pushes the current runtime wiring into the memory store. When the runtime
+		* is connected and both the intelligence WebSocket URL and runtime URL are
+		* available, the store receives a context (runtime URL, WebSocket URL, and a
+		* copy of the current headers); otherwise its context is cleared. No-op when
+		* the store has not been created yet.
+		*/
+		syncMemoryContext() {
+			var _this$intelligence;
+			if (!this._memoryStore) return;
+			if (this.runtimeConnectionStatus === CopilotKitCoreRuntimeConnectionStatus.Connected && ((_this$intelligence = this.intelligence) === null || _this$intelligence === void 0 ? void 0 : _this$intelligence.wsUrl) && this.runtimeUrl) this._memoryStore.setContext({
+				runtimeUrl: this.runtimeUrl,
+				wsUrl: this.intelligence.wsUrl,
+				headers: { ...this.headers }
+			});
+			else this._memoryStore.setContext(null);
+		}
+		/**
 		* Suggestions management (delegated to SuggestionEngine)
 		*/
 		addSuggestionsConfig(config) {
@@ -3284,507 +4361,248 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			};
 			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
-				});
-			}
+				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) {
-			var _reducerMap$get;
-			const handlers = (_reducerMap$get = reducerMap.get(creator.type)) !== null && _reducerMap$get !== void 0 ? _reducerMap$get : [];
-			handlers.push(entry.reducer);
-			reducerMap.set(creator.type, handlers);
+		/**
+		* 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 !== null && state !== void 0 ? state : initialState;
-			const handlers = reducerMap.get(action.type);
-			if (!handlers || handlers.length === 0) return currentState;
-			let nextState = currentState;
-			for (const handler of handlers) nextState = handler(nextState, action);
-			return nextState;
-		};
-	}
-	/**
-	* Creates a selector that caches and reuses the last computed result
-	* when all input references are unchanged.
-	*/
-	function createSelector(...args) {
-		if (args.length === 1) {
-			const projector = args[0];
-			let hasCached = false;
-			let lastState;
-			let lastResult;
-			return (state) => {
-				if (hasCached && state === lastState) return lastResult;
-				lastState = state;
-				lastResult = projector(state);
-				hasCached = true;
-				return lastResult;
-			};
+		/**
+		* 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((0, rxjs_operators.map)(selector), (0, rxjs_operators.distinctUntilChanged)());
-	}
-	/**
-	* RxJS operator that filters an action stream by action creators and narrows
-	* the output action type to the matched creator union.
-	*
-	* @throws Error when called without at least one action creator.
-	*/
-	function ofType(...creators) {
-		if (creators.length === 0) throw new Error("ofType requires at least one action creator");
-		const actionTypes = new Set(creators.map((creator) => creator.type));
-		return (source$) => {
-			return source$.pipe((0, rxjs_operators.filter)((action) => {
-				return actionTypes.has(action.type);
-			}));
-		};
-	}
-	/**
-	* Creates an effect descriptor consumed by `createStore`.
-	*/
-	function createEffect(factory, options = {}) {
-		if (options.dispatch === false) return {
-			run: factory,
-			dispatch: false
-		};
-		return {
-			run: factory,
-			dispatch: true
-		};
-	}
-	/**
-	* Creates a small observable store with reducer + effects.
-	*
-	* Behavior:
-	* - `init()` starts effects and dispatches `@@micro-redux/init`.
-	* - `stop()` dispatches `@@micro-redux/stop` and unsubscribes all effects.
-	* - Effect action observation is scheduled on `asapScheduler` to avoid
-	*   synchronous re-entrancy in the effect loop.
-	* - Any effect error triggers fail-fast teardown and errors both `actions$`
-	*   and `state$`.
+		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
 	*/
-	function createStore(options) {
-		var _options$effects;
-		const reducer = options.reducer;
-		const effects = (_options$effects = options.effects) !== null && _options$effects !== void 0 ? _options$effects : [];
-		let hasFatalError = false;
-		let isRunning = false;
-		let effectSubscriptions = new rxjs.Subscription();
-		let currentState = reducer(void 0, INTERNAL_BOOT_ACTION);
-		const stateSubject = new rxjs.BehaviorSubject(currentState);
-		const actionsSubject = new rxjs.Subject();
-		const dispatchInternal = (action) => {
-			if (hasFatalError) throw new Error("Store is in a failed state due to an effect error");
-			currentState = reducer(currentState, action);
-			stateSubject.next(currentState);
-			actionsSubject.next(action);
-		};
-		const failFast = (error) => {
-			if (hasFatalError) return;
-			hasFatalError = true;
-			isRunning = false;
-			effectSubscriptions.unsubscribe();
-			effectSubscriptions = new rxjs.Subscription();
-			actionsSubject.error(error);
-			stateSubject.error(error);
-		};
-		const startEffects = () => {
-			for (const effect of effects) {
-				const scheduledActions$ = actionsSubject.asObservable().pipe((0, rxjs_operators.observeOn)(rxjs.asapScheduler));
-				const state$ = stateSubject.asObservable();
-				if (effect.dispatch) {
-					const subscription = effect.run(scheduledActions$, state$).subscribe({
-						next: (effectAction) => {
-							if (hasFatalError) return;
-							dispatchInternal(effectAction);
-						},
-						error: (error) => {
-							failFast(error);
-						}
+	let ToolCallStatus = /* @__PURE__ */ function(ToolCallStatus) {
+		ToolCallStatus["InProgress"] = "inProgress";
+		ToolCallStatus["Executing"] = "executing";
+		ToolCallStatus["Complete"] = "complete";
+		return ToolCallStatus;
+	}({});
+
+//#endregion
+//#region src/utils/markdown.ts
+	function completePartialMarkdown(input) {
+		let s = input;
+		const fenceMatches = Array.from(s.matchAll(/^(\s*)(`{3,}|~{3,})/gm));
+		if (fenceMatches.length % 2 === 1) {
+			const [, indent, fence] = fenceMatches[0];
+			s += `\n${indent}${fence}`;
+		}
+		if (s.match(/\[([^\]]*)\]\(([^)]*)$/)) s += ")";
+		const openElements = [];
+		const chars = Array.from(s);
+		const codeBlockRanges = [];
+		const inlineCodeRanges = [];
+		let tempCodeFenceCount = 0;
+		let currentCodeBlockStart = -1;
+		for (let i = 0; i < chars.length; i++) if (i === 0 || chars[i - 1] === "\n") {
+			const lineMatch = s.substring(i).match(/^(\s*)(`{3,}|~{3,})/);
+			if (lineMatch) {
+				tempCodeFenceCount++;
+				if (tempCodeFenceCount % 2 === 1) currentCodeBlockStart = i;
+				else if (currentCodeBlockStart !== -1) {
+					codeBlockRanges.push({
+						start: currentCodeBlockStart,
+						end: i + lineMatch[0].length
 					});
-					effectSubscriptions.add(subscription);
-					continue;
+					currentCodeBlockStart = -1;
 				}
-				const subscription = effect.run(scheduledActions$, state$).subscribe({ error: (error) => {
-					failFast(error);
-				} });
-				effectSubscriptions.add(subscription);
+				i += lineMatch[0].length - 1;
 			}
-		};
-		return {
-			dispatch(action) {
-				dispatchInternal(action);
-			},
-			getState() {
-				return currentState;
-			},
-			get state$() {
-				return stateSubject.asObservable();
-			},
-			get actions$() {
-				return actionsSubject.asObservable();
-			},
-			select(selector) {
-				return stateSubject.asObservable().pipe(select(selector));
-			},
-			init() {
-				if (hasFatalError || isRunning) return;
-				isRunning = true;
-				startEffects();
-				if (hasFatalError) return;
-				dispatchInternal({ type: INTERNAL_ACTION_TYPES.init });
-			},
-			stop() {
-				if (hasFatalError || !isRunning) return;
-				dispatchInternal({ type: INTERNAL_ACTION_TYPES.stop });
-				effectSubscriptions.unsubscribe();
-				effectSubscriptions = new rxjs.Subscription();
-				isRunning = false;
+		}
+		for (let i = 0; i < chars.length; i++) if (chars[i] === "`") {
+			let backslashCount = 0;
+			for (let j = i - 1; j >= 0 && chars[j] === "\\"; j--) backslashCount++;
+			if (backslashCount % 2 === 0) {
+				for (let j = i + 1; j < chars.length; j++) if (chars[j] === "`") {
+					let closingBackslashCount = 0;
+					for (let k = j - 1; k >= 0 && chars[k] === "\\"; k--) closingBackslashCount++;
+					if (closingBackslashCount % 2 === 0) {
+						inlineCodeRanges.push({
+							start: i,
+							end: j + 1
+						});
+						i = j;
+						break;
+					}
+				}
 			}
+		}
+		const isInCode = (pos) => {
+			return codeBlockRanges.some((range) => pos >= range.start && pos < range.end) || inlineCodeRanges.some((range) => pos >= range.start && pos < range.end);
 		};
+		for (let i = 0; i < chars.length; i++) {
+			const char = chars[i];
+			const nextChar = chars[i + 1];
+			const prevChar = chars[i - 1];
+			if (isInCode(i)) continue;
+			if (char === "[") {
+				let isCompleteLink = false;
+				let bracketDepth = 1;
+				let j = i + 1;
+				while (j < chars.length && bracketDepth > 0) {
+					if (chars[j] === "[" && !isInCode(j)) bracketDepth++;
+					if (chars[j] === "]" && !isInCode(j)) bracketDepth--;
+					j++;
+				}
+				if (bracketDepth === 0 && chars[j] === "(") {
+					let parenDepth = 1;
+					j++;
+					while (j < chars.length && parenDepth > 0) {
+						if (chars[j] === "(" && !isInCode(j)) parenDepth++;
+						if (chars[j] === ")" && !isInCode(j)) parenDepth--;
+						j++;
+					}
+					if (parenDepth === 0) {
+						isCompleteLink = true;
+						i = j - 1;
+						continue;
+					}
+				}
+				if (!isCompleteLink) {
+					const existingIndex = openElements.findIndex((el) => el.type === "bracket");
+					if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+					else openElements.push({
+						type: "bracket",
+						marker: "[",
+						position: i
+					});
+				}
+			} else if (char === "*" && nextChar === "*") {
+				const existingIndex = openElements.findIndex((el) => el.type === "bold_star");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "bold_star",
+					marker: "**",
+					position: i
+				});
+				i++;
+			} else if (char === "_" && nextChar === "_") {
+				const existingIndex = openElements.findIndex((el) => el.type === "bold_underscore");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "bold_underscore",
+					marker: "__",
+					position: i
+				});
+				i++;
+			} else if (char === "~" && nextChar === "~") {
+				const existingIndex = openElements.findIndex((el) => el.type === "strike");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "strike",
+					marker: "~~",
+					position: i
+				});
+				i++;
+			} else if (char === "*" && prevChar !== "*" && nextChar !== "*") {
+				const existingIndex = openElements.findIndex((el) => el.type === "italic_star");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "italic_star",
+					marker: "*",
+					position: i
+				});
+			} else if (char === "_" && prevChar !== "_" && nextChar !== "_") {
+				const existingIndex = openElements.findIndex((el) => el.type === "italic_underscore");
+				if (existingIndex !== -1) openElements.splice(existingIndex, 1);
+				else openElements.push({
+					type: "italic_underscore",
+					marker: "_",
+					position: i
+				});
+			}
+		}
+		let backtickCount = 0;
+		for (let i = 0; i < chars.length; i++) if (chars[i] === "`" && !isInCode(i)) backtickCount++;
+		if (backtickCount % 2 === 1) s += "`";
+		openElements.sort((a, b) => b.position - a.position);
+		const closers = openElements.map((el) => {
+			switch (el.type) {
+				case "bracket": return "]";
+				case "bold_star": return "**";
+				case "bold_underscore": return "__";
+				case "strike": return "~~";
+				case "italic_star": return "*";
+				case "italic_underscore": return "_";
+				default: return "";
+			}
+		});
+		let result = s + closers.join("");
+		const finalFenceMatches = Array.from(result.matchAll(/^(\s*)(`{3,}|~{3,})/gm));
+		const hasUnclosedBacktick = (result.match(/`/g) || []).length % 2 === 1;
+		const hasUnclosedCodeFence = finalFenceMatches.length % 2 === 1;
+		let shouldCloseParens = !hasUnclosedBacktick && !hasUnclosedCodeFence;
+		if (shouldCloseParens) {
+			const lastOpenParen = result.lastIndexOf("(");
+			if (lastOpenParen !== -1) {
+				if ((result.substring(0, lastOpenParen).match(/`/g) || []).length % 2 === 1) shouldCloseParens = false;
+			}
+		}
+		if (shouldCloseParens) {
+			const openParens = (result.match(/\(/g) || []).length;
+			const closeParens = (result.match(/\)/g) || []).length;
+			if (openParens > closeParens) result += ")".repeat(openParens - closeParens);
+		}
+		return result;
 	}
 
 //#endregion
@@ -3799,6 +4617,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		isLoading: false,
 		isFetchingNextPage: false,
 		error: null,
+		fetchMoreError: null,
 		context: null,
 		sessionId: 0,
 		metadataCredentialsRequested: false,
@@ -3886,6 +4705,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		isLoading: Boolean(context),
 		isFetchingNextPage: false,
 		error: null,
+		fetchMoreError: null,
 		metadataCredentialsRequested: false,
 		metadataJoinCode: null,
 		nextCursor: null,
@@ -3897,6 +4717,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		isLoading: false,
 		isFetchingNextPage: false,
 		error: null,
+		fetchMoreError: null,
 		metadataCredentialsRequested: false,
 		metadataJoinCode: null,
 		nextCursor: null,
@@ -3907,7 +4728,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return {
 			...state,
 			isLoading: true,
-			error: null
+			error: null,
+			fetchMoreError: null
 		};
 	}), on(threadRestEvents.listSucceeded, (state, { sessionId, threads, joinCode, nextCursor }) => {
 		if (sessionId !== state.sessionId) return state;
@@ -3917,6 +4739,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			threads: sortThreadsByRecency(threads),
 			isLoading: false,
 			error: null,
+			fetchMoreError: null,
 			metadataJoinCode: joinCode,
 			metadataCredentialsRequested: joinCodeChanged ? false : state.metadataCredentialsRequested,
 			nextCursor
@@ -3936,6 +4759,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			...state,
 			threads: merged,
 			isFetchingNextPage: false,
+			fetchMoreError: null,
 			nextCursor
 		};
 	}), on(threadRestEvents.nextPageFailed, (state, { sessionId, error }) => {
@@ -3943,7 +4767,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		return {
 			...state,
 			isFetchingNextPage: false,
-			error
+			fetchMoreError: error
 		};
 	}), on(threadRestEvents.metadataCredentialsFailed, (state, { sessionId }) => {
 		if (sessionId !== state.sessionId) return state;
@@ -3961,7 +4785,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 		if (!state.nextCursor || state.isFetchingNextPage) return state;
 		return {
 			...state,
-			isFetchingNextPage: true
+			isFetchingNextPage: true,
+			fetchMoreError: null
 		};
 	}), on(threadAdapterEvents.renameRequested, (state, { threadId, name }) => {
 		const existing = state.threads.find((thread) => thread.id === threadId);
@@ -4091,6 +4916,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 			threads: createSelector((state) => state.threads),
 			isLoading: createSelector((state) => state.isLoading),
 			error: createSelector((state) => state.error),
+			fetchMoreError: createSelector((state) => state.fetchMoreError),
 			hasNextPage: createSelector((state) => state.nextCursor != null),
 			isFetchingNextPage: createSelector((state) => state.isFetchingNextPage),
 			isMutating: createSelector((state) => state.inFlightMutationCount > 0)
@@ -4100,6 +4926,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	const selectThreads = standaloneSelectors.threads;
 	const selectThreadsIsLoading = standaloneSelectors.isLoading;
 	const selectThreadsError = standaloneSelectors.error;
+	const selectFetchMoreError = standaloneSelectors.fetchMoreError;
 	const selectHasNextPage = standaloneSelectors.hasNextPage;
 	const selectIsFetchingNextPage = standaloneSelectors.isFetchingNextPage;
 	const selectIsMutating = standaloneSelectors.isMutating;
@@ -4485,6 +5312,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 	const ɵselectThreads = selectThreads;
 	const ɵselectThreadsIsLoading = selectThreadsIsLoading;
 	const ɵselectThreadsError = selectThreadsError;
+	const ɵselectFetchMoreError = selectFetchMoreError;
 	const ɵselectHasNextPage = selectHasNextPage;
 	const ɵselectIsFetchingNextPage = selectIsFetchingNextPage;
 	const ɵselectIsMutating = selectIsMutating;
@@ -4549,6 +5377,8 @@ exports.CopilotKitCore = CopilotKitCore;
 exports.CopilotKitCoreErrorCode = CopilotKitCoreErrorCode;
 exports.CopilotKitCoreRuntimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus;
 exports.IntelligenceAgent = IntelligenceAgent;
+exports.MEMORY_ERROR_REGISTRY = MEMORY_ERROR_REGISTRY;
+exports.MemoryError = MemoryError;
 exports.ProxiedCopilotRuntimeAgent = ProxiedCopilotRuntimeAgent;
 exports.RunHandler = RunHandler;
 exports.StateManager = StateManager;
@@ -4562,6 +5392,7 @@ exports.createSelector = createSelector;
 exports.createStore = createStore;
 exports.empty = empty;
 exports.ensureObjectArgs = ensureObjectArgs;
+exports.isAbortError = isAbortError;
 exports.isRunCompletionAware = isRunCompletionAware;
 exports.ofType = ofType;
 exports.on = on;
@@ -4570,19 +5401,33 @@ exports.props = props;
 exports.select = select;
 exports.ɵCOPILOTKIT_FEATURES = ɵCOPILOTKIT_FEATURES;
 exports.ɵMAX_SOCKET_RETRIES = ɵMAX_SOCKET_RETRIES;
+exports.ɵcreateMemoryStore = createMemoryStore;
 exports.ɵcreateThreadSelectors = ɵcreateThreadSelectors;
 exports.ɵcreateThreadStore = createThreadStore;
 exports.ɵisCopilotKitFeature = ɵisCopilotKitFeature;
+exports.ɵisRetryableMemoryStatus = isRetryableStatus;
 exports.ɵjoinPhoenixChannel$ = ɵjoinPhoenixChannel$;
+exports.ɵmapMemoryMetadataEvent = ɵmapMemoryMetadataEvent;
+exports.ɵmemoryAdapterEvents = ɵmemoryAdapterEvents;
+exports.ɵmemoryDomainEvents = ɵmemoryDomainEvents;
+exports.ɵmemoryReducer = ɵmemoryReducer;
+exports.ɵmemoryRestEvents = ɵmemoryRestEvents;
 exports.ɵobservePhoenixEvent$ = ɵobservePhoenixEvent$;
 exports.ɵobservePhoenixJoinOutcome$ = ɵobservePhoenixJoinOutcome$;
 exports.ɵobservePhoenixSocketHealth$ = ɵobservePhoenixSocketHealth$;
 exports.ɵobservePhoenixSocketSignals$ = ɵobservePhoenixSocketSignals$;
 exports.ɵphoenixChannel$ = ɵphoenixChannel$;
 exports.ɵphoenixSocket$ = ɵphoenixSocket$;
+exports.ɵselectFetchMoreError = ɵselectFetchMoreError;
 exports.ɵselectHasNextPage = ɵselectHasNextPage;
 exports.ɵselectIsFetchingNextPage = ɵselectIsFetchingNextPage;
 exports.ɵselectIsMutating = ɵselectIsMutating;
+exports.ɵselectMemories = ɵselectMemories;
+exports.ɵselectMemoriesAvailable = ɵselectMemoriesAvailable;
+exports.ɵselectMemoriesError = ɵselectMemoriesError;
+exports.ɵselectMemoriesIsLoading = ɵselectMemoriesIsLoading;
+exports.ɵselectMemoriesIsMutating = ɵselectMemoriesIsMutating;
+exports.ɵselectMemoriesRealtimeStatus = ɵselectMemoriesRealtimeStatus;
 exports.ɵselectThreads = ɵselectThreads;
 exports.ɵselectThreadsError = ɵselectThreadsError;
 exports.ɵselectThreadsIsLoading = ɵselectThreadsIsLoading;