@copilotkit/react-core 0.37.0 → 0.38.0-beta.0

package/dist/hooks/index.js

@@ -94,17 +94,16 @@ var import_react4 = require("react");
 // src/context/copilot-context.tsx
 var import_react = __toESM(require("react"));
 var emptyCopilotContext = {
-  entryPoints: {},
-  setEntryPoint: () => {
+  actions: {},
+  setAction: () => {
   },
-  removeEntryPoint: () => {
+  removeAction: () => {
   },
   chatComponentsCache: { current: {} },
   getContextString: (documents, categories) => returnAndThrowInDebug(""),
   addContext: () => "",
   removeContext: () => {
   },
-  getChatCompletionFunctionDescriptions: () => returnAndThrowInDebug([]),
   getFunctionCallHandler: () => returnAndThrowInDebug(() => __async(void 0, null, function* () {
   })),
   messages: [],
@@ -143,228 +142,150 @@ function returnAndThrowInDebug(value) {
   return value;
 }
 
+// src/hooks/use-copilot-chat.ts
+var import_runtime_client_gql2 = require("@copilotkit/runtime-client-gql");
+
 // src/hooks/use-chat.ts
 var import_react2 = require("react");
-var import_shared2 = require("@copilotkit/shared");
-var import_nanoid = require("nanoid");
-
-// src/utils/fetch-chat-completion.ts
 var import_shared = require("@copilotkit/shared");
-function fetchChatCompletion(_0) {
-  return __async(this, arguments, function* ({
-    copilotConfig,
-    model,
-    messages,
-    tools,
-    temperature,
-    headers,
-    body,
-    signal,
-    toolChoice
-  }) {
-    temperature || (temperature = 0.5);
-    tools || (tools = []);
-    const cleanedMessages = messages.map((message) => {
-      const { content, role, name, function_call } = message;
-      return { content, role, name, function_call };
-    });
-    toolChoice || (toolChoice = "auto");
-    const response = yield fetch(copilotConfig.chatApiEndpoint, {
-      method: "POST",
-      headers: __spreadValues(__spreadValues({
-        "Content-Type": "application/json"
-      }, copilotConfig.headers), headers ? __spreadValues({}, headers) : {}),
-      body: JSON.stringify(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
-        model,
-        messages: cleanedMessages,
-        stream: true
-      }, tools.length ? { tools } : {}), temperature ? { temperature } : {}), tools.length != 0 ? { tool_choice: toolChoice } : {}), copilotConfig.body), copilotConfig.backendOnlyProps), excludeBackendOnlyProps(copilotConfig)), body ? __spreadValues({}, body) : {}), copilotConfig.cloud ? { cloud: copilotConfig.cloud } : {})),
-      signal,
-      credentials: copilotConfig.credentials
-    });
-    return response;
-  });
-}
-function excludeBackendOnlyProps(copilotConfig) {
-  var _a;
-  const backendOnlyProps = (_a = copilotConfig.backendOnlyProps) != null ? _a : {};
-  if (Object.keys(backendOnlyProps).length > 0) {
-    return {
-      [import_shared.EXCLUDE_FROM_FORWARD_PROPS_KEYS]: Object.keys(backendOnlyProps)
-    };
-  } else {
-    return {};
-  }
-}
-function fetchAndDecodeChatCompletion(params) {
-  return __async(this, null, function* () {
-    const response = yield fetchChatCompletion(params);
-    if (!response.ok || !response.body) {
-      response.events = null;
-    } else {
-      const events = yield (0, import_shared.decodeChatCompletion)((0, import_shared.parseChatCompletion)(response.body));
-      response.events = events;
-    }
-    return response;
-  });
-}
-
-// src/hooks/use-chat.ts
-var import_untruncate_json = __toESM(require("untruncate-json"));
+var import_runtime_client_gql = require("@copilotkit/runtime-client-gql");
 function useChat(options) {
-  const { messages, setMessages, makeSystemMessageCallback } = options;
+  const {
+    messages,
+    setMessages,
+    makeSystemMessageCallback,
+    copilotConfig,
+    setIsLoading,
+    initialMessages,
+    isLoading,
+    actions,
+    onFunctionCall
+  } = options;
   const abortControllerRef = (0, import_react2.useRef)();
   const threadIdRef = (0, import_react2.useRef)(null);
   const runIdRef = (0, import_react2.useRef)(null);
-  const publicApiKey = options.copilotConfig.publicApiKey;
-  const headers = __spreadValues(__spreadValues({}, options.headers || {}), publicApiKey ? { [import_shared2.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey } : {});
-  const runChatCompletion = (messages2) => __async(this, null, function* () {
-    options.setIsLoading(true);
-    const newMessages = [
-      {
-        id: (0, import_nanoid.nanoid)(),
-        createdAt: /* @__PURE__ */ new Date(),
+  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
+  });
+  const runChatCompletion = (previousMessages) => __async(this, null, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    setIsLoading(true);
+    let newMessages = [
+      new import_runtime_client_gql.TextMessage({
         content: "",
-        role: "assistant"
-      }
+        role: import_runtime_client_gql.Role.Assistant
+      })
     ];
     const abortController = new AbortController();
     abortControllerRef.current = abortController;
-    setMessages([...messages2, ...newMessages]);
-    const copilotConfigBody = options.copilotConfig.body || {};
-    if (threadIdRef.current) {
-      copilotConfigBody.threadId = threadIdRef.current;
-    }
-    if (runIdRef.current) {
-      copilotConfigBody.runId = runIdRef.current;
-    }
+    setMessages([...previousMessages, ...newMessages]);
     const systemMessage = makeSystemMessageCallback();
-    const messagesWithContext = [systemMessage, ...options.initialMessages || [], ...messages2];
-    const response = yield fetchAndDecodeChatCompletion({
-      copilotConfig: __spreadProps(__spreadValues({}, options.copilotConfig), { body: copilotConfigBody }),
-      messages: messagesWithContext,
-      tools: options.tools,
-      headers,
-      signal: abortController.signal
-    });
-    if (response.headers.get("threadid")) {
-      threadIdRef.current = response.headers.get("threadid");
-    }
-    if (response.headers.get("runid")) {
-      runIdRef.current = response.headers.get("runid");
-    }
-    if (!response.events) {
-      setMessages([
-        ...messages2,
-        {
-          id: (0, import_nanoid.nanoid)(),
-          createdAt: /* @__PURE__ */ new Date(),
-          content: response.statusText,
-          role: "assistant"
-        }
-      ]);
-      options.setIsLoading(false);
-      throw new Error("Failed to fetch chat completion");
-    }
-    const reader = response.events.getReader();
-    let feedback = false;
+    const messagesWithContext = [systemMessage, ...initialMessages || [], ...previousMessages];
+    const stream = import_runtime_client_gql.CopilotRuntimeClient.asStream(
+      runtimeClient.generateCopilotResponse(
+        __spreadValues({
+          frontend: {
+            actions: actions.map((action) => ({
+              name: action.name,
+              description: action.description || "",
+              jsonSchema: JSON.stringify((0, import_shared.actionParametersToJsonSchema)(action.parameters || []))
+            }))
+          },
+          threadId: threadIdRef.current,
+          runId: runIdRef.current,
+          messages: (0, import_runtime_client_gql.convertMessagesToGqlInput)(messagesWithContext)
+        }, copilotConfig.cloud ? {
+          cloud: {
+            guardrails: {
+              inputValidationRules: {
+                allowList: copilotConfig.cloud.guardrails.input.restrictToTopic.validTopics,
+                denyList: copilotConfig.cloud.guardrails.input.restrictToTopic.invalidTopics
+              }
+            }
+          }
+        } : {}),
+        copilotConfig.properties,
+        (_a = abortControllerRef.current) == null ? void 0 : _a.signal
+      )
+    );
+    const guardrailsEnabled = ((_d = (_c = (_b = copilotConfig.cloud) == null ? void 0 : _b.guardrails) == null ? void 0 : _c.input) == null ? void 0 : _d.restrictToTopic.enabled) || false;
+    const reader = stream.getReader();
+    let results = {};
     try {
       while (true) {
         const { done, value } = yield reader.read();
         if (done) {
           break;
         }
-        let currentMessage = Object.assign({}, newMessages[newMessages.length - 1]);
-        if (value.type === "content") {
-          if (currentMessage.function_call || currentMessage.role === "function") {
-            currentMessage = {
-              id: (0, import_nanoid.nanoid)(),
-              createdAt: /* @__PURE__ */ new Date(),
-              content: "",
-              role: "assistant"
-            };
-            newMessages.push(currentMessage);
-          }
-          currentMessage.content += value.content;
-          newMessages[newMessages.length - 1] = currentMessage;
-          setMessages([...messages2, ...newMessages]);
-        } else if (value.type === "result") {
-          currentMessage = {
-            id: (0, import_nanoid.nanoid)(),
-            role: "function",
-            content: value.content,
-            name: value.name
-          };
-          newMessages.push(currentMessage);
-          setMessages([...messages2, ...newMessages]);
-          feedback = true;
-        } else if (value.type === "function" || value.type === "partial") {
-          if (currentMessage.content != "" || currentMessage.function_call || currentMessage.role == "function") {
-            currentMessage = {
-              id: (0, import_nanoid.nanoid)(),
-              createdAt: /* @__PURE__ */ new Date(),
-              content: "",
-              role: "assistant"
-            };
-            newMessages.push(currentMessage);
-          }
-          if (value.type === "function") {
-            currentMessage.function_call = {
-              name: value.name,
-              arguments: JSON.stringify(value.arguments),
-              scope: value.scope
-            };
-          } else if (value.type === "partial") {
-            let partialArguments = {};
-            try {
-              partialArguments = JSON.parse((0, import_untruncate_json.default)(value.arguments));
-            } catch (e) {
-            }
-            currentMessage.partialFunctionCall = {
-              name: value.name,
-              arguments: partialArguments
-            };
-          }
-          newMessages[newMessages.length - 1] = currentMessage;
-          setMessages([...messages2, ...newMessages]);
-          if (value.type === "function") {
-            try {
-              if (options.onFunctionCall && value.scope === "client") {
-                const result = yield options.onFunctionCall(
-                  messages2,
-                  currentMessage.function_call
-                );
-                currentMessage = {
-                  id: (0, import_nanoid.nanoid)(),
-                  role: "function",
-                  content: (0, import_shared2.encodeResult)(result),
-                  name: currentMessage.function_call.name
-                };
-                newMessages.push(currentMessage);
-                setMessages([...messages2, ...newMessages]);
-                feedback = true;
+        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)(value.generateCopilotResponse.messages);
+        if (messages2.length === 0) {
+          continue;
+        }
+        newMessages = [];
+        if (((_e = value.generateCopilotResponse.status) == null ? void 0 : _e.__typename) === "FailedResponseStatus" && value.generateCopilotResponse.status.reason === "GUARDRAILS_VALIDATION_FAILED") {
+          newMessages = [
+            new import_runtime_client_gql.TextMessage({
+              role: import_runtime_client_gql.MessageRole.Assistant,
+              content: ((_f = value.generateCopilotResponse.status.details) == null ? void 0 : _f.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 results)) {
+                if (guardrailsEnabled && value.generateCopilotResponse.status === void 0) {
+                  break;
+                }
+                const result = yield onFunctionCall({
+                  messages: previousMessages,
+                  name: message.name,
+                  args: message.arguments
+                });
+                results[message.id] = result;
               }
-            } catch (error) {
-              console.error("Failed to execute function call", error);
+              newMessages.push(
+                new import_runtime_client_gql.ResultMessage({
+                  result: import_runtime_client_gql.ResultMessage.encodeResult(results[message.id]),
+                  actionExecutionId: message.id,
+                  actionName: message.name
+                })
+              );
             }
           }
         }
+        if (newMessages.length > 0) {
+          setMessages([...previousMessages, ...newMessages]);
+        }
       }
-      if (feedback) {
+      if (
+        // if we have client side results
+        Object.values(results).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([...messages2, ...newMessages]);
+        return yield runChatCompletion([...previousMessages, ...newMessages]);
       } else {
         return newMessages.slice();
       }
     } finally {
-      options.setIsLoading(false);
+      setIsLoading(false);
     }
   });
   const runChatCompletionAndHandleFunctionCall = (messages2) => __async(this, null, function* () {
     yield runChatCompletion(messages2);
   });
   const append = (message) => __async(this, null, function* () {
-    if (options.isLoading) {
+    if (isLoading) {
       return;
     }
     const newMessages = [...messages, message];
@@ -372,12 +293,12 @@ function useChat(options) {
     return runChatCompletionAndHandleFunctionCall(newMessages);
   });
   const reload = () => __async(this, null, function* () {
-    if (options.isLoading || messages.length === 0) {
+    if (isLoading || messages.length === 0) {
       return;
     }
     let newMessages = [...messages];
     const lastMessage = messages[messages.length - 1];
-    if (lastMessage.role === "assistant") {
+    if (lastMessage instanceof import_runtime_client_gql.TextMessage && lastMessage.role === "assistant") {
       newMessages = newMessages.slice(0, -1);
     }
     setMessages(newMessages);
@@ -396,7 +317,7 @@ function useChat(options) {
 
 // src/components/copilot-provider/copilotkit.tsx
 var import_react3 = require("react");
-var import_shared3 = require("@copilotkit/shared");
+var import_shared2 = require("@copilotkit/shared");
 var import_jsx_runtime = require("react/jsx-runtime");
 var defaultCopilotContextCategories = ["global"];
 
@@ -409,14 +330,14 @@ function useCopilotChat(_a = {}) {
   ]);
   const {
     getContextString,
-    getChatCompletionFunctionDescriptions,
     getFunctionCallHandler,
     copilotApiConfig,
     messages,
     setMessages,
     isLoading,
     setIsLoading,
-    chatInstructions
+    chatInstructions,
+    actions
   } = (0, import_react4.useContext)(CopilotContext);
   const latestGetContextString = useUpdatedRef(getContextString);
   const deleteMessage = (0, import_react4.useCallback)(
@@ -428,34 +349,24 @@ function useCopilotChat(_a = {}) {
   const makeSystemMessageCallback = (0, import_react4.useCallback)(() => {
     const systemMessageMaker = makeSystemMessage || defaultSystemMessage;
     const contextString = latestGetContextString.current([], defaultCopilotContextCategories);
-    return {
-      id: "system",
+    return new import_runtime_client_gql2.TextMessage({
       content: systemMessageMaker(contextString, chatInstructions),
-      role: "system"
-    };
+      role: import_runtime_client_gql2.Role.System
+    });
   }, [getContextString, makeSystemMessage, chatInstructions]);
-  const functionDescriptions = (0, import_react4.useMemo)(() => {
-    return getChatCompletionFunctionDescriptions();
-  }, [getChatCompletionFunctionDescriptions]);
   const { append, reload, stop } = useChat(__spreadProps(__spreadValues({}, options), {
+    actions: Object.values(actions),
     copilotConfig: copilotApiConfig,
-    id: options.id,
     initialMessages: options.initialMessages || [],
-    tools: functionDescriptions,
     onFunctionCall: getFunctionCallHandler(),
-    headers: __spreadValues({}, options.headers),
-    body: __spreadValues({}, options.body),
     messages,
     setMessages,
     makeSystemMessageCallback,
     isLoading,
     setIsLoading
   }));
-  const visibleMessages = messages.filter(
-    (message) => message.role === "user" || message.role === "assistant" || message.role === "function"
-  );
   return {
-    visibleMessages,
+    visibleMessages: messages,
     appendMessage: append,
     setMessages,
     reloadMessages: reload,
@@ -497,11 +408,11 @@ ${additionalInstructions}` : "");
 
 // src/hooks/use-make-copilot-actionable.ts
 var import_react5 = require("react");
-var import_nanoid2 = require("nanoid");
-var import_shared4 = require("@copilotkit/shared");
+var import_nanoid = require("nanoid");
+var import_shared3 = require("@copilotkit/shared");
 function useMakeCopilotActionable(annotatedFunction, dependencies) {
-  const idRef = (0, import_react5.useRef)((0, import_nanoid2.nanoid)());
-  const { setEntryPoint, removeEntryPoint } = (0, import_react5.useContext)(CopilotContext);
+  const idRef = (0, import_react5.useRef)((0, import_nanoid.nanoid)());
+  const { setAction, removeAction } = (0, import_react5.useContext)(CopilotContext);
   const memoizedAnnotatedFunction = (0, import_react5.useMemo)(
     () => ({
       name: annotatedFunction.name,
@@ -512,23 +423,23 @@ function useMakeCopilotActionable(annotatedFunction, dependencies) {
     dependencies
   );
   (0, import_react5.useEffect)(() => {
-    const action = (0, import_shared4.annotatedFunctionToAction)(memoizedAnnotatedFunction);
-    setEntryPoint(idRef.current, action);
+    const action = (0, import_shared3.annotatedFunctionToAction)(memoizedAnnotatedFunction);
+    setAction(idRef.current, action);
     return () => {
-      removeEntryPoint(idRef.current);
+      removeAction(idRef.current);
     };
-  }, [memoizedAnnotatedFunction, setEntryPoint, removeEntryPoint]);
+  }, [memoizedAnnotatedFunction, setAction, removeAction]);
 }
 
 // src/hooks/use-copilot-action.ts
 var import_react6 = require("react");
-var import_nanoid3 = require("nanoid");
+var import_nanoid2 = require("nanoid");
 function useCopilotAction(action, dependencies) {
-  const { setEntryPoint, removeEntryPoint, entryPoints, chatComponentsCache } = (0, import_react6.useContext)(CopilotContext);
-  const idRef = (0, import_react6.useRef)((0, import_nanoid3.nanoid)());
+  const { setAction, removeAction, actions, chatComponentsCache } = (0, import_react6.useContext)(CopilotContext);
+  const idRef = (0, import_react6.useRef)((0, import_nanoid2.nanoid)());
   if (dependencies === void 0) {
-    if (entryPoints[idRef.current]) {
-      entryPoints[idRef.current].handler = action.handler;
+    if (actions[idRef.current]) {
+      actions[idRef.current].handler = action.handler;
       if (typeof action.render === "function") {
         if (chatComponentsCache.current !== null) {
           chatComponentsCache.current[action.name] = action.render;
@@ -537,16 +448,16 @@ function useCopilotAction(action, dependencies) {
     }
   }
   (0, import_react6.useEffect)(() => {
-    setEntryPoint(idRef.current, action);
+    setAction(idRef.current, action);
     if (chatComponentsCache.current !== null && action.render !== void 0) {
       chatComponentsCache.current[action.name] = action.render;
     }
     return () => {
-      removeEntryPoint(idRef.current);
+      removeAction(idRef.current);
     };
   }, [
-    setEntryPoint,
-    removeEntryPoint,
+    setAction,
+    removeAction,
     action.description,
     action.name,
     // This should be faster than deep equality checking