@copilotkit/react-core 2.0.0-next.1 → 2.0.0-rc.0

package/dist/headless.mjs

@@ -0,0 +1,1869 @@
+import { CopilotKitContext, CopilotKitCoreReact, useCopilotKit, useCopilotKit as useCopilotKit$1, useDefaultAgentId } from "@copilotkit/react-core/context";
+import React, { createContext, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore } from "react";
+import { DEFAULT_AGENT_ID, partialJSONParse, randomUUID } from "@copilotkit/shared";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { CopilotKitCoreRuntimeConnectionStatus, ProxiedCopilotRuntimeAgent, ToolCallStatus, ɵInterruptState, ɵclearAgentInterruptState, ɵcreateThreadStore, ɵgetAgentInterruptState, ɵisHttpAgent, ɵselectFetchMoreError, ɵselectHasNextPage, ɵselectIsFetchingNextPage, ɵselectIsMutating, ɵselectThreads, ɵselectThreadsError, ɵselectThreadsIsLoading } from "@copilotkit/core";
+import { randomUUID as randomUUID$1 } from "@ag-ui/client";
+import { z } from "zod";
+import { contentToText } from "@ag-ui/core";
+
+//#region src/lib/shallow-stable-ref.ts
+/**
+* Shallow equality comparison for objects.
+*/
+function shallowEqual(obj1, obj2) {
+	const keys1 = Object.keys(obj1);
+	const keys2 = Object.keys(obj2);
+	if (keys1.length !== keys2.length) return false;
+	for (const key of keys1) if (obj1[key] !== obj2[key]) return false;
+	return true;
+}
+/**
+* Returns true only for plain JS objects (`{}`), excluding arrays, Dates,
+* class instances, and other exotic objects that happen to have typeof "object".
+*/
+function isPlainObject$1(obj) {
+	return obj !== null && typeof obj === "object" && Object.prototype.toString.call(obj) === "[object Object]";
+}
+/**
+* Returns the same reference as long as the value is shallowly equal to the
+* previous render's value.
+*
+* - Identical references bail out immediately (O(1)).
+* - Plain objects ({}) are shallow-compared key-by-key.
+* - Arrays, Dates, class instances, functions, and primitives are compared by
+*   reference only — shallowEqual is never called on non-plain objects, which
+*   avoids incorrect equality for e.g. [1,2] vs [1,2] (different arrays).
+*
+* Typical use: stabilize inline slot props so MemoizedSlotWrapper's shallow
+* equality check isn't defeated by a new object reference on every render.
+*/
+function useShallowStableRef(value) {
+	const ref = useRef(value);
+	if (ref.current === value) return ref.current;
+	if (isPlainObject$1(ref.current) && isPlainObject$1(value)) {
+		if (shallowEqual(ref.current, value)) return ref.current;
+	}
+	ref.current = value;
+	return ref.current;
+}
+
+//#endregion
+//#region src/providers/CopilotChatConfigurationProvider.tsx
+const CopilotChatDefaultLabels = {
+	chatInputPlaceholder: "Type a message...",
+	chatInputToolbarStartTranscribeButtonLabel: "Transcribe",
+	chatInputToolbarCancelTranscribeButtonLabel: "Cancel",
+	chatInputToolbarFinishTranscribeButtonLabel: "Finish",
+	chatInputToolbarAddButtonLabel: "Add attachments",
+	chatInputToolbarToolsButtonLabel: "Tools",
+	chatInputToolbarSendButtonLabel: "Send message",
+	chatInputToolbarStopButtonLabel: "Stop",
+	assistantMessageToolbarCopyCodeLabel: "Copy",
+	assistantMessageToolbarCopyCodeCopiedLabel: "Copied",
+	assistantMessageToolbarCopyMessageLabel: "Copy",
+	assistantMessageToolbarInspectorLabel: "View in Inspector",
+	assistantMessageToolbarInspectorDescription: "Open this message in the Inspector",
+	assistantMessageToolbarInspectorLocalOnlyLabel: "Local only",
+	assistantMessageToolbarInspectorLocalOnlyDescription: "Only visible on localhost or loopback hosts in development. Never shown in production.",
+	assistantMessageToolbarInspectorTitle: "CopilotKit Inspector",
+	assistantMessageToolbarInspectorHideLabel: "Hide this icon",
+	assistantMessageToolbarInspectorHideDescription: "Until you reload this page",
+	assistantMessageToolbarThumbsUpLabel: "Good response",
+	assistantMessageToolbarThumbsDownLabel: "Bad response",
+	assistantMessageFeedbackCommentPlaceholder: "Add a comment (optional)",
+	assistantMessageFeedbackCommentSubmitLabel: "Send comment",
+	assistantMessageToolbarReadAloudLabel: "Read aloud",
+	assistantMessageToolbarRegenerateLabel: "Regenerate",
+	userMessageToolbarCopyMessageLabel: "Copy",
+	userMessageToolbarEditMessageLabel: "Edit",
+	userMessageToolbarPreviousBranchLabel: "Previous branch",
+	userMessageToolbarNextBranchLabel: "Next branch",
+	chatDisclaimerText: "AI can make mistakes. Please verify important information.",
+	chatToggleOpenLabel: "Open chat",
+	chatToggleCloseLabel: "Close chat",
+	chatScrollToBottomLabel: "Scroll to bottom",
+	modalHeaderTitle: "CopilotKit Chat",
+	welcomeMessageText: "How can I help you today?",
+	reasoningMessageThinkingLabel: "Thinking…",
+	chatInputSlashMenuLabel: "Slash commands",
+	chatInputSlashMenuEmptyText: "No commands found",
+	attachmentRemoveButtonLabel: "Remove attachment",
+	attachmentPlayVideoButtonLabel: "Play video",
+	attachmentPreviewCloseButtonLabel: "Close preview",
+	modalHeaderCloseButtonLabel: "Close",
+	modalHeaderThreadsButtonLabel: "Open threads",
+	sidebarLabel: "Copilot chat sidebar"
+};
+/**
+* Mobile breakpoint below which the chat modal and the thread-list drawer are
+* mutually exclusive. At or above this width both surfaces may coexist. This
+* mirrors the `(max-width: 767px)` / `(min-width: 768px)` split already used by
+* CopilotChatInput and CopilotSidebarView.
+*/
+const MOBILE_MAX_WIDTH_PX = 767;
+/**
+* Reports whether the current viewport is in the mobile range (`<768px`), where
+* the chat modal and drawer must not be open simultaneously. SSR-safe and
+* defensive against environments without `matchMedia` (treated as desktop, so
+* no mutual-exclusion constraint is applied).
+*
+* @returns `true` when the viewport is mobile-width, `false` otherwise.
+*/
+function isMobileViewport() {
+	if (typeof window === "undefined" || typeof window.matchMedia !== "function") return false;
+	return window.matchMedia(`(max-width: ${MOBILE_MAX_WIDTH_PX}px)`).matches;
+}
+const CopilotChatConfiguration = createContext(null);
+const CopilotChatConfigurationProvider = ({ children, labels, agentId, threadId, hasExplicitThreadId, isModalDefaultOpen }) => {
+	const parentConfig = useContext(CopilotChatConfiguration);
+	const stableLabels = useShallowStableRef(labels);
+	const mergedLabels = useMemo(() => ({
+		...CopilotChatDefaultLabels,
+		...parentConfig?.labels,
+		...stableLabels
+	}), [stableLabels, parentConfig?.labels]);
+	const providerAgentId = useDefaultAgentId();
+	const resolvedAgentId = agentId ?? parentConfig?.agentId ?? providerAgentId ?? DEFAULT_AGENT_ID;
+	const threadIdPropIsAuthoritative = threadId !== void 0 && hasExplicitThreadId !== false;
+	const isThreadIdControlled = threadIdPropIsAuthoritative;
+	const [activeThreadOverride, setActiveThreadOverride] = useState(null);
+	const resolvedThreadId = useMemo(() => {
+		if (threadIdPropIsAuthoritative) return threadId;
+		if (activeThreadOverride) return activeThreadOverride.threadId;
+		if (parentConfig?.threadId) return parentConfig.threadId;
+		if (threadId) return threadId;
+		return randomUUID();
+	}, [
+		threadIdPropIsAuthoritative,
+		threadId,
+		parentConfig?.threadId,
+		activeThreadOverride
+	]);
+	const copilotkit = useContext(CopilotKitContext)?.copilotkit;
+	const openThreadRef = useRef(null);
+	const latestThreadIdRef = useRef(resolvedThreadId);
+	latestThreadIdRef.current = resolvedThreadId;
+	useEffect(() => {
+		if (copilotkit === void 0) return;
+		const registration = copilotkit.registerOpenThread({
+			agentId: resolvedAgentId,
+			threadId: latestThreadIdRef.current
+		});
+		openThreadRef.current = registration;
+		return () => {
+			registration.unregister();
+			openThreadRef.current = null;
+		};
+	}, [copilotkit, resolvedAgentId]);
+	useEffect(() => {
+		openThreadRef.current?.update(resolvedThreadId);
+	}, [resolvedThreadId]);
+	const resolvedHasExplicitThreadId = (threadIdPropIsAuthoritative ? true : activeThreadOverride?.explicit ?? hasExplicitThreadId ?? false) || !!parentConfig?.hasExplicitThreadId;
+	const [internalModalOpen, setInternalModalOpen] = useState(isModalDefaultOpen ?? true);
+	const hasExplicitDefault = isModalDefaultOpen !== void 0;
+	const setAndSync = useCallback((open) => {
+		setInternalModalOpen(open);
+		parentConfig?.setModalOpen(open);
+	}, [parentConfig?.setModalOpen]);
+	const isMounted = useRef(false);
+	useEffect(() => {
+		if (!hasExplicitDefault) return;
+		if (!isMounted.current) {
+			isMounted.current = true;
+			return;
+		}
+		if (parentConfig?.isModalOpen === void 0) return;
+		setInternalModalOpen(parentConfig.isModalOpen);
+	}, [parentConfig?.isModalOpen, hasExplicitDefault]);
+	const resolvedIsModalOpen = hasExplicitDefault ? internalModalOpen : parentConfig?.isModalOpen ?? internalModalOpen;
+	const resolvedSetModalOpen = hasExplicitDefault ? setAndSync : parentConfig?.setModalOpen ?? setInternalModalOpen;
+	const [ownDrawerOpen, setOwnDrawerOpen] = useState(false);
+	const [ownDrawerCount, setOwnDrawerCount] = useState(0);
+	const modalCloseRef = useRef(() => {});
+	modalCloseRef.current = resolvedSetModalOpen;
+	const registeredModalClosersRef = useRef([]);
+	const ownRegisterModalCloser = useCallback((closeModal) => {
+		registeredModalClosersRef.current.push(closeModal);
+		return () => {
+			registeredModalClosersRef.current = registeredModalClosersRef.current.filter((entry) => entry !== closeModal);
+		};
+	}, []);
+	const ownSetDrawerOpen = useCallback((open) => {
+		setOwnDrawerOpen(open);
+		if (open && isMobileViewport()) {
+			const registered = registeredModalClosersRef.current;
+			(registered.length > 0 ? registered[registered.length - 1] : modalCloseRef.current)(false);
+		}
+	}, []);
+	const ownRegisterDrawer = useCallback(() => {
+		setOwnDrawerCount((count) => count + 1);
+		return () => {
+			setOwnDrawerCount((count) => Math.max(0, count - 1));
+		};
+	}, []);
+	const resolvedDrawerOpen = parentConfig ? parentConfig.drawerOpen : ownDrawerOpen;
+	const resolvedSetDrawerOpen = parentConfig ? parentConfig.setDrawerOpen : ownSetDrawerOpen;
+	const resolvedDrawerRegistered = parentConfig ? parentConfig.drawerRegistered : ownDrawerCount > 0;
+	const resolvedRegisterDrawer = parentConfig ? parentConfig.registerDrawer : ownRegisterDrawer;
+	const resolvedRegisterModalCloser = parentConfig ? parentConfig.ɵregisterModalCloser : ownRegisterModalCloser;
+	useEffect(() => {
+		if (!hasExplicitDefault) return;
+		return resolvedRegisterModalCloser(resolvedSetModalOpen);
+	}, [
+		hasExplicitDefault,
+		resolvedRegisterModalCloser,
+		resolvedSetModalOpen
+	]);
+	const isThreadIdControlledRef = useRef(isThreadIdControlled);
+	isThreadIdControlledRef.current = isThreadIdControlled;
+	const ownSetActiveThreadId = useCallback((id, options) => {
+		setActiveThreadOverride({
+			threadId: id,
+			explicit: options?.explicit ?? true
+		});
+	}, []);
+	const ownStartNewThread = useCallback(() => {
+		setActiveThreadOverride({
+			threadId: randomUUID(),
+			explicit: false
+		});
+	}, []);
+	const parentSetActiveThreadId = parentConfig?.setActiveThreadId;
+	const parentStartNewThread = parentConfig?.startNewThread;
+	const resolvedSetActiveThreadId = useCallback((id, options) => {
+		if (isThreadIdControlledRef.current) {
+			console.warn("[CopilotKit] Ignoring setActiveThreadId(): threadId is controlled via the `threadId` prop on CopilotChatConfigurationProvider.");
+			return;
+		}
+		if (parentSetActiveThreadId) {
+			parentSetActiveThreadId(id, options);
+			return;
+		}
+		ownSetActiveThreadId(id, options);
+	}, [parentSetActiveThreadId, ownSetActiveThreadId]);
+	const resolvedStartNewThread = useCallback(() => {
+		if (isThreadIdControlledRef.current) {
+			console.warn("[CopilotKit] Ignoring startNewThread(): threadId is controlled via the `threadId` prop on CopilotChatConfigurationProvider.");
+			return;
+		}
+		if (parentStartNewThread) {
+			parentStartNewThread();
+			return;
+		}
+		ownStartNewThread();
+	}, [parentStartNewThread, ownStartNewThread]);
+	const setModalOpenWithDrawerExclusion = useCallback((open) => {
+		if (open && isMobileViewport()) resolvedSetDrawerOpen(false);
+		resolvedSetModalOpen(open);
+	}, [resolvedSetModalOpen, resolvedSetDrawerOpen]);
+	const configurationValue = useMemo(() => ({
+		labels: mergedLabels,
+		agentId: resolvedAgentId,
+		threadId: resolvedThreadId,
+		hasExplicitThreadId: resolvedHasExplicitThreadId,
+		isModalOpen: resolvedIsModalOpen,
+		setModalOpen: setModalOpenWithDrawerExclusion,
+		drawerOpen: resolvedDrawerOpen,
+		setDrawerOpen: resolvedSetDrawerOpen,
+		drawerRegistered: resolvedDrawerRegistered,
+		registerDrawer: resolvedRegisterDrawer,
+		ɵregisterModalCloser: resolvedRegisterModalCloser,
+		setActiveThreadId: resolvedSetActiveThreadId,
+		startNewThread: resolvedStartNewThread
+	}), [
+		mergedLabels,
+		resolvedAgentId,
+		resolvedThreadId,
+		resolvedHasExplicitThreadId,
+		resolvedIsModalOpen,
+		setModalOpenWithDrawerExclusion,
+		resolvedDrawerOpen,
+		resolvedSetDrawerOpen,
+		resolvedDrawerRegistered,
+		resolvedRegisterDrawer,
+		resolvedRegisterModalCloser,
+		resolvedSetActiveThreadId,
+		resolvedStartNewThread
+	]);
+	return /* @__PURE__ */ jsx(CopilotChatConfiguration.Provider, {
+		value: configurationValue,
+		children
+	});
+};
+const useCopilotChatConfiguration = () => {
+	return useContext(CopilotChatConfiguration);
+};
+/**
+* Reports modal open/close requests to the host, and — when `open` is
+* supplied — makes the modal state of an already-established chat
+* configuration **controlled** for the subtree it wraps.
+*
+* This is deliberately a scope component rather than another mode inside
+* {@link CopilotChatConfigurationProvider}. The provider resolves modal state
+* across a nested chain (own state, parent sync, drawer mutual-exclusion, the
+* modal-closer registry); a controlled branch inside that resolution would add
+* a fourth interacting mode. Overriding the context for the subtree instead
+* leaves every one of those paths untouched:
+*
+* - `isModalOpen` is replaced with the host's `open`, so the rendered surface
+*   follows the prop from the very first frame (no open-then-close flash).
+* - `setModalOpen` still calls the underlying setter, so the existing
+*   parent-sync and drawer mutual-exclusion side effects continue to run, and
+*   *then* reports the request through `onOpenChange`.
+* - The wrapped setter is registered as the modal closer, so the drawer's
+*   mobile mutual-exclusion reaches the host instead of silently flipping
+*   state that nothing displays.
+*
+* A host that supplies `open` and ignores `onOpenChange` gets a modal pinned
+* to `open`, which is the standard controlled-component contract. A host that
+* supplies only `onOpenChange` is notified while the modal keeps managing
+* itself.
+*
+* Renders `children` unchanged when no chat configuration is in scope.
+*/
+const ControlledModalOpenScope = ({ children, open, onOpenChange }) => {
+	const parentConfig = useContext(CopilotChatConfiguration);
+	const parentSetModalOpen = parentConfig?.setModalOpen;
+	const registerModalCloser = parentConfig?.ɵregisterModalCloser;
+	const setModalOpen = useCallback((next) => {
+		parentSetModalOpen?.(next);
+		onOpenChange?.(next);
+	}, [parentSetModalOpen, onOpenChange]);
+	useEffect(() => {
+		if (!registerModalCloser) return;
+		return registerModalCloser(setModalOpen);
+	}, [registerModalCloser, setModalOpen]);
+	const configurationValue = useMemo(() => parentConfig ? {
+		...parentConfig,
+		isModalOpen: open ?? parentConfig.isModalOpen,
+		setModalOpen
+	} : null, [
+		parentConfig,
+		open,
+		setModalOpen
+	]);
+	if (!configurationValue) return /* @__PURE__ */ jsx(Fragment, { children });
+	return /* @__PURE__ */ jsx(CopilotChatConfiguration.Provider, {
+		value: configurationValue,
+		children
+	});
+};
+ControlledModalOpenScope.displayName = "ControlledModalOpenScope";
+
+//#endregion
+//#region src/hooks/use-agent.tsx
+let UseAgentUpdate = /* @__PURE__ */ function(UseAgentUpdate) {
+	UseAgentUpdate["OnMessagesChanged"] = "OnMessagesChanged";
+	UseAgentUpdate["OnStateChanged"] = "OnStateChanged";
+	UseAgentUpdate["OnRunStatusChanged"] = "OnRunStatusChanged";
+	return UseAgentUpdate;
+}({});
+const ALL_UPDATES = [
+	UseAgentUpdate.OnMessagesChanged,
+	UseAgentUpdate.OnStateChanged,
+	UseAgentUpdate.OnRunStatusChanged
+];
+function useAgent({ agentId, threadId, runtimeAgentId, updates, throttleMs } = {}) {
+	if (threadId != null && runtimeAgentId == null) throw new Error(`useAgent: \`threadId\` requires \`runtimeAgentId\`. A threadId is written onto a single agent, but an agent resolved by agentId alone is shared, so scoping a thread to it would clobber other useAgent callers. Pass a distinct local \`agentId\` and the runtime agent to route to, e.g. useAgent({ agentId: "chat-1", runtimeAgentId: "${agentId ?? "default"}", threadId }).`);
+	if (runtimeAgentId != null && threadId == null) throw new Error(`useAgent: \`runtimeAgentId\` requires \`threadId\`. A proxied agent exists to scope a thread to a private instance; without a threadId it behaves like the shared agent while adding a registration and a local agentId to keep unique. Either pass the thread, e.g. useAgent({ agentId: "${agentId ?? "chat-1"}", runtimeAgentId: "${runtimeAgentId}", threadId }), or bind to the agent directly with useAgent({ agentId: "${runtimeAgentId}" }).`);
+	if (runtimeAgentId != null && agentId == null) throw new Error(`useAgent: \`runtimeAgentId\` requires an explicit \`agentId\`. The proxied agent is registered under \`agentId\`, and the usual fallbacks (chat configuration, then "${DEFAULT_AGENT_ID}") name agents that already exist — registering over one throws or shadows it. Pick a local id for this hook, e.g. useAgent({ agentId: "chat-1", runtimeAgentId: "${runtimeAgentId}", threadId }).`);
+	const chatConfig = useCopilotChatConfiguration();
+	const providerAgentId = useDefaultAgentId();
+	const resolvedAgentId = agentId ?? chatConfig?.agentId ?? providerAgentId ?? DEFAULT_AGENT_ID;
+	const { copilotkit } = useCopilotKit$1();
+	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 [registeredProxyAgent, setRegisteredProxyAgent] = useState(null);
+	useEffect(() => {
+		if (runtimeAgentId == null) {
+			setRegisteredProxyAgent(null);
+			return;
+		}
+		const { agent: proxy, unregister } = copilotkit.registerProxiedAgent({
+			agentId: resolvedAgentId,
+			runtimeAgentId
+		});
+		provisionalAgentCache.current.delete(resolvedAgentId);
+		setRegisteredProxyAgent(proxy);
+		return () => {
+			unregister();
+			setRegisteredProxyAgent(null);
+		};
+	}, [
+		copilotkit,
+		resolvedAgentId,
+		runtimeAgentId
+	]);
+	const { agent, isReady } = useMemo(() => {
+		if (runtimeAgentId != null) {
+			if (registeredProxyAgent) {
+				provisionalAgentCache.current.delete(resolvedAgentId);
+				return {
+					agent: registeredProxyAgent,
+					isReady: true
+				};
+			}
+			const cached = provisionalAgentCache.current.get(resolvedAgentId);
+			if (cached) {
+				copilotkit.applyHeadersToAgent(cached);
+				return {
+					agent: cached,
+					isReady: false
+				};
+			}
+			const provisional = new ProxiedCopilotRuntimeAgent({
+				runtimeUrl: copilotkit.runtimeUrl,
+				agentId: resolvedAgentId,
+				runtimeAgentId,
+				transport: copilotkit.runtimeTransport,
+				runtimeMode: "pending"
+			});
+			copilotkit.applyHeadersToAgent(provisional);
+			provisionalAgentCache.current.set(resolvedAgentId, provisional);
+			return {
+				agent: provisional,
+				isReady: false
+			};
+		}
+		const existing = copilotkit.getAgent(resolvedAgentId);
+		if (existing) {
+			provisionalAgentCache.current.delete(resolvedAgentId);
+			return {
+				agent: existing,
+				isReady: true
+			};
+		}
+		const isRuntimeConfigured = copilotkit.runtimeUrl !== void 0;
+		const status = copilotkit.runtimeConnectionStatus;
+		if (isRuntimeConfigured && (status === CopilotKitCoreRuntimeConnectionStatus.Disconnected || status === CopilotKitCoreRuntimeConnectionStatus.Connecting)) {
+			const cached = provisionalAgentCache.current.get(resolvedAgentId);
+			if (cached) return {
+				agent: cached,
+				isReady: false
+			};
+			const provisional = new ProxiedCopilotRuntimeAgent({
+				runtimeUrl: copilotkit.runtimeUrl,
+				agentId: resolvedAgentId,
+				transport: copilotkit.runtimeTransport,
+				credentials: copilotkit.credentials,
+				runtimeMode: "pending"
+			});
+			copilotkit.applyHeadersToAgent(provisional);
+			provisionalAgentCache.current.set(resolvedAgentId, provisional);
+			return {
+				agent: provisional,
+				isReady: false
+			};
+		}
+		if (isRuntimeConfigured && status === CopilotKitCoreRuntimeConnectionStatus.Error) {
+			const cached = provisionalAgentCache.current.get(resolvedAgentId);
+			if (cached) return {
+				agent: cached,
+				isReady: false
+			};
+			const provisional = new ProxiedCopilotRuntimeAgent({
+				runtimeUrl: copilotkit.runtimeUrl,
+				agentId: resolvedAgentId,
+				transport: copilotkit.runtimeTransport,
+				credentials: copilotkit.credentials,
+				runtimeMode: "pending"
+			});
+			copilotkit.applyHeadersToAgent(provisional);
+			provisionalAgentCache.current.set(resolvedAgentId, provisional);
+			return {
+				agent: provisional,
+				isReady: false
+			};
+		}
+		const knownAgents = Object.keys(copilotkit.agents ?? {});
+		const runtimePart = isRuntimeConfigured ? `runtimeUrl=${copilotkit.runtimeUrl}` : "no runtimeUrl";
+		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.");
+	}, [
+		resolvedAgentId,
+		runtimeAgentId,
+		registeredProxyAgent,
+		copilotkit.agents,
+		copilotkit.runtimeConnectionStatus,
+		copilotkit.runtimeUrl,
+		copilotkit.runtimeTransport,
+		copilotkit.credentials,
+		JSON.stringify(copilotkit.headers)
+	]);
+	useEffect(() => {
+		if (updateFlags.length === 0) return;
+		let active = true;
+		const handlers = {};
+		let batchScheduled = false;
+		const batchedForceUpdate = () => {
+			if (!active) return;
+			if (!batchScheduled) {
+				batchScheduled = true;
+				queueMicrotask(() => {
+					batchScheduled = false;
+					if (active) forceUpdate();
+				});
+			}
+		};
+		if (updateFlags.includes(UseAgentUpdate.OnMessagesChanged)) handlers.onMessagesChanged = batchedForceUpdate;
+		if (updateFlags.includes(UseAgentUpdate.OnStateChanged)) handlers.onStateChanged = batchedForceUpdate;
+		if (updateFlags.includes(UseAgentUpdate.OnRunStatusChanged)) {
+			handlers.onRunInitialized = batchedForceUpdate;
+			handlers.onRunStartedEvent = batchedForceUpdate;
+			handlers.onRunFinalized = batchedForceUpdate;
+			handlers.onRunFailed = batchedForceUpdate;
+			handlers.onRunErrorEvent = batchedForceUpdate;
+		}
+		const subscription = copilotkit.subscribeToAgentWithOptions(agent, handlers, { throttleMs });
+		return () => {
+			active = false;
+			subscription.unsubscribe();
+		};
+	}, [
+		agent,
+		forceUpdate,
+		throttleMs,
+		providerThrottleMs,
+		updateFlags
+	]);
+	useEffect(() => {
+		if (ɵisHttpAgent(agent)) copilotkit.applyHeadersToAgent(agent);
+		if (agent instanceof ProxiedCopilotRuntimeAgent) agent.credentials = copilotkit.credentials;
+	}, [
+		agent,
+		JSON.stringify(copilotkit.headers),
+		copilotkit.credentials
+	]);
+	const configThreadId = chatConfig?.threadId;
+	const configHasExplicitThreadId = chatConfig?.hasExplicitThreadId;
+	const resolvedThreadId = threadId ?? (configHasExplicitThreadId ? configThreadId : void 0);
+	useEffect(() => {
+		if (!resolvedThreadId) return;
+		agent.threadId = resolvedThreadId;
+	}, [agent, resolvedThreadId]);
+	return {
+		agent,
+		isReady
+	};
+}
+
+//#endregion
+//#region src/hooks/tool-registration.ts
+/**
+* Deps comparison shared by `useFrontendTool` (and through it
+* `useHumanInTheLoop` and `useComponent`) and `useRenderTool`. Not part of the
+* public API.
+*/
+const EMPTY_DEPS$1 = [];
+function isPlainObject(value) {
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Plain data (primitives, plain objects, arrays, dates) compares by value.
+* Functions always compare equal: these hooks used to compare
+* `JSON.stringify(deps)`, which turns every function into `null`, and a
+* function that counted as changed would re-register on every render when it
+* is written inline (and loop in a component that also reads
+* `useRenderToolCall`). Everything else (class instances, maps, sets) compares
+* by identity. A cycle inside plain data is safe: a pair already being
+* compared counts as equal for that branch.
+*/
+function depEqual(a, b, seen) {
+	if (Object.is(a, b)) return true;
+	if (typeof a === "function" && typeof b === "function") return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (a instanceof Date && b instanceof Date) return Object.is(a.getTime(), b.getTime());
+	const aIsArray = Array.isArray(a);
+	if (aIsArray !== Array.isArray(b)) return false;
+	if (!aIsArray && !(isPlainObject(a) && isPlainObject(b))) return false;
+	if (seen.get(a) === b) return true;
+	seen.set(a, b);
+	if (aIsArray) {
+		const left = a;
+		const right = b;
+		if (left.length !== right.length) return false;
+		for (let i = 0; i < left.length; i++) if (!depEqual(left[i], right[i], seen)) return false;
+		return true;
+	}
+	const left = a;
+	const right = b;
+	const leftKeys = Object.keys(left);
+	if (leftKeys.length !== Object.keys(right).length) return false;
+	for (const key of leftKeys) {
+		if (!Object.prototype.hasOwnProperty.call(right, key)) return false;
+		if (!depEqual(left[key], right[key], seen)) return false;
+	}
+	return true;
+}
+/** Whether two deps arrays are equal. A change in length is always a change. */
+function depsEqual(prev, next) {
+	if (prev.length !== next.length) return false;
+	const seen = /* @__PURE__ */ new Map();
+	for (let i = 0; i < prev.length; i++) if (!depEqual(prev[i], next[i], seen)) return false;
+	return true;
+}
+/**
+* Turns a caller's `deps` array into a number that changes exactly when the
+* deps change, by the rules of {@link depsEqual}. Put the number, not the
+* array, in the registration effect's dependency list: that keeps the list a
+* constant length and never serializes a value.
+*/
+function useDepsVersion(deps) {
+	const next = deps ?? EMPTY_DEPS$1;
+	const ref = useRef({
+		deps: next,
+		version: 0
+	});
+	if (ref.current.deps !== next && !depsEqual(ref.current.deps, next)) ref.current = {
+		deps: next,
+		version: ref.current.version + 1
+	};
+	return ref.current.version;
+}
+
+//#endregion
+//#region src/hooks/use-frontend-tool.tsx
+function useFrontendTool(tool, deps) {
+	const { copilotkit } = useCopilotKit$1();
+	const depsVersion = useDepsVersion(deps);
+	useLayoutEffect(() => {
+		const name = tool.name;
+		if (copilotkit.getTool({
+			toolName: name,
+			agentId: tool.agentId
+		})) {
+			console.warn(`Tool '${name}' already exists for agent '${tool.agentId || "global"}'. Overriding with latest registration.`);
+			copilotkit.removeTool(name, tool.agentId);
+		}
+		copilotkit.addTool(tool);
+		if (tool.render) copilotkit.addHookRenderToolCall({
+			name,
+			args: tool.parameters,
+			agentId: tool.agentId,
+			render: tool.render
+		});
+		return () => {
+			copilotkit.removeTool(name, tool.agentId);
+		};
+	}, [
+		tool.name,
+		tool.available,
+		copilotkit,
+		depsVersion,
+		JSON.stringify(tool.webmcp ?? null)
+	]);
+}
+
+//#endregion
+//#region src/hooks/use-frontend-tools.tsx
+const EMPTY_DEPS = [];
+const EMPTY_TOOLS = [];
+/**
+* Register a list of frontend tools whose length can change between renders.
+*
+* `useFrontendTool` registers exactly one tool per call, so it cannot be called
+* in a loop over a runtime-length list without breaking the rules of hooks.
+* This hook runs a single effect over the whole array instead, which makes it
+* safe to build the list from state, props, or a server response.
+*
+* Tools are keyed by `name` plus `agentId`, the same as `useFrontendTool`. A
+* tool that disappears from the array is unregistered on the next render, and
+* every tool is unregistered on unmount. Renderers stay registered after
+* unmount so past tool calls still render in the chat history.
+*
+* @param tools - The tools to register. May be empty and may change length.
+* @param deps - Extra dependencies that force re-registration, compared by
+* identity like the second argument of `useEffect`. Use this when a handler
+* closes over a value that is not part of the tool definition. Keep the array
+* a constant length across renders.
+*
+* @example
+* Register one tool per item in application state:
+* ```tsx
+* const [reports, setReports] = useState<Report[]>([]);
+*
+* useFrontendTools(
+*   reports.map((report) => ({
+*     name: `open_${report.id}`,
+*     description: `Open the ${report.title} report`,
+*     handler: async () => navigate(`/reports/${report.id}`),
+*   })),
+*   [navigate],
+* );
+* ```
+*
+* @example
+* Register tools described by the backend:
+* ```tsx
+* const { data } = useQuery(fetchToolDescriptors);
+*
+* useFrontendTools(
+*   (data ?? []).map((descriptor) => ({
+*     name: descriptor.name,
+*     description: descriptor.description,
+*     parameters: z.object({ query: z.string() }),
+*     handler: async ({ query }) => runDescriptor(descriptor.id, query),
+*   })),
+* );
+* ```
+*/
+function useFrontendTools(tools, deps) {
+	const { copilotkit } = useCopilotKit$1();
+	const toolList = tools ?? EMPTY_TOOLS;
+	const extraDeps = deps ?? EMPTY_DEPS;
+	useLayoutEffect(() => {
+		const deduped = /* @__PURE__ */ new Map();
+		for (const tool of toolList) {
+			const key = `${tool.agentId ?? ""}:${tool.name}`;
+			if (deduped.has(key)) console.warn(`Tool '${tool.name}' is listed more than once for agent '${tool.agentId || "global"}' in the same useFrontendTools call. Using the last entry.`);
+			deduped.set(key, tool);
+		}
+		const registered = [...deduped.values()];
+		for (const tool of registered) {
+			if (copilotkit.getTool({
+				toolName: tool.name,
+				agentId: tool.agentId
+			})) {
+				console.warn(`Tool '${tool.name}' already exists for agent '${tool.agentId || "global"}'. Overriding with latest registration.`);
+				copilotkit.removeTool(tool.name, tool.agentId);
+			}
+			copilotkit.addTool(tool);
+			if (tool.render) copilotkit.addHookRenderToolCall({
+				name: tool.name,
+				args: tool.parameters,
+				agentId: tool.agentId,
+				render: tool.render
+			});
+		}
+		return () => {
+			for (const tool of registered) copilotkit.removeTool(tool.name, tool.agentId);
+		};
+	}, [
+		JSON.stringify(toolList.map((tool) => [
+			tool.name,
+			tool.description ?? null,
+			tool.agentId ?? null,
+			tool.available ?? null,
+			tool.webmcp ?? null
+		])),
+		copilotkit,
+		...extraDeps
+	]);
+}
+
+//#endregion
+//#region src/hooks/use-component.tsx
+/**
+* Registers a React component as a frontend tool renderer in chat.
+*
+* This hook is a convenience wrapper around `useFrontendTool` that:
+* - builds a model-facing tool description,
+* - forwards optional schema parameters (any Standard Schema V1 compatible library),
+* - renders your component with tool call parameters.
+*
+* Use this when you want to display a typed visual component for a tool call
+* without manually wiring a full frontend tool object.
+*
+* When `parameters` is provided, render props are inferred from the schema.
+* When omitted, the render component may accept any props.
+*
+* @typeParam TSchema - Schema describing tool parameters, or `undefined` when no schema is given.
+* @param config - Tool registration config.
+* @param deps - Optional dependencies to refresh registration (same semantics as `useEffect`).
+*
+* @example
+* ```tsx
+* // Without parameters — render accepts any props
+* useComponent({
+*   name: "showGreeting",
+*   render: ({ message }: { message: string }) => <div>{message}</div>,
+* });
+* ```
+*
+* @example
+* ```tsx
+* // With parameters — render props inferred from schema
+* useComponent({
+*   name: "showWeatherCard",
+*   parameters: z.object({ city: z.string() }),
+*   render: ({ city }) => <div>{city}</div>,
+* });
+* ```
+*
+* @example
+* ```tsx
+* useComponent(
+*   {
+*     name: "renderProfile",
+*     parameters: z.object({ userId: z.string() }),
+*     render: ProfileCard,
+*     agentId: "support-agent",
+*   },
+*   [selectedAgentId],
+* );
+* ```
+*/
+function useComponent(config, deps) {
+	const prefix = `Use this tool to display the "${config.name}" component in the chat. This tool renders a visual UI component for the user.`;
+	const fullDescription = config.description ? `${prefix}\n\n${config.description}` : prefix;
+	useFrontendTool({
+		name: config.name,
+		description: fullDescription,
+		parameters: config.parameters,
+		render: ({ args }) => {
+			const Component = config.render;
+			return /* @__PURE__ */ jsx(Component, { ...args });
+		},
+		agentId: config.agentId,
+		followUp: config.followUp
+	}, deps);
+}
+
+//#endregion
+//#region src/hooks/use-human-in-the-loop.tsx
+/** Registration name of a catch-all tool: handles any otherwise-unhandled call. */
+const WILDCARD_TOOL_NAME = "*";
+function useHumanInTheLoop(tool, deps) {
+	const { copilotkit } = useCopilotKit$1();
+	const resolvePromiseRef = useRef(null);
+	const cleanupAbortRef = useRef(null);
+	const respond = useCallback(async (result) => {
+		if (resolvePromiseRef.current) {
+			cleanupAbortRef.current?.();
+			cleanupAbortRef.current = null;
+			resolvePromiseRef.current(result);
+			resolvePromiseRef.current = null;
+		}
+	}, []);
+	const handler = useCallback(async (_args, context) => {
+		const signal = context?.signal;
+		return new Promise((resolve, reject) => {
+			if (signal?.aborted) {
+				reject(/* @__PURE__ */ new Error("Human-in-the-loop interaction aborted"));
+				return;
+			}
+			resolvePromiseRef.current = resolve;
+			if (signal) {
+				const onAbort = () => {
+					cleanupAbortRef.current = null;
+					resolvePromiseRef.current = null;
+					reject(/* @__PURE__ */ new Error("Human-in-the-loop interaction aborted"));
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				cleanupAbortRef.current = () => {
+					signal.removeEventListener("abort", onAbort);
+				};
+			}
+		});
+	}, []);
+	const RenderComponent = useCallback((props) => {
+		const ToolComponent = tool.render;
+		const name = tool.name === WILDCARD_TOOL_NAME ? props.name : tool.name;
+		if (props.status === ToolCallStatus.InProgress) {
+			const enhancedProps = {
+				...props,
+				name,
+				description: tool.description || "",
+				agentId: tool.agentId,
+				respond: void 0
+			};
+			return React.createElement(ToolComponent, enhancedProps);
+		} else if (props.status === ToolCallStatus.Executing) {
+			const enhancedProps = {
+				...props,
+				name,
+				description: tool.description || "",
+				agentId: tool.agentId,
+				respond
+			};
+			return React.createElement(ToolComponent, enhancedProps);
+		} else if (props.status === ToolCallStatus.Complete) {
+			const enhancedProps = {
+				...props,
+				name,
+				description: tool.description || "",
+				agentId: tool.agentId,
+				respond: void 0
+			};
+			return React.createElement(ToolComponent, enhancedProps);
+		}
+		return props;
+	}, [
+		tool.render,
+		tool.name,
+		tool.description,
+		tool.agentId,
+		respond
+	]);
+	useFrontendTool({
+		...tool,
+		type: "human-in-the-loop",
+		handler,
+		render: RenderComponent
+	}, deps);
+	useLayoutEffect(() => {
+		return () => {
+			copilotkit.removeHookRenderToolCall(tool.name, tool.agentId);
+		};
+	}, [
+		copilotkit,
+		tool.name,
+		tool.agentId
+	]);
+}
+
+//#endregion
+//#region src/types/interrupt.ts
+/** Name of the legacy custom event agents emit to signal an interrupt. */
+const INTERRUPT_EVENT_NAME = "on_interrupt";
+
+//#endregion
+//#region src/hooks/use-interrupt.tsx
+/** Recognize thenables returned by interrupt preprocessing handlers. */
+function isPromiseLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null && typeof Reflect.get(value, "then") === "function";
+}
+/** Derive the legacy-compatible `event` for any pending interrupt. */
+function toLegacyEvent(pending) {
+	if (pending.kind === "legacy") return pending.event;
+	return {
+		name: INTERRUPT_EVENT_NAME,
+		value: pending.interrupts[0]
+	};
+}
+/**
+* Handles agent interrupts with optional filtering, preprocessing, and resume behavior.
+*
+* Supports both the AG-UI standard interrupt flow (`RUN_FINISHED` with
+* `outcome.type === "interrupt"`) and the legacy custom-event flow
+* (`on_interrupt`). For standard interrupts, `render` receives `interrupt`
+* (the primary one) and `interrupts` (the full open set); call `resolve(payload)`
+* to resume or `cancel()` to cancel. Resuming addresses the targeted interrupt
+* and, once every open interrupt is addressed, submits a single spec `resume`
+* array via `copilotkit.runAgent`.
+*
+* - `renderInChat: true` (default): the element is published into `<CopilotChat>`; returns `void`.
+* - `renderInChat: false`: the hook returns the interrupt element for manual placement.
+*
+* @example
+* ```tsx
+* useInterrupt({
+*   render: ({ interrupt, resolve, cancel }) => (
+*     <div>
+*       <p>{interrupt?.message}</p>
+*       <button onClick={() => resolve({ approved: true })}>Approve</button>
+*       <button onClick={() => cancel()}>Cancel</button>
+*     </div>
+*   ),
+* });
+* ```
+*/
+function useInterrupt(config) {
+	const { copilotkit } = useCopilotKit$1();
+	const { agent } = useAgent({
+		agentId: config.agentId,
+		updates: []
+	});
+	const [pending, setPending] = useState(null);
+	const pendingRef = useRef(pending);
+	pendingRef.current = pending;
+	const [handlerResult, setHandlerResult] = useState(null);
+	const interruptStateRef = useRef(new ɵInterruptState());
+	useEffect(() => {
+		let localLegacy = null;
+		let localStandard = null;
+		const subscription = agent.subscribe({
+			onCustomEvent: ({ event }) => {
+				if (event.name === INTERRUPT_EVENT_NAME) localLegacy = {
+					name: event.name,
+					value: event.value
+				};
+			},
+			onRunFinishedEvent: (params) => {
+				if (params.outcome === "interrupt") localStandard = params.interrupts;
+			},
+			onRunStartedEvent: (params) => {
+				if (!agent.pendingInterrupts?.length || params?.input?.resume !== void 0) ɵclearAgentInterruptState(agent);
+				localLegacy = null;
+				localStandard = null;
+				interruptStateRef.current = new ɵInterruptState();
+				setPending(null);
+			},
+			onRunFinalized: () => {
+				if (localStandard && localStandard.length > 0) {
+					interruptStateRef.current = ɵgetAgentInterruptState(agent, localStandard);
+					setPending(interruptStateRef.current.pending);
+				} else if (localLegacy) {
+					interruptStateRef.current = new ɵInterruptState();
+					interruptStateRef.current.setLegacy(localLegacy);
+					setPending(interruptStateRef.current.pending);
+				}
+				localLegacy = null;
+				localStandard = null;
+			},
+			onRunFailed: () => {
+				localLegacy = null;
+				localStandard = null;
+				interruptStateRef.current = new ɵInterruptState();
+				setPending(null);
+			}
+		});
+		interruptStateRef.current = agent.pendingInterrupts?.length ? ɵgetAgentInterruptState(agent) : new ɵInterruptState();
+		setPending(interruptStateRef.current.pending);
+		return () => {
+			subscription.unsubscribe();
+			interruptStateRef.current = new ɵInterruptState();
+		};
+	}, [agent]);
+	/** Record an explicit answer and resume once the complete batch is addressed. */
+	const resolve = useCallback(async (payload, interruptId) => {
+		const current = pendingRef.current;
+		if (!current) return;
+		if (current.kind === "standard" && current.interrupts.length > 1 && interruptId === void 0) console.warn(`[CopilotKit] useInterrupt: resolve()/cancel() called without an interruptId while ${current.interrupts.length} interrupts are open; defaulting to the first. Pass an interruptId to address a specific interrupt.`);
+		if (interruptStateRef.current.isCompletedToolCall(interruptId, agent.messages)) {
+			console.warn("[CopilotKit] useInterrupt: ignoring an answer for an already completed frontend tool call.");
+			return;
+		}
+		const decision = interruptStateRef.current.resolve(payload, interruptId, agent.messages);
+		if (decision.kind === "legacy-resume") try {
+			return await copilotkit.runAgent({
+				agent,
+				forwardedProps: { command: {
+					resume: decision.payload,
+					interruptEvent: decision.interruptValue
+				} }
+			});
+		} catch (err) {
+			console.error("[CopilotKit] useInterrupt resolve: runAgent rejected; clearing pending + rethrowing", err);
+			setPending(null);
+			throw err;
+		}
+		if (decision.kind === "expired") {
+			console.error(`[CopilotKit] useInterrupt: interrupt ${decision.interrupt.id} expired at ${decision.interrupt.expiresAt}; not resuming.`);
+			interruptStateRef.current = new ɵInterruptState();
+			setPending(null);
+			return;
+		}
+		if (decision.kind !== "resume") return;
+		for (const toolResult of decision.toolResults) agent.addMessage({
+			id: randomUUID$1(),
+			role: "tool",
+			toolCallId: toolResult.toolCallId,
+			content: toolResult.content
+		});
+		try {
+			return await copilotkit.runAgent({
+				agent,
+				resume: decision.resume
+			});
+		} catch (err) {
+			console.error("[CopilotKit] useInterrupt resolve: runAgent rejected; clearing pending + rethrowing", err);
+			interruptStateRef.current = new ɵInterruptState();
+			setPending(null);
+			throw err;
+		}
+	}, [agent, copilotkit]);
+	/** Cancel a standard interrupt or dismiss a legacy interrupt locally. */
+	const cancel = useCallback(async (interruptId) => {
+		const current = pendingRef.current;
+		if (!current) return;
+		if (current.kind === "standard" && current.interrupts.length > 1 && interruptId === void 0) console.warn(`[CopilotKit] useInterrupt: resolve()/cancel() called without an interruptId while ${current.interrupts.length} interrupts are open; defaulting to the first. Pass an interruptId to address a specific interrupt.`);
+		if (interruptStateRef.current.isCompletedToolCall(interruptId, agent.messages)) {
+			console.warn("[CopilotKit] useInterrupt: ignoring an answer for an already completed frontend tool call.");
+			return;
+		}
+		const decision = interruptStateRef.current.cancel(interruptId, agent.messages);
+		if (decision.kind === "dismiss") {
+			console.warn("[CopilotKit] useInterrupt: cancel() is not supported for legacy on_interrupt interrupts; dismissing.");
+			interruptStateRef.current = new ɵInterruptState();
+			setPending(null);
+			return;
+		}
+		if (decision.kind === "expired") {
+			console.error(`[CopilotKit] useInterrupt: interrupt ${decision.interrupt.id} expired at ${decision.interrupt.expiresAt}; not resuming.`);
+			interruptStateRef.current = new ɵInterruptState();
+			setPending(null);
+			return;
+		}
+		if (decision.kind !== "resume") return;
+		for (const toolResult of decision.toolResults) agent.addMessage({
+			id: randomUUID$1(),
+			role: "tool",
+			toolCallId: toolResult.toolCallId,
+			content: toolResult.content
+		});
+		try {
+			return await copilotkit.runAgent({
+				agent,
+				resume: decision.resume
+			});
+		} catch (err) {
+			console.error("[CopilotKit] useInterrupt resolve: runAgent rejected; clearing pending + rethrowing", err);
+			interruptStateRef.current = new ɵInterruptState();
+			setPending(null);
+			throw err;
+		}
+	}, [agent, copilotkit]);
+	const renderRef = useRef(config.render);
+	renderRef.current = config.render;
+	const enabledRef = useRef(config.enabled);
+	enabledRef.current = config.enabled;
+	const handlerRef = useRef(config.handler);
+	handlerRef.current = config.handler;
+	const resolveRef = useRef(resolve);
+	resolveRef.current = resolve;
+	const cancelRef = useRef(cancel);
+	cancelRef.current = cancel;
+	/** Evaluate the consumer filter, logging failures and disabling their UI. */
+	const isEnabled = (event) => {
+		const predicate = enabledRef.current;
+		if (!predicate) return true;
+		try {
+			return predicate(event);
+		} catch (err) {
+			console.error("[CopilotKit] useInterrupt enabled predicate threw; treating interrupt as disabled:", err);
+			return false;
+		}
+	};
+	useEffect(() => {
+		if (!pending) {
+			setHandlerResult(null);
+			return;
+		}
+		const legacyEvent = toLegacyEvent(pending);
+		if (!isEnabled(legacyEvent)) {
+			setHandlerResult(null);
+			return;
+		}
+		const handler = handlerRef.current;
+		if (!handler) {
+			setHandlerResult(null);
+			return;
+		}
+		let cancelled = false;
+		let maybePromise;
+		try {
+			maybePromise = handler({
+				event: legacyEvent,
+				interrupt: pending.kind === "standard" ? pending.interrupts[0] : null,
+				interrupts: pending.kind === "standard" ? [...pending.interrupts] : [],
+				resolve: resolveRef.current,
+				cancel: cancelRef.current
+			});
+		} catch (err) {
+			console.error("[CopilotKit] useInterrupt handler threw; result will be null:", err);
+			if (!cancelled) setHandlerResult(null);
+			return () => {
+				cancelled = true;
+			};
+		}
+		if (isPromiseLike(maybePromise)) Promise.resolve(maybePromise).then((resolved) => {
+			if (!cancelled) setHandlerResult(resolved);
+		}).catch((err) => {
+			console.error("[CopilotKit] useInterrupt handler rejected; result will be null:", err);
+			if (!cancelled) setHandlerResult(null);
+		});
+		else setHandlerResult(maybePromise);
+		return () => {
+			cancelled = true;
+		};
+	}, [pending]);
+	const element = useMemo(() => {
+		if (!pending) return null;
+		const legacyEvent = toLegacyEvent(pending);
+		if (!isEnabled(legacyEvent)) return null;
+		return renderRef.current({
+			event: legacyEvent,
+			interrupt: pending.kind === "standard" ? pending.interrupts[0] : null,
+			interrupts: pending.kind === "standard" ? [...pending.interrupts] : [],
+			result: handlerResult,
+			resolve,
+			cancel
+		});
+	}, [
+		pending,
+		handlerResult,
+		resolve,
+		cancel
+	]);
+	useEffect(() => {
+		if (config.renderInChat === false) return;
+		copilotkit.setInterruptElement(element);
+	}, [
+		element,
+		config.renderInChat,
+		copilotkit
+	]);
+	useEffect(() => {
+		if (config.renderInChat === false) return;
+		return () => {
+			copilotkit.setInterruptElement(null);
+		};
+	}, []);
+	if (config.renderInChat === false) return element;
+}
+
+//#endregion
+//#region src/hooks/use-suggestions.tsx
+function useSuggestions({ agentId } = {}) {
+	const { copilotkit } = useCopilotKit$1();
+	const config = useCopilotChatConfiguration();
+	const providerAgentId = useDefaultAgentId();
+	const resolvedAgentId = useMemo(() => agentId ?? config?.agentId ?? providerAgentId ?? DEFAULT_AGENT_ID, [
+		agentId,
+		config?.agentId,
+		providerAgentId
+	]);
+	const [suggestions, setSuggestions] = useState(() => {
+		return copilotkit.getSuggestions(resolvedAgentId).suggestions;
+	});
+	const [isLoading, setIsLoading] = useState(() => {
+		return copilotkit.getSuggestions(resolvedAgentId).isLoading;
+	});
+	useEffect(() => {
+		const result = copilotkit.getSuggestions(resolvedAgentId);
+		setSuggestions(result.suggestions);
+		setIsLoading(result.isLoading);
+	}, [copilotkit, resolvedAgentId]);
+	useEffect(() => {
+		const subscription = copilotkit.subscribe({
+			onSuggestionsChanged: ({ agentId: changedAgentId, suggestions }) => {
+				if (changedAgentId !== resolvedAgentId) return;
+				setSuggestions(suggestions);
+			},
+			onSuggestionsStartedLoading: ({ agentId: changedAgentId }) => {
+				if (changedAgentId !== resolvedAgentId) return;
+				setIsLoading(true);
+			},
+			onSuggestionsFinishedLoading: ({ agentId: changedAgentId }) => {
+				if (changedAgentId !== resolvedAgentId) return;
+				setIsLoading(false);
+			},
+			onSuggestionsConfigChanged: () => {
+				const result = copilotkit.getSuggestions(resolvedAgentId);
+				setSuggestions(result.suggestions);
+				setIsLoading(result.isLoading);
+			}
+		});
+		return () => {
+			subscription.unsubscribe();
+		};
+	}, [copilotkit, resolvedAgentId]);
+	return {
+		suggestions,
+		reloadSuggestions: useCallback(() => {
+			copilotkit.reloadSuggestions(resolvedAgentId);
+		}, [copilotkit, resolvedAgentId]),
+		clearSuggestions: useCallback(() => {
+			copilotkit.clearSuggestions(resolvedAgentId);
+		}, [copilotkit, resolvedAgentId]),
+		isLoading
+	};
+}
+
+//#endregion
+//#region src/hooks/use-configure-suggestions.tsx
+function useConfigureSuggestions(config, deps) {
+	const { copilotkit } = useCopilotKit$1();
+	const chatConfig = useCopilotChatConfiguration();
+	const extraDeps = deps ?? [];
+	const resolvedConsumerAgentId = useMemo(() => chatConfig?.agentId ?? DEFAULT_AGENT_ID, [chatConfig?.agentId]);
+	const rawConsumerAgentId = useMemo(() => config ? config.consumerAgentId : void 0, [config]);
+	const normalizationCacheRef = useRef({
+		serialized: null,
+		config: null
+	});
+	const { normalizedConfig, serializedConfig } = useMemo(() => {
+		if (!config) {
+			normalizationCacheRef.current = {
+				serialized: null,
+				config: null
+			};
+			return {
+				normalizedConfig: null,
+				serializedConfig: null
+			};
+		}
+		if (config.available === "disabled") {
+			normalizationCacheRef.current = {
+				serialized: null,
+				config: null
+			};
+			return {
+				normalizedConfig: null,
+				serializedConfig: null
+			};
+		}
+		let built;
+		if (isDynamicConfig(config)) built = { ...config };
+		else {
+			const normalizedSuggestions = normalizeStaticSuggestions(config.suggestions);
+			built = {
+				...config,
+				suggestions: normalizedSuggestions
+			};
+		}
+		const serialized = JSON.stringify(built);
+		const cache = normalizationCacheRef.current;
+		if (cache.serialized === serialized && cache.config) return {
+			normalizedConfig: cache.config,
+			serializedConfig: serialized
+		};
+		normalizationCacheRef.current = {
+			serialized,
+			config: built
+		};
+		return {
+			normalizedConfig: built,
+			serializedConfig: serialized
+		};
+	}, [
+		config,
+		resolvedConsumerAgentId,
+		...extraDeps
+	]);
+	const latestConfigRef = useRef(null);
+	latestConfigRef.current = normalizedConfig;
+	const previousSerializedConfigRef = useRef(null);
+	const targetAgentId = useMemo(() => {
+		if (!normalizedConfig) return resolvedConsumerAgentId;
+		const consumer = normalizedConfig.consumerAgentId;
+		if (!consumer || consumer === "*") return resolvedConsumerAgentId;
+		return consumer;
+	}, [normalizedConfig, resolvedConsumerAgentId]);
+	const isGlobalConfig = rawConsumerAgentId === void 0 || rawConsumerAgentId === "*";
+	const isDynamicConfigType = useMemo(() => !!normalizedConfig && "instructions" in normalizedConfig, [normalizedConfig]);
+	const requestReload = useCallback(() => {
+		if (!normalizedConfig) return;
+		if (isGlobalConfig) {
+			const seen = /* @__PURE__ */ new Set();
+			const agents = Object.values(copilotkit.agents ?? {});
+			for (const entry of agents) {
+				const agentId = entry.agentId;
+				if (!agentId) continue;
+				seen.add(agentId);
+				if (!entry.isRunning) copilotkit.reloadSuggestions(agentId);
+			}
+			if (targetAgentId && !seen.has(targetAgentId)) copilotkit.reloadSuggestions(targetAgentId);
+			return;
+		}
+		if (!targetAgentId) return;
+		copilotkit.reloadSuggestions(targetAgentId);
+	}, [
+		copilotkit,
+		isGlobalConfig,
+		normalizedConfig,
+		targetAgentId
+	]);
+	useEffect(() => {
+		if (!serializedConfig || !latestConfigRef.current) return;
+		const id = copilotkit.addSuggestionsConfig(latestConfigRef.current);
+		requestReload();
+		return () => {
+			copilotkit.removeSuggestionsConfig(id);
+		};
+	}, [
+		copilotkit,
+		serializedConfig,
+		requestReload
+	]);
+	useEffect(() => {
+		if (!normalizedConfig) {
+			previousSerializedConfigRef.current = null;
+			return;
+		}
+		if (serializedConfig && previousSerializedConfigRef.current === serializedConfig) return;
+		if (serializedConfig) previousSerializedConfigRef.current = serializedConfig;
+		requestReload();
+	}, [
+		normalizedConfig,
+		requestReload,
+		serializedConfig
+	]);
+	useEffect(() => {
+		if (!normalizedConfig || extraDeps.length === 0) return;
+		requestReload();
+	}, [
+		extraDeps.length,
+		normalizedConfig,
+		requestReload,
+		...extraDeps
+	]);
+	useEffect(() => {
+		if (!normalizedConfig || !isDynamicConfigType) return;
+		if (!targetAgentId) return;
+		if (!!copilotkit.getAgent(targetAgentId)) return;
+		const subscription = copilotkit.subscribe({ onAgentsChanged: () => {
+			if (copilotkit.getAgent(targetAgentId)) {
+				requestReload();
+				subscription.unsubscribe();
+			}
+		} });
+		return () => {
+			subscription.unsubscribe();
+		};
+	}, [
+		copilotkit,
+		normalizedConfig,
+		isDynamicConfigType,
+		targetAgentId,
+		requestReload
+	]);
+}
+function isDynamicConfig(config) {
+	return "instructions" in config;
+}
+function normalizeStaticSuggestions(suggestions) {
+	return suggestions.map((suggestion) => ({
+		...suggestion,
+		isLoading: suggestion.isLoading ?? false
+	}));
+}
+
+//#endregion
+//#region src/hooks/use-agent-context.tsx
+function useAgentContext(context) {
+	const { description, value } = context;
+	const { copilotkit } = useCopilotKit$1();
+	const stringValue = useMemo(() => {
+		if (typeof value === "string") return value;
+		return JSON.stringify(value);
+	}, [value]);
+	useLayoutEffect(() => {
+		if (!copilotkit) return;
+		const id = copilotkit.addContext({
+			description,
+			value: stringValue
+		});
+		return () => {
+			copilotkit.removeContext(id);
+		};
+	}, [
+		description,
+		stringValue,
+		copilotkit
+	]);
+}
+
+//#endregion
+//#region src/hooks/use-threads.tsx
+function useThreadStoreSelector(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 CopilotKit Intelligence threads.
+*
+* On mount the hook fetches the thread list for the runtime-authenticated user
+* and the given `agentId`. When CopilotKit Intelligence exposes a WebSocket
+* URL, it also opens a realtime subscription so the `threads` array stays
+* current without polling — thread creates, renames, archives, and deletes
+* from any client are reflected immediately.
+*
+* Mutation methods (`renameThread`, `archiveThread`, `unarchiveThread`,
+* `deleteThread`) return promises that resolve once the platform confirms the
+* operation and reject with an `Error` on failure.
+*
+* @param input - Agent identifier and optional list controls.
+* @returns Thread list state and stable mutation callbacks.
+*
+* @example
+* ```tsx
+* import { useThreads } from "@copilotkit/react-core";
+*
+* function ThreadList() {
+*   const { threads, isLoading, renameThread, deleteThread } = useThreads({
+*     agentId: "agent-1",
+*   });
+*
+*   if (isLoading) return <p>Loading…</p>;
+*
+*   return (
+*     <ul>
+*       {threads.map((t) => (
+*         <li key={t.id}>
+*           {t.name ?? "Untitled"}
+*           <button onClick={() => renameThread(t.id, "New name")}>Rename</button>
+*           <button onClick={() => deleteThread(t.id)}>Delete</button>
+*         </li>
+*       ))}
+*     </ul>
+*   );
+* }
+* ```
+*/
+function useThreads({ agentId, includeArchived, limit, enabled = true }) {
+	const { copilotkit } = useCopilotKit$1();
+	const [store] = useState(() => ɵcreateThreadStore({ fetch: copilotkit.ɵruntimeFetch }));
+	const coreThreads = useThreadStoreSelector(store, ɵselectThreads);
+	const threads = useMemo(() => coreThreads.map(({ id, agentId, name, archived, createdAt, updatedAt, lastRunAt }) => ({
+		id,
+		agentId,
+		name,
+		archived,
+		createdAt,
+		updatedAt,
+		...lastRunAt !== void 0 ? { lastRunAt } : {}
+	})), [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);
+	const headersKey = copilotkit.ɵheadersGeneration;
+	const runtimeStatus = copilotkit.runtimeConnectionStatus;
+	const threadListEndpointSupported = copilotkit.threadEndpoints?.list !== false;
+	const threadMutationsSupported = copilotkit.threadEndpoints?.mutations !== false;
+	const threadEndpointsUnavailable = !!copilotkit.runtimeUrl && runtimeStatus === CopilotKitCoreRuntimeConnectionStatus.Connected && !threadListEndpointSupported;
+	const runtimeError = useMemo(() => {
+		if (copilotkit.runtimeUrl) return null;
+		return /* @__PURE__ */ new Error("Runtime URL is not configured");
+	}, [copilotkit.runtimeUrl]);
+	const threadEndpointsError = useMemo(() => {
+		if (!threadEndpointsUnavailable) return null;
+		return /* @__PURE__ */ new Error("Thread endpoints are not available on this CopilotKit runtime");
+	}, [threadEndpointsUnavailable]);
+	const threadMutationsError = useMemo(() => {
+		if (threadMutationsSupported) return null;
+		return /* @__PURE__ */ new Error("Thread mutations are not available on this CopilotKit runtime");
+	}, [threadMutationsSupported]);
+	const [hasDispatchedContext, setHasDispatchedContext] = useState(false);
+	const preConnectLoading = enabled && !!copilotkit.runtimeUrl && !threadEndpointsUnavailable && !hasDispatchedContext;
+	const [configErrorDismissed, setConfigErrorDismissed] = useState(false);
+	useEffect(() => {
+		setConfigErrorDismissed(false);
+	}, [runtimeError, threadEndpointsError]);
+	const activeRuntimeError = configErrorDismissed ? null : runtimeError;
+	const activeThreadEndpointsError = configErrorDismissed ? null : threadEndpointsError;
+	const isLoading = activeRuntimeError || activeThreadEndpointsError ? false : preConnectLoading || storeIsLoading;
+	const error = activeRuntimeError ?? activeThreadEndpointsError ?? storeError;
+	const listError = storeError;
+	useEffect(() => {
+		store.start();
+		return () => {
+			store.stop();
+		};
+	}, [store]);
+	useEffect(() => {
+		if (!enabled) return;
+		copilotkit.registerThreadStore(agentId, store);
+		return () => {
+			copilotkit.unregisterThreadStore(agentId);
+		};
+	}, [
+		copilotkit,
+		agentId,
+		store,
+		enabled
+	]);
+	useEffect(() => {
+		if (!enabled) {
+			store.setContext(null);
+			setHasDispatchedContext(false);
+			return;
+		}
+		if (!copilotkit.runtimeUrl) {
+			store.setContext(null);
+			setHasDispatchedContext(false);
+			return;
+		}
+		if (runtimeStatus !== CopilotKitCoreRuntimeConnectionStatus.Connected) return;
+		if (!threadListEndpointSupported) {
+			store.setContext(null);
+			setHasDispatchedContext(false);
+			return;
+		}
+		const context = {
+			runtimeUrl: copilotkit.runtimeUrl,
+			wsUrl: copilotkit.intelligence?.wsUrl,
+			agentId,
+			includeArchived,
+			limit
+		};
+		store.setContext(context);
+		setHasDispatchedContext(true);
+	}, [
+		store,
+		enabled,
+		copilotkit.runtimeUrl,
+		runtimeStatus,
+		headersKey,
+		copilotkit.intelligence?.wsUrl,
+		threadListEndpointSupported,
+		agentId,
+		includeArchived,
+		limit
+	]);
+	const guardMutation = useCallback((mutation) => {
+		return (...args) => {
+			if (threadMutationsError) return Promise.reject(threadMutationsError);
+			return mutation(...args);
+		};
+	}, [threadMutationsError]);
+	const renameThread = useMemo(() => guardMutation((threadId, name) => store.renameThread(threadId, name)), [store, guardMutation]);
+	const archiveThread = useMemo(() => guardMutation((threadId) => store.archiveThread(threadId)), [store, guardMutation]);
+	const unarchiveThread = useMemo(() => guardMutation((threadId) => store.unarchiveThread(threadId)), [store, guardMutation]);
+	const deleteThread = useMemo(() => guardMutation((threadId) => store.deleteThread(threadId)), [store, guardMutation]);
+	return {
+		threads,
+		isLoading,
+		error,
+		listError,
+		fetchMoreError,
+		hasMoreThreads,
+		isFetchingMoreThreads,
+		isMutating,
+		fetchMoreThreads: useCallback(() => store.fetchNextPage(), [store]),
+		refetchThreads: useCallback(() => store.refetchThreads(), [store]),
+		startNewThread: useCallback(() => {
+			setConfigErrorDismissed(true);
+			store.startNewThread();
+		}, [store]),
+		renameThread,
+		archiveThread,
+		unarchiveThread,
+		deleteThread
+	};
+}
+
+//#endregion
+//#region src/types/defineToolCallRenderer.ts
+function defineToolCallRenderer(def) {
+	const argsSchema = def.name === "*" && !def.args ? z.any() : def.args;
+	return {
+		name: def.name,
+		args: argsSchema,
+		render: def.render,
+		...def.agentId ? { agentId: def.agentId } : {},
+		...def.group ? { group: true } : {}
+	};
+}
+
+//#endregion
+//#region src/hooks/use-render-tool.tsx
+/**
+* Registers a renderer entry in CopilotKit's `renderToolCalls` registry.
+*
+* Key behavior:
+* - deduplicates by `agentId:name` (latest registration wins),
+* - keeps renderer entries on cleanup so historical chat tool calls can still render,
+* - refreshes registration when `deps` change.
+*
+* @typeParam S - Schema type describing tool call parameters.
+* @param config - Renderer config for wildcard or named tools.
+* @param deps - Optional dependencies to refresh registration.
+*
+* @example
+* ```tsx
+* useRenderTool(
+*   {
+*     name: "searchDocs",
+*     parameters: z.object({ query: z.string() }),
+*     render: ({ status, parameters, result }) => {
+*       if (status === "executing") return <div>Searching {parameters.query}</div>;
+*       if (status === "complete") return <div>{result}</div>;
+*       return <div>Preparing...</div>;
+*     },
+*   },
+*   [],
+* );
+* ```
+*
+* @example
+* ```tsx
+* useRenderTool(
+*   {
+*     name: "summarize",
+*     parameters: z.object({ text: z.string() }),
+*     agentId: "research-agent",
+*     render: ({ name, status }) => <div>{name}: {status}</div>,
+*   },
+*   [selectedAgentId],
+* );
+* ```
+*/
+function useRenderTool(config, deps) {
+	const { copilotkit } = useCopilotKit$1();
+	const depsVersion = useDepsVersion(deps);
+	useEffect(() => {
+		const renderer = config.name === "*" && !config.parameters ? defineToolCallRenderer({
+			name: "*",
+			render: (props) => config.render({
+				...props,
+				parameters: props.args
+			}),
+			...config.agentId ? { agentId: config.agentId } : {},
+			group: config.group
+		}) : defineToolCallRenderer({
+			name: config.name,
+			args: config.parameters,
+			render: (props) => {
+				if (props.status === ToolCallStatus.InProgress) return config.render({
+					...props,
+					parameters: props.args
+				});
+				if (props.status === ToolCallStatus.Executing) return config.render({
+					...props,
+					parameters: props.args
+				});
+				return config.render({
+					...props,
+					parameters: props.args
+				});
+			},
+			...config.agentId ? { agentId: config.agentId } : {},
+			group: config.group
+		});
+		copilotkit.addHookRenderToolCall(renderer);
+	}, [
+		config.name,
+		config.group,
+		copilotkit,
+		depsVersion
+	]);
+}
+
+//#endregion
+//#region src/hooks/use-render-tool-call.tsx
+/**
+* Memoized component that renders a single tool call.
+* This prevents unnecessary re-renders when parent components update
+* but the tool call data hasn't changed.
+*/
+const ToolCallRenderer = React.memo(function ToolCallRenderer({ toolCall, toolMessage, RenderComponent, isExecuting }) {
+	const args = useMemo(() => partialJSONParse(toolCall.function.arguments), [toolCall.function.arguments]);
+	const toolName = toolCall.function.name;
+	if (toolMessage) return /* @__PURE__ */ jsx(RenderComponent, {
+		name: toolName,
+		toolCallId: toolCall.id,
+		args,
+		status: ToolCallStatus.Complete,
+		result: contentToText(toolMessage.content)
+	});
+	else if (isExecuting) return /* @__PURE__ */ jsx(RenderComponent, {
+		name: toolName,
+		toolCallId: toolCall.id,
+		args,
+		status: ToolCallStatus.Executing,
+		result: void 0
+	});
+	else return /* @__PURE__ */ jsx(RenderComponent, {
+		name: toolName,
+		toolCallId: toolCall.id,
+		args,
+		status: ToolCallStatus.InProgress,
+		result: void 0
+	});
+}, (prevProps, nextProps) => {
+	if (prevProps.toolCall.id !== nextProps.toolCall.id) return false;
+	if (prevProps.toolCall.function.name !== nextProps.toolCall.function.name) return false;
+	if (prevProps.toolCall.function.arguments !== nextProps.toolCall.function.arguments) return false;
+	if (prevProps.toolMessage?.content !== nextProps.toolMessage?.content) return false;
+	if (prevProps.isExecuting !== nextProps.isExecuting) return false;
+	if (prevProps.RenderComponent !== nextProps.RenderComponent) return false;
+	return true;
+});
+const IS_DEVELOPMENT = process.env.NODE_ENV !== "production";
+/**
+* Reports tool calls that resolved to no renderer.
+*
+* A tool call with no renderer paints an empty message container and says
+* nothing else, so the only signal a developer gets today is a blank space in
+* the chat. This names the call and the renderers that *are* registered, which
+* is the whole diagnosis when the cause is a name that does not match.
+*
+* @param toolNames - The unmatched tool names collected during render.
+* @param registered - The registry as it stands now, re-read at report time.
+* @param alreadyWarned - Names already reported, mutated to keep this once per name.
+*/
+function warnAboutUnrenderedToolCalls(toolNames, registered, alreadyWarned) {
+	const registeredNames = Array.from(new Set(registered.map((rc) => rc.name)));
+	const hasWildcard = registeredNames.includes("*");
+	for (const toolName of toolNames) {
+		if (hasWildcard || registeredNames.includes(toolName)) continue;
+		if (alreadyWarned.has(toolName)) continue;
+		alreadyWarned.add(toolName);
+		console.warn(`[CopilotKit] The agent called the tool "${toolName}", and no renderer is registered for it, so that message rendered nothing. ` + (registeredNames.length === 0 ? "No tool-call renderers are registered. " : `Registered renderers: ${registeredNames.map((name) => `"${name}"`).join(", ")}. `) + `Register one with useRenderTool({ name: "${toolName}", ... }), or call useDefaultRenderTool() for a built-in card that covers every tool the agent calls. This warning is development-only.`);
+	}
+}
+/**
+* The tool-call renderers registered on the provider, kept current.
+* @internal
+*/
+function useToolCallRenderers() {
+	const { copilotkit } = useCopilotKit$1();
+	return useSyncExternalStore((callback) => copilotkit.subscribe({ onRenderToolCallsChanged: callback }).unsubscribe, () => copilotkit.renderToolCalls, () => copilotkit.renderToolCalls);
+}
+/**
+* Hook that returns a function to render tool calls based on the render functions
+* defined in CopilotKitProvider.
+*
+* @returns A function that takes a tool call and optional tool message and returns the rendered component
+*/
+function useRenderToolCall() {
+	const { copilotkit, executingToolCallIds } = useCopilotKit$1();
+	const agentId = useCopilotChatConfiguration()?.agentId ?? DEFAULT_AGENT_ID;
+	const unrenderedToolNames = useRef(/* @__PURE__ */ new Set());
+	const warnedToolNames = useRef(/* @__PURE__ */ new Set());
+	const renderToolCalls = useToolCallRenderers();
+	const renderToolCall = useCallback(({ toolCall, toolMessage }) => {
+		const exactMatches = renderToolCalls.filter((rc) => rc.name === toolCall.function.name);
+		const renderConfig = exactMatches.find((rc) => rc.agentId === agentId) || exactMatches.find((rc) => !rc.agentId) || exactMatches[0] || renderToolCalls.find((rc) => rc.name === "*");
+		if (!renderConfig) {
+			if (IS_DEVELOPMENT) unrenderedToolNames.current.add(toolCall.function.name);
+			return null;
+		}
+		const RenderComponent = renderConfig.render;
+		return /* @__PURE__ */ jsx(ToolCallRenderer, {
+			toolCall,
+			toolMessage,
+			RenderComponent,
+			isExecuting: executingToolCallIds.has(toolCall.id)
+		}, toolCall.id);
+	}, [
+		renderToolCalls,
+		executingToolCallIds,
+		agentId
+	]);
+	useEffect(() => {
+		if (!IS_DEVELOPMENT) return;
+		if (unrenderedToolNames.current.size === 0) return;
+		const timer = setTimeout(() => {
+			const pending = Array.from(unrenderedToolNames.current);
+			unrenderedToolNames.current.clear();
+			warnAboutUnrenderedToolCalls(pending, copilotkit.renderToolCalls, warnedToolNames.current);
+		}, 0);
+		return () => clearTimeout(timer);
+	});
+	return renderToolCall;
+}
+
+//#endregion
+//#region src/hooks/use-capabilities.tsx
+/**
+* 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, 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.
+*/
+function useCapabilities(agentId) {
+	const { agent } = useAgent({ agentId });
+	if (agent && "capabilities" in agent) return agent.capabilities;
+}
+
+//#endregion
+export { CopilotChatConfigurationProvider, CopilotChatDefaultLabels, CopilotKitCoreReact, UseAgentUpdate, defineToolCallRenderer, useAgent, useAgentContext, useCapabilities, useComponent, useConfigureSuggestions, useCopilotChatConfiguration, useCopilotKit, useFrontendTool, useFrontendTools, useHumanInTheLoop, useInterrupt, useRenderTool, useRenderToolCall, useSuggestions, useThreads };
+//# sourceMappingURL=headless.mjs.map