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

package/dist/v2/index.umd.js

@@ -3635,12 +3635,13 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		}
 		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();
 			};
@@ -4366,57 +4367,58 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		UseAgentUpdate.OnRunStatusChanged
 	];
 	function useAgent({ agentId, updates, throttleMs } = {}) {
-		agentId ?? (agentId = _copilotkit_shared.DEFAULT_AGENT_ID);
+		const chatConfig = useCopilotChatConfiguration();
+		const resolvedAgentId = agentId ?? chatConfig?.agentId ?? _copilotkit_shared.DEFAULT_AGENT_ID;
 		const { copilotkit } = useCopilotKit();
 		const providerThrottleMs = copilotkit.defaultThrottleMs;
 		const [, forceUpdate] = (0, react.useReducer)((x) => x + 1, 0);
 		const updateFlags = (0, react.useMemo)(() => updates ?? ALL_UPDATES, [JSON.stringify(updates)]);
 		const provisionalAgentCache = (0, react.useRef)(/* @__PURE__ */ new Map());
 		const agent = (0, react.useMemo)(() => {
-			const existing = copilotkit.getAgent(agentId);
+			const existing = copilotkit.getAgent(resolvedAgentId);
 			if (existing) {
-				provisionalAgentCache.current.delete(agentId);
+				provisionalAgentCache.current.delete(resolvedAgentId);
 				return existing;
 			}
 			const isRuntimeConfigured = copilotkit.runtimeUrl !== void 0;
 			const status = copilotkit.runtimeConnectionStatus;
 			if (isRuntimeConfigured && (status === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Disconnected || status === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Connecting)) {
-				const cached = provisionalAgentCache.current.get(agentId);
+				const cached = provisionalAgentCache.current.get(resolvedAgentId);
 				if (cached) {
 					copilotkit.applyHeadersToAgent(cached);
 					return cached;
 				}
 				const provisional = new _copilotkit_core.ProxiedCopilotRuntimeAgent({
 					runtimeUrl: copilotkit.runtimeUrl,
-					agentId,
+					agentId: resolvedAgentId,
 					transport: copilotkit.runtimeTransport,
 					runtimeMode: "pending"
 				});
 				copilotkit.applyHeadersToAgent(provisional);
-				provisionalAgentCache.current.set(agentId, provisional);
+				provisionalAgentCache.current.set(resolvedAgentId, provisional);
 				return provisional;
 			}
 			if (isRuntimeConfigured && status === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Error) {
-				const cached = provisionalAgentCache.current.get(agentId);
+				const cached = provisionalAgentCache.current.get(resolvedAgentId);
 				if (cached) {
 					copilotkit.applyHeadersToAgent(cached);
 					return cached;
 				}
 				const provisional = new _copilotkit_core.ProxiedCopilotRuntimeAgent({
 					runtimeUrl: copilotkit.runtimeUrl,
-					agentId,
+					agentId: resolvedAgentId,
 					transport: copilotkit.runtimeTransport,
 					runtimeMode: "pending"
 				});
 				copilotkit.applyHeadersToAgent(provisional);
-				provisionalAgentCache.current.set(agentId, provisional);
+				provisionalAgentCache.current.set(resolvedAgentId, provisional);
 				return provisional;
 			}
 			const knownAgents = Object.keys(copilotkit.agents ?? {});
 			const runtimePart = isRuntimeConfigured ? `runtimeUrl=${copilotkit.runtimeUrl}` : "no runtimeUrl";
-			throw new Error(`useAgent: Agent '${agentId}' not found after runtime sync (${runtimePart}). ` + (knownAgents.length ? `Known agents: [${knownAgents.join(", ")}]` : "No agents registered.") + " Verify your runtime /info and/or agents__unsafe_dev_only.");
+			throw new Error(`useAgent: Agent '${resolvedAgentId}' not found after runtime sync (${runtimePart}). ` + (knownAgents.length ? `Known agents: [${knownAgents.join(", ")}]` : "No agents registered.") + " Verify your runtime /info and/or agents__unsafe_dev_only.");
 		}, [
-			agentId,
+			resolvedAgentId,
 			copilotkit.agents,
 			copilotkit.runtimeConnectionStatus,
 			copilotkit.runtimeUrl,
@@ -4461,7 +4463,6 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		(0, react.useEffect)(() => {
 			if (agent instanceof _ag_ui_client.HttpAgent) copilotkit.applyHeadersToAgent(agent);
 		}, [agent, JSON.stringify(copilotkit.headers)]);
-		const chatConfig = useCopilotChatConfiguration();
 		const configThreadId = chatConfig?.threadId;
 		const configHasExplicitThreadId = chatConfig?.hasExplicitThreadId;
 		(0, react.useEffect)(() => {
@@ -4475,16 +4476,87 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		return { agent };
 	}
 
+//#endregion
+//#region src/v2/hooks/use-subagent.tsx
+	const warnedAmbiguousNames = /* @__PURE__ */ new Set();
+	function resolveSubagent(subagents, subagentId, subagentName) {
+		if (subagentId) {
+			const match = subagents[subagentId];
+			return match ? { ...match } : void 0;
+		}
+		if (subagentName) {
+			const matches = Object.values(subagents).filter((s) => s.name === subagentName);
+			if (matches.length === 0) return;
+			const chosen = matches[matches.length - 1];
+			return matches.length > 1 ? {
+				...chosen,
+				isAmbiguous: true,
+				matchCount: matches.length
+			} : { ...chosen };
+		}
+	}
+	/**
+	* Read a subagent's live lifecycle state (name, description, running status)
+	* from the CopilotKit core subagent registry, by id or by declared name.
+	*
+	* @example
+	* const sub = useSubagent({ subagentId: message.subagentId });
+	* // sub?.name, sub?.description, sub?.status
+	*/
+	function useSubagent(params) {
+		const { subagentId, subagentName, agentId } = params;
+		const { copilotkit } = useCopilotKit();
+		const config = useCopilotChatConfiguration();
+		const resolvedAgentId = (0, react.useMemo)(() => agentId ?? config?.agentId ?? _copilotkit_shared.DEFAULT_AGENT_ID, [agentId, config?.agentId]);
+		const [subagent, setSubagent] = (0, react.useState)(() => resolveSubagent(copilotkit.getSubagents(resolvedAgentId), subagentId, subagentName));
+		(0, react.useEffect)(() => {
+			setSubagent(resolveSubagent(copilotkit.getSubagents(resolvedAgentId), subagentId, subagentName));
+		}, [
+			copilotkit,
+			resolvedAgentId,
+			subagentId,
+			subagentName
+		]);
+		(0, react.useEffect)(() => {
+			const subscription = copilotkit.subscribe({ onSubagentsChanged: ({ agentId: changedAgentId, subagents }) => {
+				if (changedAgentId !== resolvedAgentId) return;
+				setSubagent(resolveSubagent(subagents, subagentId, subagentName));
+			} });
+			return () => {
+				subscription.unsubscribe();
+			};
+		}, [
+			copilotkit,
+			resolvedAgentId,
+			subagentId,
+			subagentName
+		]);
+		(0, react.useEffect)(() => {
+			if (process.env.NODE_ENV === "production" || !subagentName || !subagent?.isAmbiguous) return;
+			const key = `${subagentName}:${subagent.matchCount}`;
+			if (warnedAmbiguousNames.has(key)) return;
+			warnedAmbiguousNames.add(key);
+			console.warn(`[CopilotKit] useSubagent({ subagentName: ${JSON.stringify(subagentName)} }) matched ${subagent.matchCount} subagents. Returning the most recently started one; pass a subagentId for a stable reference.`);
+		}, [
+			subagentName,
+			subagent?.isAmbiguous,
+			subagent?.matchCount
+		]);
+		return subagent;
+	}
+
 //#endregion
 //#region src/v2/hooks/use-capabilities.tsx
 /**
-	* Returns the capabilities declared by the given agent (or the default agent).
+	* Returns the capabilities declared by the given agent (or the agent resolved
+	* from the surrounding chat configuration, falling back to the default agent).
 	* Capabilities are populated from the runtime `/info` response at connection
 	* time. The hook reads them synchronously from the agent instance — there is
 	* no separate loading state, but the value will be `undefined` until the
 	* runtime handshake completes.
 	*
-	* @param agentId - Optional agent ID. If omitted, uses the default agent.
+	* @param agentId - Optional agent ID. If omitted, inherits the surrounding
+	*          chat configuration's agent, falling back to the default agent.
 	* @returns The agent's capabilities, or `undefined` if the agent doesn't
 	*          declare capabilities.
 	*/
@@ -5057,6 +5129,7 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		})), [coreThreads]);
 		const storeIsLoading = useThreadStoreSelector(store, _copilotkit_core.ɵselectThreadsIsLoading);
 		const storeError = useThreadStoreSelector(store, _copilotkit_core.ɵselectThreadsError);
+		const fetchMoreError = useThreadStoreSelector(store, _copilotkit_core.ɵselectFetchMoreError);
 		const hasMoreThreads = useThreadStoreSelector(store, _copilotkit_core.ɵselectHasNextPage);
 		const isFetchingMoreThreads = useThreadStoreSelector(store, _copilotkit_core.ɵselectIsFetchingNextPage);
 		const isMutating = useThreadStoreSelector(store, _copilotkit_core.ɵselectIsMutating);
@@ -5162,6 +5235,7 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 			isLoading,
 			error,
 			listError,
+			fetchMoreError,
 			hasMoreThreads,
 			isFetchingMoreThreads,
 			isMutating,
@@ -5178,6 +5252,70 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		};
 	}
 
+//#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
 /**
@@ -7940,9 +8078,57 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		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;
@@ -7955,6 +8141,7 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 			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) {
@@ -7965,6 +8152,14 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 						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);
@@ -7979,6 +8174,119 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 			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;
@@ -8027,15 +8335,34 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 				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();
@@ -8044,12 +8371,34 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 				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 });
@@ -8828,7 +9177,7 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 	*   during prerender to avoid hydration mismatch).
 	* - Feeds the element domain data: `threads`, `loading`, `error`,
 	*   `activeThreadId`, `licensed`, fetch-more state.
-	* - Routes the element's nine outbound events to core thread operations
+	* - Routes the element's outbound events to core thread operations
 	*   ({@link useThreads}) and chat-configuration changes.
 	* - Registers with the surrounding chat configuration so the header
 	*   thread-list launcher appears, and binds the element `open` state to the
@@ -8855,16 +9204,16 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 	* </CopilotKitProvider>
 	* ```
 	*/
-	function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed, licenseUrl, renderRow, label, limit, "data-testid": dataTestId = "copilot-threads-drawer" }) {
+	function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed, licenseUrl, renderRow, label, recentLabel, collapsible, onCollapseChange, limit, "data-testid": dataTestId = "copilot-threads-drawer" }) {
 		const configuration = useCopilotChatConfiguration();
 		const { status, checkFeature } = useLicenseContext();
 		const licensePresent = status === "valid" || status === "expiring";
 		const featureLicensed = checkFeature("threads");
 		const licensed = licensePresent && featureLicensed;
 		const licensePending = status === null;
-		const resolvedAgentId = agentId ?? configuration?.agentId ?? "default";
+		const resolvedAgentId = agentId ?? configuration?.agentId ?? _copilotkit_shared.DEFAULT_AGENT_ID;
 		const activeThreadId = configuration?.threadId ?? null;
-		const { threads, isLoading, listError, hasMoreThreads, isFetchingMoreThreads, archiveThread, unarchiveThread, deleteThread, fetchMoreThreads, refetchThreads, startNewThread } = useThreads({
+		const { threads, isLoading, listError, fetchMoreError, hasMoreThreads, isFetchingMoreThreads, archiveThread, unarchiveThread, deleteThread, fetchMoreThreads, refetchThreads, startNewThread } = useThreads({
 			agentId: resolvedAgentId,
 			includeArchived: true,
 			enabled: licensed,
@@ -8945,6 +9294,9 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		const handleLoadMore = (0, react.useCallback)(() => {
 			fetchMoreThreads();
 		}, [fetchMoreThreads]);
+		const handleCollapseChange = (0, react.useCallback)((collapsed) => {
+			onCollapseChange?.(collapsed);
+		}, [onCollapseChange]);
 		const handlersRef = (0, react.useRef)({
 			handleThreadSelected,
 			handleNewThread,
@@ -8955,7 +9307,8 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 			handleRetry,
 			handleOpenChange,
 			handleLicensed,
-			handleLoadMore
+			handleLoadMore,
+			handleCollapseChange
 		});
 		handlersRef.current = {
 			handleThreadSelected,
@@ -8967,7 +9320,8 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 			handleRetry,
 			handleOpenChange,
 			handleLicensed,
-			handleLoadMore
+			handleLoadMore,
+			handleCollapseChange
 		};
 		(0, react.useEffect)(() => {
 			const el = elementRef.current;
@@ -9002,6 +9356,10 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 			};
 			const onLicensedEvent = () => handlersRef.current.handleLicensed();
 			const onLoadMore = () => handlersRef.current.handleLoadMore();
+			const onCollapseChangeEvent = (event) => {
+				const detail = event.detail;
+				handlersRef.current.handleCollapseChange(detail.collapsed);
+			};
 			el.addEventListener("thread-selected", onThreadSelected);
 			el.addEventListener("new-thread", onNewThreadEvent);
 			el.addEventListener("archive", onArchive);
@@ -9012,6 +9370,7 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 			el.addEventListener("retry", onRetry);
 			el.addEventListener("licensed", onLicensedEvent);
 			el.addEventListener("load-more", onLoadMore);
+			el.addEventListener("collapse-change", onCollapseChangeEvent);
 			return () => {
 				el.removeEventListener("thread-selected", onThreadSelected);
 				el.removeEventListener("new-thread", onNewThreadEvent);
@@ -9023,6 +9382,7 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 				el.removeEventListener("retry", onRetry);
 				el.removeEventListener("licensed", onLicensedEvent);
 				el.removeEventListener("load-more", onLoadMore);
+				el.removeEventListener("collapse-change", onCollapseChangeEvent);
 			};
 		}, [mounted]);
 		(0, react.useEffect)(() => {
@@ -9039,9 +9399,11 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 			el.licensed = licensed || licensePending;
 			el.hasMore = hasMoreThreads;
 			el.fetchingMore = isFetchingMoreThreads;
+			el.fetchMoreError = fetchMoreError ? fetchMoreError.message : null;
 		}, [
 			isLoading,
 			listError,
+			fetchMoreError,
 			activeThreadId,
 			licensed,
 			licensePending,
@@ -9064,6 +9426,11 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 			if (!el) return;
 			if (licenseUrl !== void 0) el.licenseUrl = licenseUrl;
 		}, [licenseUrl, mounted]);
+		(0, react.useEffect)(() => {
+			const el = elementRef.current;
+			if (!el) return;
+			if (collapsible !== void 0) el.collapsible = collapsible;
+		}, [collapsible, mounted]);
 		const rowChildren = (0, react.useMemo)(() => {
 			if (!renderRow) return null;
 			return drawerThreads.map((drawerThread) => {
@@ -9084,7 +9451,8 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		if (!mounted) return null;
 		return react.default.createElement(_copilotkit_web_components_threads_drawer.COPILOTKIT_THREADS_DRAWER_TAG, {
 			ref: elementRef,
-			"data-testid": dataTestId
+			"data-testid": dataTestId,
+			...recentLabel !== void 0 ? { "recent-label": recentLabel } : {}
 		}, rowChildren);
 	}
 	CopilotThreadsDrawer.displayName = "CopilotThreadsDrawer";
@@ -10623,8 +10991,18 @@ window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-
 		}, [agent, getSubscriber]);
 	};
 	function CopilotListenersAgentSubscription() {
-		const resolvedAgentId = useCopilotChatConfiguration()?.agentId;
-		const { agent } = useAgent({ agentId: resolvedAgentId });
+		const { copilotkit } = useCopilotKit();
+		const configAgentId = useCopilotChatConfiguration()?.agentId;
+		const { agent } = useAgent({ agentId: (0, react.useMemo)(() => {
+			const requested = configAgentId ?? _copilotkit_shared.DEFAULT_AGENT_ID;
+			const registered = copilotkit.agents ?? {};
+			if (registered[requested]) return requested;
+			if (requested === _copilotkit_shared.DEFAULT_AGENT_ID) {
+				const firstRegistered = Object.keys(registered)[0];
+				if (firstRegistered) return firstRegistered;
+			}
+			return requested;
+		}, [configAgentId, copilotkit.agents]) });
 		usePredictStateSubscription(agent);
 		return null;
 	}
@@ -11239,11 +11617,13 @@ exports.useLearnFromUserAction = useLearnFromUserAction;
 exports.useLearnFromUserActionInCurrentThread = useLearnFromUserActionInCurrentThread;
 exports.useLearningContainers = useLearningContainers;
 exports.useLearningContainersInCurrentThread = useLearningContainersInCurrentThread;
+exports.useMemories = useMemories;
 exports.useRenderActivityMessage = useRenderActivityMessage;
 exports.useRenderCustomMessages = useRenderCustomMessages;
 exports.useRenderTool = useRenderTool;
 exports.useRenderToolCall = useRenderToolCall;
 exports.useSandboxFunctions = useSandboxFunctions;
+exports.useSubagent = useSubagent;
 exports.useSuggestions = useSuggestions;
 exports.useThreads = useThreads;
 Object.keys(_copilotkit_core).forEach(function (k) {