@copilotkit/react-core 1.70.1 → 1.70.3

package/dist/v2/headless.cjs

@@ -281,6 +281,62 @@ const CopilotChatConfigurationProvider = ({ children, labels, agentId, threadId,
 const useCopilotChatConfiguration = () => {
 	return (0, react.useContext)(CopilotChatConfiguration);
 };
+/**
+* Reports modal open/close requests to the host, and — when `open` is
+* supplied — makes the modal state of an already-established chat
+* configuration **controlled** for the subtree it wraps.
+*
+* This is deliberately a scope component rather than another mode inside
+* {@link CopilotChatConfigurationProvider}. The provider resolves modal state
+* across a nested chain (own state, parent sync, drawer mutual-exclusion, the
+* modal-closer registry); a controlled branch inside that resolution would add
+* a fourth interacting mode. Overriding the context for the subtree instead
+* leaves every one of those paths untouched:
+*
+* - `isModalOpen` is replaced with the host's `open`, so the rendered surface
+*   follows the prop from the very first frame (no open-then-close flash).
+* - `setModalOpen` still calls the underlying setter, so the existing
+*   parent-sync and drawer mutual-exclusion side effects continue to run, and
+*   *then* reports the request through `onOpenChange`.
+* - The wrapped setter is registered as the modal closer, so the drawer's
+*   mobile mutual-exclusion reaches the host instead of silently flipping
+*   state that nothing displays.
+*
+* A host that supplies `open` and ignores `onOpenChange` gets a modal pinned
+* to `open`, which is the standard controlled-component contract. A host that
+* supplies only `onOpenChange` is notified while the modal keeps managing
+* itself.
+*
+* Renders `children` unchanged when no chat configuration is in scope.
+*/
+const ControlledModalOpenScope = ({ children, open, onOpenChange }) => {
+	const parentConfig = (0, react.useContext)(CopilotChatConfiguration);
+	const parentSetModalOpen = parentConfig?.setModalOpen;
+	const registerModalCloser = parentConfig?.ɵregisterModalCloser;
+	const setModalOpen = (0, react.useCallback)((next) => {
+		parentSetModalOpen?.(next);
+		onOpenChange?.(next);
+	}, [parentSetModalOpen, onOpenChange]);
+	(0, react.useEffect)(() => {
+		if (!registerModalCloser) return;
+		return registerModalCloser(setModalOpen);
+	}, [registerModalCloser, setModalOpen]);
+	const configurationValue = (0, react.useMemo)(() => parentConfig ? {
+		...parentConfig,
+		isModalOpen: open ?? parentConfig.isModalOpen,
+		setModalOpen
+	} : null, [
+		parentConfig,
+		open,
+		setModalOpen
+	]);
+	if (!configurationValue) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children });
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotChatConfiguration.Provider, {
+		value: configurationValue,
+		children
+	});
+};
+ControlledModalOpenScope.displayName = "ControlledModalOpenScope";
 
 //#endregion
 //#region src/v2/hooks/use-agent.tsx
@@ -1522,6 +1578,29 @@ const ToolCallRenderer = react.default.memo(function ToolCallRenderer({ toolCall
 	if (prevProps.RenderComponent !== nextProps.RenderComponent) return false;
 	return true;
 });
+const IS_DEVELOPMENT = 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.
@@ -1531,13 +1610,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) unrenderedToolNames.current.add(toolCall.function.name);
+			return null;
+		}
 		const RenderComponent = renderConfig.render;
 		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ToolCallRenderer, {
 			toolCall,
@@ -1550,6 +1634,17 @@ function useRenderToolCall() {
 		executingToolCallIds,
 		agentId
 	]);
+	(0, react.useEffect)(() => {
+		if (!IS_DEVELOPMENT) 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