@copilotkit/react-core 1.61.0 → 1.61.2

package/dist/{copilotkit-DtPCrXXd.cjs → copilotkit-CTCjVxkH.cjs}

@@ -1520,10 +1520,20 @@ function useRenderTool(config, deps) {
 		}) : defineToolCallRenderer({
 			name: config.name,
 			args: config.parameters,
-			render: (props) => config.render({
-				...props,
-				parameters: props.args
-			}),
+			render: (props) => {
+				if (props.status === _copilotkit_core.ToolCallStatus.InProgress) return config.render({
+					...props,
+					parameters: props.args
+				});
+				if (props.status === _copilotkit_core.ToolCallStatus.Executing) return config.render({
+					...props,
+					parameters: props.args
+				});
+				return config.render({
+					...props,
+					parameters: props.args
+				});
+			},
 			...config.agentId ? { agentId: config.agentId } : {}
 		});
 		copilotkit.addHookRenderToolCall(renderer);
@@ -3561,6 +3571,10 @@ function A2UICatalogContext({ catalog, includeSchema }) {
 
 //#endregion
 //#region src/v2/providers/CopilotKitProvider.tsx
+const zodToJsonSchemaAdapter = (schema, options) => {
+	const refStrategy = options?.$refStrategy;
+	return (0, zod_to_json_schema.zodToJsonSchema)(schema, refStrategy === "root" || refStrategy === "relative" || refStrategy === "none" || refStrategy === "seen" ? { $refStrategy: refStrategy } : {});
+};
 const HEADER_NAME = "X-CopilotCloud-Public-Api-Key";
 const COPILOT_CLOUD_CHAT_URL$1 = "https://api.cloud.copilotkit.ai/copilotkit/v1";
 const EMPTY_HEADERS = Object.freeze({});
@@ -3591,6 +3605,8 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 	const [runtimeA2UIEnabled, setRuntimeA2UIEnabled] = (0, react.useState)(false);
 	const [runtimeOpenGenUIEnabled, setRuntimeOpenGenUIEnabled] = (0, react.useState)(false);
 	const openGenUIActive = runtimeOpenGenUIEnabled || !!openGenerativeUI;
+	const a2uiCatalogProvided = !!a2ui?.catalog;
+	const a2uiActive = runtimeA2UIEnabled || a2uiCatalogProvided;
 	const [runtimeLicenseStatus, setRuntimeLicenseStatus] = (0, react.useState)(void 0);
 	(0, react.useEffect)(() => {
 		if (typeof window === "undefined") return;
@@ -3621,7 +3637,7 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 			content: OpenGenerativeUIContentSchema,
 			render: OpenGenerativeUIActivityRenderer
 		});
-		if (runtimeA2UIEnabled) renderers.unshift(createA2UIMessageRenderer({
+		if (a2uiActive) renderers.unshift(createA2UIMessageRenderer({
 			theme: a2ui?.theme ?? _copilotkit_a2ui_renderer.viewerTheme,
 			catalog: a2ui?.catalog,
 			loadingComponent: a2ui?.loadingComponent,
@@ -3629,7 +3645,7 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 		}));
 		return renderers;
 	}, [
-		runtimeA2UIEnabled,
+		a2uiActive,
 		openGenUIActive,
 		a2ui
 	]);
@@ -3816,7 +3832,10 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 		copilotkit.setRuntimeTransport(useSingleEndpoint === true ? "single" : useSingleEndpoint === false ? "rest" : "auto");
 		copilotkit.setHeaders(mergedHeaders);
 		copilotkit.setCredentials(credentials);
-		copilotkit.setProperties(properties);
+		copilotkit.setProperties(a2uiCatalogProvided ? {
+			...properties,
+			a2uiCatalogAvailable: true
+		} : properties);
 		copilotkit.setAgents__unsafe_dev_only(mergedAgents);
 		copilotkit.setDebug(debug);
 	}, [
@@ -3825,6 +3844,7 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 		mergedHeaders,
 		credentials,
 		properties,
+		a2uiCatalogProvided,
 		mergedAgents,
 		useSingleEndpoint,
 		debug
@@ -3872,7 +3892,7 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 		return JSON.stringify(sandboxFunctionsList.map((fn) => ({
 			name: fn.name,
 			description: fn.description,
-			parameters: (0, _copilotkit_shared.schemaToJsonSchema)(fn.parameters, { zodToJsonSchema: zod_to_json_schema.zodToJsonSchema })
+			parameters: (0, _copilotkit_shared.schemaToJsonSchema)(fn.parameters, { zodToJsonSchema: zodToJsonSchemaAdapter })
 		})));
 	}, [sandboxFunctionsList]);
 	(0, react.useLayoutEffect)(() => {
@@ -3893,7 +3913,7 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 		copilotkit,
 		executingToolCallIds
 	}), [copilotkit, executingToolCallIds]);
-	const licenseContextValue = (0, react.useMemo)(() => (0, _copilotkit_shared.createLicenseContextValue)(null), []);
+	const licenseContextValue = (0, react.useMemo)(() => (0, _copilotkit_shared.createLicenseContextValue)(runtimeLicenseStatus), [runtimeLicenseStatus]);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SandboxFunctionsContext.Provider, {
 		value: sandboxFunctionsList,
 		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotKitContext.Provider, {
@@ -3901,8 +3921,8 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 			children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(LicenseContext.Provider, {
 				value: licenseContextValue,
 				children: [
-					runtimeA2UIEnabled && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(A2UIBuiltInToolCallRenderer, {}),
-					runtimeA2UIEnabled && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(A2UICatalogContext, {
+					a2uiActive && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(A2UIBuiltInToolCallRenderer, {}),
+					a2uiActive && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(A2UICatalogContext, {
 						catalog: a2ui?.catalog,
 						includeSchema: a2ui?.includeSchema
 					}),
@@ -3980,16 +4000,20 @@ function useRenderActivityMessage() {
 	const renderActivityMessage = (0, react.useCallback)((message) => {
 		const renderer = findRenderer(message.activityType);
 		if (!renderer) return null;
-		const parseResult = renderer.content.safeParse(message.content);
-		if (!parseResult.success) {
-			console.warn(`Failed to parse content for activity message '${message.activityType}':`, parseResult.error);
+		const parseResult = renderer.content["~standard"].validate(message.content);
+		if (parseResult instanceof Promise) {
+			console.warn(`Async content validation is not supported for activity message '${message.activityType}'`);
+			return null;
+		}
+		if (parseResult.issues) {
+			console.warn(`Failed to parse content for activity message '${message.activityType}':`, parseResult.issues);
 			return null;
 		}
 		const Component = renderer.render;
 		const agent = copilotkit.getAgent(agentId);
 		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Component, {
 			activityType: message.activityType,
-			content: parseResult.data,
+			content: parseResult.value,
 			message,
 			agent
 		}, message.id);
@@ -4110,15 +4134,34 @@ function useComponent(config, deps) {
 function useHumanInTheLoop(tool, deps) {
 	const { copilotkit } = useCopilotKit();
 	const resolvePromiseRef = (0, react.useRef)(null);
+	const cleanupAbortRef = (0, react.useRef)(null);
 	const respond = (0, react.useCallback)(async (result) => {
 		if (resolvePromiseRef.current) {
+			cleanupAbortRef.current?.();
+			cleanupAbortRef.current = null;
 			resolvePromiseRef.current(result);
 			resolvePromiseRef.current = null;
 		}
 	}, []);
-	const handler = (0, react.useCallback)(async () => {
-		return new Promise((resolve) => {
+	const handler = (0, react.useCallback)(async (_args, context) => {
+		const signal = context?.signal;
+		return new Promise((resolve, reject) => {
+			if (signal?.aborted) {
+				reject(/* @__PURE__ */ new Error("Human-in-the-loop interaction aborted"));
+				return;
+			}
 			resolvePromiseRef.current = resolve;
+			if (signal) {
+				const onAbort = () => {
+					cleanupAbortRef.current = null;
+					resolvePromiseRef.current = null;
+					reject(/* @__PURE__ */ new Error("Human-in-the-loop interaction aborted"));
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				cleanupAbortRef.current = () => {
+					signal.removeEventListener("abort", onAbort);
+				};
+			}
 		});
 	}, []);
 	const RenderComponent = (0, react.useCallback)((props) => {
@@ -4206,7 +4249,7 @@ function useAgent({ agentId, updates, throttleMs } = {}) {
 		if (isRuntimeConfigured && (status === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Disconnected || status === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Connecting)) {
 			const cached = provisionalAgentCache.current.get(agentId);
 			if (cached) {
-				cached.headers = { ...copilotkit.headers };
+				copilotkit.applyHeadersToAgent(cached);
 				return cached;
 			}
 			const provisional = new _copilotkit_core.ProxiedCopilotRuntimeAgent({
@@ -4215,14 +4258,14 @@ function useAgent({ agentId, updates, throttleMs } = {}) {
 				transport: copilotkit.runtimeTransport,
 				runtimeMode: "pending"
 			});
-			provisional.headers = { ...copilotkit.headers };
+			copilotkit.applyHeadersToAgent(provisional);
 			provisionalAgentCache.current.set(agentId, provisional);
 			return provisional;
 		}
 		if (isRuntimeConfigured && status === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Error) {
 			const cached = provisionalAgentCache.current.get(agentId);
 			if (cached) {
-				cached.headers = { ...copilotkit.headers };
+				copilotkit.applyHeadersToAgent(cached);
 				return cached;
 			}
 			const provisional = new _copilotkit_core.ProxiedCopilotRuntimeAgent({
@@ -4231,7 +4274,7 @@ function useAgent({ agentId, updates, throttleMs } = {}) {
 				transport: copilotkit.runtimeTransport,
 				runtimeMode: "pending"
 			});
-			provisional.headers = { ...copilotkit.headers };
+			copilotkit.applyHeadersToAgent(provisional);
 			provisionalAgentCache.current.set(agentId, provisional);
 			return provisional;
 		}
@@ -4282,7 +4325,7 @@ function useAgent({ agentId, updates, throttleMs } = {}) {
 		updateFlags
 	]);
 	(0, react.useEffect)(() => {
-		if (agent instanceof _ag_ui_client.HttpAgent) agent.headers = { ...copilotkit.headers };
+		if (agent instanceof _ag_ui_client.HttpAgent) copilotkit.applyHeadersToAgent(agent);
 	}, [agent, JSON.stringify(copilotkit.headers)]);
 	const chatConfig = useCopilotChatConfiguration();
 	const configThreadId = chatConfig?.threadId;
@@ -4559,114 +4602,165 @@ const INTERRUPT_EVENT_NAME = "on_interrupt";
 function isPromiseLike(value) {
 	return (typeof value === "object" || typeof value === "function") && value !== null && typeof Reflect.get(value, "then") === "function";
 }
+/** Derive the legacy-compatible `event` for any pending interrupt. */
+function toLegacyEvent(pending) {
+	if (pending.kind === "legacy") return pending.event;
+	return {
+		name: INTERRUPT_EVENT_NAME,
+		value: pending.interrupts[0]
+	};
+}
 /**
-* Handles agent interrupts (`on_interrupt`) with optional filtering, preprocessing, and resume behavior.
+* Handles agent interrupts 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.
+* Supports both the AG-UI standard interrupt flow (`RUN_FINISHED` with
+* `outcome.type === "interrupt"`) and the legacy custom-event flow
+* (`on_interrupt`). For standard interrupts, `render` receives `interrupt`
+* (the primary one) and `interrupts` (the full open set); call `resolve(payload)`
+* to resume or `cancel()` to cancel. Resuming addresses the targeted interrupt
+* and, once every open interrupt is addressed, submits a single spec `resume`
+* array via `copilotkit.runAgent`.
 *
-* - `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).
+* - `renderInChat: true` (default): the element is published into `<CopilotChat>`; returns `void`.
+* - `renderInChat: false`: the hook returns the interrupt element for manual placement.
 *
 * @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}</>;
-* }
+* useInterrupt({
+*   render: ({ interrupt, resolve, cancel }) => (
+*     <div>
+*       <p>{interrupt?.message}</p>
+*       <button onClick={() => resolve({ approved: true })}>Approve</button>
+*       <button onClick={() => cancel()}>Cancel</button>
+*     </div>
+*   ),
+* });
 * ```
 */
 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 [pending, setPending] = (0, react.useState)(null);
+	const pendingRef = (0, react.useRef)(pending);
+	pendingRef.current = pending;
 	const [handlerResult, setHandlerResult] = (0, react.useState)(null);
+	const responsesRef = (0, react.useRef)({});
 	(0, react.useEffect)(() => {
-		let localInterrupt = null;
+		let localLegacy = null;
+		let localStandard = null;
 		const subscription = agent.subscribe({
 			onCustomEvent: ({ event }) => {
-				if (event.name === INTERRUPT_EVENT_NAME) localInterrupt = {
+				if (event.name === INTERRUPT_EVENT_NAME) localLegacy = {
 					name: event.name,
 					value: event.value
 				};
 			},
+			onRunFinishedEvent: (params) => {
+				if (params.outcome === "interrupt") localStandard = params.interrupts;
+			},
 			onRunStartedEvent: () => {
-				localInterrupt = null;
-				setPendingEvent(null);
+				localLegacy = null;
+				localStandard = null;
+				responsesRef.current = {};
+				setPending(null);
 			},
 			onRunFinalized: () => {
-				if (localInterrupt) {
-					setPendingEvent(localInterrupt);
-					localInterrupt = null;
-				}
+				if (localStandard && localStandard.length > 0) setPending({
+					kind: "standard",
+					interrupts: localStandard
+				});
+				else if (localLegacy) setPending({
+					kind: "legacy",
+					event: localLegacy
+				});
+				localLegacy = null;
+				localStandard = null;
 			},
 			onRunFailed: () => {
-				localInterrupt = null;
-				setPendingEvent(null);
+				localLegacy = null;
+				localStandard = null;
+				responsesRef.current = {};
+				setPending(null);
 			}
 		});
 		return () => subscription.unsubscribe();
 	}, [agent]);
-	const resolve = (0, react.useCallback)(async (response) => {
+	const submitStandardIfComplete = (0, react.useCallback)(async (interrupts) => {
+		if (!interrupts.every((i) => responsesRef.current[i.id])) return;
+		const expired = interrupts.find((i) => (0, _ag_ui_client.isInterruptExpired)(i));
+		if (expired) {
+			console.error(`[CopilotKit] useInterrupt: interrupt ${expired.id} expired at ${expired.expiresAt}; not resuming.`);
+			responsesRef.current = {};
+			setPending(null);
+			return;
+		}
+		const resume = (0, _ag_ui_client.buildResumeArray)(interrupts, responsesRef.current);
+		for (const i of interrupts) {
+			if (!i.toolCallId) continue;
+			const response = responsesRef.current[i.id];
+			const content = response.status === "cancelled" ? { status: "cancelled" } : response.payload ?? { status: "resolved" };
+			agent.addMessage({
+				id: (0, _ag_ui_client.randomUUID)(),
+				role: "tool",
+				toolCallId: i.toolCallId,
+				content: JSON.stringify(content)
+			});
+		}
+		responsesRef.current = {};
 		try {
+			return await copilotkit.runAgent({
+				agent,
+				resume
+			});
+		} catch (err) {
+			console.error("[CopilotKit] useInterrupt resolve: runAgent rejected; clearing pending + rethrowing", err);
+			setPending(null);
+			throw err;
+		}
+	}, [agent, copilotkit]);
+	const resolve = (0, react.useCallback)(async (payload, interruptId) => {
+		const current = pendingRef.current;
+		if (!current) return;
+		if (current.kind === "legacy") try {
 			return await copilotkit.runAgent({
 				agent,
 				forwardedProps: { command: {
-					resume: response,
-					interruptEvent: pendingEventRef.current?.value
+					resume: payload,
+					interruptEvent: current.event.value
 				} }
 			});
 		} catch (err) {
 			console.error("[CopilotKit] useInterrupt resolve: runAgent rejected; clearing pending + rethrowing", err);
-			setPendingEvent(null);
+			setPending(null);
 			throw err;
 		}
-	}, [agent, copilotkit]);
+		if (current.interrupts.length > 1 && interruptId === void 0) console.warn(`[CopilotKit] useInterrupt: resolve()/cancel() called without an interruptId while ${current.interrupts.length} interrupts are open; defaulting to the first. Pass an interruptId to address a specific interrupt.`);
+		const id = interruptId ?? current.interrupts[0]?.id;
+		if (!id) return;
+		responsesRef.current[id] = {
+			status: "resolved",
+			payload
+		};
+		return submitStandardIfComplete(current.interrupts);
+	}, [
+		agent,
+		copilotkit,
+		submitStandardIfComplete
+	]);
+	const cancel = (0, react.useCallback)(async (interruptId) => {
+		const current = pendingRef.current;
+		if (!current) return;
+		if (current.kind === "legacy") {
+			console.warn("[CopilotKit] useInterrupt: cancel() is not supported for legacy on_interrupt interrupts; dismissing.");
+			setPending(null);
+			return;
+		}
+		if (current.interrupts.length > 1 && interruptId === void 0) console.warn(`[CopilotKit] useInterrupt: resolve()/cancel() called without an interruptId while ${current.interrupts.length} interrupts are open; defaulting to the first. Pass an interruptId to address a specific interrupt.`);
+		const id = interruptId ?? current.interrupts[0]?.id;
+		if (!id) return;
+		responsesRef.current[id] = { status: "cancelled" };
+		return submitStandardIfComplete(current.interrupts);
+	}, [submitStandardIfComplete]);
 	const renderRef = (0, react.useRef)(config.render);
 	renderRef.current = config.render;
 	const enabledRef = (0, react.useRef)(config.enabled);
@@ -4675,6 +4769,8 @@ function useInterrupt(config) {
 	handlerRef.current = config.handler;
 	const resolveRef = (0, react.useRef)(resolve);
 	resolveRef.current = resolve;
+	const cancelRef = (0, react.useRef)(cancel);
+	cancelRef.current = cancel;
 	const isEnabled = (event) => {
 		const predicate = enabledRef.current;
 		if (!predicate) return true;
@@ -4686,11 +4782,12 @@ function useInterrupt(config) {
 		}
 	};
 	(0, react.useEffect)(() => {
-		if (!pendingEvent) {
+		if (!pending) {
 			setHandlerResult(null);
 			return;
 		}
-		if (!isEnabled(pendingEvent)) {
+		const legacyEvent = toLegacyEvent(pending);
+		if (!isEnabled(legacyEvent)) {
 			setHandlerResult(null);
 			return;
 		}
@@ -4703,8 +4800,11 @@ function useInterrupt(config) {
 		let maybePromise;
 		try {
 			maybePromise = handler({
-				event: pendingEvent,
-				resolve: resolveRef.current
+				event: legacyEvent,
+				interrupt: pending.kind === "standard" ? pending.interrupts[0] : null,
+				interrupts: pending.kind === "standard" ? pending.interrupts : [],
+				resolve: resolveRef.current,
+				cancel: cancelRef.current
 			});
 		} catch (err) {
 			console.error("[CopilotKit] useInterrupt handler threw; result will be null:", err);
@@ -4723,19 +4823,24 @@ function useInterrupt(config) {
 		return () => {
 			cancelled = true;
 		};
-	}, [pendingEvent]);
+	}, [pending]);
 	const element = (0, react.useMemo)(() => {
-		if (!pendingEvent) return null;
-		if (!isEnabled(pendingEvent)) return null;
+		if (!pending) return null;
+		const legacyEvent = toLegacyEvent(pending);
+		if (!isEnabled(legacyEvent)) return null;
 		return renderRef.current({
-			event: pendingEvent,
+			event: legacyEvent,
+			interrupt: pending.kind === "standard" ? pending.interrupts[0] : null,
+			interrupts: pending.kind === "standard" ? pending.interrupts : [],
 			result: handlerResult,
-			resolve
+			resolve,
+			cancel
 		});
 	}, [
-		pendingEvent,
+		pending,
 		handlerResult,
-		resolve
+		resolve,
+		cancel
 	]);
 	(0, react.useEffect)(() => {
 		if (config.renderInChat === false) return;
@@ -4771,9 +4876,9 @@ function useThreadStoreSelector(store, selector) {
 * current without polling — thread creates, renames, archives, and deletes
 * from any client are reflected immediately.
 *
-* Mutation methods (`renameThread`, `archiveThread`, `deleteThread`) return
-* promises that resolve once the platform confirms the operation and reject
-* with an `Error` on failure.
+* Mutation methods (`renameThread`, `archiveThread`, `unarchiveThread`,
+* `deleteThread`) return promises that resolve once the platform confirms the
+* operation and reject with an `Error` on failure.
 *
 * @param input - Agent identifier and optional list controls.
 * @returns Thread list state and stable mutation callbacks.
@@ -4823,21 +4928,32 @@ function useThreads$1({ agentId, includeArchived, limit }) {
 	const headersKey = (0, react.useMemo)(() => {
 		return JSON.stringify(Object.entries(copilotkit.headers ?? {}).sort(([left], [right]) => left.localeCompare(right)));
 	}, [copilotkit.headers]);
+	const runtimeStatus = copilotkit.runtimeConnectionStatus;
+	const threadListEndpointSupported = copilotkit.threadEndpoints?.list !== false;
+	const threadMutationsSupported = copilotkit.threadEndpoints?.mutations !== false;
+	const threadEndpointsUnavailable = !!copilotkit.runtimeUrl && runtimeStatus === _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Connected && !threadListEndpointSupported;
 	const runtimeError = (0, react.useMemo)(() => {
 		if (copilotkit.runtimeUrl) return null;
 		return /* @__PURE__ */ new Error("Runtime URL is not configured");
 	}, [copilotkit.runtimeUrl]);
+	const threadEndpointsError = (0, react.useMemo)(() => {
+		if (!threadEndpointsUnavailable) return null;
+		return /* @__PURE__ */ new Error("Thread endpoints are not available on this CopilotKit runtime");
+	}, [threadEndpointsUnavailable]);
+	const threadMutationsError = (0, react.useMemo)(() => {
+		if (threadMutationsSupported) return null;
+		return /* @__PURE__ */ new Error("Thread mutations are not available on this CopilotKit runtime");
+	}, [threadMutationsSupported]);
 	const [hasDispatchedContext, setHasDispatchedContext] = (0, react.useState)(false);
-	const preConnectLoading = !!copilotkit.runtimeUrl && !hasDispatchedContext;
-	const isLoading = runtimeError ? false : preConnectLoading || storeIsLoading;
-	const error = runtimeError ?? storeError;
+	const preConnectLoading = !!copilotkit.runtimeUrl && !threadEndpointsUnavailable && !hasDispatchedContext;
+	const isLoading = runtimeError || threadEndpointsError ? false : preConnectLoading || storeIsLoading;
+	const error = runtimeError ?? threadEndpointsError ?? storeError;
 	(0, react.useEffect)(() => {
 		store.start();
 		return () => {
 			store.stop();
 		};
 	}, [store]);
-	const runtimeStatus = copilotkit.runtimeConnectionStatus;
 	(0, react.useEffect)(() => {
 		copilotkit.registerThreadStore(agentId, store);
 		return () => {
@@ -4851,9 +4967,15 @@ function useThreads$1({ agentId, includeArchived, limit }) {
 	(0, react.useEffect)(() => {
 		if (!copilotkit.runtimeUrl) {
 			store.setContext(null);
+			setHasDispatchedContext(false);
 			return;
 		}
 		if (runtimeStatus !== _copilotkit_core.CopilotKitCoreRuntimeConnectionStatus.Connected) return;
+		if (!threadListEndpointSupported) {
+			store.setContext(null);
+			setHasDispatchedContext(false);
+			return;
+		}
 		const context = {
 			runtimeUrl: copilotkit.runtimeUrl,
 			headers: { ...copilotkit.headers },
@@ -4870,13 +4992,21 @@ function useThreads$1({ agentId, includeArchived, limit }) {
 		runtimeStatus,
 		headersKey,
 		copilotkit.intelligence?.wsUrl,
+		threadListEndpointSupported,
 		agentId,
 		includeArchived,
 		limit
 	]);
-	const renameThread = (0, react.useCallback)((threadId, name) => store.renameThread(threadId, name), [store]);
-	const archiveThread = (0, react.useCallback)((threadId) => store.archiveThread(threadId), [store]);
-	const deleteThread = (0, react.useCallback)((threadId) => store.deleteThread(threadId), [store]);
+	const guardMutation = (0, react.useCallback)((mutation) => {
+		return (...args) => {
+			if (threadMutationsError) return Promise.reject(threadMutationsError);
+			return mutation(...args);
+		};
+	}, [threadMutationsError]);
+	const renameThread = (0, react.useMemo)(() => guardMutation((threadId, name) => store.renameThread(threadId, name)), [store, guardMutation]);
+	const archiveThread = (0, react.useMemo)(() => guardMutation((threadId) => store.archiveThread(threadId)), [store, guardMutation]);
+	const unarchiveThread = (0, react.useMemo)(() => guardMutation((threadId) => store.unarchiveThread(threadId)), [store, guardMutation]);
+	const deleteThread = (0, react.useMemo)(() => guardMutation((threadId) => store.deleteThread(threadId)), [store, guardMutation]);
 	return {
 		threads,
 		isLoading,
@@ -4886,6 +5016,7 @@ function useThreads$1({ agentId, includeArchived, limit }) {
 		fetchMoreThreads: (0, react.useCallback)(() => store.fetchNextPage(), [store]),
 		renameThread,
 		archiveThread,
+		unarchiveThread,
 		deleteThread
 	};
 }
@@ -7683,8 +7814,10 @@ function CopilotChat({ agentId, threadId, labels, chatView, isModalDefaultOpen,
 		hasExplicitThreadId
 	]);
 	const waitForActiveRunToSettle = (0, react.useCallback)(async () => {
-		if (agent.isRunning && (0, _copilotkit_core.isRunCompletionAware)(agent) && agent.activeRunCompletionPromise) try {
-			await agent.activeRunCompletionPromise;
+		const maybeAware = agent;
+		const activeRunCompletionPromise = (0, _copilotkit_core.isRunCompletionAware)(maybeAware) ? maybeAware.activeRunCompletionPromise : void 0;
+		if (agent.isRunning && activeRunCompletionPromise) try {
+			await activeRunCompletionPromise;
 		} catch (error) {
 			console.error("CopilotChat: in-flight run rejected while queuing send", error);
 		}
@@ -10123,6 +10256,7 @@ function CopilotKit({ children, ...props }) {
 	const showInspector = shouldShowDevConsole(props.enableInspector);
 	const publicApiKey = props.publicApiKey || props.publicLicenseKey;
 	const renderArr = (0, react.useMemo)(() => [{ render: CoAgentStateRenderBridge }], []);
+	const { onError: _onError, ...v2Props } = props;
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ToastProvider, {
 		enabled,
 		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotErrorBoundary, {
@@ -10131,7 +10265,7 @@ function CopilotKit({ children, ...props }) {
 			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ThreadsProvider, {
 				threadId: props.threadId,
 				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotKitProvider, {
-					...props,
+					...v2Props,
 					showDevConsole: showInspector,
 					renderCustomMessages: renderArr,
 					useSingleEndpoint: props.useSingleEndpoint ?? true,
@@ -11083,4 +11217,4 @@ Object.defineProperty(exports, 'useToast', {
     return useToast;
   }
 });
-//# sourceMappingURL=copilotkit-DtPCrXXd.cjs.map
+//# sourceMappingURL=copilotkit-CTCjVxkH.cjs.map