@copilotkit/react-core 0.18.0-alpha.1 → 0.18.0-alpha.2

package/src/openai/chat-completion-client.ts

@@ -1,229 +0,0 @@
-import EventEmitter from "eventemitter3";
-import { Function, Message, Role } from "../types";
-import {
-  ChatCompletionTransport,
-  ChatCompletionTransportFetchParams,
-} from "./chat-completion-transport";
-
-interface ChatCompletionClientConfiguration {}
-
-interface ChatCompletionClientEvents {
-  content: string;
-  partial: [string, string];
-  error: any;
-  function: {
-    name: string;
-    arguments: any;
-  };
-  end: void;
-}
-
-export interface ChatCompletionChunk {
-  choices: {
-    delta: {
-      role: Role;
-      content?: string | null;
-      function_call?: {
-        name?: string;
-        arguments?: string;
-      };
-    };
-  }[];
-}
-
-const DEFAULT_MAX_TOKENS = 8192;
-
-export class ChatCompletionClient extends EventEmitter<ChatCompletionClientEvents> {
-  private chatCompletionTransport: ChatCompletionTransport | null = null;
-  private mode: "function" | "message" | null = null;
-  private functionCallName: string = "";
-  private functionCallArguments: string = "";
-
-  constructor(params: ChatCompletionClientConfiguration) {
-    super();
-  }
-
-  public async fetch(params: ChatCompletionTransportFetchParams) {
-    params = { ...params };
-    if (params.model && params.model in maxTokensByModel) {
-      params.maxTokens ||= maxTokensByModel[params.model];
-    } else {
-      params.maxTokens ||= DEFAULT_MAX_TOKENS;
-    }
-
-    params.functions ||= [];
-    params.messages = this.buildPrompt(params);
-    return await this.runPrompt(params);
-  }
-
-  private buildPrompt(params: ChatCompletionTransportFetchParams): Message[] {
-    let maxTokens = params.maxTokens!;
-    const messages = params.messages!;
-    const functions = params.functions!;
-    const functionsNumTokens = countFunctionsTokens(functions);
-    if (functionsNumTokens > maxTokens) {
-      throw new Error(`Too many tokens in function calls: ${functionsNumTokens} > ${maxTokens}`);
-    }
-    maxTokens -= functionsNumTokens;
-
-    for (const message of messages) {
-      if (message.role === "system") {
-        const numTokens = this.countTokens(message);
-        maxTokens -= numTokens;
-
-        if (maxTokens < 0) {
-          throw new Error("Not enough tokens for system message.");
-        }
-      }
-    }
-
-    const result: Message[] = [];
-    let cutoff: boolean = false;
-
-    const reversedMessages = [...messages].reverse();
-    for (const message of reversedMessages) {
-      if (message.role === "system") {
-        result.unshift(message);
-        continue;
-      } else if (cutoff) {
-        continue;
-      }
-      let numTokens = this.countTokens(message);
-      if (maxTokens < numTokens) {
-        cutoff = true;
-        continue;
-      }
-      result.unshift(message);
-      maxTokens -= numTokens;
-    }
-
-    return result;
-  }
-
-  private async runPrompt(params: ChatCompletionTransportFetchParams): Promise<void> {
-    this.chatCompletionTransport = new ChatCompletionTransport({});
-
-    this.chatCompletionTransport.on("data", this.onData);
-    this.chatCompletionTransport.on("error", this.onError);
-    this.chatCompletionTransport.on("end", this.onEnd);
-
-    await this.chatCompletionTransport.fetch(params);
-  }
-
-  private onData = (data: ChatCompletionChunk) => {
-    // In case we are in a function call but the next message is not a function call, flush it.
-    if (this.mode === "function" && !data.choices[0].delta.function_call) {
-      const success = this.tryFlushFunctionCall();
-      if (!success) {
-        return;
-      }
-    }
-
-    this.mode = data.choices[0].delta.function_call ? "function" : "message";
-
-    if (this.mode === "message") {
-      // if we get a message, emit the content and return;
-
-      if (data.choices[0].delta.content) {
-        this.emit("content", data.choices[0].delta.content);
-      }
-
-      return;
-    } else if (this.mode === "function") {
-      // if we get a function call, we buffer the name and arguments, then emit a partial event.
-
-      if (data.choices[0].delta.function_call!.name) {
-        this.functionCallName = data.choices[0].delta.function_call!.name!;
-      }
-      if (data.choices[0].delta.function_call!.arguments) {
-        this.functionCallArguments += data.choices[0].delta.function_call!.arguments!;
-      }
-      this.emit("partial", this.functionCallName, this.functionCallArguments);
-
-      return;
-    }
-  };
-
-  private onError = (error: any) => {
-    this.emit("error", error);
-    this.cleanup();
-  };
-
-  private onEnd = () => {
-    if (this.mode === "function") {
-      const success = this.tryFlushFunctionCall();
-      if (!success) {
-        return;
-      }
-    }
-    this.emit("end");
-    this.cleanup();
-  };
-
-  private tryFlushFunctionCall(): boolean {
-    let args: any = null;
-    try {
-      args = JSON.parse(this.functionCallArguments);
-    } catch (error) {
-      this.emit("error", error);
-      this.cleanup();
-      return false;
-    }
-    this.emit("function", {
-      name: this.functionCallName,
-      arguments: args,
-    });
-    this.mode = null;
-    this.functionCallName = "";
-    this.functionCallArguments = "";
-    return true;
-  }
-
-  private cleanup() {
-    if (this.chatCompletionTransport) {
-      this.chatCompletionTransport.off("data", this.onData);
-      this.chatCompletionTransport.off("error", this.onError);
-      this.chatCompletionTransport.off("end", this.onEnd);
-    }
-    this.chatCompletionTransport = null;
-    this.mode = null;
-    this.functionCallName = "";
-    this.functionCallArguments = "";
-  }
-
-  public countTokens(message: Message): number {
-    if (message.content) {
-      return estimateTokens(message.content);
-    } else if (message.function_call) {
-      return estimateTokens(JSON.stringify(message.function_call));
-    }
-    return 0;
-  }
-}
-
-const maxTokensByModel: { [key: string]: number } = {
-  "gpt-3.5-turbo": 4097,
-  "gpt-3.5-turbo-16k": 16385,
-  "gpt-4": 8192,
-  "gpt-4-1106-preview": 8192,
-  "gpt-4-32k": 32768,
-  "gpt-3.5-turbo-0301": 4097,
-  "gpt-4-0314": 8192,
-  "gpt-4-32k-0314": 32768,
-  "gpt-3.5-turbo-0613": 4097,
-  "gpt-4-0613": 8192,
-  "gpt-4-32k-0613": 32768,
-  "gpt-3.5-turbo-16k-0613": 16385,
-};
-
-function estimateTokens(text: string): number {
-  return text.length / 3;
-}
-
-function countFunctionsTokens(functions: Function[]): number {
-  if (functions.length === 0) {
-    return 0;
-  }
-  const json = JSON.stringify(functions);
-  return estimateTokens(json);
-}

package/src/openai/chat-completion-stream.ts

@@ -1,54 +0,0 @@
-import {
-  ChatCompletionTransport,
-  ChatCompletionTransportFetchParams,
-} from "./chat-completion-transport";
-
-export interface ChatCompletionStreamConfiguration {
-  url: string;
-  model?: string;
-}
-
-export class ChatCompletionStream {
-  private url: string;
-
-  constructor(params: ChatCompletionStreamConfiguration) {
-    this.url = params.url;
-  }
-
-  public async fetch(params: ChatCompletionTransportFetchParams): Promise<ReadableStream<string>> {
-    params = { ...params };
-    params.functions = undefined;
-
-    const transport = new ChatCompletionTransport({});
-
-    const cleanup = () => {
-      transport.off("data");
-      transport.off("end");
-      transport.off("error");
-    };
-
-    const stream = new ReadableStream<string>({
-      start: (controller) => {
-        transport.on("data", (data) => {
-          if (data.choices[0].delta.content) {
-            controller.enqueue(data.choices[0].delta.content);
-          }
-        });
-
-        transport.on("error", (error) => {
-          controller.error(error);
-          cleanup();
-        });
-
-        transport.on("end", () => {
-          controller.close();
-          cleanup();
-        });
-      },
-    });
-
-    transport.fetch(params);
-
-    return stream;
-  }
-}

package/src/openai/chat-completion-transport.ts

@@ -1,186 +0,0 @@
-import EventEmitter from "eventemitter3";
-import { Message, Function } from "../types";
-import { CopilotApiConfig } from "../context";
-
-export interface ChatCompletionTransportConfiguration {}
-
-interface ChatCompletionTransportEvents {
-  end: void;
-  data: any;
-  error: any;
-}
-
-export interface ChatCompletionTransportFetchParams {
-  copilotConfig: CopilotApiConfig;
-  model?: string;
-  messages: Message[];
-  functions?: Function[];
-  temperature?: number;
-  maxTokens?: number;
-  headers?: Record<string, string> | Headers;
-  body?: object;
-  signal?: AbortSignal;
-}
-
-const DEFAULT_MODEL = "gpt-4-1106-preview";
-
-export class ChatCompletionTransport extends EventEmitter<ChatCompletionTransportEvents> {
-  private buffer = new Uint8Array();
-  private bodyReader: ReadableStreamDefaultReader<Uint8Array> | null = null;
-
-  constructor(params: ChatCompletionTransportConfiguration) {
-    super();
-  }
-
-  private async cleanup() {
-    if (this.bodyReader) {
-      try {
-        await this.bodyReader.cancel();
-      } catch (error) {
-        console.warn("Failed to cancel body reader:", error);
-      }
-    }
-    this.bodyReader = null;
-    this.buffer = new Uint8Array();
-  }
-
-  public async fetch({
-    copilotConfig,
-    model,
-    messages,
-    functions,
-    temperature,
-    headers,
-    body,
-    signal,
-  }: ChatCompletionTransportFetchParams): Promise<void> {
-    await this.cleanup();
-
-    temperature ||= 0.5;
-    functions ||= [];
-    model ||= DEFAULT_MODEL;
-
-    // clean up any extra properties from messages
-    const cleanedMessages = messages.map((message) => {
-      const { content, role, name, function_call } = message;
-      return { content, role, name, function_call };
-    });
-
-    try {
-      const response = await fetch(copilotConfig.chatApiEndpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...copilotConfig.headers,
-          ...(headers ? { ...headers } : {}),
-        },
-        body: JSON.stringify({
-          model,
-          messages: cleanedMessages,
-          stream: true,
-          ...(functions.length ? { functions } : {}),
-          ...(temperature ? { temperature } : {}),
-          ...(functions.length != 0 ? { function_call: "auto" } : {}),
-          ...copilotConfig.body,
-          ...(body ? { ...body } : {}),
-        }),
-        signal,
-      });
-
-      if (!response.ok) {
-        try {
-          const errorText = await response.text();
-          await this.cleanup();
-          const msg = `Error ${response.status}: ${errorText}`;
-          this.emit("error", new Error(msg));
-        } catch (_error) {
-          await this.cleanup();
-          const msg = `Error ${response.status}: ${response.statusText}`;
-          this.emit("error", new Error(msg));
-        }
-        return;
-      }
-
-      if (response.body == null) {
-        await this.cleanup();
-        const msg = "Response body is null";
-        this.emit("error", new Error(msg));
-        return;
-      }
-
-      this.bodyReader = response.body.getReader();
-
-      await this.streamBody();
-    } catch (error) {
-      await this.cleanup();
-      this.emit("error", error);
-      return;
-    }
-  }
-
-  private async streamBody() {
-    while (true) {
-      try {
-        const { done, value } = await this.bodyReader!.read();
-
-        if (done) {
-          await this.cleanup();
-          this.emit("end");
-          return;
-        }
-
-        const shouldContinue = await this.processData(value);
-
-        if (!shouldContinue) {
-          return;
-        }
-      } catch (error) {
-        await this.cleanup();
-        this.emit("error", error);
-        return;
-      }
-    }
-  }
-
-  private async processData(data: Uint8Array): Promise<boolean> {
-    // Append new data to the temp buffer
-    const newBuffer = new Uint8Array(this.buffer.length + data.length);
-    newBuffer.set(this.buffer);
-    newBuffer.set(data, this.buffer.length);
-    this.buffer = newBuffer;
-
-    const dataString = new TextDecoder("utf-8").decode(this.buffer);
-
-    let lines = dataString.split("\n").filter((line) => line.trim() !== "");
-
-    // If the last line isn't complete, keep it in the buffer for next time
-    if (!dataString.endsWith("\n")) {
-      const lastLine = lines.pop() || "";
-      const remainingBytes = new TextEncoder().encode(lastLine);
-      this.buffer = new Uint8Array(remainingBytes);
-    } else {
-      this.buffer = new Uint8Array();
-    }
-
-    for (const line of lines) {
-      const cleanedLine = line.replace(/^data: /, "");
-
-      if (cleanedLine === "[DONE]") {
-        await this.cleanup();
-        this.emit("end");
-        return false;
-      }
-
-      let json;
-      try {
-        json = JSON.parse(cleanedLine);
-      } catch (error) {
-        console.error("Failed to parse JSON:", error);
-        continue;
-      }
-
-      this.emit("data", json);
-    }
-    return true;
-  }
-}

package/src/openai/index.tsx

@@ -1,5 +0,0 @@
-export {
-  ChatCompletionStream,
-  type ChatCompletionStreamConfiguration,
-} from "./chat-completion-stream";
-export { type ChatCompletionTransportFetchParams } from "./chat-completion-transport";

package/src/types/annotated-function.ts

@@ -1,27 +0,0 @@
-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/base.ts

@@ -1,61 +0,0 @@
-export type Role = "system" | "user" | "assistant" | "function";
-
-export interface Message {
-  id: string;
-  createdAt?: Date;
-  content: string;
-  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.
-   */
-  name?: string;
-  /**
-   * If the assistant role makes a function call, the `function_call` field
-   * contains the function call name and arguments. Otherwise, the field should
-   * not be set.
-   */
-  function_call?: FunctionCall;
-}
-
-export interface FunctionCall {
-  /**
-   * The arguments to call the function with, as generated by the model in JSON
-   * format. Note that the model does not always generate valid JSON, and may
-   * hallucinate parameters not defined by your function schema. Validate the
-   * arguments in your code before calling your function.
-   */
-  arguments?: string;
-  /**
-   * The name of the function to call.
-   */
-  name?: string;
-}
-
-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>;