ai 0.0.0-e27b4ed4-20240419203611

package/vue/dist/index.js

@@ -0,0 +1,1002 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// vue/index.ts
+var vue_exports = {};
+__export(vue_exports, {
+  useChat: () => useChat,
+  useCompletion: () => useCompletion
+});
+module.exports = __toCommonJS(vue_exports);
+
+// vue/use-chat.ts
+var import_swrv = __toESM(require("swrv"));
+var import_vue = require("vue");
+
+// shared/stream-parts.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 assistantMessageStreamPart = {
+  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 assistantControlDataStreamPart = {
+  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 dataMessageStreamPart = {
+  code: "6",
+  name: "data_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("role" in value) || !("data" in value) || typeof value.role !== "string" || value.role !== "data") {
+      throw new Error(
+        '"data_message" parts expect an object with a "role" and "data" property.'
+      );
+    }
+    return {
+      type: "data_message",
+      value
+    };
+  }
+};
+var toolCallStreamPart = {
+  code: "7",
+  name: "tool_calls",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some(
+      (tc) => tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string"
+    )) {
+      throw new Error(
+        '"tool_calls" parts expect an object with a ToolCallPayload.'
+      );
+    }
+    return {
+      type: "tool_calls",
+      value
+    };
+  }
+};
+var messageAnnotationsStreamPart = {
+  code: "8",
+  name: "message_annotations",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"message_annotations" parts expect an array value.');
+    }
+    return { type: "message_annotations", value };
+  }
+};
+var streamParts = [
+  textStreamPart,
+  functionCallStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  assistantMessageStreamPart,
+  assistantControlDataStreamPart,
+  dataMessageStreamPart,
+  toolCallStreamPart,
+  messageAnnotationsStreamPart
+];
+var streamPartsByCode = {
+  [textStreamPart.code]: textStreamPart,
+  [functionCallStreamPart.code]: functionCallStreamPart,
+  [dataStreamPart.code]: dataStreamPart,
+  [errorStreamPart.code]: errorStreamPart,
+  [assistantMessageStreamPart.code]: assistantMessageStreamPart,
+  [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
+  [dataMessageStreamPart.code]: dataMessageStreamPart,
+  [toolCallStreamPart.code]: toolCallStreamPart,
+  [messageAnnotationsStreamPart.code]: messageAnnotationsStreamPart
+};
+var StreamStringPrefixes = {
+  [textStreamPart.name]: textStreamPart.code,
+  [functionCallStreamPart.name]: functionCallStreamPart.code,
+  [dataStreamPart.name]: dataStreamPart.code,
+  [errorStreamPart.name]: errorStreamPart.code,
+  [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
+  [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
+  [dataMessageStreamPart.name]: dataMessageStreamPart.code,
+  [toolCallStreamPart.name]: toolCallStreamPart.code,
+  [messageAnnotationsStreamPart.name]: messageAnnotationsStreamPart.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);
+};
+
+// shared/read-data-stream.ts
+var NEWLINE = "\n".charCodeAt(0);
+function concatChunks(chunks, totalLength) {
+  const concatenatedChunks = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    concatenatedChunks.set(chunk, offset);
+    offset += chunk.length;
+  }
+  chunks.length = 0;
+  return concatenatedChunks;
+}
+async function* readDataStream(reader, {
+  isAborted
+} = {}) {
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let totalLength = 0;
+  while (true) {
+    const { value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      totalLength += value.length;
+      if (value[value.length - 1] !== NEWLINE) {
+        continue;
+      }
+    }
+    if (chunks.length === 0) {
+      break;
+    }
+    const concatenatedChunks = concatChunks(chunks, totalLength);
+    totalLength = 0;
+    const streamParts2 = decoder.decode(concatenatedChunks, { stream: true }).split("\n").filter((line) => line !== "").map(parseStreamPart);
+    for (const streamPart of streamParts2) {
+      yield streamPart;
+    }
+    if (isAborted == null ? void 0 : isAborted()) {
+      reader.cancel();
+      break;
+    }
+  }
+}
+
+// shared/generate-id.ts
+var import_non_secure = require("nanoid/non-secure");
+var generateId = (0, import_non_secure.customAlphabet)(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+
+// shared/parse-complex-response.ts
+function assignAnnotationsToMessage(message, annotations) {
+  if (!message || !annotations || !annotations.length)
+    return message;
+  return { ...message, annotations: [...annotations] };
+}
+async function parseComplexResponse({
+  reader,
+  abortControllerRef,
+  update,
+  onFinish,
+  generateId: generateId2 = generateId,
+  getCurrentDate = () => /* @__PURE__ */ new Date()
+}) {
+  const createdAt = getCurrentDate();
+  const prefixMap = {
+    data: []
+  };
+  let message_annotations = void 0;
+  for await (const { type, value } of readDataStream(reader, {
+    isAborted: () => (abortControllerRef == null ? void 0 : abortControllerRef.current) === null
+  })) {
+    if (type === "text") {
+      if (prefixMap["text"]) {
+        prefixMap["text"] = {
+          ...prefixMap["text"],
+          content: (prefixMap["text"].content || "") + value
+        };
+      } else {
+        prefixMap["text"] = {
+          id: generateId2(),
+          role: "assistant",
+          content: value,
+          createdAt
+        };
+      }
+    }
+    let functionCallMessage = null;
+    if (type === "function_call") {
+      prefixMap["function_call"] = {
+        id: generateId2(),
+        role: "assistant",
+        content: "",
+        function_call: value.function_call,
+        name: value.function_call.name,
+        createdAt
+      };
+      functionCallMessage = prefixMap["function_call"];
+    }
+    let toolCallMessage = null;
+    if (type === "tool_calls") {
+      prefixMap["tool_calls"] = {
+        id: generateId2(),
+        role: "assistant",
+        content: "",
+        tool_calls: value.tool_calls,
+        createdAt
+      };
+      toolCallMessage = prefixMap["tool_calls"];
+    }
+    if (type === "data") {
+      prefixMap["data"].push(...value);
+    }
+    let responseMessage = prefixMap["text"];
+    if (type === "message_annotations") {
+      if (!message_annotations) {
+        message_annotations = [...value];
+      } else {
+        message_annotations.push(...value);
+      }
+      functionCallMessage = assignAnnotationsToMessage(
+        prefixMap["function_call"],
+        message_annotations
+      );
+      toolCallMessage = assignAnnotationsToMessage(
+        prefixMap["tool_calls"],
+        message_annotations
+      );
+      responseMessage = assignAnnotationsToMessage(
+        prefixMap["text"],
+        message_annotations
+      );
+    }
+    if (message_annotations == null ? void 0 : message_annotations.length) {
+      const messagePrefixKeys = [
+        "text",
+        "function_call",
+        "tool_calls"
+      ];
+      messagePrefixKeys.forEach((key) => {
+        if (prefixMap[key]) {
+          prefixMap[key].annotations = [...message_annotations];
+        }
+      });
+    }
+    const merged = [functionCallMessage, toolCallMessage, responseMessage].filter(Boolean).map((message) => ({
+      ...assignAnnotationsToMessage(message, message_annotations)
+    }));
+    update(merged, [...prefixMap["data"]]);
+  }
+  onFinish == null ? void 0 : onFinish(prefixMap);
+  return {
+    messages: [
+      prefixMap.text,
+      prefixMap.function_call,
+      prefixMap.tool_calls
+    ].filter(Boolean),
+    data: prefixMap.data
+  };
+}
+
+// shared/utils.ts
+function createChunkDecoder(complex) {
+  const decoder = new TextDecoder();
+  if (!complex) {
+    return function(chunk) {
+      if (!chunk)
+        return "";
+      return decoder.decode(chunk, { stream: true });
+    };
+  }
+  return function(chunk) {
+    const decoded = decoder.decode(chunk, { stream: true }).split("\n").filter((line) => line !== "");
+    return decoded.map(parseStreamPart).filter(Boolean);
+  };
+}
+
+// shared/call-chat-api.ts
+async function callChatApi({
+  api,
+  messages,
+  body,
+  streamMode = "stream-data",
+  credentials,
+  headers,
+  abortController,
+  restoreMessagesOnFailure,
+  onResponse,
+  onUpdate,
+  onFinish,
+  generateId: generateId2
+}) {
+  var _a;
+  const response = await fetch(api, {
+    method: "POST",
+    body: JSON.stringify({
+      messages,
+      ...body
+    }),
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: (_a = abortController == null ? void 0 : abortController()) == null ? void 0 : _a.signal,
+    credentials
+  }).catch((err) => {
+    restoreMessagesOnFailure();
+    throw err;
+  });
+  if (onResponse) {
+    try {
+      await onResponse(response);
+    } catch (err) {
+      throw err;
+    }
+  }
+  if (!response.ok) {
+    restoreMessagesOnFailure();
+    throw new Error(
+      await response.text() || "Failed to fetch the chat response."
+    );
+  }
+  if (!response.body) {
+    throw new Error("The response body is empty.");
+  }
+  const reader = response.body.getReader();
+  switch (streamMode) {
+    case "text": {
+      const decoder = createChunkDecoder();
+      const resultMessage = {
+        id: generateId2(),
+        createdAt: /* @__PURE__ */ new Date(),
+        role: "assistant",
+        content: ""
+      };
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        resultMessage.content += decoder(value);
+        resultMessage.id = generateId2();
+        onUpdate([{ ...resultMessage }], []);
+        if ((abortController == null ? void 0 : abortController()) === null) {
+          reader.cancel();
+          break;
+        }
+      }
+      onFinish == null ? void 0 : onFinish(resultMessage);
+      return {
+        messages: [resultMessage],
+        data: []
+      };
+    }
+    case "stream-data": {
+      return await parseComplexResponse({
+        reader,
+        abortControllerRef: abortController != null ? { current: abortController() } : void 0,
+        update: onUpdate,
+        onFinish(prefixMap) {
+          if (onFinish && prefixMap.text != null) {
+            onFinish(prefixMap.text);
+          }
+        },
+        generateId: generateId2
+      });
+    }
+    default: {
+      const exhaustiveCheck = streamMode;
+      throw new Error(`Unknown stream mode: ${exhaustiveCheck}`);
+    }
+  }
+}
+
+// shared/process-chat-stream.ts
+async function processChatStream({
+  getStreamedResponse,
+  experimental_onFunctionCall,
+  experimental_onToolCall,
+  updateChatRequest,
+  getCurrentMessages
+}) {
+  while (true) {
+    const messagesAndDataOrJustMessage = await getStreamedResponse();
+    if ("messages" in messagesAndDataOrJustMessage) {
+      let hasFollowingResponse = false;
+      for (const message of messagesAndDataOrJustMessage.messages) {
+        if ((message.function_call === void 0 || typeof message.function_call === "string") && (message.tool_calls === void 0 || typeof message.tool_calls === "string")) {
+          continue;
+        }
+        hasFollowingResponse = true;
+        if (experimental_onFunctionCall) {
+          const functionCall = message.function_call;
+          if (typeof functionCall !== "object") {
+            console.warn(
+              "experimental_onFunctionCall should not be defined when using tools"
+            );
+            continue;
+          }
+          const functionCallResponse = await experimental_onFunctionCall(
+            getCurrentMessages(),
+            functionCall
+          );
+          if (functionCallResponse === void 0) {
+            hasFollowingResponse = false;
+            break;
+          }
+          updateChatRequest(functionCallResponse);
+        }
+        if (experimental_onToolCall) {
+          const toolCalls = message.tool_calls;
+          if (!Array.isArray(toolCalls) || toolCalls.some((toolCall) => typeof toolCall !== "object")) {
+            console.warn(
+              "experimental_onToolCall should not be defined when using tools"
+            );
+            continue;
+          }
+          const toolCallResponse = await experimental_onToolCall(getCurrentMessages(), toolCalls);
+          if (toolCallResponse === void 0) {
+            hasFollowingResponse = false;
+            break;
+          }
+          updateChatRequest(toolCallResponse);
+        }
+      }
+      if (!hasFollowingResponse) {
+        break;
+      }
+    } else {
+      let fixFunctionCallArguments2 = function(response) {
+        for (const message of response.messages) {
+          if (message.tool_calls !== void 0) {
+            for (const toolCall of message.tool_calls) {
+              if (typeof toolCall === "object") {
+                if (toolCall.function.arguments && typeof toolCall.function.arguments !== "string") {
+                  toolCall.function.arguments = JSON.stringify(
+                    toolCall.function.arguments
+                  );
+                }
+              }
+            }
+          }
+          if (message.function_call !== void 0) {
+            if (typeof message.function_call === "object") {
+              if (message.function_call.arguments && typeof message.function_call.arguments !== "string") {
+                message.function_call.arguments = JSON.stringify(
+                  message.function_call.arguments
+                );
+              }
+            }
+          }
+        }
+      };
+      var fixFunctionCallArguments = fixFunctionCallArguments2;
+      const streamedResponseMessage = messagesAndDataOrJustMessage;
+      if ((streamedResponseMessage.function_call === void 0 || typeof streamedResponseMessage.function_call === "string") && (streamedResponseMessage.tool_calls === void 0 || typeof streamedResponseMessage.tool_calls === "string")) {
+        break;
+      }
+      if (experimental_onFunctionCall) {
+        const functionCall = streamedResponseMessage.function_call;
+        if (!(typeof functionCall === "object")) {
+          console.warn(
+            "experimental_onFunctionCall should not be defined when using tools"
+          );
+          continue;
+        }
+        const functionCallResponse = await experimental_onFunctionCall(getCurrentMessages(), functionCall);
+        if (functionCallResponse === void 0)
+          break;
+        fixFunctionCallArguments2(functionCallResponse);
+        updateChatRequest(functionCallResponse);
+      }
+      if (experimental_onToolCall) {
+        const toolCalls = streamedResponseMessage.tool_calls;
+        if (!(typeof toolCalls === "object")) {
+          console.warn(
+            "experimental_onToolCall should not be defined when using functions"
+          );
+          continue;
+        }
+        const toolCallResponse = await experimental_onToolCall(getCurrentMessages(), toolCalls);
+        if (toolCallResponse === void 0)
+          break;
+        fixFunctionCallArguments2(toolCallResponse);
+        updateChatRequest(toolCallResponse);
+      }
+    }
+  }
+}
+
+// vue/use-chat.ts
+var uniqueId = 0;
+var useSWRV = import_swrv.default.default || import_swrv.default;
+var store = {};
+function useChat({
+  api = "/api/chat",
+  id,
+  initialMessages = [],
+  initialInput = "",
+  sendExtraMessageFields,
+  experimental_onFunctionCall,
+  streamMode,
+  onResponse,
+  onFinish,
+  onError,
+  credentials,
+  headers,
+  body,
+  generateId: generateId2 = generateId
+} = {}) {
+  var _a, _b;
+  const chatId = id || `chat-${uniqueId++}`;
+  const key = `${api}|${chatId}`;
+  const { data: messagesData, mutate: originalMutate } = useSWRV(
+    key,
+    () => store[key] || initialMessages
+  );
+  const { data: isLoading, mutate: mutateLoading } = useSWRV(
+    `${chatId}-loading`,
+    null
+  );
+  (_a = isLoading.value) != null ? _a : isLoading.value = false;
+  (_b = messagesData.value) != null ? _b : messagesData.value = initialMessages;
+  const mutate = (data) => {
+    store[key] = data;
+    return originalMutate();
+  };
+  const messages = messagesData;
+  const error = (0, import_vue.ref)(void 0);
+  const streamData = (0, import_vue.ref)(void 0);
+  let abortController = null;
+  async function triggerRequest(messagesSnapshot, { options, data } = {}) {
+    try {
+      error.value = void 0;
+      mutateLoading(() => true);
+      abortController = new AbortController();
+      const previousMessages = messagesData.value;
+      mutate(messagesSnapshot);
+      let chatRequest = {
+        messages: messagesSnapshot,
+        options,
+        data
+      };
+      await processChatStream({
+        getStreamedResponse: async () => {
+          var _a2;
+          const existingData = (_a2 = streamData.value) != null ? _a2 : [];
+          return await callChatApi({
+            api,
+            messages: sendExtraMessageFields ? chatRequest.messages : chatRequest.messages.map(
+              ({ role, content, name, function_call }) => ({
+                role,
+                content,
+                ...name !== void 0 && { name },
+                ...function_call !== void 0 && {
+                  function_call
+                }
+              })
+            ),
+            body: {
+              data: chatRequest.data,
+              ...(0, import_vue.unref)(body),
+              // Use unref to unwrap the ref value
+              ...options == null ? void 0 : options.body
+            },
+            streamMode,
+            headers: {
+              ...headers,
+              ...options == null ? void 0 : options.headers
+            },
+            abortController: () => abortController,
+            credentials,
+            onResponse,
+            onUpdate(merged, data2) {
+              mutate([...chatRequest.messages, ...merged]);
+              streamData.value = [...existingData, ...data2 != null ? data2 : []];
+            },
+            onFinish(message) {
+              mutate([...chatRequest.messages, message]);
+              onFinish == null ? void 0 : onFinish(message);
+            },
+            restoreMessagesOnFailure() {
+              mutate(previousMessages);
+            },
+            generateId: generateId2
+          });
+        },
+        experimental_onFunctionCall,
+        updateChatRequest(newChatRequest) {
+          chatRequest = newChatRequest;
+        },
+        getCurrentMessages: () => messages.value
+      });
+      abortController = null;
+    } catch (err) {
+      if (err.name === "AbortError") {
+        abortController = null;
+        return null;
+      }
+      if (onError && err instanceof Error) {
+        onError(err);
+      }
+      error.value = err;
+    } finally {
+      mutateLoading(() => false);
+    }
+  }
+  const append = async (message, options) => {
+    if (!message.id) {
+      message.id = generateId2();
+    }
+    return triggerRequest(messages.value.concat(message), options);
+  };
+  const reload = async (options) => {
+    const messagesSnapshot = messages.value;
+    if (messagesSnapshot.length === 0)
+      return null;
+    const lastMessage = messagesSnapshot[messagesSnapshot.length - 1];
+    if (lastMessage.role === "assistant") {
+      return triggerRequest(messagesSnapshot.slice(0, -1), options);
+    }
+    return triggerRequest(messagesSnapshot, options);
+  };
+  const stop = () => {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+  };
+  const setMessages = (messages2) => {
+    mutate(messages2);
+  };
+  const input = (0, import_vue.ref)(initialInput);
+  const handleSubmit = (e, options = {}) => {
+    e.preventDefault();
+    const inputValue = input.value;
+    if (!inputValue)
+      return;
+    append(
+      {
+        content: inputValue,
+        role: "user"
+      },
+      options
+    );
+    input.value = "";
+  };
+  return {
+    messages,
+    append,
+    error,
+    reload,
+    stop,
+    setMessages,
+    input,
+    handleSubmit,
+    isLoading,
+    data: streamData
+  };
+}
+
+// vue/use-completion.ts
+var import_swrv2 = __toESM(require("swrv"));
+var import_vue2 = require("vue");
+
+// shared/call-completion-api.ts
+async function callCompletionApi({
+  api,
+  prompt,
+  credentials,
+  headers,
+  body,
+  streamMode = "stream-data",
+  setCompletion,
+  setLoading,
+  setError,
+  setAbortController,
+  onResponse,
+  onFinish,
+  onError,
+  onData
+}) {
+  try {
+    setLoading(true);
+    setError(void 0);
+    const abortController = new AbortController();
+    setAbortController(abortController);
+    setCompletion("");
+    const res = await fetch(api, {
+      method: "POST",
+      body: JSON.stringify({
+        prompt,
+        ...body
+      }),
+      credentials,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      signal: abortController.signal
+    }).catch((err) => {
+      throw err;
+    });
+    if (onResponse) {
+      try {
+        await onResponse(res);
+      } catch (err) {
+        throw err;
+      }
+    }
+    if (!res.ok) {
+      throw new Error(
+        await res.text() || "Failed to fetch the chat response."
+      );
+    }
+    if (!res.body) {
+      throw new Error("The response body is empty.");
+    }
+    let result = "";
+    const reader = res.body.getReader();
+    switch (streamMode) {
+      case "text": {
+        const decoder = createChunkDecoder();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          result += decoder(value);
+          setCompletion(result);
+          if (abortController === null) {
+            reader.cancel();
+            break;
+          }
+        }
+        break;
+      }
+      case "stream-data": {
+        for await (const { type, value } of readDataStream(reader, {
+          isAborted: () => abortController === null
+        })) {
+          switch (type) {
+            case "text": {
+              result += value;
+              setCompletion(result);
+              break;
+            }
+            case "data": {
+              onData == null ? void 0 : onData(value);
+              break;
+            }
+          }
+        }
+        break;
+      }
+      default: {
+        const exhaustiveCheck = streamMode;
+        throw new Error(`Unknown stream mode: ${exhaustiveCheck}`);
+      }
+    }
+    if (onFinish) {
+      onFinish(prompt, result);
+    }
+    setAbortController(null);
+    return result;
+  } catch (err) {
+    if (err.name === "AbortError") {
+      setAbortController(null);
+      return null;
+    }
+    if (err instanceof Error) {
+      if (onError) {
+        onError(err);
+      }
+    }
+    setError(err);
+  } finally {
+    setLoading(false);
+  }
+}
+
+// vue/use-completion.ts
+var uniqueId2 = 0;
+var useSWRV2 = import_swrv2.default.default || import_swrv2.default;
+var store2 = {};
+function useCompletion({
+  api = "/api/completion",
+  id,
+  initialCompletion = "",
+  initialInput = "",
+  credentials,
+  headers,
+  body,
+  streamMode,
+  onResponse,
+  onFinish,
+  onError
+} = {}) {
+  var _a;
+  const completionId = id || `completion-${uniqueId2++}`;
+  const key = `${api}|${completionId}`;
+  const { data, mutate: originalMutate } = useSWRV2(
+    key,
+    () => store2[key] || initialCompletion
+  );
+  const { data: isLoading, mutate: mutateLoading } = useSWRV2(
+    `${completionId}-loading`,
+    null
+  );
+  (_a = isLoading.value) != null ? _a : isLoading.value = false;
+  const { data: streamData, mutate: mutateStreamData } = useSWRV2(`${completionId}-data`, null);
+  data.value || (data.value = initialCompletion);
+  const mutate = (data2) => {
+    store2[key] = data2;
+    return originalMutate();
+  };
+  const completion = data;
+  const error = (0, import_vue2.ref)(void 0);
+  let abortController = null;
+  async function triggerRequest(prompt, options) {
+    var _a2;
+    const existingData = (_a2 = streamData.value) != null ? _a2 : [];
+    return callCompletionApi({
+      api,
+      prompt,
+      credentials,
+      headers: {
+        ...headers,
+        ...options == null ? void 0 : options.headers
+      },
+      body: {
+        ...(0, import_vue2.unref)(body),
+        ...options == null ? void 0 : options.body
+      },
+      streamMode,
+      setCompletion: mutate,
+      setLoading: (loading) => mutateLoading(() => loading),
+      setError: (err) => {
+        error.value = err;
+      },
+      setAbortController: (controller) => {
+        abortController = controller;
+      },
+      onResponse,
+      onFinish,
+      onError,
+      onData: (data2) => {
+        mutateStreamData(() => [...existingData, ...data2 != null ? data2 : []]);
+      }
+    });
+  }
+  const complete = async (prompt, options) => {
+    return triggerRequest(prompt, options);
+  };
+  const stop = () => {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+  };
+  const setCompletion = (completion2) => {
+    mutate(completion2);
+  };
+  const input = (0, import_vue2.ref)(initialInput);
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    const inputValue = input.value;
+    if (!inputValue)
+      return;
+    return complete(inputValue);
+  };
+  return {
+    completion,
+    complete,
+    error,
+    stop,
+    setCompletion,
+    input,
+    handleSubmit,
+    isLoading,
+    data: streamData
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useChat,
+  useCompletion
+});
+//# sourceMappingURL=index.js.map