@copilotkit/react-core 1.4.8 → 1.5.0-coagents-v0-3.0

package/dist/hooks/use-copilot-chat.js

@@ -139,7 +139,15 @@ var emptyCopilotContext = {
   },
   agentSession: null,
   setAgentSession: () => {
-  }
+  },
+  agentLock: null,
+  threadId: null,
+  setThreadId: () => {
+  },
+  runId: null,
+  setRunId: () => {
+  },
+  chatAbortControllerRef: { current: null }
 };
 var CopilotContext = import_react.default.createContext(emptyCopilotContext);
 function useCopilotContext() {
@@ -155,12 +163,37 @@ function returnAndThrowInDebug(value) {
 }
 
 // src/hooks/use-copilot-chat.ts
-var import_runtime_client_gql3 = require("@copilotkit/runtime-client-gql");
+var import_runtime_client_gql4 = require("@copilotkit/runtime-client-gql");
 
 // src/hooks/use-chat.ts
 var import_react5 = require("react");
+var import_shared2 = require("@copilotkit/shared");
+var import_runtime_client_gql3 = require("@copilotkit/runtime-client-gql");
+
+// src/types/frontend-action.ts
+var import_runtime_client_gql = require("@copilotkit/runtime-client-gql");
 var import_shared = require("@copilotkit/shared");
-var import_runtime_client_gql2 = require("@copilotkit/runtime-client-gql");
+function processActionsForRuntimeRequest(actions) {
+  const filteredActions = actions.filter(
+    (action) => action.available !== import_runtime_client_gql.ActionInputAvailability.Disabled && action.disabled !== true && action.name !== "*"
+  ).map((action) => {
+    let available = import_runtime_client_gql.ActionInputAvailability.Enabled;
+    if (action.disabled) {
+      available = import_runtime_client_gql.ActionInputAvailability.Disabled;
+    } else if (action.available === "disabled") {
+      available = import_runtime_client_gql.ActionInputAvailability.Disabled;
+    } else if (action.available === "remote") {
+      available = import_runtime_client_gql.ActionInputAvailability.Remote;
+    }
+    return {
+      name: action.name,
+      description: action.description || "",
+      jsonSchema: JSON.stringify((0, import_shared.actionParametersToJsonSchema)(action.parameters || [])),
+      available
+    };
+  });
+  return filteredActions;
+}
 
 // src/components/toast/toast-provider.tsx
 var import_react3 = require("react");
@@ -290,13 +323,13 @@ function useToast() {
 }
 
 // src/hooks/use-copilot-runtime-client.ts
-var import_runtime_client_gql = require("@copilotkit/runtime-client-gql");
+var import_runtime_client_gql2 = require("@copilotkit/runtime-client-gql");
 var import_react4 = require("react");
 var useCopilotRuntimeClient = (options) => {
   const { addGraphQLErrorsToast } = useToast();
   const addErrorToast = useErrorToast();
   const runtimeClient = (0, import_react4.useMemo)(() => {
-    return new import_runtime_client_gql.CopilotRuntimeClient(__spreadProps(__spreadValues({}, options), {
+    return new import_runtime_client_gql2.CopilotRuntimeClient(__spreadProps(__spreadValues({}, options), {
       handleGQLErrors: (error) => {
         if (error.graphQLErrors.length) {
           addGraphQLErrorsToast(error.graphQLErrors);
@@ -325,17 +358,23 @@ function useChat(options) {
     setCoagentStatesWithRef,
     coagentStatesRef,
     agentSession,
-    setAgentSession
+    setAgentSession,
+    threadId,
+    setThreadId,
+    runId,
+    setRunId,
+    chatAbortControllerRef
   } = options;
-  const abortControllerRef = (0, import_react5.useRef)();
-  const threadIdRef = (0, import_react5.useRef)(null);
-  const runIdRef = (0, import_react5.useRef)(null);
   const { addGraphQLErrorsToast } = useToast();
   const runChatCompletionRef = (0, import_react5.useRef)();
   const agentSessionRef = (0, import_react5.useRef)(agentSession);
   agentSessionRef.current = agentSession;
+  const threadIdRef = (0, import_react5.useRef)(threadId);
+  threadIdRef.current = threadId;
+  const runIdRef = (0, import_react5.useRef)(runId);
+  runIdRef.current = runId;
   const publicApiKey = copilotConfig.publicApiKey;
-  const headers = __spreadValues(__spreadValues({}, copilotConfig.headers || {}), publicApiKey ? { [import_shared.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey } : {});
+  const headers = __spreadValues(__spreadValues({}, copilotConfig.headers || {}), publicApiKey ? { [import_shared2.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey } : {});
   const runtimeClient = useCopilotRuntimeClient({
     url: copilotConfig.chatApiEndpoint,
     publicApiKey: copilotConfig.publicApiKey,
@@ -344,48 +383,29 @@ function useChat(options) {
   });
   const runChatCompletion = useAsyncCallback(
     (previousMessages) => __async(this, null, function* () {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
       setIsLoading(true);
       let newMessages = [
-        new import_runtime_client_gql2.TextMessage({
+        new import_runtime_client_gql3.TextMessage({
           content: "",
-          role: import_runtime_client_gql2.Role.Assistant
+          role: import_runtime_client_gql3.Role.Assistant
         })
       ];
-      const abortController = new AbortController();
-      abortControllerRef.current = abortController;
+      chatAbortControllerRef.current = new AbortController();
       setMessages([...previousMessages, ...newMessages]);
       const systemMessage = makeSystemMessageCallback();
       const messagesWithContext = [systemMessage, ...initialMessages || [], ...previousMessages];
+      const isAgentRun = agentSessionRef.current !== null;
       const stream = runtimeClient.asStream(
         runtimeClient.generateCopilotResponse({
           data: __spreadProps(__spreadValues(__spreadProps(__spreadValues({
             frontend: {
-              actions: actions.filter(
-                (action) => action.available !== import_runtime_client_gql2.ActionInputAvailability.Disabled || !action.disabled
-              ).map((action) => {
-                let available = import_runtime_client_gql2.ActionInputAvailability.Enabled;
-                if (action.disabled) {
-                  available = import_runtime_client_gql2.ActionInputAvailability.Disabled;
-                } else if (action.available === "disabled") {
-                  available = import_runtime_client_gql2.ActionInputAvailability.Disabled;
-                } else if (action.available === "remote") {
-                  available = import_runtime_client_gql2.ActionInputAvailability.Remote;
-                }
-                return {
-                  name: action.name,
-                  description: action.description || "",
-                  jsonSchema: JSON.stringify(
-                    (0, import_shared.actionParametersToJsonSchema)(action.parameters || [])
-                  ),
-                  available
-                };
-              }),
+              actions: processActionsForRuntimeRequest(actions),
               url: window.location.href
             },
             threadId: threadIdRef.current,
             runId: runIdRef.current,
-            messages: (0, import_runtime_client_gql2.convertMessagesToGqlInput)((0, import_runtime_client_gql2.filterAgentStateMessages)(messagesWithContext))
+            messages: (0, import_runtime_client_gql3.convertMessagesToGqlInput)((0, import_runtime_client_gql3.filterAgentStateMessages)(messagesWithContext))
           }, copilotConfig.cloud ? {
             cloud: __spreadValues({}, ((_c = (_b = (_a = copilotConfig.cloud.guardrails) == null ? void 0 : _a.input) == null ? void 0 : _b.restrictToTopic) == null ? void 0 : _c.enabled) ? {
               guardrails: {
@@ -397,7 +417,7 @@ function useChat(options) {
             } : {})
           } : {}), {
             metadata: {
-              requestType: import_runtime_client_gql2.CopilotRequestType.Chat
+              requestType: import_runtime_client_gql3.CopilotRequestType.Chat
             }
           }), agentSessionRef.current ? {
             agentSession: agentSessionRef.current
@@ -408,14 +428,15 @@ function useChat(options) {
             }))
           }),
           properties: copilotConfig.properties,
-          signal: (_d = abortControllerRef.current) == null ? void 0 : _d.signal
+          signal: (_d = chatAbortControllerRef.current) == null ? void 0 : _d.signal
         })
       );
       const guardrailsEnabled = ((_g = (_f = (_e = copilotConfig.cloud) == null ? void 0 : _e.guardrails) == null ? void 0 : _f.input) == null ? void 0 : _g.restrictToTopic.enabled) || false;
       const reader = stream.getReader();
-      let actionResults = {};
       let executedCoAgentStateRenders = [];
       let followUp = void 0;
+      let messages2 = [];
+      let syncedMessages = [];
       try {
         while (true) {
           let done, value;
@@ -427,6 +448,9 @@ function useChat(options) {
             break;
           }
           if (done) {
+            if (chatAbortControllerRef.current.signal.aborted) {
+              return [];
+            }
             break;
           }
           if (!(value == null ? void 0 : value.generateCopilotResponse)) {
@@ -434,8 +458,10 @@ function useChat(options) {
           }
           threadIdRef.current = value.generateCopilotResponse.threadId || null;
           runIdRef.current = value.generateCopilotResponse.runId || null;
-          const messages2 = (0, import_runtime_client_gql2.convertGqlOutputToMessages)(
-            (0, import_runtime_client_gql2.filterAdjacentAgentStateMessages)(value.generateCopilotResponse.messages)
+          setThreadId(threadIdRef.current);
+          setRunId(runIdRef.current);
+          messages2 = (0, import_runtime_client_gql3.convertGqlOutputToMessages)(
+            (0, import_runtime_client_gql3.filterAdjacentAgentStateMessages)(value.generateCopilotResponse.messages)
           );
           if (messages2.length === 0) {
             continue;
@@ -443,44 +469,16 @@ function useChat(options) {
           newMessages = [];
           if (((_h = value.generateCopilotResponse.status) == null ? void 0 : _h.__typename) === "FailedResponseStatus" && value.generateCopilotResponse.status.reason === "GUARDRAILS_VALIDATION_FAILED") {
             newMessages = [
-              new import_runtime_client_gql2.TextMessage({
-                role: import_runtime_client_gql2.MessageRole.Assistant,
+              new import_runtime_client_gql3.TextMessage({
+                role: import_runtime_client_gql3.MessageRole.Assistant,
                 content: ((_i = value.generateCopilotResponse.status.details) == null ? void 0 : _i.guardrailsReason) || ""
               })
             ];
+            setMessages([...previousMessages, ...newMessages]);
+            break;
           } else {
+            newMessages = [...messages2];
             for (const message of messages2) {
-              newMessages.push(message);
-              if (message.isActionExecutionMessage() && message.status.code !== import_runtime_client_gql2.MessageStatusCode.Pending && message.scope === "client" && onFunctionCall) {
-                if (!(message.id in actionResults)) {
-                  if (guardrailsEnabled && value.generateCopilotResponse.status === void 0) {
-                    break;
-                  }
-                  try {
-                    setMessages([...previousMessages, ...newMessages]);
-                    const action = actions.find((action2) => action2.name === message.name);
-                    if (action) {
-                      followUp = action.followUp;
-                    }
-                    const result = yield onFunctionCall({
-                      messages: previousMessages,
-                      name: message.name,
-                      args: message.arguments
-                    });
-                    actionResults[message.id] = result;
-                  } catch (e) {
-                    actionResults[message.id] = `Failed to execute action ${message.name}`;
-                    console.error(`Failed to execute action ${message.name}: ${e}`);
-                  }
-                }
-                newMessages.push(
-                  new import_runtime_client_gql2.ResultMessage({
-                    result: import_runtime_client_gql2.ResultMessage.encodeResult(actionResults[message.id]),
-                    actionExecutionId: message.id,
-                    actionName: message.name
-                  })
-                );
-              }
               if (message.isAgentStateMessage() && !message.active && !executedCoAgentStateRenders.includes(message.id) && onCoAgentStateRender) {
                 if (guardrailsEnabled && value.generateCopilotResponse.status === void 0) {
                   break;
@@ -495,6 +493,11 @@ function useChat(options) {
             }
             const lastAgentStateMessage = [...messages2].reverse().find((message) => message.isAgentStateMessage());
             if (lastAgentStateMessage) {
+              if (lastAgentStateMessage.state.messages && lastAgentStateMessage.state.messages.length > 0) {
+                syncedMessages = (0, import_runtime_client_gql3.loadMessagesFromJsonRepresentation)(
+                  lastAgentStateMessage.state.messages
+                );
+              }
               setCoagentStatesWithRef((prevAgentStates) => __spreadProps(__spreadValues({}, prevAgentStates), {
                 [lastAgentStateMessage.agentName]: {
                   name: lastAgentStateMessage.agentName,
@@ -521,14 +524,96 @@ function useChat(options) {
             setMessages([...previousMessages, ...newMessages]);
           }
         }
+        const finalMessages = constructFinalMessages(syncedMessages, previousMessages, newMessages);
+        let didExecuteAction = false;
+        if (onFunctionCall) {
+          const lastMessages = [];
+          for (let i = finalMessages.length - 1; i >= 0; i--) {
+            const message = finalMessages[i];
+            if (message.isActionExecutionMessage() && message.status.code !== import_runtime_client_gql3.MessageStatusCode.Pending) {
+              lastMessages.unshift(message);
+            } else {
+              break;
+            }
+          }
+          for (const message of lastMessages) {
+            setMessages(finalMessages);
+            const action = actions.find((action2) => action2.name === message.name);
+            if (action) {
+              followUp = action.followUp;
+              let result;
+              try {
+                result = yield Promise.race([
+                  onFunctionCall({
+                    messages: previousMessages,
+                    name: message.name,
+                    args: message.arguments
+                  }),
+                  new Promise(
+                    (resolve) => {
+                      var _a2;
+                      return (_a2 = chatAbortControllerRef.current) == null ? void 0 : _a2.signal.addEventListener(
+                        "abort",
+                        () => resolve("Operation was aborted by the user")
+                      );
+                    }
+                  ),
+                  // if the user stopped generation, we also abort consecutive actions
+                  new Promise((resolve) => {
+                    var _a2;
+                    if ((_a2 = chatAbortControllerRef.current) == null ? void 0 : _a2.signal.aborted) {
+                      resolve("Operation was aborted by the user");
+                    }
+                  })
+                ]);
+              } catch (e) {
+                result = `Failed to execute action ${message.name}`;
+                console.error(`Failed to execute action ${message.name}: ${e}`);
+              }
+              didExecuteAction = true;
+              const messageIndex = finalMessages.findIndex((msg) => msg.id === message.id);
+              finalMessages.splice(
+                messageIndex + 1,
+                0,
+                new import_runtime_client_gql3.ResultMessage({
+                  id: "result-" + message.id,
+                  result: import_runtime_client_gql3.ResultMessage.encodeResult(result),
+                  actionExecutionId: message.id,
+                  actionName: message.name
+                })
+              );
+            }
+          }
+          setMessages(finalMessages);
+        }
         if (
           // if followUp is not explicitly false
-          followUp !== false && // if we have client side results
-          (Object.values(actionResults).length || // or the last message we received is a result
-          newMessages.length && newMessages[newMessages.length - 1].isResultMessage())
+          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
+          !((_j = chatAbortControllerRef.current) == null ? void 0 : _j.signal.aborted)
         ) {
           yield new Promise((resolve) => setTimeout(resolve, 10));
-          return yield runChatCompletionRef.current([...previousMessages, ...newMessages]);
+          return yield runChatCompletionRef.current(finalMessages);
+        } else if ((_k = chatAbortControllerRef.current) == null ? void 0 : _k.signal.aborted) {
+          const repairedMessages = finalMessages.filter((message, actionExecutionIndex) => {
+            if (message.isActionExecutionMessage()) {
+              return finalMessages.find(
+                (msg, resultIndex) => msg.isResultMessage() && msg.actionExecutionId === message.id && resultIndex === actionExecutionIndex + 1
+              );
+            }
+            return true;
+          });
+          const repairedMessageIds = repairedMessages.map((message) => message.id);
+          setMessages(repairedMessages);
+          if ((_l = agentSessionRef.current) == null ? void 0 : _l.nodeName) {
+            setAgentSession({
+              threadId: agentSessionRef.current.threadId,
+              agentName: agentSessionRef.current.agentName,
+              nodeName: "__end__"
+            });
+          }
+          return newMessages.filter((message) => repairedMessageIds.includes(message.id));
         } else {
           return newMessages.slice();
         }
@@ -585,7 +670,7 @@ function useChat(options) {
   }), [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]);
   const stop = () => {
     var _a;
-    (_a = abortControllerRef.current) == null ? void 0 : _a.abort();
+    (_a = chatAbortControllerRef.current) == null ? void 0 : _a.abort("Stop was called");
   };
   return {
     append,
@@ -594,11 +679,28 @@ function useChat(options) {
     runChatCompletion: () => runChatCompletionRef.current(messages)
   };
 }
+function constructFinalMessages(syncedMessages, previousMessages, newMessages) {
+  const finalMessages = syncedMessages.length > 0 ? [...syncedMessages] : [...previousMessages, ...newMessages];
+  if (syncedMessages.length > 0) {
+    const messagesWithAgentState = [...previousMessages, ...newMessages];
+    let previousMessageId = void 0;
+    for (const message of messagesWithAgentState) {
+      if (message.isAgentStateMessage()) {
+        const index = finalMessages.findIndex((msg) => msg.id === previousMessageId);
+        if (index !== -1) {
+          finalMessages.splice(index + 1, 0, message);
+        }
+      }
+      previousMessageId = message.id;
+    }
+  }
+  return finalMessages;
+}
 
 // src/components/copilot-provider/copilotkit.tsx
 var import_react7 = require("react");
 var import_react_dom = require("react-dom");
-var import_shared2 = require("@copilotkit/shared");
+var import_shared3 = require("@copilotkit/shared");
 
 // src/context/copilot-messages-context.tsx
 var import_react6 = __toESM(require("react"));
@@ -640,7 +742,13 @@ function useCopilotChat(_a = {}) {
     setCoagentStatesWithRef,
     coAgentStateRenders,
     agentSession,
-    setAgentSession
+    setAgentSession,
+    agentLock,
+    threadId,
+    setThreadId,
+    runId,
+    setRunId,
+    chatAbortControllerRef
   } = useCopilotContext();
   const { messages, setMessages } = useCopilotMessagesContext();
   const latestGetContextString = useUpdatedRef(getContextString);
@@ -653,9 +761,9 @@ function useCopilotChat(_a = {}) {
   const makeSystemMessageCallback = (0, import_react8.useCallback)(() => {
     const systemMessageMaker = makeSystemMessage || defaultSystemMessage;
     const contextString = latestGetContextString.current([], defaultCopilotContextCategories);
-    return new import_runtime_client_gql3.TextMessage({
+    return new import_runtime_client_gql4.TextMessage({
       content: systemMessageMaker(contextString, chatInstructions),
-      role: import_runtime_client_gql3.Role.System
+      role: import_runtime_client_gql4.Role.System
     });
   }, [getContextString, makeSystemMessage, chatInstructions]);
   const onCoAgentStateRender = useAsyncCallback(
@@ -690,7 +798,12 @@ function useCopilotChat(_a = {}) {
     coagentStatesRef,
     setCoagentStatesWithRef,
     agentSession,
-    setAgentSession
+    setAgentSession,
+    threadId,
+    setThreadId,
+    runId,
+    setRunId,
+    chatAbortControllerRef
   }));
   const latestAppend = useUpdatedRef(append);
   const latestAppendFunc = useAsyncCallback(
@@ -725,12 +838,38 @@ function useCopilotChat(_a = {}) {
   const latestRunChatCompletionFunc = useAsyncCallback(() => __async(this, null, function* () {
     return yield latestRunChatCompletion.current();
   }), [latestRunChatCompletion]);
+  const reset = (0, import_react8.useCallback)(() => {
+    latestStopFunc();
+    setMessages([]);
+    setThreadId(null);
+    setRunId(null);
+    setCoagentStatesWithRef({});
+    let initialAgentSession = null;
+    if (agentLock) {
+      initialAgentSession = {
+        agentName: agentLock
+      };
+    }
+    setAgentSession(initialAgentSession);
+  }, [
+    latestStopFunc,
+    setMessages,
+    setThreadId,
+    setCoagentStatesWithRef,
+    setAgentSession,
+    agentLock
+  ]);
+  const latestReset = useUpdatedRef(reset);
+  const latestResetFunc = (0, import_react8.useCallback)(() => {
+    return latestReset.current();
+  }, [latestReset]);
   return {
     visibleMessages: messages,
     appendMessage: latestAppendFunc,
     setMessages: latestSetMessagesFunc,
     reloadMessages: latestReloadFunc,
     stopGeneration: latestStopFunc,
+    reset: latestResetFunc,
     deleteMessage: latestDeleteFunc,
     runChatCompletion: latestRunChatCompletionFunc,
     isLoading