@copilotkit/shared 0.4.1 → 0.5.0-atai-0301-OpenAIAdapaterGetter.3

package/dist/utils/utils.d.ts

@@ -36,14 +36,14 @@ type StreamPartValueType = {
 };
 type StreamPartType = ReturnType<typeof textStreamPart.parse> | ReturnType<typeof functionCallStreamPart.parse> | ReturnType<typeof dataStreamPart.parse> | ReturnType<typeof errorStreamPart.parse> | ReturnType<typeof assistantMessage.parse> | ReturnType<typeof assistantControlData.parse>;
 declare const streamPartsByCode: {
-    readonly 0: StreamPart<"0", "text", string>;
-    readonly 1: StreamPart<"1", "function_call", {
+    readonly "0": StreamPart<"0", "text", string>;
+    readonly "1": StreamPart<"1", "function_call", {
         function_call: FunctionCall;
     }>;
-    readonly 2: StreamPart<"2", "data", JSONValue[]>;
-    readonly 3: StreamPart<"3", "error", string>;
-    readonly 4: StreamPart<"4", "assistant_message", AssistantMessage>;
-    readonly 5: StreamPart<"5", "assistant_control_data", {
+    readonly "2": StreamPart<"2", "data", JSONValue[]>;
+    readonly "3": StreamPart<"3", "error", string>;
+    readonly "4": StreamPart<"4", "assistant_message", AssistantMessage>;
+    readonly "5": StreamPart<"5", "assistant_control_data", {
         threadId: string;
         messageId: string;
     }>;

package/package.json

@@ -4,7 +4,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.4.1",
+  "version": "0.5.0-atai-0301-OpenAIAdapaterGetter.3",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -16,13 +16,13 @@
   "peerDependencies": {},
   "devDependencies": {
     "@types/jest": "^29.5.4",
-    "eslint": "^7.32.0",
+    "eslint": "^8.56.0",
     "jest": "^29.6.4",
     "ts-jest": "^29.1.1",
     "tsup": "^6.7.0",
-    "typescript": "^5.1.3",
-    "eslint-config-custom": "0.5.1",
-    "tsconfig": "0.9.1"
+    "typescript": "^5.2.3",
+    "eslint-config-custom": "0.6.0-atai-0301-OpenAIAdapaterGetter.3",
+    "tsconfig": "0.10.0-atai-0301-OpenAIAdapaterGetter.3"
   },
   "dependencies": {},
   "scripts": {

package/src/types/action.ts

@@ -0,0 +1,71 @@
+type TypeMap = {
+  string: string;
+  number: number;
+  boolean: boolean;
+  object: object;
+  "string[]": string[];
+  "number[]": number[];
+  "boolean[]": boolean[];
+  "object[]": object[];
+};
+
+export type BaseParameter = {
+  name: string;
+  type?: Exclude<keyof TypeMap, "string" | "object" | "object[]">; // Exclude object types for BaseParameter
+  description?: string;
+  required?: boolean;
+};
+
+export type StringParameter = {
+  name: string;
+  type: "string";
+  description?: string;
+  required?: boolean;
+  enum?: string[];
+};
+
+export type ObjectParameter = {
+  name: string;
+  type: "object" | "object[]";
+  description?: string;
+  required?: boolean;
+  attributes?: Parameter[];
+};
+
+export type Parameter = BaseParameter | StringParameter | ObjectParameter;
+
+type MappedParameterTypes<T extends Parameter[]> = {
+  // Check if the parameter has an 'enum' defined
+  [P in T[number] as P["name"]]: P extends { enum: Array<infer E> }
+    ? E extends string // Ensure the enum values are strings
+      ? P["required"] extends false // Check if the parameter is optional
+        ? E | undefined // If so, include 'undefined' in the type
+        : E // Otherwise, use the enum type directly
+      : never // This case should not occur since 'enum' implies string values
+    : // Handle parameters defined as 'object' with specified attributes
+    P extends { type: "object"; attributes: infer Attributes }
+    ? Attributes extends Parameter[]
+      ? MappedParameterTypes<Attributes> // Recursively map the attributes of the object
+      : never // If 'attributes' is not an array of Parameters, this is invalid
+    : // Handle parameters defined as 'object[]' without specified attributes
+    P extends { type: "object[]"; attributes?: never }
+    ? any[] // Default to 'any[]' for arrays of objects without specific attributes
+    : // Handle parameters defined as 'object[]' with specified attributes
+    P extends { type: "object[]"; attributes: infer Attributes }
+    ? Attributes extends Parameter[]
+      ? MappedParameterTypes<Attributes>[] // Recursively map each object in the array
+      : any[] // Default to 'any[]' if attributes are not properly defined
+    : // Handle all other parameter types
+    P["required"] extends false
+    ? // Include 'undefined' for optional parameters
+      TypeMap[P["type"] extends keyof TypeMap ? P["type"] : "string"] | undefined
+    : // Use the direct mapping from 'TypeMap' for the parameter's type
+      TypeMap[P["type"] extends keyof TypeMap ? P["type"] : "string"];
+};
+
+export type Action<T extends Parameter[] | [] = []> = {
+  name: string;
+  description?: string;
+  parameters?: T;
+  handler: T extends [] ? () => void : (args: MappedParameterTypes<T>) => any | Promise<any>;
+};

package/src/types/index.ts

@@ -1,2 +1,3 @@
 export * from "./openai-assistant";
 export * from "./annotated-function";
+export * from "./action";

package/src/utils/annotated-function.ts

@@ -1,4 +1,4 @@
-import { AnnotatedFunction, FunctionDefinition, ToolDefinition } from "../types";
+import { Action, AnnotatedFunction, ToolDefinition, Parameter } from "../types";
 
 export function annotatedFunctionToChatCompletionFunction(
   annotatedFunction: AnnotatedFunction<any[]>,
@@ -34,3 +34,92 @@ export function annotatedFunctionToChatCompletionFunction(
 
   return chatCompletionFunction;
 }
+
+function convertAttribute(attribute: Parameter): any {
+  switch (attribute.type) {
+    case "string":
+      return {
+        type: "string",
+        description: attribute.description,
+        ...(attribute.enum && { enum: attribute.enum }),
+      };
+    case "number":
+    case "boolean":
+      return {
+        type: attribute.type,
+        description: attribute.description,
+      };
+    case "object":
+    case "object[]":
+      const properties = attribute.attributes?.reduce((acc, attr) => {
+        acc[attr.name] = convertAttribute(attr);
+        return acc;
+      }, {} as Record<string, any>);
+      const required = attribute.attributes
+        ?.filter((attr) => attr.required !== false)
+        .map((attr) => attr.name);
+      if (attribute.type === "object[]") {
+        return {
+          type: "array",
+          items: {
+            type: "object",
+            ...(properties && { properties }),
+            ...(required && required.length > 0 && { required }),
+          },
+          description: attribute.description,
+        };
+      }
+      return {
+        type: "object",
+        description: attribute.description,
+        ...(properties && { properties }),
+        ...(required && required.length > 0 && { required }),
+      };
+    default:
+      // Handle arrays of primitive types and undefined attribute.type
+      if (attribute.type?.endsWith("[]")) {
+        const itemType = attribute.type.slice(0, -2);
+        return {
+          type: "array",
+          items: { type: itemType },
+          description: attribute.description,
+        };
+      }
+      // Fallback for undefined type or any other unexpected type
+      return {
+        type: "string",
+        description: attribute.description,
+      };
+  }
+}
+
+export function actionToChatCompletionFunction(action: Action<any>): ToolDefinition {
+  // Create the parameters object based on the argumentAnnotations
+  let parameters: { [key: string]: any } = {};
+  for (let parameter of action.parameters || []) {
+    parameters[parameter.name] = convertAttribute(parameter);
+  }
+
+  let requiredParameterNames: string[] = [];
+  for (let arg of action.parameters || []) {
+    if (arg.required !== false) {
+      requiredParameterNames.push(arg.name);
+    }
+  }
+
+  // Create the ChatCompletionFunctions object
+  let chatCompletionFunction: ToolDefinition = {
+    type: "function",
+    function: {
+      name: action.name,
+      ...(action.description && { description: action.description }),
+      parameters: {
+        type: "object",
+        properties: parameters,
+        required: requiredParameterNames,
+      },
+    },
+  };
+
+  return chatCompletionFunction;
+}

package/src/utils/parse-chat-completion.ts

@@ -3,6 +3,7 @@ import { Role } from "../types/openai-assistant";
 export interface ChatCompletionChunk {
   choices: {
     delta: {
+      id?: string;
       role: Role;
       content?: string | null;
 

package/dist/chunk-FD6FGKYY.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-FD6FGKYY.mjs.map

package/dist/chunk-NSY3OEEP.mjs

@@ -1,32 +0,0 @@
-// src/utils/annotated-function.ts
-function annotatedFunctionToChatCompletionFunction(annotatedFunction) {
-  let parameters = {};
-  for (let arg of annotatedFunction.argumentAnnotations) {
-    let { name, required, ...forwardedArgs } = arg;
-    parameters[arg.name] = forwardedArgs;
-  }
-  let requiredParameterNames = [];
-  for (let arg of annotatedFunction.argumentAnnotations) {
-    if (arg.required) {
-      requiredParameterNames.push(arg.name);
-    }
-  }
-  let chatCompletionFunction = {
-    type: "function",
-    function: {
-      name: annotatedFunction.name,
-      description: annotatedFunction.description,
-      parameters: {
-        type: "object",
-        properties: parameters,
-        required: requiredParameterNames
-      }
-    }
-  };
-  return chatCompletionFunction;
-}
-
-export {
-  annotatedFunctionToChatCompletionFunction
-};
-//# sourceMappingURL=chunk-NSY3OEEP.mjs.map

package/dist/chunk-NSY3OEEP.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/annotated-function.ts"],"sourcesContent":["import { AnnotatedFunction, FunctionDefinition, ToolDefinition } from \"../types\";\n\nexport function annotatedFunctionToChatCompletionFunction(\n  annotatedFunction: AnnotatedFunction<any[]>,\n): ToolDefinition {\n  // Create the parameters object based on the argumentAnnotations\n  let parameters: { [key: string]: any } = {};\n  for (let arg of annotatedFunction.argumentAnnotations) {\n    // isolate the args we should forward inline\n    let { name, required, ...forwardedArgs } = arg;\n    parameters[arg.name] = forwardedArgs;\n  }\n\n  let requiredParameterNames: string[] = [];\n  for (let arg of annotatedFunction.argumentAnnotations) {\n    if (arg.required) {\n      requiredParameterNames.push(arg.name);\n    }\n  }\n\n  // Create the ChatCompletionFunctions object\n  let chatCompletionFunction: ToolDefinition = {\n    type: \"function\",\n    function: {\n      name: annotatedFunction.name,\n      description: annotatedFunction.description,\n      parameters: {\n        type: \"object\",\n        properties: parameters,\n        required: requiredParameterNames,\n      },\n    },\n  };\n\n  return chatCompletionFunction;\n}\n"],"mappings":";AAEO,SAAS,0CACd,mBACgB;AAEhB,MAAI,aAAqC,CAAC;AAC1C,WAAS,OAAO,kBAAkB,qBAAqB;AAErD,QAAI,EAAE,MAAM,UAAU,GAAG,cAAc,IAAI;AAC3C,eAAW,IAAI,IAAI,IAAI;AAAA,EACzB;AAEA,MAAI,yBAAmC,CAAC;AACxC,WAAS,OAAO,kBAAkB,qBAAqB;AACrD,QAAI,IAAI,UAAU;AAChB,6BAAuB,KAAK,IAAI,IAAI;AAAA,IACtC;AAAA,EACF;AAGA,MAAI,yBAAyC;AAAA,IAC3C,MAAM;AAAA,IACN,UAAU;AAAA,MACR,MAAM,kBAAkB;AAAA,MACxB,aAAa,kBAAkB;AAAA,MAC/B,YAAY;AAAA,QACV,MAAM;AAAA,QACN,YAAY;AAAA,QACZ,UAAU;AAAA,MACZ;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-T6YVHLB7.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils/parse-chat-completion.ts"],"sourcesContent":["import { Role } from \"../types/openai-assistant\";\n\nexport interface ChatCompletionChunk {\n  choices: {\n    delta: {\n      role: Role;\n      content?: string | null;\n\n      // TODO:\n      // Temporarily add name to the OpenAI protocol until we\n      // have our own protocol.\n      // When name is set, we return the result of a server-side\n      // function call.\n      name?: string;\n\n      function_call?: {\n        name?: string;\n        arguments?: string;\n      };\n      tool_calls?: {\n        index: number;\n        id?: string;\n        function: {\n          arguments?: string;\n\n          name?: string;\n          // TODO:\n          // Temporarily add scope to the OpenAI protocol until we\n          // have our own protocol.\n          // When scope is \"server\", the client will not attempt to\n          // execute the function.\n          scope?: \"client\" | \"server\";\n        };\n      }[];\n    };\n  }[];\n}\n\n// TODO:\n// it's possible that unicode characters could be split across chunks\n// make sure to properly handle that\nexport function parseChatCompletion(\n  stream: ReadableStream<Uint8Array>,\n): ReadableStream<ChatCompletionChunk> {\n  const reader = stream.getReader();\n  let buffer = new Uint8Array();\n\n  async function cleanup(controller?: ReadableStreamDefaultController<any>) {\n    if (controller) {\n      try {\n        controller.close();\n      } catch (_) {}\n    }\n    if (reader) {\n      try {\n        await reader.cancel();\n      } catch (_) {}\n    }\n  }\n\n  return new ReadableStream<ChatCompletionChunk>({\n    async pull(controller) {\n      while (true) {\n        try {\n          const { done, value } = await reader.read();\n\n          if (done) {\n            await cleanup(controller);\n            return;\n          }\n\n          const newBuffer = new Uint8Array(buffer.length + value.length);\n          newBuffer.set(buffer);\n          newBuffer.set(value, buffer.length);\n          buffer = newBuffer;\n\n          const valueString = new TextDecoder(\"utf-8\").decode(buffer);\n          const lines = valueString.split(\"\\n\").filter((line) => line.trim() !== \"\");\n\n          // If the last line isn't complete, keep it in the buffer for next time\n          buffer = !valueString.endsWith(\"\\n\")\n            ? new TextEncoder().encode(lines.pop() || \"\")\n            : new Uint8Array();\n\n          for (const line of lines) {\n            const cleanedLine = line.replace(/^data: /, \"\");\n\n            if (cleanedLine === \"[DONE]\") {\n              await cleanup(controller);\n              return;\n            }\n\n            const json = JSON.parse(cleanedLine);\n            controller.enqueue(json);\n          }\n        } catch (error) {\n          controller.error(error);\n          await cleanup(controller);\n          return;\n        }\n      }\n    },\n    cancel() {\n      reader.cancel();\n    },\n  });\n}\n"],"mappings":";AAyCO,SAAS,oBACd,QACqC;AACrC,QAAM,SAAS,OAAO,UAAU;AAChC,MAAI,SAAS,IAAI,WAAW;AAE5B,iBAAe,QAAQ,YAAmD;AACxE,QAAI,YAAY;AACd,UAAI;AACF,mBAAW,MAAM;AAAA,MACnB,SAAS,GAAP;AAAA,MAAW;AAAA,IACf;AACA,QAAI,QAAQ;AACV,UAAI;AACF,cAAM,OAAO,OAAO;AAAA,MACtB,SAAS,GAAP;AAAA,MAAW;AAAA,IACf;AAAA,EACF;AAEA,SAAO,IAAI,eAAoC;AAAA,IAC7C,MAAM,KAAK,YAAY;AACrB,aAAO,MAAM;AACX,YAAI;AACF,gBAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAE1C,cAAI,MAAM;AACR,kBAAM,QAAQ,UAAU;AACxB;AAAA,UACF;AAEA,gBAAM,YAAY,IAAI,WAAW,OAAO,SAAS,MAAM,MAAM;AAC7D,oBAAU,IAAI,MAAM;AACpB,oBAAU,IAAI,OAAO,OAAO,MAAM;AAClC,mBAAS;AAET,gBAAM,cAAc,IAAI,YAAY,OAAO,EAAE,OAAO,MAAM;AAC1D,gBAAM,QAAQ,YAAY,MAAM,IAAI,EAAE,OAAO,CAAC,SAAS,KAAK,KAAK,MAAM,EAAE;AAGzE,mBAAS,CAAC,YAAY,SAAS,IAAI,IAC/B,IAAI,YAAY,EAAE,OAAO,MAAM,IAAI,KAAK,EAAE,IAC1C,IAAI,WAAW;AAEnB,qBAAW,QAAQ,OAAO;AACxB,kBAAM,cAAc,KAAK,QAAQ,WAAW,EAAE;AAE9C,gBAAI,gBAAgB,UAAU;AAC5B,oBAAM,QAAQ,UAAU;AACxB;AAAA,YACF;AAEA,kBAAM,OAAO,KAAK,MAAM,WAAW;AACnC,uBAAW,QAAQ,IAAI;AAAA,UACzB;AAAA,QACF,SAAS,OAAP;AACA,qBAAW,MAAM,KAAK;AACtB,gBAAM,QAAQ,UAAU;AACxB;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IACA,SAAS;AACP,aAAO,OAAO;AAAA,IAChB;AAAA,EACF,CAAC;AACH;","names":[]}