@copilotkit/react-core 1.53.0 → 1.53.1-next.1

package/dist/copilotkit-C94ayZbs.cjs

@@ -0,0 +1,2161 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let react = require("react");
+react = __toESM(react);
+let _copilotkitnext_react = require("@copilotkitnext/react");
+let _copilotkit_shared = require("@copilotkit/shared");
+let react_dom = require("react-dom");
+let react_jsx_runtime = require("react/jsx-runtime");
+let react_markdown = require("react-markdown");
+react_markdown = __toESM(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.default.createContext(emptyCopilotContext$1);
+function useCopilotContext() {
+	const context = react.default.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] = (0, react.useReducer)(treeReducer, []);
+	const addElement = (0, react.useCallback)((value, categories, parentId) => {
+		const newNodeId = (0, _copilotkit_shared.randomId)();
+		dispatch({
+			type: "ADD_NODE",
+			value,
+			parentId,
+			id: newNodeId,
+			categories
+		});
+		return newNodeId;
+	}, []);
+	const removeElement = (0, react.useCallback)((id) => {
+		dispatch({
+			type: "REMOVE_NODE",
+			id
+		});
+	}, []);
+	const getAllElements = (0, react.useCallback)(() => {
+		return tree;
+	}, [tree]);
+	return {
+		tree,
+		addElement,
+		printTree: (0, react.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] = (0, react.useReducer)(flatCategoryStoreReducer, /* @__PURE__ */ new Map());
+	return {
+		addElement: (0, react.useCallback)((value, categories) => {
+			const newId = (0, _copilotkit_shared.randomId)();
+			dispatch({
+				type: "ADD_ELEMENT",
+				value,
+				id: newId,
+				categories
+			});
+			return newId;
+		}, []),
+		removeElement: (0, react.useCallback)((id) => {
+			dispatch({
+				type: "REMOVE_ELEMENT",
+				id
+			});
+		}, []),
+		allElements: (0, react.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.default.createContext(emptyCopilotContext);
+function useCopilotMessagesContext() {
+	const context = react.default.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 = (0, react.createContext)(void 0);
+function getErrorSeverity(error) {
+	if (error.severity) switch (error.severity) {
+		case _copilotkit_shared.Severity.CRITICAL: return "critical";
+		case _copilotkit_shared.Severity.WARNING: return "warning";
+		case _copilotkit_shared.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 = (0, react.useContext)(ToastContext);
+	if (!context) throw new Error("useToast must be used within a ToastProvider");
+	return context;
+}
+function ToastProvider({ enabled, children }) {
+	const [toasts, setToasts] = (0, react.useState)([]);
+	const [bannerError, setBannerErrorState] = (0, react.useState)(null);
+	const removeToast = (0, react.useCallback)((id) => {
+		setToasts((prev) => prev.filter((toast) => toast.id !== id));
+	}, []);
+	const addToast = (0, react.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 = (0, react.useCallback)((error) => {
+		if (!enabled && error !== null) return;
+		setBannerErrorState(error);
+	}, [enabled]);
+	const value = {
+		toasts,
+		addToast,
+		addGraphQLErrorsToast: (0, react.useCallback)((errors) => {
+			console.warn("addGraphQLErrorsToast is deprecated. All errors now show as banners.");
+		}, []),
+		removeToast,
+		enabled,
+		bannerError,
+		setBannerError
+	};
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(ToastContext.Provider, {
+		value,
+		children: [bannerError && (() => {
+			const colors = getErrorColors(getErrorSeverity(bannerError));
+			return /* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: {
+						display: "flex",
+						justifyContent: "space-between",
+						alignItems: "center",
+						gap: "10px"
+					},
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							display: "flex",
+							alignItems: "center",
+							gap: "8px",
+							flex: 1,
+							minWidth: 0
+						},
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", { style: {
+							width: "12px",
+							height: "12px",
+							borderRadius: "50%",
+							backgroundColor: colors.border,
+							flexShrink: 0
+						} }), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							style: {
+								display: "flex",
+								alignItems: "center",
+								gap: "10px",
+								flex: 1,
+								minWidth: 0
+							},
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.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 = (0, react.createContext)(null);
+function useMessagesTap() {
+	const tap = (0, react.useContext)(MessagesTapContext);
+	if (!tap) throw new Error("useMessagesTap must be used inside <MessagesTapProvider>");
+	return tap;
+}
+function MessagesTapProvider({ children }) {
+	const messagesRef = (0, react.useRef)([]);
+	const tapRef = (0, react.useRef)({
+		getMessagesFromTap: () => messagesRef.current,
+		updateTapMessages: (messages) => {
+			messagesRef.current = messages;
+		}
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MessagesTapContext.Provider, {
+		value: tapRef.current,
+		children
+	});
+}
+/**
+* CopilotKit messages context.
+*/
+function CopilotMessages({ children }) {
+	const [messages, setMessages] = (0, react.useState)([]);
+	(0, react.useRef)(void 0);
+	(0, react.useRef)(void 0);
+	(0, react.useRef)(void 0);
+	const { updateTapMessages } = useMessagesTap();
+	const { threadId, agentSession, showDevConsole, onError, copilotApiConfig } = useCopilotContext();
+	const { setBannerError } = useToast();
+	const traceUIError = (0, react.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 _copilotkit_shared.CopilotKitApiDiscoveryError({ message: originalError.message });
+			if (originalError.stack.includes("CopilotKitRemoteEndpointDiscoveryError")) return new _copilotkit_shared.CopilotKitRemoteEndpointDiscoveryError({ message: originalError.message });
+			if (originalError.stack.includes("CopilotKitAgentDiscoveryError")) return new _copilotkit_shared.CopilotKitAgentDiscoveryError({
+				agentName: "",
+				availableAgents: []
+			});
+		}
+		const message = originalError?.message || gqlError.message;
+		const code = extensions?.code;
+		if (code) return new _copilotkit_shared.CopilotKitError({
+			message,
+			code
+		});
+		return null;
+	};
+	(0, react.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 === _copilotkit_shared.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 _copilotkit_shared.CopilotKitError({
+						message: gqlError.message,
+						code: _copilotkit_shared.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 _copilotkit_shared.CopilotKitError({
+				message: error?.message || String(error),
+				code: _copilotkit_shared.CopilotKitErrorCode.UNKNOWN
+			});
+			setBannerError(fallbackError);
+			traceUIError(fallbackError, error);
+		}
+	}, [
+		setBannerError,
+		showDevConsole,
+		traceUIError
+	]);
+	(0, react.useEffect)(() => {
+		updateTapMessages(messages);
+	}, [messages, updateTapMessages]);
+	const memoizedChildren = (0, react.useMemo)(() => children, [children]);
+	const [suggestions, setSuggestions] = (0, react.useState)([]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotMessagesContext.Provider, {
+		value: {
+			messages,
+			setMessages,
+			suggestions,
+			setSuggestions
+		},
+		children: memoizedChildren
+	});
+}
+
+//#endregion
+//#region src/components/usage-banner.tsx
+function UsageBanner({ severity = _copilotkit_shared.Severity.CRITICAL, message = "", onClose, actions }) {
+	if (!message || !severity) return null;
+	const theme = {
+		[_copilotkit_shared.Severity.INFO]: {
+			bg: "#f8fafc",
+			border: "#e2e8f0",
+			text: "#475569",
+			accent: "#3b82f6"
+		},
+		[_copilotkit_shared.Severity.WARNING]: {
+			bg: "#fffbeb",
+			border: "#fbbf24",
+			text: "#92400e",
+			accent: "#f59e0b"
+		},
+		[_copilotkit_shared.Severity.CRITICAL]: {
+			bg: "#fef2f2",
+			border: "#fecaca",
+			text: "#dc2626",
+			accent: "#ef4444"
+		}
+	}[severity];
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsx)("div", {
+		className: "usage-banner",
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			className: "banner-content",
+			children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					className: "banner-message",
+					children: message
+				}),
+				actions?.primary && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					className: "btn-primary",
+					onClick: actions.primary.onClick,
+					children: actions.primary.label
+				}),
+				onClose && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					className: "close-btn",
+					onClick: onClose,
+					title: "Close",
+					children: "×"
+				})
+			]
+		})
+	})] });
+}
+const getErrorActions = (error) => {
+	switch (error.code) {
+		case _copilotkit_shared.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 _copilotkit_shared.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(`${_copilotkit_shared.COPILOT_CLOUD_API_URL}/ciu`, {
+					method: "GET",
+					headers: { [_copilotkit_shared.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__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsx)("circle", {
+			cx: "12",
+			cy: "12",
+			r: "10"
+		}),
+		/* @__PURE__ */ (0, react_jsx_runtime.jsx)("line", {
+			x1: "12",
+			x2: "12",
+			y1: "8",
+			y2: "12"
+		}),
+		/* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: {
+					marginTop: idx === 0 ? 0 : 10,
+					marginBottom: 14
+				},
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ExclamationMarkIcon, { style: { marginBottom: 4 } }),
+					code && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: {
+							fontWeight: "600",
+							marginBottom: 4
+						},
+						children: [
+							"Copilot Runtime Error:",
+							" ",
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								style: {
+									fontFamily: "monospace",
+									fontWeight: "normal"
+								},
+								children: code
+							})
+						]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_markdown.default, { children: message })
+				]
+			}, idx);
+		}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			style: {
+				fontSize: "11px",
+				opacity: .75
+			},
+			children: "NOTE: This error only displays during local development."
+		})]
+	});
+}
+function useErrorToast() {
+	const { addToast } = useToast();
+	return (0, react.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__ */ (0, react_jsx_runtime.jsx)(ErrorToast, { errors })
+		});
+	}, [addToast]);
+}
+function useAsyncCallback(callback, deps) {
+	const addErrorToast = useErrorToast();
+	return (0, react.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.default.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 _copilotkit_shared.CopilotKitError) return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [this.props.children, this.props.showUsageBanner && /* @__PURE__ */ (0, react_jsx_runtime.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 = (0, react.createContext)(void 0);
+function CoAgentStateRendersProvider({ children }) {
+	const [coAgentStateRenders, setCoAgentStateRenders] = (0, react.useState)({});
+	const setCoAgentStateRender = (0, react.useCallback)((id, stateRender) => {
+		setCoAgentStateRenders((prevPoints) => ({
+			...prevPoints,
+			[id]: stateRender
+		}));
+	}, []);
+	const removeCoAgentStateRender = (0, react.useCallback)((id) => {
+		setCoAgentStateRenders((prevPoints) => {
+			const newPoints = { ...prevPoints };
+			delete newPoints[id];
+			return newPoints;
+		});
+	}, []);
+	const claimsRef = (0, react.useRef)({});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CoAgentStateRendersContext.Provider, {
+		value: {
+			coAgentStateRenders,
+			setCoAgentStateRender,
+			removeCoAgentStateRender,
+			claimsRef
+		},
+		children
+	});
+}
+function useCoAgentStateRenders() {
+	const context = (0, react.useContext)(CoAgentStateRendersContext);
+	if (!context) throw new Error("useCoAgentStateRenders must be used within CoAgentStateRendersProvider");
+	return context;
+}
+
+//#endregion
+//#region src/context/threads-context.tsx
+const ThreadsContext = (0, react.createContext)(void 0);
+function ThreadsProvider({ children, threadId: explicitThreadId }) {
+	const [internalThreadId, setThreadId] = (0, react.useState)(() => (0, _copilotkit_shared.randomUUID)());
+	const threadId = explicitThreadId ?? internalThreadId;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ThreadsContext.Provider, {
+		value: {
+			threadId,
+			setThreadId
+		},
+		children
+	});
+}
+function useThreads() {
+	const context = (0, react.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 && (0, _copilotkit_shared.dataToUUID)(getStateWithoutConstantKeys(claim.stateSnapshot)) === (0, _copilotkit_shared.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 ? (0, _copilotkit_shared.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
+	});
+	(0, react.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 } = (0, _copilotkitnext_react.useAgent)({ agentId });
+	const [nodeName, setNodeName] = (0, react.useState)(void 0);
+	const [, forceUpdate] = (0, react.useState)(0);
+	(0, react.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 = (0, react.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 = (0, react.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 (0, react.useMemo)(() => {
+		if (!stateRender || !stateRenderId) return null;
+		if (!canRender) return null;
+		if (stateRender.handler) stateRender.handler({
+			state: stateSnapshot ? (0, _copilotkit_shared.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 = (0, react.useRef)([]);
+	const getSubscriber = (0, react.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" ? (0, _copilotkit_shared.parseJson)(partialToolCallArgs, partialToolCallArgs) : partialToolCallArgs;
+				agent.setState({ [t.state_key]: emittedState[t.state_key] });
+			});
+		}
+	}), []);
+	(0, react.useEffect)(() => {
+		if (!agent) return;
+		const subscriber = getSubscriber(agent);
+		const { unsubscribe } = agent.subscribe(subscriber);
+		return () => {
+			unsubscribe();
+		};
+	}, [agent, getSubscriber]);
+};
+function CopilotListeners() {
+	const { copilotkit } = (0, _copilotkitnext_react.useCopilotKit)();
+	const resolvedAgentId = (0, _copilotkitnext_react.useCopilotChatConfiguration)()?.agentId;
+	const { setBannerError } = useToast();
+	const { agent } = (0, _copilotkitnext_react.useAgent)({ agentId: resolvedAgentId });
+	usePredictStateSubscription(agent);
+	(0, react.useEffect)(() => {
+		const subscription = copilotkit.subscribe({ onError: ({ error }) => {
+			setBannerError(new _copilotkit_shared.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 = (0, react.useMemo)(() => [{ render: CoAgentStateRenderBridge }], []);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ToastProvider, {
+		enabled,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotErrorBoundary, {
+			publicApiKey,
+			showUsageBanner: enabled,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ThreadsProvider, {
+				threadId: props.threadId,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_copilotkitnext_react.CopilotKitProvider, {
+					...props,
+					showDevConsole: showInspector,
+					renderCustomMessages: renderArr,
+					useSingleEndpoint: props.useSingleEndpoint ?? true,
+					children: /* @__PURE__ */ (0, react_jsx_runtime.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 } = (0, _copilotkitnext_react.useCopilotKit)();
+	const { onError, copilotApiConfig } = useCopilotContext();
+	(0, react.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 || _copilotkit_shared.COPILOT_CLOUD_CHAT_URL;
+	const [actions, setActions] = (0, react.useState)({});
+	const [registeredActionConfigs, setRegisteredActionConfigs] = (0, react.useState)(/* @__PURE__ */ new Map());
+	const chatComponentsCache = (0, react.useRef)({
+		actions: {},
+		coAgentStateRenders: {}
+	});
+	const { addElement, removeElement, printTree, getAllElements } = useTree();
+	const [isLoading, setIsLoading] = (0, react.useState)(false);
+	const [chatInstructions, setChatInstructions] = (0, react.useState)("");
+	const [authStates, setAuthStates] = (0, react.useState)({});
+	const [extensions, setExtensions] = (0, react.useState)({});
+	const [additionalInstructions, setAdditionalInstructions] = (0, react.useState)([]);
+	const { addElement: addDocument, removeElement: removeDocument, allElements: allDocuments } = useFlatCategoryStore();
+	const setAction = (0, react.useCallback)((id, action) => {
+		setActions((prevPoints) => {
+			return {
+				...prevPoints,
+				[id]: action
+			};
+		});
+	}, []);
+	const removeAction = (0, react.useCallback)((id) => {
+		setActions((prevPoints) => {
+			const newPoints = { ...prevPoints };
+			delete newPoints[id];
+			return newPoints;
+		});
+	}, []);
+	const getContextString = (0, react.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 = (0, react.useCallback)((context, parentId, categories = defaultCopilotContextCategories) => {
+		return addElement(context, categories, parentId);
+	}, [addElement]);
+	const removeContext = (0, react.useCallback)((id) => {
+		removeElement(id);
+	}, [removeElement]);
+	const getAllContext = (0, react.useCallback)(() => {
+		return getAllElements();
+	}, [getAllElements]);
+	const getFunctionCallHandler = (0, react.useCallback)((customEntryPoints) => {
+		return entryPointsToFunctionCallHandler(Object.values(customEntryPoints || actions));
+	}, [actions]);
+	const getDocumentsContext = (0, react.useCallback)((categories) => {
+		return allDocuments(categories);
+	}, [allDocuments]);
+	const addDocumentContext = (0, react.useCallback)((documentPointer, categories = defaultCopilotContextCategories) => {
+		return addDocument(documentPointer, categories);
+	}, [addDocument]);
+	const removeDocumentContext = (0, react.useCallback)((documentId) => {
+		removeDocument(documentId);
+	}, [removeDocument]);
+	const copilotApiConfig = (0, react.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
+	]);
+	(0, react.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 ? { [_copilotkit_shared.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: copilotApiConfig.publicApiKey } : {},
+			...authHeaders
+		};
+	}, [
+		copilotApiConfig.headers,
+		copilotApiConfig.publicApiKey,
+		authStates
+	]);
+	const [internalErrorHandlers, _setInternalErrorHandler] = (0, react.useState)({});
+	const setInternalErrorHandler = (0, react.useCallback)((handler) => {
+		_setInternalErrorHandler((prev) => ({
+			...prev,
+			...handler
+		}));
+	}, []);
+	const removeInternalErrorHandler = (0, react.useCallback)((key) => {
+		_setInternalErrorHandler((prev) => {
+			const { [key]: _removed, ...rest } = prev;
+			return rest;
+		});
+	}, []);
+	const onErrorRef = (0, react.useRef)(props.onError);
+	(0, react.useEffect)(() => {
+		onErrorRef.current = props.onError;
+	}, [props.onError]);
+	const internalHandlersRef = (0, react.useRef)({});
+	(0, react.useEffect)(() => {
+		internalHandlersRef.current = internalErrorHandlers;
+	}, [internalErrorHandlers]);
+	const handleErrors = (0, react.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] = (0, react.useState)({});
+	const addChatSuggestionConfiguration = (0, react.useCallback)((id, suggestion) => {
+		setChatSuggestionConfiguration((prev) => ({
+			...prev,
+			[id]: suggestion
+		}));
+	}, [setChatSuggestionConfiguration]);
+	const removeChatSuggestionConfiguration = (0, react.useCallback)((id) => {
+		setChatSuggestionConfiguration((prev) => {
+			const { [id]: _, ...rest } = prev;
+			return rest;
+		});
+	}, [setChatSuggestionConfiguration]);
+	const [availableAgents, setAvailableAgents] = (0, react.useState)([]);
+	const [coagentStates, setCoagentStates] = (0, react.useState)({});
+	const coagentStatesRef = (0, react.useRef)({});
+	const setCoagentStatesWithRef = (0, react.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] = (0, react.useState)(initialAgentSession);
+	(0, react.useEffect)(() => {
+		if (props.agent) setAgentSession({ agentName: props.agent });
+		else setAgentSession(null);
+	}, [props.agent]);
+	const { threadId, setThreadId: setInternalThreadId } = useThreads();
+	const setThreadId = (0, react.useCallback)((value) => {
+		if (props.threadId) throw new Error("Cannot call setThreadId() when threadId is provided via props.");
+		setInternalThreadId(value);
+	}, [props.threadId]);
+	const [runId, setRunId] = (0, react.useState)(null);
+	const chatAbortControllerRef = (0, react.useRef)(null);
+	const showDevConsole = shouldShowDevConsole(props.showDevConsole);
+	const [interruptActions, _setInterruptActions] = (0, react.useState)({});
+	const setInterruptAction = (0, react.useCallback)((action) => {
+		_setInterruptActions((prev) => {
+			if (action == null || !action.id) return prev;
+			return {
+				...prev,
+				[action.id]: {
+					...prev[action.id] ?? {},
+					...action
+				}
+			};
+		});
+	}, []);
+	const removeInterruptAction = (0, react.useCallback)((actionId) => {
+		_setInterruptActions((prev) => {
+			const { [actionId]: _, ...rest } = prev;
+			return rest;
+		});
+	}, []);
+	const [interruptEventQueue, setInterruptEventQueue] = (0, react.useState)({});
+	const addInterruptEvent = (0, react.useCallback)((queuedEvent) => {
+		setInterruptEventQueue((prev) => {
+			const threadQueue = prev[queuedEvent.threadId] || [];
+			return {
+				...prev,
+				[queuedEvent.threadId]: [...threadQueue, queuedEvent]
+			};
+		});
+	}, []);
+	const resolveInterruptEvent = (0, react.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 = (0, react.useMemo)(() => children, [children]);
+	const [bannerError, setBannerError] = (0, react.useState)(null);
+	const agentLock = (0, react.useMemo)(() => props.agent ?? null, [props.agent]);
+	const forwardedParameters = (0, react.useMemo)(() => props.forwardedParameters ?? {}, [props.forwardedParameters]);
+	const updateExtensions = (0, react.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 = (0, react.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 = (0, react.useCallback)((actionConfig) => {
+		const key = actionConfig.action.name || (0, _copilotkit_shared.randomUUID)();
+		setRegisteredActionConfigs((prev) => {
+			const newMap = new Map(prev);
+			newMap.set(key, actionConfig);
+			return newMap;
+		});
+		return key;
+	}, []);
+	const handleRemoveRegisteredAction = (0, react.useCallback)((actionKey) => {
+		setRegisteredActionConfigs((prev) => {
+			const newMap = new Map(prev);
+			newMap.delete(actionKey);
+			return newMap;
+		});
+	}, []);
+	const RegisteredActionsRenderer = (0, react.useMemo)(() => {
+		return () => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: Array.from(registeredActionConfigs.entries()).map(([key, config]) => {
+			const Component = config.component;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Component, { action: config.action }, key);
+		}) });
+	}, [registeredActionConfigs]);
+	const copilotContextValue = (0, react.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__ */ (0, react_jsx_runtime.jsx)(_copilotkitnext_react.CopilotChatConfigurationProvider, {
+		agentId: props.agent ?? "default",
+		threadId,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(CopilotContext.Provider, {
+			value: copilotContextValue,
+			children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotListeners, {}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotKitErrorBridge, {}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(CoAgentStateRendersProvider, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(MessagesTapProvider, { children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(CopilotMessages, { children: [memoizedChildren, /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RegisteredActionsRenderer, {})] }) }), bannerError && showDevConsole && /* @__PURE__ */ (0, react_jsx_runtime.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) => {
+				(0, react_dom.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 _copilotkit_shared.ConfigurationError("Missing required prop: 'runtimeUrl' or 'publicApiKey' or 'publicLicenseKey'");
+	if (cloudFeatures.length > 0 && !hasApiKey) throw new _copilotkit_shared.MissingPublicApiKeyError(`Missing required prop: 'publicApiKey' or 'publicLicenseKey' to use cloud features: ${cloudFeatures.map(formatFeatureName).join(", ")}`);
+}
+
+//#endregion
+Object.defineProperty(exports, 'CoAgentStateRenderBridge', {
+  enumerable: true,
+  get: function () {
+    return CoAgentStateRenderBridge;
+  }
+});
+Object.defineProperty(exports, 'CoAgentStateRendersContext', {
+  enumerable: true,
+  get: function () {
+    return CoAgentStateRendersContext;
+  }
+});
+Object.defineProperty(exports, 'CoAgentStateRendersProvider', {
+  enumerable: true,
+  get: function () {
+    return CoAgentStateRendersProvider;
+  }
+});
+Object.defineProperty(exports, 'CopilotContext', {
+  enumerable: true,
+  get: function () {
+    return CopilotContext;
+  }
+});
+Object.defineProperty(exports, 'CopilotKit', {
+  enumerable: true,
+  get: function () {
+    return CopilotKit;
+  }
+});
+Object.defineProperty(exports, 'CopilotMessagesContext', {
+  enumerable: true,
+  get: function () {
+    return CopilotMessagesContext;
+  }
+});
+Object.defineProperty(exports, 'ThreadsContext', {
+  enumerable: true,
+  get: function () {
+    return ThreadsContext;
+  }
+});
+Object.defineProperty(exports, 'ThreadsProvider', {
+  enumerable: true,
+  get: function () {
+    return ThreadsProvider;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'defaultCopilotContextCategories', {
+  enumerable: true,
+  get: function () {
+    return defaultCopilotContextCategories;
+  }
+});
+Object.defineProperty(exports, 'shouldShowDevConsole', {
+  enumerable: true,
+  get: function () {
+    return shouldShowDevConsole;
+  }
+});
+Object.defineProperty(exports, 'useAsyncCallback', {
+  enumerable: true,
+  get: function () {
+    return useAsyncCallback;
+  }
+});
+Object.defineProperty(exports, 'useCoAgentStateRenders', {
+  enumerable: true,
+  get: function () {
+    return useCoAgentStateRenders;
+  }
+});
+Object.defineProperty(exports, 'useCopilotContext', {
+  enumerable: true,
+  get: function () {
+    return useCopilotContext;
+  }
+});
+Object.defineProperty(exports, 'useCopilotMessagesContext', {
+  enumerable: true,
+  get: function () {
+    return useCopilotMessagesContext;
+  }
+});
+Object.defineProperty(exports, 'useThreads', {
+  enumerable: true,
+  get: function () {
+    return useThreads;
+  }
+});
+Object.defineProperty(exports, 'useToast', {
+  enumerable: true,
+  get: function () {
+    return useToast;
+  }
+});
+//# sourceMappingURL=copilotkit-C94ayZbs.cjs.map