@copilotkit/react-core 0.13.0 → 0.15.0-alpha.0

package/src/hooks/use-flat-category-store.ts

@@ -17,28 +17,19 @@ interface FlatCategoryStoreElement<T> {
 
 const useFlatCategoryStore = <T>(): UseFlatCategoryStoreReturn<T> => {
   const [elements, dispatch] = useReducer<
-    React.Reducer<
-      Map<FlatCategoryStoreId, FlatCategoryStoreElement<T>>,
-      Action<T>
-    >
-  >(
-    flatCategoryStoreReducer,
-    new Map<FlatCategoryStoreId, FlatCategoryStoreElement<T>>()
-  );
+    React.Reducer<Map<FlatCategoryStoreId, FlatCategoryStoreElement<T>>, Action<T>>
+  >(flatCategoryStoreReducer, new Map<FlatCategoryStoreId, FlatCategoryStoreElement<T>>());
 
-  const addElement = useCallback(
-    (value: T, categories: string[]): FlatCategoryStoreId => {
-      const newId = nanoid();
-      dispatch({
-        type: "ADD_ELEMENT",
-        value,
-        id: newId,
-        categories,
-      });
-      return newId;
-    },
-    []
-  );
+  const addElement = useCallback((value: T, categories: string[]): FlatCategoryStoreId => {
+    const newId = nanoid();
+    dispatch({
+      type: "ADD_ELEMENT",
+      value,
+      id: newId,
+      categories,
+    });
+    return newId;
+  }, []);
 
   const removeElement = useCallback((id: FlatCategoryStoreId): void => {
     dispatch({ type: "REMOVE_ELEMENT", id });
@@ -55,7 +46,7 @@ const useFlatCategoryStore = <T>(): UseFlatCategoryStoreReturn<T> => {
       });
       return result;
     },
-    [elements]
+    [elements],
   );
 
   return { addElement, removeElement, allElements };
@@ -76,7 +67,7 @@ type Action<T> =
 // Reducer
 function flatCategoryStoreReducer<T>(
   state: Map<FlatCategoryStoreId, FlatCategoryStoreElement<T>>,
-  action: Action<T>
+  action: Action<T>,
 ): Map<FlatCategoryStoreId, FlatCategoryStoreElement<T>> {
   switch (action.type) {
     case "ADD_ELEMENT": {
@@ -101,8 +92,7 @@ function flatCategoryStoreReducer<T>(
 }
 
 function setsHaveIntersection<T>(setA: Set<T>, setB: Set<T>): boolean {
-  const [smallerSet, largerSet] =
-    setA.size <= setB.size ? [setA, setB] : [setB, setA];
+  const [smallerSet, largerSet] = setA.size <= setB.size ? [setA, setB] : [setB, setA];
 
   for (let item of smallerSet) {
     if (largerSet.has(item)) {

package/src/hooks/use-make-copilot-actionable.ts

@@ -7,7 +7,7 @@ import { nanoid } from "nanoid";
 
 export function useMakeCopilotActionable<ActionInput extends any[]>(
   annotatedFunction: AnnotatedFunction<ActionInput>,
-  dependencies: any[]
+  dependencies: any[],
 ) {
   const idRef = useRef(nanoid()); // generate a unique id
   const { setEntryPoint, removeEntryPoint } = useContext(CopilotContext);
@@ -19,14 +19,11 @@ export function useMakeCopilotActionable<ActionInput extends any[]>(
       argumentAnnotations: annotatedFunction.argumentAnnotations,
       implementation: annotatedFunction.implementation,
     }),
-    dependencies
+    dependencies,
   );
 
   useEffect(() => {
-    setEntryPoint(
-      idRef.current,
-      memoizedAnnotatedFunction as AnnotatedFunction<any[]>
-    );
+    setEntryPoint(idRef.current, memoizedAnnotatedFunction as AnnotatedFunction<any[]>);
 
     return () => {
       removeEntryPoint(idRef.current);

package/src/hooks/use-make-copilot-document-readable.ts

@@ -14,10 +14,9 @@ import { DocumentPointer } from "../types";
 export function useMakeCopilotDocumentReadable(
   document: DocumentPointer,
   categories?: string[],
-  dependencies: any[] = []
+  dependencies: any[] = [],
 ): string | undefined {
-  const { addDocumentContext, removeDocumentContext } =
-    useContext(CopilotContext);
+  const { addDocumentContext, removeDocumentContext } = useContext(CopilotContext);
   const idRef = useRef<string>();
 
   useEffect(() => {

package/src/hooks/use-make-copilot-readable.ts

@@ -13,7 +13,7 @@ import { CopilotContext } from "../context/copilot-context";
 export function useMakeCopilotReadable(
   information: string,
   parentId?: string,
-  categories?: string[]
+  categories?: string[],
 ): string | undefined {
   const { addContext, removeContext } = useContext(CopilotContext);
   const idRef = useRef<string>();

package/src/hooks/use-tree.ts

@@ -15,11 +15,7 @@ export type Tree = TreeNode[];
 
 export interface UseTreeReturn {
   tree: Tree;
-  addElement: (
-    value: string,
-    categories: string[],
-    parentId?: TreeNodeId
-  ) => TreeNodeId;
+  addElement: (value: string, categories: string[], parentId?: TreeNodeId) => TreeNodeId;
   printTree: (categories: string[]) => string;
   removeElement: (id: TreeNodeId) => void;
 }
@@ -47,11 +43,7 @@ const removeNode = (nodes: Tree, id: TreeNodeId): Tree => {
   }, []);
 };
 
-const addNode = (
-  nodes: Tree,
-  newNode: TreeNode,
-  parentId?: TreeNodeId
-): Tree => {
+const addNode = (nodes: Tree, newNode: TreeNode, parentId?: TreeNodeId): Tree => {
   if (!parentId) {
     return [...nodes, newNode];
   }
@@ -65,10 +57,7 @@ const addNode = (
   });
 };
 
-const treeIndentationRepresentation = (
-  index: number,
-  indentLevel: number
-): string => {
+const treeIndentationRepresentation = (index: number, indentLevel: number): string => {
   if (indentLevel === 0) {
     return (index + 1).toString();
   } else if (indentLevel === 1) {
@@ -105,12 +94,9 @@ const printNode = (node: TreeNode, prefix = "", indentLevel = 0): string => {
     (child, index) =>
       (output += printNode(
         child,
-        `${childPrePrefix}${treeIndentationRepresentation(
-          index,
-          indentLevel + 1
-        )}. `,
-        indentLevel + 1
-      ))
+        `${childPrePrefix}${treeIndentationRepresentation(index, indentLevel + 1)}. `,
+        indentLevel + 1,
+      )),
   );
   return output;
 };
@@ -168,7 +154,7 @@ const useTree = (): UseTreeReturn => {
       });
       return newNodeId; // Return the new ID
     },
-    []
+    [],
   );
 
   const removeElement = useCallback((id: TreeNodeId): void => {
@@ -191,14 +177,11 @@ const useTree = (): UseTreeReturn => {
           output += "\n";
         }
 
-        output += printNode(
-          node,
-          `${treeIndentationRepresentation(index, 0)}. `
-        );
+        output += printNode(node, `${treeIndentationRepresentation(index, 0)}. `);
       });
       return output;
     },
-    [tree]
+    [tree],
   );
 
   return { tree, addElement, printTree, removeElement };
@@ -207,8 +190,7 @@ const useTree = (): UseTreeReturn => {
 export default useTree;
 
 function setsHaveIntersection<T>(setA: Set<T>, setB: Set<T>): boolean {
-  const [smallerSet, largerSet] =
-    setA.size <= setB.size ? [setA, setB] : [setB, setA];
+  const [smallerSet, largerSet] = setA.size <= setB.size ? [setA, setB] : [setB, setA];
 
   for (let item of smallerSet) {
     if (largerSet.has(item)) {

package/src/index.tsx

@@ -2,3 +2,4 @@ export * from "./components";
 export * from "./context";
 export * from "./hooks";
 export * from "./types";
+export * from "./openai-assistants";

package/src/openai-assistants/hooks/index.ts

@@ -0,0 +1,9 @@
+// export type { AssistantStatus } from "./use-assistants";
+// export { experimental_useAssistant } from "./use-assistants";
+export type {
+  AssistantStatus,
+  RequestForwardingOptions,
+  UseCopilotChatOptionsV2,
+  UseCopilotChatV2Result,
+} from "./use-copilot-chat-v2";
+export { useCopilotChatV2 } from "./use-copilot-chat-v2";

package/src/openai-assistants/hooks/use-assistants.ts

@@ -0,0 +1,114 @@
+"use client";
+
+import { useState } from "react";
+import { processMessageStream } from "../utils";
+import { Message, parseStreamPart } from "@copilotkit/shared";
+
+export type AssistantStatus = "in_progress" | "awaiting_message";
+
+export interface UseAssistantResult {
+  messages: Message[];
+  input: string;
+  handleInputChange: (e: any) => void;
+  submitMessage: (e: any) => Promise<void>;
+  status: AssistantStatus;
+  error: unknown;
+}
+
+export function experimental_useAssistant({
+  api,
+  threadId: threadIdParam,
+}: {
+  api: string;
+  threadId?: string | undefined;
+}): UseAssistantResult {
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [input, setInput] = useState("");
+  const [threadId, setThreadId] = useState<string | undefined>(undefined);
+  const [status, setStatus] = useState<AssistantStatus>("awaiting_message");
+  const [error, setError] = useState<unknown | undefined>(undefined);
+
+  const handleInputChange = (e: any) => {
+    setInput(e.target.value);
+  };
+
+  const submitMessage = async (e: any) => {
+    e.preventDefault();
+
+    if (input === "") {
+      return;
+    }
+
+    setStatus("in_progress");
+
+    setMessages((messages) => [...messages, { id: "", role: "user", content: input }]);
+
+    setInput("");
+
+    const result = await fetch(api, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        // always use user-provided threadId when available:
+        threadId: threadIdParam ?? threadId ?? null,
+        message: input,
+      }),
+    });
+
+    if (result.body == null) {
+      throw new Error("The response body is empty.");
+    }
+
+    await processMessageStream(result.body.getReader(), (message: string) => {
+      try {
+        const { type, value } = parseStreamPart(message);
+
+        switch (type) {
+          case "assistant_message": {
+            // append message:
+            setMessages((messages) => [
+              ...messages,
+              {
+                id: value.id,
+                role: value.role,
+                content: value.content[0].text.value,
+              },
+            ]);
+            break;
+          }
+
+          case "assistant_control_data": {
+            setThreadId(value.threadId);
+
+            // set id of last message:
+            setMessages((messages) => {
+              const lastMessage = messages[messages.length - 1];
+              lastMessage.id = value.messageId;
+              return [...messages.slice(0, messages.length - 1), lastMessage];
+            });
+
+            break;
+          }
+
+          case "error": {
+            setError(value);
+            break;
+          }
+        }
+      } catch (error) {
+        setError(error);
+      }
+    });
+
+    setStatus("awaiting_message");
+  };
+
+  return {
+    messages,
+    input,
+    handleInputChange,
+    submitMessage,
+    status,
+    error,
+  };
+}

package/src/openai-assistants/hooks/use-copilot-chat-v2.ts

@@ -0,0 +1,186 @@
+import { useContext, useMemo, useState } from "react";
+import { processMessageStream } from "../utils";
+import { Message, parseStreamPart } from "@copilotkit/shared";
+import { CopilotContext, copilotApiConfigExtrapolator } from "../../context";
+import { defaultCopilotContextCategories } from "../../components";
+
+export type AssistantStatus = "in_progress" | "awaiting_message";
+
+export interface RequestForwardingOptions {
+  /**
+   * The credentials mode to be used for the fetch request.
+   * Possible values are: 'omit', 'same-origin', 'include'.
+   * Defaults to 'same-origin'.
+   */
+  credentials?: RequestCredentials;
+  /**
+   * HTTP headers to be sent with the API request.
+   */
+  headers?: Record<string, string> | Headers;
+  /**
+   * Extra body object to be sent with the API request.
+   * @example
+   * Send a `sessionId` to the API along with the messages.
+   * ```js
+   * useChat({
+   *   body: {
+   *     sessionId: '123',
+   *   }
+   * })
+   * ```
+   */
+  body?: object;
+}
+export interface UseCopilotChatOptionsV2 extends RequestForwardingOptions {
+  makeSystemMessage?: (contextString: string) => string;
+  threadId?: string | undefined;
+}
+
+export interface UseCopilotChatV2Result {
+  messages: Message[];
+  input: string;
+  handleInputChange: (e: any) => void;
+  submitMessage: (e: any) => Promise<void>;
+  status: AssistantStatus;
+  error: unknown;
+}
+
+export function useCopilotChatV2(options: UseCopilotChatOptionsV2): UseCopilotChatV2Result {
+  const {
+    getContextString,
+    getChatCompletionFunctionDescriptions,
+    getFunctionCallHandler,
+    copilotApiConfig,
+  } = useContext(CopilotContext);
+
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [input, setInput] = useState("");
+  const [threadId, setThreadId] = useState<string | undefined>(undefined);
+  const [status, setStatus] = useState<AssistantStatus>("awaiting_message");
+  const [error, setError] = useState<unknown | undefined>(undefined);
+
+  const systemMessage: Message = useMemo(() => {
+    const systemMessageMaker = options.makeSystemMessage || defaultSystemMessage;
+    const contextString = getContextString([], defaultCopilotContextCategories); // TODO: make the context categories configurable
+
+    return {
+      id: "system",
+      content: systemMessageMaker(contextString),
+      role: "system",
+    };
+  }, [getContextString, options.makeSystemMessage]);
+
+  const handleInputChange = (e: any) => {
+    setInput(e.target.value);
+  };
+
+  const submitMessage = async (e: any) => {
+    e.preventDefault();
+
+    if (input === "") {
+      return;
+    }
+
+    setStatus("in_progress");
+
+    setMessages((messages) => [...messages, { id: "", role: "user", content: input }]);
+
+    setInput("");
+
+    const apiUrl = copilotApiConfigExtrapolator(copilotApiConfig).chatApiEndpointV2;
+    const result = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...copilotApiConfig.headers,
+        ...options.headers,
+      },
+      body: JSON.stringify({
+        // always use user-provided threadId when available:
+        threadId: options.threadId ?? threadId ?? null,
+        message: input,
+        functions: getChatCompletionFunctionDescriptions(),
+        ...copilotApiConfig.body,
+        ...options.body,
+      }),
+    });
+
+    if (result.body == null) {
+      throw new Error("The response body is empty.");
+    }
+
+    await processMessageStream(result.body.getReader(), (message: string) => {
+      try {
+        const { type, value } = parseStreamPart(message);
+
+        switch (type) {
+          case "assistant_message": {
+            // append message:
+            setMessages((messages) => [
+              ...messages,
+              {
+                id: value.id,
+                role: value.role,
+                content: value.content[0].text.value,
+              },
+            ]);
+            break;
+          }
+
+          case "assistant_control_data": {
+            setThreadId(value.threadId);
+
+            // set id of last message:
+            setMessages((messages) => {
+              const lastMessage = messages[messages.length - 1];
+              lastMessage.id = value.messageId;
+              return [...messages.slice(0, messages.length - 1), lastMessage];
+            });
+
+            break;
+          }
+
+          case "error": {
+            setError(value);
+            break;
+          }
+        }
+      } catch (error) {
+        setError(error);
+      }
+    });
+
+    setStatus("awaiting_message");
+  };
+
+  return {
+    messages,
+    input,
+    handleInputChange,
+    submitMessage,
+    status,
+    error,
+  };
+}
+
+export function defaultSystemMessage(contextString: string): string {
+  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.
+`;
+}

package/src/openai-assistants/index.ts

@@ -0,0 +1,2 @@
+export * from "./hooks";
+export * from "./utils";

package/src/openai-assistants/utils/index.ts

@@ -0,0 +1 @@
+export { processMessageStream } from "./process-message-stream";

package/src/openai-assistants/utils/process-message-stream.ts

@@ -0,0 +1,25 @@
+export async function processMessageStream(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  processMessage: (message: string) => void | Promise<void>,
+) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+
+    if (done) {
+      if (buffer.length > 0) {
+        processMessage(buffer);
+      }
+      break;
+    }
+
+    buffer += decoder.decode(value, { stream: true });
+
+    let endIndex: number;
+    while ((endIndex = buffer.indexOf("\n")) !== -1) {
+      processMessage(buffer.substring(0, endIndex).trim());
+      buffer = buffer.substring(endIndex + 1); // Remove the processed instruction + delimiter
+    }
+  }
+}

package/dist/chunk-3BOHSSKR.mjs

@@ -1,141 +0,0 @@
-import { __spreadProps, __spreadValues } from './chunk-MRXNTQOX.mjs';
-import { nanoid } from 'nanoid';
-import { useReducer, useCallback } from 'react';
-
-var removeNode = (nodes, id) => {
-  return nodes.reduce((result, node) => {
-    if (node.id !== id) {
-      const newNode = __spreadProps(__spreadValues({}, node), { children: removeNode(node.children, id) });
-      result.push(newNode);
-    }
-    return result;
-  }, []);
-};
-var addNode = (nodes, newNode, parentId) => {
-  if (!parentId) {
-    return [...nodes, newNode];
-  }
-  return nodes.map((node) => {
-    if (node.id === parentId) {
-      return __spreadProps(__spreadValues({}, node), { children: [...node.children, newNode] });
-    } else if (node.children.length) {
-      return __spreadProps(__spreadValues({}, node), { children: addNode(node.children, newNode, parentId) });
-    }
-    return node;
-  });
-};
-var treeIndentationRepresentation = (index, indentLevel) => {
-  if (indentLevel === 0) {
-    return (index + 1).toString();
-  } else if (indentLevel === 1) {
-    return String.fromCharCode(65 + index);
-  } else if (indentLevel === 2) {
-    return String.fromCharCode(97 + index);
-  } else {
-    return "-";
-  }
-};
-var printNode = (node, prefix = "", indentLevel = 0) => {
-  const indent = " ".repeat(3).repeat(indentLevel);
-  const prefixPlusIndentLength = prefix.length + indent.length;
-  const subsequentLinesPrefix = " ".repeat(prefixPlusIndentLength);
-  const valueLines = node.value.split("\n");
-  const outputFirstLine = `${indent}${prefix}${valueLines[0]}`;
-  const outputSubsequentLines = valueLines.slice(1).map((line) => `${subsequentLinesPrefix}${line}`).join("\n");
-  let output = `${outputFirstLine}
-`;
-  if (outputSubsequentLines) {
-    output += `${outputSubsequentLines}
-`;
-  }
-  const childPrePrefix = " ".repeat(prefix.length);
-  node.children.forEach(
-    (child, index) => output += printNode(
-      child,
-      `${childPrePrefix}${treeIndentationRepresentation(
-        index,
-        indentLevel + 1
-      )}. `,
-      indentLevel + 1
-    )
-  );
-  return output;
-};
-function treeReducer(state, action) {
-  switch (action.type) {
-    case "ADD_NODE": {
-      const { value, parentId, id: newNodeId } = action;
-      const newNode = {
-        id: newNodeId,
-        value,
-        children: [],
-        categories: new Set(action.categories)
-      };
-      try {
-        return addNode(state, newNode, parentId);
-      } catch (error) {
-        console.error(`Error while adding node with id ${newNodeId}: ${error}`);
-        return state;
-      }
-    }
-    case "REMOVE_NODE":
-      return removeNode(state, action.id);
-    default:
-      return state;
-  }
-}
-var useTree = () => {
-  const [tree, dispatch] = useReducer(treeReducer, []);
-  const addElement = useCallback(
-    (value, categories, parentId) => {
-      const newNodeId = nanoid();
-      dispatch({
-        type: "ADD_NODE",
-        value,
-        parentId,
-        id: newNodeId,
-        categories
-      });
-      return newNodeId;
-    },
-    []
-  );
-  const removeElement = useCallback((id) => {
-    dispatch({ type: "REMOVE_NODE", id });
-  }, []);
-  const printTree = useCallback(
-    (categories) => {
-      const categoriesSet = new Set(categories);
-      let output = "";
-      tree.forEach((node, index) => {
-        if (!setsHaveIntersection(categoriesSet, node.categories)) {
-          return;
-        }
-        if (index !== 0) {
-          output += "\n";
-        }
-        output += printNode(
-          node,
-          `${treeIndentationRepresentation(index, 0)}. `
-        );
-      });
-      return output;
-    },
-    [tree]
-  );
-  return { tree, addElement, printTree, removeElement };
-};
-var use_tree_default = useTree;
-function setsHaveIntersection(setA, setB) {
-  const [smallerSet, largerSet] = setA.size <= setB.size ? [setA, setB] : [setB, setA];
-  for (let item of smallerSet) {
-    if (largerSet.has(item)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export { use_tree_default };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-3BOHSSKR.mjs.map