@copilotkit/react-core 1.54.1 → 1.55.0-next.7

package/dist/index.umd.js

@@ -1,10 +1,10 @@
 "use client";
 
 (function(global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('react'), require('@copilotkitnext/react'), require('@copilotkit/shared'), require('react-dom'), require('react/jsx-runtime'), require('react-markdown'), require('@copilotkit/runtime-client-gql'), require('@copilotkitnext/core'), require('@ag-ui/client')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react', '@copilotkitnext/react', '@copilotkit/shared', 'react-dom', 'react/jsx-runtime', 'react-markdown', '@copilotkit/runtime-client-gql', '@copilotkitnext/core', '@ag-ui/client'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitReactCore = {}), global.React,global.CopilotKitNextReact,global.CopilotKitShared,global.ReactDOM,global.ReactJsxRuntime,global.ReactMarkdown,global.CopilotKitRuntimeClientGQL,global.CopilotKitNextCore,global.AgUIClient));
-})(this, function(exports, react, _copilotkitnext_react, _copilotkit_shared, react_dom, react_jsx_runtime, react_markdown, _copilotkit_runtime_client_gql, _copilotkitnext_core, _ag_ui_client) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('react'), require('@copilotkit/core'), require('@ag-ui/client'), require('@copilotkit/shared'), require('react/jsx-runtime'), require('zod'), require('@lit-labs/react'), require('@copilotkit/a2ui-renderer'), require('react-dom'), require('react-markdown'), require('@copilotkit/runtime-client-gql')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', '@copilotkit/core', '@ag-ui/client', '@copilotkit/shared', 'react/jsx-runtime', 'zod', '@lit-labs/react', '@copilotkit/a2ui-renderer', 'react-dom', 'react-markdown', '@copilotkit/runtime-client-gql'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitReactCore = {}), global.React,global.CopilotKitCore,global.AgUIClient,global.CopilotKitShared,global.ReactJsxRuntime,global.Zod,global._lit_labs_react,global.CopilotKitA2UIRenderer,global.ReactDOM,global.ReactMarkdown,global.CopilotKitRuntimeClientGQL));
+})(this, function(exports, react, _copilotkit_core, _ag_ui_client, _copilotkit_shared, react_jsx_runtime, zod, _lit_labs_react, _copilotkit_a2ui_renderer, react_dom, react_markdown, _copilotkit_runtime_client_gql) {
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 //#region \0rolldown/runtime.js
 	var __create = Object.create;
@@ -36,6 +36,1912 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 react = __toESM(react);
 react_markdown = __toESM(react_markdown);
 
+//#region src/v2/providers/CopilotChatConfigurationProvider.tsx
+	const CopilotChatDefaultLabels = {
+		chatInputPlaceholder: "Type a message...",
+		chatInputToolbarStartTranscribeButtonLabel: "Transcribe",
+		chatInputToolbarCancelTranscribeButtonLabel: "Cancel",
+		chatInputToolbarFinishTranscribeButtonLabel: "Finish",
+		chatInputToolbarAddButtonLabel: "Add photos or files",
+		chatInputToolbarToolsButtonLabel: "Tools",
+		assistantMessageToolbarCopyCodeLabel: "Copy",
+		assistantMessageToolbarCopyCodeCopiedLabel: "Copied",
+		assistantMessageToolbarCopyMessageLabel: "Copy",
+		assistantMessageToolbarThumbsUpLabel: "Good response",
+		assistantMessageToolbarThumbsDownLabel: "Bad response",
+		assistantMessageToolbarReadAloudLabel: "Read aloud",
+		assistantMessageToolbarRegenerateLabel: "Regenerate",
+		userMessageToolbarCopyMessageLabel: "Copy",
+		userMessageToolbarEditMessageLabel: "Edit",
+		chatDisclaimerText: "AI can make mistakes. Please verify important information.",
+		chatToggleOpenLabel: "Open chat",
+		chatToggleCloseLabel: "Close chat",
+		modalHeaderTitle: "CopilotKit Chat",
+		welcomeMessageText: "How can I help you today?"
+	};
+	const CopilotChatConfiguration = (0, react.createContext)(null);
+	const CopilotChatConfigurationProvider = ({ children, labels, agentId, threadId, isModalDefaultOpen }) => {
+		var _ref, _parentConfig$isModal, _parentConfig$setModa;
+		const parentConfig = (0, react.useContext)(CopilotChatConfiguration);
+		const mergedLabels = (0, react.useMemo)(() => {
+			var _parentConfig$labels;
+			return {
+				...CopilotChatDefaultLabels,
+				...(_parentConfig$labels = parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.labels) !== null && _parentConfig$labels !== void 0 ? _parentConfig$labels : {},
+				...labels !== null && labels !== void 0 ? labels : {}
+			};
+		}, [labels, parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.labels]);
+		const resolvedAgentId = (_ref = agentId !== null && agentId !== void 0 ? agentId : parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.agentId) !== null && _ref !== void 0 ? _ref : _copilotkit_shared.DEFAULT_AGENT_ID;
+		const resolvedThreadId = (0, react.useMemo)(() => {
+			if (threadId) return threadId;
+			if (parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.threadId) return parentConfig.threadId;
+			return (0, _copilotkit_shared.randomUUID)();
+		}, [threadId, parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.threadId]);
+		const [internalModalOpen, setInternalModalOpen] = (0, react.useState)(isModalDefaultOpen !== null && isModalDefaultOpen !== void 0 ? isModalDefaultOpen : true);
+		const hasExplicitDefault = isModalDefaultOpen !== void 0;
+		const setAndSync = (0, react.useCallback)((open) => {
+			setInternalModalOpen(open);
+			parentConfig === null || parentConfig === void 0 || parentConfig.setModalOpen(open);
+		}, [parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.setModalOpen]);
+		const isMounted = (0, react.useRef)(false);
+		(0, react.useEffect)(() => {
+			if (!hasExplicitDefault) return;
+			if (!isMounted.current) {
+				isMounted.current = true;
+				return;
+			}
+			if ((parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.isModalOpen) === void 0) return;
+			setInternalModalOpen(parentConfig.isModalOpen);
+		}, [parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.isModalOpen, hasExplicitDefault]);
+		const resolvedIsModalOpen = hasExplicitDefault ? internalModalOpen : (_parentConfig$isModal = parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.isModalOpen) !== null && _parentConfig$isModal !== void 0 ? _parentConfig$isModal : internalModalOpen;
+		const resolvedSetModalOpen = hasExplicitDefault ? setAndSync : (_parentConfig$setModa = parentConfig === null || parentConfig === void 0 ? void 0 : parentConfig.setModalOpen) !== null && _parentConfig$setModa !== void 0 ? _parentConfig$setModa : setInternalModalOpen;
+		const configurationValue = (0, react.useMemo)(() => ({
+			labels: mergedLabels,
+			agentId: resolvedAgentId,
+			threadId: resolvedThreadId,
+			isModalOpen: resolvedIsModalOpen,
+			setModalOpen: resolvedSetModalOpen
+		}), [
+			mergedLabels,
+			resolvedAgentId,
+			resolvedThreadId,
+			resolvedIsModalOpen,
+			resolvedSetModalOpen
+		]);
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotChatConfiguration.Provider, {
+			value: configurationValue,
+			children
+		});
+	};
+	const useCopilotChatConfiguration = () => {
+		return (0, react.useContext)(CopilotChatConfiguration);
+	};
+
+//#endregion
+//#region src/v2/components/CopilotKitInspector.tsx
+	const CopilotKitInspector = ({ core, ...rest }) => {
+		const [InspectorComponent, setInspectorComponent] = react.useState(null);
+		react.useEffect(() => {
+			let mounted = true;
+			import("@copilotkit/web-inspector").then((mod) => {
+				var _mod$defineWebInspect;
+				(_mod$defineWebInspect = mod.defineWebInspector) === null || _mod$defineWebInspect === void 0 || _mod$defineWebInspect.call(mod);
+				const Component = (0, _lit_labs_react.createComponent)({
+					tagName: mod.WEB_INSPECTOR_TAG,
+					elementClass: mod.WebInspectorElement,
+					react
+				});
+				if (mounted) setInspectorComponent(() => Component);
+			});
+			return () => {
+				mounted = false;
+			};
+		}, []);
+		if (!InspectorComponent) return null;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(InspectorComponent, {
+			...rest,
+			core: core !== null && core !== void 0 ? core : null
+		});
+	};
+	CopilotKitInspector.displayName = "CopilotKitInspector";
+
+//#endregion
+//#region src/v2/components/license-warning-banner.tsx
+	const BANNER_STYLES = {
+		base: {
+			position: "fixed",
+			bottom: "8px",
+			left: "50%",
+			transform: "translateX(-50%)",
+			zIndex: 99999,
+			display: "inline-flex",
+			alignItems: "center",
+			gap: "12px",
+			whiteSpace: "nowrap",
+			padding: "8px 16px",
+			fontSize: "13px",
+			fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif",
+			borderRadius: "6px",
+			boxShadow: "0 2px 8px rgba(0, 0, 0, 0.15)"
+		},
+		info: {
+			backgroundColor: "#eff6ff",
+			border: "1px solid #93c5fd",
+			color: "#1e40af"
+		},
+		warning: {
+			backgroundColor: "#fffbeb",
+			border: "1px solid #fbbf24",
+			color: "#92400e"
+		},
+		critical: {
+			backgroundColor: "#fef2f2",
+			border: "1px solid #fca5a5",
+			color: "#991b1b"
+		}
+	};
+	function getSeverityStyle(severity) {
+		switch (severity) {
+			case "warning": return BANNER_STYLES.warning;
+			case "critical": return BANNER_STYLES.critical;
+			default: return BANNER_STYLES.info;
+		}
+	}
+	function BannerShell({ severity, message, actionLabel, actionUrl, onDismiss }) {
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			style: {
+				...BANNER_STYLES.base,
+				...getSeverityStyle(severity)
+			},
+			children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: message }), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: {
+					display: "flex",
+					gap: "8px",
+					alignItems: "center"
+				},
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("a", {
+					href: actionUrl,
+					target: "_blank",
+					rel: "noopener noreferrer",
+					style: {
+						fontWeight: 600,
+						textDecoration: "underline",
+						color: "inherit"
+					},
+					children: actionLabel
+				}), onDismiss && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					onClick: onDismiss,
+					style: {
+						background: "none",
+						border: "none",
+						cursor: "pointer",
+						color: "inherit",
+						fontSize: "16px"
+					},
+					children: "×"
+				})]
+			})]
+		});
+	}
+	function LicenseWarningBanner({ type, featureName, expiryDate, graceRemaining, onDismiss }) {
+		switch (type) {
+			case "no_license": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BannerShell, {
+				severity: "info",
+				message: "Powered by CopilotKit",
+				actionLabel: "Get a license",
+				actionUrl: "https://copilotkit.ai/pricing",
+				onDismiss
+			});
+			case "feature_unlicensed": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BannerShell, {
+				severity: "warning",
+				message: `⚠ The "${featureName}" feature requires a CopilotKit license.`,
+				actionLabel: "Get a license",
+				actionUrl: "https://copilotkit.ai/pricing",
+				onDismiss
+			});
+			case "expiring": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BannerShell, {
+				severity: "warning",
+				message: `Your CopilotKit license expires in ${graceRemaining} day${graceRemaining !== 1 ? "s" : ""}. Please renew.`,
+				actionLabel: "Renew",
+				actionUrl: "https://cloud.copilotkit.ai",
+				onDismiss
+			});
+			case "expired": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BannerShell, {
+				severity: "critical",
+				message: `Your CopilotKit license expired${expiryDate ? ` on ${expiryDate}` : ""}. Please renew at copilotkit.ai/pricing`,
+				actionLabel: "Renew now",
+				actionUrl: "https://copilotkit.ai/pricing",
+				onDismiss
+			});
+			case "invalid": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(BannerShell, {
+				severity: "critical",
+				message: "Invalid CopilotKit license token. Please check your configuration.",
+				actionLabel: "Get a license",
+				actionUrl: "https://copilotkit.ai/pricing",
+				onDismiss
+			});
+			default: return null;
+		}
+	}
+
+//#endregion
+//#region src/v2/components/MCPAppsActivityRenderer.tsx
+	const PROTOCOL_VERSION = "2025-06-18";
+	function buildSandboxHTML(extraCspDomains) {
+		const baseScriptSrc = "'self' 'wasm-unsafe-eval' 'unsafe-inline' 'unsafe-eval' blob: data: http://localhost:* https://localhost:*";
+		const baseFrameSrc = "* blob: data: http://localhost:* https://localhost:*";
+		const extra = (extraCspDomains === null || extraCspDomains === void 0 ? void 0 : extraCspDomains.length) ? " " + extraCspDomains.join(" ") : "";
+		return `<!doctype html>
+<html>
+<head>
+<meta charset="utf-8" />
+<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src * data: blob: 'unsafe-inline'; media-src * blob: data:; font-src * blob: data:; script-src ${baseScriptSrc + extra}; style-src * blob: data: 'unsafe-inline'; connect-src *; frame-src ${baseFrameSrc + extra}; base-uri 'self';" />
+<style>html,body{margin:0;padding:0;height:100%;width:100%;overflow:hidden}*{box-sizing:border-box}iframe{background-color:transparent;border:none;padding:0;overflow:hidden;width:100%;height:100%}</style>
+</head>
+<body>
+<script>
+if(window.self===window.top){throw new Error("This file must be used in an iframe.")}
+const inner=document.createElement("iframe");
+inner.style="width:100%;height:100%;border:none;";
+inner.setAttribute("sandbox","allow-scripts allow-same-origin allow-forms");
+document.body.appendChild(inner);
+window.addEventListener("message",async(event)=>{
+if(event.source===window.parent){
+if(event.data&&event.data.method==="ui/notifications/sandbox-resource-ready"){
+const{html,sandbox}=event.data.params;
+if(typeof sandbox==="string")inner.setAttribute("sandbox",sandbox);
+if(typeof html==="string")inner.srcdoc=html;
+}else if(inner&&inner.contentWindow){
+inner.contentWindow.postMessage(event.data,"*");
+}
+}else if(event.source===inner.contentWindow){
+window.parent.postMessage(event.data,"*");
+}
+});
+window.parent.postMessage({jsonrpc:"2.0",method:"ui/notifications/sandbox-proxy-ready",params:{}},"*");
+<\/script>
+</body>
+</html>`;
+	}
+	/**
+	* Queue for serializing MCP app requests to an agent.
+	* Ensures requests wait for the agent to stop running and are processed one at a time.
+	*/
+	var MCPAppsRequestQueue = class {
+		constructor() {
+			this.queues = /* @__PURE__ */ new Map();
+			this.processing = /* @__PURE__ */ new Map();
+		}
+		/**
+		* Add a request to the queue for a specific agent thread.
+		* Returns a promise that resolves when the request completes.
+		*/
+		async enqueue(agent, request) {
+			const threadId = agent.threadId || "default";
+			return new Promise((resolve, reject) => {
+				let queue = this.queues.get(threadId);
+				if (!queue) {
+					queue = [];
+					this.queues.set(threadId, queue);
+				}
+				queue.push({
+					execute: request,
+					resolve,
+					reject
+				});
+				this.processQueue(threadId, agent);
+			});
+		}
+		async processQueue(threadId, agent) {
+			if (this.processing.get(threadId)) return;
+			this.processing.set(threadId, true);
+			try {
+				const queue = this.queues.get(threadId);
+				if (!queue) return;
+				while (queue.length > 0) {
+					const item = queue[0];
+					try {
+						await this.waitForAgentIdle(agent);
+						const result = await item.execute();
+						item.resolve(result);
+					} catch (error) {
+						item.reject(error instanceof Error ? error : new Error(String(error)));
+					}
+					queue.shift();
+				}
+			} finally {
+				this.processing.set(threadId, false);
+			}
+		}
+		waitForAgentIdle(agent) {
+			return new Promise((resolve) => {
+				if (!agent.isRunning) {
+					resolve();
+					return;
+				}
+				let done = false;
+				const finish = () => {
+					if (done) return;
+					done = true;
+					clearInterval(checkInterval);
+					sub.unsubscribe();
+					resolve();
+				};
+				const sub = agent.subscribe({
+					onRunFinalized: finish,
+					onRunFailed: finish
+				});
+				const checkInterval = setInterval(() => {
+					if (!agent.isRunning) finish();
+				}, 500);
+			});
+		}
+	};
+	const mcpAppsRequestQueue = new MCPAppsRequestQueue();
+	/**
+	* Activity type for MCP Apps events - must match the middleware's MCPAppsActivityType
+	*/
+	const MCPAppsActivityType = "mcp-apps";
+	const MCPAppsActivityContentSchema = zod.z.object({
+		result: zod.z.object({
+			content: zod.z.array(zod.z.any()).optional(),
+			structuredContent: zod.z.any().optional(),
+			isError: zod.z.boolean().optional()
+		}),
+		resourceUri: zod.z.string(),
+		serverHash: zod.z.string(),
+		serverId: zod.z.string().optional(),
+		toolInput: zod.z.record(zod.z.unknown()).optional()
+	});
+	function isRequest(msg) {
+		return "id" in msg && "method" in msg;
+	}
+	function isNotification(msg) {
+		return !("id" in msg) && "method" in msg;
+	}
+	/**
+	* MCP Apps Extension Activity Renderer
+	*
+	* Renders MCP Apps UI in a sandboxed iframe with full protocol support.
+	* Fetches resource content on-demand via proxied MCP requests.
+	*/
+	const MCPAppsActivityRenderer = function MCPAppsActivityRenderer({ content, agent }) {
+		var _fetchedResource$_met2;
+		const containerRef = (0, react.useRef)(null);
+		const iframeRef = (0, react.useRef)(null);
+		const [iframeReady, setIframeReady] = (0, react.useState)(false);
+		const [error, setError] = (0, react.useState)(null);
+		const [isLoading, setIsLoading] = (0, react.useState)(true);
+		const [iframeSize, setIframeSize] = (0, react.useState)({});
+		const [fetchedResource, setFetchedResource] = (0, react.useState)(null);
+		const contentRef = (0, react.useRef)(content);
+		contentRef.current = content;
+		const agentRef = (0, react.useRef)(agent);
+		agentRef.current = agent;
+		const fetchStateRef = (0, react.useRef)({
+			inProgress: false,
+			promise: null,
+			resourceUri: null
+		});
+		const sendToIframe = (0, react.useCallback)((msg) => {
+			var _iframeRef$current;
+			if ((_iframeRef$current = iframeRef.current) === null || _iframeRef$current === void 0 ? void 0 : _iframeRef$current.contentWindow) {
+				console.log("[MCPAppsRenderer] Sending to iframe:", msg);
+				iframeRef.current.contentWindow.postMessage(msg, "*");
+			}
+		}, []);
+		const sendResponse = (0, react.useCallback)((id, result) => {
+			sendToIframe({
+				jsonrpc: "2.0",
+				id,
+				result
+			});
+		}, [sendToIframe]);
+		const sendErrorResponse = (0, react.useCallback)((id, code, message) => {
+			sendToIframe({
+				jsonrpc: "2.0",
+				id,
+				error: {
+					code,
+					message
+				}
+			});
+		}, [sendToIframe]);
+		const sendNotification = (0, react.useCallback)((method, params) => {
+			sendToIframe({
+				jsonrpc: "2.0",
+				method,
+				params: params || {}
+			});
+		}, [sendToIframe]);
+		(0, react.useEffect)(() => {
+			const { resourceUri, serverHash, serverId } = content;
+			if (fetchStateRef.current.inProgress && fetchStateRef.current.resourceUri === resourceUri) {
+				var _fetchStateRef$curren;
+				(_fetchStateRef$curren = fetchStateRef.current.promise) === null || _fetchStateRef$curren === void 0 || _fetchStateRef$curren.then((resource) => {
+					if (resource) {
+						setFetchedResource(resource);
+						setIsLoading(false);
+					}
+				}).catch((err) => {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setIsLoading(false);
+				});
+				return;
+			}
+			if (!agent) {
+				setError(/* @__PURE__ */ new Error("No agent available to fetch resource"));
+				setIsLoading(false);
+				return;
+			}
+			fetchStateRef.current.inProgress = true;
+			fetchStateRef.current.resourceUri = resourceUri;
+			const fetchPromise = (async () => {
+				try {
+					var _resultData$contents;
+					const resultData = (await mcpAppsRequestQueue.enqueue(agent, () => agent.runAgent({ forwardedProps: { __proxiedMCPRequest: {
+						serverHash,
+						serverId,
+						method: "resources/read",
+						params: { uri: resourceUri }
+					} } }))).result;
+					const resource = resultData === null || resultData === void 0 || (_resultData$contents = resultData.contents) === null || _resultData$contents === void 0 ? void 0 : _resultData$contents[0];
+					if (!resource) throw new Error("No resource content in response");
+					return resource;
+				} catch (err) {
+					console.error("[MCPAppsRenderer] Failed to fetch resource:", err);
+					throw err;
+				} finally {
+					fetchStateRef.current.inProgress = false;
+				}
+			})();
+			fetchStateRef.current.promise = fetchPromise;
+			fetchPromise.then((resource) => {
+				if (resource) {
+					setFetchedResource(resource);
+					setIsLoading(false);
+				}
+			}).catch((err) => {
+				setError(err instanceof Error ? err : new Error(String(err)));
+				setIsLoading(false);
+			});
+		}, [agent, content]);
+		(0, react.useEffect)(() => {
+			if (isLoading || !fetchedResource) return;
+			const container = containerRef.current;
+			if (!container) return;
+			let mounted = true;
+			let messageHandler = null;
+			let initialListener = null;
+			let createdIframe = null;
+			const setup = async () => {
+				try {
+					var _fetchedResource$_met;
+					const iframe = document.createElement("iframe");
+					createdIframe = iframe;
+					iframe.style.width = "100%";
+					iframe.style.height = "100px";
+					iframe.style.border = "none";
+					iframe.style.backgroundColor = "transparent";
+					iframe.style.display = "block";
+					iframe.setAttribute("sandbox", "allow-scripts allow-same-origin allow-forms");
+					const sandboxReady = new Promise((resolve) => {
+						initialListener = (event) => {
+							if (event.source === iframe.contentWindow) {
+								var _event$data;
+								if (((_event$data = event.data) === null || _event$data === void 0 ? void 0 : _event$data.method) === "ui/notifications/sandbox-proxy-ready") {
+									if (initialListener) {
+										window.removeEventListener("message", initialListener);
+										initialListener = null;
+									}
+									resolve();
+								}
+							}
+						};
+						window.addEventListener("message", initialListener);
+					});
+					if (!mounted) {
+						if (initialListener) {
+							window.removeEventListener("message", initialListener);
+							initialListener = null;
+						}
+						return;
+					}
+					iframe.srcdoc = buildSandboxHTML((_fetchedResource$_met = fetchedResource._meta) === null || _fetchedResource$_met === void 0 || (_fetchedResource$_met = _fetchedResource$_met.ui) === null || _fetchedResource$_met === void 0 || (_fetchedResource$_met = _fetchedResource$_met.csp) === null || _fetchedResource$_met === void 0 ? void 0 : _fetchedResource$_met.resourceDomains);
+					iframeRef.current = iframe;
+					container.appendChild(iframe);
+					await sandboxReady;
+					if (!mounted) return;
+					console.log("[MCPAppsRenderer] Sandbox proxy ready");
+					messageHandler = async (event) => {
+						if (event.source !== iframe.contentWindow) return;
+						const msg = event.data;
+						if (!msg || typeof msg !== "object" || msg.jsonrpc !== "2.0") return;
+						console.log("[MCPAppsRenderer] Received from iframe:", msg);
+						if (isRequest(msg)) switch (msg.method) {
+							case "ui/initialize":
+								sendResponse(msg.id, {
+									protocolVersion: PROTOCOL_VERSION,
+									hostInfo: {
+										name: "CopilotKit MCP Apps Host",
+										version: "1.0.0"
+									},
+									hostCapabilities: {
+										openLinks: {},
+										logging: {}
+									},
+									hostContext: {
+										theme: "light",
+										platform: "web"
+									}
+								});
+								break;
+							case "ui/message": {
+								const currentAgent = agentRef.current;
+								if (!currentAgent) {
+									console.warn("[MCPAppsRenderer] ui/message: No agent available");
+									sendResponse(msg.id, { isError: false });
+									break;
+								}
+								try {
+									var _params$content;
+									const params = msg.params;
+									const textContent = ((_params$content = params.content) === null || _params$content === void 0 ? void 0 : _params$content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n")) || "";
+									if (textContent) currentAgent.addMessage({
+										id: crypto.randomUUID(),
+										role: params.role || "user",
+										content: textContent
+									});
+									sendResponse(msg.id, { isError: false });
+								} catch (err) {
+									console.error("[MCPAppsRenderer] ui/message error:", err);
+									sendResponse(msg.id, { isError: true });
+								}
+								break;
+							}
+							case "ui/open-link": {
+								var _msg$params;
+								const url = (_msg$params = msg.params) === null || _msg$params === void 0 ? void 0 : _msg$params.url;
+								if (url) {
+									window.open(url, "_blank", "noopener,noreferrer");
+									sendResponse(msg.id, { isError: false });
+								} else sendErrorResponse(msg.id, -32602, "Missing url parameter");
+								break;
+							}
+							case "tools/call": {
+								const { serverHash, serverId } = contentRef.current;
+								const currentAgent = agentRef.current;
+								if (!serverHash) {
+									sendErrorResponse(msg.id, -32603, "No server hash available for proxying");
+									break;
+								}
+								if (!currentAgent) {
+									sendErrorResponse(msg.id, -32603, "No agent available for proxying");
+									break;
+								}
+								try {
+									const runResult = await mcpAppsRequestQueue.enqueue(currentAgent, () => currentAgent.runAgent({ forwardedProps: { __proxiedMCPRequest: {
+										serverHash,
+										serverId,
+										method: "tools/call",
+										params: msg.params
+									} } }));
+									sendResponse(msg.id, runResult.result || {});
+								} catch (err) {
+									console.error("[MCPAppsRenderer] tools/call error:", err);
+									sendErrorResponse(msg.id, -32603, String(err));
+								}
+								break;
+							}
+							default: sendErrorResponse(msg.id, -32601, `Method not found: ${msg.method}`);
+						}
+						if (isNotification(msg)) switch (msg.method) {
+							case "ui/notifications/initialized":
+								console.log("[MCPAppsRenderer] Inner iframe initialized");
+								if (mounted) setIframeReady(true);
+								break;
+							case "ui/notifications/size-changed": {
+								const { width, height } = msg.params || {};
+								console.log("[MCPAppsRenderer] Size change:", {
+									width,
+									height
+								});
+								if (mounted) setIframeSize({
+									width: typeof width === "number" ? width : void 0,
+									height: typeof height === "number" ? height : void 0
+								});
+								break;
+							}
+							case "notifications/message":
+								console.log("[MCPAppsRenderer] App log:", msg.params);
+								break;
+						}
+					};
+					window.addEventListener("message", messageHandler);
+					let html;
+					if (fetchedResource.text) html = fetchedResource.text;
+					else if (fetchedResource.blob) html = atob(fetchedResource.blob);
+					else throw new Error("Resource has no text or blob content");
+					sendNotification("ui/notifications/sandbox-resource-ready", { html });
+				} catch (err) {
+					console.error("[MCPAppsRenderer] Setup error:", err);
+					if (mounted) setError(err instanceof Error ? err : new Error(String(err)));
+				}
+			};
+			setup();
+			return () => {
+				mounted = false;
+				if (initialListener) {
+					window.removeEventListener("message", initialListener);
+					initialListener = null;
+				}
+				if (messageHandler) window.removeEventListener("message", messageHandler);
+				if (createdIframe) {
+					createdIframe.remove();
+					createdIframe = null;
+				}
+				iframeRef.current = null;
+			};
+		}, [
+			isLoading,
+			fetchedResource,
+			sendNotification,
+			sendResponse,
+			sendErrorResponse
+		]);
+		(0, react.useEffect)(() => {
+			if (iframeRef.current) {
+				if (iframeSize.width !== void 0) {
+					iframeRef.current.style.minWidth = `min(${iframeSize.width}px, 100%)`;
+					iframeRef.current.style.width = "100%";
+				}
+				if (iframeSize.height !== void 0) iframeRef.current.style.height = `${iframeSize.height}px`;
+			}
+		}, [iframeSize]);
+		(0, react.useEffect)(() => {
+			if (iframeReady && content.toolInput) {
+				console.log("[MCPAppsRenderer] Sending tool input:", content.toolInput);
+				sendNotification("ui/notifications/tool-input", { arguments: content.toolInput });
+			}
+		}, [
+			iframeReady,
+			content.toolInput,
+			sendNotification
+		]);
+		(0, react.useEffect)(() => {
+			if (iframeReady && content.result) {
+				console.log("[MCPAppsRenderer] Sending tool result:", content.result);
+				sendNotification("ui/notifications/tool-result", content.result);
+			}
+		}, [
+			iframeReady,
+			content.result,
+			sendNotification
+		]);
+		const borderStyle = (fetchedResource === null || fetchedResource === void 0 || (_fetchedResource$_met2 = fetchedResource._meta) === null || _fetchedResource$_met2 === void 0 || (_fetchedResource$_met2 = _fetchedResource$_met2.ui) === null || _fetchedResource$_met2 === void 0 ? void 0 : _fetchedResource$_met2.prefersBorder) === true ? {
+			borderRadius: "8px",
+			backgroundColor: "#f9f9f9",
+			border: "1px solid #e0e0e0"
+		} : {};
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			ref: containerRef,
+			style: {
+				width: "100%",
+				height: iframeSize.height ? `${iframeSize.height}px` : "auto",
+				minHeight: "100px",
+				overflow: "hidden",
+				position: "relative",
+				...borderStyle
+			},
+			children: [isLoading && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: {
+					padding: "1rem",
+					color: "#666"
+				},
+				children: "Loading..."
+			}), error && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: {
+					color: "red",
+					padding: "1rem"
+				},
+				children: ["Error: ", error.message]
+			})]
+		});
+	};
+
+//#endregion
+//#region src/v2/a2ui/A2UIMessageRenderer.tsx
+	let initialized = false;
+	function ensureInitialized() {
+		if (!initialized) {
+			(0, _copilotkit_a2ui_renderer.initializeDefaultCatalog)();
+			(0, _copilotkit_a2ui_renderer.injectStyles)();
+			initialized = true;
+		}
+	}
+	function createA2UIMessageRenderer(options) {
+		const { theme } = options;
+		return {
+			activityType: "a2ui-surface",
+			content: zod.z.any(),
+			render: ({ content, agent }) => {
+				ensureInitialized();
+				const [operations, setOperations] = (0, react.useState)([]);
+				const lastSignatureRef = (0, react.useRef)(null);
+				const { copilotkit } = useCopilotKit();
+				(0, react.useEffect)(() => {
+					if (!content || !Array.isArray(content.operations)) {
+						lastSignatureRef.current = null;
+						setOperations([]);
+						return;
+					}
+					const incoming = content.operations;
+					const signature = stringifyOperations(incoming);
+					if (signature && signature === lastSignatureRef.current) return;
+					lastSignatureRef.current = signature;
+					setOperations(incoming);
+				}, [content]);
+				const groupedOperations = (0, react.useMemo)(() => {
+					const groups = /* @__PURE__ */ new Map();
+					for (const operation of operations) {
+						var _getOperationSurfaceI;
+						const surfaceId = (_getOperationSurfaceI = getOperationSurfaceId(operation)) !== null && _getOperationSurfaceI !== void 0 ? _getOperationSurfaceI : _copilotkit_a2ui_renderer.DEFAULT_SURFACE_ID;
+						if (!groups.has(surfaceId)) groups.set(surfaceId, []);
+						groups.get(surfaceId).push(operation);
+					}
+					return groups;
+				}, [operations]);
+				if (!groupedOperations.size) return null;
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					className: "cpk:flex cpk:min-h-0 cpk:flex-1 cpk:flex-col cpk:gap-6 cpk:overflow-auto cpk:py-6",
+					children: Array.from(groupedOperations.entries()).map(([surfaceId, ops]) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReactSurfaceHost, {
+						surfaceId,
+						operations: ops,
+						theme,
+						agent,
+						copilotkit
+					}, surfaceId))
+				});
+			}
+		};
+	}
+	/**
+	* Renders a single A2UI surface using the React renderer.
+	* Wraps A2UIProvider + A2UIRenderer and bridges actions back to CopilotKit.
+	*/
+	function ReactSurfaceHost({ surfaceId, operations, theme, agent, copilotkit }) {
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			className: "cpk:flex cpk:w-full cpk:flex-none cpk:flex-col cpk:gap-4",
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(_copilotkit_a2ui_renderer.A2UIProvider, {
+				onAction: (0, react.useCallback)(async (message) => {
+					if (!agent) return;
+					try {
+						var _copilotkit$propertie;
+						console.info("[A2UI] Action dispatched", message.userAction);
+						copilotkit.setProperties({
+							...(_copilotkit$propertie = copilotkit.properties) !== null && _copilotkit$propertie !== void 0 ? _copilotkit$propertie : {},
+							a2uiAction: message
+						});
+						await copilotkit.runAgent({ agent });
+					} finally {
+						if (copilotkit.properties) {
+							const { a2uiAction, ...rest } = copilotkit.properties;
+							copilotkit.setProperties(rest);
+						}
+					}
+				}, [agent, copilotkit]),
+				theme,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(SurfaceMessageProcessor, {
+					surfaceId,
+					operations
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_copilotkit_a2ui_renderer.A2UIRenderer, {
+					surfaceId,
+					className: "cpk:flex cpk:flex-1"
+				})]
+			})
+		});
+	}
+	/**
+	* Processes A2UI operations into the provider's message processor.
+	* Must be a child of A2UIProvider to access the actions context.
+	*/
+	function SurfaceMessageProcessor({ surfaceId, operations }) {
+		const { processMessages } = (0, _copilotkit_a2ui_renderer.useA2UIActions)();
+		const lastProcessedRef = (0, react.useRef)("");
+		(0, react.useEffect)(() => {
+			const key = `${surfaceId}-${JSON.stringify(operations)}`;
+			if (key === lastProcessedRef.current) return;
+			lastProcessedRef.current = key;
+			processMessages(operations);
+		}, [
+			processMessages,
+			surfaceId,
+			operations
+		]);
+		return null;
+	}
+	function getOperationSurfaceId(operation) {
+		var _ref, _ref2, _ref3, _operation$beginRende, _operation$beginRende2, _operation$surfaceUpd, _operation$dataModelU, _operation$deleteSurf;
+		if (!operation || typeof operation !== "object") return null;
+		if (typeof operation.surfaceId === "string") return operation.surfaceId;
+		return (_ref = (_ref2 = (_ref3 = (_operation$beginRende = operation === null || operation === void 0 || (_operation$beginRende2 = operation.beginRendering) === null || _operation$beginRende2 === void 0 ? void 0 : _operation$beginRende2.surfaceId) !== null && _operation$beginRende !== void 0 ? _operation$beginRende : operation === null || operation === void 0 || (_operation$surfaceUpd = operation.surfaceUpdate) === null || _operation$surfaceUpd === void 0 ? void 0 : _operation$surfaceUpd.surfaceId) !== null && _ref3 !== void 0 ? _ref3 : operation === null || operation === void 0 || (_operation$dataModelU = operation.dataModelUpdate) === null || _operation$dataModelU === void 0 ? void 0 : _operation$dataModelU.surfaceId) !== null && _ref2 !== void 0 ? _ref2 : operation === null || operation === void 0 || (_operation$deleteSurf = operation.deleteSurface) === null || _operation$deleteSurf === void 0 ? void 0 : _operation$deleteSurf.surfaceId) !== null && _ref !== void 0 ? _ref : null;
+	}
+	function stringifyOperations(ops) {
+		try {
+			return JSON.stringify(ops);
+		} catch (error) {
+			return null;
+		}
+	}
+
+//#endregion
+//#region src/v2/lib/react-core.ts
+	var CopilotKitCoreReact = class extends _copilotkit_core.CopilotKitCore {
+		constructor(config) {
+			var _config$renderToolCal, _config$renderCustomM, _config$renderActivit;
+			super(config);
+			this._renderToolCalls = [];
+			this._hookRenderToolCalls = /* @__PURE__ */ new Map();
+			this._cachedMergedRenderToolCalls = null;
+			this._renderCustomMessages = [];
+			this._renderActivityMessages = [];
+			this._interruptElement = null;
+			this._renderToolCalls = (_config$renderToolCal = config.renderToolCalls) !== null && _config$renderToolCal !== void 0 ? _config$renderToolCal : [];
+			this._renderCustomMessages = (_config$renderCustomM = config.renderCustomMessages) !== null && _config$renderCustomM !== void 0 ? _config$renderCustomM : [];
+			this._renderActivityMessages = (_config$renderActivit = config.renderActivityMessages) !== null && _config$renderActivit !== void 0 ? _config$renderActivit : [];
+		}
+		get renderCustomMessages() {
+			return this._renderCustomMessages;
+		}
+		get renderActivityMessages() {
+			return this._renderActivityMessages;
+		}
+		get renderToolCalls() {
+			if (this._hookRenderToolCalls.size === 0) return this._renderToolCalls;
+			if (this._cachedMergedRenderToolCalls) return this._cachedMergedRenderToolCalls;
+			const merged = /* @__PURE__ */ new Map();
+			for (const rc of this._renderToolCalls) {
+				var _rc$agentId;
+				merged.set(`${(_rc$agentId = rc.agentId) !== null && _rc$agentId !== void 0 ? _rc$agentId : ""}:${rc.name}`, rc);
+			}
+			for (const [key, rc] of this._hookRenderToolCalls) merged.set(key, rc);
+			this._cachedMergedRenderToolCalls = Array.from(merged.values());
+			return this._cachedMergedRenderToolCalls;
+		}
+		setRenderActivityMessages(renderers) {
+			this._renderActivityMessages = renderers;
+		}
+		setRenderCustomMessages(renderers) {
+			this._renderCustomMessages = renderers;
+		}
+		setRenderToolCalls(renderToolCalls) {
+			this._renderToolCalls = renderToolCalls;
+			this._cachedMergedRenderToolCalls = null;
+			this._notifyRenderToolCallsChanged();
+		}
+		addHookRenderToolCall(entry) {
+			var _entry$agentId;
+			const key = `${(_entry$agentId = entry.agentId) !== null && _entry$agentId !== void 0 ? _entry$agentId : ""}:${entry.name}`;
+			this._hookRenderToolCalls.set(key, entry);
+			this._cachedMergedRenderToolCalls = null;
+			this._notifyRenderToolCallsChanged();
+		}
+		removeHookRenderToolCall(name, agentId) {
+			const key = `${agentId !== null && agentId !== void 0 ? agentId : ""}:${name}`;
+			if (this._hookRenderToolCalls.delete(key)) {
+				this._cachedMergedRenderToolCalls = null;
+				this._notifyRenderToolCallsChanged();
+			}
+		}
+		_notifyRenderToolCallsChanged() {
+			this.notifySubscribers((subscriber) => {
+				const reactSubscriber = subscriber;
+				if (reactSubscriber.onRenderToolCallsChanged) reactSubscriber.onRenderToolCallsChanged({
+					copilotkit: this,
+					renderToolCalls: this.renderToolCalls
+				});
+			}, "Subscriber onRenderToolCallsChanged error:");
+		}
+		get interruptElement() {
+			return this._interruptElement;
+		}
+		setInterruptElement(element) {
+			this._interruptElement = element;
+			this.notifySubscribers((subscriber) => {
+				var _reactSubscriber$onIn;
+				const reactSubscriber = subscriber;
+				(_reactSubscriber$onIn = reactSubscriber.onInterruptElementChanged) === null || _reactSubscriber$onIn === void 0 || _reactSubscriber$onIn.call(reactSubscriber, {
+					copilotkit: this,
+					interruptElement: this._interruptElement
+				});
+			}, "Subscriber onInterruptElementChanged error:");
+		}
+		subscribe(subscriber) {
+			return super.subscribe(subscriber);
+		}
+		/**
+		* Wait for pending React state updates before the follow-up agent run.
+		*
+		* When a frontend tool handler calls setState(), React 18 batches the update
+		* and schedules a commit via its internal scheduler (MessageChannel). The
+		* useAgentContext hook registers context via useLayoutEffect, which runs
+		* synchronously after React commits that batch.
+		*
+		* Awaiting a zero-delay timeout yields to the macrotask queue. React's
+		* MessageChannel task runs first, committing the pending state and running
+		* useLayoutEffect (which updates the context store). The follow-up runAgent
+		* call then reads fresh context.
+		*/
+		async waitForPendingFrameworkUpdates() {
+			await new Promise((resolve) => setTimeout(resolve, 0));
+		}
+	};
+
+//#endregion
+//#region src/v2/providers/CopilotKitProvider.tsx
+	const HEADER_NAME = "X-CopilotCloud-Public-Api-Key";
+	const COPILOT_CLOUD_CHAT_URL$1 = "https://api.cloud.copilotkit.ai/copilotkit/v1";
+	const CopilotKitContext = (0, react.createContext)({
+		copilotkit: null,
+		executingToolCallIds: /* @__PURE__ */ new Set()
+	});
+	const LicenseContext = (0, react.createContext)((0, _copilotkit_shared.createLicenseContextValue)(null));
+	function useStableArrayProp(prop, warningMessage, isMeaningfulChange) {
+		const empty = (0, react.useMemo)(() => [], []);
+		const value = prop !== null && prop !== void 0 ? prop : empty;
+		const initial = (0, react.useRef)(value);
+		(0, react.useEffect)(() => {
+			if (warningMessage && value !== initial.current && (isMeaningfulChange ? isMeaningfulChange(initial.current, value) : true)) console.error(warningMessage);
+		}, [value, warningMessage]);
+		return value;
+	}
+	const CopilotKitProvider = ({ children, runtimeUrl, headers = {}, credentials, publicApiKey, publicLicenseKey, licenseToken, properties = {}, agents__unsafe_dev_only: agents = {}, selfManagedAgents = {}, renderToolCalls, renderActivityMessages, renderCustomMessages, frontendTools, humanInTheLoop, showDevConsole = false, useSingleEndpoint = false, onError, a2ui }) => {
+		const [shouldRenderInspector, setShouldRenderInspector] = (0, react.useState)(false);
+		const [runtimeA2UIEnabled, setRuntimeA2UIEnabled] = (0, react.useState)(false);
+		const [runtimeLicenseStatus, setRuntimeLicenseStatus] = (0, react.useState)(void 0);
+		(0, react.useEffect)(() => {
+			if (typeof window === "undefined") return;
+			if (showDevConsole === true) setShouldRenderInspector(true);
+			else if (showDevConsole === "auto") if (new Set(["localhost", "127.0.0.1"]).has(window.location.hostname)) setShouldRenderInspector(true);
+			else setShouldRenderInspector(false);
+			else setShouldRenderInspector(false);
+		}, [showDevConsole]);
+		const renderToolCallsList = useStableArrayProp(renderToolCalls, "renderToolCalls must be a stable array. If you want to dynamically add or remove tools, use `useFrontendTool` instead.", (initial, next) => {
+			const key = (rc) => {
+				var _rc$agentId, _rc$name;
+				return `${(_rc$agentId = rc === null || rc === void 0 ? void 0 : rc.agentId) !== null && _rc$agentId !== void 0 ? _rc$agentId : ""}:${(_rc$name = rc === null || rc === void 0 ? void 0 : rc.name) !== null && _rc$name !== void 0 ? _rc$name : ""}`;
+			};
+			const setFrom = (arr) => new Set(arr.map(key));
+			const a = setFrom(initial);
+			const b = setFrom(next);
+			if (a.size !== b.size) return true;
+			for (const k of a) if (!b.has(k)) return true;
+			return false;
+		});
+		const renderCustomMessagesList = useStableArrayProp(renderCustomMessages, "renderCustomMessages must be a stable array.");
+		const renderActivityMessagesList = useStableArrayProp(renderActivityMessages, "renderActivityMessages must be a stable array.");
+		const builtInActivityRenderers = (0, react.useMemo)(() => {
+			const renderers = [{
+				activityType: MCPAppsActivityType,
+				content: MCPAppsActivityContentSchema,
+				render: MCPAppsActivityRenderer
+			}];
+			if (runtimeA2UIEnabled) {
+				var _a2ui$theme;
+				renderers.unshift(createA2UIMessageRenderer({ theme: (_a2ui$theme = a2ui === null || a2ui === void 0 ? void 0 : a2ui.theme) !== null && _a2ui$theme !== void 0 ? _a2ui$theme : _copilotkit_a2ui_renderer.viewerTheme }));
+			}
+			return renderers;
+		}, [runtimeA2UIEnabled, a2ui]);
+		const allActivityRenderers = (0, react.useMemo)(() => {
+			return [...renderActivityMessagesList, ...builtInActivityRenderers];
+		}, [renderActivityMessagesList, builtInActivityRenderers]);
+		const resolvedPublicKey = publicApiKey !== null && publicApiKey !== void 0 ? publicApiKey : publicLicenseKey;
+		const mergedAgents = (0, react.useMemo)(() => ({
+			...agents,
+			...selfManagedAgents
+		}), [agents, selfManagedAgents]);
+		const hasLocalAgents = mergedAgents && Object.keys(mergedAgents).length > 0;
+		const mergedHeaders = (0, react.useMemo)(() => {
+			if (!resolvedPublicKey) return headers;
+			if (headers[HEADER_NAME]) return headers;
+			return {
+				...headers,
+				[HEADER_NAME]: resolvedPublicKey
+			};
+		}, [headers, resolvedPublicKey]);
+		if (!runtimeUrl && !resolvedPublicKey && !hasLocalAgents) {
+			const message = "Missing required prop: 'runtimeUrl' or 'publicApiKey' or 'publicLicenseKey'";
+			if (process.env.NODE_ENV === "production") throw new Error(message);
+			else console.warn(message);
+		}
+		const chatApiEndpoint = runtimeUrl !== null && runtimeUrl !== void 0 ? runtimeUrl : resolvedPublicKey ? COPILOT_CLOUD_CHAT_URL$1 : void 0;
+		const frontendToolsList = useStableArrayProp(frontendTools, "frontendTools must be a stable array. If you want to dynamically add or remove tools, use `useFrontendTool` instead.");
+		const humanInTheLoopList = useStableArrayProp(humanInTheLoop, "humanInTheLoop must be a stable array. If you want to dynamically add or remove human-in-the-loop tools, use `useHumanInTheLoop` instead.");
+		const processedHumanInTheLoopTools = (0, react.useMemo)(() => {
+			const processedTools = [];
+			const processedRenderToolCalls = [];
+			humanInTheLoopList.forEach((tool) => {
+				const frontendTool = {
+					name: tool.name,
+					description: tool.description,
+					parameters: tool.parameters,
+					followUp: tool.followUp,
+					...tool.agentId && { agentId: tool.agentId },
+					handler: async () => {
+						return new Promise((resolve) => {
+							console.warn(`Human-in-the-loop tool '${tool.name}' called but no interactive handler is set up.`);
+							resolve(void 0);
+						});
+					}
+				};
+				processedTools.push(frontendTool);
+				if (tool.render) processedRenderToolCalls.push({
+					name: tool.name,
+					args: tool.parameters,
+					render: tool.render,
+					...tool.agentId && { agentId: tool.agentId }
+				});
+			});
+			return {
+				tools: processedTools,
+				renderToolCalls: processedRenderToolCalls
+			};
+		}, [humanInTheLoopList]);
+		const allTools = (0, react.useMemo)(() => {
+			const tools = [];
+			tools.push(...frontendToolsList);
+			tools.push(...processedHumanInTheLoopTools.tools);
+			return tools;
+		}, [frontendToolsList, processedHumanInTheLoopTools]);
+		const allRenderToolCalls = (0, react.useMemo)(() => {
+			const combined = [...renderToolCallsList];
+			frontendToolsList.forEach((tool) => {
+				if (tool.render) {
+					const args = tool.parameters || (tool.name === "*" ? zod.z.any() : void 0);
+					if (args) combined.push({
+						name: tool.name,
+						args,
+						render: tool.render
+					});
+				}
+			});
+			combined.push(...processedHumanInTheLoopTools.renderToolCalls);
+			return combined;
+		}, [
+			renderToolCallsList,
+			frontendToolsList,
+			processedHumanInTheLoopTools
+		]);
+		const copilotkitRef = (0, react.useRef)(null);
+		if (copilotkitRef.current === null) copilotkitRef.current = new CopilotKitCoreReact({
+			runtimeUrl: chatApiEndpoint,
+			runtimeTransport: useSingleEndpoint ? "single" : "rest",
+			headers: mergedHeaders,
+			credentials,
+			properties,
+			agents__unsafe_dev_only: mergedAgents,
+			tools: allTools,
+			renderToolCalls: allRenderToolCalls,
+			renderActivityMessages: allActivityRenderers,
+			renderCustomMessages: renderCustomMessagesList
+		});
+		const copilotkit = copilotkitRef.current;
+		(0, react.useEffect)(() => {
+			const subscription = copilotkit.subscribe({ onRuntimeConnectionStatusChanged: () => {
+				setRuntimeA2UIEnabled(copilotkit.a2uiEnabled);
+				setRuntimeLicenseStatus(copilotkit.licenseStatus);
+			} });
+			return () => {
+				subscription.unsubscribe();
+			};
+		}, [copilotkit]);
+		const [, forceUpdate] = (0, react.useReducer)((x) => x + 1, 0);
+		(0, react.useEffect)(() => {
+			const subscription = copilotkit.subscribe({ onRenderToolCallsChanged: () => {
+				forceUpdate();
+			} });
+			return () => {
+				subscription.unsubscribe();
+			};
+		}, [copilotkit]);
+		const [executingToolCallIds, setExecutingToolCallIds] = (0, react.useState)(() => /* @__PURE__ */ new Set());
+		(0, react.useEffect)(() => {
+			const subscription = copilotkit.subscribe({
+				onToolExecutionStart: ({ toolCallId }) => {
+					setExecutingToolCallIds((prev) => {
+						if (prev.has(toolCallId)) return prev;
+						const next = new Set(prev);
+						next.add(toolCallId);
+						return next;
+					});
+				},
+				onToolExecutionEnd: ({ toolCallId }) => {
+					setExecutingToolCallIds((prev) => {
+						if (!prev.has(toolCallId)) return prev;
+						const next = new Set(prev);
+						next.delete(toolCallId);
+						return next;
+					});
+				}
+			});
+			return () => {
+				subscription.unsubscribe();
+			};
+		}, [copilotkit]);
+		const onErrorRef = (0, react.useRef)(onError);
+		(0, react.useEffect)(() => {
+			onErrorRef.current = onError;
+		}, [onError]);
+		(0, react.useEffect)(() => {
+			if (!onErrorRef.current) return;
+			const subscription = copilotkit.subscribe({ onError: (event) => {
+				var _onErrorRef$current;
+				(_onErrorRef$current = onErrorRef.current) === null || _onErrorRef$current === void 0 || _onErrorRef$current.call(onErrorRef, {
+					error: event.error,
+					code: event.code,
+					context: event.context
+				});
+			} });
+			return () => {
+				subscription.unsubscribe();
+			};
+		}, [copilotkit]);
+		(0, react.useEffect)(() => {
+			copilotkit.setRuntimeUrl(chatApiEndpoint);
+			copilotkit.setRuntimeTransport(useSingleEndpoint ? "single" : "rest");
+			copilotkit.setHeaders(mergedHeaders);
+			copilotkit.setCredentials(credentials);
+			copilotkit.setProperties(properties);
+			copilotkit.setAgents__unsafe_dev_only(mergedAgents);
+		}, [
+			copilotkit,
+			chatApiEndpoint,
+			mergedHeaders,
+			credentials,
+			properties,
+			mergedAgents,
+			useSingleEndpoint
+		]);
+		const didMountRef = (0, react.useRef)(false);
+		(0, react.useEffect)(() => {
+			if (!didMountRef.current) return;
+			copilotkit.setTools(allTools);
+		}, [copilotkit, allTools]);
+		(0, react.useEffect)(() => {
+			if (!didMountRef.current) return;
+			copilotkit.setRenderToolCalls(allRenderToolCalls);
+		}, [copilotkit, allRenderToolCalls]);
+		(0, react.useEffect)(() => {
+			if (!didMountRef.current) return;
+			copilotkit.setRenderActivityMessages(allActivityRenderers);
+		}, [copilotkit, allActivityRenderers]);
+		(0, react.useEffect)(() => {
+			if (!didMountRef.current) return;
+			copilotkit.setRenderCustomMessages(renderCustomMessagesList);
+		}, [copilotkit, renderCustomMessagesList]);
+		(0, react.useEffect)(() => {
+			didMountRef.current = true;
+		}, []);
+		const contextValue = (0, react.useMemo)(() => ({
+			copilotkit,
+			executingToolCallIds
+		}), [copilotkit, executingToolCallIds]);
+		const licenseContextValue = (0, react.useMemo)(() => (0, _copilotkit_shared.createLicenseContextValue)(null), []);
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotKitContext.Provider, {
+			value: contextValue,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(LicenseContext.Provider, {
+				value: licenseContextValue,
+				children: [
+					children,
+					shouldRenderInspector ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotKitInspector, { core: copilotkit }) : null,
+					runtimeLicenseStatus === "none" && !resolvedPublicKey && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LicenseWarningBanner, { type: "no_license" }),
+					runtimeLicenseStatus === "expired" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LicenseWarningBanner, { type: "expired" }),
+					runtimeLicenseStatus === "invalid" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LicenseWarningBanner, { type: "invalid" }),
+					runtimeLicenseStatus === "expiring" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LicenseWarningBanner, { type: "expiring" })
+				]
+			})
+		});
+	};
+	const useCopilotKit = () => {
+		const context = (0, react.useContext)(CopilotKitContext);
+		const [, forceUpdate] = (0, react.useReducer)((x) => x + 1, 0);
+		if (!context) throw new Error("useCopilotKit must be used within CopilotKitProvider");
+		(0, react.useEffect)(() => {
+			const subscription = context.copilotkit.subscribe({ onRuntimeConnectionStatusChanged: () => {
+				forceUpdate();
+			} });
+			return () => {
+				subscription.unsubscribe();
+			};
+		}, []);
+		return context;
+	};
+
+//#endregion
+//#region src/v2/hooks/use-render-tool-call.tsx
+/**
+	* Memoized component that renders a single tool call.
+	* This prevents unnecessary re-renders when parent components update
+	* but the tool call data hasn't changed.
+	*/
+	const ToolCallRenderer = react.default.memo(function ToolCallRenderer({ toolCall, toolMessage, RenderComponent, isExecuting }) {
+		const args = (0, react.useMemo)(() => (0, _copilotkit_shared.partialJSONParse)(toolCall.function.arguments), [toolCall.function.arguments]);
+		const toolName = toolCall.function.name;
+		if (toolMessage) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RenderComponent, {
+			name: toolName,
+			args,
+			status: _copilotkit_core.ToolCallStatus.Complete,
+			result: toolMessage.content
+		});
+		else if (isExecuting) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RenderComponent, {
+			name: toolName,
+			args,
+			status: _copilotkit_core.ToolCallStatus.Executing,
+			result: void 0
+		});
+		else return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RenderComponent, {
+			name: toolName,
+			args,
+			status: _copilotkit_core.ToolCallStatus.InProgress,
+			result: void 0
+		});
+	}, (prevProps, nextProps) => {
+		var _prevProps$toolMessag, _nextProps$toolMessag;
+		if (prevProps.toolCall.id !== nextProps.toolCall.id) return false;
+		if (prevProps.toolCall.function.name !== nextProps.toolCall.function.name) return false;
+		if (prevProps.toolCall.function.arguments !== nextProps.toolCall.function.arguments) return false;
+		if (((_prevProps$toolMessag = prevProps.toolMessage) === null || _prevProps$toolMessag === void 0 ? void 0 : _prevProps$toolMessag.content) !== ((_nextProps$toolMessag = nextProps.toolMessage) === null || _nextProps$toolMessag === void 0 ? void 0 : _nextProps$toolMessag.content)) return false;
+		if (prevProps.isExecuting !== nextProps.isExecuting) return false;
+		if (prevProps.RenderComponent !== nextProps.RenderComponent) return false;
+		return true;
+	});
+	/**
+	* Hook that returns a function to render tool calls based on the render functions
+	* defined in CopilotKitProvider.
+	*
+	* @returns A function that takes a tool call and optional tool message and returns the rendered component
+	*/
+	function useRenderToolCall$1() {
+		var _config$agentId;
+		const { copilotkit, executingToolCallIds } = useCopilotKit();
+		const config = useCopilotChatConfiguration();
+		const agentId = (_config$agentId = config === null || config === void 0 ? void 0 : config.agentId) !== null && _config$agentId !== void 0 ? _config$agentId : _copilotkit_shared.DEFAULT_AGENT_ID;
+		const renderToolCalls = (0, react.useSyncExternalStore)((callback) => {
+			return copilotkit.subscribe({ onRenderToolCallsChanged: callback }).unsubscribe;
+		}, () => copilotkit.renderToolCalls, () => copilotkit.renderToolCalls);
+		return (0, react.useCallback)(({ toolCall, toolMessage }) => {
+			const exactMatches = renderToolCalls.filter((rc) => rc.name === toolCall.function.name);
+			const renderConfig = exactMatches.find((rc) => rc.agentId === agentId) || exactMatches.find((rc) => !rc.agentId) || exactMatches[0] || renderToolCalls.find((rc) => rc.name === "*");
+			if (!renderConfig) return null;
+			const RenderComponent = renderConfig.render;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ToolCallRenderer, {
+				toolCall,
+				toolMessage,
+				RenderComponent,
+				isExecuting: executingToolCallIds.has(toolCall.id)
+			}, toolCall.id);
+		}, [
+			renderToolCalls,
+			executingToolCallIds,
+			agentId
+		]);
+	}
+
+//#endregion
+//#region src/v2/hooks/use-render-custom-messages.tsx
+	function useRenderCustomMessages() {
+		const { copilotkit } = useCopilotKit();
+		const config = useCopilotChatConfiguration();
+		if (!config) return null;
+		const { agentId, threadId } = config;
+		const customMessageRenderers = copilotkit.renderCustomMessages.filter((renderer) => renderer.agentId === void 0 || renderer.agentId === agentId).sort((a, b) => {
+			const aHasAgent = a.agentId !== void 0;
+			if (aHasAgent === (b.agentId !== void 0)) return 0;
+			return aHasAgent ? -1 : 1;
+		});
+		return function(params) {
+			var _copilotkit$getRunIdF;
+			if (!customMessageRenderers.length) return null;
+			const { message, position } = params;
+			const resolvedRunId = (_copilotkit$getRunIdF = copilotkit.getRunIdForMessage(agentId, threadId, message.id)) !== null && _copilotkit$getRunIdF !== void 0 ? _copilotkit$getRunIdF : copilotkit.getRunIdsForThread(agentId, threadId).slice(-1)[0];
+			const runId = resolvedRunId !== null && resolvedRunId !== void 0 ? resolvedRunId : `missing-run-id:${message.id}`;
+			const agent = copilotkit.getAgent(agentId);
+			if (!agent) throw new Error("Agent not found");
+			const messagesIdsInRun = resolvedRunId ? agent.messages.filter((msg) => copilotkit.getRunIdForMessage(agentId, threadId, msg.id) === resolvedRunId).map((msg) => msg.id) : [message.id];
+			const rawMessageIndex = agent.messages.findIndex((msg) => msg.id === message.id);
+			const messageIndex = rawMessageIndex >= 0 ? rawMessageIndex : 0;
+			const messageIndexInRun = resolvedRunId ? Math.max(messagesIdsInRun.indexOf(message.id), 0) : 0;
+			const numberOfMessagesInRun = resolvedRunId ? messagesIdsInRun.length : 1;
+			const stateSnapshot = resolvedRunId ? copilotkit.getStateByRun(agentId, threadId, resolvedRunId) : void 0;
+			let result = null;
+			for (const renderer of customMessageRenderers) {
+				if (!renderer.render) continue;
+				const Component = renderer.render;
+				result = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Component, {
+					message,
+					position,
+					runId,
+					messageIndex,
+					messageIndexInRun,
+					numberOfMessagesInRun,
+					agentId,
+					stateSnapshot
+				}, `${runId}-${message.id}-${position}`);
+				if (result) break;
+			}
+			return result;
+		};
+	}
+
+//#endregion
+//#region src/v2/hooks/use-frontend-tool.tsx
+	const EMPTY_DEPS = [];
+	function useFrontendTool$1(tool, deps) {
+		const { copilotkit } = useCopilotKit();
+		const extraDeps = deps !== null && deps !== void 0 ? deps : EMPTY_DEPS;
+		(0, react.useEffect)(() => {
+			const name = tool.name;
+			if (copilotkit.getTool({
+				toolName: name,
+				agentId: tool.agentId
+			})) {
+				console.warn(`Tool '${name}' already exists for agent '${tool.agentId || "global"}'. Overriding with latest registration.`);
+				copilotkit.removeTool(name, tool.agentId);
+			}
+			copilotkit.addTool(tool);
+			if (tool.render && tool.parameters) copilotkit.addHookRenderToolCall({
+				name,
+				args: tool.parameters,
+				agentId: tool.agentId,
+				render: tool.render
+			});
+			return () => {
+				copilotkit.removeTool(name, tool.agentId);
+			};
+		}, [
+			tool.name,
+			tool.available,
+			copilotkit,
+			extraDeps.length,
+			...extraDeps
+		]);
+	}
+
+//#endregion
+//#region src/v2/types/defineToolCallRenderer.ts
+	function defineToolCallRenderer(def) {
+		const argsSchema = def.name === "*" && !def.args ? zod.z.any() : def.args;
+		return {
+			name: def.name,
+			args: argsSchema,
+			render: def.render,
+			...def.agentId ? { agentId: def.agentId } : {}
+		};
+	}
+
+//#endregion
+//#region src/v2/hooks/use-human-in-the-loop.tsx
+	function useHumanInTheLoop$1(tool, deps) {
+		const { copilotkit } = useCopilotKit();
+		const resolvePromiseRef = (0, react.useRef)(null);
+		const respond = (0, react.useCallback)(async (result) => {
+			if (resolvePromiseRef.current) {
+				resolvePromiseRef.current(result);
+				resolvePromiseRef.current = null;
+			}
+		}, []);
+		const handler = (0, react.useCallback)(async () => {
+			return new Promise((resolve) => {
+				resolvePromiseRef.current = resolve;
+			});
+		}, []);
+		const RenderComponent = (0, react.useCallback)((props) => {
+			const ToolComponent = tool.render;
+			if (props.status === "inProgress") {
+				const enhancedProps = {
+					...props,
+					name: tool.name,
+					description: tool.description || "",
+					respond: void 0
+				};
+				return react.default.createElement(ToolComponent, enhancedProps);
+			} else if (props.status === "executing") {
+				const enhancedProps = {
+					...props,
+					name: tool.name,
+					description: tool.description || "",
+					respond
+				};
+				return react.default.createElement(ToolComponent, enhancedProps);
+			} else if (props.status === "complete") {
+				const enhancedProps = {
+					...props,
+					name: tool.name,
+					description: tool.description || "",
+					respond: void 0
+				};
+				return react.default.createElement(ToolComponent, enhancedProps);
+			}
+			return react.default.createElement(ToolComponent, props);
+		}, [
+			tool.render,
+			tool.name,
+			tool.description,
+			respond
+		]);
+		useFrontendTool$1({
+			...tool,
+			handler,
+			render: RenderComponent
+		}, deps);
+		(0, react.useEffect)(() => {
+			return () => {
+				copilotkit.removeHookRenderToolCall(tool.name, tool.agentId);
+			};
+		}, [
+			copilotkit,
+			tool.name,
+			tool.agentId
+		]);
+	}
+
+//#endregion
+//#region src/v2/hooks/use-agent.tsx
+	let UseAgentUpdate = /* @__PURE__ */ function(UseAgentUpdate) {
+		UseAgentUpdate["OnMessagesChanged"] = "OnMessagesChanged";
+		UseAgentUpdate["OnStateChanged"] = "OnStateChanged";
+		UseAgentUpdate["OnRunStatusChanged"] = "OnRunStatusChanged";
+		return UseAgentUpdate;
+	}({});
+	const ALL_UPDATES = [
+		UseAgentUpdate.OnMessagesChanged,
+		UseAgentUpdate.OnStateChanged,
+		UseAgentUpdate.OnRunStatusChanged
+	];
+	function useAgent({ agentId, updates } = {}) {
+		var _agentId;
+		(_agentId = agentId) !== null && _agentId !== void 0 || (agentId = _copilotkit_shared.DEFAULT_AGENT_ID);
+		const { copilotkit } = useCopilotKit();
+		const [, forceUpdate] = (0, react.useReducer)((x) => x + 1, 0);
+		const updateFlags = (0, react.useMemo)(() => updates !== null && updates !== void 0 ? updates : ALL_UPDATES, [JSON.stringify(updates)]);
+		const provisionalAgentCache = (0, react.useRef)(/* @__PURE__ */ new Map());
+		const agent = (0, react.useMemo)(() => {
+			var _copilotkit$agents;
+			const existing = copilotkit.getAgent(agentId);
+			if (existing) {
+				provisionalAgentCache.current.delete(agentId);
+				return existing;
+			}
+			const isRuntimeConfigured = copilotkit.runtimeUrl !== void 0;
+			const status = copilotkit.runtimeConnectionStatus;
+			if (isRuntimeConfigured && (status === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Disconnected || status === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Connecting)) {
+				const cached = provisionalAgentCache.current.get(agentId);
+				if (cached) {
+					cached.headers = { ...copilotkit.headers };
+					return cached;
+				}
+				const provisional = new _copilotkit_core.ProxiedCopilotRuntimeAgent({
+					runtimeUrl: copilotkit.runtimeUrl,
+					agentId,
+					transport: copilotkit.runtimeTransport,
+					runtimeMode: "pending"
+				});
+				provisional.headers = { ...copilotkit.headers };
+				provisionalAgentCache.current.set(agentId, provisional);
+				return provisional;
+			}
+			if (isRuntimeConfigured && status === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Error) {
+				const provisional = new _copilotkit_core.ProxiedCopilotRuntimeAgent({
+					runtimeUrl: copilotkit.runtimeUrl,
+					agentId,
+					transport: copilotkit.runtimeTransport,
+					runtimeMode: "pending"
+				});
+				provisional.headers = { ...copilotkit.headers };
+				return provisional;
+			}
+			const knownAgents = Object.keys((_copilotkit$agents = copilotkit.agents) !== null && _copilotkit$agents !== void 0 ? _copilotkit$agents : {});
+			const runtimePart = isRuntimeConfigured ? `runtimeUrl=${copilotkit.runtimeUrl}` : "no runtimeUrl";
+			throw new Error(`useAgent: Agent '${agentId}' not found after runtime sync (${runtimePart}). ` + (knownAgents.length ? `Known agents: [${knownAgents.join(", ")}]` : "No agents registered.") + " Verify your runtime /info and/or agents__unsafe_dev_only.");
+		}, [
+			agentId,
+			copilotkit.agents,
+			copilotkit.runtimeConnectionStatus,
+			copilotkit.runtimeUrl,
+			copilotkit.runtimeTransport,
+			JSON.stringify(copilotkit.headers)
+		]);
+		(0, react.useEffect)(() => {
+			if (updateFlags.length === 0) return;
+			const handlers = {};
+			if (updateFlags.includes(UseAgentUpdate.OnMessagesChanged)) handlers.onMessagesChanged = () => {
+				forceUpdate();
+			};
+			if (updateFlags.includes(UseAgentUpdate.OnStateChanged)) handlers.onStateChanged = forceUpdate;
+			if (updateFlags.includes(UseAgentUpdate.OnRunStatusChanged)) {
+				handlers.onRunInitialized = forceUpdate;
+				handlers.onRunFinalized = forceUpdate;
+				handlers.onRunFailed = forceUpdate;
+			}
+			const subscription = agent.subscribe(handlers);
+			return () => subscription.unsubscribe();
+		}, [
+			agent,
+			forceUpdate,
+			JSON.stringify(updateFlags)
+		]);
+		return { agent };
+	}
+
+//#endregion
+//#region src/v2/hooks/use-suggestions.tsx
+	function useSuggestions({ agentId } = {}) {
+		const { copilotkit } = useCopilotKit();
+		const config = useCopilotChatConfiguration();
+		const resolvedAgentId = (0, react.useMemo)(() => {
+			var _ref;
+			return (_ref = agentId !== null && agentId !== void 0 ? agentId : config === null || config === void 0 ? void 0 : config.agentId) !== null && _ref !== void 0 ? _ref : _copilotkit_shared.DEFAULT_AGENT_ID;
+		}, [agentId, config === null || config === void 0 ? void 0 : config.agentId]);
+		const [suggestions, setSuggestions] = (0, react.useState)(() => {
+			return copilotkit.getSuggestions(resolvedAgentId).suggestions;
+		});
+		const [isLoading, setIsLoading] = (0, react.useState)(() => {
+			return copilotkit.getSuggestions(resolvedAgentId).isLoading;
+		});
+		(0, react.useEffect)(() => {
+			const result = copilotkit.getSuggestions(resolvedAgentId);
+			setSuggestions(result.suggestions);
+			setIsLoading(result.isLoading);
+		}, [copilotkit, resolvedAgentId]);
+		(0, react.useEffect)(() => {
+			const subscription = copilotkit.subscribe({
+				onSuggestionsChanged: ({ agentId: changedAgentId, suggestions }) => {
+					if (changedAgentId !== resolvedAgentId) return;
+					setSuggestions(suggestions);
+				},
+				onSuggestionsStartedLoading: ({ agentId: changedAgentId }) => {
+					if (changedAgentId !== resolvedAgentId) return;
+					setIsLoading(true);
+				},
+				onSuggestionsFinishedLoading: ({ agentId: changedAgentId }) => {
+					if (changedAgentId !== resolvedAgentId) return;
+					setIsLoading(false);
+				},
+				onSuggestionsConfigChanged: () => {
+					const result = copilotkit.getSuggestions(resolvedAgentId);
+					setSuggestions(result.suggestions);
+					setIsLoading(result.isLoading);
+				}
+			});
+			return () => {
+				subscription.unsubscribe();
+			};
+		}, [copilotkit, resolvedAgentId]);
+		return {
+			suggestions,
+			reloadSuggestions: (0, react.useCallback)(() => {
+				copilotkit.reloadSuggestions(resolvedAgentId);
+			}, [copilotkit, resolvedAgentId]),
+			clearSuggestions: (0, react.useCallback)(() => {
+				copilotkit.clearSuggestions(resolvedAgentId);
+			}, [copilotkit, resolvedAgentId]),
+			isLoading
+		};
+	}
+
+//#endregion
+//#region src/v2/hooks/use-configure-suggestions.tsx
+	function useConfigureSuggestions(config, deps) {
+		const { copilotkit } = useCopilotKit();
+		const chatConfig = useCopilotChatConfiguration();
+		const extraDeps = deps !== null && deps !== void 0 ? deps : [];
+		const resolvedConsumerAgentId = (0, react.useMemo)(() => {
+			var _chatConfig$agentId;
+			return (_chatConfig$agentId = chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.agentId) !== null && _chatConfig$agentId !== void 0 ? _chatConfig$agentId : _copilotkit_shared.DEFAULT_AGENT_ID;
+		}, [chatConfig === null || chatConfig === void 0 ? void 0 : chatConfig.agentId]);
+		const rawConsumerAgentId = (0, react.useMemo)(() => config ? config.consumerAgentId : void 0, [config]);
+		const normalizationCacheRef = (0, react.useRef)({
+			serialized: null,
+			config: null
+		});
+		const { normalizedConfig, serializedConfig } = (0, react.useMemo)(() => {
+			if (!config) {
+				normalizationCacheRef.current = {
+					serialized: null,
+					config: null
+				};
+				return {
+					normalizedConfig: null,
+					serializedConfig: null
+				};
+			}
+			if (config.available === "disabled") {
+				normalizationCacheRef.current = {
+					serialized: null,
+					config: null
+				};
+				return {
+					normalizedConfig: null,
+					serializedConfig: null
+				};
+			}
+			let built;
+			if (isDynamicConfig(config)) built = { ...config };
+			else {
+				const normalizedSuggestions = normalizeStaticSuggestions(config.suggestions);
+				built = {
+					...config,
+					suggestions: normalizedSuggestions
+				};
+			}
+			const serialized = JSON.stringify(built);
+			const cache = normalizationCacheRef.current;
+			if (cache.serialized === serialized && cache.config) return {
+				normalizedConfig: cache.config,
+				serializedConfig: serialized
+			};
+			normalizationCacheRef.current = {
+				serialized,
+				config: built
+			};
+			return {
+				normalizedConfig: built,
+				serializedConfig: serialized
+			};
+		}, [
+			config,
+			resolvedConsumerAgentId,
+			...extraDeps
+		]);
+		const latestConfigRef = (0, react.useRef)(null);
+		latestConfigRef.current = normalizedConfig;
+		const previousSerializedConfigRef = (0, react.useRef)(null);
+		const targetAgentId = (0, react.useMemo)(() => {
+			if (!normalizedConfig) return resolvedConsumerAgentId;
+			const consumer = normalizedConfig.consumerAgentId;
+			if (!consumer || consumer === "*") return resolvedConsumerAgentId;
+			return consumer;
+		}, [normalizedConfig, resolvedConsumerAgentId]);
+		const isGlobalConfig = rawConsumerAgentId === void 0 || rawConsumerAgentId === "*";
+		const requestReload = (0, react.useCallback)(() => {
+			if (!normalizedConfig) return;
+			if (isGlobalConfig) {
+				var _copilotkit$agents;
+				const agents = Object.values((_copilotkit$agents = copilotkit.agents) !== null && _copilotkit$agents !== void 0 ? _copilotkit$agents : {});
+				for (const entry of agents) {
+					const agentId = entry.agentId;
+					if (!agentId) continue;
+					if (!entry.isRunning) copilotkit.reloadSuggestions(agentId);
+				}
+				return;
+			}
+			if (!targetAgentId) return;
+			copilotkit.reloadSuggestions(targetAgentId);
+		}, [
+			copilotkit,
+			isGlobalConfig,
+			normalizedConfig,
+			targetAgentId
+		]);
+		(0, react.useEffect)(() => {
+			if (!serializedConfig || !latestConfigRef.current) return;
+			const id = copilotkit.addSuggestionsConfig(latestConfigRef.current);
+			requestReload();
+			return () => {
+				copilotkit.removeSuggestionsConfig(id);
+			};
+		}, [
+			copilotkit,
+			serializedConfig,
+			requestReload
+		]);
+		(0, react.useEffect)(() => {
+			if (!normalizedConfig) {
+				previousSerializedConfigRef.current = null;
+				return;
+			}
+			if (serializedConfig && previousSerializedConfigRef.current === serializedConfig) return;
+			if (serializedConfig) previousSerializedConfigRef.current = serializedConfig;
+			requestReload();
+		}, [
+			normalizedConfig,
+			requestReload,
+			serializedConfig
+		]);
+		(0, react.useEffect)(() => {
+			if (!normalizedConfig || extraDeps.length === 0) return;
+			requestReload();
+		}, [
+			extraDeps.length,
+			normalizedConfig,
+			requestReload,
+			...extraDeps
+		]);
+	}
+	function isDynamicConfig(config) {
+		return "instructions" in config;
+	}
+	function normalizeStaticSuggestions(suggestions) {
+		return suggestions.map((suggestion) => {
+			var _suggestion$isLoading;
+			return {
+				...suggestion,
+				isLoading: (_suggestion$isLoading = suggestion.isLoading) !== null && _suggestion$isLoading !== void 0 ? _suggestion$isLoading : false
+			};
+		});
+	}
+
+//#endregion
+//#region src/v2/hooks/use-interrupt.tsx
+	const INTERRUPT_EVENT_NAME = "on_interrupt";
+	function isPromiseLike(value) {
+		return (typeof value === "object" || typeof value === "function") && value !== null && typeof Reflect.get(value, "then") === "function";
+	}
+	/**
+	* Handles agent interrupts (`on_interrupt`) with optional filtering, preprocessing, and resume behavior.
+	*
+	* The hook listens to custom events on the active agent, stores interrupt payloads per run,
+	* and surfaces a render callback once the run finalizes. Call `resolve` from your UI to resume
+	* execution with user-provided data.
+	*
+	* - `renderInChat: true` (default): the element is published into `<CopilotChat>` and this hook returns `void`.
+	* - `renderInChat: false`: the hook returns the interrupt element so you can place it anywhere in your component tree.
+	*
+	* `event.value` is typed as `any` since the interrupt payload shape depends on your agent.
+	* Type-narrow it in your callbacks (e.g. `handler`, `enabled`, `render`) as needed.
+	*
+	* @typeParam TResult - Inferred from `handler` return type. Exposed as `result` in `render`.
+	* @param config - Interrupt configuration (renderer, optional handler/filter, and render mode).
+	* @returns When `renderInChat` is `false`, returns the interrupt element (or `null` when idle).
+	* Otherwise returns `void` and publishes the element into chat. In `render`, `result` is always
+	* either the handler's resolved return value or `null` (including when no handler is provided,
+	* when filtering skips the interrupt, or when handler execution fails).
+	*
+	* @example
+	* ```tsx
+	* import { useInterrupt } from "@copilotkit/react-core/v2";
+	*
+	* function InterruptUI() {
+	*   useInterrupt({
+	*     render: ({ event, resolve }) => (
+	*       <div>
+	*         <p>{event.value.question}</p>
+	*         <button onClick={() => resolve({ approved: true })}>Approve</button>
+	*         <button onClick={() => resolve({ approved: false })}>Reject</button>
+	*       </div>
+	*     ),
+	*   });
+	*
+	*   return null;
+	* }
+	* ```
+	*
+	* @example
+	* ```tsx
+	* import { useInterrupt } from "@copilotkit/react-core/v2";
+	*
+	* function CustomPanel() {
+	*   const interruptElement = useInterrupt({
+	*     renderInChat: false,
+	*     enabled: (event) => event.value.startsWith("approval:"),
+	*     handler: async ({ event }) => ({ label: event.value.toUpperCase() }),
+	*     render: ({ event, result, resolve }) => (
+	*       <aside>
+	*         <strong>{result?.label ?? ""}</strong>
+	*         <button onClick={() => resolve({ value: event.value })}>Continue</button>
+	*       </aside>
+	*     ),
+	*   });
+	*
+	*   return <>{interruptElement}</>;
+	* }
+	* ```
+	*/
+	function useInterrupt(config) {
+		const { copilotkit } = useCopilotKit();
+		const { agent } = useAgent({ agentId: config.agentId });
+		const [pendingEvent, setPendingEvent] = (0, react.useState)(null);
+		const pendingEventRef = (0, react.useRef)(pendingEvent);
+		pendingEventRef.current = pendingEvent;
+		const [handlerResult, setHandlerResult] = (0, react.useState)(null);
+		(0, react.useEffect)(() => {
+			let localInterrupt = null;
+			const subscription = agent.subscribe({
+				onCustomEvent: ({ event }) => {
+					if (event.name === INTERRUPT_EVENT_NAME) localInterrupt = {
+						name: event.name,
+						value: event.value
+					};
+				},
+				onRunStartedEvent: () => {
+					localInterrupt = null;
+					setPendingEvent(null);
+				},
+				onRunFinalized: () => {
+					if (localInterrupt) {
+						setPendingEvent(localInterrupt);
+						localInterrupt = null;
+					}
+				},
+				onRunFailed: () => {
+					localInterrupt = null;
+				}
+			});
+			return () => subscription.unsubscribe();
+		}, [agent]);
+		const resolve = (0, react.useCallback)((response) => {
+			var _pendingEventRef$curr;
+			setPendingEvent(null);
+			copilotkit.runAgent({
+				agent,
+				forwardedProps: { command: {
+					resume: response,
+					interruptEvent: (_pendingEventRef$curr = pendingEventRef.current) === null || _pendingEventRef$curr === void 0 ? void 0 : _pendingEventRef$curr.value
+				} }
+			});
+		}, [agent, copilotkit]);
+		(0, react.useEffect)(() => {
+			if (!pendingEvent) {
+				setHandlerResult(null);
+				return;
+			}
+			if (config.enabled && !config.enabled(pendingEvent)) {
+				setHandlerResult(null);
+				return;
+			}
+			const handler = config.handler;
+			if (!handler) {
+				setHandlerResult(null);
+				return;
+			}
+			let cancelled = false;
+			const maybePromise = handler({
+				event: pendingEvent,
+				resolve
+			});
+			if (isPromiseLike(maybePromise)) Promise.resolve(maybePromise).then((resolved) => {
+				if (!cancelled) setHandlerResult(resolved);
+			}).catch(() => {
+				if (!cancelled) setHandlerResult(null);
+			});
+			else setHandlerResult(maybePromise);
+			return () => {
+				cancelled = true;
+			};
+		}, [
+			pendingEvent,
+			config.enabled,
+			config.handler,
+			resolve
+		]);
+		const element = (0, react.useMemo)(() => {
+			if (!pendingEvent) return null;
+			if (config.enabled && !config.enabled(pendingEvent)) return null;
+			return config.render({
+				event: pendingEvent,
+				result: handlerResult,
+				resolve
+			});
+		}, [
+			pendingEvent,
+			handlerResult,
+			config.enabled,
+			config.render,
+			resolve
+		]);
+		(0, react.useEffect)(() => {
+			if (config.renderInChat === false) return;
+			copilotkit.setInterruptElement(element);
+			return () => copilotkit.setInterruptElement(null);
+		}, [
+			element,
+			config.renderInChat,
+			copilotkit
+		]);
+		if (config.renderInChat === false) return element;
+	}
+
+//#endregion
 //#region src/context/copilot-context.tsx
 	const emptyCopilotContext$1 = {
 		actions: {},
@@ -1454,7 +3360,7 @@ react_markdown = __toESM(react_markdown);
 		var _props$runId;
 		const { stateSnapshot, message } = props;
 		const { coAgentStateRenders, claimsRef } = useCoAgentStateRenders();
-		const { agent } = (0, _copilotkitnext_react.useAgent)({ agentId });
+		const { agent } = useAgent({ agentId });
 		const [nodeName, setNodeName] = (0, react.useState)(void 0);
 		const [, forceUpdate] = (0, react.useState)(0);
 		(0, react.useEffect)(() => {
@@ -1563,11 +3469,11 @@ react_markdown = __toESM(react_markdown);
 		}, [agent, getSubscriber]);
 	};
 	function CopilotListeners() {
-		const { copilotkit } = (0, _copilotkitnext_react.useCopilotKit)();
-		const existingConfig = (0, _copilotkitnext_react.useCopilotChatConfiguration)();
+		const { copilotkit } = useCopilotKit();
+		const existingConfig = useCopilotChatConfiguration();
 		const resolvedAgentId = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.agentId;
 		const { setBannerError } = useToast();
-		const { agent } = (0, _copilotkitnext_react.useAgent)({ agentId: resolvedAgentId });
+		const { agent } = useAgent({ agentId: resolvedAgentId });
 		usePredictStateSubscription(agent);
 		(0, react.useEffect)(() => {
 			const subscription = copilotkit.subscribe({ onError: ({ error }) => {
@@ -1614,7 +3520,7 @@ react_markdown = __toESM(react_markdown);
 				showUsageBanner: enabled,
 				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ThreadsProvider, {
 					threadId: props.threadId,
-					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_copilotkitnext_react.CopilotKitProvider, {
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotKitProvider, {
 						...props,
 						showDevConsole: showInspector,
 						renderCustomMessages: renderArr,
@@ -1635,7 +3541,7 @@ react_markdown = __toESM(react_markdown);
 	* Chat components are rendered.
 	*/
 	function CopilotKitErrorBridge() {
-		const { copilotkit } = (0, _copilotkitnext_react.useCopilotKit)();
+		const { copilotkit } = useCopilotKit();
 		const { onError, copilotApiConfig } = useCopilotContext();
 		(0, react.useEffect)(() => {
 			if (!copilotkit) return;
@@ -2053,7 +3959,7 @@ react_markdown = __toESM(react_markdown);
 			setInternalErrorHandler,
 			removeInternalErrorHandler
 		]);
-		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_copilotkitnext_react.CopilotChatConfigurationProvider, {
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotChatConfigurationProvider, {
 			agentId: (_props$agent2 = props.agent) !== null && _props$agent2 !== void 0 ? _props$agent2 : "default",
 			threadId,
 			children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(CopilotContext.Provider, {
@@ -2108,7 +4014,7 @@ react_markdown = __toESM(react_markdown);
 //#endregion
 //#region src/hooks/use-lazy-tool-renderer.tsx
 	function useLazyToolRenderer() {
-		const renderToolCall = (0, _copilotkitnext_react.useRenderToolCall)();
+		const renderToolCall = useRenderToolCall$1();
 		return (0, react.useCallback)((message, messages) => {
 			var _message$toolCalls;
 			if (!(message === null || message === void 0 || (_message$toolCalls = message.toolCalls) === null || _message$toolCalls === void 0 ? void 0 : _message$toolCalls.length)) return null;
@@ -2126,12 +4032,12 @@ react_markdown = __toESM(react_markdown);
 //#region src/hooks/use-copilot-chat_internal.ts
 	function useCopilotChatInternal({ suggestions, onInProgress, onSubmitMessage, onStopGeneration, onReloadMessages } = {}) {
 		var _existingConfig$agent, _existingConfig$threa, _agent$messages5;
-		const { copilotkit } = (0, _copilotkitnext_react.useCopilotKit)();
+		const { copilotkit } = useCopilotKit();
 		const { threadId, agentSession } = useCopilotContext();
-		const existingConfig = (0, _copilotkitnext_react.useCopilotChatConfiguration)();
+		const existingConfig = useCopilotChatConfiguration();
 		const [agentAvailable, setAgentAvailable] = (0, react.useState)(false);
 		const resolvedAgentId = (_existingConfig$agent = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.agentId) !== null && _existingConfig$agent !== void 0 ? _existingConfig$agent : "default";
-		const { agent } = (0, _copilotkitnext_react.useAgent)({ agentId: resolvedAgentId });
+		const { agent } = useAgent({ agentId: resolvedAgentId });
 		(0, react.useEffect)(() => {
 			let detached = false;
 			const connectAbortController = new AbortController();
@@ -2146,7 +4052,7 @@ react_markdown = __toESM(react_markdown);
 					if (error instanceof _ag_ui_client.AGUIConnectNotImplementedError) {} else console.error("CopilotChat: connectAgent failed", error);
 				}
 			};
-			if (agent && (existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.threadId) && agent.threadId !== existingConfig.threadId && copilotkit.runtimeConnectionStatus === _copilotkitnext_core.CopilotKitCoreRuntimeConnectionStatus.Connected) {
+			if (agent && (existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.threadId) && agent.threadId !== existingConfig.threadId && copilotkit.runtimeConnectionStatus === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Connected) {
 				agent.threadId = existingConfig.threadId;
 				connect(agent);
 			}
@@ -2185,7 +4091,7 @@ react_markdown = __toESM(react_markdown);
 		const latestDeleteFunc = (0, react.useCallback)((messageId) => {
 			return latestDelete.current(messageId);
 		}, [latestDelete]);
-		const currentSuggestions = (0, _copilotkitnext_react.useSuggestions)({ agentId: resolvedAgentId });
+		const currentSuggestions = useSuggestions({ agentId: resolvedAgentId });
 		const reload = useAsyncCallback(async (reloadMessageId) => {
 			var _agent$messages2;
 			if (!agent) return;
@@ -2285,7 +4191,7 @@ react_markdown = __toESM(react_markdown);
 			return latestReset.current();
 		}, [latestReset]);
 		const lazyToolRendered = useLazyToolRenderer();
-		const renderCustomMessage = (0, _copilotkitnext_react.useRenderCustomMessages)();
+		const renderCustomMessage = useRenderCustomMessages();
 		const legacyCustomMessageRenderer = useLegacyCoagentRenderer({
 			copilotkit,
 			agent,
@@ -2776,7 +4682,7 @@ react_markdown = __toESM(react_markdown);
 		(0, react.useEffect)(() => {
 			handlerRef.current = tool.handler;
 		}, [tool.handler, ...dependencies !== null && dependencies !== void 0 ? dependencies : []]);
-		(0, _copilotkitnext_react.useFrontendTool)({
+		useFrontendTool$1({
 			name,
 			description,
 			parameters: zodParameters,
@@ -2793,12 +4699,12 @@ react_markdown = __toESM(react_markdown);
 //#endregion
 //#region src/hooks/use-render-tool-call.ts
 	function useRenderToolCall(tool, dependencies) {
-		const { copilotkit } = (0, _copilotkitnext_react.useCopilotKit)();
+		const { copilotkit } = useCopilotKit();
 		const hasAddedRef = (0, react.useRef)(false);
 		(0, react.useEffect)(() => {
 			const { name, parameters, render } = tool;
 			const zodParameters = (0, _copilotkit_shared.getZodParameters)(parameters);
-			const renderToolCall = name === "*" ? (0, _copilotkitnext_react.defineToolCallRenderer)({
+			const renderToolCall = name === "*" ? defineToolCallRenderer({
 				name: "*",
 				render: ((args) => {
 					return render({
@@ -2806,7 +4712,7 @@ react_markdown = __toESM(react_markdown);
 						result: args.result ? (0, _copilotkit_shared.parseJson)(args.result, args.result) : args.result
 					});
 				})
-			}) : (0, _copilotkitnext_react.defineToolCallRenderer)({
+			}) : defineToolCallRenderer({
 				name,
 				args: zodParameters,
 				render: ((args) => {
@@ -2844,19 +4750,19 @@ react_markdown = __toESM(react_markdown);
 				const rendered = render((() => {
 					const mappedArgs = args.args;
 					switch (args.status) {
-						case _copilotkitnext_core.ToolCallStatus.InProgress: return {
+						case _copilotkit_core.ToolCallStatus.InProgress: return {
 							args: mappedArgs,
 							respond: args.respond,
 							status: args.status,
 							handler: void 0
 						};
-						case _copilotkitnext_core.ToolCallStatus.Executing: return {
+						case _copilotkit_core.ToolCallStatus.Executing: return {
 							args: mappedArgs,
 							respond: args.respond,
 							status: args.status,
 							handler: () => {}
 						};
-						case _copilotkitnext_core.ToolCallStatus.Complete: return {
+						case _copilotkit_core.ToolCallStatus.Complete: return {
 							args: mappedArgs,
 							respond: args.respond,
 							status: args.status,
@@ -2873,7 +4779,7 @@ react_markdown = __toESM(react_markdown);
 				return rendered !== null && rendered !== void 0 ? rendered : null;
 			};
 		}, [render, ...dependencies !== null && dependencies !== void 0 ? dependencies : []]);
-		(0, _copilotkitnext_react.useHumanInTheLoop)({
+		useHumanInTheLoop$1({
 			name,
 			description,
 			followUp,
@@ -3287,7 +5193,7 @@ react_markdown = __toESM(react_markdown);
 	* Adds the given information to the Copilot context to make it readable by Copilot.
 	*/
 	function useCopilotReadable({ description, value, convert, available }, dependencies) {
-		const { copilotkit } = (0, _copilotkitnext_react.useCopilotKit)();
+		const { copilotkit } = useCopilotKit();
 		const ctxIdRef = (0, react.useRef)(void 0);
 		(0, react.useEffect)(() => {
 			if (!copilotkit) return;
@@ -3322,7 +5228,7 @@ react_markdown = __toESM(react_markdown);
 //#endregion
 //#region src/hooks/use-agent-nodename.ts
 	function useAgentNodeName(agentName) {
-		const { agent } = (0, _copilotkitnext_react.useAgent)({ agentId: agentName });
+		const { agent } = useAgent({ agentId: agentName });
 		const nodeNameRef = (0, react.useRef)("start");
 		(0, react.useEffect)(() => {
 			if (!agent) return;
@@ -3442,8 +5348,8 @@ react_markdown = __toESM(react_markdown);
 	* we refer to as CoAgents, checkout the documentation at https://docs.copilotkit.ai/coagents/quickstart/langgraph.
 	*/
 	function useCoAgent(options) {
-		const { agent } = (0, _copilotkitnext_react.useAgent)({ agentId: options.name });
-		const { copilotkit } = (0, _copilotkitnext_react.useCopilotKit)();
+		const { agent } = useAgent({ agentId: options.name });
+		const { copilotkit } = useCopilotKit();
 		const nodeName = useAgentNodeName(options.name);
 		const handleStateUpdate = (0, react.useCallback)((newState) => {
 			if (!agent) return;
@@ -3721,7 +5627,7 @@ react_markdown = __toESM(react_markdown);
 		var _ref, _action$agentId;
 		const actionRef = (0, react.useRef)(action);
 		actionRef.current = action;
-		const existingConfig = (0, _copilotkitnext_react.useCopilotChatConfiguration)();
+		const existingConfig = useCopilotChatConfiguration();
 		const resolvedAgentId = (_ref = (_action$agentId = action.agentId) !== null && _action$agentId !== void 0 ? _action$agentId : existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.agentId) !== null && _ref !== void 0 ? _ref : "default";
 		const threadId = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.threadId;
 		const nodeName = useAgentNodeName(resolvedAgentId);
@@ -3735,7 +5641,7 @@ react_markdown = __toESM(react_markdown);
 			threadId,
 			nodeName
 		};
-		(0, _copilotkitnext_react.useInterrupt)({
+		useInterrupt({
 			render: (0, react.useCallback)(({ event, result, resolve }) => {
 				const renderFn = actionRef.current.render;
 				if (!renderFn) return react.default.createElement(react.default.Fragment);
@@ -3897,10 +5803,10 @@ react_markdown = __toESM(react_markdown);
 	*/
 	function useCopilotChatSuggestions(config, dependencies = []) {
 		var _existingConfig$agent, _ref;
-		const existingConfig = (0, _copilotkitnext_react.useCopilotChatConfiguration)();
+		const existingConfig = useCopilotChatConfiguration();
 		const resolvedAgentId = (_existingConfig$agent = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.agentId) !== null && _existingConfig$agent !== void 0 ? _existingConfig$agent : "default";
 		const available = (_ref = config.available === "enabled" ? "always" : config.available) !== null && _ref !== void 0 ? _ref : "before-first-message";
-		(0, _copilotkitnext_react.useConfigureSuggestions)({
+		useConfigureSuggestions({
 			...config,
 			available,
 			consumerAgentId: resolvedAgentId
@@ -3971,7 +5877,7 @@ react_markdown = __toESM(react_markdown);
 	* }
 	* ```
 	*
-	* Have a look at the [Presentation Example App](https://github.com/CopilotKit/CopilotKit/blob/main/src/v1.x/examples/next-openai/src/app/presentation/page.tsx) for a more complete example.
+	* Have a look at the [Presentation Example App](https://github.com/CopilotKit/CopilotKit/blob/main/examples/v1/next-openai/src/app/presentation/page.tsx) for a more complete example.
 	*/
 	var CopilotTask = class {
 		constructor(config) {