@copilotkit/react-core 0.2.0 → 0.4.0

package/src/hooks/use-copilot-chat.ts

@@ -0,0 +1,107 @@
+import { useMemo, useContext } from "react";
+import {
+  CopilotContext,
+  CopilotContextParams,
+} from "../context/copilot-context";
+import { useChat } from "ai/react";
+import { ChatRequestOptions, CreateMessage, Message } from "ai";
+import { UseChatOptions } from "ai";
+
+export interface UseCopilotChatOptions extends UseChatOptions {
+  makeSystemMessage?: (contextString: string) => string;
+}
+
+export interface UseCopilotChatReturn {
+  visibleMessages: Message[];
+  append: (
+    message: Message | CreateMessage,
+    chatRequestOptions?: ChatRequestOptions
+  ) => Promise<string | null | undefined>;
+  reload: (
+    chatRequestOptions?: ChatRequestOptions
+  ) => Promise<string | null | undefined>;
+  stop: () => void;
+  isLoading: boolean;
+  input: string;
+  setInput: React.Dispatch<React.SetStateAction<string>>;
+}
+
+export function useCopilotChat({
+  makeSystemMessage,
+  ...options
+}: UseCopilotChatOptions): UseCopilotChatReturn {
+  const {
+    getContextString,
+    getChatCompletionFunctionDescriptions,
+    getFunctionCallHandler,
+  } = useContext(CopilotContext);
+
+  const systemMessage: Message = useMemo(() => {
+    const systemMessageMaker = makeSystemMessage || defaultSystemMessage;
+    const contextString = getContextString();
+
+    return {
+      id: "system",
+      content: systemMessageMaker(contextString),
+      role: "system",
+    };
+  }, [getContextString, makeSystemMessage]);
+
+  const initialMessagesWithContext = [systemMessage].concat(
+    options.initialMessages || []
+  );
+
+  const functionDescriptions = useMemo(() => {
+    return getChatCompletionFunctionDescriptions();
+  }, [getChatCompletionFunctionDescriptions]);
+
+  const { messages, append, reload, stop, isLoading, input, setInput } =
+    useChat({
+      id: options.id,
+      initialMessages: initialMessagesWithContext,
+      experimental_onFunctionCall: getFunctionCallHandler(),
+      body: {
+        id: options.id,
+        previewToken,
+        copilotkit_manually_passed_function_descriptions: functionDescriptions,
+      },
+    });
+
+  const visibleMessages = messages.filter(
+    (message) => message.role === "user" || message.role === "assistant"
+  );
+
+  return {
+    visibleMessages,
+    append,
+    reload,
+    stop,
+    isLoading,
+    input,
+    setInput,
+  };
+}
+
+const previewToken = "TODO123";
+
+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/hooks/use-make-copilot-actionable.ts

@@ -0,0 +1,35 @@
+"use client";
+
+import { useRef, useContext, useEffect, useMemo } from "react";
+import { CopilotContext } from "../context/copilot-context";
+import { AnnotatedFunction } from "../types/annotated-function";
+import { nanoid } from "nanoid";
+
+export function useMakeCopilotActionable<ActionInput extends any[]>(
+  annotatedFunction: AnnotatedFunction<ActionInput>,
+  dependencies: any[]
+) {
+  const idRef = useRef(nanoid()); // generate a unique id
+  const { setEntryPoint, removeEntryPoint } = useContext(CopilotContext);
+
+  const memoizedAnnotatedFunction: AnnotatedFunction<ActionInput> = useMemo(
+    () => ({
+      name: annotatedFunction.name,
+      description: annotatedFunction.description,
+      argumentAnnotations: annotatedFunction.argumentAnnotations,
+      implementation: annotatedFunction.implementation,
+    }),
+    dependencies
+  );
+
+  useEffect(() => {
+    setEntryPoint(
+      idRef.current,
+      memoizedAnnotatedFunction as AnnotatedFunction<any[]>
+    );
+
+    return () => {
+      removeEntryPoint(idRef.current);
+    };
+  }, [memoizedAnnotatedFunction, setEntryPoint, removeEntryPoint]);
+}

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

@@ -0,0 +1,23 @@
+"use client";
+
+import { useRef, useContext, useEffect } from "react";
+import { CopilotContext } from "../context/copilot-context";
+
+export function useMakeCopilotReadable(
+  information: string,
+  parentId?: string
+): string | undefined {
+  const { addContext, removeContext } = useContext(CopilotContext);
+  const idRef = useRef<string>();
+
+  useEffect(() => {
+    const id = addContext(information, parentId);
+    idRef.current = id;
+
+    return () => {
+      removeContext(id);
+    };
+  }, [information, parentId, addContext, removeContext]);
+
+  return idRef.current;
+}

package/src/hooks/use-tree.ts

@@ -0,0 +1,170 @@
+import { nanoid } from "nanoid";
+import { useReducer, useCallback } from "react";
+
+export type TreeNodeId = string;
+
+export interface TreeNode {
+  id: TreeNodeId;
+  value: string;
+  children: TreeNode[];
+  parentId?: TreeNodeId;
+}
+
+export type Tree = TreeNode[];
+
+export interface UseTreeReturn {
+  tree: Tree;
+  addElement: (value: string, parentId?: TreeNodeId) => TreeNodeId;
+  printTree: () => string;
+  removeElement: (id: TreeNodeId) => void;
+}
+
+const findNode = (nodes: Tree, id: TreeNodeId): TreeNode | undefined => {
+  for (const node of nodes) {
+    if (node.id === id) {
+      return node;
+    }
+    const result = findNode(node.children, id);
+    if (result) {
+      return result;
+    }
+  }
+  return undefined;
+};
+
+const removeNode = (nodes: Tree, id: TreeNodeId): Tree => {
+  return nodes.reduce((result: Tree, node) => {
+    if (node.id !== id) {
+      const newNode = { ...node, children: removeNode(node.children, id) };
+      result.push(newNode);
+    }
+    return result;
+  }, []);
+};
+
+const addNode = (
+  nodes: Tree,
+  newNode: TreeNode,
+  parentId?: TreeNodeId
+): Tree => {
+  if (!parentId) {
+    return [...nodes, newNode];
+  }
+  return nodes.map((node) => {
+    if (node.id === parentId) {
+      return { ...node, children: [...node.children, newNode] };
+    } else if (node.children.length) {
+      return { ...node, children: addNode(node.children, newNode, parentId) };
+    }
+    return node;
+  });
+};
+
+const treeIndentationRepresentation = (
+  index: number,
+  indentLevel: number
+): string => {
+  if (indentLevel === 0) {
+    return (index + 1).toString();
+  } else if (indentLevel === 1) {
+    return String.fromCharCode(65 + index); // 65 is the ASCII value for 'A'
+  } else if (indentLevel === 2) {
+    return String.fromCharCode(97 + index); // 97 is the ASCII value for 'a'
+  } else {
+    throw new Error("Indentation level not supported");
+  }
+};
+
+const printNode = (node: TreeNode, prefix = "", indentLevel = 0): string => {
+  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}\n`;
+  if (outputSubsequentLines) {
+    output += `${outputSubsequentLines}\n`;
+  }
+
+  node.children.forEach(
+    (child, index) =>
+      (output += printNode(
+        child,
+        `${prefix}${treeIndentationRepresentation(index, indentLevel + 1)}. `,
+        indentLevel + 1
+      ))
+  );
+  return output;
+};
+
+// Action types
+type Action =
+  | { type: "ADD_NODE"; value: string; parentId?: string; id: string }
+  | { type: "REMOVE_NODE"; id: string };
+
+// Reducer function
+function treeReducer(state: Tree, action: Action): Tree {
+  switch (action.type) {
+    case "ADD_NODE": {
+      const { value, parentId, id: newNodeId } = action;
+      const newNode: TreeNode = {
+        id: newNodeId,
+        value,
+        children: [],
+      };
+
+      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;
+  }
+}
+
+// useTree hook
+const useTree = (): UseTreeReturn => {
+  const [tree, dispatch] = useReducer(treeReducer, []);
+
+  const addElement = useCallback(
+    (value: string, parentId?: string): TreeNodeId => {
+      const newNodeId = nanoid(); // Generate new ID outside of dispatch
+      dispatch({ type: "ADD_NODE", value, parentId, id: newNodeId });
+      return newNodeId; // Return the new ID
+    },
+    []
+  );
+
+  const removeElement = useCallback((id: TreeNodeId): void => {
+    dispatch({ type: "REMOVE_NODE", id });
+  }, []);
+
+  const printTree = (): string => {
+    let output = "";
+    tree.forEach(
+      (node, index) =>
+        (output += printNode(
+          node,
+          `${treeIndentationRepresentation(index, 0)}. `
+        ))
+    );
+    return output;
+  };
+
+  return { tree, addElement, printTree, removeElement };
+};
+
+export default useTree;

package/src/index.tsx

@@ -1,2 +1,4 @@
-// components
-export * from "./hook";
+export * from "./components";
+export * from "./context";
+export * from "./hooks";
+export * from "./types";

package/src/types/annotated-function.ts

@@ -0,0 +1,27 @@
+export interface AnnotatedFunctionSimpleArgument {
+  name: string;
+  type: "string" | "number" | "boolean" | "object"; // Add or change types according to your needs.
+  description: string;
+  required: boolean;
+}
+
+export interface AnnotatedFunctionArrayArgument {
+  name: string;
+  type: "array";
+  items: {
+    type: string;
+  };
+  description: string;
+  required: boolean;
+}
+
+export type AnnotatedFunctionArgument =
+  | AnnotatedFunctionSimpleArgument
+  | AnnotatedFunctionArrayArgument;
+
+export interface AnnotatedFunction<Inputs extends any[]> {
+  name: string;
+  description: string;
+  argumentAnnotations: AnnotatedFunctionArgument[];
+  implementation: (...args: Inputs) => Promise<void>;
+}

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export type { AnnotatedFunctionArgument } from "./annotated-function";
+export type { AnnotatedFunction } from "./annotated-function";

package/tsup.config.ts

@@ -1,13 +1,12 @@
 import { defineConfig, Options } from "tsup";
 
 export default defineConfig((options: Options) => ({
-  treeshake: true,
-  splitting: true,
-  entry: ["src/**/*.tsx"],
+  entry: ["src/**/*.{ts,tsx}"],
   format: ["esm"],
   dts: true,
-  minify: true,
+  minify: false,
   clean: true,
   external: ["react"],
+  sourcemap: true,
   ...options,
 }));

package/dist/chunk-KFCOT2YX.js

@@ -1,26 +0,0 @@
-'use strict';
-
-var t = require('react');
-
-function _interopNamespaceDefault(e) {
-	var n = Object.create(null);
-	if (e) {
-		Object.keys(e).forEach(function (k) {
-			if (k !== 'default') {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () { return e[k]; }
-				});
-			}
-		});
-	}
-	n.default = e;
-	return Object.freeze(n);
-}
-
-var t__namespace = /*#__PURE__*/_interopNamespaceDefault(t);
-
-function u(){t__namespace.useState(0);}
-
-exports.a = u;

package/dist/hook.d.ts

@@ -1,3 +0,0 @@
-declare function useTurbo(): void;
-
-export { useTurbo };

package/dist/hook.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var chunkKFCOT2YX_js = require('./chunk-KFCOT2YX.js');
-
-
-
-Object.defineProperty(exports, 'useTurbo', {
-	enumerable: true,
-	get: function () { return chunkKFCOT2YX_js.a; }
-});

package/dist/index.js

@@ -1,10 +0,0 @@
-'use strict';
-
-var chunkKFCOT2YX_js = require('./chunk-KFCOT2YX.js');
-
-
-
-Object.defineProperty(exports, 'useTurbo', {
-	enumerable: true,
-	get: function () { return chunkKFCOT2YX_js.a; }
-});

package/src/hook.tsx

@@ -1,5 +0,0 @@
-import * as React from "react";
-
-export function useTurbo() {
-  const [num, setNum] = React.useState(0);
-}