@copilotkit/react-core 0.16.0-alpha.3 → 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-3MAIWZNZ.mjs

@@ -1,58 +0,0 @@
-import './chunk-MRXNTQOX.mjs';
-import React from 'react';
-
-function copilotApiConfigExtrapolator(config) {
-  return {
-    get chatApiEndpoint() {
-      return `${config.chatApiEndpoint}`;
-    },
-    get chatApiEndpointV2() {
-      return `${config.chatApiEndpointV2}`;
-    }
-  };
-}
-var emptyCopilotContext = {
-  entryPoints: {},
-  setEntryPoint: () => {
-  },
-  removeEntryPoint: () => {
-  },
-  getChatCompletionFunctionDescriptions: () => returnAndThrowInDebug(),
-  getFunctionCallHandler: () => returnAndThrowInDebug(),
-  getContextString: (documents, categories) => returnAndThrowInDebug(),
-  addContext: () => "",
-  removeContext: () => {
-  },
-  getDocumentsContext: (categories) => returnAndThrowInDebug(),
-  addDocumentContext: () => returnAndThrowInDebug(),
-  removeDocumentContext: () => {
-  },
-  copilotApiConfig: new class {
-    get chatApiEndpoint() {
-      throw new Error(
-        "Remember to wrap your app in a `<CopilotProvider> {...} </CopilotProvider>` !!!"
-      );
-    }
-    get chatApiEndpointV2() {
-      throw new Error(
-        "Remember to wrap your app in a `<CopilotProvider> {...} </CopilotProvider>` !!!"
-      );
-    }
-    get headers() {
-      return {};
-    }
-    get body() {
-      return {};
-    }
-  }()
-};
-var CopilotContext = React.createContext(emptyCopilotContext);
-function returnAndThrowInDebug(value) {
-  throw new Error(
-    "Remember to wrap your app in a `<CopilotProvider> {...} </CopilotProvider>` !!!"
-  );
-}
-
-export { CopilotContext, copilotApiConfigExtrapolator };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-3MAIWZNZ.mjs.map

package/dist/chunk-3MAIWZNZ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/context/copilot-context.tsx"],"names":[],"mappings":";;;;;AAGA,OAAO,WAAW;AA6CX,SAAS,6BAA6B,QAA0B;AACrE,SAAO;AAAA,IACL,IAAI,kBAA0B;AAC5B,aAAO,GAAG,OAAO;AAAA,IACnB;AAAA,IACA,IAAI,oBAA4B;AAC9B,aAAO,GAAG,OAAO;AAAA,IACnB;AAAA,EACF;AACF;AAwBA,IAAM,sBAA4C;AAAA,EAChD,aAAa,CAAC;AAAA,EACd,eAAe,MAAM;AAAA,EAAC;AAAA,EACtB,kBAAkB,MAAM;AAAA,EAAC;AAAA,EACzB,uCAAuC,MAAM,sBAAsB,CAAC,CAAC;AAAA,EACrE,wBAAwB,MAAM,sBAAsB,MAAY;AAAA,EAAC,EAAC;AAAA,EAElE,kBAAkB,CAAC,WAA8B,eAC/C,sBAAsB,EAAE;AAAA,EAC1B,YAAY,MAAM;AAAA,EAClB,eAAe,MAAM;AAAA,EAAC;AAAA,EAEtB,qBAAqB,CAAC,eAAyB,sBAAsB,CAAC,CAAC;AAAA,EACvE,oBAAoB,MAAM,sBAAsB,EAAE;AAAA,EAClD,uBAAuB,MAAM;AAAA,EAAC;AAAA,EAE9B,kBAAkB,IAAK,MAAkC;AAAA,IACvD,IAAI,kBAA0B;AAC5B,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,IACA,IAAI,oBAA4B;AAC9B,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AAAA,IACA,IAAI,UAAkC;AACpC,aAAO,CAAC;AAAA,IACV;AAAA,IACA,IAAI,OAA4B;AAC9B,aAAO,CAAC;AAAA,IACV;AAAA,EACF,EAAG;AACL;AAEO,IAAM,iBAAiB,MAAM,cAAoC,mBAAmB;AAE3F,SAAS,sBAAyB,OAAa;AAC7C,QAAM,IAAI;AAAA,IACR;AAAA,EACF;AACA,SAAO;AACT","sourcesContent":["\"use client\";\n\nimport { FunctionCallHandler } from \"ai\";\nimport React from \"react\";\nimport { TreeNodeId } from \"../hooks/use-tree\";\nimport { AnnotatedFunction } from \"../types/annotated-function\";\nimport { ChatCompletionCreateParams } from \"openai/resources/chat\";\nimport { DocumentPointer } from \"../types\";\n\n/**\n * Interface for the configuration of the Copilot API.\n */\nexport interface CopilotApiConfig {\n  /**\n   * The endpoint for the chat API.\n   */\n  chatApiEndpoint: string;\n\n  /**\n   * The endpoint for the chat API v2.\n   */\n  chatApiEndpointV2: string;\n\n  /**\n   * additional headers to be sent with the request\n   * @default {}\n   * @example\n   * ```\n   * {\n   *   'Authorization': 'Bearer your_token_here'\n   * }\n   * ```\n   */\n  headers: Record<string, string>;\n\n  /**\n   * Additional body params to be sent with the request\n   * @default {}\n   * @example\n   * ```\n   * {\n   *   'message': 'Hello, world!'\n   * }\n   * ```\n   */\n  body: Record<string, any>;\n}\n\nexport function copilotApiConfigExtrapolator(config: CopilotApiConfig) {\n  return {\n    get chatApiEndpoint(): string {\n      return `${config.chatApiEndpoint}`;\n    },\n    get chatApiEndpointV2(): string {\n      return `${config.chatApiEndpointV2}`;\n    },\n  };\n}\n\nexport interface CopilotContextParams {\n  // function-calling\n  entryPoints: Record<string, AnnotatedFunction<any[]>>;\n  setEntryPoint: (id: string, entryPoint: AnnotatedFunction<any[]>) => void;\n  removeEntryPoint: (id: string) => void;\n  getChatCompletionFunctionDescriptions: () => ChatCompletionCreateParams.Function[];\n  getFunctionCallHandler: () => FunctionCallHandler;\n\n  // text context\n  getContextString: (documents: DocumentPointer[], categories: string[]) => string;\n  addContext: (context: string, parentId?: string, categories?: string[]) => TreeNodeId;\n  removeContext: (id: TreeNodeId) => void;\n\n  // document context\n  getDocumentsContext: (categories: string[]) => DocumentPointer[];\n  addDocumentContext: (documentPointer: DocumentPointer, categories?: string[]) => TreeNodeId;\n  removeDocumentContext: (documentId: string) => void;\n\n  // api endpoints\n  copilotApiConfig: CopilotApiConfig;\n}\n\nconst emptyCopilotContext: CopilotContextParams = {\n  entryPoints: {},\n  setEntryPoint: () => {},\n  removeEntryPoint: () => {},\n  getChatCompletionFunctionDescriptions: () => returnAndThrowInDebug([]),\n  getFunctionCallHandler: () => returnAndThrowInDebug(async () => {}),\n\n  getContextString: (documents: DocumentPointer[], categories: string[]) =>\n    returnAndThrowInDebug(\"\"),\n  addContext: () => \"\",\n  removeContext: () => {},\n\n  getDocumentsContext: (categories: string[]) => returnAndThrowInDebug([]),\n  addDocumentContext: () => returnAndThrowInDebug(\"\"),\n  removeDocumentContext: () => {},\n\n  copilotApiConfig: new (class implements CopilotApiConfig {\n    get chatApiEndpoint(): string {\n      throw new Error(\n        \"Remember to wrap your app in a `<CopilotProvider> {...} </CopilotProvider>` !!!\",\n      );\n    }\n    get chatApiEndpointV2(): string {\n      throw new Error(\n        \"Remember to wrap your app in a `<CopilotProvider> {...} </CopilotProvider>` !!!\",\n      );\n    }\n    get headers(): Record<string, string> {\n      return {};\n    }\n    get body(): Record<string, any> {\n      return {};\n    }\n  })(),\n};\n\nexport const CopilotContext = React.createContext<CopilotContextParams>(emptyCopilotContext);\n\nfunction returnAndThrowInDebug<T>(value: T): T {\n  throw new Error(\n    \"Remember to wrap your app in a `<CopilotProvider> {...} </CopilotProvider>` !!!\",\n  );\n  return value;\n}\n"]}

package/dist/chunk-45PUEKTG.mjs

@@ -1,19 +0,0 @@
-import { CopilotContext } from './chunk-3MAIWZNZ.mjs';
-import { useContext, useRef, useEffect } from 'react';
-
-function useMakeCopilotReadable(information, parentId, categories) {
-  const { addContext, removeContext } = useContext(CopilotContext);
-  const idRef = useRef();
-  useEffect(() => {
-    const id = addContext(information, parentId, categories);
-    idRef.current = id;
-    return () => {
-      removeContext(id);
-    };
-  }, [information, parentId, addContext, removeContext]);
-  return idRef.current;
-}
-
-export { useMakeCopilotReadable };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-45PUEKTG.mjs.map

package/dist/chunk-45PUEKTG.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/hooks/use-make-copilot-readable.ts"],"names":[],"mappings":";;;;;AAEA,SAAS,YAAY,WAAW,cAAc;AAUvC,SAAS,uBACd,aACA,UACA,YACoB;AACpB,QAAM,EAAE,YAAY,cAAc,IAAI,WAAW,cAAc;AAC/D,QAAM,QAAQ,OAAe;AAE7B,YAAU,MAAM;AACd,UAAM,KAAK,WAAW,aAAa,UAAU,UAAU;AACvD,UAAM,UAAU;AAEhB,WAAO,MAAM;AACX,oBAAc,EAAE;AAAA,IAClB;AAAA,EACF,GAAG,CAAC,aAAa,UAAU,YAAY,aAAa,CAAC;AAErD,SAAO,MAAM;AACf","sourcesContent":["\"use client\";\n\nimport { useContext, useEffect, useRef } from \"react\";\nimport { CopilotContext } from \"../context/copilot-context\";\n\n/**\n * Adds the given information to the Copilot context to make it readable by Copilot.\n * @param information - The information to be added to the Copilot context.\n * @param parentId - The ID of the parent context, if any.\n * @param categories - An array of categories to control which context are visible where. Particularly useful with CopilotTextarea (see `useMakeAutosuggestionFunction`)\n * @returns The ID of the added context.\n */\nexport function useMakeCopilotReadable(\n  information: string,\n  parentId?: string,\n  categories?: string[],\n): string | undefined {\n  const { addContext, removeContext } = useContext(CopilotContext);\n  const idRef = useRef<string>();\n\n  useEffect(() => {\n    const id = addContext(information, parentId, categories);\n    idRef.current = id;\n\n    return () => {\n      removeContext(id);\n    };\n  }, [information, parentId, addContext, removeContext]);\n\n  return idRef.current;\n}\n"]}