@copilotkit/core 1.69.0 → 1.69.1

package/dist/index.cjs

@@ -1999,6 +1999,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
 /**
@@ -2182,8 +2206,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);
@@ -2217,6 +2241,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,
@@ -2363,21 +2388,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.
@@ -2850,6 +2861,61 @@ 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
@@ -2865,15 +2931,39 @@ var StateManager = class {
 				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;
@@ -3012,7 +3102,7 @@ var StateManager = class {
 	/**
 	* 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) if (this.getRunIdForMessage(agent.agentId, threadId, message.id) === void 0) this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
@@ -4935,6 +5025,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) => (0, rxjs.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
 /**
@@ -5979,6 +6130,101 @@ var ɵInterruptState = class {
 	}
 };
 
+//#endregion
+//#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
 exports.AgentRegistry = AgentRegistry;
 exports.AgentThreadLockedError = AgentThreadLockedError;
@@ -5986,6 +6232,7 @@ exports.ContextStore = ContextStore;
 exports.CopilotKitCore = CopilotKitCore;
 exports.CopilotKitCoreErrorCode = CopilotKitCoreErrorCode;
 exports.CopilotKitCoreRuntimeConnectionStatus = CopilotKitCoreRuntimeConnectionStatus;
+exports.INSPECTOR_THREAD_BRIDGE_PLUGIN_ID = INSPECTOR_THREAD_BRIDGE_PLUGIN_ID;
 exports.IntelligenceAgent = IntelligenceAgent;
 exports.MEMORY_ERROR_REGISTRY = MEMORY_ERROR_REGISTRY;
 exports.MemoryError = MemoryError;
@@ -5997,15 +6244,25 @@ exports.ToolCallStatus = ToolCallStatus;
 exports.completePartialMarkdown = completePartialMarkdown;
 exports.createActionGroup = createActionGroup;
 exports.createEffect = createEffect;
+exports.createInspectorThreadRequestId = createInspectorThreadRequestId;
 exports.createReducer = createReducer;
 exports.createSelector = createSelector;
 exports.createStore = createStore;
+exports.emitInspectorActiveThread = emitInspectorActiveThread;
+exports.emitInspectorStopViewing = emitInspectorStopViewing;
+exports.emitInspectorViewThread = emitInspectorViewThread;
+exports.emitInspectorViewThreadResult = emitInspectorViewThreadResult;
 exports.empty = empty;
 exports.ensureObjectArgs = ensureObjectArgs;
 exports.isAbortError = isAbortError;
+exports.isInspectorThreadBridgeEnabled = isInspectorThreadBridgeEnabled;
 exports.isRunCompletionAware = isRunCompletionAware;
 exports.ofType = ofType;
 exports.on = on;
+exports.onInspectorActiveThread = onInspectorActiveThread;
+exports.onInspectorStopViewing = onInspectorStopViewing;
+exports.onInspectorViewThread = onInspectorViewThread;
+exports.onInspectorViewThreadResult = onInspectorViewThreadResult;
 exports.parseToolArguments = parseToolArguments;
 exports.props = props;
 exports.select = select;
@@ -6015,6 +6272,7 @@ exports.ɵMAX_SOCKET_RETRIES = ɵMAX_SOCKET_RETRIES;
 exports.ɵcreateMemoryStore = createMemoryStore;
 exports.ɵcreateThreadSelectors = ɵcreateThreadSelectors;
 exports.ɵcreateThreadStore = createThreadStore;
+exports.ɵinjectInspectorEvents = ɵinjectInspectorEvents;
 exports.ɵisCopilotKitFeature = ɵisCopilotKitFeature;
 exports.ɵisRetryableMemoryStatus = isRetryableStatus;
 exports.ɵjoinPhoenixChannel$ = ɵjoinPhoenixChannel$;
@@ -6029,6 +6287,7 @@ exports.ɵobservePhoenixSocketHealth$ = ɵobservePhoenixSocketHealth$;
 exports.ɵobservePhoenixSocketSignals$ = ɵobservePhoenixSocketSignals$;
 exports.ɵphoenixChannel$ = ɵphoenixChannel$;
 exports.ɵphoenixSocket$ = ɵphoenixSocket$;
+exports.ɵresetInspectorInject = ɵresetInspectorInject;
 exports.ɵselectFetchMoreError = ɵselectFetchMoreError;
 exports.ɵselectHasNextPage = ɵselectHasNextPage;
 exports.ɵselectIsFetchingNextPage = ɵselectIsFetchingNextPage;