@copilotkit/react-core 1.53.0-next.6 → 1.53.1-next.0

package/dist/copilotkit-Yh_Ld_FX.mjs

@@ -0,0 +1,2031 @@
+import React, { createContext, useCallback, useContext, useEffect, useMemo, useReducer, useRef, useState } from "react";
+import { CopilotChatConfigurationProvider, CopilotKitProvider, useAgent, useCopilotChatConfiguration, useCopilotKit } 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, dataToUUID, parseJson, randomId, randomUUID } from "@copilotkit/shared";
+import { flushSync } from "react-dom";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import ReactMarkdown from "react-markdown";
+
+//#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/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: props.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]);
+	const copilotContextValue = useMemo(() => ({
+		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
+	}), [
+		actions,
+		chatComponentsCache,
+		getFunctionCallHandler,
+		setAction,
+		removeAction,
+		handleSetRegisteredActions,
+		handleRemoveRegisteredAction,
+		getContextString,
+		addContext,
+		removeContext,
+		getAllContext,
+		getDocumentsContext,
+		addDocumentContext,
+		removeDocumentContext,
+		copilotApiConfig,
+		isLoading,
+		chatSuggestionConfiguration,
+		addChatSuggestionConfiguration,
+		removeChatSuggestionConfiguration,
+		chatInstructions,
+		additionalInstructions,
+		showDevConsole,
+		coagentStates,
+		setCoagentStatesWithRef,
+		agentSession,
+		setAgentSession,
+		forwardedParameters,
+		agentLock,
+		threadId,
+		setThreadId,
+		runId,
+		availableAgents,
+		props.authConfig_c,
+		authStates,
+		updateAuthStates,
+		extensions,
+		updateExtensions,
+		interruptActions,
+		setInterruptAction,
+		removeInterruptAction,
+		interruptEventQueue,
+		addInterruptEvent,
+		resolveInterruptEvent,
+		bannerError,
+		handleErrors,
+		internalErrorHandlers,
+		setInternalErrorHandler,
+		removeInternalErrorHandler
+	]);
+	return /* @__PURE__ */ jsx(CopilotChatConfigurationProvider, {
+		agentId: props.agent ?? "default",
+		threadId,
+		children: /* @__PURE__ */ jsxs(CopilotContext.Provider, {
+			value: copilotContextValue,
+			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
+export { ThreadsProvider as a, CoAgentStateRendersProvider as c, shouldShowDevConsole as d, useToast as f, useCopilotContext as g, CopilotContext as h, ThreadsContext as i, useCoAgentStateRenders as l, useCopilotMessagesContext as m, defaultCopilotContextCategories as n, useThreads as o, CopilotMessagesContext as p, CoAgentStateRenderBridge as r, CoAgentStateRendersContext as s, CopilotKit as t, useAsyncCallback as u };
+//# sourceMappingURL=copilotkit-Yh_Ld_FX.mjs.map