@copilotkit/react-core 1.2.2-feat-runtime-remote-actions.1 → 1.3.0

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

@@ -1,14 +1,3 @@
-import { CopilotContextParams } from '../context/copilot-context.js';
-import '@copilotkit/shared';
-import '@copilotkit/runtime-client-gql';
-import '../types/frontend-action.js';
-import 'react';
-import './use-tree.js';
-import '../types/document-pointer.js';
-import '../types/chat-suggestion-configuration.js';
-import '../types/coagent-action.js';
-import '../types/coagent-state.js';
-
 interface WithInternalStateManagementAndInitial<T> {
     name: string;
     initialState: T;
@@ -30,8 +19,9 @@ interface UseCoagentReturnType<T> {
     running: boolean;
     state: T;
     setState: (newState: T | ((prevState: T | undefined) => T)) => void;
-    start: (context: CopilotContextParams) => void;
-    stop: (context: CopilotContextParams) => void;
+    start: () => void;
+    stop: () => void;
+    run: (hint?: string) => Promise<void>;
 }
 declare function useCoAgent<T = any>(options: UseCoagentOptions<T>): UseCoagentReturnType<T>;
 

package/dist/hooks/use-coagent.js

@@ -22,6 +22,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -70,7 +82,7 @@ __export(use_coagent_exports, {
   useCoAgent: () => useCoAgent
 });
 module.exports = __toCommonJS(use_coagent_exports);
-var import_react2 = require("react");
+var import_react5 = require("react");
 
 // src/context/copilot-context.tsx
 var import_react = __toESM(require("react"));
@@ -139,7 +151,386 @@ function returnAndThrowInDebug(value) {
   return value;
 }
 
+// src/hooks/use-copilot-chat.ts
+var import_react4 = require("react");
+var import_runtime_client_gql2 = require("@copilotkit/runtime-client-gql");
+
+// src/hooks/use-chat.ts
+var import_react2 = require("react");
+var import_shared = require("@copilotkit/shared");
+var import_runtime_client_gql = require("@copilotkit/runtime-client-gql");
+function useChat(options) {
+  const {
+    messages,
+    setMessages,
+    makeSystemMessageCallback,
+    copilotConfig,
+    setIsLoading,
+    initialMessages,
+    isLoading,
+    actions,
+    onFunctionCall,
+    onCoagentAction,
+    setCoagentStates,
+    coagentStates,
+    agentSession,
+    setAgentSession
+  } = options;
+  const abortControllerRef = (0, import_react2.useRef)();
+  const threadIdRef = (0, import_react2.useRef)(null);
+  const runIdRef = (0, import_react2.useRef)(null);
+  const publicApiKey = copilotConfig.publicApiKey;
+  const headers = __spreadValues(__spreadValues({}, copilotConfig.headers || {}), publicApiKey ? { [import_shared.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey } : {});
+  const runtimeClient = new import_runtime_client_gql.CopilotRuntimeClient({
+    url: copilotConfig.chatApiEndpoint,
+    publicApiKey: copilotConfig.publicApiKey,
+    headers,
+    credentials: copilotConfig.credentials
+  });
+  const runChatCompletion = (previousMessages) => __async(this, null, function* () {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    setIsLoading(true);
+    let newMessages = [
+      new import_runtime_client_gql.TextMessage({
+        content: "",
+        role: import_runtime_client_gql.Role.Assistant
+      })
+    ];
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+    setMessages([...previousMessages, ...newMessages]);
+    const systemMessage = makeSystemMessageCallback();
+    const messagesWithContext = [systemMessage, ...initialMessages || [], ...previousMessages];
+    const stream = import_runtime_client_gql.CopilotRuntimeClient.asStream(
+      runtimeClient.generateCopilotResponse({
+        data: __spreadProps(__spreadValues(__spreadProps(__spreadValues({
+          frontend: {
+            actions: actions.map((action) => ({
+              name: action.name,
+              description: action.description || "",
+              jsonSchema: JSON.stringify((0, import_shared.actionParametersToJsonSchema)(action.parameters || []))
+            })),
+            url: window.location.href
+          },
+          threadId: threadIdRef.current,
+          runId: runIdRef.current,
+          messages: (0, import_runtime_client_gql.convertMessagesToGqlInput)((0, import_runtime_client_gql.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: {
+              inputValidationRules: {
+                allowList: copilotConfig.cloud.guardrails.input.restrictToTopic.validTopics,
+                denyList: copilotConfig.cloud.guardrails.input.restrictToTopic.invalidTopics
+              }
+            }
+          } : {})
+        } : {}), {
+          metadata: {
+            requestType: import_runtime_client_gql.CopilotRequestType.Chat
+          }
+        }), agentSession ? {
+          agentSession
+        } : {}), {
+          agentStates: Object.values(coagentStates).map((state) => ({
+            agentName: state.name,
+            state: JSON.stringify(state.state)
+          }))
+        }),
+        properties: copilotConfig.properties,
+        signal: (_d = abortControllerRef.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 executedCoagentActions = [];
+    try {
+      while (true) {
+        const { done, value } = yield reader.read();
+        if (done) {
+          break;
+        }
+        if (!(value == null ? void 0 : value.generateCopilotResponse)) {
+          continue;
+        }
+        threadIdRef.current = value.generateCopilotResponse.threadId || null;
+        runIdRef.current = value.generateCopilotResponse.runId || null;
+        const messages2 = (0, import_runtime_client_gql.convertGqlOutputToMessages)(
+          (0, import_runtime_client_gql.filterAdjacentAgentStateMessages)(value.generateCopilotResponse.messages)
+        );
+        if (messages2.length === 0) {
+          continue;
+        }
+        newMessages = [];
+        if (((_h = value.generateCopilotResponse.status) == null ? void 0 : _h.__typename) === "FailedResponseStatus" && value.generateCopilotResponse.status.reason === "GUARDRAILS_VALIDATION_FAILED") {
+          newMessages = [
+            new import_runtime_client_gql.TextMessage({
+              role: import_runtime_client_gql.MessageRole.Assistant,
+              content: ((_i = value.generateCopilotResponse.status.details) == null ? void 0 : _i.guardrailsReason) || ""
+            })
+          ];
+        } else {
+          for (const message of messages2) {
+            newMessages.push(message);
+            if (message instanceof import_runtime_client_gql.ActionExecutionMessage && message.status.code !== import_runtime_client_gql.MessageStatusCode.Pending && message.scope === "client" && onFunctionCall) {
+              if (!(message.id in actionResults)) {
+                if (guardrailsEnabled && value.generateCopilotResponse.status === void 0) {
+                  break;
+                }
+                const result = yield onFunctionCall({
+                  messages: previousMessages,
+                  name: message.name,
+                  args: message.arguments
+                });
+                actionResults[message.id] = result;
+              }
+              newMessages.push(
+                new import_runtime_client_gql.ResultMessage({
+                  result: import_runtime_client_gql.ResultMessage.encodeResult(actionResults[message.id]),
+                  actionExecutionId: message.id,
+                  actionName: message.name
+                })
+              );
+            }
+            if (message instanceof import_runtime_client_gql.AgentStateMessage && !message.active && !executedCoagentActions.includes(message.id) && onCoagentAction) {
+              if (guardrailsEnabled && value.generateCopilotResponse.status === void 0) {
+                break;
+              }
+              yield onCoagentAction({
+                name: message.agentName,
+                nodeName: message.nodeName,
+                state: message.state
+              });
+              executedCoagentActions.push(message.id);
+            }
+          }
+          const lastAgentStateMessage = [...messages2].reverse().find((message) => message instanceof import_runtime_client_gql.AgentStateMessage);
+          if (lastAgentStateMessage) {
+            if (lastAgentStateMessage.running) {
+              setCoagentStates((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
+                }
+              }));
+              setAgentSession({
+                threadId: lastAgentStateMessage.threadId,
+                agentName: lastAgentStateMessage.agentName,
+                nodeName: lastAgentStateMessage.nodeName
+              });
+            } else {
+              setAgentSession(null);
+            }
+          }
+        }
+        if (newMessages.length > 0) {
+          setMessages([...previousMessages, ...newMessages]);
+        }
+      }
+      if (
+        // 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] instanceof import_runtime_client_gql.ResultMessage
+      ) {
+        yield new Promise((resolve) => setTimeout(resolve, 10));
+        return yield runChatCompletion([...previousMessages, ...newMessages]);
+      } else {
+        return newMessages.slice();
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  });
+  const runChatCompletionAndHandleFunctionCall = (messages2) => __async(this, null, function* () {
+    yield runChatCompletion(messages2);
+  });
+  const append = (message) => __async(this, null, function* () {
+    if (isLoading) {
+      return;
+    }
+    const newMessages = [...messages, message];
+    setMessages(newMessages);
+    return runChatCompletionAndHandleFunctionCall(newMessages);
+  });
+  const reload = () => __async(this, null, function* () {
+    if (isLoading || messages.length === 0) {
+      return;
+    }
+    let newMessages = [...messages];
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage instanceof import_runtime_client_gql.TextMessage && lastMessage.role === "assistant") {
+      newMessages = newMessages.slice(0, -1);
+    }
+    setMessages(newMessages);
+    return runChatCompletionAndHandleFunctionCall(newMessages);
+  });
+  const stop = () => {
+    var _a;
+    (_a = abortControllerRef.current) == null ? void 0 : _a.abort();
+  };
+  return {
+    append,
+    reload,
+    stop
+  };
+}
+
+// src/components/copilot-provider/copilotkit.tsx
+var import_react3 = require("react");
+var import_react_dom = require("react-dom");
+var import_shared2 = require("@copilotkit/shared");
+var import_jsx_runtime = require("react/jsx-runtime");
+var defaultCopilotContextCategories = ["global"];
+
+// src/hooks/use-copilot-chat.ts
+function useCopilotChat(_a = {}) {
+  var _b = _a, {
+    makeSystemMessage
+  } = _b, options = __objRest(_b, [
+    "makeSystemMessage"
+  ]);
+  const {
+    getContextString,
+    getFunctionCallHandler,
+    copilotApiConfig,
+    messages,
+    setMessages,
+    isLoading,
+    setIsLoading,
+    chatInstructions,
+    actions,
+    coagentStates,
+    setCoagentStates,
+    coagentActions,
+    agentSession,
+    setAgentSession
+  } = useCopilotContext();
+  const latestGetContextString = useUpdatedRef(getContextString);
+  const deleteMessage = (0, import_react4.useCallback)(
+    (messageId) => {
+      setMessages((prev) => prev.filter((message) => message.id !== messageId));
+    },
+    [setMessages]
+  );
+  const makeSystemMessageCallback = (0, import_react4.useCallback)(() => {
+    const systemMessageMaker = makeSystemMessage || defaultSystemMessage;
+    const contextString = latestGetContextString.current([], defaultCopilotContextCategories);
+    return new import_runtime_client_gql2.TextMessage({
+      content: systemMessageMaker(contextString, chatInstructions),
+      role: import_runtime_client_gql2.Role.System
+    });
+  }, [getContextString, makeSystemMessage, chatInstructions]);
+  const onCoagentAction = (0, import_react4.useCallback)(
+    (args) => __async(this, null, function* () {
+      var _a2;
+      const { name, nodeName, state } = args;
+      let action = Object.values(coagentActions).find(
+        (action2) => action2.name === name && action2.nodeName === nodeName
+      );
+      if (!action) {
+        action = Object.values(coagentActions).find(
+          (action2) => action2.name === name && !action2.nodeName
+        );
+      }
+      if (action) {
+        yield (_a2 = action.handler) == null ? void 0 : _a2.call(action, { state, nodeName });
+      }
+    }),
+    [coagentActions]
+  );
+  const { append, reload, stop } = useChat(__spreadProps(__spreadValues({}, options), {
+    actions: Object.values(actions),
+    copilotConfig: copilotApiConfig,
+    initialMessages: options.initialMessages || [],
+    onFunctionCall: getFunctionCallHandler(),
+    onCoagentAction,
+    messages,
+    setMessages,
+    makeSystemMessageCallback,
+    isLoading,
+    setIsLoading,
+    coagentStates,
+    setCoagentStates,
+    agentSession,
+    setAgentSession
+  }));
+  const latestAppend = useUpdatedRef(append);
+  const latestAppendFunc = (0, import_react4.useCallback)(
+    (message) => {
+      return latestAppend.current(message);
+    },
+    [latestAppend]
+  );
+  const latestReload = useUpdatedRef(reload);
+  const latestReloadFunc = (0, import_react4.useCallback)(() => {
+    return latestReload.current();
+  }, [latestReload]);
+  const latestStop = useUpdatedRef(stop);
+  const latestStopFunc = (0, import_react4.useCallback)(() => {
+    return latestStop.current();
+  }, [latestStop]);
+  const latestDelete = useUpdatedRef(deleteMessage);
+  const latestDeleteFunc = (0, import_react4.useCallback)(
+    (messageId) => {
+      return latestDelete.current(messageId);
+    },
+    [latestDelete]
+  );
+  const latestSetMessages = useUpdatedRef(setMessages);
+  const latestSetMessagesFunc = (0, import_react4.useCallback)(
+    (messages2) => {
+      return latestSetMessages.current(messages2);
+    },
+    [latestSetMessages]
+  );
+  return {
+    visibleMessages: messages,
+    appendMessage: latestAppendFunc,
+    setMessages: latestSetMessagesFunc,
+    reloadMessages: latestReloadFunc,
+    stopGeneration: latestStopFunc,
+    deleteMessage: latestDeleteFunc,
+    isLoading
+  };
+}
+function useUpdatedRef(value) {
+  const ref = (0, import_react4.useRef)(value);
+  (0, import_react4.useEffect)(() => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+}
+function defaultSystemMessage(contextString, additionalInstructions) {
+  return `
+Please act as an efficient, competent, conscientious, and industrious professional assistant.
+
+Help the user achieve their goals, and you do so in a way that is as efficient as possible, without unnecessary fluff, but also without sacrificing professionalism.
+Always be polite and respectful, and prefer brevity over verbosity.
+
+The user has provided you with the following context:
+\`\`\`
+${contextString}
+\`\`\`
+
+They have also provided you with functions you can call to initiate actions on their behalf, or functions you can call to receive more information.
+
+Please assist them as best you can.
+
+You can ask them for clarifying questions if needed, but don't be annoying about it. If you can reasonably 'fill in the blanks' yourself, do so.
+
+If you would like to call a function, call it without saying anything else.
+` + (additionalInstructions ? `
+
+${additionalInstructions}` : "");
+}
+
 // src/hooks/use-coagent.ts
+var import_runtime_client_gql3 = require("@copilotkit/runtime-client-gql");
 function useCoAgent(options) {
   const isExternalStateManagement = (options2) => {
     return "state" in options2 && "setState" in options2;
@@ -148,7 +539,9 @@ function useCoAgent(options) {
   const isInternalStateManagementWithInitial = (options2) => {
     return "initialState" in options2;
   };
-  const { coagentStates, setCoagentStates } = useCopilotContext();
+  const context = useCopilotContext();
+  const { coagentStates, setCoagentStates } = context;
+  const { appendMessage } = useCopilotChat();
   const getCoagentState = (coagentStates2, name2) => {
     if (coagentStates2[name2]) {
       return coagentStates2[name2];
@@ -177,7 +570,7 @@ function useCoAgent(options) {
   };
   const coagentState = getCoagentState(coagentStates, name);
   const state = isExternalStateManagement(options) ? options.state : coagentState.state;
-  (0, import_react2.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     if (isExternalStateManagement(options)) {
       setState(options.state);
     } else if (coagentStates[name] === void 0) {
@@ -190,11 +583,14 @@ function useCoAgent(options) {
     state,
     setState,
     running: coagentState.running,
-    start: (context) => {
+    start: () => {
       startAgent(name, context);
     },
-    stop: (context) => {
+    stop: () => {
       stopAgent(name, context);
+    },
+    run: (hint) => {
+      return runAgent(name, context, appendMessage, hint);
     }
   };
 }
@@ -212,6 +608,45 @@ function stopAgent(name, context) {
     console.warn(`No agent session found for ${name}`);
   }
 }
+function runAgent(name, context, appendMessage, hint) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const { agentSession, setAgentSession } = context;
+    if (!agentSession || agentSession.agentName !== name) {
+      setAgentSession({
+        agentName: name
+      });
+    }
+    let previousState = null;
+    for (let i = context.messages.length - 1; i >= 0; i--) {
+      const message = context.messages[i];
+      if (message instanceof import_runtime_client_gql3.AgentStateMessage && message.agentName === name) {
+        previousState = message.state;
+      }
+    }
+    let state = ((_b = (_a = context.coagentStates) == null ? void 0 : _a[name]) == null ? void 0 : _b.state) || {};
+    let content = "The state of the agent has been updated\n";
+    if (previousState !== null) {
+      content += `The previous state was:
+${JSON.stringify(previousState, null, 2)}
+
+`;
+    }
+    content += `The current state is:
+${JSON.stringify(state, null, 2)}`;
+    if (hint) {
+      content += `
+
+${hint}`;
+    }
+    return yield appendMessage(
+      new import_runtime_client_gql3.TextMessage({
+        role: import_runtime_client_gql3.Role.System,
+        content
+      })
+    );
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   useCoAgent