@copilotkit/react-core 1.9.2-next.9 → 1.9.3-next.0

package/src/hooks/use-chat.ts

@@ -1,4 +1,5 @@
 import React, { useCallback, useEffect, useRef } from "react";
+import { flushSync } from "react-dom";
 import {
   FunctionCallHandler,
   COPILOT_CLOUD_PUBLIC_API_KEY_HEADER,
@@ -37,9 +38,8 @@ import {
 import { CopilotApiConfig } from "../context";
 import { FrontendAction, processActionsForRuntimeRequest } from "../types/frontend-action";
 import { CoagentState } from "../types/coagent-state";
-import { AgentSession } from "../context/copilot-context";
+import { AgentSession, useCopilotContext } from "../context/copilot-context";
 import { useCopilotRuntimeClient } from "./use-copilot-runtime-client";
-import { useCopilotContext } from "../context/copilot-context";
 import { useAsyncCallback, useErrorToast } from "../components/error-boundary/error-utils";
 import { useToast } from "../components/toast/toast-provider";
 import {
@@ -223,13 +223,13 @@ export function useChat(options: UseChatOptions): UseChatHelpers {
   const addErrorToast = useErrorToast();
   const { setBannerError } = useToast();
 
-  // Get onTrace from context since it's not part of copilotConfig
-  const { onTrace } = useCopilotContext();
+  // Get onError from context since it's not part of copilotConfig
+  const { onError } = useCopilotContext();
 
   // Add tracing functionality to use-chat
   const traceUIError = async (error: CopilotKitError, originalError?: any) => {
-    // Just check if onTrace and publicApiKey are defined
-    if (!onTrace || !copilotConfig?.publicApiKey) return;
+    // Just check if onError and publicApiKey are defined
+    if (!onError || !copilotConfig?.publicApiKey) return;
 
     try {
       const traceEvent = {
@@ -251,9 +251,9 @@ export function useChat(options: UseChatOptions): UseChatHelpers {
         error,
       };
 
-      await onTrace(traceEvent);
+      await onError(traceEvent);
     } catch (traceError) {
-      console.error("Error in use-chat onTrace handler:", traceError);
+      console.error("Error in use-chat onError handler:", traceError);
     }
   };
   // We need to keep a ref of coagent states and session because of renderAndWait - making sure
@@ -623,6 +623,8 @@ export function useChat(options: UseChatOptions): UseChatHelpers {
                   threadId: lastAgentStateMessage.threadId,
                   nodeName: lastAgentStateMessage.nodeName,
                   runId: lastAgentStateMessage.runId,
+                  // Preserve existing config from previous state
+                  config: prevAgentStates[lastAgentStateMessage.agentName]?.config,
                 },
               }));
               if (lastAgentStateMessage.running) {
@@ -658,6 +660,55 @@ export function useChat(options: UseChatOptions): UseChatHelpers {
 
         let didExecuteAction = false;
 
+        // ----- Helper function to execute an action and manage its lifecycle -----
+        const executeActionFromMessage = async (
+          currentAction: FrontendAction<any>,
+          actionMessage: ActionExecutionMessage,
+        ) => {
+          const isInterruptAction = interruptMessages.find((m) => m.id === actionMessage.id);
+          // Determine follow-up behavior: use action's specific setting if defined, otherwise default based on interrupt status.
+          followUp = currentAction?.followUp ?? !isInterruptAction;
+
+          // Call _setActivatingMessageId before executing the action for HITL correlation
+          if ((currentAction as any)?._setActivatingMessageId) {
+            (currentAction as any)._setActivatingMessageId(actionMessage.id);
+          }
+
+          const resultMessage = await executeAction({
+            onFunctionCall: onFunctionCall!,
+            message: actionMessage,
+            chatAbortControllerRef,
+            onError: (error: Error) => {
+              addErrorToast([error]);
+              // console.error is kept here as it's a genuine error in action execution
+              console.error(`Failed to execute action ${actionMessage.name}: ${error}`);
+            },
+            setMessages,
+            getFinalMessages: () => finalMessages,
+            isRenderAndWait: (currentAction as any)?._isRenderAndWait || false,
+          });
+          didExecuteAction = true;
+          const messageIndex = finalMessages.findIndex((msg) => msg.id === actionMessage.id);
+          finalMessages.splice(messageIndex + 1, 0, resultMessage);
+
+          // If the executed action was a renderAndWaitForResponse type, update messages immediately
+          // to reflect its completion in the UI, making it interactive promptly.
+          if ((currentAction as any)?._isRenderAndWait) {
+            const messagesForImmediateUpdate = [...finalMessages];
+            flushSync(() => {
+              setMessages(messagesForImmediateUpdate);
+            });
+          }
+
+          // Clear _setActivatingMessageId after the action is done
+          if ((currentAction as any)?._setActivatingMessageId) {
+            (currentAction as any)._setActivatingMessageId(null);
+          }
+
+          return resultMessage;
+        };
+        // ----------------------------------------------------------------------
+
         // execute regular action executions that are specific to the frontend (last actions)
         if (onFunctionCall) {
           // Find consecutive action execution messages at the end
@@ -687,44 +738,38 @@ export function useChat(options: UseChatOptions): UseChatHelpers {
               ? getPairedFeAction(actions, message)
               : null;
 
-            const executeActionFromMessage = async (
-              action: FrontendAction<any>,
-              message: ActionExecutionMessage,
-            ) => {
-              const isInterruptAction = interruptMessages.find((m) => m.id === message.id);
-              followUp = action?.followUp ?? !isInterruptAction;
-              const resultMessage = await executeAction({
-                onFunctionCall,
-                previousMessages,
-                message,
-                chatAbortControllerRef,
-                onError: (error: Error) => {
-                  addErrorToast([error]);
-                  console.error(`Failed to execute action ${message.name}: ${error}`);
-                },
-              });
-              didExecuteAction = true;
-              const messageIndex = finalMessages.findIndex((msg) => msg.id === message.id);
-              finalMessages.splice(messageIndex + 1, 0, resultMessage);
-
-              return resultMessage;
-            };
-
             // execution message which has an action registered with the hook (remote availability):
             // execute that action first, and then the "paired FE action"
             if (action && message.isActionExecutionMessage()) {
-              const resultMessage = await executeActionFromMessage(action, message);
-              const pairedFeAction = getPairedFeAction(actions, resultMessage);
-
-              if (pairedFeAction) {
-                const newExecutionMessage = new ActionExecutionMessage({
-                  name: pairedFeAction.name,
-                  arguments: parseJson(resultMessage.result, resultMessage.result),
-                  status: message.status,
-                  createdAt: message.createdAt,
-                  parentMessageId: message.parentMessageId,
-                });
-                await executeActionFromMessage(pairedFeAction, newExecutionMessage);
+              // For HITL actions, check if they've already been processed to avoid redundant handler calls.
+              const isRenderAndWaitAction = (action as any)?._isRenderAndWait || false;
+              const alreadyProcessed =
+                isRenderAndWaitAction &&
+                finalMessages.some(
+                  (fm) => fm.isResultMessage() && fm.actionExecutionId === message.id,
+                );
+
+              if (alreadyProcessed) {
+                // Skip re-execution if already processed
+              } else {
+                // Call the single, externally defined executeActionFromMessage
+                const resultMessage = await executeActionFromMessage(
+                  action,
+                  message as ActionExecutionMessage,
+                );
+                const pairedFeAction = getPairedFeAction(actions, resultMessage);
+
+                if (pairedFeAction) {
+                  const newExecutionMessage = new ActionExecutionMessage({
+                    name: pairedFeAction.name,
+                    arguments: parseJson(resultMessage.result, resultMessage.result),
+                    status: message.status,
+                    createdAt: message.createdAt,
+                    parentMessageId: message.parentMessageId,
+                  });
+                  // Call the single, externally defined executeActionFromMessage
+                  await executeActionFromMessage(pairedFeAction, newExecutionMessage);
+                }
               }
             } else if (message.isResultMessage() && currentResultMessagePairedFeAction) {
               // Actions which are set up in runtime actions array: Grab the result, executed paired FE action with it as args.
@@ -735,6 +780,7 @@ export function useChat(options: UseChatOptions): UseChatHelpers {
                 createdAt: message.createdAt,
               });
               finalMessages.push(newExecutionMessage);
+              // Call the single, externally defined executeActionFromMessage
               await executeActionFromMessage(
                 currentResultMessagePairedFeAction,
                 newExecutionMessage,
@@ -745,10 +791,10 @@ export function useChat(options: UseChatOptions): UseChatHelpers {
           setMessages(finalMessages);
         }
 
+        // Conditionally run chat completion again if followUp is not explicitly false
+        // and an action was executed or the last message is a server-side result (for non-agent runs).
         if (
-          // if followUp is not explicitly false
           followUp !== false &&
-          // and we executed an action
           (didExecuteAction ||
             // the last message is a server side result
             (!isAgentRun &&
@@ -892,25 +938,47 @@ export function useChat(options: UseChatOptions): UseChatHelpers {
   );
 
   const reload = useAsyncCallback(
-    async (messageId: string): Promise<void> => {
+    async (reloadMessageId: string): Promise<void> => {
       if (isLoading || messages.length === 0) {
         return;
       }
 
-      const index = messages.findIndex((msg) => msg.id === messageId);
-      if (index === -1) {
-        console.warn(`Message with id ${messageId} not found`);
+      const reloadMessageIndex = messages.findIndex((msg) => msg.id === reloadMessageId);
+      if (reloadMessageIndex === -1) {
+        console.warn(`Message with id ${reloadMessageId} not found`);
         return;
       }
 
-      let newMessages = messages.slice(0, index); // excludes the message with messageId
-      if (newMessages.length > 0 && newMessages[newMessages.length - 1].isAgentStateMessage()) {
-        newMessages = newMessages.slice(0, newMessages.length - 1); // remove last one too
+      // @ts-expect-error -- message has role
+      const reloadMessageRole = messages[reloadMessageIndex].role;
+      if (reloadMessageRole !== MessageRole.Assistant) {
+        console.warn(`Regenerate cannot be performed on ${reloadMessageRole} role`);
+        return;
       }
 
-      setMessages(newMessages);
+      let historyCutoff: Message[] = [];
+      if (messages.length > 2) {
+        // message to regenerate from is now first.
+        // Work backwards to find the first the closest user message
+        const lastUserMessageBeforeRegenerate = messages
+          .slice(0, reloadMessageIndex)
+          .reverse()
+          .find(
+            (msg) =>
+              // @ts-expect-error -- message has role
+              msg.role === MessageRole.User,
+          );
+        const indexOfLastUserMessageBeforeRegenerate = messages.findIndex(
+          (msg) => msg.id === lastUserMessageBeforeRegenerate!.id,
+        );
+
+        // Include the user message, remove everything after it
+        historyCutoff = messages.slice(0, indexOfLastUserMessageBeforeRegenerate + 1);
+      }
 
-      return runChatCompletionAndHandleFunctionCall(newMessages);
+      setMessages(historyCutoff);
+
+      return runChatCompletionAndHandleFunctionCall(historyCutoff);
     },
     [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall],
   );
@@ -958,26 +1026,46 @@ function constructFinalMessages(
 
 async function executeAction({
   onFunctionCall,
-  previousMessages,
   message,
   chatAbortControllerRef,
   onError,
+  setMessages,
+  getFinalMessages,
+  isRenderAndWait,
 }: {
   onFunctionCall: FunctionCallHandler;
-  previousMessages: Message[];
   message: ActionExecutionMessage;
   chatAbortControllerRef: React.MutableRefObject<AbortController | null>;
   onError: (error: Error) => void;
+  setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+  getFinalMessages: () => Message[];
+  isRenderAndWait: boolean;
 }) {
   let result: any;
   let error: Error | null = null;
+
+  const currentMessagesForHandler = getFinalMessages();
+
+  // The handler (onFunctionCall) runs its synchronous part here, potentially setting up
+  // renderAndWaitRef.current for HITL actions via useCopilotAction's transformed handler.
+  const handlerReturnedPromise = onFunctionCall({
+    messages: currentMessagesForHandler,
+    name: message.name,
+    args: message.arguments,
+  });
+
+  // For HITL actions, call flushSync immediately after their handler has set up the promise
+  // and before awaiting the promise. This ensures the UI updates to an interactive state.
+  if (isRenderAndWait) {
+    const currentMessagesForRender = getFinalMessages();
+    flushSync(() => {
+      setMessages([...currentMessagesForRender]);
+    });
+  }
+
   try {
     result = await Promise.race([
-      onFunctionCall({
-        messages: previousMessages,
-        name: message.name,
-        args: message.arguments,
-      }),
+      handlerReturnedPromise, // Await the promise returned by the handler
       new Promise((resolve) =>
         chatAbortControllerRef.current?.signal.addEventListener("abort", () =>
           resolve("Operation was aborted by the user"),

package/src/hooks/use-coagent.ts

@@ -311,6 +311,42 @@ export function useCoAgent<T = any>(options: UseCoagentOptions<T>): UseCoagentRe
     coagentStates[name] === undefined,
   ]);
 
+  // Sync config when runtime configuration changes
+  useEffect(() => {
+    const newConfig = options.config
+      ? options.config
+      : options.configurable
+        ? { configurable: options.configurable }
+        : undefined;
+
+    if (newConfig === undefined) return;
+
+    setCoagentStatesWithRef((prev) => {
+      const existing = prev[name] ?? {
+        name,
+        state: isInternalStateManagementWithInitial(options) ? options.initialState : {},
+        config: {},
+        running: false,
+        active: false,
+        threadId: undefined,
+        nodeName: undefined,
+        runId: undefined,
+      };
+
+      if (JSON.stringify(existing.config) === JSON.stringify(newConfig)) {
+        return prev;
+      }
+
+      return {
+        ...prev,
+        [name]: {
+          ...existing,
+          config: newConfig,
+        },
+      };
+    });
+  }, [JSON.stringify(options.config), JSON.stringify(options.configurable)]);
+
   const runAgentCallback = useAsyncCallback(
     async (hint?: HintFunction) => {
       await runAgent(name, context, appendMessage, runChatCompletion, hint);

package/src/hooks/use-copilot-action.ts

@@ -159,11 +159,14 @@ export function useCopilotAction<const T extends Parameter[] | [] = []>(
   const { setAction, removeAction, actions, chatComponentsCache } = useCopilotContext();
   const idRef = useRef<string>(randomId());
   const renderAndWaitRef = useRef<RenderAndWaitForResponse | null>(null);
+  const activatingMessageIdRef = useRef<string | null>(null);
   const { addToast } = useToast();
 
   // clone the action to avoid mutating the original object
   action = { ...action };
 
+  // const { currentlyActivatingHitlActionMessageIdRef } = useCopilotContext() as any; // <-- REMOVE THIS FOR NOW
+
   // If the developer provides a renderAndWaitForResponse function, we transform the action
   // to use a promise internally, so that we can treat it like a normal action.
   if (
@@ -172,12 +175,21 @@ export function useCopilotAction<const T extends Parameter[] | [] = []>(
     // check if renderAndWaitForResponse is set
     (action.renderAndWait || action.renderAndWaitForResponse)
   ) {
+    (action as any)._isRenderAndWait = true; // Internal flag to identify this action type later
     const renderAndWait = action.renderAndWait || action.renderAndWaitForResponse;
     // remove the renderAndWait function from the action
     action.renderAndWait = undefined;
     action.renderAndWaitForResponse = undefined;
+
+    // Add a method for use-chat.ts to set the activating message ID.
+    // This helps correlate the action instance with the message being processed by use-chat.
+    (action as any)._setActivatingMessageId = (id: string | null) => {
+      activatingMessageIdRef.current = id;
+    };
+
     // add a handler that will be called when the action is executed
     action.handler = useAsyncCallback(async () => {
+      const currentActivatingId = activatingMessageIdRef.current;
       // we create a new promise when the handler is called
       let resolve: (result: any) => void;
       let reject: (error: any) => void;
@@ -185,26 +197,55 @@ export function useCopilotAction<const T extends Parameter[] | [] = []>(
         resolve = resolvePromise;
         reject = rejectPromise;
       });
-      renderAndWaitRef.current = { promise, resolve: resolve!, reject: reject! };
+      renderAndWaitRef.current = {
+        promise,
+        resolve: resolve!,
+        reject: reject!,
+        messageId: currentActivatingId,
+      };
       // then we await the promise (it will be resolved in the original renderAndWait function)
-      return await promise;
+      const result = await promise;
+      return result;
     }, []) as any;
 
     // add a render function that will be called when the action is rendered
-    action.render = ((props: ActionRenderProps<T>): React.ReactElement => {
-      // Specifically for renderAndWaitForResponse the executing state is set too early, causing a race condition
-      // To fit it: we will wait for the handler to be ready
+    action.render = ((props: ActionRenderProps<T> & { messageId?: string }): React.ReactElement => {
+      const currentRenderMessageId = props.messageId;
+      // For renderAndWaitForResponse, the 'executing' state might be set by use-chat before
+      // this specific action instance's handler (and thus its promise) is ready.
+      // This logic adjusts the status to 'inProgress' if the current render
+      // isn't for the actively processing HITL action, preventing premature interaction.
       let status = props.status;
-      if (props.status === "executing" && !renderAndWaitRef.current) {
-        status = "inProgress";
+      if (props.status === "executing") {
+        if (!renderAndWaitRef.current || !renderAndWaitRef.current.promise) {
+          status = "inProgress";
+        } else if (
+          renderAndWaitRef.current.messageId !== currentRenderMessageId &&
+          activatingMessageIdRef.current !== currentRenderMessageId
+        ) {
+          status = "inProgress";
+        }
+        // If conditions met, status remains 'executing'
       }
       // Create type safe waitProps based on whether T extends empty array or not
       const waitProps = {
         status,
         args: props.args,
         result: props.result,
-        handler: status === "executing" ? renderAndWaitRef.current!.resolve : undefined,
-        respond: status === "executing" ? renderAndWaitRef.current!.resolve : undefined,
+        // handler and respond should only be provided if this is the truly active instance
+        // and its promise infrastructure is ready.
+        handler:
+          status === "executing" &&
+          renderAndWaitRef.current &&
+          renderAndWaitRef.current.messageId === currentRenderMessageId
+            ? renderAndWaitRef.current!.resolve
+            : undefined,
+        respond:
+          status === "executing" &&
+          renderAndWaitRef.current &&
+          renderAndWaitRef.current.messageId === currentRenderMessageId
+            ? renderAndWaitRef.current!.resolve
+            : undefined,
       } as T extends [] ? ActionRenderPropsNoArgsWait<T> : ActionRenderPropsWait<T>;
 
       // Type guard to check if renderAndWait is for no args case
@@ -302,4 +343,5 @@ interface RenderAndWaitForResponse {
   promise: Promise<any>;
   resolve: (result: any) => void;
   reject: (error: any) => void;
+  messageId: string | null;
 }

package/src/hooks/use-copilot-runtime-client.ts

@@ -12,31 +12,30 @@ import {
   CopilotKitAgentDiscoveryError,
   CopilotKitError,
   CopilotKitErrorCode,
-  ERROR_CONFIG,
-  CopilotTraceHandler,
-  CopilotTraceEvent,
+  CopilotErrorHandler,
+  CopilotErrorEvent,
 } from "@copilotkit/shared";
 import { shouldShowDevConsole } from "../utils/dev-console";
 
 export interface CopilotRuntimeClientHookOptions extends CopilotRuntimeClientOptions {
   showDevConsole?: boolean;
-  onTrace?: CopilotTraceHandler;
+  onError?: CopilotErrorHandler;
 }
 
 export const useCopilotRuntimeClient = (options: CopilotRuntimeClientHookOptions) => {
   const { setBannerError } = useToast();
-  const { showDevConsole, onTrace, ...runtimeOptions } = options;
+  const { showDevConsole, onError, ...runtimeOptions } = options;
 
   // Deduplication state for structured errors
   const lastStructuredErrorRef = useRef<{ message: string; timestamp: number } | null>(null);
 
   // Helper function to trace UI errors
   const traceUIError = async (error: CopilotKitError, originalError?: any) => {
-    // Just check if onTrace and publicApiKey are defined
-    if (!onTrace || !runtimeOptions.publicApiKey) return;
+    // Just check if onError and publicApiKey are defined
+    if (!onError || !runtimeOptions.publicApiKey) return;
 
     try {
-      const traceEvent: CopilotTraceEvent = {
+      const errorEvent: CopilotErrorEvent = {
         type: "error",
         timestamp: Date.now(),
         context: {
@@ -54,9 +53,9 @@ export const useCopilotRuntimeClient = (options: CopilotRuntimeClientHookOptions
         },
         error,
       };
-      await onTrace(traceEvent);
-    } catch (traceError) {
-      console.error("Error in onTrace handler:", traceError);
+      await onError(errorEvent);
+    } catch (error) {
+      console.error("Error in onError handler:", error);
     }
   };
 
@@ -142,7 +141,7 @@ export const useCopilotRuntimeClient = (options: CopilotRuntimeClientHookOptions
         setBannerError(warningError);
       },
     });
-  }, [runtimeOptions, setBannerError, showDevConsole, onTrace]);
+  }, [runtimeOptions, setBannerError, showDevConsole, onError]);
 
   return runtimeClient;
 };

package/src/setupTests.ts

@@ -0,0 +1,26 @@
+// Mock modules that cause ES module issues
+jest.mock("@segment/analytics-node", () => ({
+  Analytics: jest.fn().mockImplementation(() => ({
+    track: jest.fn(),
+    identify: jest.fn(),
+    page: jest.fn(),
+    group: jest.fn(),
+    alias: jest.fn(),
+  })),
+}));
+
+jest.mock("@copilotkit/shared", () => ({
+  parseJson: jest.fn((jsonString, defaultValue) => {
+    try {
+      return JSON.parse(jsonString);
+    } catch {
+      return defaultValue;
+    }
+  }),
+  CopilotKitAgentDiscoveryError: jest.fn(),
+}));
+
+// Mock react-dom/test-utils to avoid compatibility issues
+jest.mock("react-dom/test-utils", () => ({
+  act: jest.fn((fn) => fn()),
+}));

package/tsconfig.json

@@ -1,5 +1,8 @@
 {
   "extends": "../../utilities/tsconfig/react-library.json",
-  "include": ["."],
-  "exclude": ["dist", "build", "node_modules", "**/*.test.ts", "**/*.test.tsx", "**/__tests__/*"]
+  "compilerOptions": {
+    "types": ["jest", "@types/jest"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "build", "node_modules"]
 }

package/dist/chunk-55QZ2SVJ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/hooks/use-copilot-runtime-client.ts"],"sourcesContent":["import {\n  CopilotRuntimeClient,\n  CopilotRuntimeClientOptions,\n  GraphQLError,\n} from \"@copilotkit/runtime-client-gql\";\nimport { useToast } from \"../components/toast/toast-provider\";\nimport { useMemo, useRef } from \"react\";\nimport {\n  ErrorVisibility,\n  CopilotKitApiDiscoveryError,\n  CopilotKitRemoteEndpointDiscoveryError,\n  CopilotKitAgentDiscoveryError,\n  CopilotKitError,\n  CopilotKitErrorCode,\n  ERROR_CONFIG,\n  CopilotTraceHandler,\n  CopilotTraceEvent,\n} from \"@copilotkit/shared\";\nimport { shouldShowDevConsole } from \"../utils/dev-console\";\n\nexport interface CopilotRuntimeClientHookOptions extends CopilotRuntimeClientOptions {\n  showDevConsole?: boolean;\n  onTrace?: CopilotTraceHandler;\n}\n\nexport const useCopilotRuntimeClient = (options: CopilotRuntimeClientHookOptions) => {\n  const { setBannerError } = useToast();\n  const { showDevConsole, onTrace, ...runtimeOptions } = options;\n\n  // Deduplication state for structured errors\n  const lastStructuredErrorRef = useRef<{ message: string; timestamp: number } | null>(null);\n\n  // Helper function to trace UI errors\n  const traceUIError = async (error: CopilotKitError, originalError?: any) => {\n    // Just check if onTrace and publicApiKey are defined\n    if (!onTrace || !runtimeOptions.publicApiKey) return;\n\n    try {\n      const traceEvent: CopilotTraceEvent = {\n        type: \"error\",\n        timestamp: Date.now(),\n        context: {\n          source: \"ui\",\n          request: {\n            operation: \"runtimeClient\",\n            url: runtimeOptions.url,\n            startTime: Date.now(),\n          },\n          technical: {\n            environment: \"browser\",\n            userAgent: typeof navigator !== \"undefined\" ? navigator.userAgent : undefined,\n            stackTrace: originalError instanceof Error ? originalError.stack : undefined,\n          },\n        },\n        error,\n      };\n      await onTrace(traceEvent);\n    } catch (traceError) {\n      console.error(\"Error in onTrace handler:\", traceError);\n    }\n  };\n\n  const runtimeClient = useMemo(() => {\n    return new CopilotRuntimeClient({\n      ...runtimeOptions,\n      handleGQLErrors: (error) => {\n        if ((error as any).graphQLErrors?.length) {\n          const graphQLErrors = (error as any).graphQLErrors as GraphQLError[];\n\n          // Route all errors to banners for consistent UI\n          const routeError = (gqlError: GraphQLError) => {\n            const extensions = gqlError.extensions;\n            const visibility = extensions?.visibility as ErrorVisibility;\n            const isDev = shouldShowDevConsole(showDevConsole ?? false);\n\n            // Silent errors - just log\n            if (visibility === ErrorVisibility.SILENT) {\n              console.error(\"CopilotKit Silent Error:\", gqlError.message);\n              return;\n            }\n\n            if (!isDev) {\n              console.error(\"CopilotKit Error (hidden in production):\", gqlError.message);\n              return;\n            }\n\n            // All errors (including DEV_ONLY) show as banners for consistency\n            // Deduplicate to prevent spam\n            const now = Date.now();\n            const errorMessage = gqlError.message;\n            if (\n              lastStructuredErrorRef.current &&\n              lastStructuredErrorRef.current.message === errorMessage &&\n              now - lastStructuredErrorRef.current.timestamp < 150\n            ) {\n              return; // Skip duplicate\n            }\n            lastStructuredErrorRef.current = { message: errorMessage, timestamp: now };\n\n            const ckError = createStructuredError(gqlError);\n            if (ckError) {\n              setBannerError(ckError);\n              // Trace the error\n              traceUIError(ckError, gqlError);\n            } else {\n              // Fallback for unstructured errors\n              const fallbackError = new CopilotKitError({\n                message: gqlError.message,\n                code: CopilotKitErrorCode.UNKNOWN,\n              });\n              setBannerError(fallbackError);\n              // Trace the fallback error\n              traceUIError(fallbackError, gqlError);\n            }\n          };\n\n          // Process all errors as banners\n          graphQLErrors.forEach(routeError);\n        } else {\n          const isDev = shouldShowDevConsole(showDevConsole ?? false);\n          if (!isDev) {\n            console.error(\"CopilotKit Error (hidden in production):\", error);\n          } else {\n            // Route non-GraphQL errors to banner as well\n            const fallbackError = new CopilotKitError({\n              message: error?.message || String(error),\n              code: CopilotKitErrorCode.UNKNOWN,\n            });\n            setBannerError(fallbackError);\n            // Trace the non-GraphQL error\n            traceUIError(fallbackError, error);\n          }\n        }\n      },\n      handleGQLWarning: (message: string) => {\n        console.warn(message);\n        // Show warnings as banners too for consistency\n        const warningError = new CopilotKitError({\n          message,\n          code: CopilotKitErrorCode.UNKNOWN,\n        });\n        setBannerError(warningError);\n      },\n    });\n  }, [runtimeOptions, setBannerError, showDevConsole, onTrace]);\n\n  return runtimeClient;\n};\n\n// Create appropriate structured error from GraphQL error\nfunction createStructuredError(gqlError: GraphQLError): CopilotKitError | null {\n  const extensions = gqlError.extensions;\n  const originalError = extensions?.originalError as any;\n  const message = originalError?.message || gqlError.message;\n  const code = extensions?.code as CopilotKitErrorCode;\n\n  if (code) {\n    return new CopilotKitError({ message, code });\n  }\n\n  // Legacy error detection by stack trace\n  if (originalError?.stack?.includes(\"CopilotApiDiscoveryError\")) {\n    return new CopilotKitApiDiscoveryError({ message });\n  }\n  if (originalError?.stack?.includes(\"CopilotKitRemoteEndpointDiscoveryError\")) {\n    return new CopilotKitRemoteEndpointDiscoveryError({ message });\n  }\n  if (originalError?.stack?.includes(\"CopilotKitAgentDiscoveryError\")) {\n    return new CopilotKitAgentDiscoveryError({\n      agentName: \"\",\n      availableAgents: [],\n    });\n  }\n\n  return null;\n}\n"],"mappings":"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","names":["_a"]}