@copilotkit/shared 0.37.0 → 0.38.0-beta.0

package/dist/utils/utils.test.js

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

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

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

package/dist/utils/utils.test.mjs

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

package/dist/utils/utils.test.mjs.map

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

package/src/constants/copilot-protocol.ts

@@ -1 +0,0 @@
-export const EXCLUDE_FROM_FORWARD_PROPS_KEYS = "exclude_from_forward_props_keys";

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

@@ -1,33 +0,0 @@
-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

@@ -1,169 +0,0 @@
-import { ChatCompletionChunk, ToolCallFunctionCall } 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;
-  scope: "client" | "server";
-}
-
-export interface ChatCompletionResultEvent {
-  type: "result";
-  content: string;
-  name: string;
-}
-
-export type ChatCompletionEvent =
-  | ChatCompletionContentEvent
-  | ChatCompletionPartialEvent
-  | ChatCompletionFunctionEvent
-  | ChatCompletionResultEvent;
-
-export function decodeChatCompletion(
-  stream: ReadableStream<ChatCompletionChunk>,
-): ReadableStream<ChatCompletionEvent> {
-  const reader = stream.getReader();
-
-  type Mode = { type: "function"; function: ToolCallFunctionCall } | { type: "message" };
-
-  let mode: Mode | null = null;
-  let functionCallName: string = "";
-  let functionCallArguments: string = "";
-  let functionCallScope: "client" | "server" = "client";
-
-  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,
-          scope: functionCallScope,
-        });
-
-        mode = null;
-        functionCallName = "";
-        functionCallArguments = "";
-        return true;
-      };
-
-      while (true) {
-        try {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            if (mode?.type === "function") {
-              flushFunctionCall();
-            }
-            await cleanup(controller);
-            return;
-          }
-
-          // In case we are currently handling a function call but the next message is either
-          // - not a function call
-          // - or is another function call (indicated by the presence of 'name' field in the next function call object)
-          // => flush the current function call.
-          if (
-            mode?.type === "function" &&
-            (!value.choices[0].delta.tool_calls?.[0]?.function ||
-              value.choices[0].delta.tool_calls?.[0]?.function.name)
-          ) {
-            if (!flushFunctionCall()) {
-              return;
-            }
-          }
-
-          const maybeFunctionCall = value.choices[0].delta.tool_calls?.[0]?.function;
-          if (maybeFunctionCall) {
-            mode = { type: "function", function: maybeFunctionCall };
-          } else {
-            mode = { type: "message" };
-          }
-
-          // if we get a message, emit the content and continue;
-          if (mode.type === "message") {
-            // if we got a result message, send a result event
-            if (value.choices[0].delta.role === "function") {
-              controller.enqueue({
-                type: "result",
-                content: value.choices[0].delta.content!,
-                name: value.choices[0].delta.name!,
-              });
-            }
-            // otherwise, send a content event
-            else 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.type === "function") {
-            const maybeFunctionCallName = mode.function.name;
-            if (maybeFunctionCallName) {
-              functionCallName = maybeFunctionCallName;
-            }
-
-            const maybeFunctionCallArguments = mode.function.arguments;
-            if (maybeFunctionCallArguments) {
-              functionCallArguments += maybeFunctionCallArguments;
-            }
-
-            const maybeFunctionCallScope = mode.function.scope;
-            if (maybeFunctionCallScope) {
-              functionCallScope = maybeFunctionCallScope;
-            }
-
-            controller.enqueue({
-              type: "partial",
-              name: functionCallName,
-              arguments: functionCallArguments,
-            });
-            continue;
-          }
-        } catch (error) {
-          controller.error(error);
-          await cleanup(controller);
-          return;
-        }
-      }
-    },
-    cancel() {
-      reader.cancel();
-    },
-  });
-}

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

@@ -1,112 +0,0 @@
-import { Role } from "../types/openai-assistant";
-
-export interface ToolCallFunctionCall {
-  arguments?: string;
-
-  name?: string;
-  // TODO:
-  // Temporarily add scope to the OpenAI protocol until we
-  // have our own protocol.
-  // When scope is "server", the client will not attempt to
-  // execute the function.
-  scope?: "client" | "server";
-}
-
-export interface ToolCallPayload {
-  index: number;
-  id?: string;
-  function: ToolCallFunctionCall;
-}
-
-export interface ChatCompletionChunk {
-  choices: {
-    delta: {
-      id?: string;
-      role: Role;
-      content?: string | null;
-
-      // TODO:
-      // Temporarily add name to the OpenAI protocol until we
-      // have our own protocol.
-      // When name is set, we return the result of a server-side
-      // function call.
-      name?: string;
-
-      function_call?: {
-        name?: string;
-        arguments?: string;
-      };
-      tool_calls?: ToolCallPayload[];
-    };
-  }[];
-}
-
-// 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/src/utils/utils.test.ts

@@ -1,7 +0,0 @@
-import * as utils from "./utils";
-
-describe("emptyTest", () => {
-  it("should be truthy", () => {
-    expect(true).toBeTruthy();
-  });
-});

package/src/utils/utils.ts

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