@copilotkit/shared 0.2.0-alpha.3 → 0.2.0-alpha.4

package/dist/utils/utils.js

@@ -0,0 +1,140 @@
+'use strict';
+
+// src/utils/utils.ts
+var textStreamPart = {
+  code: "0",
+  name: "text",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var functionCallStreamPart = {
+  code: "1",
+  name: "function_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("function_call" in value) || typeof value.function_call !== "object" || value.function_call == null || !("name" in value.function_call) || !("arguments" in value.function_call) || typeof value.function_call.name !== "string" || typeof value.function_call.arguments !== "string") {
+      throw new Error('"function_call" parts expect an object with a "function_call" property.');
+    }
+    return {
+      type: "function_call",
+      value
+    };
+  }
+};
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
+  }
+};
+var errorStreamPart = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
+  }
+};
+var assistantMessage = {
+  code: "4",
+  name: "assistant_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("id" in value) || !("role" in value) || !("content" in value) || typeof value.id !== "string" || typeof value.role !== "string" || value.role !== "assistant" || !Array.isArray(value.content) || !value.content.every(
+      (item) => item != null && typeof item === "object" && "type" in item && item.type === "text" && "text" in item && item.text != null && typeof item.text === "object" && "value" in item.text && typeof item.text.value === "string"
+    )) {
+      throw new Error(
+        '"assistant_message" parts expect an object with an "id", "role", and "content" property.'
+      );
+    }
+    return {
+      type: "assistant_message",
+      value
+    };
+  }
+};
+var assistantControlData = {
+  code: "5",
+  name: "assistant_control_data",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("threadId" in value) || !("messageId" in value) || typeof value.threadId !== "string" || typeof value.messageId !== "string") {
+      throw new Error(
+        '"assistant_control_data" parts expect an object with a "threadId" and "messageId" property.'
+      );
+    }
+    return {
+      type: "assistant_control_data",
+      value: {
+        threadId: value.threadId,
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var streamParts = [
+  textStreamPart,
+  functionCallStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  assistantMessage,
+  assistantControlData
+];
+var streamPartsByCode = {
+  [textStreamPart.code]: textStreamPart,
+  [functionCallStreamPart.code]: functionCallStreamPart,
+  [dataStreamPart.code]: dataStreamPart,
+  [errorStreamPart.code]: errorStreamPart,
+  [assistantMessage.code]: assistantMessage,
+  [assistantControlData.code]: assistantControlData
+};
+var StreamStringPrefixes = {
+  [textStreamPart.name]: textStreamPart.code,
+  [functionCallStreamPart.name]: functionCallStreamPart.code,
+  [dataStreamPart.name]: dataStreamPart.code,
+  [errorStreamPart.name]: errorStreamPart.code,
+  [assistantMessage.name]: assistantMessage.code,
+  [assistantControlData.name]: assistantControlData.code
+};
+var validCodes = streamParts.map((part) => part.code);
+var parseStreamPart = (line) => {
+  const firstSeparatorIndex = line.indexOf(":");
+  if (firstSeparatorIndex === -1) {
+    throw new Error("Failed to parse stream string. No separator found.");
+  }
+  const prefix = line.slice(0, firstSeparatorIndex);
+  if (!validCodes.includes(prefix)) {
+    throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);
+  }
+  const code = prefix;
+  const textValue = line.slice(firstSeparatorIndex + 1);
+  const jsonValue = JSON.parse(textValue);
+  return streamPartsByCode[code].parse(jsonValue);
+};
+function formatStreamPart(type, value) {
+  const streamPart = streamParts.find((part) => part.name === type);
+  if (!streamPart) {
+    throw new Error(`Invalid stream part type: ${type}`);
+  }
+  return `${streamPart.code}:${JSON.stringify(value)}
+`;
+}
+var isStreamStringEqualToType = (type, value) => value.startsWith(`${StreamStringPrefixes[type]}:`) && value.endsWith("\n");
+var COMPLEX_HEADER = "X-Experimental-Stream-Data";
+
+exports.COMPLEX_HEADER = COMPLEX_HEADER;
+exports.StreamStringPrefixes = StreamStringPrefixes;
+exports.formatStreamPart = formatStreamPart;
+exports.isStreamStringEqualToType = isStreamStringEqualToType;
+exports.parseStreamPart = parseStreamPart;
+exports.streamPartsByCode = streamPartsByCode;
+exports.validCodes = validCodes;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=utils.js.map

package/dist/utils/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { AssistantMessage, FunctionCall, JSONValue } from \"../types/openai-assistant\";\n\nexport interface StreamPart<CODE extends string, NAME extends string, TYPE> {\n  code: CODE;\n  name: NAME;\n  parse: (value: JSONValue) => { type: NAME; value: TYPE };\n}\n\nconst textStreamPart: StreamPart<\"0\", \"text\", string> = {\n  code: \"0\",\n  name: \"text\",\n  parse: (value: JSONValue) => {\n    if (typeof value !== \"string\") {\n      throw new Error('\"text\" parts expect a string value.');\n    }\n    return { type: \"text\", value };\n  },\n};\n\n/**\n * This is a utility function that helps in parsing the stream parts.\n * It takes a JSONValue as input and returns an object with type and value.\n * The type is a string that represents the type of the stream part.\n * The value is the actual value of the stream part.\n * If the input value is not a string, it throws an error.\n */\nconst functionCallStreamPart: StreamPart<\"1\", \"function_call\", { function_call: FunctionCall }> = {\n  code: \"1\",\n  name: \"function_call\",\n  parse: (value: JSONValue) => {\n    if (\n      value == null ||\n      typeof value !== \"object\" ||\n      !(\"function_call\" in value) ||\n      typeof value.function_call !== \"object\" ||\n      value.function_call == null ||\n      !(\"name\" in value.function_call) ||\n      !(\"arguments\" in value.function_call) ||\n      typeof value.function_call.name !== \"string\" ||\n      typeof value.function_call.arguments !== \"string\"\n    ) {\n      throw new Error('\"function_call\" parts expect an object with a \"function_call\" property.');\n    }\n\n    return {\n      type: \"function_call\",\n      value: value as unknown as { function_call: FunctionCall },\n    };\n  },\n};\n\nconst dataStreamPart: StreamPart<\"2\", \"data\", Array<JSONValue>> = {\n  code: \"2\",\n  name: \"data\",\n  parse: (value: JSONValue) => {\n    if (!Array.isArray(value)) {\n      throw new Error('\"data\" parts expect an array value.');\n    }\n\n    return { type: \"data\", value };\n  },\n};\n\nconst errorStreamPart: StreamPart<\"3\", \"error\", string> = {\n  code: \"3\",\n  name: \"error\",\n  parse: (value: JSONValue) => {\n    if (typeof value !== \"string\") {\n      throw new Error('\"error\" parts expect a string value.');\n    }\n    return { type: \"error\", value };\n  },\n};\n\nconst assistantMessage: StreamPart<\"4\", \"assistant_message\", AssistantMessage> = {\n  code: \"4\",\n  name: \"assistant_message\",\n  parse: (value: JSONValue) => {\n    if (\n      value == null ||\n      typeof value !== \"object\" ||\n      !(\"id\" in value) ||\n      !(\"role\" in value) ||\n      !(\"content\" in value) ||\n      typeof value.id !== \"string\" ||\n      typeof value.role !== \"string\" ||\n      value.role !== \"assistant\" ||\n      !Array.isArray(value.content) ||\n      !value.content.every(\n        (item) =>\n          item != null &&\n          typeof item === \"object\" &&\n          \"type\" in item &&\n          item.type === \"text\" &&\n          \"text\" in item &&\n          item.text != null &&\n          typeof item.text === \"object\" &&\n          \"value\" in item.text &&\n          typeof item.text.value === \"string\",\n      )\n    ) {\n      throw new Error(\n        '\"assistant_message\" parts expect an object with an \"id\", \"role\", and \"content\" property.',\n      );\n    }\n\n    return {\n      type: \"assistant_message\",\n      value: value as AssistantMessage,\n    };\n  },\n};\n\nconst assistantControlData: StreamPart<\n  \"5\",\n  \"assistant_control_data\",\n  {\n    threadId: string;\n    messageId: string;\n  }\n> = {\n  code: \"5\",\n  name: \"assistant_control_data\",\n  parse: (value: JSONValue) => {\n    if (\n      value == null ||\n      typeof value !== \"object\" ||\n      !(\"threadId\" in value) ||\n      !(\"messageId\" in value) ||\n      typeof value.threadId !== \"string\" ||\n      typeof value.messageId !== \"string\"\n    ) {\n      throw new Error(\n        '\"assistant_control_data\" parts expect an object with a \"threadId\" and \"messageId\" property.',\n      );\n    }\n\n    return {\n      type: \"assistant_control_data\",\n      value: {\n        threadId: value.threadId,\n        messageId: value.messageId,\n      },\n    };\n  },\n};\n\nconst streamParts = [\n  textStreamPart,\n  functionCallStreamPart,\n  dataStreamPart,\n  errorStreamPart,\n  assistantMessage,\n  assistantControlData,\n] as const;\n\n// union type of all stream parts\ntype StreamParts =\n  | typeof textStreamPart\n  | typeof functionCallStreamPart\n  | typeof dataStreamPart\n  | typeof errorStreamPart\n  | typeof assistantMessage\n  | typeof assistantControlData;\n\n/**\n * Maps the type of a stream part to its value type.\n */\ntype StreamPartValueType = {\n  [P in StreamParts as P[\"name\"]]: ReturnType<P[\"parse\"]>[\"value\"];\n};\n\nexport type StreamPartType =\n  | ReturnType<typeof textStreamPart.parse>\n  | ReturnType<typeof functionCallStreamPart.parse>\n  | ReturnType<typeof dataStreamPart.parse>\n  | ReturnType<typeof errorStreamPart.parse>\n  | ReturnType<typeof assistantMessage.parse>\n  | ReturnType<typeof assistantControlData.parse>;\n\nexport const streamPartsByCode = {\n  [textStreamPart.code]: textStreamPart,\n  [functionCallStreamPart.code]: functionCallStreamPart,\n  [dataStreamPart.code]: dataStreamPart,\n  [errorStreamPart.code]: errorStreamPart,\n  [assistantMessage.code]: assistantMessage,\n  [assistantControlData.code]: assistantControlData,\n} as const;\n\n/**\n * The map of prefixes for data in the stream\n *\n * - 0: Text from the LLM response\n * - 1: (OpenAI) function_call responses\n * - 2: custom JSON added by the user using `Data`\n *\n * Example:\n * ```\n * 0:Vercel\n * 0:'s\n * 0: AI\n * 0: AI\n * 0: SDK\n * 0: is great\n * 0:!\n * 2: { \"someJson\": \"value\" }\n * 1: {\"function_call\": {\"name\": \"get_current_weather\", \"arguments\": \"{\\\\n\\\\\"location\\\\\": \\\\\"Charlottesville, Virginia\\\\\",\\\\n\\\\\"format\\\\\": \\\\\"celsius\\\\\"\\\\n}\"}}\n *```\n */\nexport const StreamStringPrefixes = {\n  [textStreamPart.name]: textStreamPart.code,\n  [functionCallStreamPart.name]: functionCallStreamPart.code,\n  [dataStreamPart.name]: dataStreamPart.code,\n  [errorStreamPart.name]: errorStreamPart.code,\n  [assistantMessage.name]: assistantMessage.code,\n  [assistantControlData.name]: assistantControlData.code,\n} as const;\n\nexport const validCodes = streamParts.map((part) => part.code);\n\n/**\n * Parses a stream part from a string.\n *\n * @param line The string to parse.\n * @returns The parsed stream part.\n * @throws An error if the string cannot be parsed.\n */\nexport const parseStreamPart = (line: string): StreamPartType => {\n  const firstSeparatorIndex = line.indexOf(\":\");\n\n  if (firstSeparatorIndex === -1) {\n    throw new Error(\"Failed to parse stream string. No separator found.\");\n  }\n\n  const prefix = line.slice(0, firstSeparatorIndex);\n\n  if (!validCodes.includes(prefix as keyof typeof streamPartsByCode)) {\n    throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);\n  }\n\n  const code = prefix as keyof typeof streamPartsByCode;\n\n  const textValue = line.slice(firstSeparatorIndex + 1);\n  const jsonValue: JSONValue = JSON.parse(textValue);\n\n  return streamPartsByCode[code].parse(jsonValue);\n};\n\n/**\n * Prepends a string with a prefix from the `StreamChunkPrefixes`, JSON-ifies it,\n * and appends a new line.\n *\n * It ensures type-safety for the part type and value.\n */\nexport function formatStreamPart<T extends keyof StreamPartValueType>(\n  type: T,\n  value: StreamPartValueType[T],\n): StreamString {\n  const streamPart = streamParts.find((part) => part.name === type);\n\n  if (!streamPart) {\n    throw new Error(`Invalid stream part type: ${type}`);\n  }\n\n  return `${streamPart.code}:${JSON.stringify(value)}\\n`;\n}\n\nexport const isStreamStringEqualToType = (\n  type: keyof typeof StreamStringPrefixes,\n  value: string,\n): value is StreamString =>\n  value.startsWith(`${StreamStringPrefixes[type]}:`) && value.endsWith(\"\\n\");\n\nexport type StreamString =\n  `${typeof StreamStringPrefixes[keyof typeof StreamStringPrefixes]}:${string}\\n`;\n\n/**\n * A header sent to the client so it knows how to handle parsing the stream (as a deprecated text response or using the new prefixed protocol)\n */\nexport const COMPLEX_HEADER = \"X-Experimental-Stream-Data\";\n"]}

package/dist/utils/utils.test.js

@@ -0,0 +1,10 @@
+'use strict';
+
+// src/utils/utils.test.ts
+describe("emptyTest", () => {
+  it("should be truthy", () => {
+    expect(true).toBeTruthy();
+  });
+});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=utils.test.js.map

package/dist/utils/utils.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/utils.test.ts"],"names":[],"mappings":";AAEA,SAAS,aAAa,MAAM;AAC1B,KAAG,oBAAoB,MAAM;AAC3B,WAAO,IAAI,EAAE,WAAW;AAAA,EAC1B,CAAC;AACH,CAAC","sourcesContent":["import * as utils from \"./utils\";\n\ndescribe(\"emptyTest\", () => {\n  it(\"should be truthy\", () => {\n    expect(true).toBeTruthy();\n  });\n});\n"]}

package/package.json

@@ -4,27 +4,29 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.0-alpha.3",
+  "version": "0.2.0-alpha.4",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
-  "exports": "./dist/index.mjs",
+  "exports": {
+    ".": "./dist/index.js"
+  },
   "types": "./dist/index.d.ts",
   "license": "MIT",
   "peerDependencies": {},
   "devDependencies": {
     "@types/jest": "^29.5.4",
     "eslint": "^7.32.0",
+    "eslint-config-custom": "0.3.0-alpha.4",
     "jest": "^29.6.4",
     "ts-jest": "^29.1.1",
+    "tsconfig": "0.7.0-alpha.4",
     "tsup": "^6.7.0",
-    "typescript": "^5.1.3",
-    "eslint-config-custom": "0.2.0",
-    "tsconfig": "0.6.0"
+    "typescript": "^5.1.3"
   },
   "dependencies": {},
   "scripts": {
-    "build": "tsup --treeshake",
+    "build": "tsup --treeshake --clean",
     "dev": "tsup --watch --no-splitting",
     "test": "jest",
     "check-types": "tsc --noEmit",

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

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

package/src/types/openai-assistant.ts

@@ -1,3 +1,5 @@
+export type Role = "system" | "user" | "assistant" | "function";
+
 export interface FunctionCall {
   /**
    * The arguments to call the function with, as generated by the model in JSON
@@ -21,7 +23,7 @@ export interface Message {
   createdAt?: Date;
   content: string;
   ui?: string | null | undefined;
-  role: "system" | "user" | "assistant" | "function";
+  role: Role;
   /**
    * If the message has a role of `function`, the `name` field is the name of the function.
    * Otherwise, the name field should not be set.
@@ -35,6 +37,34 @@ export interface Message {
   function_call?: string | FunctionCall;
 }
 
+export interface Function {
+  /**
+   * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain
+   * underscores and dashes, with a maximum length of 64.
+   */
+  name: string;
+  /**
+   * The parameters the functions accepts, described as a JSON Schema object. See the
+   * [guide](/docs/guides/gpt/function-calling) for examples, and the
+   * [JSON Schema reference](https://json-schema.org/understanding-json-schema/) for
+   * documentation about the format.
+   *
+   * To describe a function that accepts no parameters, provide the value
+   * `{"type": "object", "properties": {}}`.
+   */
+  parameters: Record<string, unknown>;
+  /**
+   * A description of what the function does, used by the model to choose when and
+   * how to call the function.
+   */
+  description?: string;
+}
+
+export type FunctionCallHandler = (
+  chatMessages: Message[],
+  functionCall: FunctionCall,
+) => Promise<void>;
+
 export type AssistantMessage = {
   id: string;
   role: "assistant";

package/src/utils/annotated-function.ts

@@ -0,0 +1,33 @@
+import { AnnotatedFunction, Function } from "../types";
+
+export function annotatedFunctionToChatCompletionFunction(
+  annotatedFunction: AnnotatedFunction<any[]>,
+): Function {
+  // Create the parameters object based on the argumentAnnotations
+  let parameters: { [key: string]: any } = {};
+  for (let arg of annotatedFunction.argumentAnnotations) {
+    // isolate the args we should forward inline
+    let { name, required, ...forwardedArgs } = arg;
+    parameters[arg.name] = forwardedArgs;
+  }
+
+  let requiredParameterNames: string[] = [];
+  for (let arg of annotatedFunction.argumentAnnotations) {
+    if (arg.required) {
+      requiredParameterNames.push(arg.name);
+    }
+  }
+
+  // Create the ChatCompletionFunctions object
+  let chatCompletionFunction: Function = {
+    name: annotatedFunction.name,
+    description: annotatedFunction.description,
+    parameters: {
+      type: "object",
+      properties: parameters,
+      required: requiredParameterNames,
+    },
+  };
+
+  return chatCompletionFunction;
+}

package/src/utils/decode-chat-completion-as-text.ts

@@ -0,0 +1,33 @@
+import { ChatCompletionEvent } from "./decode-chat-completion";
+
+export function decodeChatCompletionAsText(
+  stream: ReadableStream<ChatCompletionEvent>,
+): ReadableStream<string> {
+  const reader = stream.getReader();
+
+  return new ReadableStream<string>({
+    async pull(controller) {
+      while (true) {
+        try {
+          const { done, value } = await reader.read();
+
+          if (done) {
+            controller.close();
+            return;
+          }
+
+          if (value.type === "content") {
+            controller.enqueue(value.content);
+            continue;
+          }
+        } catch (error) {
+          controller.error(error);
+          return;
+        }
+      }
+    },
+    cancel() {
+      reader.cancel();
+    },
+  });
+}

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

@@ -0,0 +1,127 @@
+import { ChatCompletionChunk } from "./parse-chat-completion";
+
+export interface ChatCompletionContentEvent {
+  type: "content";
+  content: string;
+}
+
+export interface ChatCompletionPartialEvent {
+  type: "partial";
+  name: string;
+  arguments: string;
+}
+
+export interface ChatCompletionFunctionEvent {
+  type: "function";
+  name: string;
+  arguments: any;
+}
+
+export type ChatCompletionEvent =
+  | ChatCompletionContentEvent
+  | ChatCompletionPartialEvent
+  | ChatCompletionFunctionEvent;
+
+export function decodeChatCompletion(
+  stream: ReadableStream<ChatCompletionChunk>,
+): ReadableStream<ChatCompletionEvent> {
+  const reader = stream.getReader();
+
+  let mode: "function" | "message" | null = null;
+  let functionCallName: string = "";
+  let functionCallArguments: string = "";
+
+  async function cleanup(controller?: ReadableStreamDefaultController<any>) {
+    if (controller) {
+      try {
+        controller.close();
+      } catch (_) {}
+    }
+    if (reader) {
+      try {
+        await reader.cancel();
+      } catch (_) {}
+    }
+  }
+
+  return new ReadableStream<ChatCompletionEvent>({
+    async pull(controller) {
+      const flushFunctionCall = (): boolean => {
+        let args: any = null;
+        try {
+          args = JSON.parse(functionCallArguments);
+        } catch (error) {
+          cleanup(controller);
+          controller.error(error);
+          return false;
+        }
+        controller.enqueue({
+          type: "function",
+          name: functionCallName,
+          arguments: args,
+        });
+
+        mode = null;
+        functionCallName = "";
+        functionCallArguments = "";
+        return true;
+      };
+
+      while (true) {
+        try {
+          const { done, value } = await reader.read();
+
+          if (done) {
+            if (mode === "function") {
+              flushFunctionCall();
+            }
+            await cleanup(controller);
+            return;
+          }
+
+          // In case we are in a function call but the next message is not a function call, flush it.
+          if (mode === "function" && !value.choices[0].delta.function_call) {
+            if (!flushFunctionCall()) {
+              return;
+            }
+          }
+
+          mode = value.choices[0].delta.function_call ? "function" : "message";
+
+          // if we get a message, emit the content and continue;
+          if (mode === "message") {
+            if (value.choices[0].delta.content) {
+              controller.enqueue({
+                type: "content",
+                content: value.choices[0].delta.content,
+              });
+            }
+            continue;
+          }
+          // if we get a function call, buffer the name and arguments, then emit a partial event.
+          else if (mode === "function") {
+            if (value.choices[0].delta.function_call!.name) {
+              functionCallName = value.choices[0].delta.function_call!.name!;
+            }
+            if (value.choices[0].delta.function_call!.arguments) {
+              functionCallArguments += value.choices[0].delta.function_call!.arguments!;
+            }
+            controller.enqueue({
+              type: "partial",
+              name: functionCallName,
+              arguments: functionCallArguments,
+            });
+            continue;
+          }
+        } catch (error) {
+          controller.error(error);
+          await cleanup(controller);
+          return;
+        }
+      }
+    },
+    cancel() {
+      reader.cancel();
+    },
+  });
+}

package/src/utils/index.ts

@@ -1 +1,5 @@
 export * from "./utils";
+export * from "./parse-chat-completion";
+export * from "./decode-chat-completion";
+export * from "./decode-chat-completion-as-text";
+export * from "./annotated-function";

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

@@ -0,0 +1,84 @@
+import { Role } from "../types/openai-assistant";
+
+export interface ChatCompletionChunk {
+  choices: {
+    delta: {
+      role: Role;
+      content?: string | null;
+      function_call?: {
+        name?: string;
+        arguments?: string;
+      };
+    };
+  }[];
+}
+
+// TODO:
+// it's possible that unicode characters could be split across chunks
+// make sure to properly handle that
+export function parseChatCompletion(
+  stream: ReadableStream<Uint8Array>,
+): ReadableStream<ChatCompletionChunk> {
+  const reader = stream.getReader();
+  let buffer = new Uint8Array();
+
+  async function cleanup(controller?: ReadableStreamDefaultController<any>) {
+    if (controller) {
+      try {
+        controller.close();
+      } catch (_) {}
+    }
+    if (reader) {
+      try {
+        await reader.cancel();
+      } catch (_) {}
+    }
+  }
+
+  return new ReadableStream<ChatCompletionChunk>({
+    async pull(controller) {
+      while (true) {
+        try {
+          const { done, value } = await reader.read();
+
+          if (done) {
+            await cleanup(controller);
+            return;
+          }
+
+          const newBuffer = new Uint8Array(buffer.length + value.length);
+          newBuffer.set(buffer);
+          newBuffer.set(value, buffer.length);
+          buffer = newBuffer;
+
+          const valueString = new TextDecoder("utf-8").decode(buffer);
+          const lines = valueString.split("\n").filter((line) => line.trim() !== "");
+
+          // If the last line isn't complete, keep it in the buffer for next time
+          buffer = !valueString.endsWith("\n")
+            ? new TextEncoder().encode(lines.pop() || "")
+            : new Uint8Array();
+
+          for (const line of lines) {
+            const cleanedLine = line.replace(/^data: /, "");
+
+            if (cleanedLine === "[DONE]") {
+              await cleanup(controller);
+              return;
+            }
+
+            const json = JSON.parse(cleanedLine);
+            controller.enqueue(json);
+          }
+        } catch (error) {
+          controller.error(error);
+          await cleanup(controller);
+          return;
+        }
+      }
+    },
+    cancel() {
+      reader.cancel();
+    },
+  });
+}

package/tsup.config.ts

@@ -2,10 +2,9 @@ import { defineConfig, Options } from "tsup";
 
 export default defineConfig((options: Options) => ({
   entry: ["src/**/*.{ts,tsx}"],
-  format: ["esm"],
+  format: ["esm", "cjs"],
   dts: true,
   minify: false,
-  clean: true,
   external: [],
   sourcemap: true,
   exclude: [

package/dist/chunk-YJLRG5U3.mjs

@@ -1,3 +0,0 @@
-
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-YJLRG5U3.mjs.map

package/dist/chunk-YPBKY4KY.mjs

@@ -1,3 +0,0 @@
-
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-YPBKY4KY.mjs.map