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

package/dist/v2/index.umd.js

@@ -1,10 +1,1982 @@
-(function(factory) {
-  
-  typeof define === 'function' && define.amd ? define([], factory) :
-  factory();
-})(function() {
+(function(global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('@copilotkitnext/react'), require('react'), require('@copilotkit/shared'), require('react-dom'), require('react/jsx-runtime')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@copilotkitnext/react', 'react', '@copilotkit/shared', 'react-dom', 'react/jsx-runtime'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitReactCoreV2 = {}), global.CopilotKitNextReact,global.React,global.CopilotKitShared,global.ReactDOM,global.ReactJsxRuntime));
+})(this, function(exports, _copilotkitnext_react, react, _copilotkit_shared, react_dom, react_jsx_runtime) {
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#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
+react = __toESM(react);
 
+//#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);
+
+//#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) => {
+			var _toast$id;
+			if (!enabled) return;
+			const id = (_toast$id = toast.id) !== null && _toast$id !== void 0 ? _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 === null || extensions === void 0 ? void 0 : extensions.originalError;
+			if (originalError === null || originalError === void 0 ? void 0 : 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 === null || originalError === void 0 ? void 0 : originalError.message) || gqlError.message;
+			const code = extensions === null || extensions === void 0 ? void 0 : extensions.code;
+			if (code) return new _copilotkit_shared.CopilotKitError({
+				message,
+				code
+			});
+			return null;
+		};
+		(0, react.useCallback)((error) => {
+			var _error$graphQLErrors;
+			if ((_error$graphQLErrors = error.graphQLErrors) === null || _error$graphQLErrors === void 0 ? void 0 : _error$graphQLErrors.length) {
+				const graphQLErrors = error.graphQLErrors;
+				const routeError = (gqlError) => {
+					const extensions = gqlError.extensions;
+					const visibility = extensions === null || extensions === void 0 ? void 0 : 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 === null || error === void 0 ? void 0 : 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 === null || actions === void 0 ? void 0 : 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 === null || onUpdate === void 0 || 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/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) => {
+					var _prevState$status;
+					if ((newStatus === null || newStatus === void 0 ? void 0 : newStatus.severity) !== ((_prevState$status = prevState.status) === null || _prevState$status === void 0 ? void 0 : _prevState$status.severity)) return { status: newStatus !== null && newStatus !== void 0 ? 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) {
+					var _this$state$status$se, _this$state$status, _this$state$status$me, _this$state$status2;
+					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$se = (_this$state$status = this.state.status) === null || _this$state$status === void 0 ? void 0 : _this$state$status.severity) !== null && _this$state$status$se !== void 0 ? _this$state$status$se : this.state.error.severity,
+						message: (_this$state$status$me = (_this$state$status2 = this.state.status) === null || _this$state$status2 === void 0 ? void 0 : _this$state$status2.message) !== null && _this$state$status$me !== void 0 ? _this$state$status$me : 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 !== null && explicitThreadId !== void 0 ? 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 !== null && runId !== void 0 ? runId : "pending";
+		const renderClaimedByOtherMessageEntry = Object.entries(claims).find(([, claim]) => {
+			var _claim$runId;
+			return claim.stateRenderId === stateRenderId && ((_claim$runId = claim.runId) !== null && _claim$runId !== void 0 ? _claim$runId : "pending") === normalizedRunId && (0, _copilotkit_shared.dataToUUID)(getStateWithoutConstantKeys(claim.stateSnapshot)) === (0, _copilotkit_shared.dataToUUID)(getStateWithoutConstantKeys(stateSnapshot));
+		});
+		const renderClaimedByOtherMessage = renderClaimedByOtherMessageEntry === null || renderClaimedByOtherMessageEntry === void 0 ? void 0 : renderClaimedByOtherMessageEntry[1];
+		const claimedMessageId = renderClaimedByOtherMessageEntry === null || renderClaimedByOtherMessageEntry === void 0 ? void 0 : 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 }) {
+		var _reverse$find, _agentMessages$messag, _existingClaim$stateS, _existingClaim$stateS2;
+		const lastAssistantId = agentMessages ? (_reverse$find = [...agentMessages].reverse().find((msg) => msg.role === "assistant")) === null || _reverse$find === void 0 ? void 0 : _reverse$find.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$messag = agentMessages[messageIndex]) === null || _agentMessages$messag === void 0 ? void 0 : _agentMessages$messag.role : void 0;
+		let previousUserMessageId;
+		if (messageIndex > 0 && agentMessages) for (let i = messageIndex - 1; i >= 0; i -= 1) {
+			var _agentMessages$i;
+			if (((_agentMessages$i = agentMessages[i]) === null || _agentMessages$i === void 0 ? void 0 : _agentMessages$i.role) === "user") {
+				var _agentMessages$i2;
+				previousUserMessageId = (_agentMessages$i2 = agentMessages[i]) === null || _agentMessages$i2 === void 0 ? void 0 : _agentMessages$i2.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 !== null && cachedMessageSnapshot !== void 0 ? 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 === null || existingClaim === void 0 ? void 0 : existingClaim.locked) ? (_existingClaim$stateS = existingClaim.stateSnapshot) !== null && _existingClaim$stateS !== void 0 ? _existingClaim$stateS : cachedSnapshot : hasSnapshotKeys ? snapshot : (_existingClaim$stateS2 = existingClaim === null || existingClaim === void 0 ? void 0 : existingClaim.stateSnapshot) !== null && _existingClaim$stateS2 !== void 0 ? _existingClaim$stateS2 : 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) {
+		var _store$LAST_SNAPSHOTS, _store$LAST_SNAPSHOTS2;
+		const store = getClaimsStore(claimsRef);
+		return {
+			byStateRenderAndRun: (_store$LAST_SNAPSHOTS = store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN]) !== null && _store$LAST_SNAPSHOTS !== void 0 ? _store$LAST_SNAPSHOTS : {},
+			byMessageId: (_store$LAST_SNAPSHOTS2 = store[LAST_SNAPSHOTS_BY_MESSAGE]) !== null && _store$LAST_SNAPSHOTS2 !== void 0 ? _store$LAST_SNAPSHOTS2 : {}
+		};
+	}
+	function useStateRenderRegistry({ agentId, stateRenderId, message, messageIndex, stateSnapshot, agentState, agentMessages, claimsRef }) {
+		var _store$LAST_SNAPSHOTS3, _claimsRef$current$me;
+		const store = getClaimsStore(claimsRef);
+		const runId = message.runId;
+		const { runId: cachedMessageRunId } = readCachedMessageEntry((_store$LAST_SNAPSHOTS3 = store[LAST_SNAPSHOTS_BY_MESSAGE]) === null || _store$LAST_SNAPSHOTS3 === void 0 ? void 0 : _store$LAST_SNAPSHOTS3[message.id]);
+		const effectiveRunId = getEffectiveRunId({
+			existingClaimRunId: (_claimsRef$current$me = claimsRef.current[message.id]) === null || _claimsRef$current$me === void 0 ? void 0 : _claimsRef$current$me.runId,
+			cachedMessageRunId,
+			runId
+		});
+		(0, react.useEffect)(() => {
+			return () => {
+				const existingClaim = claimsRef.current[message.id];
+				if ((existingClaim === null || existingClaim === void 0 ? void 0 : existingClaim.stateSnapshot) && Object.keys(existingClaim.stateSnapshot).length > 0) {
+					var _store$LAST_SNAPSHOTS4, _existingClaim$runId, _store$LAST_SNAPSHOTS5, _existingClaim$runId2;
+					const snapshotCache = { ...(_store$LAST_SNAPSHOTS4 = store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN]) !== null && _store$LAST_SNAPSHOTS4 !== void 0 ? _store$LAST_SNAPSHOTS4 : {} };
+					const cacheKey = `${existingClaim.stateRenderId}::${(_existingClaim$runId = existingClaim.runId) !== null && _existingClaim$runId !== void 0 ? _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_SNAPSHOTS5 = store[LAST_SNAPSHOTS_BY_MESSAGE]) !== null && _store$LAST_SNAPSHOTS5 !== void 0 ? _store$LAST_SNAPSHOTS5 : {} };
+					messageCache[message.id] = {
+						snapshot: existingClaim.stateSnapshot,
+						runId: (_existingClaim$runId2 = existingClaim.runId) !== null && _existingClaim$runId2 !== void 0 ? _existingClaim$runId2 : 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 === null || agentMessages === void 0 ? void 0 : 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) {
+				var _store$LAST_SNAPSHOTS6, _store$LAST_SNAPSHOTS7;
+				claimsRef.current[message.id].stateSnapshot = snapshot;
+				const snapshotCache = { ...(_store$LAST_SNAPSHOTS6 = store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN]) !== null && _store$LAST_SNAPSHOTS6 !== void 0 ? _store$LAST_SNAPSHOTS6 : {} };
+				const cacheKey = `${stateRenderId}::${effectiveRunId}`;
+				snapshotCache[cacheKey] = snapshot;
+				snapshotCache[`${stateRenderId}::latest`] = snapshot;
+				store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
+				const messageCache = { ...(_store$LAST_SNAPSHOTS7 = store[LAST_SNAPSHOTS_BY_MESSAGE]) !== null && _store$LAST_SNAPSHOTS7 !== void 0 ? _store$LAST_SNAPSHOTS7 : {} };
+				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) {
+				var _store$LAST_SNAPSHOTS8, _store$LAST_SNAPSHOTS9;
+				claimsRef.current[message.id].stateSnapshot = snapshotForClaim;
+				const snapshotCache = { ...(_store$LAST_SNAPSHOTS8 = store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN]) !== null && _store$LAST_SNAPSHOTS8 !== void 0 ? _store$LAST_SNAPSHOTS8 : {} };
+				const cacheKey = `${stateRenderId}::${effectiveRunId}`;
+				snapshotCache[cacheKey] = snapshotForClaim;
+				snapshotCache[`${stateRenderId}::latest`] = snapshotForClaim;
+				store[LAST_SNAPSHOTS_BY_RENDER_AND_RUN] = snapshotCache;
+				const messageCache = { ...(_store$LAST_SNAPSHOTS9 = store[LAST_SNAPSHOTS_BY_MESSAGE]) !== null && _store$LAST_SNAPSHOTS9 !== void 0 ? _store$LAST_SNAPSHOTS9 : {} };
+				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) {
+		var _props$runId;
+		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 === null || stateRenderEntry === void 0 ? void 0 : stateRenderEntry[0];
+		const stateRender = stateRenderEntry === null || stateRenderEntry === void 0 ? void 0 : stateRenderEntry[1];
+		const { canRender } = useStateRenderRegistry({
+			agentId,
+			stateRenderId,
+			message: {
+				...message,
+				runId: (_props$runId = props.runId) !== null && _props$runId !== void 0 ? _props$runId : message.runId
+			},
+			messageIndex: props.messageIndex,
+			stateSnapshot,
+			agentState: agent === null || agent === void 0 ? void 0 : agent.state,
+			agentMessages: agent === null || agent === void 0 ? void 0 : agent.messages,
+			claimsRef
+		});
+		return (0, react.useMemo)(() => {
+			if (!stateRender || !stateRenderId) return null;
+			if (!canRender) return null;
+			if (stateRender.handler) {
+				var _agent$state;
+				stateRender.handler({
+					state: stateSnapshot ? (0, _copilotkit_shared.parseJson)(stateSnapshot, stateSnapshot) : (_agent$state = agent === null || agent === void 0 ? void 0 : agent.state) !== null && _agent$state !== void 0 ? _agent$state : {},
+					nodeName: nodeName !== null && nodeName !== void 0 ? nodeName : ""
+				});
+			}
+			if (stateRender.render) {
+				var _claimsRef$current$me;
+				const status = (agent === null || agent === void 0 ? void 0 : agent.isRunning) ? RenderStatus.InProgress : RenderStatus.Complete;
+				if (typeof stateRender.render === "string") return stateRender.render;
+				return stateRender.render({
+					status,
+					state: (_claimsRef$current$me = claimsRef.current[message.id].stateSnapshot) !== null && _claimsRef$current$me !== void 0 ? _claimsRef$current$me : {},
+					nodeName: nodeName !== null && nodeName !== void 0 ? nodeName : ""
+				});
+			}
+		}, [
+			stateRender,
+			stateRenderId,
+			agent === null || agent === void 0 ? void 0 : agent.state,
+			agent === null || agent === void 0 ? void 0 : 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 === null || t === void 0 ? void 0 : 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 existingConfig = (0, _copilotkitnext_react.useCopilotChatConfiguration)();
+		const resolvedAgentId = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.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 === null || copilotkit === void 0 ? void 0 : 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 }) {
+		var _props$useSingleEndpo;
+		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$useSingleEndpo = props.useSingleEndpoint) !== null && _props$useSingleEndpo !== void 0 ? _props$useSingleEndpo : 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 === null || copilotApiConfig === void 0 ? void 0 : 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) {
+		var _props$agent2;
+		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) {
+				var _props$guardrails_c, _props$guardrails_c2;
+				cloud = { guardrails: { input: { restrictToTopic: {
+					enabled: Boolean(props.guardrails_c),
+					validTopics: ((_props$guardrails_c = props.guardrails_c) === null || _props$guardrails_c === void 0 ? void 0 : _props$guardrails_c.validTopics) || [],
+					invalidTopics: ((_props$guardrails_c2 = props.guardrails_c) === null || _props$guardrails_c2 === void 0 ? void 0 : _props$guardrails_c2.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) => {
+				var _prev$action$id;
+				if (action == null || !action.id) return prev;
+				return {
+					...prev,
+					[action.id]: {
+						...(_prev$action$id = prev[action.id]) !== null && _prev$action$id !== void 0 ? _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)(() => {
+			var _props$agent;
+			return (_props$agent = props.agent) !== null && _props$agent !== void 0 ? _props$agent : null;
+		}, [props.agent]);
+		const forwardedParameters = (0, react.useMemo)(() => {
+			var _props$forwardedParam;
+			return (_props$forwardedParam = props.forwardedParameters) !== null && _props$forwardedParam !== void 0 ? _props$forwardedParam : {};
+		}, [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$agent2 = props.agent) !== null && _props$agent2 !== void 0 ? _props$agent2 : "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 {
+							var _action$handler;
+							result = await ((_action$handler = action.handler) === null || _action$handler === void 0 ? void 0 : _action$handler.call(action, 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
+exports.CopilotKit = CopilotKit;
 var _copilotkitnext_core = require("@copilotkitnext/core");
 Object.keys(_copilotkitnext_core).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
@@ -13,7 +1985,6 @@ Object.keys(_copilotkitnext_core).forEach(function (k) {
   });
 });
 
-var _copilotkitnext_react = require("@copilotkitnext/react");
 Object.keys(_copilotkitnext_react).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
@@ -21,4 +1992,5 @@ Object.keys(_copilotkitnext_react).forEach(function (k) {
   });
 });
 
-});
+});
+//# sourceMappingURL=index.umd.js.map