@copilotkit/react-core 0.8.0-alpha.5 → 0.8.0-alpha.6

package/src/components/copilot-provider.tsx

@@ -5,6 +5,8 @@ import { CopilotContext, CopilotApiConfig } from "../context/copilot-context";
 import useTree from "../hooks/use-tree";
 import { AnnotatedFunction } from "../types/annotated-function";
 import { ChatCompletionCreateParams } from "openai/resources/chat";
+import { DocumentPointer } from "../types";
+import useFlatCategoryStore from "../hooks/use-flat-category-store";
 
 export function CopilotProvider({
   copilotApiConfig,
@@ -18,6 +20,11 @@ export function CopilotProvider({
   >({});
 
   const { addElement, removeElement, printTree } = useTree();
+  const {
+    addElement: addDocument,
+    removeElement: removeDocument,
+    allElements: allDocuments,
+  } = useFlatCategoryStore<DocumentPointer>();
 
   const setEntryPoint = useCallback(
     (id: string, entryPoint: AnnotatedFunction<any[]>) => {
@@ -68,6 +75,27 @@ export function CopilotProvider({
     return entryPointsToFunctionCallHandler(Object.values(entryPoints));
   }, [entryPoints]);
 
+  const getDocumentsContext = useCallback(
+    (categories: string[] = ["global"]) => {
+      return allDocuments(categories);
+    },
+    [allDocuments]
+  );
+
+  const addDocumentContext = useCallback(
+    (documentPointer: DocumentPointer, categories: string[] = ["global"]) => {
+      return addDocument(documentPointer, categories);
+    },
+    [addDocument]
+  );
+
+  const removeDocumentContext = useCallback(
+    (documentId: string) => {
+      removeDocument(documentId);
+    },
+    [removeDocument]
+  );
+
   return (
     <CopilotContext.Provider
       value={{
@@ -79,7 +107,9 @@ export function CopilotProvider({
         getContextString,
         addContext,
         removeContext,
-
+        getDocumentsContext,
+        addDocumentContext,
+        removeDocumentContext,
         copilotApiConfig,
       }}
     >

package/src/context/copilot-context.tsx

@@ -5,6 +5,7 @@ import React from "react";
 import { TreeNodeId } from "../hooks/use-tree";
 import { AnnotatedFunction } from "../types/annotated-function";
 import { ChatCompletionCreateParams } from "openai/resources/chat";
+import { DocumentPointer } from "../types";
 
 export interface CopilotApiConfig {
   chatApiEndpoint: string;
@@ -35,6 +36,14 @@ export interface CopilotContextParams {
   ) => TreeNodeId;
   removeContext: (id: TreeNodeId) => void;
 
+  // document context
+  getDocumentsContext: (categories?: string[]) => DocumentPointer[];
+  addDocumentContext: (
+    documentPointer: DocumentPointer,
+    categories?: string[]
+  ) => TreeNodeId;
+  removeDocumentContext: (documentId: string) => void;
+
   // api endpoints
   copilotApiConfig: CopilotApiConfig;
 }
@@ -50,6 +59,10 @@ const emptyCopilotContext: CopilotContextParams = {
   addContext: () => "",
   removeContext: () => {},
 
+  getDocumentsContext: () => returnAndThrowInDebug([]),
+  addDocumentContext: () => returnAndThrowInDebug(""),
+  removeDocumentContext: () => {},
+
   copilotApiConfig: new (class implements CopilotApiConfig {
     get chatApiEndpoint(): string {
       throw new Error(

package/src/hooks/index.ts

@@ -4,3 +4,4 @@ export type { UseCopilotChatReturn } from "./use-copilot-chat";
 
 export { useMakeCopilotActionable } from "./use-make-copilot-actionable";
 export { useMakeCopilotReadable } from "./use-make-copilot-readable";
+export { useMakeCopilotDocumentReadable } from "./use-make-copilot-document-readable";

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

@@ -0,0 +1,114 @@
+import { nanoid } from "nanoid";
+import { useCallback, useReducer } from "react";
+
+export type FlatCategoryStoreId = string;
+
+export interface UseFlatCategoryStoreReturn<T> {
+  addElement: (value: T, categories: string[]) => FlatCategoryStoreId;
+  removeElement: (id: FlatCategoryStoreId) => void;
+  allElements: (categories: string[]) => T[];
+}
+
+interface FlatCategoryStoreElement<T> {
+  id: FlatCategoryStoreId;
+  value: T;
+  categories: Set<string>;
+}
+
+const useFlatCategoryStore = <T>(): UseFlatCategoryStoreReturn<T> => {
+  const [elements, dispatch] = useReducer<
+    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 removeElement = useCallback((id: FlatCategoryStoreId): void => {
+    dispatch({ type: "REMOVE_ELEMENT", id });
+  }, []);
+
+  const allElements = useCallback(
+    (categories: string[]): T[] => {
+      const categoriesSet = new Set(categories);
+      const result: T[] = [];
+      elements.forEach((element) => {
+        if (setsHaveIntersection(categoriesSet, element.categories)) {
+          result.push(element.value);
+        }
+      });
+      return result;
+    },
+    [elements]
+  );
+
+  return { addElement, removeElement, allElements };
+};
+
+export default useFlatCategoryStore;
+
+// Action types
+type Action<T> =
+  | {
+      type: "ADD_ELEMENT";
+      value: T;
+      id: FlatCategoryStoreId;
+      categories: string[];
+    }
+  | { type: "REMOVE_ELEMENT"; id: FlatCategoryStoreId };
+
+// Reducer
+function flatCategoryStoreReducer<T>(
+  state: Map<FlatCategoryStoreId, FlatCategoryStoreElement<T>>,
+  action: Action<T>
+): Map<FlatCategoryStoreId, FlatCategoryStoreElement<T>> {
+  switch (action.type) {
+    case "ADD_ELEMENT": {
+      const { value, id, categories } = action;
+      const newElement: FlatCategoryStoreElement<T> = {
+        id,
+        value,
+        categories: new Set(categories),
+      };
+      const newState = new Map(state);
+      newState.set(id, newElement);
+      return newState;
+    }
+    case "REMOVE_ELEMENT": {
+      const newState = new Map(state);
+      newState.delete(action.id);
+      return newState;
+    }
+    default:
+      return state;
+  }
+}
+
+function setsHaveIntersection<T>(setA: Set<T>, setB: Set<T>): boolean {
+  const [smallerSet, largerSet] =
+    setA.size <= setB.size ? [setA, setB] : [setB, setA];
+
+  for (let item of smallerSet) {
+    if (largerSet.has(item)) {
+      return true;
+    }
+  }
+
+  return false;
+}

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

@@ -0,0 +1,32 @@
+"use client";
+
+import { useContext, useEffect, useRef } from "react";
+import { CopilotContext } from "../context/copilot-context";
+import { DocumentPointer } from "../types";
+
+/**
+ * Adds the given information to the Copilot context to make it readable by Copilot.
+ * @param information - The information to be added to the Copilot context.
+ * @param parentId - The ID of the parent context, if any.
+ * @param categories - An array of categories to control which context are visible where. Particularly useful with CopilotTextarea (see `useMakeAutosuggestionFunction`)
+ * @returns The ID of the added context.
+ */
+export function useMakeCopilotDocumentReadable(
+  document: DocumentPointer,
+  categories?: string[]
+): string | undefined {
+  const { addDocumentContext, removeDocumentContext } =
+    useContext(CopilotContext);
+  const idRef = useRef<string>();
+
+  useEffect(() => {
+    const id = addDocumentContext(document, categories);
+    idRef.current = id;
+
+    return () => {
+      removeDocumentContext(id);
+    };
+  }, [document, categories, addDocumentContext, removeDocumentContext]);
+
+  return idRef.current;
+}

package/src/types/document-pointer.ts

@@ -0,0 +1,7 @@
+export interface DocumentPointer {
+  id: string;
+  name: string;
+  sourceApplication: string;
+  iconImageUri: string;
+  getContents: () => Promise<string>;
+}

package/src/types/index.ts

@@ -1,2 +1,3 @@
 export type { AnnotatedFunctionArgument } from "./annotated-function";
 export type { AnnotatedFunction } from "./annotated-function";
+export type { DocumentPointer } from "./document-pointer";