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

package/dist/{copilotkit-BtRkFsNR.mjs → copilotkit-dtSVHJCs.mjs}

@@ -1,6 +1,6 @@
 import * as React$1 from "react";
 import React, { createContext, forwardRef, memo, useCallback, useContext, useEffect, useId, useImperativeHandle, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore } from "react";
-import { CopilotKitCore, CopilotKitCoreRuntimeConnectionStatus, ProxiedCopilotRuntimeAgent, ToolCallStatus, isRunCompletionAware, ɵcreateThreadStore, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading } from "@copilotkit/core";
+import { CopilotKitCore, CopilotKitCoreRuntimeConnectionStatus, ProxiedCopilotRuntimeAgent, ToolCallStatus, isRunCompletionAware, ɵcreateThreadStore, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectMemories, ɵselectMemoriesAvailable, ɵselectMemoriesError, ɵselectMemoriesIsLoading, ɵselectMemoriesRealtimeStatus, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading } from "@copilotkit/core";
 import { HttpAgent, buildResumeArray, isInterruptExpired, randomUUID } from "@ag-ui/client";
 import { extendTailwindMerge, twMerge } from "tailwind-merge";
 import { ArrowUp, Check, ChevronDown, ChevronLeft, ChevronRight, ChevronRightIcon, Copy, Edit, Loader2, MessageCircle, Mic, PanelLeftOpen, Play, Plus, RefreshCw, Square, ThumbsDown, ThumbsUp, Upload, Volume2, X } from "lucide-react";
@@ -3620,12 +3620,13 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 	}
 	const copilotkit = copilotkitRef.current;
 	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();
 		};
@@ -4351,57 +4352,58 @@ const ALL_UPDATES = [
 	UseAgentUpdate.OnRunStatusChanged
 ];
 function useAgent({ agentId, updates, throttleMs } = {}) {
-	agentId ??= DEFAULT_AGENT_ID;
+	const chatConfig = useCopilotChatConfiguration();
+	const resolvedAgentId = agentId ?? chatConfig?.agentId ?? DEFAULT_AGENT_ID;
 	const { copilotkit } = useCopilotKit();
 	const providerThrottleMs = copilotkit.defaultThrottleMs;
 	const [, forceUpdate] = useReducer((x) => x + 1, 0);
 	const updateFlags = useMemo(() => updates ?? ALL_UPDATES, [JSON.stringify(updates)]);
 	const provisionalAgentCache = useRef(/* @__PURE__ */ new Map());
 	const agent = 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 === CopilotKitCoreRuntimeConnectionStatus.Disconnected || status === CopilotKitCoreRuntimeConnectionStatus.Connecting)) {
-			const cached = provisionalAgentCache.current.get(agentId);
+			const cached = provisionalAgentCache.current.get(resolvedAgentId);
 			if (cached) {
 				copilotkit.applyHeadersToAgent(cached);
 				return cached;
 			}
 			const provisional = new 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 === CopilotKitCoreRuntimeConnectionStatus.Error) {
-			const cached = provisionalAgentCache.current.get(agentId);
+			const cached = provisionalAgentCache.current.get(resolvedAgentId);
 			if (cached) {
 				copilotkit.applyHeadersToAgent(cached);
 				return cached;
 			}
 			const provisional = new 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,
@@ -4446,7 +4448,6 @@ function useAgent({ agentId, updates, throttleMs } = {}) {
 	useEffect(() => {
 		if (agent instanceof HttpAgent) copilotkit.applyHeadersToAgent(agent);
 	}, [agent, JSON.stringify(copilotkit.headers)]);
-	const chatConfig = useCopilotChatConfiguration();
 	const configThreadId = chatConfig?.threadId;
 	const configHasExplicitThreadId = chatConfig?.hasExplicitThreadId;
 	useEffect(() => {
@@ -4460,16 +4461,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 = useMemo(() => agentId ?? config?.agentId ?? DEFAULT_AGENT_ID, [agentId, config?.agentId]);
+	const [subagent, setSubagent] = useState(() => resolveSubagent(copilotkit.getSubagents(resolvedAgentId), subagentId, subagentName));
+	useEffect(() => {
+		setSubagent(resolveSubagent(copilotkit.getSubagents(resolvedAgentId), subagentId, subagentName));
+	}, [
+		copilotkit,
+		resolvedAgentId,
+		subagentId,
+		subagentName
+	]);
+	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
+	]);
+	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.
 */
@@ -5042,6 +5114,7 @@ function useThreads$1({ agentId, includeArchived, limit, enabled = true }) {
 	})), [coreThreads]);
 	const storeIsLoading = useThreadStoreSelector(store, ɵselectThreadsIsLoading);
 	const storeError = useThreadStoreSelector(store, ɵselectThreadsError);
+	const fetchMoreError = useThreadStoreSelector(store, ɵselectFetchMoreError);
 	const hasMoreThreads = useThreadStoreSelector(store, ɵselectHasNextPage);
 	const isFetchingMoreThreads = useThreadStoreSelector(store, ɵselectIsFetchingNextPage);
 	const isMutating = useThreadStoreSelector(store, ɵselectIsMutating);
@@ -5147,6 +5220,7 @@ function useThreads$1({ agentId, includeArchived, limit, enabled = true }) {
 		isLoading,
 		error,
 		listError,
+		fetchMoreError,
 		hasMoreThreads,
 		isFetchingMoreThreads,
 		isMutating,
@@ -5163,6 +5237,70 @@ function useThreads$1({ agentId, includeArchived, limit, enabled = true }) {
 	};
 }
 
+//#endregion
+//#region src/v2/hooks/use-memories.tsx
+function useMemoryStoreSelector(store, selector) {
+	return useSyncExternalStore(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, ɵselectMemories),
+		isLoading: useMemoryStoreSelector(store, ɵselectMemoriesIsLoading),
+		error: useMemoryStoreSelector(store, ɵselectMemoriesError),
+		isAvailable: useMemoryStoreSelector(store, ɵselectMemoriesAvailable),
+		realtimeStatus: useMemoryStoreSelector(store, ɵselectMemoriesRealtimeStatus),
+		refresh: useCallback(() => store.refresh(), [store]),
+		addMemory: useCallback((input) => store.addMemory(input), [store]),
+		updateMemory: useCallback((id, changes) => store.updateMemory(id, changes), [store]),
+		removeMemory: useCallback((id) => store.removeMemory(id), [store])
+	};
+}
+
 //#endregion
 //#region src/v2/lib/record-annotation.ts
 /**
@@ -7925,9 +8063,57 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 	const { messageView: providedMessageView, suggestionView: providedSuggestionView, onStop: providedStopHandler, ...restProps } = props;
 	const [lastConnectedThreadId, setLastConnectedThreadId] = useState(null);
 	const isConnecting = hasExplicitThreadId && lastConnectedThreadId !== resolvedThreadId;
+	const activeConnectCountRef = useRef(0);
+	const pendingRunActivityReconnectRef = useRef(false);
+	const runActivityReconnectGenerationRef = useRef(0);
+	const activeLocalRunIdsRef = useRef(/* @__PURE__ */ new Set());
+	const recentlyLocalRunIdsRef = useRef(/* @__PURE__ */ new Map());
+	const activeWakeRunIdsRef = useRef(/* @__PURE__ */ new Set());
+	const recentlyWakeRunIdsRef = useRef(/* @__PURE__ */ new Map());
+	const pendingWakeRunIdRef = useRef(void 0);
+	const startRunActivityReconnectRef = useRef(null);
+	const runtimeStatus = copilotkit.runtimeConnectionStatus === CopilotKitCoreRuntimeConnectionStatus.Connected ? "Connected" : copilotkit.runtimeConnectionStatus;
+	const hasNativeIntelligenceRunActivity = hasExplicitThreadId && runtimeStatus === "Connected" && !!copilotkit.intelligence?.wsUrl && copilotkit.threadEndpoints?.realtimeMetadata === true;
+	const [standaloneRunActivityStore] = useState(() => ɵcreateThreadStore({ fetch: globalThis.fetch }));
 	const previousThreadIdRef = useRef(null);
 	const hasExplicitThreadIdRef = useRef(hasExplicitThreadId);
 	hasExplicitThreadIdRef.current = hasExplicitThreadId;
+	const rememberRecentlyLocalRunId = 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 = 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 = 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]);
+	useEffect(() => {
+		const recentlyLocalRunIds = recentlyLocalRunIdsRef.current;
+		const recentlyWakeRunIds = recentlyWakeRunIdsRef.current;
+		return () => {
+			recentlyLocalRunIds.forEach((timeout) => {
+				clearTimeout(timeout);
+			});
+			recentlyLocalRunIds.clear();
+			recentlyWakeRunIds.forEach((timeout) => {
+				clearTimeout(timeout);
+			});
+			recentlyWakeRunIds.clear();
+		};
+	}, []);
 	useEffect(() => {
 		const threadChanged = previousThreadIdRef.current !== resolvedThreadId;
 		previousThreadIdRef.current = resolvedThreadId;
@@ -7940,6 +8126,7 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 		const connectAbortController = new AbortController();
 		if (agent instanceof HttpAgent) agent.abortController = connectAbortController;
 		const connect = async (agentToConnect) => {
+			activeConnectCountRef.current += 1;
 			try {
 				await copilotkit.connectAgent({ agent: agentToConnect });
 			} catch (error) {
@@ -7950,6 +8137,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);
@@ -7964,6 +8159,119 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 		resolvedAgentId,
 		hasExplicitThreadId
 	]);
+	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 = useCallback(async () => {
 		const maybeAware = agent;
 		const activeRunCompletionPromise = isRunCompletionAware(maybeAware) ? maybeAware.activeRunCompletionPromise : void 0;
@@ -8012,15 +8320,34 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 			role: "user",
 			content: value
 		});
+		const localRunId = hasNativeIntelligenceRunActivity ? randomUUID$1() : 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 = useCallback(async (suggestion) => {
 		await waitForActiveRunToSettle();
@@ -8029,12 +8356,34 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 			role: "user",
 			content: suggestion.message
 		});
+		const localRunId = hasNativeIntelligenceRunActivity ? randomUUID$1() : 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 = useCallback(() => {
 		try {
 			copilotkit.stopAgent({ agent });
@@ -8813,7 +9162,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
@@ -8840,16 +9189,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 ?? 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,
@@ -8930,6 +9279,9 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 	const handleLoadMore = useCallback(() => {
 		fetchMoreThreads();
 	}, [fetchMoreThreads]);
+	const handleCollapseChange = useCallback((collapsed) => {
+		onCollapseChange?.(collapsed);
+	}, [onCollapseChange]);
 	const handlersRef = useRef({
 		handleThreadSelected,
 		handleNewThread,
@@ -8940,7 +9292,8 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 		handleRetry,
 		handleOpenChange,
 		handleLicensed,
-		handleLoadMore
+		handleLoadMore,
+		handleCollapseChange
 	});
 	handlersRef.current = {
 		handleThreadSelected,
@@ -8952,7 +9305,8 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 		handleRetry,
 		handleOpenChange,
 		handleLicensed,
-		handleLoadMore
+		handleLoadMore,
+		handleCollapseChange
 	};
 	useEffect(() => {
 		const el = elementRef.current;
@@ -8987,6 +9341,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);
@@ -8997,6 +9355,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);
@@ -9008,6 +9367,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]);
 	useEffect(() => {
@@ -9024,9 +9384,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,
@@ -9049,6 +9411,11 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 		if (!el) return;
 		if (licenseUrl !== void 0) el.licenseUrl = licenseUrl;
 	}, [licenseUrl, mounted]);
+	useEffect(() => {
+		const el = elementRef.current;
+		if (!el) return;
+		if (collapsible !== void 0) el.collapsible = collapsible;
+	}, [collapsible, mounted]);
 	const rowChildren = useMemo(() => {
 		if (!renderRow) return null;
 		return drawerThreads.map((drawerThread) => {
@@ -9069,7 +9436,8 @@ function CopilotThreadsDrawer({ agentId, onThreadSelect, onNewThread, onLicensed
 	if (!mounted) return null;
 	return React.createElement(COPILOTKIT_THREADS_DRAWER_TAG, {
 		ref: elementRef,
-		"data-testid": dataTestId
+		"data-testid": dataTestId,
+		...recentLabel !== void 0 ? { "recent-label": recentLabel } : {}
 	}, rowChildren);
 }
 CopilotThreadsDrawer.displayName = "CopilotThreadsDrawer";
@@ -10722,8 +11090,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: useMemo(() => {
+		const requested = configAgentId ?? DEFAULT_AGENT_ID;
+		const registered = copilotkit.agents ?? {};
+		if (registered[requested]) return requested;
+		if (requested === DEFAULT_AGENT_ID) {
+			const firstRegistered = Object.keys(registered)[0];
+			if (firstRegistered) return firstRegistered;
+		}
+		return requested;
+	}, [configAgentId, copilotkit.agents]) });
 	usePredictStateSubscription(agent);
 	return null;
 }
@@ -11256,5 +11634,5 @@ function validateProps(props) {
 }
 
 //#endregion
-export { UseAgentUpdate as $, CopilotChatMessageView as A, CopilotChatAssistantMessage_default as B, CopilotModalHeader as C, CopilotChatConfigurationProvider as Ct, CopilotChat as D, DefaultOpenIcon as E, CopilotChatSuggestionView as F, useLearnFromUserActionInCurrentThread as G, useLearningContainersInCurrentThread as H, CopilotChatSuggestionPill as I, useInterrupt as J, useLearnFromUserAction as K, CopilotChatReasoningMessage_default as L, IntelligenceIndicator as M, getIntelligenceTurnAnchors as N, CopilotChatView_default as O, IntelligenceIndicatorView as P, useCapabilities as Q, CopilotChatUserMessage_default as R, CopilotSidebarView as S, CopilotChatAudioRecorder as St, DefaultCloseIcon as T, useLearningContainers as U, CopilotChatToolCallsView as V, useAttachments as W, useSuggestions as X, useConfigureSuggestions as Y, useAgentContext as Z, WildcardToolCallRender as _, useRenderToolCall as _t, ThreadsProvider as a, useFrontendTool as at, CopilotSidebar as b, CopilotChatInput_default as bt, CoAgentStateRendersProvider as c, CopilotKitProvider as ct, shouldShowDevConsole as d, SandboxFunctionsContext as dt, useAgent as et, useToast as f, useSandboxFunctions as ft, useCopilotContext as g, CopilotKitInspector as gt, CopilotContext as h, MCPAppsActivityType as ht, ThreadsContext as i, useComponent as it, INTELLIGENCE_TURN_HEAD as j, CopilotChatAttachmentQueue as k, useCoAgentStateRenders as l, defineToolCallRenderer as lt, useCopilotMessagesContext as m, MCPAppsActivityRenderer as mt, defaultCopilotContextCategories as n, useDefaultRenderTool as nt, useThreads as o, useRenderActivityMessage as ot, CopilotMessagesContext as p, MCPAppsActivityContentSchema as pt, useThreads$1 as q, CoAgentStateRenderBridge as r, useRenderTool as rt, CoAgentStateRendersContext as s, useRenderCustomMessages as st, CopilotKit as t, useHumanInTheLoop as tt, useAsyncCallback as u, createA2UIMessageRenderer as ut, CopilotThreadsDrawer as v, useCopilotKit as vt, CopilotChatToggleButton as w, useCopilotChatConfiguration as wt, CopilotPopupView as x, AudioRecorderError as xt, CopilotPopup as y, CopilotKitCoreReact as yt, CopilotChatAttachmentRenderer as z };
-//# sourceMappingURL=copilotkit-BtRkFsNR.mjs.map
+export { useCapabilities as $, CopilotChatMessageView as A, CopilotChatAssistantMessage_default as B, CopilotModalHeader as C, AudioRecorderError as Ct, CopilotChat as D, DefaultOpenIcon as E, useCopilotChatConfiguration as Et, CopilotChatSuggestionView as F, useLearnFromUserActionInCurrentThread as G, useLearningContainersInCurrentThread as H, CopilotChatSuggestionPill as I, useThreads$1 as J, useLearnFromUserAction as K, CopilotChatReasoningMessage_default as L, IntelligenceIndicator as M, getIntelligenceTurnAnchors as N, CopilotChatView_default as O, IntelligenceIndicatorView as P, useAgentContext as Q, CopilotChatUserMessage_default as R, CopilotSidebarView as S, CopilotChatInput_default as St, DefaultCloseIcon as T, CopilotChatConfigurationProvider as Tt, useLearningContainers as U, CopilotChatToolCallsView as V, useAttachments as W, useConfigureSuggestions as X, useInterrupt as Y, useSuggestions as Z, WildcardToolCallRender as _, MCPAppsActivityType as _t, ThreadsProvider as a, useRenderTool as at, CopilotSidebar as b, useCopilotKit as bt, CoAgentStateRendersProvider as c, useRenderActivityMessage as ct, shouldShowDevConsole as d, defineToolCallRenderer as dt, useSubagent as et, useToast as f, createA2UIMessageRenderer as ft, useCopilotContext as g, MCPAppsActivityRenderer as gt, CopilotContext as h, MCPAppsActivityContentSchema as ht, ThreadsContext as i, useDefaultRenderTool as it, INTELLIGENCE_TURN_HEAD as j, CopilotChatAttachmentQueue as k, useCoAgentStateRenders as l, useRenderCustomMessages as lt, useCopilotMessagesContext as m, useSandboxFunctions as mt, defaultCopilotContextCategories as n, useAgent as nt, useThreads as o, useComponent as ot, CopilotMessagesContext as p, SandboxFunctionsContext as pt, useMemories as q, CoAgentStateRenderBridge as r, useHumanInTheLoop as rt, CoAgentStateRendersContext as s, useFrontendTool as st, CopilotKit as t, UseAgentUpdate as tt, useAsyncCallback as u, CopilotKitProvider as ut, CopilotThreadsDrawer as v, CopilotKitInspector as vt, CopilotChatToggleButton as w, CopilotChatAudioRecorder as wt, CopilotPopupView as x, CopilotKitCoreReact as xt, CopilotPopup as y, useRenderToolCall as yt, CopilotChatAttachmentRenderer as z };
+//# sourceMappingURL=copilotkit-dtSVHJCs.mjs.map