@copilotkit/react-core 1.70.2 → 1.70.3

package/dist/{copilotkit-DcFo270Y.cjs → copilotkit-BU3OvveB.cjs}

@@ -1549,6 +1549,29 @@ const ToolCallRenderer = react.default.memo(function ToolCallRenderer({ toolCall
 	if (prevProps.RenderComponent !== nextProps.RenderComponent) return false;
 	return true;
 });
+const IS_DEVELOPMENT$1 = process.env.NODE_ENV !== "production";
+/**
+* Reports tool calls that resolved to no renderer.
+*
+* A tool call with no renderer paints an empty message container and says
+* nothing else, so the only signal a developer gets today is a blank space in
+* the chat. This names the call and the renderers that *are* registered, which
+* is the whole diagnosis when the cause is a name that does not match.
+*
+* @param toolNames - The unmatched tool names collected during render.
+* @param registered - The registry as it stands now, re-read at report time.
+* @param alreadyWarned - Names already reported, mutated to keep this once per name.
+*/
+function warnAboutUnrenderedToolCalls(toolNames, registered, alreadyWarned) {
+	const registeredNames = Array.from(new Set(registered.map((rc) => rc.name)));
+	const hasWildcard = registeredNames.includes("*");
+	for (const toolName of toolNames) {
+		if (hasWildcard || registeredNames.includes(toolName)) continue;
+		if (alreadyWarned.has(toolName)) continue;
+		alreadyWarned.add(toolName);
+		console.warn(`[CopilotKit] The agent called the tool "${toolName}", and no renderer is registered for it, so that message rendered nothing. ` + (registeredNames.length === 0 ? "No tool-call renderers are registered. " : `Registered renderers: ${registeredNames.map((name) => `"${name}"`).join(", ")}. `) + `Register one with useRenderTool({ name: "${toolName}", ... }), or call useDefaultRenderTool() for a built-in card that covers every tool the agent calls. This warning is development-only.`);
+	}
+}
 /**
 * Hook that returns a function to render tool calls based on the render functions
 * defined in CopilotKitProvider.
@@ -1558,13 +1581,18 @@ const ToolCallRenderer = react.default.memo(function ToolCallRenderer({ toolCall
 function useRenderToolCall() {
 	const { copilotkit, executingToolCallIds } = (0, _copilotkit_react_core_v2_context.useCopilotKit)();
 	const agentId = useCopilotChatConfiguration()?.agentId ?? _copilotkit_shared.DEFAULT_AGENT_ID;
+	const unrenderedToolNames = (0, react.useRef)(/* @__PURE__ */ new Set());
+	const warnedToolNames = (0, react.useRef)(/* @__PURE__ */ new Set());
 	const renderToolCalls = (0, react.useSyncExternalStore)((callback) => {
 		return copilotkit.subscribe({ onRenderToolCallsChanged: callback }).unsubscribe;
 	}, () => copilotkit.renderToolCalls, () => copilotkit.renderToolCalls);
-	return (0, react.useCallback)(({ toolCall, toolMessage }) => {
+	const renderToolCall = (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;
+		if (!renderConfig) {
+			if (IS_DEVELOPMENT$1) unrenderedToolNames.current.add(toolCall.function.name);
+			return null;
+		}
 		const RenderComponent = renderConfig.render;
 		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ToolCallRenderer, {
 			toolCall,
@@ -1577,6 +1605,17 @@ function useRenderToolCall() {
 		executingToolCallIds,
 		agentId
 	]);
+	(0, react.useEffect)(() => {
+		if (!IS_DEVELOPMENT$1) return;
+		if (unrenderedToolNames.current.size === 0) return;
+		const timer = setTimeout(() => {
+			const pending = Array.from(unrenderedToolNames.current);
+			unrenderedToolNames.current.clear();
+			warnAboutUnrenderedToolCalls(pending, copilotkit.renderToolCalls, warnedToolNames.current);
+		}, 0);
+		return () => clearTimeout(timer);
+	});
+	return renderToolCall;
 }
 
 //#endregion
@@ -3055,6 +3094,95 @@ const A2UISurfaceContentSchema = zod.z.object({
 	a2ui_operations: zod.z.array(zod.z.any()).optional(),
 	...A2UILifecycleFields
 }).passthrough();
+const IS_DEVELOPMENT = process.env.NODE_ENV !== "production";
+/**
+* How long to wait for a surface to report its first paint before giving up on
+* the loader cross-over. Reaching it also means `onReady` never fired, which is
+* the signal the warning below reports.
+*/
+const PAINT_FALLBACK_MS = 8e3;
+/**
+* Names the operation kinds a surface received, for a warning that has to say
+* what did arrive as well as what did not.
+*
+* @param operations - The operations grouped under one surface.
+* @returns A comma-separated list of operation keys, or "none".
+*/
+function describeOperationKinds(operations) {
+	const kinds = /* @__PURE__ */ new Set();
+	for (const operation of operations) {
+		if (!operation || typeof operation !== "object") continue;
+		for (const key of Object.keys(operation)) if (key !== "version") kinds.add(key);
+	}
+	return kinds.size === 0 ? "none" : Array.from(kinds).join(", ");
+}
+/**
+* Reports surfaces that received operations and never painted.
+*
+* Reaching {@link PAINT_FALLBACK_MS} with no `onReady` means the operations were
+* accepted, were not malformed enough to raise the provider's error state, and
+* still put nothing on screen. Left alone that is invisible: the loader drops,
+* the turn finishes, and the only trace is an empty placeholder above the reply.
+*
+* `surfaceHasRenderableContent` already knows which half is missing, so the
+* warning says which rather than making the reader re-derive it.
+*
+* @param grouped - Operations grouped by surface id.
+*/
+function warnAboutUnpaintedSurfaces(grouped) {
+	for (const [surfaceId, operations] of grouped) {
+		if (surfaceHasRenderableContent(operations)) continue;
+		const cause = operations.filter((o) => o?.updateComponents).length === 0 ? "no updateComponents operation arrived, so the surface was never given anything to draw" : "its components address their values by \"path\" and no updateDataModel carried a non-empty value, so every bound component drew empty";
+		console.warn(`[CopilotKit] A2UI surface "${surfaceId}" received operations and never painted after ${String(PAINT_FALLBACK_MS)}ms: ${cause}. Operations received: ${describeOperationKinds(operations)}. The payload was accepted, so check what the agent sent rather than the client wiring. This warning is development-only.`);
+	}
+}
+/**
+* Names the component ids a surface was sent, for a warning about the one id
+* that is missing.
+*
+* @param operations - The operations grouped under one surface.
+* @returns A quoted, comma-separated list of ids, or "none".
+*/
+function describeComponentIds(operations) {
+	const ids = [];
+	for (const operation of operations) {
+		const components = operation?.updateComponents?.components;
+		if (!Array.isArray(components)) continue;
+		for (const component of components) {
+			const id = component?.id;
+			if (typeof id === "string" && !ids.includes(id)) ids.push(id);
+		}
+	}
+	return ids.length === 0 ? "none" : ids.map((id) => `"${id}"`).join(", ");
+}
+/**
+* Reports a surface that is still waiting for its {@link ROOT_COMPONENT_ID}
+* component once its operations have stopped arriving.
+*
+* Both renderers begin walking a surface at that one id, and treat an id they
+* cannot find as not arrived yet — an animated placeholder. That is right while
+* operations stream. Once they have stopped it is not waiting, it is stuck, and
+* every other check calls it healthy: the surface exists, `processMessages` did
+* not throw, the component types were never reached, and
+* `surfaceHasRenderableContent` says yes on the strength of components plus a
+* data model, so `onReady` fires and the never-painted report is suppressed.
+* A complete, accepted payload therefore animates a grey box forever in silence.
+*
+* Reads the live components model rather than scanning the operations for the
+* id, so it covers every way the root can fail to resolve — not only a payload
+* that never named one.
+*
+* @param surfaceId - The surface the operations were addressed to.
+* @param operations - The operations processed for that surface.
+* @param surface - The live surface model, already known to exist.
+*/
+function warnAboutUnresolvedRoot(surfaceId, operations, surface) {
+	if (surface?.componentsModel?.get?.(_copilotkit_a2ui_renderer.ROOT_COMPONENT_ID)) return;
+	const componentOps = operations.filter((o) => o?.updateComponents);
+	if (componentOps.length === 0) return;
+	const cause = componentOps.some((o) => o.updateComponents?.components?.some?.((c) => c?.id === _copilotkit_a2ui_renderer.ROOT_COMPONENT_ID)) ? `a component with id "${_copilotkit_a2ui_renderer.ROOT_COMPONENT_ID}" WAS sent, so the components did not reach the surface's model — check for an A2UI render error above, or a catalog that took none of them` : `the components it received are named ${describeComponentIds(operations)}, and none of them is "${_copilotkit_a2ui_renderer.ROOT_COMPONENT_ID}" — rename the entry-point component to "${_copilotkit_a2ui_renderer.ROOT_COMPONENT_ID}", and make every other component reachable from it through child/children`;
+	console.warn(`[CopilotKit] A2UI surface "${surfaceId}" has no "${_copilotkit_a2ui_renderer.ROOT_COMPONENT_ID}" component ${String(PAINT_FALLBACK_MS)}ms after its last operations were processed, so it is showing the placeholder for a component that has not arrived yet and will keep showing it: ${cause}. Operations received: ${describeOperationKinds(operations)}. This warning is development-only.`);
+}
 function createA2UIMessageRenderer(options) {
 	const { theme, catalog, loadingComponent, recovery, onAction } = options;
 	const showAfterMs = recovery?.showAfterMs ?? 2e3;
@@ -3088,6 +3216,8 @@ function createA2UIMessageRenderer(options) {
 				return groups;
 			}, [operations]);
 			const hasOps = groupedOperations.size > 0;
+			const groupedOperationsRef = (0, react.useRef)(groupedOperations);
+			groupedOperationsRef.current = groupedOperations;
 			const renderLifecycle = (c) => {
 				const status = c?.status;
 				const debugExposure = resolveDebugExposure(c, optionDebugExposure);
@@ -3119,7 +3249,10 @@ function createA2UIMessageRenderer(options) {
 					readyRef.current = false;
 					return;
 				}
-				const t = setTimeout(() => setSurfaceReady(true), 8e3);
+				const t = setTimeout(() => {
+					setSurfaceReady(true);
+					if (IS_DEVELOPMENT && !readyRef.current) warnAboutUnpaintedSurfaces(groupedOperationsRef.current);
+				}, PAINT_FALLBACK_MS);
 				return () => clearTimeout(t);
 			}, [hasOps]);
 			if (!hasOps) return renderLifecycle(content);
@@ -3243,8 +3376,21 @@ function SurfaceMessageProcessor({ surfaceId, operations, onReady }) {
 		const hash = JSON.stringify(operations);
 		if (hash === lastHashRef.current) return;
 		lastHashRef.current = hash;
-		processMessages(getSurface(surfaceId) ? operations.filter((op) => !op?.createSurface) : operations);
+		const ops = getSurface(surfaceId) ? operations.filter((op) => !op?.createSurface) : operations;
+		processMessages(ops);
 		if (onReady && surfaceHasRenderableContent(operations)) onReady();
+		if (!IS_DEVELOPMENT) return;
+		if (!getSurface(surfaceId)) {
+			const missingSurfaceCheck = setTimeout(() => {
+				if (getSurface(surfaceId)) return;
+				console.warn(`[CopilotKit] A2UI processed ${String(ops.length)} operation(s) addressed to surface "${surfaceId}" and no surface by that id exists, so this card rendered nothing. Operations received: ${describeOperationKinds(ops)}. A createSurface for "${surfaceId}" has to arrive before, or with, the operations that target it. This warning is development-only.`);
+			}, 0);
+			return () => clearTimeout(missingSurfaceCheck);
+		}
+		const unresolvedRootCheck = setTimeout(() => {
+			warnAboutUnresolvedRoot(surfaceId, operations, getSurface(surfaceId));
+		}, PAINT_FALLBACK_MS);
+		return () => clearTimeout(unresolvedRootCheck);
 	}, [
 		processMessages,
 		getSurface,
@@ -3271,10 +3417,26 @@ function surfaceHasRenderableContent(operations) {
 		return Object.values(v).some((x) => Array.isArray(x) ? x.length > 0 : x !== null && x !== void 0 && x !== "");
 	});
 }
+/**
+* Resolves the surface an operation addresses.
+*
+* The nested v0.9 `surfaceId` wins, because that is the id `MessageProcessor`
+* creates the surface under. Grouping by a top-level `surfaceId` instead files
+* the operations against a surface that never exists, which paints nothing —
+* the silence the missing-surface report above now names. A top-level
+* `surfaceId` is not the v0.9 shape, so it is honoured only when no nested id is
+* present. `getSurfaceId` in `@copilotkit/a2ui-renderer`'s web-components path
+* resolves it in the same order; the two disagreeing is what OSS-1048 recorded.
+*
+* @param operation - One A2UI operation, of any shape.
+* @returns The surface id, or null when the operation names none.
+*/
 function getOperationSurfaceId(operation) {
 	if (!operation || typeof operation !== "object") return null;
+	const nested = operation?.createSurface?.surfaceId ?? operation?.updateComponents?.surfaceId ?? operation?.updateDataModel?.surfaceId ?? operation?.deleteSurface?.surfaceId;
+	if (typeof nested === "string") return nested;
 	if (typeof operation.surfaceId === "string") return operation.surfaceId;
-	return operation?.createSurface?.surfaceId ?? operation?.updateComponents?.surfaceId ?? operation?.updateDataModel?.surfaceId ?? operation?.deleteSurface?.surfaceId ?? null;
+	return null;
 }
 
 //#endregion
@@ -3488,6 +3650,9 @@ const COPILOT_CLOUD_CHAT_URL$1 = "https://api.cloud.copilotkit.ai/copilotkit/v1"
 const EMPTY_HEADERS = Object.freeze({});
 const EMPTY_PROPERTIES = Object.freeze({});
 const EMPTY_AGENTS = Object.freeze({});
+/** Registration name of a catch-all tool: handles any otherwise-unhandled call. */
+const WILDCARD_TOOL_NAME$1 = "*";
+const HUMAN_IN_THE_LOOP_ABORTED_MESSAGE = "Human-in-the-loop interaction aborted";
 const DEFAULT_DESIGN_SKILL = `When generating UI with generateSandboxedUi, follow these design principles inspired by shadcn/ui:
 
 - Use a minimal, flat aesthetic. Avoid drop shadows and gradients — rely on subtle borders (1px solid, light gray like #e5e7eb) to define surfaces.
@@ -3606,6 +3771,11 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 	}
 	const chatApiEndpoint = 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.");
+	/**
+	* A `humanInTheLoop` prop tool call that is parked, waiting on the user.
+	* Keyed by tool call id, so parallel calls of one tool stay independent.
+	*/
+	const pendingHumanInTheLoopRef = (0, react.useRef)(/* @__PURE__ */ new Map());
 	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 sandboxFunctionsList = useStableArrayProp(openGenerativeUI?.sandboxFunctions, "openGenerativeUI.sandboxFunctions must be a stable array.");
 	const processedHumanInTheLoopTools = (0, react.useMemo)(() => {
@@ -3618,20 +3788,52 @@ const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY
 				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);
+				handler: async (_args, context) => {
+					const signal = context?.signal;
+					const key = context?.toolCall?.id ?? tool.name;
+					return new Promise((resolve, reject) => {
+						if (signal?.aborted) {
+							reject(new Error(HUMAN_IN_THE_LOOP_ABORTED_MESSAGE));
+							return;
+						}
+						const pending = { resolve };
+						pendingHumanInTheLoopRef.current.set(key, pending);
+						if (signal) {
+							const onAbort = () => {
+								pendingHumanInTheLoopRef.current.delete(key);
+								reject(new Error(HUMAN_IN_THE_LOOP_ABORTED_MESSAGE));
+							};
+							signal.addEventListener("abort", onAbort, { once: true });
+							pending.detachAbort = () => {
+								signal.removeEventListener("abort", onAbort);
+							};
+						}
 					});
 				}
 			};
 			processedTools.push(frontendTool);
-			if (tool.render) processedRenderToolCalls.push({
-				name: tool.name,
-				args: tool.parameters,
-				render: tool.render,
-				...tool.agentId && { agentId: tool.agentId }
-			});
+			if (tool.render) {
+				const ToolComponent = tool.render;
+				const RenderComponent = (props) => (0, react.createElement)(ToolComponent, {
+					...props,
+					name: tool.name === WILDCARD_TOOL_NAME$1 ? props.name : tool.name,
+					description: tool.description || "",
+					agentId: tool.agentId,
+					respond: props.status === _copilotkit_core.ToolCallStatus.Executing ? async (result) => {
+						const pending = pendingHumanInTheLoopRef.current.get(props.toolCallId);
+						if (!pending) return;
+						pending.detachAbort?.();
+						pendingHumanInTheLoopRef.current.delete(props.toolCallId);
+						pending.resolve(result);
+					} : void 0
+				});
+				processedRenderToolCalls.push({
+					name: tool.name,
+					args: tool.parameters,
+					render: RenderComponent,
+					...tool.agentId && { agentId: tool.agentId }
+				});
+			}
 		});
 		return {
 			tools: processedTools,
@@ -12793,4 +12995,4 @@ Object.defineProperty(exports, 'ɵrunMcpFollowUp', {
     return ɵrunMcpFollowUp;
   }
 });
-//# sourceMappingURL=copilotkit-DcFo270Y.cjs.map
+//# sourceMappingURL=copilotkit-BU3OvveB.cjs.map