@copilotkit/core 1.68.3 → 1.69.1

package/dist/index.mjs

@@ -1998,6 +1998,30 @@ const SUGGEST_TOOL = {
 	}
 };
 
+//#endregion
+//#region src/core/tool-result-content.ts
+/**
+* Single authority for the forwarded-to-client sentinel used by StateManager
+* and RunHandler.
+*/
+const FORWARDED_TO_CLIENT = "Forwarded to client";
+function normalizeToolResultContent(content) {
+	if (typeof content === "string") return content.trim();
+	if (Array.isArray(content)) {
+		const text = content.flatMap((part) => {
+			if (typeof part === "string") return [part];
+			if (part && typeof part === "object" && "text" in part && typeof part.text === "string") return [part.text];
+			return [];
+		}).join("").trim();
+		return text.length > 0 ? text : null;
+	}
+	if (content && typeof content === "object" && "text" in content && typeof content.text === "string") return content.text.trim();
+	return null;
+}
+function isForwardedToClientPlaceholder(content) {
+	return normalizeToolResultContent(content) === FORWARDED_TO_CLIENT;
+}
+
 //#endregion
 //#region src/core/run-handler.ts
 /**
@@ -2181,8 +2205,8 @@ var RunHandler = class {
 	* Connect an agent (establish initial connection)
 	*/
 	async connectAgent({ agent }) {
+		const incomingThreadId = agent.threadId ?? null;
 		try {
-			const incomingThreadId = agent.threadId ?? null;
 			const restoreKey = this.getConnectRestoreKey(agent);
 			const isFreshRestore = incomingThreadId !== (this._lastConnectedThreadIdsByAgent.get(restoreKey) ?? null);
 			this._lastConnectedThreadIdsByAgent.set(restoreKey, incomingThreadId);
@@ -2216,6 +2240,7 @@ var RunHandler = class {
 			if (!(connectError.name === "AbortError" || connectError.message === "Fetch is aborted" || connectError.message === "signal is aborted without reason" || connectError.message === "component unmounted")) {
 				const context = {};
 				if (agent.agentId) context.agentId = agent.agentId;
+				if (incomingThreadId) context.threadId = incomingThreadId;
 				await this._internal.emitError({
 					error: connectError,
 					code: CopilotKitCoreErrorCode.AGENT_CONNECT_FAILED,
@@ -2362,21 +2387,7 @@ var RunHandler = class {
 		return runAgentResult;
 	}
 	isFrontendPlaceholderResult(message) {
-		if (message.role !== "tool") return false;
-		return this.normalizeToolResultContent(message.content) === "Forwarded to client";
-	}
-	normalizeToolResultContent(content) {
-		if (typeof content === "string") return content.trim();
-		if (Array.isArray(content)) {
-			const text = content.flatMap((part) => {
-				if (typeof part === "string") return [part];
-				if (part && typeof part === "object" && "text" in part && typeof part.text === "string") return [part.text];
-				return [];
-			}).join("").trim();
-			return text.length > 0 ? text : null;
-		}
-		if (content && typeof content === "object" && "text" in content && typeof content.text === "string") return content.text.trim();
-		return null;
+		return message.role === "tool" && isForwardedToClientPlaceholder(message.content);
 	}
 	/**
 	* Shared handler execution logic used by executeSpecificTool, executeWildcardTool, and runTool.
@@ -2802,6 +2813,7 @@ const isContinuation = (input) => input.resume !== void 0 || Object.prototype.ha
 var StateManager = class {
 	stateByRun = /* @__PURE__ */ new Map();
 	messageToRun = /* @__PURE__ */ new Map();
+	rawEventByMessage = /* @__PURE__ */ new Map();
 	activeRun = /* @__PURE__ */ new Map();
 	agentSubscriptions = /* @__PURE__ */ new Map();
 	pendingContinuations = /* @__PURE__ */ new WeakMap();
@@ -2848,29 +2860,109 @@ var StateManager = class {
 		let revoked = false;
 		let subRunId;
 		let runFinished = false;
+		const pendingResults = /* @__PURE__ */ new WeakMap();
+		const reconcilePendingResults = (historyMessages, input) => {
+			const events = pendingResults.get(input);
+			if (!events) return void 0;
+			const messages = [...historyMessages];
+			let changed = false;
+			for (const event of events.values()) {
+				const ownerIndex = messages.findIndex((message) => message.role === "assistant" && message.toolCalls?.some((toolCall) => toolCall.id === event.toolCallId));
+				if (ownerIndex < 0) continue;
+				const matchingIndexes = messages.reduce((indexes, message, index) => {
+					if (message.role === "tool" && message.toolCallId === event.toolCallId) indexes.push(index);
+					return indexes;
+				}, []);
+				const realIndex = matchingIndexes.find((index) => !isForwardedToClientPlaceholder(messages[index]?.content));
+				if (realIndex !== void 0) {
+					for (const duplicateIndex of matchingIndexes.filter((candidateIndex) => candidateIndex !== realIndex).sort((a, b) => b - a)) {
+						messages.splice(duplicateIndex, 1);
+						changed = true;
+					}
+					continue;
+				}
+				const placeholderIndex = matchingIndexes.find((index) => isForwardedToClientPlaceholder(messages[index]?.content));
+				if (placeholderIndex !== void 0) {
+					if (isForwardedToClientPlaceholder(event.content)) {
+						for (const duplicateIndex of matchingIndexes.slice(1).sort((a, b) => b - a)) {
+							messages.splice(duplicateIndex, 1);
+							changed = true;
+						}
+						continue;
+					}
+					messages[placeholderIndex] = {
+						...messages[placeholderIndex],
+						id: event.messageId,
+						content: event.content
+					};
+					changed = true;
+					for (const duplicateIndex of matchingIndexes.filter((candidateIndex) => candidateIndex !== placeholderIndex && isForwardedToClientPlaceholder(messages[candidateIndex]?.content)).sort((a, b) => b - a)) messages.splice(duplicateIndex, 1);
+					continue;
+				}
+				const result = {
+					id: event.messageId,
+					role: "tool",
+					toolCallId: event.toolCallId,
+					content: event.content
+				};
+				let insertIndex = ownerIndex + 1;
+				while (messages[insertIndex]?.role === "tool") insertIndex++;
+				messages.splice(insertIndex, 0, result);
+				changed = true;
+			}
+			return changed ? { messages } : void 0;
+		};
+		const clearPendingResults = (input) => {
+			pendingResults.delete(input);
+		};
 		const effectiveInput = (input) => ({
 			...input,
 			runId: subRunId ?? input.runId
 		});
 		const { unsubscribe } = agent.subscribe({
-			onRunStartedEvent: ({ input, state }) => {
+			onRunStartedEvent: ({ event, input, state }) => {
 				if (revoked) return;
 				const internalContinuation = [...this.pendingContinuations.get(agent) ?? []].find((pending) => pending.expectedInput === input);
 				internalContinuation?.cancel();
-				if (runFinished && input.runId === subRunId && !internalContinuation && !isContinuation(input)) subRunId = randomUUID();
-				else subRunId = internalContinuation?.expectedRunId ?? input.runId;
+				if (internalContinuation) subRunId = internalContinuation.expectedRunId ?? event.runId ?? input.runId;
+				else if (runFinished && input.runId === subRunId && !isContinuation(input) && (event.runId == null || event.runId === subRunId)) subRunId = randomUUID();
+				else subRunId = event.runId || input.runId;
 				runFinished = false;
 				this.handleRunStarted(agent, effectiveInput(input), state);
 			},
-			onRunFinishedEvent: ({ input, state }) => {
+			onRunFinishedEvent: ({ input, state, messages }) => {
 				if (revoked) return;
 				runFinished = true;
-				this.handleRunFinished(agent, effectiveInput(input), state);
+				const effective = effectiveInput(input);
+				const mutation = reconcilePendingResults(messages, input);
+				clearPendingResults(input);
+				this.handleRunFinished(agent, effective, state);
+				return mutation;
 			},
-			onRunErrorEvent: ({ input, state }) => {
+			onRunErrorEvent: ({ input, state, messages }) => {
 				if (revoked) return;
 				runFinished = true;
-				this.handleRunFinished(agent, effectiveInput(input), state);
+				const effective = effectiveInput(input);
+				const mutation = reconcilePendingResults(messages, input);
+				this.handleRunFinished(agent, effective, state);
+				return mutation;
+			},
+			onRunFailed: ({ input, messages }) => {
+				if (revoked) return;
+				return reconcilePendingResults(messages, input);
+			},
+			onRunFinalized: ({ input }) => {
+				if (revoked) return;
+				clearPendingResults(input);
+			},
+			onToolCallResultEvent: ({ event, input }) => {
+				if (revoked) return;
+				let events = pendingResults.get(input);
+				if (!events) {
+					events = /* @__PURE__ */ new Map();
+					pendingResults.set(input, events);
+				}
+				events.set(event.toolCallId, event);
 			},
 			onStateSnapshotEvent: ({ event, input, state }) => {
 				if (revoked) return;
@@ -2880,13 +2972,22 @@ var StateManager = class {
 				if (revoked) return;
 				this.handleStateDelta(agent, event, effectiveInput(input), state);
 			},
+			onTextMessageStartEvent: ({ event, input }) => {
+				if (revoked) return;
+				this.handleTextMessageStart(agent, event, effectiveInput(input));
+			},
 			onMessagesSnapshotEvent: ({ event, input, messages }) => {
 				if (revoked) return;
 				this.handleMessagesSnapshot(agent, event, effectiveInput(input), messages);
+				this.pruneRawEvents(agent.agentId, input.threadId, event.messages, effectiveInput(input));
 			},
 			onNewMessage: ({ message, input }) => {
 				if (revoked) return;
 				this.handleNewMessage(agent, message, input ? effectiveInput(input) : void 0);
+			},
+			onMessagesChanged: ({ messages, input }) => {
+				if (revoked) return;
+				if (!input) this.pruneRawEvents(agent.agentId, agent.threadId, messages);
 			}
 		});
 		this.agentSubscriptions.set(agentId, () => {
@@ -2904,6 +3005,7 @@ var StateManager = class {
 			unsubscribe();
 			this.agentSubscriptions.delete(agentId);
 		}
+		this.rawEventByMessage.delete(agentId);
 	}
 	/**
 	* Get state for a specific run
@@ -2921,6 +3023,13 @@ var StateManager = class {
 		return this.messageToRun.get(agentId)?.get(threadId)?.get(messageId);
 	}
 	/**
+	* Get direct text-start metadata associated with a message.
+	*/
+	getRawEventForMessage(agentId, threadId, messageId) {
+		const rawEvent = this.rawEventByMessage.get(agentId)?.get(threadId)?.get(messageId);
+		return rawEvent === void 0 ? void 0 : structuredClone_(rawEvent);
+	}
+	/**
 	* Get all states for an agent's thread
 	*/
 	getStatesForThread(agentId, threadId) {
@@ -2972,12 +3081,30 @@ var StateManager = class {
 		this.saveState(agent.agentId, threadId, runId, state);
 	}
 	/**
+	* Capture only defined metadata from a normalized direct text-start event.
+	*/
+	handleTextMessageStart(agent, event, input) {
+		if (!agent.agentId) return;
+		const { threadId } = input;
+		if (event.rawEvent === void 0) {
+			const threadEvents = this.rawEventByMessage.get(agent.agentId)?.get(threadId);
+			threadEvents?.delete(event.messageId);
+			if (threadEvents?.size === 0) this.rawEventByMessage.get(agent.agentId)?.delete(threadId);
+			if (this.rawEventByMessage.get(agent.agentId)?.size === 0) this.rawEventByMessage.delete(agent.agentId);
+			return;
+		}
+		if (!this.rawEventByMessage.has(agent.agentId)) this.rawEventByMessage.set(agent.agentId, /* @__PURE__ */ new Map());
+		const agentEvents = this.rawEventByMessage.get(agent.agentId);
+		if (!agentEvents.has(threadId)) agentEvents.set(threadId, /* @__PURE__ */ new Map());
+		agentEvents.get(threadId).set(event.messageId, event.rawEvent);
+	}
+	/**
 	* Handle messages snapshot event
 	*/
-	handleMessagesSnapshot(agent, event, input, messages) {
+	handleMessagesSnapshot(agent, event, input, _messages) {
 		if (!agent.agentId) return;
 		const { threadId, runId } = input;
-		for (const message of event.messages) this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
+		for (const message of event.messages) if (this.getRunIdForMessage(agent.agentId, threadId, message.id) === void 0) this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
 	}
 	/**
 	* Handle new message event
@@ -3011,12 +3138,23 @@ var StateManager = class {
 		if (!agentMessages.has(threadId)) agentMessages.set(threadId, /* @__PURE__ */ new Map());
 		agentMessages.get(threadId).set(messageId, runId);
 	}
+	pruneRawEvents(agentId, fallbackThreadId, messages, input) {
+		const threadId = input?.threadId ?? fallbackThreadId;
+		if (!threadId) return;
+		const threadEvents = this.rawEventByMessage.get(agentId)?.get(threadId);
+		if (!threadEvents) return;
+		const messageIds = new Set(messages.map((message) => message.id));
+		for (const messageId of threadEvents.keys()) if (!messageIds.has(messageId)) threadEvents.delete(messageId);
+		if (threadEvents.size === 0) this.rawEventByMessage.get(agentId)?.delete(threadId);
+		if (this.rawEventByMessage.get(agentId)?.size === 0) this.rawEventByMessage.delete(agentId);
+	}
 	/**
 	* Clear all state for an agent
 	*/
 	clearAgentState(agentId) {
 		this.stateByRun.delete(agentId);
 		this.messageToRun.delete(agentId);
+		this.rawEventByMessage.delete(agentId);
 	}
 	/**
 	* Clear all state for a thread
@@ -3024,6 +3162,7 @@ var StateManager = class {
 	clearThreadState(agentId, threadId) {
 		this.stateByRun.get(agentId)?.delete(threadId);
 		this.messageToRun.get(agentId)?.delete(threadId);
+		this.rawEventByMessage.get(agentId)?.delete(threadId);
 	}
 };
 
@@ -4853,6 +4992,9 @@ var CopilotKitCore = class {
 	getRunIdForMessage(agentId, threadId, messageId) {
 		return this.stateManager.getRunIdForMessage(agentId, threadId, messageId);
 	}
+	getRawEventForMessage(agentId, threadId, messageId) {
+		return this.stateManager.getRawEventForMessage(agentId, threadId, messageId);
+	}
 	getRunIdsForThread(agentId, threadId) {
 		return this.stateManager.getRunIdsForThread(agentId, threadId);
 	}
@@ -4882,6 +5024,67 @@ var CopilotKitCore = class {
 	async waitForPendingFrameworkUpdates() {}
 };
 
+//#endregion
+//#region src/core/inspect-inject.ts
+const REMINT_ID_KEYS = [
+	"messageId",
+	"parentMessageId",
+	"toolCallId",
+	"runId"
+];
+function newInspectorId() {
+	if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+	return `cpk-inject-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function remintInspectorEventIds(events) {
+	const mapped = /* @__PURE__ */ new Map();
+	const idFor = (value) => {
+		const existing = mapped.get(value);
+		if (existing) return existing;
+		const next = newInspectorId();
+		mapped.set(value, next);
+		return next;
+	};
+	return events.map((event) => {
+		const copy = { ...event };
+		for (const key of REMINT_ID_KEYS) {
+			const value = copy[key];
+			if (typeof value === "string" && value.length > 0) copy[key] = idFor(value);
+		}
+		return copy;
+	});
+}
+/**
+* Inspector-only helper. Apply AG-UI events to a live agent through the
+* same runAgent path a real agent uses, so chat and frontend-tool handlers
+* update. Not a documented product API.
+*/
+async function ɵinjectInspectorEvents(params) {
+	const { core, agent, events } = params;
+	if (agent.isRunning) throw new Error("The agent is running. Wait for the current run to end.");
+	if (events.length === 0) throw new Error("Snippet JSON must be an array of events.");
+	const before = new Set(agent.messages.map((message) => message.id));
+	const originalRun = agent.run;
+	const runEvents = remintInspectorEventIds(events);
+	agent.run = (_input) => from(runEvents);
+	try {
+		await core.runAgent({ agent });
+	} finally {
+		agent.run = originalRun;
+	}
+	return { messageIds: agent.messages.filter((message) => !before.has(message.id)).map((message) => message.id) };
+}
+/**
+* Remove messages created by the last Inspector inject. Does not undo
+* frontend-tool handler side effects.
+*/
+function ɵresetInspectorInject(params) {
+	const drop = new Set(params.messageIds);
+	if (drop.size === 0) return;
+	const next = params.agent.messages.filter((message) => !drop.has(message.id));
+	params.agent.setMessages(next);
+}
+
 //#endregion
 //#region src/types.ts
 /**
@@ -5137,6 +5340,16 @@ function optionalString(value) {
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 /**
+* REST `/threads` is agent-scoped. The Phoenix `user_meta` channel is not.
+* Drop live upserts that belong to a different agent, or one Inspector
+* `all-agents` flatten shows the same thread twice until a hard refresh.
+*/
+function threadMetadataTargetsAgent(payload, agentId) {
+	if (!agentId || payload.operation === "deleted") return true;
+	const threadAgentId = optionalString(payload.thread.agentId);
+	return !threadAgentId || threadAgentId === agentId;
+}
+/**
 * Converts gateway run-activity payloads into the internal TypeScript shape.
 */
 function normalizeThreadRunActivityNotification(payload) {
@@ -5562,7 +5775,7 @@ function createThreadStore(environment) {
 					}))), ɵobservePhoenixJoinOutcome$(channel$).pipe(filter((outcome) => outcome.type !== "joined"), map((outcome) => outcome.type === "timeout" ? threadSocketEvents.joinTimedOut({ sessionId: action.sessionId }) : threadSocketEvents.joinFailed({ sessionId: action.sessionId })))).pipe(takeUntil(merge(shutdown$, fatalSocketShutdown$)));
 				});
 			}))),
-			createEffect((actions$, state$) => actions$.pipe(ofType(threadSocketEvents.metadataReceived), withLatestFrom(state$), filter(([action, state]) => action.sessionId === state.sessionId), map(([action, state]) => {
+			createEffect((actions$, state$) => actions$.pipe(ofType(threadSocketEvents.metadataReceived), withLatestFrom(state$), filter(([action, state]) => action.sessionId === state.sessionId && threadMetadataTargetsAgent(action.payload, state.context?.agentId)), map(([action, state]) => {
 				if (action.payload.operation === "deleted") return threadDomainEvents.threadDeleted({
 					sessionId: action.sessionId,
 					threadId: action.payload.deleted.id
@@ -5917,5 +6130,100 @@ var ɵInterruptState = class {
 };
 
 //#endregion
-export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, IntelligenceAgent, MEMORY_ERROR_REGISTRY, MemoryError, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, completePartialMarkdown, createActionGroup, createEffect, createReducer, createSelector, createStore, empty, ensureObjectArgs, isAbortError, isRunCompletionAware, ofType, on, parseToolArguments, props, select, ɵCOPILOTKIT_FEATURES, ɵInterruptState, ɵMAX_SOCKET_RETRIES, createMemoryStore as ɵcreateMemoryStore, ɵcreateThreadSelectors, createThreadStore as ɵcreateThreadStore, ɵisCopilotKitFeature, isRetryableStatus as ɵisRetryableMemoryStatus, ɵjoinPhoenixChannel$, ɵmapMemoryMetadataEvent, ɵmemoryAdapterEvents, ɵmemoryDomainEvents, ɵmemoryReducer, ɵmemoryRestEvents, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesIsMutating, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
+//#region src/inspector-thread-bridge.ts
+const INSPECTOR_THREAD_BRIDGE_PLUGIN_ID = "cpk-inspector-thread";
+const EVENT_PREFIX = `copilotkit:${INSPECTOR_THREAD_BRIDGE_PLUGIN_ID}`;
+function eventName(suffix) {
+	return `${EVENT_PREFIX}:${suffix}`;
+}
+function getEventTarget() {
+	if (typeof window !== "undefined" && typeof window.addEventListener === "function") return window;
+	if (typeof EventTarget === "undefined") return null;
+	const sharedGlobal = globalThis;
+	sharedGlobal.__COPILOTKIT_INSPECTOR_THREAD_EVENT_TARGET__ ??= new EventTarget();
+	return sharedGlobal.__COPILOTKIT_INSPECTOR_THREAD_EVENT_TARGET__;
+}
+function createDetailEvent(name, detail) {
+	if (typeof CustomEvent !== "undefined") return new CustomEvent(name, { detail });
+	const event = new Event(name);
+	Object.defineProperty(event, "detail", { value: detail });
+	return event;
+}
+function detailFromEvent(event) {
+	return event.detail;
+}
+/** The Inspector thread bridge is development-only. */
+function isInspectorThreadBridgeEnabled() {
+	return process.env.NODE_ENV !== "production";
+}
+function createInspectorThreadRequestId() {
+	if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+	return `inspector-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function dispatch(suffix, payload) {
+	if (!isInspectorThreadBridgeEnabled()) return;
+	const target = getEventTarget();
+	if (!target) return;
+	target.dispatchEvent(createDetailEvent(eventName(suffix), payload));
+}
+function on$1(suffix, handler) {
+	if (!isInspectorThreadBridgeEnabled()) return () => void 0;
+	const target = getEventTarget();
+	if (!target) return () => void 0;
+	const listener = (event) => {
+		handler(detailFromEvent(event));
+	};
+	const name = eventName(suffix);
+	target.addEventListener(name, listener);
+	return () => target.removeEventListener(name, listener);
+}
+/**
+* Ask the first mounted official chat for the matching agent to load a thread.
+* Returns false when no chat claims the request synchronously.
+*/
+function emitInspectorViewThread(payload) {
+	if (!isInspectorThreadBridgeEnabled()) return false;
+	const target = getEventTarget();
+	if (!target) return false;
+	const detail = {
+		payload,
+		claimed: false
+	};
+	target.dispatchEvent(createDetailEvent(eventName("view-thread"), detail));
+	return detail.claimed;
+}
+function emitInspectorStopViewing(payload) {
+	dispatch("stop-viewing", payload);
+}
+function emitInspectorActiveThread(payload) {
+	dispatch("active-thread", payload);
+}
+function emitInspectorViewThreadResult(payload) {
+	dispatch("view-thread-result", payload);
+}
+function onInspectorViewThread(handler) {
+	if (!isInspectorThreadBridgeEnabled()) return () => void 0;
+	const target = getEventTarget();
+	if (!target) return () => void 0;
+	const listener = (event) => {
+		const detail = detailFromEvent(event);
+		if (detail.claimed) return;
+		detail.claimed = handler(detail.payload);
+	};
+	const name = eventName("view-thread");
+	target.addEventListener(name, listener);
+	return () => target.removeEventListener(name, listener);
+}
+function onInspectorStopViewing(handler) {
+	return on$1("stop-viewing", handler);
+}
+function onInspectorActiveThread(handler) {
+	return on$1("active-thread", handler);
+}
+function onInspectorViewThreadResult(handler) {
+	return on$1("view-thread-result", handler);
+}
+
+//#endregion
+export { AgentRegistry, AgentThreadLockedError, ContextStore, CopilotKitCore, CopilotKitCoreErrorCode, CopilotKitCoreRuntimeConnectionStatus, INSPECTOR_THREAD_BRIDGE_PLUGIN_ID, IntelligenceAgent, MEMORY_ERROR_REGISTRY, MemoryError, ProxiedCopilotRuntimeAgent, RunHandler, StateManager, SuggestionEngine, ToolCallStatus, completePartialMarkdown, createActionGroup, createEffect, createInspectorThreadRequestId, createReducer, createSelector, createStore, emitInspectorActiveThread, emitInspectorStopViewing, emitInspectorViewThread, emitInspectorViewThreadResult, empty, ensureObjectArgs, isAbortError, isInspectorThreadBridgeEnabled, isRunCompletionAware, ofType, on, onInspectorActiveThread, onInspectorStopViewing, onInspectorViewThread, onInspectorViewThreadResult, parseToolArguments, props, select, ɵCOPILOTKIT_FEATURES, ɵInterruptState, ɵMAX_SOCKET_RETRIES, createMemoryStore as ɵcreateMemoryStore, ɵcreateThreadSelectors, createThreadStore as ɵcreateThreadStore, ɵinjectInspectorEvents, ɵisCopilotKitFeature, isRetryableStatus as ɵisRetryableMemoryStatus, ɵjoinPhoenixChannel$, ɵmapMemoryMetadataEvent, ɵmemoryAdapterEvents, ɵmemoryDomainEvents, ɵmemoryReducer, ɵmemoryRestEvents, ɵobservePhoenixEvent$, ɵobservePhoenixJoinOutcome$, ɵobservePhoenixSocketHealth$, ɵobservePhoenixSocketSignals$, ɵphoenixChannel$, ɵphoenixSocket$, ɵresetInspectorInject, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesIsMutating, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading, ɵthreadAdapterEvents };
 //# sourceMappingURL=index.mjs.map