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

package/dist/{copilotkit-CdpDZi3i.cjs → copilotkit-DLwoVUsE.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();
 		};
@@ -4381,57 +4382,58 @@ const ALL_UPDATES = [
 	UseAgentUpdate.OnRunStatusChanged
 ];
 function useAgent({ agentId, updates, throttleMs } = {}) {
-	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,
@@ -4476,7 +4478,6 @@ function useAgent({ agentId, updates, throttleMs } = {}) {
 	(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)(() => {
@@ -4490,16 +4491,87 @@ function useAgent({ agentId, updates, throttleMs } = {}) {
 	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.
 */
@@ -5072,6 +5144,7 @@ function useThreads$1({ agentId, includeArchived, limit, enabled = true }) {
 	})), [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);
@@ -5177,6 +5250,7 @@ function useThreads$1({ agentId, includeArchived, limit, enabled = true }) {
 		isLoading,
 		error,
 		listError,
+		fetchMoreError,
 		hasMoreThreads,
 		isFetchingMoreThreads,
 		isMutating,
@@ -5193,6 +5267,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 +8093,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 +8156,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 +8167,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 +8189,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 +8350,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 +8386,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 });
@@ -8843,7 +9192,7 @@ function findChatInput(origin) {
 *   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
@@ -8870,16 +9219,16 @@ function findChatInput(origin) {
 * </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$1({
+	const { threads, isLoading, listError, fetchMoreError, hasMoreThreads, isFetchingMoreThreads, archiveThread, unarchiveThread, deleteThread, fetchMoreThreads, refetchThreads, startNewThread } = useThreads$1({
 		agentId: resolvedAgentId,
 		includeArchived: true,
 		enabled: licensed,
@@ -8960,6 +9309,9 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 	const handleLoadMore = (0, react.useCallback)(() => {
 		fetchMoreThreads();
 	}, [fetchMoreThreads]);
+	const handleCollapseChange = (0, react.useCallback)((collapsed) => {
+		onCollapseChange?.(collapsed);
+	}, [onCollapseChange]);
 	const handlersRef = (0, react.useRef)({
 		handleThreadSelected,
 		handleNewThread,
@@ -8970,7 +9322,8 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 		handleRetry,
 		handleOpenChange,
 		handleLicensed,
-		handleLoadMore
+		handleLoadMore,
+		handleCollapseChange
 	});
 	handlersRef.current = {
 		handleThreadSelected,
@@ -8982,7 +9335,8 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 		handleRetry,
 		handleOpenChange,
 		handleLicensed,
-		handleLoadMore
+		handleLoadMore,
+		handleCollapseChange
 	};
 	(0, react.useEffect)(() => {
 		const el = elementRef.current;
@@ -9017,6 +9371,10 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 		};
 		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);
@@ -9027,6 +9385,7 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 		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);
@@ -9038,6 +9397,7 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 			el.removeEventListener("retry", onRetry);
 			el.removeEventListener("licensed", onLicensedEvent);
 			el.removeEventListener("load-more", onLoadMore);
+			el.removeEventListener("collapse-change", onCollapseChangeEvent);
 		};
 	}, [mounted]);
 	(0, react.useEffect)(() => {
@@ -9054,9 +9414,11 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 		el.licensed = licensed || licensePending;
 		el.hasMore = hasMoreThreads;
 		el.fetchingMore = isFetchingMoreThreads;
+		el.fetchMoreError = fetchMoreError ? fetchMoreError.message : null;
 	}, [
 		isLoading,
 		listError,
+		fetchMoreError,
 		activeThreadId,
 		licensed,
 		licensePending,
@@ -9079,6 +9441,11 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 		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) => {
@@ -9099,7 +9466,8 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 	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";
@@ -10752,8 +11120,18 @@ const usePredictStateSubscription = (agent) => {
 	}, [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;
 }
@@ -11706,6 +12084,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 () {
@@ -11736,6 +12120,12 @@ Object.defineProperty(exports, 'useSandboxFunctions', {
     return useSandboxFunctions;
   }
 });
+Object.defineProperty(exports, 'useSubagent', {
+  enumerable: true,
+  get: function () {
+    return useSubagent;
+  }
+});
 Object.defineProperty(exports, 'useSuggestions', {
   enumerable: true,
   get: function () {
@@ -11760,4 +12150,4 @@ Object.defineProperty(exports, 'useToast', {
     return useToast;
   }
 });
-//# sourceMappingURL=copilotkit-CdpDZi3i.cjs.map
+//# sourceMappingURL=copilotkit-DLwoVUsE.cjs.map