@copilotkit/react-core 1.51.5-next.0 → 1.51.5-next.1

package/dist/index.mjs

@@ -1,151 +1,3947 @@
 "use client";
-import "./chunk-FD6FGKYY.mjs";
-import "./chunk-36KQV2NA.mjs";
-import "./chunk-6YOKPWQ7.mjs";
-import "./chunk-LUGEI4YQ.mjs";
-import {
-  CopilotTask
-} from "./chunk-DAQORGBP.mjs";
-import "./chunk-TPN7WC53.mjs";
-import "./chunk-JD7BAH7U.mjs";
-import "./chunk-SPCZTZCY.mjs";
-import {
-  CopilotKit,
-  defaultCopilotContextCategories
-} from "./chunk-2JZZD4RP.mjs";
-import "./chunk-NINJMAND.mjs";
-import "./chunk-CYDWEPFL.mjs";
-import {
-  SUGGESTION_RETRY_CONFIG
-} from "./chunk-2IDV5OHF.mjs";
-import "./chunk-SFOKX4MH.mjs";
-import {
-  shouldShowDevConsole
-} from "./chunk-ICIK2BSB.mjs";
-import "./chunk-R7BV32X4.mjs";
-import "./chunk-WV2EA7SX.mjs";
-import "./chunk-K5OXUXCG.mjs";
-import "./chunk-L7GPCF2V.mjs";
-import "./chunk-A6NKSGH3.mjs";
-import {
-  useLangGraphInterrupt
-} from "./chunk-IGYMBU43.mjs";
-import {
-  useMakeCopilotDocumentReadable
-} from "./chunk-GY3FQICF.mjs";
-import {
-  useCopilotReadable
-} from "./chunk-Z6JV2LRY.mjs";
-import {
-  useCopilotRuntimeClient
-} from "./chunk-2RSAYTXH.mjs";
-import {
-  useDefaultTool
-} from "./chunk-7U3DNFBF.mjs";
-import {
-  useCoAgent
-} from "./chunk-CZT7JUIM.mjs";
-import {
-  useCopilotAdditionalInstructions
-} from "./chunk-3LZZ4RVM.mjs";
-import {
-  useCopilotAuthenticatedAction_c
-} from "./chunk-TFZXOEY4.mjs";
-import {
-  useCopilotAction
-} from "./chunk-VZ4NSOFQ.mjs";
-import {
-  useRenderToolCall
-} from "./chunk-MBJ7OLYI.mjs";
-import {
-  useFrontendTool
-} from "./chunk-UA23VX5J.mjs";
-import {
-  useHumanInTheLoop
-} from "./chunk-LNGBARXE.mjs";
-import {
-  useCopilotChatHeadless_c
-} from "./chunk-P6ZPE4XJ.mjs";
-import {
-  useCopilotChatSuggestions
-} from "./chunk-SYGQHN3H.mjs";
-import {
-  useCopilotChat
-} from "./chunk-4ZQYMC5F.mjs";
-import {
-  useCopilotChatInternal
-} from "./chunk-AAGMWZCN.mjs";
-import {
-  useLazyToolRenderer
-} from "./chunk-ZVF5Q6IH.mjs";
-import {
-  useLangGraphInterruptRender
-} from "./chunk-V42VL2JR.mjs";
-import "./chunk-6AWG5FWL.mjs";
-import "./chunk-O7ARI5CV.mjs";
-import "./chunk-I76HKHPJ.mjs";
-import "./chunk-G7SUZGGB.mjs";
-import "./chunk-QXZTCGF4.mjs";
-import "./chunk-7GIBHX6X.mjs";
-import {
-  useCoAgentStateRender
-} from "./chunk-S65UEHGI.mjs";
-import "./chunk-NB2FKV2V.mjs";
-import {
-  CoAgentStateRendersContext,
-  CoAgentStateRendersProvider,
-  useCoAgentStateRenders
-} from "./chunk-IHMMKEFG.mjs";
-import {
-  CopilotContext,
-  useCopilotContext
-} from "./chunk-C7HSVDHD.mjs";
-import {
-  CopilotMessagesContext,
-  useCopilotMessagesContext
-} from "./chunk-DMLQZG75.mjs";
-import {
-  ThreadsContext,
-  ThreadsProvider,
-  useThreads
-} from "./chunk-SK2XMJUD.mjs";
-import "./chunk-WRALJIW5.mjs";
-import "./chunk-ZP2IMXFY.mjs";
-import "./chunk-SKC7AJIV.mjs";
-export {
-  CoAgentStateRendersContext,
-  CoAgentStateRendersProvider,
-  CopilotContext,
-  CopilotKit,
-  CopilotMessagesContext,
-  CopilotTask,
-  SUGGESTION_RETRY_CONFIG,
-  ThreadsContext,
-  ThreadsProvider,
-  defaultCopilotContextCategories,
-  shouldShowDevConsole,
-  useCoAgent,
-  useCoAgentStateRender,
-  useCoAgentStateRenders,
-  useCopilotAction,
-  useCopilotAdditionalInstructions,
-  useCopilotAuthenticatedAction_c,
-  useCopilotChat,
-  useCopilotChatHeadless_c,
-  useCopilotChatInternal,
-  useCopilotChatSuggestions,
-  useCopilotContext,
-  useCopilotMessagesContext,
-  useCopilotReadable,
-  useCopilotRuntimeClient,
-  useDefaultTool,
-  useFrontendTool,
-  useHumanInTheLoop,
-  useLangGraphInterrupt,
-  useLangGraphInterruptRender,
-  useLazyToolRenderer,
-  useMakeCopilotDocumentReadable,
-  useRenderToolCall,
-  useThreads
+
+import React, { Fragment, createContext, createElement, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState } from "react";
+import { CopilotChatConfigurationProvider, CopilotKitProvider, defineToolCallRenderer, useAgent, useConfigureSuggestions, useCopilotChatConfiguration, useCopilotKit, useFrontendTool as useFrontendTool$1, useHumanInTheLoop as useHumanInTheLoop$1, useRenderCustomMessages, useRenderToolCall as useRenderToolCall$1, useSuggestions } from "@copilotkitnext/react";
+import { COPILOT_CLOUD_API_URL, COPILOT_CLOUD_CHAT_URL, COPILOT_CLOUD_PUBLIC_API_KEY_HEADER, ConfigurationError, CopilotKitAgentDiscoveryError, CopilotKitApiDiscoveryError, CopilotKitError, CopilotKitErrorCode, CopilotKitLowLevelError, CopilotKitRemoteEndpointDiscoveryError, ErrorVisibility, MissingPublicApiKeyError, Severity, actionParametersToJsonSchema, dataToUUID, getZodParameters, parseJson, randomId, randomUUID, styledConsole } from "@copilotkit/shared";
+import { flushSync } from "react-dom";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import ReactMarkdown from "react-markdown";
+import { ActionInputAvailability, CopilotRequestType, CopilotRuntimeClient, Message as Message$1, MetaEventName, Role, TextMessage, convertGqlOutputToMessages, convertMessagesToGqlInput, filterAgentStateMessages, gqlToAGUI } from "@copilotkit/runtime-client-gql";
+import { AGUIConnectNotImplementedError } from "@ag-ui/client";
+import { ToolCallStatus } from "@copilotkitnext/core";
+
+//#region src/context/copilot-context.tsx
+const emptyCopilotContext$1 = {
+	actions: {},
+	setAction: () => {},
+	removeAction: () => {},
+	setRegisteredActions: () => "",
+	removeRegisteredAction: () => {},
+	chatComponentsCache: { current: {
+		actions: {},
+		coAgentStateRenders: {}
+	} },
+	getContextString: (documents, categories) => returnAndThrowInDebug(""),
+	addContext: () => "",
+	removeContext: () => {},
+	getAllContext: () => [],
+	getFunctionCallHandler: () => returnAndThrowInDebug(async () => {}),
+	isLoading: false,
+	setIsLoading: () => returnAndThrowInDebug(false),
+	chatInstructions: "",
+	setChatInstructions: () => returnAndThrowInDebug(""),
+	additionalInstructions: [],
+	setAdditionalInstructions: () => returnAndThrowInDebug([]),
+	getDocumentsContext: (categories) => returnAndThrowInDebug([]),
+	addDocumentContext: () => returnAndThrowInDebug(""),
+	removeDocumentContext: () => {},
+	copilotApiConfig: new class {
+		get chatApiEndpoint() {
+			throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
+		}
+		get headers() {
+			return {};
+		}
+		get body() {
+			return {};
+		}
+	}(),
+	chatSuggestionConfiguration: {},
+	addChatSuggestionConfiguration: () => {},
+	removeChatSuggestionConfiguration: () => {},
+	showDevConsole: false,
+	coagentStates: {},
+	setCoagentStates: () => {},
+	coagentStatesRef: { current: {} },
+	setCoagentStatesWithRef: () => {},
+	agentSession: null,
+	setAgentSession: () => {},
+	forwardedParameters: {},
+	agentLock: null,
+	threadId: "",
+	setThreadId: () => {},
+	runId: null,
+	setRunId: () => {},
+	chatAbortControllerRef: { current: null },
+	availableAgents: [],
+	extensions: {},
+	setExtensions: () => {},
+	interruptActions: {},
+	setInterruptAction: () => {},
+	removeInterruptAction: () => {},
+	interruptEventQueue: {},
+	addInterruptEvent: () => {},
+	resolveInterruptEvent: () => {},
+	onError: () => {},
+	bannerError: null,
+	setBannerError: () => {},
+	internalErrorHandlers: {},
+	setInternalErrorHandler: () => {},
+	removeInternalErrorHandler: () => {}
 };
+const CopilotContext = React.createContext(emptyCopilotContext$1);
+function useCopilotContext() {
+	const context = React.useContext(CopilotContext);
+	if (context === emptyCopilotContext$1) throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
+	return context;
+}
+function returnAndThrowInDebug(_value) {
+	throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
+}
+
+//#endregion
+//#region src/hooks/use-tree.ts
+const removeNode = (nodes, id) => {
+	return nodes.reduce((result, node) => {
+		if (node.id !== id) {
+			const newNode = {
+				...node,
+				children: removeNode(node.children, id)
+			};
+			result.push(newNode);
+		}
+		return result;
+	}, []);
+};
+const addNode = (nodes, newNode, parentId) => {
+	if (!parentId) return [...nodes, newNode];
+	return nodes.map((node) => {
+		if (node.id === parentId) return {
+			...node,
+			children: [...node.children, newNode]
+		};
+		else if (node.children.length) return {
+			...node,
+			children: addNode(node.children, newNode, parentId)
+		};
+		return node;
+	});
+};
+const treeIndentationRepresentation = (index, indentLevel) => {
+	if (indentLevel === 0) return (index + 1).toString();
+	else if (indentLevel === 1) return String.fromCharCode(65 + index);
+	else if (indentLevel === 2) return String.fromCharCode(97 + index);
+	else return "-";
+};
+const printNode = (node, prefix = "", indentLevel = 0) => {
+	const indent = " ".repeat(3).repeat(indentLevel);
+	const prefixPlusIndentLength = prefix.length + indent.length;
+	const subsequentLinesPrefix = " ".repeat(prefixPlusIndentLength);
+	const valueLines = node.value.split("\n");
+	const outputFirstLine = `${indent}${prefix}${valueLines[0]}`;
+	const outputSubsequentLines = valueLines.slice(1).map((line) => `${subsequentLinesPrefix}${line}`).join("\n");
+	let output = `${outputFirstLine}\n`;
+	if (outputSubsequentLines) output += `${outputSubsequentLines}\n`;
+	const childPrePrefix = " ".repeat(prefix.length);
+	node.children.forEach((child, index) => output += printNode(child, `${childPrePrefix}${treeIndentationRepresentation(index, indentLevel + 1)}. `, indentLevel + 1));
+	return output;
+};
+function treeReducer(state, action) {
+	switch (action.type) {
+		case "ADD_NODE": {
+			const { value, parentId, id: newNodeId } = action;
+			const newNode = {
+				id: newNodeId,
+				value,
+				children: [],
+				categories: new Set(action.categories)
+			};
+			try {
+				return addNode(state, newNode, parentId);
+			} catch (error) {
+				console.error(`Error while adding node with id ${newNodeId}: ${error}`);
+				return state;
+			}
+		}
+		case "REMOVE_NODE": return removeNode(state, action.id);
+		default: return state;
+	}
+}
+const useTree = () => {
+	const [tree, dispatch] = useReducer(treeReducer, []);
+	const addElement = useCallback((value, categories, parentId) => {
+		const newNodeId = randomId();
+		dispatch({
+			type: "ADD_NODE",
+			value,
+			parentId,
+			id: newNodeId,
+			categories
+		});
+		return newNodeId;
+	}, []);
+	const removeElement = useCallback((id) => {
+		dispatch({
+			type: "REMOVE_NODE",
+			id
+		});
+	}, []);
+	const getAllElements = useCallback(() => {
+		return tree;
+	}, [tree]);
+	return {
+		tree,
+		addElement,
+		printTree: useCallback((categories) => {
+			const categoriesSet = new Set(categories);
+			let output = "";
+			tree.forEach((node, index) => {
+				if (!setsHaveIntersection$1(categoriesSet, node.categories)) return;
+				if (index !== 0) output += "\n";
+				output += printNode(node, `${treeIndentationRepresentation(index, 0)}. `);
+			});
+			return output;
+		}, [tree]),
+		removeElement,
+		getAllElements
+	};
+};
+function setsHaveIntersection$1(setA, setB) {
+	const [smallerSet, largerSet] = setA.size <= setB.size ? [setA, setB] : [setB, setA];
+	for (let item of smallerSet) if (largerSet.has(item)) return true;
+	return false;
+}
+
+//#endregion
+//#region src/hooks/use-flat-category-store.ts
+const useFlatCategoryStore = () => {
+	const [elements, dispatch] = useReducer(flatCategoryStoreReducer, /* @__PURE__ */ new Map());
+	return {
+		addElement: useCallback((value, categories) => {
+			const newId = randomId();
+			dispatch({
+				type: "ADD_ELEMENT",
+				value,
+				id: newId,
+				categories
+			});
+			return newId;
+		}, []),
+		removeElement: useCallback((id) => {
+			dispatch({
+				type: "REMOVE_ELEMENT",
+				id
+			});
+		}, []),
+		allElements: useCallback((categories) => {
+			const categoriesSet = new Set(categories);
+			const result = [];
+			elements.forEach((element) => {
+				if (setsHaveIntersection(categoriesSet, element.categories)) result.push(element.value);
+			});
+			return result;
+		}, [elements])
+	};
+};
+function flatCategoryStoreReducer(state, action) {
+	switch (action.type) {
+		case "ADD_ELEMENT": {
+			const { value, id, categories } = action;
+			const newElement = {
+				id,
+				value,
+				categories: new Set(categories)
+			};
+			const newState = new Map(state);
+			newState.set(id, newElement);
+			return newState;
+		}
+		case "REMOVE_ELEMENT": {
+			const newState = new Map(state);
+			newState.delete(action.id);
+			return newState;
+		}
+		default: return state;
+	}
+}
+function setsHaveIntersection(setA, setB) {
+	const [smallerSet, largerSet] = setA.size <= setB.size ? [setA, setB] : [setB, setA];
+	for (let item of smallerSet) if (largerSet.has(item)) return true;
+	return false;
+}
+
+//#endregion
+//#region src/context/copilot-messages-context.tsx
+const emptyCopilotContext = {
+	messages: [],
+	setMessages: () => [],
+	suggestions: [],
+	setSuggestions: () => []
+};
+const CopilotMessagesContext = React.createContext(emptyCopilotContext);
+function useCopilotMessagesContext() {
+	const context = React.useContext(CopilotMessagesContext);
+	if (context === emptyCopilotContext) throw new Error("A messages consuming component was not wrapped with `<CopilotMessages> {...} </CopilotMessages>`");
+	return context;
+}
+
+//#endregion
+//#region src/components/toast/toast-provider.tsx
+const ToastContext = createContext(void 0);
+function getErrorSeverity(error) {
+	if (error.severity) switch (error.severity) {
+		case Severity.CRITICAL: return "critical";
+		case Severity.WARNING: return "warning";
+		case Severity.INFO: return "info";
+		default: return "info";
+	}
+	const message = error.message.toLowerCase();
+	if (message.includes("api key") || message.includes("401") || message.includes("unauthorized") || message.includes("authentication") || message.includes("incorrect api key")) return "critical";
+	return "info";
+}
+function getErrorColors(severity) {
+	switch (severity) {
+		case "critical": return {
+			background: "#fee2e2",
+			border: "#dc2626",
+			text: "#7f1d1d",
+			icon: "#dc2626"
+		};
+		case "warning": return {
+			background: "#fef3c7",
+			border: "#d97706",
+			text: "#78350f",
+			icon: "#d97706"
+		};
+		case "info": return {
+			background: "#dbeafe",
+			border: "#2563eb",
+			text: "#1e3a8a",
+			icon: "#2563eb"
+		};
+	}
+}
+function useToast() {
+	const context = useContext(ToastContext);
+	if (!context) throw new Error("useToast must be used within a ToastProvider");
+	return context;
+}
+function ToastProvider({ enabled, children }) {
+	const [toasts, setToasts] = useState([]);
+	const [bannerError, setBannerErrorState] = useState(null);
+	const removeToast = useCallback((id) => {
+		setToasts((prev) => prev.filter((toast) => toast.id !== id));
+	}, []);
+	const addToast = useCallback((toast) => {
+		if (!enabled) return;
+		const id = toast.id ?? Math.random().toString(36).substring(2, 9);
+		setToasts((currentToasts) => {
+			if (currentToasts.find((toast) => toast.id === id)) return currentToasts;
+			return [...currentToasts, {
+				...toast,
+				id
+			}];
+		});
+		if (toast.duration) setTimeout(() => {
+			removeToast(id);
+		}, toast.duration);
+	}, [enabled, removeToast]);
+	const setBannerError = useCallback((error) => {
+		if (!enabled && error !== null) return;
+		setBannerErrorState(error);
+	}, [enabled]);
+	const value = {
+		toasts,
+		addToast,
+		addGraphQLErrorsToast: useCallback((errors) => {
+			console.warn("addGraphQLErrorsToast is deprecated. All errors now show as banners.");
+		}, []),
+		removeToast,
+		enabled,
+		bannerError,
+		setBannerError
+	};
+	return /* @__PURE__ */ jsxs(ToastContext.Provider, {
+		value,
+		children: [bannerError && (() => {
+			const colors = getErrorColors(getErrorSeverity(bannerError));
+			return /* @__PURE__ */ jsx("div", {
+				style: {
+					position: "fixed",
+					bottom: "20px",
+					left: "50%",
+					transform: "translateX(-50%)",
+					zIndex: 9999,
+					backgroundColor: colors.background,
+					border: `1px solid ${colors.border}`,
+					borderLeft: `4px solid ${colors.border}`,
+					borderRadius: "8px",
+					padding: "12px 16px",
+					fontSize: "13px",
+					boxShadow: "0 4px 12px rgba(0, 0, 0, 0.15)",
+					backdropFilter: "blur(8px)",
+					maxWidth: "min(90vw, 700px)",
+					width: "100%",
+					boxSizing: "border-box",
+					overflow: "hidden"
+				},
+				children: /* @__PURE__ */ jsxs("div", {
+					style: {
+						display: "flex",
+						justifyContent: "space-between",
+						alignItems: "center",
+						gap: "10px"
+					},
+					children: [/* @__PURE__ */ jsxs("div", {
+						style: {
+							display: "flex",
+							alignItems: "center",
+							gap: "8px",
+							flex: 1,
+							minWidth: 0
+						},
+						children: [/* @__PURE__ */ jsx("div", { style: {
+							width: "12px",
+							height: "12px",
+							borderRadius: "50%",
+							backgroundColor: colors.border,
+							flexShrink: 0
+						} }), /* @__PURE__ */ jsxs("div", {
+							style: {
+								display: "flex",
+								alignItems: "center",
+								gap: "10px",
+								flex: 1,
+								minWidth: 0
+							},
+							children: [/* @__PURE__ */ jsx("div", {
+								style: {
+									color: colors.text,
+									lineHeight: "1.4",
+									fontWeight: "400",
+									fontSize: "13px",
+									flex: 1,
+									wordBreak: "break-all",
+									overflowWrap: "break-word",
+									maxWidth: "550px",
+									overflow: "hidden",
+									display: "-webkit-box",
+									WebkitLineClamp: 10,
+									WebkitBoxOrient: "vertical"
+								},
+								children: (() => {
+									let message = bannerError.message;
+									const jsonMatch = message.match(/'message':\s*'([^']+)'/);
+									if (jsonMatch) return jsonMatch[1];
+									message = message.split(" - ")[0];
+									message = message.split(": Error code")[0];
+									message = message.replace(/:\s*\d{3}$/, "");
+									message = message.replace(/See more:.*$/g, "");
+									message = message.trim();
+									return message || "Configuration error occurred.";
+								})()
+							}), (() => {
+								const message = bannerError.message;
+								const markdownLinkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+								const plainUrlRegex = /(https?:\/\/[^\s)]+)/g;
+								let url = null;
+								let buttonText = "See More";
+								const markdownMatch = markdownLinkRegex.exec(message);
+								if (markdownMatch) {
+									url = markdownMatch[2];
+									buttonText = "See More";
+								} else {
+									const urlMatch = plainUrlRegex.exec(message);
+									if (urlMatch) {
+										url = urlMatch[0].replace(/[.,;:'"]*$/, "");
+										buttonText = "See More";
+									}
+								}
+								if (!url) return null;
+								return /* @__PURE__ */ jsx("button", {
+									onClick: () => window.open(url, "_blank", "noopener,noreferrer"),
+									style: {
+										background: colors.border,
+										color: "white",
+										border: "none",
+										borderRadius: "5px",
+										padding: "4px 10px",
+										fontSize: "11px",
+										fontWeight: "500",
+										cursor: "pointer",
+										transition: "all 0.2s ease",
+										flexShrink: 0
+									},
+									onMouseEnter: (e) => {
+										e.currentTarget.style.opacity = "0.9";
+										e.currentTarget.style.transform = "translateY(-1px)";
+									},
+									onMouseLeave: (e) => {
+										e.currentTarget.style.opacity = "1";
+										e.currentTarget.style.transform = "translateY(0)";
+									},
+									children: buttonText
+								});
+							})()]
+						})]
+					}), /* @__PURE__ */ jsx("button", {
+						onClick: () => setBannerError(null),
+						style: {
+							background: "transparent",
+							border: "none",
+							color: colors.text,
+							cursor: "pointer",
+							padding: "2px",
+							borderRadius: "3px",
+							fontSize: "14px",
+							lineHeight: "1",
+							opacity: .6,
+							transition: "all 0.2s ease",
+							flexShrink: 0
+						},
+						title: "Dismiss",
+						onMouseEnter: (e) => {
+							e.currentTarget.style.opacity = "1";
+							e.currentTarget.style.background = "rgba(0, 0, 0, 0.05)";
+						},
+						onMouseLeave: (e) => {
+							e.currentTarget.style.opacity = "0.6";
+							e.currentTarget.style.background = "transparent";
+						},
+						children: "×"
+					})]
+				})
+			});
+		})(), children]
+	});
+}
+
+//#endregion
+//#region src/utils/dev-console.ts
+function isLocalhost() {
+	if (typeof window === "undefined") return false;
+	return window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1" || window.location.hostname === "0.0.0.0";
+}
+function shouldShowDevConsole(showDevConsole) {
+	if (showDevConsole !== void 0) return showDevConsole;
+	return isLocalhost();
+}
+
+//#endregion
+//#region src/components/copilot-provider/copilot-messages.tsx
+/**
+* An internal context to separate the messages state (which is constantly changing) from the rest of CopilotKit context
+*/
+const MessagesTapContext = createContext(null);
+function useMessagesTap() {
+	const tap = useContext(MessagesTapContext);
+	if (!tap) throw new Error("useMessagesTap must be used inside <MessagesTapProvider>");
+	return tap;
+}
+function MessagesTapProvider({ children }) {
+	const messagesRef = useRef([]);
+	const tapRef = useRef({
+		getMessagesFromTap: () => messagesRef.current,
+		updateTapMessages: (messages) => {
+			messagesRef.current = messages;
+		}
+	});
+	return /* @__PURE__ */ jsx(MessagesTapContext.Provider, {
+		value: tapRef.current,
+		children
+	});
+}
+/**
+* CopilotKit messages context.
+*/
+function CopilotMessages({ children }) {
+	const [messages, setMessages] = useState([]);
+	useRef(void 0);
+	useRef(void 0);
+	useRef(void 0);
+	const { updateTapMessages } = useMessagesTap();
+	const { threadId, agentSession, showDevConsole, onError, copilotApiConfig } = useCopilotContext();
+	const { setBannerError } = useToast();
+	const traceUIError = useCallback(async (error, originalError) => {
+		if (!onError || !copilotApiConfig.publicApiKey) return;
+		try {
+			await onError({
+				type: "error",
+				timestamp: Date.now(),
+				context: {
+					source: "ui",
+					request: {
+						operation: "loadAgentState",
+						url: copilotApiConfig.chatApiEndpoint,
+						startTime: Date.now()
+					},
+					technical: {
+						environment: "browser",
+						userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+						stackTrace: originalError instanceof Error ? originalError.stack : void 0
+					}
+				},
+				error
+			});
+		} catch (traceError) {
+			console.error("Error in CopilotMessages onError handler:", traceError);
+		}
+	}, [
+		onError,
+		copilotApiConfig.publicApiKey,
+		copilotApiConfig.chatApiEndpoint
+	]);
+	const createStructuredError = (gqlError) => {
+		const extensions = gqlError.extensions;
+		const originalError = extensions?.originalError;
+		if (originalError?.stack) {
+			if (originalError.stack.includes("CopilotApiDiscoveryError")) return new CopilotKitApiDiscoveryError({ message: originalError.message });
+			if (originalError.stack.includes("CopilotKitRemoteEndpointDiscoveryError")) return new CopilotKitRemoteEndpointDiscoveryError({ message: originalError.message });
+			if (originalError.stack.includes("CopilotKitAgentDiscoveryError")) return new CopilotKitAgentDiscoveryError({
+				agentName: "",
+				availableAgents: []
+			});
+		}
+		const message = originalError?.message || gqlError.message;
+		const code = extensions?.code;
+		if (code) return new CopilotKitError({
+			message,
+			code
+		});
+		return null;
+	};
+	useCallback((error) => {
+		if (error.graphQLErrors?.length) {
+			const graphQLErrors = error.graphQLErrors;
+			const routeError = (gqlError) => {
+				const visibility = gqlError.extensions?.visibility;
+				if (!shouldShowDevConsole(showDevConsole)) {
+					console.error("CopilotKit Error (hidden in production):", gqlError.message);
+					return;
+				}
+				if (visibility === ErrorVisibility.SILENT) {
+					console.error("CopilotKit Silent Error:", gqlError.message);
+					return;
+				}
+				const ckError = createStructuredError(gqlError);
+				if (ckError) {
+					setBannerError(ckError);
+					traceUIError(ckError, gqlError);
+				} else {
+					const fallbackError = new CopilotKitError({
+						message: gqlError.message,
+						code: CopilotKitErrorCode.UNKNOWN
+					});
+					setBannerError(fallbackError);
+					traceUIError(fallbackError, gqlError);
+				}
+			};
+			graphQLErrors.forEach(routeError);
+		} else if (!shouldShowDevConsole(showDevConsole)) console.error("CopilotKit Error (hidden in production):", error);
+		else {
+			const fallbackError = new CopilotKitError({
+				message: error?.message || String(error),
+				code: CopilotKitErrorCode.UNKNOWN
+			});
+			setBannerError(fallbackError);
+			traceUIError(fallbackError, error);
+		}
+	}, [
+		setBannerError,
+		showDevConsole,
+		traceUIError
+	]);
+	useEffect(() => {
+		updateTapMessages(messages);
+	}, [messages, updateTapMessages]);
+	const memoizedChildren = useMemo(() => children, [children]);
+	const [suggestions, setSuggestions] = useState([]);
+	return /* @__PURE__ */ jsx(CopilotMessagesContext.Provider, {
+		value: {
+			messages,
+			setMessages,
+			suggestions,
+			setSuggestions
+		},
+		children: memoizedChildren
+	});
+}
+
+//#endregion
+//#region src/components/usage-banner.tsx
+function UsageBanner({ severity = Severity.CRITICAL, message = "", onClose, actions }) {
+	if (!message || !severity) return null;
+	const theme = {
+		[Severity.INFO]: {
+			bg: "#f8fafc",
+			border: "#e2e8f0",
+			text: "#475569",
+			accent: "#3b82f6"
+		},
+		[Severity.WARNING]: {
+			bg: "#fffbeb",
+			border: "#fbbf24",
+			text: "#92400e",
+			accent: "#f59e0b"
+		},
+		[Severity.CRITICAL]: {
+			bg: "#fef2f2",
+			border: "#fecaca",
+			text: "#dc2626",
+			accent: "#ef4444"
+		}
+	}[severity];
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("style", { children: `
+          @keyframes slideUp {
+            from { opacity: 0; transform: translateX(-50%) translateY(8px); }
+            to { opacity: 1; transform: translateX(-50%) translateY(0); }
+          }
+          
+          .usage-banner {
+            position: fixed;
+            bottom: 24px;
+            left: 50%;
+            transform: translateX(-50%);
+            width: min(600px, calc(100vw - 32px));
+            z-index: 10000;
+            animation: slideUp 0.2s cubic-bezier(0.16, 1, 0.3, 1);
+          }
+          
+          .banner-content {
+            background: linear-gradient(135deg, ${theme.bg} 0%, ${theme.bg}f5 100%);
+            border: 1px solid ${theme.border};
+            border-radius: 12px;
+            padding: 18px 20px;
+            box-shadow: 
+              0 4px 24px rgba(0, 0, 0, 0.08),
+              0 2px 8px rgba(0, 0, 0, 0.04),
+              inset 0 1px 0 rgba(255, 255, 255, 0.7);
+            display: flex;
+            align-items: center;
+            gap: 16px;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+            backdrop-filter: blur(12px);
+            position: relative;
+            overflow: hidden;
+          }
+          
+          .banner-content::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            height: 1px;
+            background: linear-gradient(90deg, transparent, ${theme.accent}40, transparent);
+          }
+          
+          .banner-message {
+            color: ${theme.text};
+            font-size: 14px;
+            line-height: 1.5;
+            font-weight: 500;
+            flex: 1;
+            letter-spacing: -0.01em;
+          }
+          
+          .close-btn {
+            background: rgba(0, 0, 0, 0.05);
+            border: none;
+            color: ${theme.text};
+            cursor: pointer;
+            padding: 0;
+            border-radius: 6px;
+            opacity: 0.6;
+            transition: all 0.15s cubic-bezier(0.16, 1, 0.3, 1);
+            font-size: 14px;
+            line-height: 1;
+            flex-shrink: 0;
+            width: 24px;
+            height: 24px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+          }
+          
+          .close-btn:hover {
+            opacity: 1;
+            background: rgba(0, 0, 0, 0.08);
+            transform: scale(1.05);
+          }
+          
+          .btn-primary {
+            background: linear-gradient(135deg, ${theme.accent} 0%, ${theme.accent}e6 100%);
+            color: white;
+            border: none;
+            border-radius: 8px;
+            padding: 10px 18px;
+            font-size: 13px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.15s cubic-bezier(0.16, 1, 0.3, 1);
+            font-family: inherit;
+            flex-shrink: 0;
+            box-shadow: 
+              0 2px 8px ${theme.accent}30,
+              inset 0 1px 0 rgba(255, 255, 255, 0.2);
+            letter-spacing: -0.01em;
+          }
+          
+          .btn-primary:hover {
+            transform: translateY(-1px) scale(1.02);
+            box-shadow: 
+              0 4px 12px ${theme.accent}40,
+              inset 0 1px 0 rgba(255, 255, 255, 0.25);
+          }
+          
+          .btn-primary:active {
+            transform: translateY(0) scale(0.98);
+            transition: all 0.08s cubic-bezier(0.16, 1, 0.3, 1);
+          }
+          
+          @media (max-width: 640px) {
+            .usage-banner {
+              width: calc(100vw - 24px);
+            }
+            
+            .banner-content {
+              padding: 16px;
+              gap: 12px;
+            }
+            
+            .banner-message {
+              font-size: 13px;
+              line-height: 1.45;
+            }
+            
+            .btn-primary {
+              padding: 8px 14px;
+              font-size: 12px;
+            }
+            
+            .close-btn {
+              width: 22px;
+              height: 22px;
+              font-size: 12px;
+            }
+          }
+        ` }), /* @__PURE__ */ jsx("div", {
+		className: "usage-banner",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "banner-content",
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: "banner-message",
+					children: message
+				}),
+				actions?.primary && /* @__PURE__ */ jsx("button", {
+					className: "btn-primary",
+					onClick: actions.primary.onClick,
+					children: actions.primary.label
+				}),
+				onClose && /* @__PURE__ */ jsx("button", {
+					className: "close-btn",
+					onClick: onClose,
+					title: "Close",
+					children: "×"
+				})
+			]
+		})
+	})] });
+}
+const getErrorActions = (error) => {
+	switch (error.code) {
+		case CopilotKitErrorCode.MISSING_PUBLIC_API_KEY_ERROR: return { primary: {
+			label: "Show me how",
+			onClick: () => window.open("https://docs.copilotkit.ai/premium#how-do-i-get-access-to-premium-features", "_blank", "noopener,noreferrer")
+		} };
+		case CopilotKitErrorCode.UPGRADE_REQUIRED_ERROR: return { primary: {
+			label: "Upgrade",
+			onClick: () => window.open("https://cloud.copilotkit.ai", "_blank", "noopener,noreferrer")
+		} };
+		default: return;
+	}
+};
+
+//#endregion
+//#region src/utils/suggestions-constants.ts
+/**
+* Constants for suggestions retry logic
+*/
+const SUGGESTION_RETRY_CONFIG = {
+	MAX_RETRIES: 3,
+	COOLDOWN_MS: 5e3
+};
+
+//#endregion
+//#region src/lib/status-checker.ts
+const STATUS_CHECK_INTERVAL = 1e3 * 60 * 5;
+var StatusChecker = class {
+	constructor() {
+		this.activeKey = null;
+		this.intervalId = null;
+		this.instanceCount = 0;
+		this.lastResponse = null;
+	}
+	async start(publicApiKey, onUpdate) {
+		this.instanceCount++;
+		if (this.activeKey === publicApiKey) return;
+		if (this.intervalId) clearInterval(this.intervalId);
+		const checkStatus = async () => {
+			try {
+				const response = await fetch(`${COPILOT_CLOUD_API_URL}/ciu`, {
+					method: "GET",
+					headers: { [COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey }
+				}).then((response) => response.json());
+				this.lastResponse = response;
+				onUpdate?.(response);
+				return response;
+			} catch (error) {
+				return null;
+			}
+		};
+		const initialResponse = await checkStatus();
+		this.intervalId = setInterval(checkStatus, STATUS_CHECK_INTERVAL);
+		this.activeKey = publicApiKey;
+		return initialResponse;
+	}
+	getLastResponse() {
+		return this.lastResponse;
+	}
+	stop() {
+		this.instanceCount--;
+		if (this.instanceCount === 0) {
+			if (this.intervalId) {
+				clearInterval(this.intervalId);
+				this.intervalId = null;
+				this.activeKey = null;
+				this.lastResponse = null;
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/components/toast/exclamation-mark-icon.tsx
+const ExclamationMarkIcon = ({ className, style }) => /* @__PURE__ */ jsxs("svg", {
+	xmlns: "http://www.w3.org/2000/svg",
+	width: "24",
+	height: "24",
+	viewBox: "0 0 24 24",
+	fill: "none",
+	stroke: "currentColor",
+	strokeWidth: "2",
+	strokeLinecap: "round",
+	strokeLinejoin: "round",
+	className: `lucide lucide-circle-alert ${className ? className : ""}`,
+	style,
+	children: [
+		/* @__PURE__ */ jsx("circle", {
+			cx: "12",
+			cy: "12",
+			r: "10"
+		}),
+		/* @__PURE__ */ jsx("line", {
+			x1: "12",
+			x2: "12",
+			y1: "8",
+			y2: "12"
+		}),
+		/* @__PURE__ */ jsx("line", {
+			x1: "12",
+			x2: "12.01",
+			y1: "16",
+			y2: "16"
+		})
+	]
+});
+
+//#endregion
+//#region src/components/error-boundary/error-utils.tsx
+function ErrorToast({ errors }) {
+	return /* @__PURE__ */ jsxs("div", {
+		style: {
+			fontSize: "13px",
+			maxWidth: "600px"
+		},
+		children: [errors.map((error, idx) => {
+			const message = ("extensions" in error ? error.extensions?.originalError : {})?.message ?? error.message;
+			const code = "extensions" in error ? error.extensions?.code : null;
+			return /* @__PURE__ */ jsxs("div", {
+				style: {
+					marginTop: idx === 0 ? 0 : 10,
+					marginBottom: 14
+				},
+				children: [
+					/* @__PURE__ */ jsx(ExclamationMarkIcon, { style: { marginBottom: 4 } }),
+					code && /* @__PURE__ */ jsxs("div", {
+						style: {
+							fontWeight: "600",
+							marginBottom: 4
+						},
+						children: [
+							"Copilot Runtime Error:",
+							" ",
+							/* @__PURE__ */ jsx("span", {
+								style: {
+									fontFamily: "monospace",
+									fontWeight: "normal"
+								},
+								children: code
+							})
+						]
+					}),
+					/* @__PURE__ */ jsx(ReactMarkdown, { children: message })
+				]
+			}, idx);
+		}), /* @__PURE__ */ jsx("div", {
+			style: {
+				fontSize: "11px",
+				opacity: .75
+			},
+			children: "NOTE: This error only displays during local development."
+		})]
+	});
+}
+function useErrorToast() {
+	const { addToast } = useToast();
+	return useCallback((errors) => {
+		addToast({
+			type: "error",
+			id: errors.map((err) => {
+				const message = "extensions" in err ? (err.extensions?.originalError)?.message || err.message : err.message;
+				const stack = err.stack || "";
+				return btoa(message + stack).slice(0, 32);
+			}).join("|"),
+			message: /* @__PURE__ */ jsx(ErrorToast, { errors })
+		});
+	}, [addToast]);
+}
+function useAsyncCallback(callback, deps) {
+	const addErrorToast = useErrorToast();
+	return useCallback(async (...args) => {
+		try {
+			return await callback(...args);
+		} catch (error) {
+			console.error("Error in async callback:", error);
+			addErrorToast([error]);
+			throw error;
+		}
+	}, deps);
+}
+
+//#endregion
+//#region src/components/error-boundary/error-boundary.tsx
+const statusChecker = new StatusChecker();
+var CopilotErrorBoundary = class extends React.Component {
+	constructor(props) {
+		super(props);
+		this.state = { hasError: false };
+	}
+	static getDerivedStateFromError(error) {
+		return {
+			hasError: true,
+			error
+		};
+	}
+	componentDidMount() {
+		if (this.props.publicApiKey) statusChecker.start(this.props.publicApiKey, (newStatus) => {
+			this.setState((prevState) => {
+				if (newStatus?.severity !== prevState.status?.severity) return { status: newStatus ?? void 0 };
+				return null;
+			});
+		});
+	}
+	componentWillUnmount() {
+		statusChecker.stop();
+	}
+	componentDidCatch(error, errorInfo) {
+		console.error("CopilotKit Error:", error, errorInfo);
+	}
+	render() {
+		if (this.state.hasError) {
+			if (this.state.error instanceof CopilotKitError) return /* @__PURE__ */ jsxs(Fragment$1, { children: [this.props.children, this.props.showUsageBanner && /* @__PURE__ */ jsx(UsageBanner, {
+				severity: this.state.status?.severity ?? this.state.error.severity,
+				message: this.state.status?.message ?? this.state.error.message,
+				actions: getErrorActions(this.state.error)
+			})] });
+			throw this.state.error;
+		}
+		return this.props.children;
+	}
+};
+
+//#endregion
+//#region src/context/coagent-state-renders-context.tsx
+const CoAgentStateRendersContext = createContext(void 0);
+function CoAgentStateRendersProvider({ children }) {
+	const [coAgentStateRenders, setCoAgentStateRenders] = useState({});
+	const setCoAgentStateRender = useCallback((id, stateRender) => {
+		setCoAgentStateRenders((prevPoints) => ({
+			...prevPoints,
+			[id]: stateRender
+		}));
+	}, []);
+	const removeCoAgentStateRender = useCallback((id) => {
+		setCoAgentStateRenders((prevPoints) => {
+			const newPoints = { ...prevPoints };
+			delete newPoints[id];
+			return newPoints;
+		});
+	}, []);
+	const claimsRef = useRef({});
+	return /* @__PURE__ */ jsx(CoAgentStateRendersContext.Provider, {
+		value: {
+			coAgentStateRenders,
+			setCoAgentStateRender,
+			removeCoAgentStateRender,
+			claimsRef
+		},
+		children
+	});
+}
+function useCoAgentStateRenders() {
+	const context = useContext(CoAgentStateRendersContext);
+	if (!context) throw new Error("useCoAgentStateRenders must be used within CoAgentStateRendersProvider");
+	return context;
+}
+
+//#endregion
+//#region src/context/threads-context.tsx
+const ThreadsContext = createContext(void 0);
+function ThreadsProvider({ children, threadId: explicitThreadId }) {
+	const [internalThreadId, setThreadId] = useState(() => randomUUID());
+	const threadId = explicitThreadId ?? internalThreadId;
+	return /* @__PURE__ */ jsx(ThreadsContext.Provider, {
+		value: {
+			threadId,
+			setThreadId
+		},
+		children
+	});
+}
+function useThreads() {
+	const context = useContext(ThreadsContext);
+	if (!context) throw new Error("useThreads must be used within ThreadsProvider");
+	return context;
+}
+
+//#endregion
+//#region src/hooks/use-coagent-state-render-bridge.helpers.ts
+let RenderStatus = /* @__PURE__ */ function(RenderStatus) {
+	RenderStatus["InProgress"] = "inProgress";
+	RenderStatus["Complete"] = "complete";
+	return RenderStatus;
+}({});
+let ClaimAction = /* @__PURE__ */ function(ClaimAction) {
+	ClaimAction["Create"] = "create";
+	ClaimAction["Override"] = "override";
+	ClaimAction["Existing"] = "existing";
+	ClaimAction["Block"] = "block";
+	return ClaimAction;
+}({});
+function getStateWithoutConstantKeys(state) {
+	if (!state) return {};
+	const { messages, tools, copilotkit, ...stateWithoutConstantKeys } = state;
+	return stateWithoutConstantKeys;
+}
+function areStatesEquals(a, b) {
+	if (a && !b || !a && b) return false;
+	const { messages, tools, copilotkit, ...aWithoutConstantKeys } = a;
+	const { messages: bMessages, tools: bTools, copilotkit: bCopilotkit, ...bWithoutConstantKeys } = b;
+	return JSON.stringify(aWithoutConstantKeys) === JSON.stringify(bWithoutConstantKeys);
+}
+function isPlaceholderMessageId(messageId) {
+	return !!messageId && messageId.startsWith("coagent-state-render-");
+}
+function isPlaceholderMessageName(messageName) {
+	return messageName === "coagent-state-render";
+}
+function readCachedMessageEntry(entry) {
+	if (!entry || typeof entry !== "object") return {
+		snapshot: entry,
+		runId: void 0
+	};
+	return {
+		snapshot: "snapshot" in entry ? entry.snapshot : entry,
+		runId: "runId" in entry ? entry.runId : void 0
+	};
+}
+function getEffectiveRunId({ existingClaimRunId, cachedMessageRunId, runId }) {
+	return existingClaimRunId || cachedMessageRunId || runId || "pending";
+}
+/**
+* Resolve whether a message can claim a render slot.
+* This is a pure decision function; the caller applies claim mutations.
+*/
+function resolveClaim({ claims, context, stateSnapshot }) {
+	const { messageId, stateRenderId, runId, messageIndex } = context;
+	const existing = claims[messageId];
+	if (existing) {
+		const canRender = existing.stateRenderId === stateRenderId;
+		const shouldUpdateRunId = canRender && runId && (!existing.runId || existing.runId === "pending");
+		return {
+			canRender,
+			action: canRender ? ClaimAction.Existing : ClaimAction.Block,
+			updateRunId: shouldUpdateRunId ? runId : void 0
+		};
+	}
+	const normalizedRunId = runId ?? "pending";
+	const renderClaimedByOtherMessageEntry = Object.entries(claims).find(([, claim]) => claim.stateRenderId === stateRenderId && (claim.runId ?? "pending") === normalizedRunId && dataToUUID(getStateWithoutConstantKeys(claim.stateSnapshot)) === dataToUUID(getStateWithoutConstantKeys(stateSnapshot)));
+	const renderClaimedByOtherMessage = renderClaimedByOtherMessageEntry?.[1];
+	const claimedMessageId = renderClaimedByOtherMessageEntry?.[0];
+	if (renderClaimedByOtherMessage) {
+		if (messageIndex !== void 0 && renderClaimedByOtherMessage.messageIndex !== void 0 && messageIndex > renderClaimedByOtherMessage.messageIndex) return {
+			canRender: true,
+			action: ClaimAction.Override,
+			nextClaim: {
+				stateRenderId,
+				runId,
+				messageIndex
+			},
+			lockOthers: runId === renderClaimedByOtherMessage.runId || isPlaceholderMessageId(claimedMessageId)
+		};
+		if (runId && renderClaimedByOtherMessage.runId && runId !== renderClaimedByOtherMessage.runId) return {
+			canRender: true,
+			action: ClaimAction.Override,
+			nextClaim: {
+				stateRenderId,
+				runId,
+				messageIndex
+			},
+			lockOthers: isPlaceholderMessageId(claimedMessageId)
+		};
+		if (isPlaceholderMessageId(claimedMessageId)) return {
+			canRender: true,
+			action: ClaimAction.Override,
+			nextClaim: {
+				stateRenderId,
+				runId,
+				messageIndex
+			},
+			lockOthers: true
+		};
+		if (stateSnapshot && renderClaimedByOtherMessage.stateSnapshot && !areStatesEquals(renderClaimedByOtherMessage.stateSnapshot, stateSnapshot)) return {
+			canRender: true,
+			action: ClaimAction.Override,
+			nextClaim: {
+				stateRenderId,
+				runId
+			}
+		};
+		return {
+			canRender: false,
+			action: ClaimAction.Block
+		};
+	}
+	if (!runId) return {
+		canRender: false,
+		action: ClaimAction.Block
+	};
+	return {
+		canRender: true,
+		action: ClaimAction.Create,
+		nextClaim: {
+			stateRenderId,
+			runId,
+			messageIndex
+		}
+	};
+}
+/**
+* Select the best snapshot to render for this message.
+* Priority order is:
+* 1) explicit message snapshot
+* 2) live agent state (latest assistant only)
+* 3) cached snapshot for message
+* 4) cached snapshot for stateRenderId+runId
+* 5) last cached snapshot for stateRenderId
+*/
+function selectSnapshot({ messageId, messageName, allowLiveState, skipLatestCache, stateRenderId, effectiveRunId, stateSnapshotProp, agentState, agentMessages, existingClaim, caches }) {
+	const lastAssistantId = agentMessages ? [...agentMessages].reverse().find((msg) => msg.role === "assistant")?.id : void 0;
+	const latestSnapshot = stateRenderId !== void 0 ? caches.byStateRenderAndRun[`${stateRenderId}::latest`] : void 0;
+	const messageIndex = agentMessages ? agentMessages.findIndex((msg) => msg.id === messageId) : -1;
+	const messageRole = messageIndex >= 0 && agentMessages ? agentMessages[messageIndex]?.role : void 0;
+	let previousUserMessageId;
+	if (messageIndex > 0 && agentMessages) {
+		for (let i = messageIndex - 1; i >= 0; i -= 1) if (agentMessages[i]?.role === "user") {
+			previousUserMessageId = agentMessages[i]?.id;
+			break;
+		}
+	}
+	const liveStateIsStale = stateSnapshotProp === void 0 && latestSnapshot !== void 0 && agentState !== void 0 && areStatesEquals(latestSnapshot, agentState);
+	const shouldUseLiveState = (Boolean(allowLiveState) || !lastAssistantId || messageId === lastAssistantId) && !liveStateIsStale;
+	const snapshot = stateSnapshotProp ? parseJson(stateSnapshotProp, stateSnapshotProp) : shouldUseLiveState ? agentState : void 0;
+	const hasSnapshotKeys = !!(snapshot && Object.keys(snapshot).length > 0);
+	const allowEmptySnapshot = snapshot !== void 0 && !hasSnapshotKeys && (stateSnapshotProp !== void 0 || shouldUseLiveState);
+	const messageCacheEntry = caches.byMessageId[messageId];
+	const cachedMessageSnapshot = readCachedMessageEntry(messageCacheEntry).snapshot;
+	const cacheKey = stateRenderId !== void 0 ? `${stateRenderId}::${effectiveRunId}` : void 0;
+	let cachedSnapshot = cachedMessageSnapshot ?? caches.byMessageId[messageId];
+	if (cachedSnapshot === void 0 && cacheKey && caches.byStateRenderAndRun[cacheKey] !== void 0) cachedSnapshot = caches.byStateRenderAndRun[cacheKey];
+	if (cachedSnapshot === void 0 && stateRenderId && previousUserMessageId && caches.byStateRenderAndRun[`${stateRenderId}::pending:${previousUserMessageId}`] !== void 0) cachedSnapshot = caches.byStateRenderAndRun[`${stateRenderId}::pending:${previousUserMessageId}`];
+	if (cachedSnapshot === void 0 && !skipLatestCache && stateRenderId && messageRole !== "assistant" && (stateSnapshotProp !== void 0 || agentState && Object.keys(agentState).length > 0)) cachedSnapshot = caches.byStateRenderAndRun[`${stateRenderId}::latest`];
+	const snapshotForClaim = existingClaim?.locked ? existingClaim.stateSnapshot ?? cachedSnapshot : hasSnapshotKeys ? snapshot : existingClaim?.stateSnapshot ?? cachedSnapshot;
+	return {
+		snapshot,
+		hasSnapshotKeys,
+		cachedSnapshot,
+		allowEmptySnapshot,
+		snapshotForClaim
+	};
+}
+
+//#endregion
+//#region src/hooks/use-coagent-state-render-registry.ts
+const LAST_SNAPSHOTS_BY_RENDER_AND_RUN = "__lastSnapshotsByStateRenderIdAndRun";
+const LAST_SNAPSHOTS_BY_MESSAGE = "__lastSnapshotsByMessageId";
+function getClaimsStore(claimsRef) {
+	return claimsRef.current;
+}
+function getSnapshotCaches(claimsRef) {
+	const store = getClaimsStore(claimsRef);
+	return {
+		byStateRenderAndRun: store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {},
+		byMessageId: store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {}
+	};
+}
+function useStateRenderRegistry({ agentId, stateRenderId, message, messageIndex, stateSnapshot, agentState, agentMessages, claimsRef }) {
+	const store = getClaimsStore(claimsRef);
+	const runId = message.runId;
+	const cachedMessageEntry = store[LAST_SNAPSHOTS_BY_MESSAGE]?.[message.id];
+	const { runId: cachedMessageRunId } = readCachedMessageEntry(cachedMessageEntry);
+	const existingClaimRunId = claimsRef.current[message.id]?.runId;
+	const effectiveRunId = getEffectiveRunId({
+		existingClaimRunId,
+		cachedMessageRunId,
+		runId
+	});
+	useEffect(() => {
+		return () => {
+			const existingClaim = claimsRef.current[message.id];
+			if (existingClaim?.stateSnapshot && Object.keys(existingClaim.stateSnapshot).length > 0) {
+				const snapshotCache = { ...store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {} };
+				const cacheKey = `${existingClaim.stateRenderId}::${existingClaim.runId ?? "pending"}`;
+				snapshotCache[cacheKey] = existingClaim.stateSnapshot;
+				snapshotCache[`${existingClaim.stateRenderId}::latest`] = existingClaim.stateSnapshot;
+				store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
+				const messageCache = { ...store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {} };
+				messageCache[message.id] = {
+					snapshot: existingClaim.stateSnapshot,
+					runId: existingClaim.runId ?? effectiveRunId
+				};
+				store[LAST_SNAPSHOTS_BY_MESSAGE] = messageCache;
+			}
+			delete claimsRef.current[message.id];
+		};
+	}, [
+		claimsRef,
+		effectiveRunId,
+		message.id
+	]);
+	if (!stateRenderId) return { canRender: false };
+	const caches = getSnapshotCaches(claimsRef);
+	const existingClaim = claimsRef.current[message.id];
+	const { snapshot, hasSnapshotKeys, allowEmptySnapshot, snapshotForClaim } = selectSnapshot({
+		messageId: message.id,
+		messageName: message.name,
+		allowLiveState: isPlaceholderMessageName(message.name) || isPlaceholderMessageId(message.id),
+		skipLatestCache: isPlaceholderMessageName(message.name) || isPlaceholderMessageId(message.id),
+		stateRenderId,
+		effectiveRunId,
+		stateSnapshotProp: stateSnapshot,
+		agentState,
+		agentMessages,
+		existingClaim,
+		caches
+	});
+	const resolution = resolveClaim({
+		claims: claimsRef.current,
+		context: {
+			agentId,
+			messageId: message.id,
+			stateRenderId,
+			runId: effectiveRunId,
+			messageIndex
+		},
+		stateSnapshot: snapshotForClaim
+	});
+	if (resolution.action === ClaimAction.Block) return { canRender: false };
+	if (resolution.updateRunId && claimsRef.current[message.id]) claimsRef.current[message.id].runId = resolution.updateRunId;
+	if (resolution.nextClaim) claimsRef.current[message.id] = resolution.nextClaim;
+	if (resolution.lockOthers) Object.entries(claimsRef.current).forEach(([id, claim]) => {
+		if (id !== message.id && claim.stateRenderId === stateRenderId) claim.locked = true;
+	});
+	if (existingClaim && !existingClaim.locked && agentMessages?.length) {
+		const indexInAgentMessages = agentMessages.findIndex((msg) => msg.id === message.id);
+		if (indexInAgentMessages >= 0 && indexInAgentMessages < agentMessages.length - 1) existingClaim.locked = true;
+	}
+	const existingSnapshot = claimsRef.current[message.id].stateSnapshot;
+	const snapshotChanged = stateSnapshot && existingSnapshot !== void 0 && !areStatesEquals(existingSnapshot, snapshot);
+	if (snapshot && (stateSnapshot || hasSnapshotKeys || allowEmptySnapshot) && (!claimsRef.current[message.id].locked || snapshotChanged)) {
+		if (!claimsRef.current[message.id].locked || snapshotChanged) {
+			claimsRef.current[message.id].stateSnapshot = snapshot;
+			const snapshotCache = { ...store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {} };
+			const cacheKey = `${stateRenderId}::${effectiveRunId}`;
+			snapshotCache[cacheKey] = snapshot;
+			snapshotCache[`${stateRenderId}::latest`] = snapshot;
+			store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
+			const messageCache = { ...store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {} };
+			messageCache[message.id] = {
+				snapshot,
+				runId: effectiveRunId
+			};
+			store[LAST_SNAPSHOTS_BY_MESSAGE] = messageCache;
+			if (stateSnapshot) claimsRef.current[message.id].locked = true;
+		}
+	} else if (snapshotForClaim) {
+		if (!claimsRef.current[message.id].stateSnapshot) {
+			claimsRef.current[message.id].stateSnapshot = snapshotForClaim;
+			const snapshotCache = { ...store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] ?? {} };
+			const cacheKey = `${stateRenderId}::${effectiveRunId}`;
+			snapshotCache[cacheKey] = snapshotForClaim;
+			snapshotCache[`${stateRenderId}::latest`] = snapshotForClaim;
+			store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
+			const messageCache = { ...store[LAST_SNAPSHOTS_BY_MESSAGE] ?? {} };
+			messageCache[message.id] = {
+				snapshot: snapshotForClaim,
+				runId: effectiveRunId
+			};
+			store[LAST_SNAPSHOTS_BY_MESSAGE] = messageCache;
+		}
+	}
+	return { canRender: true };
+}
+
+//#endregion
+//#region src/hooks/use-coagent-state-render-bridge.tsx
+function useCoagentStateRenderBridge(agentId, props) {
+	const { stateSnapshot, message } = props;
+	const { coAgentStateRenders, claimsRef } = useCoAgentStateRenders();
+	const { agent } = useAgent({ agentId });
+	const [nodeName, setNodeName] = useState(void 0);
+	const [, forceUpdate] = useState(0);
+	useEffect(() => {
+		if (!agent) return;
+		const { unsubscribe } = agent.subscribe({
+			onStateChanged: () => {
+				forceUpdate((value) => value + 1);
+			},
+			onStepStartedEvent: ({ event }) => {
+				if (event.stepName !== nodeName) setNodeName(event.stepName);
+			},
+			onStepFinishedEvent: ({ event }) => {
+				if (event.stepName === nodeName) setNodeName(void 0);
+			}
+		});
+		return () => {
+			unsubscribe();
+		};
+	}, [agentId, nodeName]);
+	const getStateRender = useCallback((messageId) => {
+		return Object.entries(coAgentStateRenders).find(([stateRenderId, stateRender]) => {
+			if (claimsRef.current[messageId]) return stateRenderId === claimsRef.current[messageId].stateRenderId;
+			const matchingAgentName = stateRender.name === agentId;
+			const matchesNodeContext = stateRender.nodeName ? stateRender.nodeName === nodeName : true;
+			return matchingAgentName && matchesNodeContext;
+		});
+	}, [
+		coAgentStateRenders,
+		nodeName,
+		agentId
+	]);
+	const stateRenderEntry = useMemo(() => getStateRender(message.id), [getStateRender, message.id]);
+	const stateRenderId = stateRenderEntry?.[0];
+	const stateRender = stateRenderEntry?.[1];
+	const { canRender } = useStateRenderRegistry({
+		agentId,
+		stateRenderId,
+		message: {
+			...message,
+			runId: props.runId ?? message.runId
+		},
+		messageIndex: props.messageIndex,
+		stateSnapshot,
+		agentState: agent?.state,
+		agentMessages: agent?.messages,
+		claimsRef
+	});
+	return useMemo(() => {
+		if (!stateRender || !stateRenderId) return null;
+		if (!canRender) return null;
+		if (stateRender.handler) stateRender.handler({
+			state: stateSnapshot ? parseJson(stateSnapshot, stateSnapshot) : agent?.state ?? {},
+			nodeName: nodeName ?? ""
+		});
+		if (stateRender.render) {
+			const status = agent?.isRunning ? RenderStatus.InProgress : RenderStatus.Complete;
+			if (typeof stateRender.render === "string") return stateRender.render;
+			return stateRender.render({
+				status,
+				state: claimsRef.current[message.id].stateSnapshot ?? {},
+				nodeName: nodeName ?? ""
+			});
+		}
+	}, [
+		stateRender,
+		stateRenderId,
+		agent?.state,
+		agent?.isRunning,
+		nodeName,
+		message.id,
+		stateSnapshot,
+		canRender
+	]);
+}
+function CoAgentStateRenderBridge(props) {
+	return useCoagentStateRenderBridge(props.agentId, props);
+}
+
+//#endregion
+//#region src/components/CopilotListeners.tsx
+const usePredictStateSubscription = (agent) => {
+	const predictStateToolsRef = useRef([]);
+	const getSubscriber = useCallback((agent) => ({
+		onCustomEvent: ({ event }) => {
+			if (event.name === "PredictState") predictStateToolsRef.current = event.value;
+		},
+		onToolCallArgsEvent: ({ partialToolCallArgs, toolCallName }) => {
+			predictStateToolsRef.current.forEach((t) => {
+				if (t?.tool !== toolCallName) return;
+				const emittedState = typeof partialToolCallArgs === "string" ? parseJson(partialToolCallArgs, partialToolCallArgs) : partialToolCallArgs;
+				agent.setState({ [t.state_key]: emittedState[t.state_key] });
+			});
+		}
+	}), []);
+	useEffect(() => {
+		if (!agent) return;
+		const subscriber = getSubscriber(agent);
+		const { unsubscribe } = agent.subscribe(subscriber);
+		return () => {
+			unsubscribe();
+		};
+	}, [agent, getSubscriber]);
+};
+function CopilotListeners() {
+	const { copilotkit } = useCopilotKit();
+	const resolvedAgentId = useCopilotChatConfiguration()?.agentId;
+	const { setBannerError } = useToast();
+	const { agent } = useAgent({ agentId: resolvedAgentId });
+	usePredictStateSubscription(agent);
+	useEffect(() => {
+		const subscription = copilotkit.subscribe({ onError: ({ error }) => {
+			setBannerError(new CopilotKitLowLevelError({
+				error,
+				message: error.message,
+				url: typeof window !== "undefined" ? window.location.href : ""
+			}));
+		} });
+		return () => {
+			subscription.unsubscribe();
+		};
+	}, [copilotkit?.subscribe]);
+	return null;
+}
+
+//#endregion
+//#region src/components/copilot-provider/copilotkit.tsx
+/**
+* This component will typically wrap your entire application (or a sub-tree of your application where you want to have a copilot). It provides the copilot context to all other components and hooks.
+*
+* ## Example
+*
+* You can find more information about self-hosting CopilotKit [here](/guides/self-hosting).
+*
+* ```tsx
+* import { CopilotKit } from "@copilotkit/react-core";
+*
+* <CopilotKit runtimeUrl="<your-runtime-url>">
+*   // ... your app ...
+* </CopilotKit>
+* ```
+*/
+function CopilotKit({ children, ...props }) {
+	const enabled = shouldShowDevConsole(props.showDevConsole);
+	const showInspector = shouldShowDevConsole(props.enableInspector);
+	const publicApiKey = props.publicApiKey || props.publicLicenseKey;
+	const renderArr = useMemo(() => [{ render: CoAgentStateRenderBridge }], []);
+	return /* @__PURE__ */ jsx(ToastProvider, {
+		enabled,
+		children: /* @__PURE__ */ jsx(CopilotErrorBoundary, {
+			publicApiKey,
+			showUsageBanner: enabled,
+			children: /* @__PURE__ */ jsx(ThreadsProvider, {
+				threadId: props.threadId,
+				children: /* @__PURE__ */ jsx(CopilotKitProvider, {
+					...props,
+					showDevConsole: showInspector,
+					renderCustomMessages: renderArr,
+					useSingleEndpoint: true,
+					children: /* @__PURE__ */ jsx(CopilotKitInternal, {
+						...props,
+						children
+					})
+				})
+			})
+		})
+	});
+}
+/**
+* Bridge component that subscribes to v2.x copilotkit core error events
+* and forwards them to v1.x error handling system.
+* This ensures only ONE subscription exists regardless of how many times
+* Chat components are rendered.
+*/
+function CopilotKitErrorBridge() {
+	const { copilotkit } = useCopilotKit();
+	const { onError, copilotApiConfig } = useCopilotContext();
+	useEffect(() => {
+		if (!copilotkit) return;
+		const subscription = copilotkit.subscribe({ onError: async (event) => {
+			const errorEvent = {
+				type: "error",
+				timestamp: Date.now(),
+				context: {
+					source: "agent",
+					request: {
+						operation: event.code || "unknown",
+						url: copilotApiConfig?.chatApiEndpoint,
+						startTime: Date.now()
+					},
+					technical: {
+						environment: "browser",
+						userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+						stackTrace: event.error.stack
+					},
+					...event.context
+				},
+				error: event.error
+			};
+			try {
+				await onError(errorEvent);
+			} catch (handlerError) {
+				console.error("Error in onError handler:", handlerError);
+			}
+		} });
+		return () => {
+			subscription.unsubscribe();
+		};
+	}, [
+		copilotkit,
+		onError,
+		copilotApiConfig
+	]);
+	return null;
+}
+function CopilotKitInternal(cpkProps) {
+	const { children, ...props } = cpkProps;
+	/**
+	* This will throw an error if the props are invalid.
+	*/
+	validateProps(cpkProps);
+	const publicApiKey = props.publicLicenseKey || props.publicApiKey;
+	const chatApiEndpoint = props.runtimeUrl || COPILOT_CLOUD_CHAT_URL;
+	const [actions, setActions] = useState({});
+	const [registeredActionConfigs, setRegisteredActionConfigs] = useState(/* @__PURE__ */ new Map());
+	const chatComponentsCache = useRef({
+		actions: {},
+		coAgentStateRenders: {}
+	});
+	const { addElement, removeElement, printTree, getAllElements } = useTree();
+	const [isLoading, setIsLoading] = useState(false);
+	const [chatInstructions, setChatInstructions] = useState("");
+	const [authStates, setAuthStates] = useState({});
+	const [extensions, setExtensions] = useState({});
+	const [additionalInstructions, setAdditionalInstructions] = useState([]);
+	const { addElement: addDocument, removeElement: removeDocument, allElements: allDocuments } = useFlatCategoryStore();
+	const setAction = useCallback((id, action) => {
+		setActions((prevPoints) => {
+			return {
+				...prevPoints,
+				[id]: action
+			};
+		});
+	}, []);
+	const removeAction = useCallback((id) => {
+		setActions((prevPoints) => {
+			const newPoints = { ...prevPoints };
+			delete newPoints[id];
+			return newPoints;
+		});
+	}, []);
+	const getContextString = useCallback((documents, categories) => {
+		return `${documents.map((document) => {
+			return `${document.name} (${document.sourceApplication}):\n${document.getContents()}`;
+		}).join("\n\n")}\n\n${printTree(categories)}`;
+	}, [printTree]);
+	const addContext = useCallback((context, parentId, categories = defaultCopilotContextCategories) => {
+		return addElement(context, categories, parentId);
+	}, [addElement]);
+	const removeContext = useCallback((id) => {
+		removeElement(id);
+	}, [removeElement]);
+	const getAllContext = useCallback(() => {
+		return getAllElements();
+	}, [getAllElements]);
+	const getFunctionCallHandler = useCallback((customEntryPoints) => {
+		return entryPointsToFunctionCallHandler(Object.values(customEntryPoints || actions));
+	}, [actions]);
+	const getDocumentsContext = useCallback((categories) => {
+		return allDocuments(categories);
+	}, [allDocuments]);
+	const addDocumentContext = useCallback((documentPointer, categories = defaultCopilotContextCategories) => {
+		return addDocument(documentPointer, categories);
+	}, [addDocument]);
+	const removeDocumentContext = useCallback((documentId) => {
+		removeDocument(documentId);
+	}, [removeDocument]);
+	const copilotApiConfig = useMemo(() => {
+		let cloud = void 0;
+		if (publicApiKey) cloud = { guardrails: { input: { restrictToTopic: {
+			enabled: Boolean(props.guardrails_c),
+			validTopics: props.guardrails_c?.validTopics || [],
+			invalidTopics: props.guardrails_c?.invalidTopics || []
+		} } } };
+		return {
+			publicApiKey,
+			...cloud ? { cloud } : {},
+			chatApiEndpoint,
+			headers: props.headers || {},
+			properties: props.properties || {},
+			transcribeAudioUrl: props.transcribeAudioUrl,
+			textToSpeechUrl: props.textToSpeechUrl,
+			credentials: props.credentials
+		};
+	}, [
+		publicApiKey,
+		props.headers,
+		props.properties,
+		props.transcribeAudioUrl,
+		props.textToSpeechUrl,
+		props.credentials,
+		props.cloudRestrictToTopic,
+		props.guardrails_c
+	]);
+	useMemo(() => {
+		const authHeaders = Object.values(authStates || {}).reduce((acc, state) => {
+			if (state.status === "authenticated" && state.authHeaders) return {
+				...acc,
+				...Object.entries(state.authHeaders).reduce((headers, [key, value]) => ({
+					...headers,
+					[key.startsWith("X-Custom-") ? key : `X-Custom-${key}`]: value
+				}), {})
+			};
+			return acc;
+		}, {});
+		return {
+			...copilotApiConfig.headers || {},
+			...copilotApiConfig.publicApiKey ? { [COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: copilotApiConfig.publicApiKey } : {},
+			...authHeaders
+		};
+	}, [
+		copilotApiConfig.headers,
+		copilotApiConfig.publicApiKey,
+		authStates
+	]);
+	const [internalErrorHandlers, _setInternalErrorHandler] = useState({});
+	const setInternalErrorHandler = useCallback((handler) => {
+		_setInternalErrorHandler((prev) => ({
+			...prev,
+			...handler
+		}));
+	}, []);
+	const removeInternalErrorHandler = useCallback((key) => {
+		_setInternalErrorHandler((prev) => {
+			const { [key]: _removed, ...rest } = prev;
+			return rest;
+		});
+	}, []);
+	const onErrorRef = useRef(props.onError);
+	useEffect(() => {
+		onErrorRef.current = props.onError;
+	}, [props.onError]);
+	const internalHandlersRef = useRef({});
+	useEffect(() => {
+		internalHandlersRef.current = internalErrorHandlers;
+	}, [internalErrorHandlers]);
+	const handleErrors = useCallback(async (error) => {
+		if (copilotApiConfig.publicApiKey && onErrorRef.current) try {
+			await onErrorRef.current(error);
+		} catch (e) {
+			console.error("Error in public onError handler:", e);
+		}
+		const handlers = Object.values(internalHandlersRef.current);
+		await Promise.all(handlers.map((h) => Promise.resolve(h(error)).catch((e) => console.error("Error in internal error handler:", e))));
+	}, [copilotApiConfig.publicApiKey]);
+	const [chatSuggestionConfiguration, setChatSuggestionConfiguration] = useState({});
+	const addChatSuggestionConfiguration = useCallback((id, suggestion) => {
+		setChatSuggestionConfiguration((prev) => ({
+			...prev,
+			[id]: suggestion
+		}));
+	}, [setChatSuggestionConfiguration]);
+	const removeChatSuggestionConfiguration = useCallback((id) => {
+		setChatSuggestionConfiguration((prev) => {
+			const { [id]: _, ...rest } = prev;
+			return rest;
+		});
+	}, [setChatSuggestionConfiguration]);
+	const [availableAgents, setAvailableAgents] = useState([]);
+	const [coagentStates, setCoagentStates] = useState({});
+	const coagentStatesRef = useRef({});
+	const setCoagentStatesWithRef = useCallback((value) => {
+		const newValue = typeof value === "function" ? value(coagentStatesRef.current) : value;
+		coagentStatesRef.current = newValue;
+		setCoagentStates((prev) => {
+			return newValue;
+		});
+	}, []);
+	let initialAgentSession = null;
+	if (props.agent) initialAgentSession = { agentName: props.agent };
+	const [agentSession, setAgentSession] = useState(initialAgentSession);
+	useEffect(() => {
+		if (props.agent) setAgentSession({ agentName: props.agent });
+		else setAgentSession(null);
+	}, [props.agent]);
+	const { threadId, setThreadId: setInternalThreadId } = useThreads();
+	const setThreadId = useCallback((value) => {
+		if (props.threadId) throw new Error("Cannot call setThreadId() when threadId is provided via props.");
+		setInternalThreadId(value);
+	}, [props.threadId]);
+	const [runId, setRunId] = useState(null);
+	const chatAbortControllerRef = useRef(null);
+	const showDevConsole = shouldShowDevConsole(props.showDevConsole);
+	const [interruptActions, _setInterruptActions] = useState({});
+	const setInterruptAction = useCallback((action) => {
+		_setInterruptActions((prev) => {
+			if (action == null || !action.id) return prev;
+			return {
+				...prev,
+				[action.id]: {
+					...prev[action.id] ?? {},
+					...action
+				}
+			};
+		});
+	}, []);
+	const removeInterruptAction = useCallback((actionId) => {
+		_setInterruptActions((prev) => {
+			const { [actionId]: _, ...rest } = prev;
+			return rest;
+		});
+	}, []);
+	const [interruptEventQueue, setInterruptEventQueue] = useState({});
+	const addInterruptEvent = useCallback((queuedEvent) => {
+		setInterruptEventQueue((prev) => {
+			const threadQueue = prev[queuedEvent.threadId] || [];
+			return {
+				...prev,
+				[queuedEvent.threadId]: [...threadQueue, queuedEvent]
+			};
+		});
+	}, []);
+	const resolveInterruptEvent = useCallback((threadId, eventId, response) => {
+		setInterruptEventQueue((prev) => {
+			const threadQueue = prev[threadId] || [];
+			return {
+				...prev,
+				[threadId]: threadQueue.map((queuedEvent) => queuedEvent.eventId === eventId ? {
+					...queuedEvent,
+					event: {
+						...queuedEvent.event,
+						response
+					}
+				} : queuedEvent)
+			};
+		});
+	}, []);
+	const memoizedChildren = useMemo(() => children, [children]);
+	const [bannerError, setBannerError] = useState(null);
+	const agentLock = useMemo(() => props.agent ?? null, [props.agent]);
+	const forwardedParameters = useMemo(() => props.forwardedParameters ?? {}, [props.forwardedParameters]);
+	const updateExtensions = useCallback((newExtensions) => {
+		setExtensions((prev) => {
+			const resolved = typeof newExtensions === "function" ? newExtensions(prev) : newExtensions;
+			return Object.keys(resolved).length === Object.keys(prev).length && Object.entries(resolved).every(([key, value]) => prev[key] === value) ? prev : resolved;
+		});
+	}, [setExtensions]);
+	const updateAuthStates = useCallback((newAuthStates) => {
+		setAuthStates((prev) => {
+			const resolved = typeof newAuthStates === "function" ? newAuthStates(prev) : newAuthStates;
+			return Object.keys(resolved).length === Object.keys(prev).length && Object.entries(resolved).every(([key, value]) => prev[key] === value) ? prev : resolved;
+		});
+	}, [setAuthStates]);
+	const handleSetRegisteredActions = useCallback((actionConfig) => {
+		const key = actionConfig.action.name || randomUUID();
+		setRegisteredActionConfigs((prev) => {
+			const newMap = new Map(prev);
+			newMap.set(key, actionConfig);
+			return newMap;
+		});
+		return key;
+	}, []);
+	const handleRemoveRegisteredAction = useCallback((actionKey) => {
+		setRegisteredActionConfigs((prev) => {
+			const newMap = new Map(prev);
+			newMap.delete(actionKey);
+			return newMap;
+		});
+	}, []);
+	const RegisteredActionsRenderer = useMemo(() => {
+		return () => /* @__PURE__ */ jsx(Fragment$1, { children: Array.from(registeredActionConfigs.entries()).map(([key, config]) => {
+			const Component = config.component;
+			return /* @__PURE__ */ jsx(Component, { action: config.action }, key);
+		}) });
+	}, [registeredActionConfigs]);
+	return /* @__PURE__ */ jsx(CopilotChatConfigurationProvider, {
+		agentId: props.agent ?? "default",
+		threadId,
+		children: /* @__PURE__ */ jsxs(CopilotContext.Provider, {
+			value: {
+				actions,
+				chatComponentsCache,
+				getFunctionCallHandler,
+				setAction,
+				removeAction,
+				setRegisteredActions: handleSetRegisteredActions,
+				removeRegisteredAction: handleRemoveRegisteredAction,
+				getContextString,
+				addContext,
+				removeContext,
+				getAllContext,
+				getDocumentsContext,
+				addDocumentContext,
+				removeDocumentContext,
+				copilotApiConfig,
+				isLoading,
+				setIsLoading,
+				chatSuggestionConfiguration,
+				addChatSuggestionConfiguration,
+				removeChatSuggestionConfiguration,
+				chatInstructions,
+				setChatInstructions,
+				additionalInstructions,
+				setAdditionalInstructions,
+				showDevConsole,
+				coagentStates,
+				setCoagentStates,
+				coagentStatesRef,
+				setCoagentStatesWithRef,
+				agentSession,
+				setAgentSession,
+				forwardedParameters,
+				agentLock,
+				threadId,
+				setThreadId,
+				runId,
+				setRunId,
+				chatAbortControllerRef,
+				availableAgents,
+				authConfig_c: props.authConfig_c,
+				authStates_c: authStates,
+				setAuthStates_c: updateAuthStates,
+				extensions,
+				setExtensions: updateExtensions,
+				interruptActions,
+				setInterruptAction,
+				removeInterruptAction,
+				interruptEventQueue,
+				addInterruptEvent,
+				resolveInterruptEvent,
+				bannerError,
+				setBannerError,
+				onError: handleErrors,
+				internalErrorHandlers,
+				setInternalErrorHandler,
+				removeInternalErrorHandler
+			},
+			children: [
+				/* @__PURE__ */ jsx(CopilotListeners, {}),
+				/* @__PURE__ */ jsx(CopilotKitErrorBridge, {}),
+				/* @__PURE__ */ jsxs(CoAgentStateRendersProvider, { children: [/* @__PURE__ */ jsx(MessagesTapProvider, { children: /* @__PURE__ */ jsxs(CopilotMessages, { children: [memoizedChildren, /* @__PURE__ */ jsx(RegisteredActionsRenderer, {})] }) }), bannerError && showDevConsole && /* @__PURE__ */ jsx(UsageBanner, {
+					severity: bannerError.severity,
+					message: bannerError.message,
+					onClose: () => setBannerError(null),
+					actions: getErrorActions(bannerError)
+				})] })
+			]
+		})
+	});
+}
+const defaultCopilotContextCategories = ["global"];
+function entryPointsToFunctionCallHandler(actions) {
+	return async ({ name, args }) => {
+		let actionsByFunctionName = {};
+		for (let action of actions) actionsByFunctionName[action.name] = action;
+		const action = actionsByFunctionName[name];
+		let result = void 0;
+		if (action) {
+			await new Promise((resolve, reject) => {
+				flushSync(async () => {
+					try {
+						result = await action.handler?.(args);
+						resolve();
+					} catch (error) {
+						reject(error);
+					}
+				});
+			});
+			await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+		return result;
+	};
+}
+function formatFeatureName(featureName) {
+	return featureName.replace(/_c$/, "").split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+function validateProps(props) {
+	const cloudFeatures = Object.keys(props).filter((key) => key.endsWith("_c"));
+	const hasApiKey = props.publicApiKey || props.publicLicenseKey;
+	if (!props.runtimeUrl && !hasApiKey) throw new ConfigurationError("Missing required prop: 'runtimeUrl' or 'publicApiKey' or 'publicLicenseKey'");
+	if (cloudFeatures.length > 0 && !hasApiKey) throw new MissingPublicApiKeyError(`Missing required prop: 'publicApiKey' or 'publicLicenseKey' to use cloud features: ${cloudFeatures.map(formatFeatureName).join(", ")}`);
+}
+
+//#endregion
+//#region src/hooks/use-agent-nodename.ts
+function useAgentNodeName(agentName) {
+	const { agent } = useAgent({ agentId: agentName });
+	const nodeNameRef = useRef("start");
+	useEffect(() => {
+		if (!agent) return;
+		const subscription = agent.subscribe({
+			onStepStartedEvent: ({ event }) => {
+				nodeNameRef.current = event.stepName;
+			},
+			onRunStartedEvent: () => {
+				nodeNameRef.current = "start";
+			},
+			onRunFinishedEvent: () => {
+				nodeNameRef.current = "end";
+			}
+		});
+		return () => {
+			subscription.unsubscribe();
+		};
+	}, [agent]);
+	return nodeNameRef.current;
+}
+
+//#endregion
+//#region src/hooks/use-langgraph-interrupt-render.ts
+const InterruptRenderer = ({ event, result, render, resolve }) => {
+	return render({
+		event,
+		result,
+		resolve
+	});
+};
+function useLangGraphInterruptRender(agent) {
+	const { interruptActions, agentSession, threadId, interruptEventQueue, addInterruptEvent, resolveInterruptEvent } = useCopilotContext();
+	const nodeName = useAgentNodeName(useCopilotChatConfiguration()?.agentId ?? "default");
+	useEffect(() => {
+		if (!agent) return;
+		let localInterrupt = null;
+		const { unsubscribe } = agent.subscribe({
+			onCustomEvent: ({ event }) => {
+				if (event.name === "on_interrupt") {
+					const eventData = {
+						name: MetaEventName.LangGraphInterruptEvent,
+						type: event.type,
+						value: parseJson(event.value, event.value)
+					};
+					localInterrupt = {
+						eventId: dataToUUID(eventData, "interruptEvents"),
+						threadId,
+						event: eventData
+					};
+				}
+			},
+			onRunStartedEvent: () => {
+				localInterrupt = null;
+			},
+			onRunFinalized: () => {
+				if (localInterrupt) {
+					addInterruptEvent(localInterrupt);
+					localInterrupt = null;
+				}
+			}
+		});
+		return () => {
+			unsubscribe();
+		};
+	}, [agent, threadId]);
+	const handleResolve = useCallback((eventId, response) => {
+		agent?.runAgent({ forwardedProps: { command: { resume: response } } });
+		resolveInterruptEvent(threadId, eventId, response ?? "");
+	}, [agent, threadId]);
+	return useMemo(() => {
+		const currentQueuedEvent = (interruptEventQueue[threadId] || []).find((qe) => !qe.event.response);
+		if (!currentQueuedEvent || !agentSession) return null;
+		const matchingAction = Object.values(interruptActions).find((action) => {
+			if (!action.enabled) return true;
+			return action.enabled({
+				eventValue: currentQueuedEvent.event.value,
+				agentMetadata: {
+					...agentSession,
+					nodeName
+				}
+			});
+		});
+		if (!matchingAction) return null;
+		const { render, handler } = matchingAction;
+		const resolveInterrupt = (response) => {
+			handleResolve(currentQueuedEvent.eventId, response);
+		};
+		let result = null;
+		if (handler) result = handler({
+			event: currentQueuedEvent.event,
+			resolve: resolveInterrupt
+		});
+		if (!render) return null;
+		return React.createElement(InterruptRenderer, {
+			event: currentQueuedEvent.event,
+			result,
+			render,
+			resolve: resolveInterrupt
+		});
+	}, [
+		interruptActions,
+		interruptEventQueue,
+		threadId,
+		agentSession,
+		handleResolve
+	]);
+}
+
+//#endregion
+//#region src/hooks/use-lazy-tool-renderer.tsx
+function useLazyToolRenderer() {
+	const renderToolCall = useRenderToolCall$1();
+	return useCallback((message, messages) => {
+		if (!message?.toolCalls?.length) return null;
+		const toolCall = message.toolCalls[0];
+		if (!toolCall) return null;
+		const toolMessage = messages?.find((m) => m.role === "tool" && m.toolCallId === toolCall.id);
+		return () => renderToolCall({
+			toolCall,
+			toolMessage
+		});
+	}, [renderToolCall]);
+}
+
+//#endregion
+//#region src/hooks/use-copilot-chat_internal.ts
+function useCopilotChatInternal({ suggestions, onInProgress, onSubmitMessage, onStopGeneration, onReloadMessages } = {}) {
+	const { copilotkit } = useCopilotKit();
+	const { threadId, agentSession } = useCopilotContext();
+	const existingConfig = useCopilotChatConfiguration();
+	const [agentAvailable, setAgentAvailable] = useState(false);
+	const resolvedAgentId = existingConfig?.agentId ?? "default";
+	const { agent } = useAgent({ agentId: resolvedAgentId });
+	useEffect(() => {
+		const connect = async (agent) => {
+			setAgentAvailable(false);
+			try {
+				await copilotkit.connectAgent({ agent });
+				setAgentAvailable(true);
+			} catch (error) {
+				if (error instanceof AGUIConnectNotImplementedError) {} else console.error("CopilotChat: connectAgent failed", error);
+			}
+		};
+		if (agent && existingConfig?.threadId && agent.threadId !== existingConfig.threadId) {
+			agent.threadId = existingConfig.threadId;
+			connect(agent);
+		}
+		return () => {};
+	}, [
+		existingConfig?.threadId,
+		agent,
+		copilotkit,
+		resolvedAgentId
+	]);
+	useEffect(() => {
+		onInProgress?.(Boolean(agent?.isRunning));
+	}, [agent?.isRunning, onInProgress]);
+	const interrupt = useLangGraphInterruptRender(agent);
+	const reset = () => {
+		agent?.setMessages([]);
+		agent?.setState(null);
+	};
+	const latestDelete = useUpdatedRef(useCallback((messageId) => {
+		const filteredMessages = (agent?.messages ?? []).filter((message) => message.id !== messageId);
+		agent?.setMessages(filteredMessages);
+	}, [agent?.setMessages, agent?.messages]));
+	const latestDeleteFunc = useCallback((messageId) => {
+		return latestDelete.current(messageId);
+	}, [latestDelete]);
+	const currentSuggestions = useSuggestions({ agentId: resolvedAgentId });
+	const reload = useAsyncCallback(async (reloadMessageId) => {
+		if (!agent) return;
+		const messages = agent?.messages ?? [];
+		if (agent.isRunning || messages.length === 0) return;
+		const reloadMessageIndex = messages.findIndex((msg) => msg.id === reloadMessageId);
+		if (reloadMessageIndex === -1) {
+			console.warn(`Message with id ${reloadMessageId} not found`);
+			return;
+		}
+		const reloadMessageRole = messages[reloadMessageIndex].role;
+		if (reloadMessageRole !== "assistant") {
+			console.warn(`Regenerate cannot be performed on ${reloadMessageRole} role`);
+			return;
+		}
+		let historyCutoff = [messages[0]];
+		if (messages.length > 2 && reloadMessageIndex !== 0) {
+			const lastUserMessageBeforeRegenerate = messages.slice(0, reloadMessageIndex).reverse().find((msg) => msg.role === "user");
+			if (!lastUserMessageBeforeRegenerate) historyCutoff = [messages[0]];
+			else {
+				const indexOfLastUserMessageBeforeRegenerate = messages.findIndex((msg) => msg.id === lastUserMessageBeforeRegenerate.id);
+				historyCutoff = messages.slice(0, indexOfLastUserMessageBeforeRegenerate + 1);
+			}
+		} else if (messages.length > 2 && reloadMessageIndex === 0) historyCutoff = [messages[0], messages[1]];
+		agent?.setMessages(historyCutoff);
+		if (agent) try {
+			await copilotkit.runAgent({ agent });
+		} catch (error) {
+			console.error("CopilotChat: runAgent failed during reload", error);
+		}
+	}, [
+		agent?.messages.length,
+		agent?.isRunning,
+		agent?.setMessages,
+		copilotkit?.runAgent
+	]);
+	const latestSendMessageFunc = useAsyncCallback(async (message, options) => {
+		if (!agent) return;
+		const followUp = options?.followUp ?? true;
+		if (options?.clearSuggestions) copilotkit.clearSuggestions(resolvedAgentId);
+		if (onSubmitMessage) {
+			const content = typeof message.content === "string" ? message.content : message.content && "text" in message.content ? message.content.text : message.content && "filename" in message.content ? message.content.filename : "";
+			try {
+				await onSubmitMessage(content);
+			} catch (error) {
+				console.error("Error in onSubmitMessage:", error);
+			}
+		}
+		agent?.addMessage(message);
+		if (followUp) try {
+			await copilotkit.runAgent({ agent });
+		} catch (error) {
+			console.error("CopilotChat: runAgent failed", error);
+		}
+	}, [
+		agent,
+		copilotkit,
+		resolvedAgentId,
+		onSubmitMessage
+	]);
+	const latestAppendFunc = useAsyncCallback(async (message, options) => {
+		return latestSendMessageFunc(gqlToAGUI([message])[0], options);
+	}, [latestSendMessageFunc]);
+	const latestSetMessagesFunc = useCallback((messages) => {
+		if (messages.every((message) => message instanceof Message$1)) return agent?.setMessages?.(gqlToAGUI(messages));
+		return agent?.setMessages?.(messages);
+	}, [agent?.setMessages, agent]);
+	const latestReload = useUpdatedRef(reload);
+	const latestReloadFunc = useAsyncCallback(async (messageId) => {
+		onReloadMessages?.({
+			messageId,
+			currentAgentName: agent?.agentId,
+			messages: agent?.messages ?? []
+		});
+		return await latestReload.current(messageId);
+	}, [
+		latestReload,
+		agent,
+		onReloadMessages
+	]);
+	const latestStopFunc = useCallback(() => {
+		onStopGeneration?.({
+			currentAgentName: agent?.agentId,
+			messages: agent?.messages ?? []
+		});
+		return agent?.abortRun?.();
+	}, [onStopGeneration, agent]);
+	const latestReset = useUpdatedRef(reset);
+	const latestResetFunc = useCallback(() => {
+		return latestReset.current();
+	}, [latestReset]);
+	const lazyToolRendered = useLazyToolRenderer();
+	const renderCustomMessage = useRenderCustomMessages();
+	const legacyCustomMessageRenderer = useLegacyCoagentRenderer({
+		copilotkit,
+		agent,
+		agentId: resolvedAgentId,
+		threadId: existingConfig?.threadId ?? threadId
+	});
+	const allMessages = agent?.messages ?? [];
+	const resolvedMessages = useMemo(() => {
+		let processedMessages = allMessages.map((message) => {
+			if (message.role !== "assistant") return message;
+			const lazyRendered = lazyToolRendered(message, allMessages);
+			if (lazyRendered) {
+				const renderedGenUi = lazyRendered();
+				if (renderedGenUi) return {
+					...message,
+					generativeUI: () => renderedGenUi
+				};
+			}
+			const bridgeRenderer = legacyCustomMessageRenderer || renderCustomMessage ? () => {
+				if (legacyCustomMessageRenderer) return legacyCustomMessageRenderer({
+					message,
+					position: "before"
+				});
+				try {
+					return renderCustomMessage?.({
+						message,
+						position: "before"
+					}) ?? null;
+				} catch (error) {
+					console.warn("[CopilotKit] renderCustomMessages failed, falling back to legacy renderer", error);
+					return null;
+				}
+			} : null;
+			if (bridgeRenderer) return {
+				...message,
+				generativeUI: bridgeRenderer,
+				generativeUIPosition: "before"
+			};
+			return message;
+		});
+		const hasAssistantMessages = processedMessages.some((msg) => msg.role === "assistant");
+		const canUseCustomRenderer = Boolean(renderCustomMessage && copilotkit?.getAgent?.(resolvedAgentId));
+		const placeholderRenderer = legacyCustomMessageRenderer ? legacyCustomMessageRenderer : canUseCustomRenderer ? renderCustomMessage : null;
+		const shouldRenderPlaceholder = Boolean(agent?.isRunning) || Boolean(agent?.state && Object.keys(agent.state).length);
+		const effectiveThreadId = threadId ?? agent?.threadId ?? "default";
+		let latestUserIndex = -1;
+		for (let i = processedMessages.length - 1; i >= 0; i -= 1) if (processedMessages[i].role === "user") {
+			latestUserIndex = i;
+			break;
+		}
+		const latestUserMessageId = latestUserIndex >= 0 ? processedMessages[latestUserIndex].id : void 0;
+		const currentRunId = latestUserMessageId ? copilotkit.getRunIdForMessage(resolvedAgentId, effectiveThreadId, latestUserMessageId) || `pending:${latestUserMessageId}` : void 0;
+		const hasAssistantForCurrentRun = latestUserIndex >= 0 ? processedMessages.slice(latestUserIndex + 1).some((msg) => msg.role === "assistant") : hasAssistantMessages;
+		if (placeholderRenderer && shouldRenderPlaceholder && !hasAssistantForCurrentRun) {
+			const placeholderMessage = {
+				id: currentRunId ? `coagent-state-render-${resolvedAgentId}-${currentRunId}` : `coagent-state-render-${resolvedAgentId}`,
+				role: "assistant",
+				content: "",
+				name: "coagent-state-render",
+				runId: currentRunId
+			};
+			processedMessages = [...processedMessages, {
+				...placeholderMessage,
+				generativeUIPosition: "before",
+				generativeUI: () => placeholderRenderer({
+					message: placeholderMessage,
+					position: "before"
+				})
+			}];
+		}
+		return processedMessages;
+	}, [
+		agent?.messages,
+		lazyToolRendered,
+		allMessages,
+		renderCustomMessage,
+		legacyCustomMessageRenderer,
+		resolvedAgentId,
+		copilotkit,
+		agent?.isRunning,
+		agent?.state
+	]);
+	const renderedSuggestions = useMemo(() => {
+		if (Array.isArray(suggestions)) return {
+			suggestions: suggestions.map((s) => ({
+				...s,
+				isLoading: false
+			})),
+			isLoading: false
+		};
+		return currentSuggestions;
+	}, [suggestions, currentSuggestions]);
+	return {
+		messages: resolvedMessages,
+		sendMessage: latestSendMessageFunc,
+		appendMessage: latestAppendFunc,
+		setMessages: latestSetMessagesFunc,
+		reloadMessages: latestReloadFunc,
+		stopGeneration: latestStopFunc,
+		reset: latestResetFunc,
+		deleteMessage: latestDeleteFunc,
+		isAvailable: agentAvailable,
+		isLoading: Boolean(agent?.isRunning),
+		suggestions: renderedSuggestions.suggestions,
+		setSuggestions: (suggestions) => copilotkit.addSuggestionsConfig({ suggestions }),
+		generateSuggestions: async () => copilotkit.reloadSuggestions(resolvedAgentId),
+		resetSuggestions: () => copilotkit.clearSuggestions(resolvedAgentId),
+		isLoadingSuggestions: renderedSuggestions.isLoading,
+		interrupt,
+		agent,
+		threadId
+	};
+}
+function useUpdatedRef(value) {
+	const ref = useRef(value);
+	useEffect(() => {
+		ref.current = value;
+	}, [value]);
+	return ref;
+}
+function useLegacyCoagentRenderer({ copilotkit, agent, agentId, threadId }) {
+	return useMemo(() => {
+		if (!copilotkit || !agent) return null;
+		return ({ message, position }) => {
+			const effectiveThreadId = threadId ?? agent.threadId ?? "default";
+			const providedRunId = message.runId;
+			return createElement(CoAgentStateRenderBridge, {
+				message,
+				position,
+				runId: (providedRunId ? providedRunId : copilotkit.getRunIdForMessage(agentId, effectiveThreadId, message.id)) || `pending:${message.id}`,
+				messageIndex: Math.max(agent.messages.findIndex((msg) => msg.id === message.id), 0),
+				messageIndexInRun: 0,
+				numberOfMessagesInRun: 1,
+				agentId,
+				stateSnapshot: message.state
+			});
+		};
+	}, [
+		agent,
+		agentId,
+		copilotkit,
+		threadId
+	]);
+}
+
+//#endregion
+//#region src/hooks/use-copilot-chat.ts
+/**
+* `useCopilotChat` is a lightweight React hook for headless chat interactions.
+* Perfect for controlling the prebuilt chat components programmatically.
+*
+* **Open Source Friendly** - Works without requiring a free public license key.
+*
+* <Callout title="Looking for fully headless UI?">
+* Get started with [useCopilotChatHeadless_c](https://docs.copilotkit.ai/reference/v1/hooks/useCopilotChatHeadless_c).
+* </Callout>
+*
+* ## Use Cases
+*
+* - **Programmatic Messaging**: Send messages without displaying chat UI
+* - **Programmatic control**: Control prebuilt component programmatically
+* - **Background Operations**: Trigger AI interactions in the background
+* - **Fire-and-Forget**: Send messages without needing to read responses
+*
+* ## Usage
+*
+* ```tsx
+* import { TextMessage, MessageRole } from "@copilotkit/runtime-client-gql";
+*
+* const { appendMessage } = useCopilotChat();
+*
+* // Example usage without naming conflicts
+* const handleSendMessage = async (content: string) => {
+*   await appendMessage(
+*     new TextMessage({
+*       role: MessageRole.User,
+*       content,
+*     })
+*   );
+* };
+* ```
+*
+* ## Return Values
+* The following properties are returned from the hook:
+*
+* <PropertyReference name="visibleMessages" type="DeprecatedGqlMessage[]" deprecated>
+* Array of messages in old non-AG-UI format, use for compatibility only
+* </PropertyReference>
+*
+* <PropertyReference name="appendMessage" type="(message: DeprecatedGqlMessage, options?) => Promise<void>" deprecated>
+* Append message using old format, use `sendMessage` instead
+* </PropertyReference>
+*
+* <PropertyReference name="reloadMessages" type="(messageId: string) => Promise<void>">
+* Regenerate the response for a specific message by ID
+* </PropertyReference>
+*
+* <PropertyReference name="stopGeneration" type="() => void">
+* Stop the current message generation process
+* </PropertyReference>
+*
+* <PropertyReference name="reset" type="() => void">
+* Clear all messages and reset chat state completely
+* </PropertyReference>
+*
+* <PropertyReference name="isLoading" type="boolean">
+* Whether the chat is currently generating a response
+* </PropertyReference>
+*
+* <PropertyReference name="runChatCompletion" type="() => Promise<Message[]>">
+* Manually trigger chat completion for advanced usage
+* </PropertyReference>
+*
+* <PropertyReference name="mcpServers" type="MCPServerConfig[]">
+* Array of Model Context Protocol server configurations
+* </PropertyReference>
+*
+* <PropertyReference name="setMcpServers" type="(servers: MCPServerConfig[]) => void">
+* Update MCP server configurations for enhanced context
+* </PropertyReference>
+*/
+/**
+* A lightweight React hook for headless chat interactions.
+* Perfect for programmatic messaging, background operations, and custom UI implementations.
+*
+* **Open Source Friendly** - Works without requiring a `publicApiKey`.
+*/
+function useCopilotChat(options = {}) {
+	const { visibleMessages, appendMessage, reloadMessages, stopGeneration, reset, isLoading, isAvailable, runChatCompletion, mcpServers, setMcpServers } = useCopilotChatInternal(options);
+	return {
+		visibleMessages,
+		appendMessage,
+		reloadMessages,
+		stopGeneration,
+		reset,
+		isLoading,
+		isAvailable,
+		runChatCompletion,
+		mcpServers,
+		setMcpServers
+	};
+}
+
+//#endregion
+//#region src/hooks/use-copilot-chat-headless_c.ts
+/**
+* `useCopilotChatHeadless_c` is for building fully custom UI (headless UI) implementations.
+*
+* <Callout title="This is a premium-only feature">
+* Sign up for free on [Copilot Cloud](https://cloud.copilotkit.ai) to get your public license key or read more about <a href="/premium/overview">premium features</a>.
+*
+* Usage is generous, **free** to get started, and works with **either self-hosted or Copilot Cloud** environments.
+* </Callout>
+*
+* ## Key Features
+*
+* - **Fully headless**: Build your own fully custom UI's for your agentic applications.
+* - **Advanced Suggestions**: Direct access to suggestions array with full control
+* - **Interrupt Handling**: Support for advanced interrupt functionality
+* - **MCP Server Support**: Model Context Protocol server configurations
+* - **Chat Controls**: Complete set of chat management functions
+* - **Loading States**: Comprehensive loading state management
+*
+*
+* ## Usage
+*
+* ### Basic Setup
+*
+* ```tsx
+* import { CopilotKit } from "@copilotkit/react-core";
+* import { useCopilotChatHeadless_c } from "@copilotkit/react-core";
+*
+* export function App() {
+*   return (
+*     <CopilotKit publicApiKey="your-free-public-license-key">
+*       <YourComponent />
+*     </CopilotKit>
+*   );
+* }
+*
+* export function YourComponent() {
+*   const { messages, sendMessage, isLoading } = useCopilotChatHeadless_c();
+*
+*   const handleSendMessage = async () => {
+*     await sendMessage({
+*       id: "123",
+*       role: "user",
+*       content: "Hello World",
+*     });
+*   };
+*
+*   return (
+*     <div>
+*       {messages.map(msg => <div key={msg.id}>{msg.content}</div>)}
+*       <button onClick={handleSendMessage} disabled={isLoading}>
+*         Send Message
+*       </button>
+*     </div>
+*   );
+* }
+* ```
+*
+* ### Working with Suggestions
+*
+* ```tsx
+* import { useCopilotChatHeadless_c, useCopilotChatSuggestions } from "@copilotkit/react-core";
+*
+* export function SuggestionExample() {
+*   const {
+*     suggestions,
+*     setSuggestions,
+*     generateSuggestions,
+*     isLoadingSuggestions
+*   } = useCopilotChatHeadless_c();
+*
+*   // Configure AI suggestion generation
+*   useCopilotChatSuggestions({
+*     instructions: "Suggest helpful actions based on the current context",
+*     maxSuggestions: 3
+*   });
+*
+*   return (
+*     <div>
+*       {suggestions.map(suggestion => (
+*         <button key={suggestion.title}>{suggestion.title}</button>
+*       ))}
+*       <button onClick={generateSuggestions} disabled={isLoadingSuggestions}>
+*         Generate Suggestions
+*       </button>
+*     </div>
+*   );
+* }
+* ```
+*
+* ## Return Values
+* The following properties are returned from the hook:
+*
+* <PropertyReference name="messages" type="Message[]">
+* The messages currently in the chat in AG-UI format
+* </PropertyReference>
+*
+* <PropertyReference name="sendMessage" type="(message: Message, options?) => Promise<void>">
+* Send a new message to the chat and trigger AI response
+* </PropertyReference>
+*
+* <PropertyReference name="setMessages" type="(messages: Message[] | DeprecatedGqlMessage[]) => void">
+* Replace all messages in the chat with new array
+* </PropertyReference>
+*
+* <PropertyReference name="deleteMessage" type="(messageId: string) => void">
+* Remove a specific message by ID from the chat
+* </PropertyReference>
+*
+* <PropertyReference name="reloadMessages" type="(messageId: string) => Promise<void>">
+* Regenerate the response for a specific message by ID
+* </PropertyReference>
+*
+* <PropertyReference name="stopGeneration" type="() => void">
+* Stop the current message generation process
+* </PropertyReference>
+*
+* <PropertyReference name="reset" type="() => void">
+* Clear all messages and reset chat state completely
+* </PropertyReference>
+*
+* <PropertyReference name="isLoading" type="boolean">
+* Whether the chat is currently generating a response
+* </PropertyReference>
+*
+* <PropertyReference name="runChatCompletion" type="() => Promise<Message[]>">
+* Manually trigger chat completion for advanced usage
+* </PropertyReference>
+*
+* <PropertyReference name="mcpServers" type="MCPServerConfig[]">
+* Array of Model Context Protocol server configurations
+* </PropertyReference>
+*
+* <PropertyReference name="setMcpServers" type="(servers: MCPServerConfig[]) => void">
+* Update MCP server configurations for enhanced context
+* </PropertyReference>
+*
+* <PropertyReference name="suggestions" type="SuggestionItem[]">
+* Current suggestions array for reading or manual control
+* </PropertyReference>
+*
+* <PropertyReference name="setSuggestions" type="(suggestions: SuggestionItem[]) => void">
+* Manually set suggestions for custom workflows
+* </PropertyReference>
+*
+* <PropertyReference name="generateSuggestions" type="() => Promise<void>">
+* Trigger AI-powered suggestion generation using configured settings
+* </PropertyReference>
+*
+* <PropertyReference name="resetSuggestions" type="() => void">
+* Clear all current suggestions and reset generation state
+* </PropertyReference>
+*
+* <PropertyReference name="isLoadingSuggestions" type="boolean">
+* Whether suggestions are currently being generated
+* </PropertyReference>
+*
+* <PropertyReference name="interrupt" type="string | React.ReactElement | null">
+* Interrupt content for human-in-the-loop workflows
+* </PropertyReference>
+*/
+const createNonFunctionalReturn = () => ({
+	visibleMessages: [],
+	messages: [],
+	sendMessage: async () => {},
+	appendMessage: async () => {},
+	setMessages: () => {},
+	deleteMessage: () => {},
+	reloadMessages: async () => {},
+	stopGeneration: () => {},
+	reset: () => {},
+	isLoading: false,
+	isAvailable: false,
+	runChatCompletion: async () => [],
+	mcpServers: [],
+	setMcpServers: () => {},
+	suggestions: [],
+	setSuggestions: () => {},
+	generateSuggestions: async () => {},
+	resetSuggestions: () => {},
+	isLoadingSuggestions: false,
+	interrupt: null
+});
+/**
+* Enterprise React hook that provides complete chat functionality for fully custom UI implementations.
+* Includes all advanced features like direct message access, suggestions array, interrupt handling, and MCP support.
+*
+* **Requires a publicApiKey** - Sign up for free at https://cloud.copilotkit.ai/
+*
+* @param options - Configuration options for the chat
+* @returns Complete chat interface with all enterprise features
+*
+* @example
+* ```tsx
+* const { messages, sendMessage, suggestions, interrupt } = useCopilotChatHeadless_c();
+* ```
+*/
+function useCopilotChatHeadless_c(options = {}) {
+	const { copilotApiConfig, setBannerError } = useCopilotContext();
+	const hasPublicApiKey = Boolean(copilotApiConfig.publicApiKey);
+	const internalResult = useCopilotChatInternal(options);
+	useEffect(() => {
+		if (!hasPublicApiKey) {
+			setBannerError(new CopilotKitError({
+				message: "You're using useCopilotChatHeadless_c, a premium-only feature, which offers extensive headless chat capabilities. To continue, you'll need to provide a free public license key.",
+				code: CopilotKitErrorCode.MISSING_PUBLIC_API_KEY_ERROR,
+				severity: Severity.WARNING,
+				visibility: ErrorVisibility.BANNER
+			}));
+			styledConsole.logCopilotKitPlatformMessage();
+		} else setBannerError(null);
+	}, [hasPublicApiKey]);
+	if (hasPublicApiKey) return internalResult;
+	return createNonFunctionalReturn();
+}
+
+//#endregion
+//#region src/hooks/use-frontend-tool.ts
+function useFrontendTool(tool, dependencies) {
+	const { name, description, parameters, render, followUp, available } = tool;
+	const zodParameters = getZodParameters(parameters);
+	const renderRef = useRef(render);
+	useEffect(() => {
+		renderRef.current = render;
+	}, [render, ...dependencies ?? []]);
+	const normalizedRender = useMemo(() => {
+		if (typeof render === "undefined") return;
+		return ((args) => {
+			const currentRender = renderRef.current;
+			if (typeof currentRender === "undefined") return null;
+			if (typeof currentRender === "string") return React.createElement(React.Fragment, null, currentRender);
+			const rendered = currentRender({
+				...args,
+				result: typeof args.result === "string" ? parseJson(args.result, args.result) : args.result
+			});
+			if (typeof rendered === "string") return React.createElement(React.Fragment, null, rendered);
+			return rendered ?? null;
+		});
+	}, []);
+	const handlerRef = useRef(tool.handler);
+	useEffect(() => {
+		handlerRef.current = tool.handler;
+	}, [tool.handler, ...dependencies ?? []]);
+	useFrontendTool$1({
+		name,
+		description,
+		parameters: zodParameters,
+		handler: tool.handler ? (args) => handlerRef.current?.(args) : void 0,
+		followUp,
+		render: normalizedRender,
+		available: available === void 0 ? void 0 : available !== "disabled"
+	});
+}
+
+//#endregion
+//#region src/hooks/use-render-tool-call.ts
+function useRenderToolCall(tool, dependencies) {
+	const { copilotkit } = useCopilotKit();
+	const hasAddedRef = useRef(false);
+	useEffect(() => {
+		const { name, parameters, render } = tool;
+		const zodParameters = getZodParameters(parameters);
+		const renderToolCall = name === "*" ? defineToolCallRenderer({
+			name: "*",
+			render: ((args) => {
+				return render({
+					...args,
+					result: args.result ? parseJson(args.result, args.result) : args.result
+				});
+			})
+		}) : defineToolCallRenderer({
+			name,
+			args: zodParameters,
+			render: ((args) => {
+				return render({
+					...args,
+					result: args.result ? parseJson(args.result, args.result) : args.result
+				});
+			})
+		});
+		const existingIndex = copilotkit.renderToolCalls.findIndex((r) => r.name === name);
+		if (existingIndex !== -1) copilotkit.renderToolCalls.splice(existingIndex, 1);
+		copilotkit.renderToolCalls.push(renderToolCall);
+		hasAddedRef.current = true;
+		return () => {
+			if (hasAddedRef.current) {
+				const index = copilotkit.renderToolCalls.findIndex((r) => r.name === name);
+				if (index !== -1) copilotkit.renderToolCalls.splice(index, 1);
+				hasAddedRef.current = false;
+			}
+		};
+	}, [tool, ...dependencies ?? []]);
+}
+
+//#endregion
+//#region src/hooks/use-human-in-the-loop.ts
+function useHumanInTheLoop(tool, dependencies) {
+	const { render, ...toolRest } = tool;
+	const { name, description, parameters, followUp } = toolRest;
+	const zodParameters = getZodParameters(parameters);
+	const renderRef = useRef(null);
+	useEffect(() => {
+		renderRef.current = (args) => {
+			if (typeof render === "string") return React.createElement(React.Fragment, null, render);
+			if (!render) return null;
+			const rendered = render((() => {
+				const mappedArgs = args.args;
+				switch (args.status) {
+					case ToolCallStatus.InProgress: return {
+						args: mappedArgs,
+						respond: args.respond,
+						status: args.status,
+						handler: void 0
+					};
+					case ToolCallStatus.Executing: return {
+						args: mappedArgs,
+						respond: args.respond,
+						status: args.status,
+						handler: () => {}
+					};
+					case ToolCallStatus.Complete: return {
+						args: mappedArgs,
+						respond: args.respond,
+						status: args.status,
+						result: args.result ? parseJson(args.result, args.result) : args.result,
+						handler: void 0
+					};
+					default: throw new CopilotKitError({
+						code: CopilotKitErrorCode.UNKNOWN,
+						message: `Invalid tool call status: ${args.status}`
+					});
+				}
+			})());
+			if (typeof rendered === "string") return React.createElement(React.Fragment, null, rendered);
+			return rendered ?? null;
+		};
+	}, [render, ...dependencies ?? []]);
+	useHumanInTheLoop$1({
+		name,
+		description,
+		followUp,
+		parameters: zodParameters,
+		render: ((args) => renderRef.current?.(args) ?? null)
+	});
+}
+
+//#endregion
+//#region src/hooks/use-copilot-action.ts
+/**
+* Example usage of useCopilotAction with complex parameters:
+*
+* @example
+* useCopilotAction({
+*   name: "myAction",
+*   parameters: [
+*     { name: "arg1", type: "string", enum: ["option1", "option2", "option3"], required: false },
+*     { name: "arg2", type: "number" },
+*     {
+*       name: "arg3",
+*       type: "object",
+*       attributes: [
+*         { name: "nestedArg1", type: "boolean" },
+*         { name: "xyz", required: false },
+*       ],
+*     },
+*     { name: "arg4", type: "number[]" },
+*   ],
+*   handler: ({ arg1, arg2, arg3, arg4 }) => {
+*     const x = arg3.nestedArg1;
+*     const z = arg3.xyz;
+*     console.log(arg1, arg2, arg3);
+*   },
+* });
+*
+* @example
+* // Simple action without parameters
+* useCopilotAction({
+*   name: "myAction",
+*   handler: () => {
+*     console.log("No parameters provided.");
+*   },
+* });
+*
+* @example
+* // Interactive action with UI rendering and response handling
+* useCopilotAction({
+*   name: "handleMeeting",
+*   description: "Handle a meeting by booking or canceling",
+*   parameters: [
+*     {
+*       name: "meeting",
+*       type: "string",
+*       description: "The meeting to handle",
+*       required: true,
+*     },
+*     {
+*       name: "date",
+*       type: "string",
+*       description: "The date of the meeting",
+*       required: true,
+*     },
+*     {
+*       name: "title",
+*       type: "string",
+*       description: "The title of the meeting",
+*       required: true,
+*     },
+*   ],
+*   renderAndWaitForResponse: ({ args, respond, status }) => {
+*     const { meeting, date, title } = args;
+*     return (
+*       <MeetingConfirmationDialog
+*         meeting={meeting}
+*         date={date}
+*         title={title}
+*         onConfirm={() => respond('meeting confirmed')}
+*         onCancel={() => respond('meeting canceled')}
+*       />
+*     );
+*   },
+* });
+*
+* @example
+* // Catch all action allows you to render actions that are not defined in the frontend
+* useCopilotAction({
+*   name: "*",
+*   render: ({ name, args, status, result, handler, respond }) => {
+*     return <div>Rendering action: {name}</div>;
+*   },
+* });
+*/
+/**
+* <img src="https://cdn.copilotkit.ai/docs/copilotkit/images/use-copilot-action/useCopilotAction.gif" width="500" />
+* `useCopilotAction` is a React hook that you can use in your application to provide
+* custom actions that can be called by the AI. Essentially, it allows the Copilot to
+* execute these actions contextually during a chat, based on the user's interactions
+* and needs.
+*
+* Here's how it works:
+*
+* Use `useCopilotAction` to set up actions that the Copilot can call. To provide
+* more context to the Copilot, you can provide it with a `description` (for example to explain
+* what the action does, under which conditions it can be called, etc.).
+*
+* Then you define the parameters of the action, which can be simple, e.g. primitives like strings or numbers,
+* or complex, e.g. objects or arrays.
+*
+* Finally, you provide a `handler` function that receives the parameters and returns a result.
+* CopilotKit takes care of automatically inferring the parameter types, so you get type safety
+* and autocompletion for free.
+*
+* To render a custom UI for the action, you can provide a `render()` function. This function
+* lets you render a custom component or return a string to display.
+*
+* ## Usage
+*
+* ### Simple Usage
+*
+* ```tsx
+* useCopilotAction({
+*   name: "sayHello",
+*   description: "Say hello to someone.",
+*   parameters: [
+*     {
+*       name: "name",
+*       type: "string",
+*       description: "name of the person to say greet",
+*     },
+*   ],
+*   handler: async ({ name }) => {
+*     alert(`Hello, ${name}!`);
+*   },
+* });
+* ```
+*
+* ## Generative UI
+*
+* This hooks enables you to dynamically generate UI elements and render them in the copilot chat. For more information, check out the [Generative UI](/guides/generative-ui) page.
+*/
+function getActionConfig(action) {
+	if (action.name === "*") return {
+		type: "render",
+		action
+	};
+	if ("renderAndWaitForResponse" in action || "renderAndWait" in action) {
+		let render = action.render;
+		if (!render && "renderAndWaitForResponse" in action) render = action.renderAndWaitForResponse;
+		if (!render && "renderAndWait" in action) render = action.renderAndWait;
+		return {
+			type: "hitl",
+			action: {
+				...action,
+				render
+			}
+		};
+	}
+	if ("available" in action) {
+		if (action.available === "enabled" || action.available === "remote") return {
+			type: "frontend",
+			action
+		};
+		if (action.available === "frontend" || action.available === "disabled") return {
+			type: "render",
+			action
+		};
+	}
+	if ("handler" in action) return {
+		type: "frontend",
+		action
+	};
+	throw new Error("Invalid action configuration");
+}
+/**
+* useCopilotAction is a legacy hook maintained for backwards compatibility.
+*
+* To avoid violating React's Rules of Hooks (which prohibit conditional hook calls),
+* we use a registration pattern:
+* 1. This hook registers the action configuration with the CopilotContext
+* 2. A renderer component in CopilotKit actually renders the appropriate hook wrapper
+* 3. React properly manages hook state since components are rendered, not conditionally called
+*
+* This allows action types to change between renders without corrupting React's hook state.
+*/
+function useCopilotAction(action, dependencies) {
+	const [initialActionConfig] = useState(getActionConfig(action));
+	const currentActionConfig = getActionConfig(action);
+	/**
+	* Calling hooks conditionally violates React's Rules of Hooks. This rule exists because
+	* React maintains the call stack for hooks like useEffect or useState, and conditionally
+	* calling a hook would result in inconsistent call stacks between renders.
+	*
+	* Unfortunately, useCopilotAction _has_ to conditionally call a hook based on the
+	* supplied parameters. In order to avoid breaking React's call stack tracking, while
+	* breaking the Rule of Hooks, we use a ref to store the initial action configuration
+	* and throw an error if the _configuration_ changes such that we would call a different hook.
+	*/
+	if (initialActionConfig.type !== currentActionConfig.type) throw new Error("Action configuration changed between renders");
+	switch (currentActionConfig.type) {
+		case "render": return useRenderToolCall(currentActionConfig.action, dependencies);
+		case "hitl": return useHumanInTheLoop(currentActionConfig.action, dependencies);
+		case "frontend": return useFrontendTool(currentActionConfig.action, dependencies);
+		default: throw new Error("Invalid action configuration");
+	}
+}
+
+//#endregion
+//#region src/hooks/use-coagent-state-render.ts
+/**
+* The useCoAgentStateRender hook allows you to render UI or text based components on a Agentic Copilot's state in the chat.
+* This is particularly useful for showing intermediate state or progress during Agentic Copilot operations.
+*
+* ## Usage
+*
+* ### Simple Usage
+*
+* ```tsx
+* import { useCoAgentStateRender } from "@copilotkit/react-core";
+*
+* type YourAgentState = {
+*   agent_state_property: string;
+* }
+*
+* useCoAgentStateRender<YourAgentState>({
+*   name: "basic_agent",
+*   nodeName: "optionally_specify_a_specific_node",
+*   render: ({ status, state, nodeName }) => {
+*     return (
+*       <YourComponent
+*         agentStateProperty={state.agent_state_property}
+*         status={status}
+*         nodeName={nodeName}
+*       />
+*     );
+*   },
+* });
+* ```
+*
+* This allows for you to render UI components or text based on what is happening within the agent.
+*
+* ### Example
+* A great example of this is in our Perplexity Clone where we render the progress of an agent's internet search as it is happening.
+* You can play around with it below or learn how to build it with its [demo](/coagents/videos/perplexity-clone).
+*
+* <Callout type="info">
+*   This example is hosted on Vercel and may take a few seconds to load.
+* </Callout>
+*
+* <iframe src="https://examples-coagents-ai-researcher-ui.vercel.app/" className="w-full rounded-lg border h-[700px] my-4" />
+*/
+/**
+* This hook is used to render agent state with custom UI components or text. This is particularly
+* useful for showing intermediate state or progress during Agentic Copilot operations.
+* To get started using rendering intermediate state through this hook, checkout the documentation.
+*
+* https://docs.copilotkit.ai/coagents/shared-state/predictive-state-updates
+*/
+function useCoAgentStateRender(action, dependencies) {
+	const { chatComponentsCache, availableAgents } = useContext(CopilotContext);
+	const { setCoAgentStateRender, removeCoAgentStateRender, coAgentStateRenders } = useCoAgentStateRenders();
+	const idRef = useRef(randomId());
+	const { setBannerError, addToast } = useToast();
+	useEffect(() => {
+		if (availableAgents?.length && !availableAgents.some((a) => a.name === action.name)) {
+			`${action.name}`;
+			setBannerError(new CopilotKitAgentDiscoveryError({
+				agentName: action.name,
+				availableAgents: availableAgents.map((a) => ({
+					name: a.name,
+					id: a.id
+				}))
+			}));
+		}
+	}, [availableAgents]);
+	const key = `${action.name}-${action.nodeName || "global"}`;
+	if (dependencies === void 0) {
+		if (coAgentStateRenders[idRef.current]) {
+			coAgentStateRenders[idRef.current].handler = action.handler;
+			if (typeof action.render === "function") {
+				if (chatComponentsCache.current !== null) chatComponentsCache.current.coAgentStateRenders[key] = action.render;
+			}
+		}
+	}
+	useEffect(() => {
+		const currentId = idRef.current;
+		if (Object.entries(coAgentStateRenders).some(([id, otherAction]) => {
+			if (id === currentId) return false;
+			if (otherAction.name !== action.name) return false;
+			const hasNodeName = !!action.nodeName;
+			const hasOtherNodeName = !!otherAction.nodeName;
+			if (!hasNodeName && !hasOtherNodeName) return true;
+			if (hasNodeName !== hasOtherNodeName) return false;
+			return action.nodeName === otherAction.nodeName;
+		})) addToast({
+			type: "warning",
+			message: action.nodeName ? `Found multiple state renders for agent ${action.name} and node ${action.nodeName}. State renders might get overridden` : `Found multiple state renders for agent ${action.name}. State renders might get overridden`,
+			id: `dup-action-${action.name}`
+		});
+	}, [coAgentStateRenders]);
+	useEffect(() => {
+		setCoAgentStateRender(idRef.current, action);
+		if (chatComponentsCache.current !== null && action.render !== void 0) chatComponentsCache.current.coAgentStateRenders[key] = action.render;
+		return () => {
+			removeCoAgentStateRender(idRef.current);
+		};
+	}, [
+		setCoAgentStateRender,
+		removeCoAgentStateRender,
+		action.name,
+		typeof action.render === "string" ? action.render : void 0,
+		...dependencies || []
+	]);
+}
+
+//#endregion
+//#region src/hooks/use-make-copilot-document-readable.ts
+/**
+* Makes a document readable by Copilot.
+* @param document The document to make readable.
+* @param categories The categories to associate with the document.
+* @param dependencies The dependencies to use for the effect.
+* @returns The id of the document.
+*/
+function useMakeCopilotDocumentReadable(document, categories, dependencies = []) {
+	const { addDocumentContext, removeDocumentContext } = useCopilotContext();
+	const idRef = useRef(void 0);
+	useEffect(() => {
+		const id = addDocumentContext(document, categories);
+		idRef.current = id;
+		return () => {
+			removeDocumentContext(id);
+		};
+	}, [
+		addDocumentContext,
+		removeDocumentContext,
+		...dependencies
+	]);
+	return idRef.current;
+}
+
+//#endregion
+//#region src/hooks/use-copilot-readable.ts
+/**
+* `useCopilotReadable` is a React hook that provides app-state and other information
+* to the Copilot. Optionally, the hook can also handle hierarchical state within your
+* application, passing these parent-child relationships to the Copilot.
+*
+* ## Usage
+*
+* ### Simple Usage
+*
+* In its most basic usage, useCopilotReadable accepts a single string argument
+* representing any piece of app state, making it available for the Copilot to use
+* as context when responding to user input.
+*
+* ```tsx
+* import { useCopilotReadable } from "@copilotkit/react-core";
+*
+* export function MyComponent() {
+*   const [employees, setEmployees] = useState([]);
+*
+*   useCopilotReadable({
+*     description: "The list of employees",
+*     value: employees,
+*   });
+* }
+* ```
+*
+* ### Nested Components
+*
+* Optionally, you can maintain the hierarchical structure of information by passing
+* `parentId`. This allows you to use `useCopilotReadable` in nested components:
+*
+* ```tsx /employeeContextId/1 {17,23}
+* import { useCopilotReadable } from "@copilotkit/react-core";
+*
+* function Employee(props: EmployeeProps) {
+*   const { employeeName, workProfile, metadata } = props;
+*
+*   // propagate any information to copilot
+*   const employeeContextId = useCopilotReadable({
+*     description: "Employee name",
+*     value: employeeName
+*   });
+*
+*   // Pass a parentID to maintain a hierarchical structure.
+*   // Especially useful with child React components, list elements, etc.
+*   useCopilotReadable({
+*     description: "Work profile",
+*     value: workProfile.description(),
+*     parentId: employeeContextId
+*   });
+*
+*   useCopilotReadable({
+*     description: "Employee metadata",
+*     value: metadata.description(),
+*     parentId: employeeContextId
+*   });
+*
+*   return (
+*     // Render as usual...
+*   );
+* }
+* ```
+*/
+/**
+* Adds the given information to the Copilot context to make it readable by Copilot.
+*/
+function useCopilotReadable({ description, value, convert, available }, dependencies) {
+	const { copilotkit } = useCopilotKit();
+	const ctxIdRef = useRef(void 0);
+	useEffect(() => {
+		if (!copilotkit) return;
+		const found = Object.entries(copilotkit.context).find(([id, ctxItem]) => {
+			return JSON.stringify({
+				description,
+				value
+			}) == JSON.stringify(ctxItem);
+		});
+		if (found) {
+			ctxIdRef.current = found[0];
+			if (available === "disabled") copilotkit.removeContext(ctxIdRef.current);
+			return;
+		}
+		if (!found && available === "disabled") return;
+		ctxIdRef.current = copilotkit.addContext({
+			description,
+			value: (convert ?? JSON.stringify)(value)
+		});
+		return () => {
+			if (!ctxIdRef.current) return;
+			copilotkit.removeContext(ctxIdRef.current);
+		};
+	}, [
+		description,
+		value,
+		convert
+	]);
+	return ctxIdRef.current;
+}
+
+//#endregion
+//#region src/hooks/use-coagent.ts
+/**
+* <Callout type="info">
+*   Usage of this hook assumes some additional setup in your application, for more information
+*   on that see the CoAgents <span className="text-blue-500">[getting started guide](/coagents/quickstart/langgraph)</span>.
+* </Callout>
+* <Frame className="my-12">
+*   <img
+*     src="https://cdn.copilotkit.ai/docs/copilotkit/images/coagents/SharedStateCoAgents.gif"
+*     alt="CoAgents demonstration"
+*     className="w-auto"
+*   />
+* </Frame>
+*
+* This hook is used to integrate an agent into your application. With its use, you can
+* render and update the state of an agent, allowing for a dynamic and interactive experience.
+* We call these shared state experiences agentic copilots, or CoAgents for short.
+*
+* ## Usage
+*
+* ### Simple Usage
+*
+* ```tsx
+* import { useCoAgent } from "@copilotkit/react-core";
+*
+* type AgentState = {
+*   count: number;
+* }
+*
+* const agent = useCoAgent<AgentState>({
+*   name: "my-agent",
+*   initialState: {
+*     count: 0,
+*   },
+* });
+*
+* ```
+*
+* `useCoAgent` returns an object with the following properties:
+*
+* ```tsx
+* const {
+*   name,     // The name of the agent currently being used.
+*   nodeName, // The name of the current LangGraph node.
+*   state,    // The current state of the agent.
+*   setState, // A function to update the state of the agent.
+*   running,  // A boolean indicating if the agent is currently running.
+*   start,    // A function to start the agent.
+*   stop,     // A function to stop the agent.
+*   run,      // A function to re-run the agent. Takes a HintFunction to inform the agent why it is being re-run.
+* } = agent;
+* ```
+*
+* Finally we can leverage these properties to create reactive experiences with the agent!
+*
+* ```tsx
+* const { state, setState } = useCoAgent<AgentState>({
+*   name: "my-agent",
+*   initialState: {
+*     count: 0,
+*   },
+* });
+*
+* return (
+*   <div>
+*     <p>Count: {state.count}</p>
+*     <button onClick={() => setState({ count: state.count + 1 })}>Increment</button>
+*   </div>
+* );
+* ```
+*
+* This reactivity is bidirectional, meaning that changes to the state from the agent will be reflected in the UI and vice versa.
+*
+* ## Parameters
+* <PropertyReference name="options" type="UseCoagentOptions<T>" required>
+*   The options to use when creating the coagent.
+*   <PropertyReference name="name" type="string" required>
+*     The name of the agent to use.
+*   </PropertyReference>
+*   <PropertyReference name="initialState" type="T | any">
+*     The initial state of the agent.
+*   </PropertyReference>
+*   <PropertyReference name="state" type="T | any">
+*     State to manage externally if you are using this hook with external state management.
+*   </PropertyReference>
+*   <PropertyReference name="setState" type="(newState: T | ((prevState: T | undefined) => T)) => void">
+*     A function to update the state of the agent if you are using this hook with external state management.
+*   </PropertyReference>
+* </PropertyReference>
+*/
+/**
+* This hook is used to integrate an agent into your application. With its use, you can
+* render and update the state of the agent, allowing for a dynamic and interactive experience.
+* We call these shared state experiences "agentic copilots". To get started using agentic copilots, which
+* we refer to as CoAgents, checkout the documentation at https://docs.copilotkit.ai/coagents/quickstart/langgraph.
+*/
+function useCoAgent(options) {
+	const { agent } = useAgent({ agentId: options.name });
+	const { copilotkit } = useCopilotKit();
+	const nodeName = useAgentNodeName(options.name);
+	const handleStateUpdate = useCallback((newState) => {
+		if (!agent) return;
+		if (typeof newState === "function") {
+			const updater = newState;
+			agent.setState(updater(agent.state));
+		} else agent.setState({
+			...agent.state,
+			...newState
+		});
+	}, [agent?.state, agent?.setState]);
+	useEffect(() => {
+		if (!options.config && !options.configurable) return;
+		let config = options.config ?? {};
+		if (options.configurable) config = {
+			...config,
+			configurable: {
+				...options.configurable,
+				...config.configurable
+			}
+		};
+		copilotkit.setProperties(config);
+	}, [options.config, options.configurable]);
+	useEffect(() => {
+		if (agent?.state && isExternalStateManagement(options) && JSON.stringify(options.state) !== JSON.stringify(agent.state)) handleStateUpdate(options.state);
+	}, [
+		agent,
+		useMemo(() => isExternalStateManagement(options) ? JSON.stringify(options.state) : void 0, [isExternalStateManagement(options) ? JSON.stringify(options.state) : void 0]),
+		handleStateUpdate
+	]);
+	const hasStateValues = useCallback((value) => {
+		return Boolean(value && Object.keys(value).length);
+	}, []);
+	const initialStateRef = useRef(isExternalStateManagement(options) ? options.state : "initialState" in options ? options.initialState : void 0);
+	useEffect(() => {
+		if (isExternalStateManagement(options)) initialStateRef.current = options.state;
+		else if ("initialState" in options) initialStateRef.current = options.initialState;
+	}, [isExternalStateManagement(options) ? JSON.stringify(options.state) : "initialState" in options ? JSON.stringify(options.initialState) : void 0]);
+	useEffect(() => {
+		if (!agent) return;
+		const subscription = agent.subscribe({
+			onStateChanged: (args) => {
+				if (isExternalStateManagement(options)) options.setState(args.state);
+			},
+			onRunInitialized: (args) => {
+				if (hasStateValues(args.state)) {
+					handleStateUpdate(args.state);
+					return;
+				}
+				if (hasStateValues(agent.state)) return;
+				if (initialStateRef.current !== void 0) handleStateUpdate(initialStateRef.current);
+			}
+		});
+		return () => {
+			subscription.unsubscribe();
+		};
+	}, [
+		agent,
+		handleStateUpdate,
+		hasStateValues
+	]);
+	return useMemo(() => {
+		if (!agent) {
+			const noop = () => {};
+			const noopAsync = async () => {};
+			const initialState = ("state" in options && options.state) ?? ("initialState" in options && options.initialState) ?? {};
+			return {
+				name: options.name,
+				nodeName,
+				threadId: void 0,
+				running: false,
+				state: initialState,
+				setState: noop,
+				start: noop,
+				stop: noop,
+				run: noopAsync
+			};
+		}
+		return {
+			name: agent?.agentId ?? options.name,
+			nodeName,
+			threadId: agent.threadId,
+			running: agent.isRunning,
+			state: agent.state,
+			setState: handleStateUpdate,
+			start: agent.runAgent,
+			stop: agent.abortRun,
+			run: agent.runAgent
+		};
+	}, [
+		agent?.state,
+		agent?.runAgent,
+		agent?.abortRun,
+		agent?.runAgent,
+		agent?.threadId,
+		agent?.isRunning,
+		agent?.agentId,
+		handleStateUpdate,
+		options.name
+	]);
+}
+const isExternalStateManagement = (options) => {
+	return "state" in options && "setState" in options;
+};
+
+//#endregion
+//#region src/hooks/use-copilot-runtime-client.ts
+const useCopilotRuntimeClient = (options) => {
+	const { setBannerError } = useToast();
+	const { showDevConsole, onError, ...runtimeOptions } = options;
+	const lastStructuredErrorRef = useRef(null);
+	const traceUIError = async (error, originalError) => {
+		try {
+			await onError({
+				type: "error",
+				timestamp: Date.now(),
+				context: {
+					source: "ui",
+					request: {
+						operation: "runtimeClient",
+						url: runtimeOptions.url,
+						startTime: Date.now()
+					},
+					technical: {
+						environment: "browser",
+						userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+						stackTrace: originalError instanceof Error ? originalError.stack : void 0
+					}
+				},
+				error
+			});
+		} catch (error) {
+			console.error("Error in onError handler:", error);
+		}
+	};
+	return useMemo(() => {
+		return new CopilotRuntimeClient({
+			...runtimeOptions,
+			handleGQLErrors: (error) => {
+				if (error.graphQLErrors?.length) {
+					const graphQLErrors = error.graphQLErrors;
+					const routeError = (gqlError) => {
+						if (gqlError.extensions?.visibility === ErrorVisibility.SILENT) {
+							console.error("CopilotKit Silent Error:", gqlError.message);
+							return;
+						}
+						const now = Date.now();
+						const errorMessage = gqlError.message;
+						if (lastStructuredErrorRef.current && lastStructuredErrorRef.current.message === errorMessage && now - lastStructuredErrorRef.current.timestamp < 150) return;
+						lastStructuredErrorRef.current = {
+							message: errorMessage,
+							timestamp: now
+						};
+						const ckError = createStructuredError(gqlError);
+						if (ckError) {
+							setBannerError(ckError);
+							traceUIError(ckError, gqlError);
+						} else {
+							const fallbackError = new CopilotKitError({
+								message: gqlError.message,
+								code: CopilotKitErrorCode.UNKNOWN
+							});
+							setBannerError(fallbackError);
+							traceUIError(fallbackError, gqlError);
+						}
+					};
+					graphQLErrors.forEach(routeError);
+				} else {
+					const fallbackError = new CopilotKitError({
+						message: error?.message || String(error),
+						code: CopilotKitErrorCode.UNKNOWN
+					});
+					setBannerError(fallbackError);
+					traceUIError(fallbackError, error);
+				}
+			},
+			handleGQLWarning: (message) => {
+				console.warn(message);
+				setBannerError(new CopilotKitError({
+					message,
+					code: CopilotKitErrorCode.UNKNOWN
+				}));
+			}
+		});
+	}, [
+		runtimeOptions,
+		setBannerError,
+		onError
+	]);
+};
+function createStructuredError(gqlError) {
+	const extensions = gqlError.extensions;
+	const originalError = extensions?.originalError;
+	const message = originalError?.message || gqlError.message;
+	const code = extensions?.code;
+	if (code) return new CopilotKitError({
+		message,
+		code
+	});
+	if (originalError?.stack?.includes("CopilotApiDiscoveryError")) return new CopilotKitApiDiscoveryError({ message });
+	if (originalError?.stack?.includes("CopilotKitRemoteEndpointDiscoveryError")) return new CopilotKitRemoteEndpointDiscoveryError({ message });
+	if (originalError?.stack?.includes("CopilotKitAgentDiscoveryError")) return new CopilotKitAgentDiscoveryError({
+		agentName: "",
+		availableAgents: []
+	});
+	return null;
+}
+
+//#endregion
+//#region src/hooks/use-copilot-authenticated-action.ts
+/**
+* Hook to create an authenticated action that requires user sign-in before execution.
+*
+* @remarks
+* This feature is only available when using CopilotKit's hosted cloud service.
+* To use this feature, sign up at https://cloud.copilotkit.ai to get your publicApiKey.
+*
+* @param action - The frontend action to be wrapped with authentication
+* @param dependencies - Optional array of dependencies that will trigger recreation of the action when changed
+*/
+function useCopilotAuthenticatedAction_c(action, dependencies) {
+	const { authConfig_c, authStates_c, setAuthStates_c } = useCopilotContext();
+	const pendingActionRef = useRef(null);
+	const executeAction = useCallback((props) => {
+		if (typeof action.render === "function") return action.render(props);
+		return action.render || React.createElement(Fragment);
+	}, [action]);
+	const wrappedRender = useCallback((props) => {
+		if (!Object.values(authStates_c || {}).some((state) => state.status === "authenticated")) {
+			pendingActionRef.current = props;
+			return authConfig_c?.SignInComponent ? React.createElement(authConfig_c.SignInComponent, { onSignInComplete: (authState) => {
+				setAuthStates_c?.((prev) => ({
+					...prev,
+					[action.name]: authState
+				}));
+				if (pendingActionRef.current) {
+					executeAction(pendingActionRef.current);
+					pendingActionRef.current = null;
+				}
+			} }) : React.createElement(Fragment);
+		}
+		return executeAction(props);
+	}, [
+		action,
+		authStates_c,
+		setAuthStates_c
+	]);
+	useCopilotAction({
+		...action,
+		render: wrappedRender
+	}, dependencies);
+}
+
+//#endregion
+//#region src/hooks/use-langgraph-interrupt.ts
+function useLangGraphInterrupt(action, dependencies) {
+	const { setInterruptAction, removeInterruptAction, interruptActions, threadId } = useContext(CopilotContext);
+	const { addToast } = useToast();
+	const actionId = dataToUUID(action, "lgAction");
+	useEffect(() => {
+		if (!action) return;
+		setInterruptAction({
+			...action,
+			id: actionId
+		});
+		return () => {
+			removeInterruptAction(actionId);
+		};
+	}, [
+		setInterruptAction,
+		removeInterruptAction,
+		threadId,
+		actionId,
+		...dependencies || []
+	]);
+}
+
+//#endregion
+//#region src/hooks/use-copilot-additional-instructions.ts
+/**
+* `useCopilotAdditionalInstructions` is a React hook that provides additional instructions
+* to the Copilot.
+*
+* ## Usage
+*
+* ### Simple Usage
+*
+* In its most basic usage, useCopilotAdditionalInstructions accepts a single string argument
+* representing the instructions to be added to the Copilot.
+*
+* ```tsx
+* import { useCopilotAdditionalInstructions } from "@copilotkit/react-core";
+*
+* export function MyComponent() {
+*   useCopilotAdditionalInstructions({
+*     instructions: "Do not answer questions about the weather.",
+*   });
+* }
+* ```
+*
+* ### Conditional Usage
+*
+* You can also conditionally add instructions based on the state of your app.
+*
+* ```tsx
+* import { useCopilotAdditionalInstructions } from "@copilotkit/react-core";
+*
+* export function MyComponent() {
+*   const [showInstructions, setShowInstructions] = useState(false);
+*
+*   useCopilotAdditionalInstructions({
+*     available: showInstructions ? "enabled" : "disabled",
+*     instructions: "Do not answer questions about the weather.",
+*   });
+* }
+* ```
+*/
+/**
+* Adds the given instructions to the Copilot context.
+*/
+function useCopilotAdditionalInstructions({ instructions, available = "enabled" }, dependencies) {
+	const { setAdditionalInstructions } = useCopilotContext();
+	useEffect(() => {
+		if (available === "disabled") return;
+		setAdditionalInstructions((prevInstructions) => [...prevInstructions || [], instructions]);
+		return () => {
+			setAdditionalInstructions((prevInstructions) => prevInstructions?.filter((instruction) => instruction !== instructions) || []);
+		};
+	}, [
+		available,
+		instructions,
+		setAdditionalInstructions,
+		...dependencies || []
+	]);
+}
+
+//#endregion
+//#region src/hooks/use-default-tool.ts
+function useDefaultTool(tool, dependencies) {
+	useCopilotAction({
+		...tool,
+		name: "*"
+	}, dependencies);
+}
+
+//#endregion
+//#region src/hooks/use-copilot-chat-suggestions.tsx
+/**
+* <Callout type="warning">
+*   useCopilotChatSuggestions is experimental. The interface is not final and
+*   can change without notice.
+* </Callout>
+*
+* `useCopilotReadable` is a React hook that provides app-state and other information
+* to the Copilot. Optionally, the hook can also handle hierarchical state within your
+* application, passing these parent-child relationships to the Copilot.
+*
+* <br/>
+* <img src="https://cdn.copilotkit.ai/docs/copilotkit/images/use-copilot-chat-suggestions/use-copilot-chat-suggestions.gif" width="500" />
+*
+* ## Usage
+*
+* ### Install Dependencies
+*
+* This component is part of the [@copilotkit/react-ui](https://npmjs.com/package/@copilotkit/react-ui) package.
+*
+* ```shell npm2yarn \"@copilotkit/react-ui"\
+* npm install @copilotkit/react-core @copilotkit/react-ui
+* ```
+*
+* ### Simple Usage
+*
+* ```tsx
+* import { useCopilotChatSuggestions } from "@copilotkit/react-ui";
+*
+* export function MyComponent() {
+*   const [employees, setEmployees] = useState([]);
+*
+*   useCopilotChatSuggestions({
+*     instructions: `The following employees are on duty: ${JSON.stringify(employees)}`,
+*   });
+* }
+* ```
+*
+* ### Dependency Management
+*
+* ```tsx
+* import { useCopilotChatSuggestions } from "@copilotkit/react-ui";
+*
+* export function MyComponent() {
+*   useCopilotChatSuggestions(
+*     {
+*       instructions: "Suggest the most relevant next actions.",
+*     },
+*     [appState],
+*   );
+* }
+* ```
+*
+* In the example above, the suggestions are generated based on the given instructions.
+* The hook monitors `appState`, and updates suggestions accordingly whenever it changes.
+*
+* ### Behavior and Lifecycle
+*
+* The hook registers the configuration with the chat context upon component mount and
+* removes it on unmount, ensuring a clean and efficient lifecycle management.
+*/
+function useCopilotChatSuggestions(config, dependencies = []) {
+	const resolvedAgentId = useCopilotChatConfiguration()?.agentId ?? "default";
+	const available = (config.available === "enabled" ? "always" : config.available) ?? "before-first-message";
+	useConfigureSuggestions({
+		...config,
+		available,
+		consumerAgentId: resolvedAgentId
+	}, dependencies);
+}
+
+//#endregion
+//#region src/types/frontend-action.ts
+function processActionsForRuntimeRequest(actions) {
+	return actions.filter((action) => action.available !== ActionInputAvailability.Disabled && action.disabled !== true && action.name !== "*" && action.available != "frontend" && !action.pairedAction).map((action) => {
+		let available = ActionInputAvailability.Enabled;
+		if (action.disabled) available = ActionInputAvailability.Disabled;
+		else if (action.available === "disabled") available = ActionInputAvailability.Disabled;
+		else if (action.available === "remote") available = ActionInputAvailability.Remote;
+		return {
+			name: action.name,
+			description: action.description || "",
+			jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters || [])),
+			available
+		};
+	});
+}
+
+//#endregion
+//#region src/lib/copilot-task.ts
+/**
+* This class is used to execute one-off tasks, for example on button press. It can use the context available via [useCopilotReadable](/reference/v1/hooks/useCopilotReadable) and the actions provided by [useCopilotAction](/reference/v1/hooks/useCopilotAction), or you can provide your own context and actions.
+*
+* ## Example
+* In the simplest case, use CopilotTask in the context of your app by giving it instructions on what to do.
+*
+* ```tsx
+* import { CopilotTask, useCopilotContext } from "@copilotkit/react-core";
+*
+* export function MyComponent() {
+*   const context = useCopilotContext();
+*
+*   const task = new CopilotTask({
+*     instructions: "Set a random message",
+*     actions: [
+*       {
+*         name: "setMessage",
+*       description: "Set the message.",
+*       argumentAnnotations: [
+*         {
+*           name: "message",
+*           type: "string",
+*           description:
+*             "A message to display.",
+*           required: true,
+*         },
+*       ],
+*      }
+*     ]
+*   });
+*
+*   const executeTask = async () => {
+*     await task.run(context, action);
+*   }
+*
+*   return (
+*     <>
+*       <button onClick={executeTask}>
+*         Execute task
+*       </button>
+*     </>
+*   )
+* }
+* ```
+*
+* Have a look at the [Presentation Example App](https://github.com/CopilotKit/CopilotKit/blob/main/src/v1.x/examples/next-openai/src/app/presentation/page.tsx) for a more complete example.
+*/
+var CopilotTask = class {
+	constructor(config) {
+		this.instructions = config.instructions;
+		this.actions = config.actions || [];
+		this.includeCopilotReadable = config.includeCopilotReadable !== false;
+		this.includeCopilotActions = config.includeCopilotActions !== false;
+		this.forwardedParameters = config.forwardedParameters;
+	}
+	/**
+	* Run the task.
+	* @param context The CopilotContext to use for the task. Use `useCopilotContext` to obtain the current context.
+	* @param data The data to use for the task.
+	*/
+	async run(context, data) {
+		const actions = this.includeCopilotActions ? Object.assign({}, context.actions) : {};
+		for (const fn of this.actions) actions[fn.name] = fn;
+		let contextString = "";
+		if (data) contextString = (typeof data === "string" ? data : JSON.stringify(data)) + "\n\n";
+		if (this.includeCopilotReadable) contextString += context.getContextString([], defaultCopilotContextCategories);
+		const messages = [new TextMessage({
+			content: taskSystemMessage(contextString, this.instructions),
+			role: Role.System
+		})];
+		const response = await new CopilotRuntimeClient({
+			url: context.copilotApiConfig.chatApiEndpoint,
+			publicApiKey: context.copilotApiConfig.publicApiKey,
+			headers: context.copilotApiConfig.headers,
+			credentials: context.copilotApiConfig.credentials
+		}).generateCopilotResponse({
+			data: {
+				frontend: {
+					actions: processActionsForRuntimeRequest(Object.values(actions)),
+					url: window.location.href
+				},
+				messages: convertMessagesToGqlInput(filterAgentStateMessages(messages)),
+				metadata: { requestType: CopilotRequestType.Task },
+				forwardedParameters: {
+					toolChoice: "required",
+					...this.forwardedParameters ?? {}
+				}
+			},
+			properties: context.copilotApiConfig.properties
+		}).toPromise();
+		const functionCallHandler = context.getFunctionCallHandler(actions);
+		const functionCalls = convertGqlOutputToMessages(response.data?.generateCopilotResponse?.messages || []).filter((m) => m.isActionExecutionMessage());
+		for (const functionCall of functionCalls) await functionCallHandler({
+			messages,
+			name: functionCall.name,
+			args: functionCall.arguments
+		});
+	}
+};
+function taskSystemMessage(contextString, instructions) {
+	return `
+Please act as an efficient, competent, conscientious, and industrious professional assistant.
+
+Help the user achieve their goals, and you do so in a way that is as efficient as possible, without unnecessary fluff, but also without sacrificing professionalism.
+Always be polite and respectful, and prefer brevity over verbosity.
+
+The user has provided you with the following context:
+\`\`\`
+${contextString}
+\`\`\`
+
+They have also provided you with functions you can call to initiate actions on their behalf.
+
+Please assist them as best you can.
+
+This is not a conversation, so please do not ask questions. Just call a function without saying anything else.
+
+The user has given you the following task to complete:
+
+\`\`\`
+${instructions}
+\`\`\`
+`;
+}
+
+//#endregion
+export { CoAgentStateRendersContext, CoAgentStateRendersProvider, CopilotContext, CopilotKit, CopilotMessagesContext, CopilotTask, SUGGESTION_RETRY_CONFIG, ThreadsContext, ThreadsProvider, defaultCopilotContextCategories, shouldShowDevConsole, useCoAgent, useCoAgentStateRender, useCoAgentStateRenders, useCopilotAction, useCopilotAdditionalInstructions, useCopilotAuthenticatedAction_c, useCopilotChat, useCopilotChatHeadless_c, useCopilotChatInternal, useCopilotChatSuggestions, useCopilotContext, useCopilotMessagesContext, useCopilotReadable, useCopilotRuntimeClient, useDefaultTool, useFrontendTool, useHumanInTheLoop, useLangGraphInterrupt, useLangGraphInterruptRender, useLazyToolRenderer, useMakeCopilotDocumentReadable, useRenderToolCall, useThreads };
 //# sourceMappingURL=index.mjs.map