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

package/dist/hooks/index.js

@@ -173,7 +173,7 @@ var emptyCopilotContext = {
   langGraphInterruptAction: null,
   setLangGraphInterruptAction: () => null,
   removeLangGraphInterruptAction: () => null,
-  onTrace: void 0
+  onError: void 0
 };
 var CopilotContext = import_react.default.createContext(emptyCopilotContext);
 function useCopilotContext() {
@@ -192,6 +192,7 @@ var import_runtime_client_gql4 = require("@copilotkit/runtime-client-gql");
 
 // src/hooks/use-chat.ts
 var import_react5 = require("react");
+var import_react_dom = require("react-dom");
 var import_shared4 = require("@copilotkit/shared");
 var import_runtime_client_gql3 = require("@copilotkit/runtime-client-gql");
 
@@ -248,13 +249,13 @@ function shouldShowDevConsole(showDevConsole) {
 // src/hooks/use-copilot-runtime-client.ts
 var useCopilotRuntimeClient = (options) => {
   const { setBannerError } = useToast();
-  const _a = options, { showDevConsole, onTrace } = _a, runtimeOptions = __objRest(_a, ["showDevConsole", "onTrace"]);
+  const _a = options, { showDevConsole, onError } = _a, runtimeOptions = __objRest(_a, ["showDevConsole", "onError"]);
   const lastStructuredErrorRef = (0, import_react3.useRef)(null);
   const traceUIError = (error, originalError) => __async(void 0, null, function* () {
-    if (!onTrace || !runtimeOptions.publicApiKey)
+    if (!onError || !runtimeOptions.publicApiKey)
       return;
     try {
-      const traceEvent = {
+      const errorEvent = {
         type: "error",
         timestamp: Date.now(),
         context: {
@@ -272,9 +273,9 @@ var useCopilotRuntimeClient = (options) => {
         },
         error
       };
-      yield onTrace(traceEvent);
-    } catch (traceError) {
-      console.error("Error in onTrace handler:", traceError);
+      yield onError(errorEvent);
+    } catch (error2) {
+      console.error("Error in onError handler:", error2);
     }
   });
   const runtimeClient = (0, import_react3.useMemo)(() => {
@@ -338,7 +339,7 @@ var useCopilotRuntimeClient = (options) => {
         setBannerError(warningError);
       }
     }));
-  }, [runtimeOptions, setBannerError, showDevConsole, onTrace]);
+  }, [runtimeOptions, setBannerError, showDevConsole, onError]);
   return runtimeClient;
 };
 function createStructuredError(gqlError) {
@@ -511,9 +512,9 @@ function useChat(options) {
   const runChatCompletionRef = (0, import_react5.useRef)();
   const addErrorToast = useErrorToast();
   const { setBannerError } = useToast();
-  const { onTrace } = useCopilotContext();
+  const { onError } = useCopilotContext();
   const traceUIError = (error, originalError) => __async(this, null, function* () {
-    if (!onTrace || !(copilotConfig == null ? void 0 : copilotConfig.publicApiKey))
+    if (!onError || !(copilotConfig == null ? void 0 : copilotConfig.publicApiKey))
       return;
     try {
       const traceEvent = {
@@ -534,9 +535,9 @@ function useChat(options) {
         },
         error
       };
-      yield onTrace(traceEvent);
+      yield onError(traceEvent);
     } catch (traceError) {
-      console.error("Error in use-chat onTrace handler:", traceError);
+      console.error("Error in use-chat onError handler:", traceError);
     }
   });
   const agentSessionRef = (0, import_react5.useRef)(agentSession);
@@ -758,17 +759,22 @@ function useChat(options) {
                   lastAgentStateMessage.state.messages
                 );
               }
-              setCoagentStatesWithRef((prevAgentStates) => __spreadProps(__spreadValues({}, prevAgentStates), {
-                [lastAgentStateMessage.agentName]: {
-                  name: lastAgentStateMessage.agentName,
-                  state: lastAgentStateMessage.state,
-                  running: lastAgentStateMessage.running,
-                  active: lastAgentStateMessage.active,
-                  threadId: lastAgentStateMessage.threadId,
-                  nodeName: lastAgentStateMessage.nodeName,
-                  runId: lastAgentStateMessage.runId
-                }
-              }));
+              setCoagentStatesWithRef((prevAgentStates) => {
+                var _a2;
+                return __spreadProps(__spreadValues({}, prevAgentStates), {
+                  [lastAgentStateMessage.agentName]: {
+                    name: lastAgentStateMessage.agentName,
+                    state: lastAgentStateMessage.state,
+                    running: lastAgentStateMessage.running,
+                    active: lastAgentStateMessage.active,
+                    threadId: lastAgentStateMessage.threadId,
+                    nodeName: lastAgentStateMessage.nodeName,
+                    runId: lastAgentStateMessage.runId,
+                    // Preserve existing config from previous state
+                    config: (_a2 = prevAgentStates[lastAgentStateMessage.agentName]) == null ? void 0 : _a2.config
+                  }
+                });
+              });
               if (lastAgentStateMessage.running) {
                 setAgentSession({
                   threadId: lastAgentStateMessage.threadId,
@@ -798,6 +804,39 @@ function useChat(options) {
           newMessages
         );
         let didExecuteAction = false;
+        const executeActionFromMessage = (currentAction, actionMessage) => __async(this, null, function* () {
+          var _a2;
+          const isInterruptAction = interruptMessages.find((m) => m.id === actionMessage.id);
+          followUp = (_a2 = currentAction == null ? void 0 : currentAction.followUp) != null ? _a2 : !isInterruptAction;
+          if (currentAction == null ? void 0 : currentAction._setActivatingMessageId) {
+            currentAction._setActivatingMessageId(actionMessage.id);
+          }
+          const resultMessage = yield executeAction({
+            onFunctionCall,
+            message: actionMessage,
+            chatAbortControllerRef,
+            onError: (error) => {
+              addErrorToast([error]);
+              console.error(`Failed to execute action ${actionMessage.name}: ${error}`);
+            },
+            setMessages,
+            getFinalMessages: () => finalMessages,
+            isRenderAndWait: (currentAction == null ? void 0 : currentAction._isRenderAndWait) || false
+          });
+          didExecuteAction = true;
+          const messageIndex = finalMessages.findIndex((msg) => msg.id === actionMessage.id);
+          finalMessages.splice(messageIndex + 1, 0, resultMessage);
+          if (currentAction == null ? void 0 : currentAction._isRenderAndWait) {
+            const messagesForImmediateUpdate = [...finalMessages];
+            (0, import_react_dom.flushSync)(() => {
+              setMessages(messagesForImmediateUpdate);
+            });
+          }
+          if (currentAction == null ? void 0 : currentAction._setActivatingMessageId) {
+            currentAction._setActivatingMessageId(null);
+          }
+          return resultMessage;
+        });
         if (onFunctionCall) {
           const lastMessages = [];
           for (let i = finalMessages.length - 1; i >= 0; i--) {
@@ -814,37 +853,28 @@ function useChat(options) {
               (action2) => action2.name === message.name
             );
             const currentResultMessagePairedFeAction = message.isResultMessage() ? getPairedFeAction(actions, message) : null;
-            const executeActionFromMessage = (action2, message2) => __async(this, null, function* () {
-              var _a2;
-              const isInterruptAction = interruptMessages.find((m) => m.id === message2.id);
-              followUp = (_a2 = action2 == null ? void 0 : action2.followUp) != null ? _a2 : !isInterruptAction;
-              const resultMessage = yield executeAction({
-                onFunctionCall,
-                previousMessages,
-                message: message2,
-                chatAbortControllerRef,
-                onError: (error) => {
-                  addErrorToast([error]);
-                  console.error(`Failed to execute action ${message2.name}: ${error}`);
-                }
-              });
-              didExecuteAction = true;
-              const messageIndex = finalMessages.findIndex((msg) => msg.id === message2.id);
-              finalMessages.splice(messageIndex + 1, 0, resultMessage);
-              return resultMessage;
-            });
             if (action && message.isActionExecutionMessage()) {
-              const resultMessage = yield executeActionFromMessage(action, message);
-              const pairedFeAction = getPairedFeAction(actions, resultMessage);
-              if (pairedFeAction) {
-                const newExecutionMessage = new import_runtime_client_gql3.ActionExecutionMessage({
-                  name: pairedFeAction.name,
-                  arguments: (0, import_shared4.parseJson)(resultMessage.result, resultMessage.result),
-                  status: message.status,
-                  createdAt: message.createdAt,
-                  parentMessageId: message.parentMessageId
-                });
-                yield executeActionFromMessage(pairedFeAction, newExecutionMessage);
+              const isRenderAndWaitAction = (action == null ? void 0 : action._isRenderAndWait) || false;
+              const alreadyProcessed = isRenderAndWaitAction && finalMessages.some(
+                (fm) => fm.isResultMessage() && fm.actionExecutionId === message.id
+              );
+              if (alreadyProcessed) {
+              } else {
+                const resultMessage = yield executeActionFromMessage(
+                  action,
+                  message
+                );
+                const pairedFeAction = getPairedFeAction(actions, resultMessage);
+                if (pairedFeAction) {
+                  const newExecutionMessage = new import_runtime_client_gql3.ActionExecutionMessage({
+                    name: pairedFeAction.name,
+                    arguments: (0, import_shared4.parseJson)(resultMessage.result, resultMessage.result),
+                    status: message.status,
+                    createdAt: message.createdAt,
+                    parentMessageId: message.parentMessageId
+                  });
+                  yield executeActionFromMessage(pairedFeAction, newExecutionMessage);
+                }
               }
             } else if (message.isResultMessage() && currentResultMessagePairedFeAction) {
               const newExecutionMessage = new import_runtime_client_gql3.ActionExecutionMessage({
@@ -862,13 +892,9 @@ function useChat(options) {
           }
           setMessages(finalMessages);
         }
-        if (
-          // if followUp is not explicitly false
-          followUp !== false && // and we executed an action
-          (didExecuteAction || // the last message is a server side result
-          !isAgentRun && finalMessages.length && finalMessages[finalMessages.length - 1].isResultMessage()) && // the user did not stop generation
-          !((_r = chatAbortControllerRef.current) == null ? void 0 : _r.signal.aborted)
-        ) {
+        if (followUp !== false && (didExecuteAction || // the last message is a server side result
+        !isAgentRun && finalMessages.length && finalMessages[finalMessages.length - 1].isResultMessage()) && // the user did not stop generation
+        !((_r = chatAbortControllerRef.current) == null ? void 0 : _r.signal.aborted)) {
           yield new Promise((resolve) => setTimeout(resolve, 10));
           return yield runChatCompletionRef.current(finalMessages);
         } else if ((_s = chatAbortControllerRef.current) == null ? void 0 : _s.signal.aborted) {
@@ -976,21 +1002,35 @@ function useChat(options) {
     [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]
   );
   const reload = useAsyncCallback(
-    (messageId) => __async(this, null, function* () {
+    (reloadMessageId) => __async(this, null, function* () {
       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);
-      if (newMessages.length > 0 && newMessages[newMessages.length - 1].isAgentStateMessage()) {
-        newMessages = newMessages.slice(0, newMessages.length - 1);
+      const reloadMessageRole = messages[reloadMessageIndex].role;
+      if (reloadMessageRole !== import_runtime_client_gql3.MessageRole.Assistant) {
+        console.warn(`Regenerate cannot be performed on ${reloadMessageRole} role`);
+        return;
       }
-      setMessages(newMessages);
-      return runChatCompletionAndHandleFunctionCall(newMessages);
+      let historyCutoff = [];
+      if (messages.length > 2) {
+        const lastUserMessageBeforeRegenerate = messages.slice(0, reloadMessageIndex).reverse().find(
+          (msg) => (
+            // @ts-expect-error -- message has role
+            msg.role === import_runtime_client_gql3.MessageRole.User
+          )
+        );
+        const indexOfLastUserMessageBeforeRegenerate = messages.findIndex(
+          (msg) => msg.id === lastUserMessageBeforeRegenerate.id
+        );
+        historyCutoff = messages.slice(0, indexOfLastUserMessageBeforeRegenerate + 1);
+      }
+      setMessages(historyCutoff);
+      return runChatCompletionAndHandleFunctionCall(historyCutoff);
     }),
     [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]
   );
@@ -1025,20 +1065,31 @@ function constructFinalMessages(syncedMessages, previousMessages, newMessages) {
 function executeAction(_0) {
   return __async(this, arguments, function* ({
     onFunctionCall,
-    previousMessages,
     message,
     chatAbortControllerRef,
-    onError
+    onError,
+    setMessages,
+    getFinalMessages,
+    isRenderAndWait
   }) {
     let result;
     let error = null;
+    const currentMessagesForHandler = getFinalMessages();
+    const handlerReturnedPromise = onFunctionCall({
+      messages: currentMessagesForHandler,
+      name: message.name,
+      args: message.arguments
+    });
+    if (isRenderAndWait) {
+      const currentMessagesForRender = getFinalMessages();
+      (0, import_react_dom.flushSync)(() => {
+        setMessages([...currentMessagesForRender]);
+      });
+    }
     try {
       result = yield Promise.race([
-        onFunctionCall({
-          messages: previousMessages,
-          name: message.name,
-          args: message.arguments
-        }),
+        handlerReturnedPromise,
+        // Await the promise returned by the handler
         new Promise(
           (resolve) => {
             var _a;
@@ -1086,7 +1137,7 @@ function getPairedFeAction(actions, message) {
 
 // src/components/copilot-provider/copilotkit.tsx
 var import_react7 = require("react");
-var import_react_dom = require("react-dom");
+var import_react_dom2 = require("react-dom");
 var import_shared5 = require("@copilotkit/shared");
 
 // src/context/copilot-messages-context.tsx
@@ -1331,6 +1382,7 @@ function useCopilotAction(action, dependencies) {
   const { setAction, removeAction, actions, chatComponentsCache } = useCopilotContext();
   const idRef = (0, import_react9.useRef)((0, import_shared6.randomId)());
   const renderAndWaitRef = (0, import_react9.useRef)(null);
+  const activatingMessageIdRef = (0, import_react9.useRef)(null);
   const { addToast } = useToast();
   action = __spreadValues({}, action);
   if (
@@ -1338,30 +1390,48 @@ function useCopilotAction(action, dependencies) {
     isFrontendAction(action) && // check if renderAndWaitForResponse is set
     (action.renderAndWait || action.renderAndWaitForResponse)
   ) {
+    action._isRenderAndWait = true;
     const renderAndWait = action.renderAndWait || action.renderAndWaitForResponse;
     action.renderAndWait = void 0;
     action.renderAndWaitForResponse = void 0;
+    action._setActivatingMessageId = (id) => {
+      activatingMessageIdRef.current = id;
+    };
     action.handler = useAsyncCallback(() => __async(this, null, function* () {
+      const currentActivatingId = activatingMessageIdRef.current;
       let resolve;
       let reject;
       const promise = new Promise((resolvePromise, rejectPromise) => {
         resolve = resolvePromise;
         reject = rejectPromise;
       });
-      renderAndWaitRef.current = { promise, resolve, reject };
-      return yield promise;
+      renderAndWaitRef.current = {
+        promise,
+        resolve,
+        reject,
+        messageId: currentActivatingId
+      };
+      const result = yield promise;
+      return result;
     }), []);
     action.render = (props) => {
+      const currentRenderMessageId = props.messageId;
       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";
+        }
       }
       const waitProps = {
         status,
         args: props.args,
         result: props.result,
-        handler: status === "executing" ? renderAndWaitRef.current.resolve : void 0,
-        respond: status === "executing" ? renderAndWaitRef.current.resolve : void 0
+        // 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 : void 0,
+        respond: status === "executing" && renderAndWaitRef.current && renderAndWaitRef.current.messageId === currentRenderMessageId ? renderAndWaitRef.current.resolve : void 0
       };
       const isNoArgsRenderWait = (_fn) => {
         var _a;
@@ -1630,6 +1700,32 @@ function useCoAgent(options) {
     // reset initialstate on reset
     coagentStates[name] === void 0
   ]);
+  (0, import_react13.useEffect)(() => {
+    const newConfig = options.config ? options.config : options.configurable ? { configurable: options.configurable } : void 0;
+    if (newConfig === void 0)
+      return;
+    setCoagentStatesWithRef((prev) => {
+      var _a;
+      const existing = (_a = prev[name]) != null ? _a : {
+        name,
+        state: isInternalStateManagementWithInitial(options) ? options.initialState : {},
+        config: {},
+        running: false,
+        active: false,
+        threadId: void 0,
+        nodeName: void 0,
+        runId: void 0
+      };
+      if (JSON.stringify(existing.config) === JSON.stringify(newConfig)) {
+        return prev;
+      }
+      return __spreadProps(__spreadValues({}, prev), {
+        [name]: __spreadProps(__spreadValues({}, existing), {
+          config: newConfig
+        })
+      });
+    });
+  }, [JSON.stringify(options.config), JSON.stringify(options.configurable)]);
   const runAgentCallback = useAsyncCallback(
     (hint) => __async(this, null, function* () {
       yield runAgent(name, context, appendMessage, runChatCompletion, hint);