@copilotkit/react-core 0.3.0 → 0.4.0

package/src/context/copilot-context.tsx

@@ -1,33 +1,33 @@
-'use client'
+"use client";
 
-import React from 'react'
-import { AnnotatedFunction } from '../types/annotated-function'
-import { TreeNodeId } from '../hooks/use-tree'
-import { ChatCompletionFunctions } from 'openai-edge/types/api'
-import { FunctionCallHandler } from 'ai'
+import React from "react";
+import { AnnotatedFunction } from "../types/annotated-function";
+import { TreeNodeId } from "../hooks/use-tree";
+import { ChatCompletionFunctions } from "openai-edge/types/api";
+import { FunctionCallHandler } from "ai";
 
 export interface CopilotContextParams {
-  entryPoints: Record<string, AnnotatedFunction<any[]>>
-  getChatCompletionFunctions: () => ChatCompletionFunctions[]
-  getFunctionCallHandler: () => FunctionCallHandler
-  setEntryPoint: (id: string, entryPoint: AnnotatedFunction<any[]>) => void
-  removeEntryPoint: (id: string) => void
+  entryPoints: Record<string, AnnotatedFunction<any[]>>;
+  getChatCompletionFunctionDescriptions: () => ChatCompletionFunctions[];
+  getFunctionCallHandler: () => FunctionCallHandler;
+  setEntryPoint: (id: string, entryPoint: AnnotatedFunction<any[]>) => void;
+  removeEntryPoint: (id: string) => void;
 
-  getContextString: () => string
-  addContext: (context: string, parentId?: string) => TreeNodeId
-  removeContext: (id: TreeNodeId) => void
+  getContextString: () => string;
+  addContext: (context: string, parentId?: string) => TreeNodeId;
+  removeContext: (id: TreeNodeId) => void;
 }
 
 const emptyCopilotContext: CopilotContextParams = {
   entryPoints: {},
-  getChatCompletionFunctions: () => [],
+  getChatCompletionFunctionDescriptions: () => [],
   getFunctionCallHandler: () => async () => {},
   setEntryPoint: () => {},
   removeEntryPoint: () => {},
-  getContextString: () => '',
-  addContext: () => '',
-  removeContext: () => {}
-}
+  getContextString: () => "",
+  addContext: () => "",
+  removeContext: () => {},
+};
 
 export const CopilotContext =
-  React.createContext<CopilotContextParams>(emptyCopilotContext)
+  React.createContext<CopilotContextParams>(emptyCopilotContext);

package/src/context/index.ts

@@ -1,2 +1,2 @@
-export { CopilotContext } from './copilot-context'
-export type { CopilotContextParams } from './copilot-context'
+export { CopilotContext } from "./copilot-context";
+export type { CopilotContextParams } from "./copilot-context";

package/src/hooks/index.ts

@@ -1,6 +1,6 @@
-export { useCopilotChat } from './use-copilot-chat'
-export type { UseCopilotChatOptions } from './use-copilot-chat'
-export type { UseCopilotChatReturn } from './use-copilot-chat'
+export { useCopilotChat } from "./use-copilot-chat";
+export type { UseCopilotChatOptions } from "./use-copilot-chat";
+export type { UseCopilotChatReturn } from "./use-copilot-chat";
 
-export { useMakeCopilotActionable } from './use-make-copilot-actionable'
-export { useMakeCopilotReadable } from './use-make-copilot-readable'
+export { useMakeCopilotActionable } from "./use-make-copilot-actionable";
+export { useMakeCopilotReadable } from "./use-make-copilot-readable";

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

@@ -1,29 +1,29 @@
-import { useMemo, useContext } from 'react'
+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'
+  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
+  makeSystemMessage?: (contextString: string) => string;
 }
 
 export interface UseCopilotChatReturn {
-  visibleMessages: Message[]
+  visibleMessages: Message[];
   append: (
     message: Message | CreateMessage,
     chatRequestOptions?: ChatRequestOptions
-  ) => Promise<string | null | undefined>
+  ) => Promise<string | null | undefined>;
   reload: (
     chatRequestOptions?: ChatRequestOptions
-  ) => Promise<string | null | undefined>
-  stop: () => void
-  isLoading: boolean
-  input: string
-  setInput: React.Dispatch<React.SetStateAction<string>>
+  ) => Promise<string | null | undefined>;
+  stop: () => void;
+  isLoading: boolean;
+  input: string;
+  setInput: React.Dispatch<React.SetStateAction<string>>;
 }
 
 export function useCopilotChat({
@@ -32,28 +32,28 @@ export function useCopilotChat({
 }: UseCopilotChatOptions): UseCopilotChatReturn {
   const {
     getContextString,
-    getChatCompletionFunctions,
-    getFunctionCallHandler
-  } = useContext(CopilotContext)
+    getChatCompletionFunctionDescriptions,
+    getFunctionCallHandler,
+  } = useContext(CopilotContext);
 
   const systemMessage: Message = useMemo(() => {
-    const systemMessageMaker = makeSystemMessage || defaultSystemMessage
-    const contextString = getContextString()
+    const systemMessageMaker = makeSystemMessage || defaultSystemMessage;
+    const contextString = getContextString();
 
     return {
-      id: 'system',
+      id: "system",
       content: systemMessageMaker(contextString),
-      role: 'system'
-    }
-  }, [getContextString, makeSystemMessage])
+      role: "system",
+    };
+  }, [getContextString, makeSystemMessage]);
 
   const initialMessagesWithContext = [systemMessage].concat(
     options.initialMessages || []
-  )
+  );
 
-  const functions = useMemo(() => {
-    return getChatCompletionFunctions()
-  }, [getChatCompletionFunctions])
+  const functionDescriptions = useMemo(() => {
+    return getChatCompletionFunctionDescriptions();
+  }, [getChatCompletionFunctionDescriptions]);
 
   const { messages, append, reload, stop, isLoading, input, setInput } =
     useChat({
@@ -63,13 +63,13 @@ export function useCopilotChat({
       body: {
         id: options.id,
         previewToken,
-        functions
-      }
-    })
+        copilotkit_manually_passed_function_descriptions: functionDescriptions,
+      },
+    });
 
   const visibleMessages = messages.filter(
-    message => message.role === 'user' || message.role === 'assistant'
-  )
+    (message) => message.role === "user" || message.role === "assistant"
+  );
 
   return {
     visibleMessages,
@@ -78,16 +78,17 @@ export function useCopilotChat({
     stop,
     isLoading,
     input,
-    setInput
-  }
+    setInput,
+  };
 }
 
-const previewToken = 'TODO123'
+const previewToken = "TODO123";
 
 export function defaultSystemMessage(contextString: string): string {
   return `
-Please act as a efficient, competent, and conscientious professional assistant.
-You 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.
+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:
@@ -98,6 +99,9 @@ ${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.
-If you are not sure how to proceed to best fulfill their requests, please ask them for more information.
-`
+
+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

@@ -1,35 +1,35 @@
-'use client'
+"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'
+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 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
+      implementation: annotatedFunction.implementation,
     }),
     dependencies
-  )
+  );
 
   useEffect(() => {
     setEntryPoint(
       idRef.current,
       memoizedAnnotatedFunction as AnnotatedFunction<any[]>
-    )
+    );
 
     return () => {
-      removeEntryPoint(idRef.current)
-    }
-  }, [memoizedAnnotatedFunction, setEntryPoint, removeEntryPoint])
+      removeEntryPoint(idRef.current);
+    };
+  }, [memoizedAnnotatedFunction, setEntryPoint, removeEntryPoint]);
 }

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

@@ -1,23 +1,23 @@
-'use client'
+"use client";
 
-import { useRef, useContext, useEffect } from 'react'
-import { CopilotContext } from '../context/copilot-context'
+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>()
+  const { addContext, removeContext } = useContext(CopilotContext);
+  const idRef = useRef<string>();
 
   useEffect(() => {
-    const id = addContext(information, parentId)
-    idRef.current = id
+    const id = addContext(information, parentId);
+    idRef.current = id;
 
     return () => {
-      removeContext(id)
-    }
-  }, [information, parentId, addContext, removeContext])
+      removeContext(id);
+    };
+  }, [information, parentId, addContext, removeContext]);
 
-  return idRef.current
+  return idRef.current;
 }

package/src/hooks/use-tree.ts

@@ -1,79 +1,97 @@
-import { nanoid } from 'nanoid'
-import { useReducer, useCallback } from 'react'
+import { nanoid } from "nanoid";
+import { useReducer, useCallback } from "react";
 
-export type TreeNodeId = string
+export type TreeNodeId = string;
 
 export interface TreeNode {
-  id: TreeNodeId
-  value: string
-  children: TreeNode[]
-  parentId?: TreeNodeId
+  id: TreeNodeId;
+  value: string;
+  children: TreeNode[];
+  parentId?: TreeNodeId;
 }
 
-export type Tree = TreeNode[]
+export type Tree = TreeNode[];
 
 export interface UseTreeReturn {
-  tree: Tree
-  addElement: (value: string, parentId?: TreeNodeId) => TreeNodeId
-  printTree: () => string
-  removeElement: (id: TreeNodeId) => void
+  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
+      return node;
     }
-    const result = findNode(node.children, id)
+    const result = findNode(node.children, id);
     if (result) {
-      return result
+      return result;
     }
   }
-  return undefined
-}
+  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)
+      const newNode = { ...node, children: removeNode(node.children, id) };
+      result.push(newNode);
     }
-    return result
-  }, [])
-}
+    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()
+    return (index + 1).toString();
   } else if (indentLevel === 1) {
-    return String.fromCharCode(65 + index) // 65 is the ASCII value for 'A'
+    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'
+    return String.fromCharCode(97 + index); // 97 is the ASCII value for 'a'
   } else {
-    throw new Error('Indentation level not supported')
+    throw new Error("Indentation level not supported");
   }
-}
+};
 
-const printNode = (node: TreeNode, prefix = '', indentLevel = 0): string => {
-  const indent = ' '.repeat(3).repeat(indentLevel)
+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 prefixPlusIndentLength = prefix.length + indent.length;
+  const subsequentLinesPrefix = " ".repeat(prefixPlusIndentLength);
 
-  const valueLines = node.value.split('\n')
+  const valueLines = node.value.split("\n");
 
-  const outputFirstLine = `${indent}${prefix}${valueLines[0]}`
+  const outputFirstLine = `${indent}${prefix}${valueLines[0]}`;
   const outputSubsequentLines = valueLines
     .slice(1)
-    .map(line => `${subsequentLinesPrefix}${line}`)
-    .join('\n')
+    .map((line) => `${subsequentLinesPrefix}${line}`)
+    .join("\n");
 
-  let output = `${outputFirstLine}\n`
+  let output = `${outputFirstLine}\n`;
   if (outputSubsequentLines) {
-    output += `${outputSubsequentLines}\n`
+    output += `${outputSubsequentLines}\n`;
   }
 
   node.children.forEach(
@@ -83,77 +101,70 @@ const printNode = (node: TreeNode, prefix = '', indentLevel = 0): string => {
         `${prefix}${treeIndentationRepresentation(index, indentLevel + 1)}. `,
         indentLevel + 1
       ))
-  )
-  return output
-}
+  );
+  return output;
+};
 
 // Action types
 type Action =
-  | { type: 'ADD_NODE'; value: string; parentId?: string; id: string }
-  | { type: 'REMOVE_NODE'; id: string }
+  | { 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
+    case "ADD_NODE": {
+      const { value, parentId, id: newNodeId } = action;
       const newNode: TreeNode = {
         id: newNodeId,
         value,
-        children: []
-      }
-
-      if (parentId) {
-        const parent = findNode(state, parentId)
-        if (parent) {
-          newNode.parentId = parentId
-          parent.children.push(newNode)
-        } else {
-          throw new Error(`Parent with id ${parentId} not found`)
-        }
-      } else {
-        return [...state, newNode]
+        children: [],
+      };
+
+      try {
+        return addNode(state, newNode, parentId);
+      } catch (error) {
+        console.error(`Error while adding node with id ${newNodeId}: ${error}`);
+        return state;
       }
-
-      return state
     }
-    case 'REMOVE_NODE':
-      return removeNode(state, action.id)
+    case "REMOVE_NODE":
+      return removeNode(state, action.id);
     default:
-      return state
+      return state;
   }
 }
 
 // useTree hook
 const useTree = (): UseTreeReturn => {
-  const [tree, dispatch] = useReducer(treeReducer, [])
+  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 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 })
-  }, [])
+    dispatch({ type: "REMOVE_NODE", id });
+  }, []);
 
   const printTree = (): string => {
-    let output = ''
+    let output = "";
     tree.forEach(
       (node, index) =>
         (output += printNode(
           node,
           `${treeIndentationRepresentation(index, 0)}. `
         ))
-    )
-    return output
-  }
+    );
+    return output;
+  };
 
-  return { tree, addElement, printTree, removeElement }
-}
+  return { tree, addElement, printTree, removeElement };
+};
 
-export default useTree
+export default useTree;

package/src/index.tsx

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

package/src/types/annotated-function.ts

@@ -1,14 +1,27 @@
-export interface AnnotatedFunctionArgument {
-  name: string
-  type: string
-  description: string
-  allowedValues?: any[]
-  required: boolean
+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>
+  name: string;
+  description: string;
+  argumentAnnotations: AnnotatedFunctionArgument[];
+  implementation: (...args: Inputs) => Promise<void>;
 }

package/src/types/index.ts

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

package/tsup.config.ts

@@ -1,14 +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/index.js

@@ -1,32 +0,0 @@
-'use strict';
-
-var V = require('react');
-var nanoid = require('nanoid');
-var jsxRuntime = require('react/jsx-runtime');
-var react = require('ai/react');
-
-var k=Object.defineProperty,q=Object.defineProperties;var U=Object.getOwnPropertyDescriptors;var x=Object.getOwnPropertySymbols;var P=Object.prototype.hasOwnProperty,A=Object.prototype.propertyIsEnumerable;var N=(e,t,n)=>t in e?k(e,t,{enumerable:!0,configurable:!0,writable:!0,value:n}):e[t]=n,h=(e,t)=>{for(var n in t||(t={}))P.call(t,n)&&N(e,n,t[n]);if(x)for(var n of x(t))A.call(t,n)&&N(e,n,t[n]);return e},T=(e,t)=>q(e,U(t));var E=(e,t)=>{var n={};for(var o in e)P.call(e,o)&&t.indexOf(o)<0&&(n[o]=e[o]);if(e!=null&&x)for(var o of x(e))t.indexOf(o)<0&&A.call(e,o)&&(n[o]=e[o]);return n};var v=(e,t,n)=>new Promise((o,r)=>{var i=u=>{try{a(n.next(u));}catch(c){r(c);}},s=u=>{try{a(n.throw(u));}catch(c){r(c);}},a=u=>u.done?o(u.value):Promise.resolve(u.value).then(i,s);a((n=n.apply(e,t)).next());});var I=(e,t)=>{for(let n of e){if(n.id===t)return n;let o=I(n.children,t);if(o)return o}},M=(e,t)=>e.reduce((n,o)=>{if(o.id!==t){let r=T(h({},o),{children:M(o.children,t)});n.push(r);}return n},[]),b=(e,t)=>{if(t===0)return (e+1).toString();if(t===1)return String.fromCharCode(65+e);if(t===2)return String.fromCharCode(97+e);throw new Error("Indentation level not supported")},O=(e,t="",n=0)=>{let o=" ".repeat(3).repeat(n),r=t.length+o.length,i=" ".repeat(r),s=e.value.split(`
-`),a=`${o}${t}${s[0]}`,u=s.slice(1).map(l=>`${i}${l}`).join(`
-`),c=`${a}
-`;return u&&(c+=`${u}
-`),e.children.forEach((l,g)=>c+=O(l,`${t}${b(g,n+1)}. `,n+1)),c};function j(e,t){switch(t.type){case"ADD_NODE":{let{value:n,parentId:o,id:r}=t,i={id:r,value:n,children:[]};if(o){let s=I(e,o);if(s)i.parentId=o,s.children.push(i);else throw new Error(`Parent with id ${o} not found`)}else return [...e,i];return e}case"REMOVE_NODE":return M(e,t.id);default:return e}}var L=()=>{let[e,t]=V.useReducer(j,[]),n=V.useCallback((i,s)=>{let a=nanoid.nanoid();return t({type:"ADD_NODE",value:i,parentId:s,id:a}),a},[]),o=V.useCallback(i=>{t({type:"REMOVE_NODE",id:i});},[]);return {tree:e,addElement:n,printTree:()=>{let i="";return e.forEach((s,a)=>i+=O(s,`${b(a,0)}. `)),i},removeElement:o}},w=L;var J={entryPoints:{},getChatCompletionFunctions:()=>[],getFunctionCallHandler:()=>()=>v(void 0,null,function*(){}),setEntryPoint:()=>{},removeEntryPoint:()=>{},getContextString:()=>"",addContext:()=>"",removeContext:()=>{}},d=V.createContext(J);function B({children:e}){let[t,n]=V.useState({}),{addElement:o,removeElement:r,printTree:i}=w(),s=V.useCallback((p,m)=>{n(C=>T(h({},C),{[p]:m}));},[]),a=V.useCallback(p=>{n(m=>{let C=h({},m);return delete C[p],C});},[]),u=V.useCallback(()=>i(),[i]),c=V.useCallback((p,m)=>o(p,m),[o]),l=V.useCallback(p=>{r(p);},[r]),g=V.useCallback(()=>X(Object.values(t)),[t]),F=V.useCallback(()=>W(Object.values(t)),[t]);return jsxRuntime.jsx(d.Provider,{value:{entryPoints:t,getChatCompletionFunctions:g,getFunctionCallHandler:F,setEntryPoint:s,removeEntryPoint:a,getContextString:u,addContext:c,removeContext:l},children:e})}function W(e){return (t,n)=>v(this,null,function*(){let o={};for(let i of e)o[i.name]=i;let r=o[n.name||""];if(r){let i=[];n.arguments&&(i=JSON.parse(n.arguments));let s=[];for(let a of r.argumentAnnotations)s.push(i[a.name]);yield r.implementation(...s);}})}function X(e){return e.map(Y)}function Y(e){let t={};for(let r of e.argumentAnnotations)t[r.name]={type:r.type,description:r.description};let n=[];for(let r of e.argumentAnnotations)r.required&&n.push(r.name);return {name:e.name,description:e.description,parameters:{type:"object",properties:t,required:n}}}function Z(n){var o=n,{makeSystemMessage:e}=o,t=E(o,["makeSystemMessage"]);let{getContextString:r,getChatCompletionFunctions:i,getFunctionCallHandler:s}=V.useContext(d),u=[V.useMemo(()=>{let y=e||te,$=r();return {id:"system",content:y($),role:"system"}},[r,e])].concat(t.initialMessages||[]),c=V.useMemo(()=>i(),[i]),{messages:l,append:g,reload:F,stop:p,isLoading:m,input:C,setInput:D}=react.useChat({id:t.id,initialMessages:u,experimental_onFunctionCall:s(),body:{id:t.id,previewToken:ee,functions:c}});return {visibleMessages:l.filter(y=>y.role==="user"||y.role==="assistant"),append:g,reload:F,stop:p,isLoading:m,input:C,setInput:D}}var ee="TODO123";function te(e){return `
-Please act as a efficient, competent, and conscientious professional assistant.
-You 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:
-\`\`\`
-${e}
-\`\`\`
-
-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.
-If you are not sure how to proceed to best fulfill their requests, please ask them for more information.
-`}function ae(e,t){let n=V.useRef(nanoid.nanoid()),{setEntryPoint:o,removeEntryPoint:r}=V.useContext(d),i=V.useMemo(()=>({name:e.name,description:e.description,argumentAnnotations:e.argumentAnnotations,implementation:e.implementation}),t);V.useEffect(()=>(o(n.current,i),()=>{r(n.current);}),[i,o,r]);}function de(e,t){let{addContext:n,removeContext:o}=V.useContext(d),r=V.useRef();return V.useEffect(()=>{let i=n(e,t);return r.current=i,()=>{o(i);}},[e,t,n,o]),r.current}
-
-exports.CopilotContext = d;
-exports.CopilotProvider = B;
-exports.useCopilotChat = Z;
-exports.useMakeCopilotActionable = ae;
-exports.useMakeCopilotReadable = de;