@copilotkit/react-core 1.62.1 → 1.62.2-canary.1783457132

package/dist/{copilotkit-CdpDZi3i.cjs → copilotkit-Ces-OkSR.cjs}

@@ -3650,12 +3650,13 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 	}
 	const copilotkit = copilotkitRef.current;
 	(0, react.useEffect)(() => {
-		setRuntimeA2UIEnabled(copilotkit.a2uiEnabled);
-		const subscription = copilotkit.subscribe({ onRuntimeConnectionStatusChanged: () => {
+		const syncRuntimeInfo = () => {
 			setRuntimeA2UIEnabled(copilotkit.a2uiEnabled);
 			setRuntimeOpenGenUIEnabled(copilotkit.openGenerativeUIEnabled);
 			setRuntimeLicenseStatus(copilotkit.licenseStatus);
-		} });
+		};
+		const subscription = copilotkit.subscribe({ onRuntimeConnectionStatusChanged: syncRuntimeInfo });
+		syncRuntimeInfo();
 		return () => {
 			subscription.unsubscribe();
 		};
@@ -5193,6 +5194,70 @@ function useThreads$1({ agentId, includeArchived, limit, enabled = true }) {
 	};
 }
 
+//#endregion
+//#region src/v2/hooks/use-memories.tsx
+function useMemoryStoreSelector(store, selector) {
+	return (0, react.useSyncExternalStore)((0, react.useCallback)((onStoreChange) => {
+		const subscription = store.select(selector).subscribe(onStoreChange);
+		return () => subscription.unsubscribe();
+	}, [store, selector]), () => selector(store.getState()), () => selector(store.getServerState()));
+}
+/**
+* React hook for listing and managing platform memories.
+*
+* Reads the memory store owned and wired by `CopilotKitCore`. On mount the
+* hook exposes the live list plus stable `addMemory` / `updateMemory` /
+* `removeMemory` / `refresh` callbacks. Mutations are server-authoritative:
+* each resolves once the platform confirms the operation and rejects with an
+* `Error` on failure.
+*
+* Realtime updates are automatic: the core's memory store opens its own
+* `user_meta:memories:<joinCode>` channel and applies `memory_metadata` deltas
+* to the list. You can still call `refresh()` to re-pull the REST snapshot on
+* demand.
+*
+* @returns Memory list state and stable mutation callbacks.
+*
+* @example
+* ```tsx
+* import { useMemories } from "@copilotkit/react-core";
+*
+* function MemoryList() {
+*   const { memories, isLoading, isAvailable, addMemory, removeMemory } =
+*     useMemories();
+*
+*   if (!isAvailable) return null;
+*   if (isLoading) return <p>Loading…</p>;
+*
+*   return (
+*     <ul>
+*       {memories.map((m) => (
+*         <li key={m.id}>
+*           {m.content}
+*           <button onClick={() => removeMemory(m.id)}>Delete</button>
+*         </li>
+*       ))}
+*     </ul>
+*   );
+* }
+* ```
+*/
+function useMemories() {
+	const { copilotkit } = useCopilotKit();
+	const store = copilotkit.getMemoryStore();
+	return {
+		memories: useMemoryStoreSelector(store, _copilotkit_core.ɵselectMemories),
+		isLoading: useMemoryStoreSelector(store, _copilotkit_core.ɵselectMemoriesIsLoading),
+		error: useMemoryStoreSelector(store, _copilotkit_core.ɵselectMemoriesError),
+		isAvailable: useMemoryStoreSelector(store, _copilotkit_core.ɵselectMemoriesAvailable),
+		realtimeStatus: useMemoryStoreSelector(store, _copilotkit_core.ɵselectMemoriesRealtimeStatus),
+		refresh: (0, react.useCallback)(() => store.refresh(), [store]),
+		addMemory: (0, react.useCallback)((input) => store.addMemory(input), [store]),
+		updateMemory: (0, react.useCallback)((id, changes) => store.updateMemory(id, changes), [store]),
+		removeMemory: (0, react.useCallback)((id) => store.removeMemory(id), [store])
+	};
+}
+
 //#endregion
 //#region src/v2/lib/record-annotation.ts
 /**
@@ -7955,9 +8020,57 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 	const { messageView: providedMessageView, suggestionView: providedSuggestionView, onStop: providedStopHandler, ...restProps } = props;
 	const [lastConnectedThreadId, setLastConnectedThreadId] = (0, react.useState)(null);
 	const isConnecting = hasExplicitThreadId && lastConnectedThreadId !== resolvedThreadId;
+	const activeConnectCountRef = (0, react.useRef)(0);
+	const pendingRunActivityReconnectRef = (0, react.useRef)(false);
+	const runActivityReconnectGenerationRef = (0, react.useRef)(0);
+	const activeLocalRunIdsRef = (0, react.useRef)(/* @__PURE__ */ new Set());
+	const recentlyLocalRunIdsRef = (0, react.useRef)(/* @__PURE__ */ new Map());
+	const activeWakeRunIdsRef = (0, react.useRef)(/* @__PURE__ */ new Set());
+	const recentlyWakeRunIdsRef = (0, react.useRef)(/* @__PURE__ */ new Map());
+	const pendingWakeRunIdRef = (0, react.useRef)(void 0);
+	const startRunActivityReconnectRef = (0, react.useRef)(null);
+	const runtimeStatus = copilotkit.runtimeConnectionStatus === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Connected ? "Connected" : copilotkit.runtimeConnectionStatus;
+	const hasNativeIntelligenceRunActivity = hasExplicitThreadId && runtimeStatus === "Connected" && !!copilotkit.intelligence?.wsUrl && copilotkit.threadEndpoints?.realtimeMetadata === true;
+	const [standaloneRunActivityStore] = (0, react.useState)(() => (0, _copilotkit_core.ɵcreateThreadStore)({ fetch: globalThis.fetch }));
 	const previousThreadIdRef = (0, react.useRef)(null);
 	const hasExplicitThreadIdRef = (0, react.useRef)(hasExplicitThreadId);
 	hasExplicitThreadIdRef.current = hasExplicitThreadId;
+	const rememberRecentlyLocalRunId = (0, react.useCallback)((runId) => {
+		const existingTimeout = recentlyLocalRunIdsRef.current.get(runId);
+		if (existingTimeout) clearTimeout(existingTimeout);
+		const timeout = setTimeout(() => {
+			recentlyLocalRunIdsRef.current.delete(runId);
+		}, 3e4);
+		recentlyLocalRunIdsRef.current.set(runId, timeout);
+	}, []);
+	const rememberRecentlyWakeRunId = (0, react.useCallback)((runId) => {
+		const existingTimeout = recentlyWakeRunIdsRef.current.get(runId);
+		if (existingTimeout) clearTimeout(existingTimeout);
+		const timeout = setTimeout(() => {
+			recentlyWakeRunIdsRef.current.delete(runId);
+		}, 3e4);
+		recentlyWakeRunIdsRef.current.set(runId, timeout);
+	}, []);
+	const isLocalActiveRunActivity = (0, react.useCallback)((notification) => {
+		if (notification.agentId && notification.agentId !== resolvedAgentId) return false;
+		if (!notification.runId || !activeLocalRunIdsRef.current.has(notification.runId) && !recentlyLocalRunIdsRef.current.has(notification.runId)) return false;
+		const eventType = notification.eventType.toUpperCase();
+		return eventType === "RUN_STARTED" || eventType === "RUN_FINISHED" || eventType === "RUN_ERROR";
+	}, [resolvedAgentId]);
+	(0, react.useEffect)(() => {
+		const recentlyLocalRunIds = recentlyLocalRunIdsRef.current;
+		const recentlyWakeRunIds = recentlyWakeRunIdsRef.current;
+		return () => {
+			recentlyLocalRunIds.forEach((timeout) => {
+				clearTimeout(timeout);
+			});
+			recentlyLocalRunIds.clear();
+			recentlyWakeRunIds.forEach((timeout) => {
+				clearTimeout(timeout);
+			});
+			recentlyWakeRunIds.clear();
+		};
+	}, []);
 	(0, react.useEffect)(() => {
 		const threadChanged = previousThreadIdRef.current !== resolvedThreadId;
 		previousThreadIdRef.current = resolvedThreadId;
@@ -7970,6 +8083,7 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 		const connectAbortController = new AbortController();
 		if (agent instanceof _ag_ui_client.HttpAgent) agent.abortController = connectAbortController;
 		const connect = async (agentToConnect) => {
+			activeConnectCountRef.current += 1;
 			try {
 				await copilotkit.connectAgent({ agent: agentToConnect });
 			} catch (error) {
@@ -7980,6 +8094,14 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 					if (!detached) setLastConnectedThreadId(resolvedThreadId);
 				});
 				else if (!hasExplicitThreadIdRef.current) agentToConnect.setMessages([]);
+				activeConnectCountRef.current = Math.max(0, activeConnectCountRef.current - 1);
+				if (!detached && activeConnectCountRef.current === 0) {
+					const startReconnect = startRunActivityReconnectRef.current;
+					if (pendingRunActivityReconnectRef.current && startReconnect) {
+						pendingRunActivityReconnectRef.current = false;
+						startReconnect(runActivityReconnectGenerationRef.current);
+					}
+				}
 			}
 		};
 		connect(agent);
@@ -7994,6 +8116,119 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 		resolvedAgentId,
 		hasExplicitThreadId
 	]);
+	(0, react.useEffect)(() => {
+		if (!hasNativeIntelligenceRunActivity) return;
+		const registeredThreadStore = copilotkit.getThreadStore(resolvedAgentId);
+		const threadStore = registeredThreadStore ?? standaloneRunActivityStore;
+		if (!threadStore?.subscribeToRunActivity) return;
+		const ownsStandaloneStore = registeredThreadStore === void 0;
+		if (ownsStandaloneStore) {
+			threadStore.start();
+			const context = copilotkit.runtimeUrl ? {
+				runtimeUrl: copilotkit.runtimeUrl,
+				headers: { ...copilotkit.headers },
+				wsUrl: copilotkit.intelligence?.wsUrl,
+				agentId: resolvedAgentId
+			} : null;
+			threadStore.setContext(context);
+		}
+		const generation = runActivityReconnectGenerationRef.current + 1;
+		runActivityReconnectGenerationRef.current = generation;
+		let detached = false;
+		let wakeReconnectActive = false;
+		let pendingAgentIdleDrain = null;
+		const hasActiveAgentRun = () => activeLocalRunIdsRef.current.size > 0 || agent.isRunning;
+		const scheduleAgentIdleDrain = () => {
+			if (pendingAgentIdleDrain !== null) return;
+			pendingAgentIdleDrain = setTimeout(() => {
+				pendingAgentIdleDrain = null;
+				if (detached || runActivityReconnectGenerationRef.current !== generation || !pendingRunActivityReconnectRef.current) return;
+				if (hasActiveAgentRun()) {
+					scheduleAgentIdleDrain();
+					return;
+				}
+				startRunActivityReconnectRef.current?.(generation);
+			}, 10);
+		};
+		const connect = async () => {
+			activeConnectCountRef.current += 1;
+			wakeReconnectActive = true;
+			const wakeRunId = pendingWakeRunIdRef.current;
+			pendingWakeRunIdRef.current = void 0;
+			if (wakeRunId) activeWakeRunIdsRef.current.add(wakeRunId);
+			let didConnect = false;
+			try {
+				await copilotkit.connectAgent({ agent });
+				didConnect = true;
+			} catch (error) {
+				if (!detached) console.error("CopilotChat: run activity reconnect failed", error);
+			} finally {
+				if (wakeRunId) {
+					activeWakeRunIdsRef.current.delete(wakeRunId);
+					if (didConnect) rememberRecentlyWakeRunId(wakeRunId);
+				}
+				activeConnectCountRef.current = Math.max(0, activeConnectCountRef.current - 1);
+				wakeReconnectActive = false;
+				if (!detached && runActivityReconnectGenerationRef.current === generation && activeConnectCountRef.current === 0 && pendingRunActivityReconnectRef.current) {
+					pendingRunActivityReconnectRef.current = false;
+					connect();
+				}
+			}
+		};
+		startRunActivityReconnectRef.current = (requestedGeneration) => {
+			if (detached || requestedGeneration !== generation || runActivityReconnectGenerationRef.current !== generation) return;
+			if (hasActiveAgentRun()) {
+				pendingRunActivityReconnectRef.current = true;
+				scheduleAgentIdleDrain();
+				return;
+			}
+			if (activeConnectCountRef.current > 0) {
+				if (!wakeReconnectActive) pendingRunActivityReconnectRef.current = true;
+				return;
+			}
+			pendingRunActivityReconnectRef.current = false;
+			connect();
+		};
+		const subscription = threadStore.subscribeToRunActivity((notification) => {
+			if (notification.threadId !== resolvedThreadId) return;
+			if (notification.agentId && notification.agentId !== resolvedAgentId) return;
+			if (isLocalActiveRunActivity(notification)) return;
+			if (notification.runId && (activeWakeRunIdsRef.current.has(notification.runId) || recentlyWakeRunIdsRef.current.has(notification.runId))) return;
+			pendingWakeRunIdRef.current = notification.runId;
+			startRunActivityReconnectRef.current?.(generation);
+		});
+		return () => {
+			detached = true;
+			pendingRunActivityReconnectRef.current = false;
+			pendingWakeRunIdRef.current = void 0;
+			if (pendingAgentIdleDrain !== null) {
+				clearTimeout(pendingAgentIdleDrain);
+				pendingAgentIdleDrain = null;
+			}
+			if (startRunActivityReconnectRef.current) startRunActivityReconnectRef.current = null;
+			if (wakeReconnectActive) agent.detachActiveRun().catch(() => {});
+			activeWakeRunIdsRef.current.clear();
+			subscription.unsubscribe();
+			if (ownsStandaloneStore) {
+				threadStore.setContext(null);
+				threadStore.stop();
+			}
+		};
+	}, [
+		agent,
+		resolvedAgentId,
+		resolvedThreadId,
+		hasExplicitThreadId,
+		hasNativeIntelligenceRunActivity,
+		copilotkit.runtimeConnectionStatus,
+		copilotkit.runtimeUrl,
+		copilotkit.headers,
+		copilotkit.intelligence?.wsUrl,
+		copilotkit.threadEndpoints?.realtimeMetadata,
+		standaloneRunActivityStore,
+		isLocalActiveRunActivity,
+		rememberRecentlyWakeRunId
+	]);
 	const waitForActiveRunToSettle = (0, react.useCallback)(async () => {
 		const maybeAware = agent;
 		const activeRunCompletionPromise = (0, _copilotkit_core.isRunCompletionAware)(maybeAware) ? maybeAware.activeRunCompletionPromise : void 0;
@@ -8042,15 +8277,34 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 			role: "user",
 			content: value
 		});
+		const localRunId = hasNativeIntelligenceRunActivity ? (0, _copilotkit_shared.randomUUID)() : void 0;
+		if (localRunId) activeLocalRunIdsRef.current.add(localRunId);
 		try {
-			await copilotkit.runAgent({ agent });
+			await copilotkit.runAgent({
+				agent,
+				...localRunId !== void 0 ? { runId: localRunId } : {}
+			});
 		} catch (error) {
 			console.error("CopilotChat: runAgent failed", error);
+		} finally {
+			if (localRunId) {
+				activeLocalRunIdsRef.current.delete(localRunId);
+				rememberRecentlyLocalRunId(localRunId);
+			}
+			if (pendingRunActivityReconnectRef.current && activeLocalRunIdsRef.current.size === 0 && activeConnectCountRef.current === 0) {
+				const startReconnect = startRunActivityReconnectRef.current;
+				if (startReconnect) {
+					pendingRunActivityReconnectRef.current = false;
+					startReconnect(runActivityReconnectGenerationRef.current);
+				}
+			}
 		}
 	}, [
 		agent,
 		consumeAttachments,
-		waitForActiveRunToSettle
+		waitForActiveRunToSettle,
+		hasNativeIntelligenceRunActivity,
+		rememberRecentlyLocalRunId
 	]);
 	const handleSelectSuggestion = (0, react.useCallback)(async (suggestion) => {
 		await waitForActiveRunToSettle();
@@ -8059,12 +8313,34 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 			role: "user",
 			content: suggestion.message
 		});
+		const localRunId = hasNativeIntelligenceRunActivity ? (0, _copilotkit_shared.randomUUID)() : void 0;
+		if (localRunId) activeLocalRunIdsRef.current.add(localRunId);
 		try {
-			await copilotkit.runAgent({ agent });
+			await copilotkit.runAgent({
+				agent,
+				...localRunId !== void 0 ? { runId: localRunId } : {}
+			});
 		} catch (error) {
 			console.error("CopilotChat: runAgent failed after selecting suggestion", error);
+		} finally {
+			if (localRunId) {
+				activeLocalRunIdsRef.current.delete(localRunId);
+				rememberRecentlyLocalRunId(localRunId);
+			}
+			if (pendingRunActivityReconnectRef.current && activeLocalRunIdsRef.current.size === 0 && activeConnectCountRef.current === 0) {
+				const startReconnect = startRunActivityReconnectRef.current;
+				if (startReconnect) {
+					pendingRunActivityReconnectRef.current = false;
+					startReconnect(runActivityReconnectGenerationRef.current);
+				}
+			}
 		}
-	}, [agent, waitForActiveRunToSettle]);
+	}, [
+		agent,
+		waitForActiveRunToSettle,
+		hasNativeIntelligenceRunActivity,
+		rememberRecentlyLocalRunId
+	]);
 	const stopCurrentRun = (0, react.useCallback)(() => {
 		try {
 			copilotkit.stopAgent({ agent });
@@ -11706,6 +11982,12 @@ Object.defineProperty(exports, 'useLearningContainersInCurrentThread', {
     return useLearningContainersInCurrentThread;
   }
 });
+Object.defineProperty(exports, 'useMemories', {
+  enumerable: true,
+  get: function () {
+    return useMemories;
+  }
+});
 Object.defineProperty(exports, 'useRenderActivityMessage', {
   enumerable: true,
   get: function () {
@@ -11760,4 +12042,4 @@ Object.defineProperty(exports, 'useToast', {
     return useToast;
   }
 });
-//# sourceMappingURL=copilotkit-CdpDZi3i.cjs.map
+//# sourceMappingURL=copilotkit-Ces-OkSR.cjs.map