@copilotkit/react-core 0.16.0 → 0.17.0-alpha.0

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

@@ -0,0 +1,240 @@
+import EventEmitter from "eventemitter3";
+import { Function, Message, Role } from "../types";
+import {
+  ChatCompletionTransport,
+  ChatCompletionTransportFetchParams,
+} from "./chat-completion-transport";
+
+interface ChatCompletionClientConfiguration {
+  url: string;
+  model?: string;
+}
+
+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 url: string;
+  private model?: string;
+
+  private chatCompletionTransport: ChatCompletionTransport | null = null;
+  private mode: "function" | "message" | null = null;
+  private functionCallName: string = "";
+  private functionCallArguments: string = "";
+
+  constructor(params: ChatCompletionClientConfiguration) {
+    super();
+    this.model = params.model;
+    this.url = params.url;
+  }
+
+  public async fetch(params: ChatCompletionTransportFetchParams) {
+    params = { ...params };
+    if (this.model && this.model in maxTokensByModel) {
+      params.maxTokens ||= maxTokensByModel[this.model];
+    } else {
+      params.maxTokens ||= DEFAULT_MAX_TOKENS;
+    }
+
+    params.functions ||= [];
+    params.model = this.model;
+    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({
+      url: this.url,
+    });
+
+    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

@@ -0,0 +1,56 @@
+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({
+      url: this.url,
+    });
+
+    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

@@ -0,0 +1,190 @@
+import EventEmitter from "eventemitter3";
+import { Message, Function } from "../types";
+import { CopilotApiConfig } from "../context";
+
+export interface ChatCompletionTransportConfiguration {
+  url: string;
+}
+
+interface ChatCompletionTransportEvents {
+  end: void;
+  data: any;
+  error: any;
+}
+
+export interface ChatCompletionTransportFetchParams {
+  model?: string;
+  messages: Message[];
+  functions?: Function[];
+  temperature?: number;
+  maxTokens?: number;
+  headers?: Record<string, string> | Headers;
+  body?: object;
+  copilotConfig: CopilotApiConfig;
+  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;
+  private url: string;
+
+  constructor({ url }: ChatCompletionTransportConfiguration) {
+    super();
+    this.url = url;
+  }
+
+  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({
+    model,
+    messages,
+    copilotConfig,
+    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(this.url, {
+        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

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

package/src/openai-assistants/hooks/use-copilot-chat-v2.ts

@@ -1,7 +1,7 @@
 import { useContext, useMemo, useState } from "react";
 import { processMessageStream } from "../utils";
 import { Message, parseStreamPart } from "@copilotkit/shared";
-import { CopilotContext, copilotApiConfigExtrapolator } from "../../context";
+import { CopilotContext } from "../../context";
 import { defaultCopilotContextCategories } from "../../components";
 
 export type AssistantStatus = "in_progress" | "awaiting_message";
@@ -87,7 +87,7 @@ export function useCopilotChatV2(options: UseCopilotChatOptionsV2): UseCopilotCh
 
     setInput("");
 
-    const apiUrl = copilotApiConfigExtrapolator(copilotApiConfig).chatApiEndpointV2;
+    const apiUrl = copilotApiConfig.chatApiEndpointV2;
 
     const functions = getChatCompletionFunctionDescriptions();
 

package/src/types/base.ts

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

package/src/types/index.ts

@@ -1,3 +1,4 @@
 export type { AnnotatedFunctionArgument } from "./annotated-function";
 export type { AnnotatedFunction } from "./annotated-function";
 export type { DocumentPointer } from "./document-pointer";
+export type { Role, Message, Function, FunctionCall, FunctionCallHandler } from "./base";

package/dist/chunk-7GFKOIO7.mjs

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

package/dist/chunk-7GFKOIO7.mjs.map

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

package/dist/chunk-BABVSMJR.mjs

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

package/dist/chunk-BABVSMJR.mjs.map

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

package/dist/chunk-DE37LEZJ.mjs

@@ -1,79 +0,0 @@
-import { defaultCopilotContextCategories } from './chunk-EV26IMLL.mjs';
-import { CopilotContext, copilotApiConfigExtrapolator } from './chunk-YGJFU4ZP.mjs';
-import { __objRest, __spreadProps, __spreadValues } from './chunk-MRXNTQOX.mjs';
-import { useContext, useMemo } from 'react';
-import { useChat } from 'ai/react';
-
-function useCopilotChat(_a) {
-  var _b = _a, {
-    makeSystemMessage
-  } = _b, options = __objRest(_b, [
-    "makeSystemMessage"
-  ]);
-  const {
-    getContextString,
-    getChatCompletionFunctionDescriptions,
-    getFunctionCallHandler,
-    copilotApiConfig
-  } = useContext(CopilotContext);
-  const systemMessage = useMemo(() => {
-    const systemMessageMaker = makeSystemMessage || defaultSystemMessage;
-    const contextString = getContextString([], defaultCopilotContextCategories);
-    return {
-      id: "system",
-      content: systemMessageMaker(contextString),
-      role: "system"
-    };
-  }, [getContextString, makeSystemMessage]);
-  const initialMessagesWithContext = [systemMessage].concat(options.initialMessages || []);
-  const functionDescriptions = useMemo(() => {
-    return getChatCompletionFunctionDescriptions();
-  }, [getChatCompletionFunctionDescriptions]);
-  const { messages, append, reload, stop, isLoading, input, setInput } = useChat(__spreadProps(__spreadValues({}, options), {
-    api: copilotApiConfigExtrapolator(copilotApiConfig).chatApiEndpoint,
-    id: options.id,
-    initialMessages: initialMessagesWithContext,
-    experimental_onFunctionCall: getFunctionCallHandler(),
-    headers: __spreadValues(__spreadValues({}, copilotApiConfig.headers), options.headers),
-    body: __spreadValues(__spreadValues(__spreadValues({
-      id: options.id
-    }, functionDescriptions.length > 0 && { functions: functionDescriptions }), copilotApiConfig.body), options.body)
-  }));
-  const visibleMessages = messages.filter(
-    (message) => message.role === "user" || message.role === "assistant"
-  );
-  return {
-    visibleMessages,
-    append,
-    reload,
-    stop,
-    isLoading,
-    input,
-    setInput
-  };
-}
-function defaultSystemMessage(contextString) {
-  return `
-Please act as an efficient, competent, conscientious, and industrious professional assistant.
-
-Help the user achieve their goals, and you do so in a way that is as efficient as possible, without unnecessary fluff, but also without sacrificing professionalism.
-Always be polite and respectful, and prefer brevity over verbosity.
-
-The user has provided you with the following context:
-\`\`\`
-${contextString}
-\`\`\`
-
-They have also provided you with functions you can call to initiate actions on their behalf, or functions you can call to receive more information.
-
-Please assist them as best you can.
-
-You can ask them for clarifying questions if needed, but don't be annoying about it. If you can reasonably 'fill in the blanks' yourself, do so.
-
-If you would like to call a function, call it without saying anything else.
-`;
-}
-
-export { defaultSystemMessage, useCopilotChat };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-DE37LEZJ.mjs.map

package/dist/chunk-DE37LEZJ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/hooks/use-copilot-chat.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAAA,SAAS,SAAS,kBAAkB;AAMpC,SAAS,eAAe;AAuBjB,SAAS,eAAe,IAGiB;AAHjB,eAC7B;AAAA;AAAA,EA9BF,IA6B+B,IAE1B,oBAF0B,IAE1B;AAAA,IADH;AAAA;AAGA,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI,WAAW,cAAc;AAE7B,QAAM,gBAAyB,QAAQ,MAAM;AAC3C,UAAM,qBAAqB,qBAAqB;AAChD,UAAM,gBAAgB,iBAAiB,CAAC,GAAG,+BAA+B;AAE1E,WAAO;AAAA,MACL,IAAI;AAAA,MACJ,SAAS,mBAAmB,aAAa;AAAA,MACzC,MAAM;AAAA,IACR;AAAA,EACF,GAAG,CAAC,kBAAkB,iBAAiB,CAAC;AAExC,QAAM,6BAA6B,CAAC,aAAa,EAAE,OAAO,QAAQ,mBAAmB,CAAC,CAAC;AAEvF,QAAM,uBAA8D,QAAQ,MAAM;AAChF,WAAO,sCAAsC;AAAA,EAC/C,GAAG,CAAC,qCAAqC,CAAC;AAE1C,QAAM,EAAE,UAAU,QAAQ,QAAQ,MAAM,WAAW,OAAO,SAAS,IAAI,QAAQ,iCAC1E,UAD0E;AAAA,IAE7E,KAAK,6BAA6B,gBAAgB,EAAE;AAAA,IACpD,IAAI,QAAQ;AAAA,IACZ,iBAAiB;AAAA,IACjB,6BAA6B,uBAAuB;AAAA,IACpD,SAAS,kCAAK,iBAAiB,UAAY,QAAQ;AAAA,IACnD,MAAM;AAAA,MACJ,IAAI,QAAQ;AAAA,OACR,qBAAqB,SAAS,KAAK,EAAE,WAAW,qBAAqB,IACtE,iBAAiB,OACjB,QAAQ;AAAA,EAEf,EAAC;AAED,QAAM,kBAAkB,SAAS;AAAA,IAC/B,CAAC,YAAY,QAAQ,SAAS,UAAU,QAAQ,SAAS;AAAA,EAC3D;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,SAAS,qBAAqB,eAA+B;AAClE,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWF","sourcesContent":["import { useMemo, useContext } from \"react\";\nimport {\n  CopilotContext,\n  CopilotContextParams,\n  copilotApiConfigExtrapolator,\n} from \"../context/copilot-context\";\nimport { useChat } from \"ai/react\";\nimport { ChatRequestOptions, CreateMessage, Message } from \"ai\";\nimport { UseChatOptions } from \"ai\";\nimport { defaultCopilotContextCategories } from \"../components\";\nimport { ChatCompletionCreateParams } from \"openai/resources/chat\";\n\nexport interface UseCopilotChatOptions extends UseChatOptions {\n  makeSystemMessage?: (contextString: string) => string;\n}\n\nexport interface UseCopilotChatReturn {\n  visibleMessages: Message[];\n  append: (\n    message: Message | CreateMessage,\n    chatRequestOptions?: ChatRequestOptions,\n  ) => Promise<string | null | undefined>;\n  reload: (chatRequestOptions?: ChatRequestOptions) => Promise<string | null | undefined>;\n  stop: () => void;\n  isLoading: boolean;\n  input: string;\n  setInput: React.Dispatch<React.SetStateAction<string>>;\n}\n\nexport function useCopilotChat({\n  makeSystemMessage,\n  ...options\n}: UseCopilotChatOptions): UseCopilotChatReturn {\n  const {\n    getContextString,\n    getChatCompletionFunctionDescriptions,\n    getFunctionCallHandler,\n    copilotApiConfig,\n  } = useContext(CopilotContext);\n\n  const systemMessage: Message = useMemo(() => {\n    const systemMessageMaker = makeSystemMessage || defaultSystemMessage;\n    const contextString = getContextString([], defaultCopilotContextCategories); // TODO: make the context categories configurable\n\n    return {\n      id: \"system\",\n      content: systemMessageMaker(contextString),\n      role: \"system\",\n    };\n  }, [getContextString, makeSystemMessage]);\n\n  const initialMessagesWithContext = [systemMessage].concat(options.initialMessages || []);\n\n  const functionDescriptions: ChatCompletionCreateParams.Function[] = useMemo(() => {\n    return getChatCompletionFunctionDescriptions();\n  }, [getChatCompletionFunctionDescriptions]);\n\n  const { messages, append, reload, stop, isLoading, input, setInput } = useChat({\n    ...options,\n    api: copilotApiConfigExtrapolator(copilotApiConfig).chatApiEndpoint,\n    id: options.id,\n    initialMessages: initialMessagesWithContext,\n    experimental_onFunctionCall: getFunctionCallHandler(),\n    headers: { ...copilotApiConfig.headers, ...options.headers },\n    body: {\n      id: options.id,\n      ...(functionDescriptions.length > 0 && { functions: functionDescriptions }),\n      ...copilotApiConfig.body,\n      ...options.body,\n    },\n  });\n\n  const visibleMessages = messages.filter(\n    (message) => message.role === \"user\" || message.role === \"assistant\",\n  );\n\n  return {\n    visibleMessages,\n    append,\n    reload,\n    stop,\n    isLoading,\n    input,\n    setInput,\n  };\n}\n\nexport function defaultSystemMessage(contextString: string): string {\n  return `\nPlease act as an efficient, competent, conscientious, and industrious professional assistant.\n\nHelp the user achieve their goals, and you do so in a way that is as efficient as possible, without unnecessary fluff, but also without sacrificing professionalism.\nAlways be polite and respectful, and prefer brevity over verbosity.\n\nThe user has provided you with the following context:\n\\`\\`\\`\n${contextString}\n\\`\\`\\`\n\nThey have also provided you with functions you can call to initiate actions on their behalf, or functions you can call to receive more information.\n\nPlease assist them as best you can.\n\nYou can ask them for clarifying questions if needed, but don't be annoying about it. If you can reasonably 'fill in the blanks' yourself, do so.\n\nIf you would like to call a function, call it without saying anything else.\n`;\n}\n"]}

package/dist/chunk-EFZPSZWO.mjs

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