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

package/dist/hooks/index.mjs

@@ -1,20 +1,23 @@
 import "../chunk-L34MHAXR.mjs";
 import {
+  runAgent,
+  startAgent,
+  stopAgent,
   useCoAgent
-} from "../chunk-FSC4A3JN.mjs";
+} from "../chunk-42N5VKIX.mjs";
 import {
   useCopilotAction
-} from "../chunk-YUY5ZAST.mjs";
+} from "../chunk-ALR5W5JK.mjs";
 import {
   useCopilotChat
-} from "../chunk-6EMLM6WX.mjs";
+} from "../chunk-BT6WK2JZ.mjs";
 import {
   useCopilotReadable
-} from "../chunk-AG7FH7OD.mjs";
+} from "../chunk-5FYKUKG3.mjs";
 import {
   useMakeCopilotDocumentReadable
-} from "../chunk-UOVONDR6.mjs";
-import "../chunk-IVYL7JRC.mjs";
+} from "../chunk-V3PFWGIY.mjs";
+import "../chunk-VMP6JWBB.mjs";
 import "../chunk-QCUP6HLK.mjs";
 import "../chunk-MLAS4QUR.mjs";
 import "../chunk-XXR4QFAQ.mjs";
@@ -22,7 +25,8 @@ import "../chunk-5FHSUKQL.mjs";
 import "../chunk-6U3UH3KO.mjs";
 import "../chunk-YPSGKPDA.mjs";
 import "../chunk-DCTJZ742.mjs";
-import "../chunk-NTLCOVE5.mjs";
+import "../chunk-QTDCEDOC.mjs";
+import "../chunk-XERJQUHA.mjs";
 import {
   useCopilotRuntimeClient
 } from "../chunk-7LRDVJH5.mjs";
@@ -30,10 +34,13 @@ import "../chunk-SFPANIOY.mjs";
 import "../chunk-O7ARI5CV.mjs";
 import {
   useCoAgentStateRender
-} from "../chunk-X6ZF5WAX.mjs";
-import "../chunk-XQFVXX6R.mjs";
+} from "../chunk-35EN6BG4.mjs";
+import "../chunk-TQN3EZWQ.mjs";
 import "../chunk-SKC7AJIV.mjs";
 export {
+  runAgent,
+  startAgent,
+  stopAgent,
   useCoAgent,
   useCoAgentStateRender,
   useCopilotAction,

package/dist/hooks/use-chat.d.ts

@@ -68,6 +68,26 @@ type UseChatOptions = {
      * setState-powered method to update the agent session
      */
     setAgentSession: React.Dispatch<React.SetStateAction<AgentSession | null>>;
+    /**
+     * The current thread ID.
+     */
+    threadId: string | null;
+    /**
+     * set the current thread ID
+     */
+    setThreadId: (threadId: string | null) => void;
+    /**
+     * The current run ID.
+     */
+    runId: string | null;
+    /**
+     * set the current run ID
+     */
+    setRunId: (runId: string | null) => void;
+    /**
+     * The global chat abort controller.
+     */
+    chatAbortControllerRef: React.MutableRefObject<AbortController | null>;
 };
 type UseChatHelpers = {
     /**

package/dist/hooks/use-chat.js

@@ -61,8 +61,33 @@ __export(use_chat_exports, {
 });
 module.exports = __toCommonJS(use_chat_exports);
 var import_react4 = 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_react2 = require("react");
@@ -192,13 +217,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_react3 = require("react");
 var useCopilotRuntimeClient = (options) => {
   const { addGraphQLErrorsToast } = useToast();
   const addErrorToast = useErrorToast();
   const runtimeClient = (0, import_react3.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);
@@ -227,17 +252,23 @@ function useChat(options) {
     setCoagentStatesWithRef,
     coagentStatesRef,
     agentSession,
-    setAgentSession
+    setAgentSession,
+    threadId,
+    setThreadId,
+    runId,
+    setRunId,
+    chatAbortControllerRef
   } = options;
-  const abortControllerRef = (0, import_react4.useRef)();
-  const threadIdRef = (0, import_react4.useRef)(null);
-  const runIdRef = (0, import_react4.useRef)(null);
   const { addGraphQLErrorsToast } = useToast();
   const runChatCompletionRef = (0, import_react4.useRef)();
   const agentSessionRef = (0, import_react4.useRef)(agentSession);
   agentSessionRef.current = agentSession;
+  const threadIdRef = (0, import_react4.useRef)(threadId);
+  threadIdRef.current = threadId;
+  const runIdRef = (0, import_react4.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,
@@ -246,48 +277,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: {
@@ -299,7 +311,7 @@ function useChat(options) {
             } : {})
           } : {}), {
             metadata: {
-              requestType: import_runtime_client_gql2.CopilotRequestType.Chat
+              requestType: import_runtime_client_gql3.CopilotRequestType.Chat
             }
           }), agentSessionRef.current ? {
             agentSession: agentSessionRef.current
@@ -310,14 +322,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;
@@ -329,6 +342,9 @@ function useChat(options) {
             break;
           }
           if (done) {
+            if (chatAbortControllerRef.current.signal.aborted) {
+              return [];
+            }
             break;
           }
           if (!(value == null ? void 0 : value.generateCopilotResponse)) {
@@ -336,8 +352,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;
@@ -345,44 +363,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;
@@ -397,6 +387,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,
@@ -423,14 +418,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();
         }
@@ -487,7 +564,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,
@@ -496,6 +573,23 @@ 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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   useChat