@copilotkit/react-core 0.21.0-mme-assistant-api.0 → 0.21.0-mme-function-call-labels.2

package/dist/types/frontend-action.js

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types/frontend-action.ts
+var frontend_action_exports = {};
+module.exports = __toCommonJS(frontend_action_exports);
+//# sourceMappingURL=frontend-action.js.map

package/dist/types/frontend-action.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/frontend-action.ts"],"sourcesContent":["import { Action, Parameter, MappedParameterTypes } from \"@copilotkit/shared\";\nimport React from \"react\";\n\ninterface InProgressState<T extends Parameter[] | [] = []> {\n  status: \"inProgress\";\n  args: Partial<MappedParameterTypes<T>>;\n  result: undefined;\n}\n\ninterface ExecutingState<T extends Parameter[] | [] = []> {\n  status: \"executing\";\n  args: MappedParameterTypes<T>;\n  result: undefined;\n}\n\ninterface CompleteState<T extends Parameter[] | [] = []> {\n  status: \"complete\";\n  args: MappedParameterTypes<T>;\n  result: any;\n}\n\ninterface InProgressStateNoArgs<T extends Parameter[] | [] = []> {\n  status: \"inProgress\";\n  args: Partial<MappedParameterTypes<T>>;\n  result: undefined;\n}\n\ninterface ExecutingStateNoArgs<T extends Parameter[] | [] = []> {\n  status: \"executing\";\n  args: MappedParameterTypes<T>;\n  result: undefined;\n}\n\ninterface CompleteStateNoArgs<T extends Parameter[] | [] = []> {\n  status: \"complete\";\n  args: MappedParameterTypes<T>;\n  result: any;\n}\n\nexport type ActionRenderProps<T extends Parameter[] | [] = []> =\n  | CompleteState<T>\n  | ExecutingState<T>\n  | InProgressState<T>;\n\nexport type ActionRenderPropsNoArgs<T extends Parameter[] | [] = []> =\n  | CompleteStateNoArgs<T>\n  | ExecutingStateNoArgs<T>\n  | InProgressStateNoArgs<T>;\n\nexport type FrontendAction<T extends Parameter[] | [] = []> = Action<T> & {\n  render?:\n    | string\n    | (T extends []\n        ? (props: ActionRenderPropsNoArgs<T>) => string | React.ReactElement\n        : (props: ActionRenderProps<T>) => string | React.ReactElement);\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/types/frontend-action.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=frontend-action.mjs.map

package/dist/types/frontend-action.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/utils/fetch-chat-completion.d.ts

@@ -1,5 +1,6 @@
 import { Message, ToolDefinition, ChatCompletionEvent } from '@copilotkit/shared';
 import { CopilotApiConfig } from '../context/copilot-context.js';
+import '../types/frontend-action.js';
 import 'react';
 import '../hooks/use-tree.js';
 import '../types/document-pointer.js';

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.21.0-mme-assistant-api.0",
+  "version": "0.21.0-mme-function-call-labels.2",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -19,18 +19,19 @@
   "devDependencies": {
     "@types/jest": "^29.5.4",
     "@types/react": "^18.2.5",
-    "eslint": "^7.32.0",
+    "eslint": "^8.56.0",
     "jest": "^29.6.4",
     "react": "^18.2.0",
     "ts-jest": "^29.1.1",
     "tsup": "^6.7.0",
-    "typescript": "^5.1.3",
-    "eslint-config-custom": "0.6.0-mme-assistant-api.0",
-    "tsconfig": "0.10.0-mme-assistant-api.0"
+    "typescript": "^5.2.3",
+    "eslint-config-custom": "0.6.0-mme-function-call-labels.2",
+    "tsconfig": "0.10.0-mme-function-call-labels.2"
   },
   "dependencies": {
     "nanoid": "^4.0.2",
-    "@copilotkit/shared": "0.5.0-mme-assistant-api.0"
+    "untruncate-json": "^0.0.1",
+    "@copilotkit/shared": "0.5.0-mme-function-call-labels.2"
   },
   "scripts": {
     "build": "tsup --clean",

package/src/components/copilot-provider/copilotkit.tsx

@@ -1,15 +1,11 @@
 "use client";
 
-import { FunctionDefinition } from "@copilotkit/shared";
-import { useCallback, useState } from "react";
+import { Ref, useCallback, useRef, useState } from "react";
 import { CopilotContext, CopilotApiConfig } from "../../context/copilot-context";
 import useTree from "../../hooks/use-tree";
 import { DocumentPointer } from "../../types";
-import {
-  FunctionCallHandler,
-  AnnotatedFunction,
-  annotatedFunctionToChatCompletionFunction,
-} from "@copilotkit/shared";
+import { FunctionCallHandler, actionToChatCompletionFunction } from "@copilotkit/shared";
+import { FrontendAction } from "../../types/frontend-action";
 import useFlatCategoryStore from "../../hooks/use-flat-category-store";
 import { StandardCopilotApiConfig } from "./standard-copilot-api-config";
 import { CopilotKitProps } from "./copilotkit-props";
@@ -56,8 +52,8 @@ export function CopilotKit({ children, ...props }: CopilotKitProps) {
   // Compute all the functions and properties that we need to pass
   // to the CopilotContext.
 
-  const [entryPoints, setEntryPoints] = useState<Record<string, AnnotatedFunction<any[]>>>({});
-
+  const [entryPoints, setEntryPoints] = useState<Record<string, FrontendAction<any>>>({});
+  const chatComponentsCache = useRef<Record<string, Function | string>>({});
   const { addElement, removeElement, printTree } = useTree();
 
   const {
@@ -66,7 +62,7 @@ export function CopilotKit({ children, ...props }: CopilotKitProps) {
     allElements: allDocuments,
   } = useFlatCategoryStore<DocumentPointer>();
 
-  const setEntryPoint = useCallback((id: string, entryPoint: AnnotatedFunction<any[]>) => {
+  const setEntryPoint = useCallback((id: string, entryPoint: FrontendAction<any>) => {
     setEntryPoints((prevPoints) => {
       return {
         ...prevPoints,
@@ -117,14 +113,14 @@ export function CopilotKit({ children, ...props }: CopilotKitProps) {
   );
 
   const getChatCompletionFunctionDescriptions = useCallback(
-    (customEntryPoints?: Record<string, AnnotatedFunction<any[]>>) => {
+    (customEntryPoints?: Record<string, FrontendAction<any>>) => {
       return entryPointsToChatCompletionFunctions(Object.values(customEntryPoints || entryPoints));
     },
     [entryPoints],
   );
 
   const getFunctionCallHandler = useCallback(
-    (customEntryPoints?: Record<string, AnnotatedFunction<any[]>>) => {
+    (customEntryPoints?: Record<string, FrontendAction<any>>) => {
       return entryPointsToFunctionCallHandler(Object.values(customEntryPoints || entryPoints));
     },
     [entryPoints],
@@ -166,6 +162,7 @@ export function CopilotKit({ children, ...props }: CopilotKitProps) {
     <CopilotContext.Provider
       value={{
         entryPoints,
+        chatComponentsCache,
         getChatCompletionFunctionDescriptions,
         getFunctionCallHandler,
         setEntryPoint,
@@ -186,54 +183,24 @@ export function CopilotKit({ children, ...props }: CopilotKitProps) {
 
 export const defaultCopilotContextCategories = ["global"];
 
-function entryPointsToFunctionCallHandler(
-  entryPoints: AnnotatedFunction<any[]>[],
-): FunctionCallHandler {
+function entryPointsToChatCompletionFunctions(actions: FrontendAction<any>[]): ToolDefinition[] {
+  return actions.map(actionToChatCompletionFunction);
+}
+
+function entryPointsToFunctionCallHandler(actions: FrontendAction<any>[]): FunctionCallHandler {
   return async (chatMessages, functionCall) => {
-    let entrypointsByFunctionName: Record<string, AnnotatedFunction<any[]>> = {};
-    for (let entryPoint of entryPoints) {
-      entrypointsByFunctionName[entryPoint.name] = entryPoint;
+    let actionsByFunctionName: Record<string, FrontendAction<any>> = {};
+    for (let action of actions) {
+      actionsByFunctionName[action.name] = action;
     }
 
-    const entryPointFunction = entrypointsByFunctionName[functionCall.name || ""];
-    if (entryPointFunction) {
+    const action = actionsByFunctionName[functionCall.name || ""];
+    if (action) {
       let functionCallArguments: Record<string, any>[] = [];
       if (functionCall.arguments) {
         functionCallArguments = JSON.parse(functionCall.arguments);
       }
-
-      const paramsInCorrectOrder: any[] = [];
-      for (let arg of entryPointFunction.argumentAnnotations) {
-        paramsInCorrectOrder.push(
-          functionCallArguments[arg.name as keyof typeof functionCallArguments],
-        );
-      }
-
-      await entryPointFunction.implementation(...paramsInCorrectOrder);
-
-      // commented out becasue for now we don't want to return anything
-      // const result = await entryPointFunction.implementation(
-      //   ...parsedFunctionCallArguments
-      // );
-      // const functionResponse: ChatRequest = {
-      //   messages: [
-      //     ...chatMessages,
-      //     {
-      //       id: nanoid(),
-      //       name: functionCall.name,
-      //       role: 'function' as const,
-      //       content: JSON.stringify(result),
-      //     },
-      //   ],
-      // };
-
-      // return functionResponse;
+      return await action.handler(functionCallArguments);
     }
   };
 }
-
-function entryPointsToChatCompletionFunctions(
-  entryPoints: AnnotatedFunction<any[]>[],
-): ToolDefinition[] {
-  return entryPoints.map(annotatedFunctionToChatCompletionFunction);
-}

package/src/context/copilot-context.tsx

@@ -1,7 +1,8 @@
 "use client";
 
-import { FunctionCallHandler, AnnotatedFunction, ToolDefinition } from "@copilotkit/shared";
-import React from "react";
+import { FunctionCallHandler, ToolDefinition } from "@copilotkit/shared";
+import { FrontendAction } from "../types/frontend-action";
+import React, { Ref } from "react";
 import { TreeNodeId } from "../hooks/use-tree";
 import { DocumentPointer } from "../types";
 
@@ -58,14 +59,15 @@ export interface CopilotApiConfig {
 
 export interface CopilotContextParams {
   // function-calling
-  entryPoints: Record<string, AnnotatedFunction<any[]>>;
-  setEntryPoint: (id: string, entryPoint: AnnotatedFunction<any[]>) => void;
+  entryPoints: Record<string, FrontendAction<any>>;
+  setEntryPoint: (id: string, entryPoint: FrontendAction<any>) => void;
   removeEntryPoint: (id: string) => void;
+  chatComponentsCache: React.RefObject<Record<string, Function | string>>;
   getChatCompletionFunctionDescriptions: (
-    customEntryPoints?: Record<string, AnnotatedFunction<any[]>>,
+    customEntryPoints?: Record<string, FrontendAction<any>>,
   ) => ToolDefinition[];
   getFunctionCallHandler: (
-    customEntryPoints?: Record<string, AnnotatedFunction<any[]>>,
+    customEntryPoints?: Record<string, FrontendAction<any>>,
   ) => FunctionCallHandler;
 
   // text context
@@ -88,7 +90,7 @@ const emptyCopilotContext: CopilotContextParams = {
   removeEntryPoint: () => {},
   getChatCompletionFunctionDescriptions: () => returnAndThrowInDebug([]),
   getFunctionCallHandler: () => returnAndThrowInDebug(async () => {}),
-
+  chatComponentsCache: { current: {} },
   getContextString: (documents: DocumentPointer[], categories: string[]) =>
     returnAndThrowInDebug(""),
   addContext: () => "",

package/src/hooks/index.ts

@@ -3,6 +3,7 @@ export type { UseCopilotChatOptions } from "./use-copilot-chat";
 export type { UseCopilotChatReturn } from "./use-copilot-chat";
 
 export { useMakeCopilotActionable } from "./use-make-copilot-actionable";
+export { useCopilotAction } from "./use-copilot-action";
 export { useMakeCopilotReadable } from "./use-make-copilot-readable";
 export { useMakeCopilotDocumentReadable } from "./use-make-copilot-document-readable";
 export { type UseChatHelpers } from "./use-chat";

package/src/hooks/use-chat.ts

@@ -1,8 +1,16 @@
 import { useRef, useState } from "react";
-import { Message, ToolDefinition, FunctionCallHandler, encodeResult } from "@copilotkit/shared";
+import {
+  Message,
+  ToolDefinition,
+  FunctionCallHandler,
+  encodeResult,
+  FunctionCall,
+} from "@copilotkit/shared";
+
 import { nanoid } from "nanoid";
 import { fetchAndDecodeChatCompletion } from "../utils/fetch-chat-completion";
 import { CopilotApiConfig } from "../context";
+import untruncateJson from "untruncate-json";
 
 export type UseChatOptions = {
   /**
@@ -176,7 +184,7 @@ export function useChat(options: UseChatOptionsWithCopilotConfig): UseChatHelper
 
           // After receiving a result, feed back the new messages to GPT
           feedback = true;
-        } else if (value.type === "function") {
+        } else if (value.type === "function" || value.type === "partial") {
           // Create a new message if the previous one is not empty
           if (
             currentMessage.content != "" ||
@@ -191,36 +199,53 @@ export function useChat(options: UseChatOptionsWithCopilotConfig): UseChatHelper
             };
             newMessages.push(currentMessage);
           }
-          currentMessage.function_call = {
-            name: value.name,
-            arguments: JSON.stringify(value.arguments),
-            scope: value.scope,
-          };
+          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: any = {};
+            try {
+              partialArguments = JSON.parse(untruncateJson(value.arguments));
+            } catch (e) {}
+
+            currentMessage.partialFunctionCall = {
+              name: value.name,
+              arguments: partialArguments,
+            };
+          }
 
           newMessages[newMessages.length - 1] = currentMessage;
           setMessages([...messages, ...newMessages]);
 
-          // Execute the function call
-          try {
-            if (options.onFunctionCall && value.scope === "client") {
-              const result = await options.onFunctionCall(messages, currentMessage.function_call);
-
-              currentMessage = {
-                id: nanoid(),
-                role: "function",
-                content: encodeResult(result),
-                name: currentMessage.function_call!.name!,
-              };
-              newMessages.push(currentMessage);
-              setMessages([...messages, ...newMessages]);
-
-              // After a function call, feed back the new messages to GPT
-              feedback = true;
+          if (value.type === "function") {
+            // Execute the function call
+            try {
+              if (options.onFunctionCall && value.scope === "client") {
+                const result = await options.onFunctionCall(
+                  messages,
+                  currentMessage.function_call as FunctionCall,
+                );
+
+                currentMessage = {
+                  id: nanoid(),
+                  role: "function",
+                  content: encodeResult(result),
+                  name: (currentMessage.function_call! as FunctionCall).name!,
+                };
+                newMessages.push(currentMessage);
+                setMessages([...messages, ...newMessages]);
+
+                // After a function call, feed back the new messages to GPT
+                feedback = true;
+              }
+            } catch (error) {
+              console.error("Failed to execute function call", error);
+              // TODO: Handle error
+              // this should go to the message itself
             }
-          } catch (error) {
-            console.error("Failed to execute function call", error);
-            // TODO: Handle error
-            // this should go to the message itself
           }
         }
       }

package/src/hooks/use-copilot-action-implementation.ts

@@ -0,0 +1,114 @@
+"use client";
+
+import { AnnotatedFunction, Parameter } from "@copilotkit/shared";
+import { useRef, useContext, useEffect } from "react";
+import { FrontendAction } from "../types/frontend-action";
+import { CopilotContext } from "../context/copilot-context";
+import { nanoid } from "nanoid";
+
+// We implement useCopilotActionImplementation dependency handling so that
+// the developer has the option to not provide any dependencies.
+// In this case, we assume they want to update the handler on each rerender.
+// To avoid getting stuck in an infinite loop, we update the handler directly,
+// skipping React state updates.
+// This is ok in this case, because the handler is not part of any UI that
+// needs to be updated.
+// useCallback, useMemo or other memoization techniques are not suitable here,
+// because they will cause a infinite rerender loop.
+export function useCopilotActionImplementation<T extends Array<any> = []>(
+  action: FrontendAction<T>,
+  dependencies?: any[],
+): void {
+  const { setEntryPoint, removeEntryPoint, entryPoints, chatComponentsCache } =
+    useContext(CopilotContext);
+  const idRef = useRef<string>(nanoid());
+
+  // If the developer doesn't provide dependencies, we assume they want to
+  // update handler and render function when the action object changes.
+  // This ensures that any captured variables in the handler are up to date.
+  if (dependencies === undefined) {
+    if (entryPoints[idRef.current]) {
+      entryPoints[idRef.current].handler = action.handler;
+      if (typeof action.render === "function") {
+        if (chatComponentsCache.current !== null) {
+          chatComponentsCache.current[action.name] = action.render;
+        }
+      }
+    }
+  }
+
+  useEffect(() => {
+    setEntryPoint(idRef.current, action);
+    if (chatComponentsCache.current !== null && action.render !== undefined) {
+      chatComponentsCache.current[action.name] = action.render;
+    }
+    return () => {
+      // NOTE: For now, we don't remove the chatComponentsCache entry when the action is removed.
+      // This is because we currently don't have access to the messages array in CopilotContext.
+      removeEntryPoint(idRef.current);
+    };
+  }, [
+    setEntryPoint,
+    removeEntryPoint,
+    action.description,
+    action.name,
+    // This should be faster than deep equality checking
+    // In addition, all major JS engines guarantee the order of object keys
+    JSON.stringify(action.parameters),
+    // include render only if it's a string
+    typeof action.render === "string" ? action.render : undefined,
+    // dependencies set by the developer
+    ...(dependencies || []),
+  ]);
+}
+
+export function annotatedFunctionToAction(
+  annotatedFunction: AnnotatedFunction<any[]>,
+): FrontendAction<any> {
+  const parameters: Parameter[] = annotatedFunction.argumentAnnotations.map((annotation) => {
+    switch (annotation.type) {
+      case "string":
+      case "number":
+      case "boolean":
+      case "object":
+        return {
+          name: annotation.name,
+          description: annotation.description,
+          type: annotation.type,
+          required: annotation.required,
+        };
+      case "array":
+        let type;
+        if (annotation.items.type === "string") {
+          type = "string[]";
+        } else if (annotation.items.type === "number") {
+          type = "number[]";
+        } else if (annotation.items.type === "boolean") {
+          type = "boolean[]";
+        } else if (annotation.items.type === "object") {
+          type = "object[]";
+        } else {
+          type = "string[]";
+        }
+        return {
+          name: annotation.name,
+          description: annotation.description,
+          type: type as any,
+          required: annotation.required,
+        };
+    }
+  });
+
+  return {
+    name: annotatedFunction.name,
+    description: annotatedFunction.description,
+    parameters: parameters,
+    handler: (args) => {
+      const paramsInCorrectOrder: any[] = [];
+      for (let arg of annotatedFunction.argumentAnnotations) {
+        paramsInCorrectOrder.push(args[arg.name]);
+      }
+      return annotatedFunction.implementation(...paramsInCorrectOrder);
+    },
+  };
+}

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

@@ -0,0 +1,45 @@
+"use client";
+
+import { Parameter } from "@copilotkit/shared";
+import { FrontendAction } from "../types/frontend-action";
+import { useCopilotActionImplementation } from "./use-copilot-action-implementation";
+
+  // Prettier chokes on the `const` in the function signature
+  // To have the main implementation checked by prettier, we split 
+  // this into a separate file
+  // prettier-ignore
+export function useCopilotAction<const T extends Parameter[] | [] = []>(action: FrontendAction<T>, dependencies?: any[]): void {
+  return useCopilotActionImplementation(action, dependencies);
+}
+
+// Usage Example:
+// useCopilotAction({
+//   name: "myAction",
+//   parameters: [
+//     { name: "arg1", type: "string", enum: ["option1", "option2", "option3"], required: false },
+//     { name: "arg2", type: "number" },
+//     {
+//       name: "arg3",
+//       type: "object",
+//       attributes: [
+//         { name: "nestedArg1", type: "boolean" },
+//         { name: "xyz", required: false },
+//       ],
+//     },
+//     { name: "arg4", type: "number[]" },
+//   ],
+//   handler: ({ arg1, arg2, arg3, arg4 }) => {
+//     const x = arg3.nestedArg1;
+//     const z = arg3.xyz;
+//     console.log(arg1, arg2, arg3);
+//   },
+// });
+
+// useCopilotAction({
+//   name: "myAction",
+//   handler: () => {
+//     console.log("No parameters provided.");
+//   },
+// });
+
+// https://community.openai.com/t/function-call-complex-arrays-as-parameters/295648/3

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

@@ -61,7 +61,8 @@ export function useCopilotChat({
   });
 
   const visibleMessages = messages.filter(
-    (message) => message.role === "user" || message.role === "assistant",
+    (message) =>
+      message.role === "user" || message.role === "assistant" || message.role === "function",
   );
 
   return {

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

@@ -4,7 +4,11 @@ import { useRef, useContext, useEffect, useMemo } from "react";
 import { CopilotContext } from "../context/copilot-context";
 import { AnnotatedFunction } from "@copilotkit/shared";
 import { nanoid } from "nanoid";
+import { annotatedFunctionToAction } from "./use-copilot-action-implementation";
 
+/**
+ * @deprecated Use the useCopilotAction function instead.
+ */
 export function useMakeCopilotActionable<ActionInput extends any[]>(
   annotatedFunction: AnnotatedFunction<ActionInput>,
   dependencies: any[],
@@ -23,7 +27,8 @@ export function useMakeCopilotActionable<ActionInput extends any[]>(
   );
 
   useEffect(() => {
-    setEntryPoint(idRef.current, memoizedAnnotatedFunction as AnnotatedFunction<any[]>);
+    const action = annotatedFunctionToAction(memoizedAnnotatedFunction as AnnotatedFunction<any[]>);
+    setEntryPoint(idRef.current, action);
 
     return () => {
       removeEntryPoint(idRef.current);

package/src/lib/copilot-task.ts

@@ -1,4 +1,5 @@
-import { AnnotatedFunction, FunctionCall, Message } from "@copilotkit/shared";
+import { FunctionCall, Message } from "@copilotkit/shared";
+import { FrontendAction } from "../types/frontend-action";
 import { CopilotContextParams } from "../context";
 import { defaultCopilotContextCategories } from "../components";
 import { fetchAndDecodeChatCompletion } from "../utils/fetch-chat-completion";
@@ -11,7 +12,7 @@ export interface CopilotTaskConfig {
   /**
    * Action definitions to be sent to the API.
    */
-  actions?: AnnotatedFunction<any[]>[];
+  actions?: FrontendAction<any>[];
   /**
    * Whether to include the copilot readable context in the task.
    */
@@ -25,13 +26,13 @@ export interface CopilotTaskConfig {
 
 export class CopilotTask<T = any> {
   private instructions: string;
-  private functions: AnnotatedFunction<any[]>[];
+  private actions: FrontendAction<any>[];
   private includeCopilotReadable: boolean;
   private includeCopilotActionable: boolean;
 
   constructor(config: CopilotTaskConfig) {
     this.instructions = config.instructions;
-    this.functions = config.actions || [];
+    this.actions = config.actions || [];
     this.includeCopilotReadable = config.includeCopilotReadable || true;
     this.includeCopilotActionable = config.includeCopilotActionable || true;
   }
@@ -40,7 +41,7 @@ export class CopilotTask<T = any> {
     const entryPoints = this.includeCopilotActionable ? Object.assign({}, context.entryPoints) : {};
 
     // merge functions into entry points
-    for (const fn of this.functions) {
+    for (const fn of this.actions) {
       entryPoints[fn.name] = fn;
     }
 

package/src/types/frontend-action.ts

@@ -0,0 +1,56 @@
+import { Action, Parameter, MappedParameterTypes } from "@copilotkit/shared";
+import React from "react";
+
+interface InProgressState<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  result: undefined;
+}
+
+interface ExecutingState<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  result: undefined;
+}
+
+interface CompleteState<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  result: any;
+}
+
+interface InProgressStateNoArgs<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  result: undefined;
+}
+
+interface ExecutingStateNoArgs<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  result: undefined;
+}
+
+interface CompleteStateNoArgs<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  result: any;
+}
+
+export type ActionRenderProps<T extends Parameter[] | [] = []> =
+  | CompleteState<T>
+  | ExecutingState<T>
+  | InProgressState<T>;
+
+export type ActionRenderPropsNoArgs<T extends Parameter[] | [] = []> =
+  | CompleteStateNoArgs<T>
+  | ExecutingStateNoArgs<T>
+  | InProgressStateNoArgs<T>;
+
+export type FrontendAction<T extends Parameter[] | [] = []> = Action<T> & {
+  render?:
+    | string
+    | (T extends []
+        ? (props: ActionRenderPropsNoArgs<T>) => string | React.ReactElement
+        : (props: ActionRenderProps<T>) => string | React.ReactElement);
+};