ai 2.2.23 → 2.2.25

package/react/dist/index.mjs

@@ -6,6 +6,129 @@ import useSWR from "swr";
 
 // shared/utils.ts
 import { customAlphabet } from "nanoid/non-secure";
+
+// 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 assistantMessage = {
+  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 assistantControlData = {
+  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 streamParts = [
+  textStreamPart,
+  functionCallStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  assistantMessage,
+  assistantControlData
+];
+var streamPartsByCode = {
+  [textStreamPart.code]: textStreamPart,
+  [functionCallStreamPart.code]: functionCallStreamPart,
+  [dataStreamPart.code]: dataStreamPart,
+  [errorStreamPart.code]: errorStreamPart,
+  [assistantMessage.code]: assistantMessage,
+  [assistantControlData.code]: assistantControlData
+};
+var StreamStringPrefixes = {
+  [textStreamPart.name]: textStreamPart.code,
+  [functionCallStreamPart.name]: functionCallStreamPart.code,
+  [dataStreamPart.name]: dataStreamPart.code,
+  [errorStreamPart.name]: errorStreamPart.code,
+  [assistantMessage.name]: assistantMessage.code,
+  [assistantControlData.name]: assistantControlData.code
+};
+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/utils.ts
 var nanoid = customAlphabet(
   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
   7
@@ -21,50 +144,30 @@ function createChunkDecoder(complex) {
   }
   return function(chunk) {
     const decoded = decoder.decode(chunk, { stream: true }).split("\n").filter((line) => line !== "");
-    return decoded.map(getStreamStringTypeAndValue).filter(Boolean);
+    return decoded.map(parseStreamPart).filter(Boolean);
   };
 }
-var StreamStringPrefixes = {
-  text: 0,
-  function_call: 1,
-  data: 2
-  // user_err: 3?
-};
-var getStreamStringTypeAndValue = (line) => {
-  const firstSeperatorIndex = line.indexOf(":");
-  if (firstSeperatorIndex === -1) {
-    throw new Error("Failed to parse stream string");
-  }
-  const prefix = line.slice(0, firstSeperatorIndex);
-  const type = Object.keys(StreamStringPrefixes).find(
-    (key) => StreamStringPrefixes[key] === Number(prefix)
-  );
-  const val = line.slice(firstSeperatorIndex + 1);
-  let parsedVal = val;
-  if (!val) {
-    return { type, value: "" };
-  }
-  try {
-    parsedVal = JSON.parse(val);
-  } catch (e) {
-    console.error("Failed to parse JSON value:", val);
-  }
-  return { type, value: parsedVal };
-};
 var COMPLEX_HEADER = "X-Experimental-Stream-Data";
 
-// react/parse-complex-response.ts
+// shared/call-api.ts
+import { nanoid as nanoid2 } from "nanoid";
+
+// shared/parse-complex-response.ts
 async function parseComplexResponse({
   reader,
   abortControllerRef,
   update,
-  onFinish
+  onFinish,
+  generateId = nanoid,
+  getCurrentDate = () => /* @__PURE__ */ new Date()
 }) {
+  const createdAt = getCurrentDate();
   const decode = createChunkDecoder(true);
-  const createdAt = /* @__PURE__ */ new Date();
-  const prefixMap = {};
+  const prefixMap = {
+    data: []
+  };
   const NEWLINE = "\n".charCodeAt(0);
-  let chunks = [];
+  const chunks = [];
   let totalLength = 0;
   while (true) {
     const { value } = await reader.read();
@@ -101,7 +204,7 @@ async function parseComplexResponse({
           };
         } else {
           prefixMap["text"] = {
-            id: nanoid(),
+            id: generateId(),
             role: "assistant",
             content: value2,
             createdAt
@@ -110,37 +213,24 @@ async function parseComplexResponse({
       }
       let functionCallMessage = null;
       if (type === "function_call") {
-        prefixMap["function_call"] = value2;
-        let functionCall = prefixMap["function_call"];
-        if (functionCall && typeof functionCall === "string") {
-          const parsedFunctionCall = JSON.parse(
-            functionCall
-          ).function_call;
-          functionCallMessage = {
-            id: nanoid(),
-            role: "assistant",
-            content: "",
-            function_call: parsedFunctionCall,
-            name: parsedFunctionCall.name,
-            createdAt
-          };
-          prefixMap["function_call"] = functionCallMessage;
-        }
+        prefixMap["function_call"] = {
+          id: generateId(),
+          role: "assistant",
+          content: "",
+          function_call: value2.function_call,
+          name: value2.function_call.name,
+          createdAt
+        };
+        functionCallMessage = prefixMap["function_call"];
       }
       if (type === "data") {
-        const parsedValue = JSON.parse(value2);
-        if (prefixMap["data"]) {
-          prefixMap["data"] = [...prefixMap["data"], ...parsedValue];
-        } else {
-          prefixMap["data"] = parsedValue;
-        }
+        prefixMap["data"].push(...value2);
       }
-      const data = prefixMap["data"];
       const responseMessage = prefixMap["text"];
       const merged = [functionCallMessage, responseMessage].filter(
         Boolean
       );
-      update(merged, data);
+      update(merged, [...prefixMap["data"]]);
       if ((abortControllerRef == null ? void 0 : abortControllerRef.current) === null) {
         reader.cancel();
         break;
@@ -148,7 +238,157 @@ async function parseComplexResponse({
     }
   }
   onFinish == null ? void 0 : onFinish(prefixMap);
-  return prefixMap;
+  return {
+    messages: [prefixMap.text, prefixMap.function_call].filter(
+      Boolean
+    ),
+    data: prefixMap.data
+  };
+}
+
+// shared/call-api.ts
+async function callApi({
+  api,
+  messages,
+  body,
+  credentials,
+  headers,
+  abortController,
+  appendMessage,
+  restoreMessagesOnFailure,
+  onResponse,
+  onUpdate,
+  onFinish
+}) {
+  var _a;
+  const response = await fetch(api, {
+    method: "POST",
+    body: JSON.stringify({
+      messages,
+      ...body
+    }),
+    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();
+  const isComplexMode = response.headers.get(COMPLEX_HEADER) === "true";
+  if (isComplexMode) {
+    return await parseComplexResponse({
+      reader,
+      abortControllerRef: abortController != null ? { current: abortController() } : void 0,
+      update: onUpdate,
+      onFinish(prefixMap) {
+        if (onFinish && prefixMap.text != null) {
+          onFinish(prefixMap.text);
+        }
+      }
+    });
+  } else {
+    const createdAt = /* @__PURE__ */ new Date();
+    const decode = createChunkDecoder(false);
+    let streamedResponse = "";
+    const replyId = nanoid2();
+    let responseMessage = {
+      id: replyId,
+      createdAt,
+      content: "",
+      role: "assistant"
+    };
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      streamedResponse += decode(value);
+      if (streamedResponse.startsWith('{"function_call":')) {
+        responseMessage["function_call"] = streamedResponse;
+      } else {
+        responseMessage["content"] = streamedResponse;
+      }
+      appendMessage({ ...responseMessage });
+      if ((abortController == null ? void 0 : abortController()) === null) {
+        reader.cancel();
+        break;
+      }
+    }
+    if (streamedResponse.startsWith('{"function_call":')) {
+      const parsedFunctionCall = JSON.parse(streamedResponse).function_call;
+      responseMessage["function_call"] = parsedFunctionCall;
+      appendMessage({ ...responseMessage });
+    }
+    if (onFinish) {
+      onFinish(responseMessage);
+    }
+    return responseMessage;
+  }
+}
+
+// shared/process-chat-stream.ts
+async function processChatStream({
+  getStreamedResponse: getStreamedResponse2,
+  experimental_onFunctionCall,
+  updateChatRequest,
+  getCurrentMessages
+}) {
+  while (true) {
+    const messagesAndDataOrJustMessage = await getStreamedResponse2();
+    if ("messages" in messagesAndDataOrJustMessage) {
+      let hasFollowingResponse = false;
+      for (const message of messagesAndDataOrJustMessage.messages) {
+        if (message.function_call === void 0 || typeof message.function_call === "string") {
+          continue;
+        }
+        hasFollowingResponse = true;
+        if (experimental_onFunctionCall) {
+          const functionCall = message.function_call;
+          const functionCallResponse = await experimental_onFunctionCall(
+            getCurrentMessages(),
+            functionCall
+          );
+          if (functionCallResponse === void 0) {
+            hasFollowingResponse = false;
+            break;
+          }
+          updateChatRequest(functionCallResponse);
+        }
+      }
+      if (!hasFollowingResponse) {
+        break;
+      }
+    } else {
+      const streamedResponseMessage = messagesAndDataOrJustMessage;
+      if (streamedResponseMessage.function_call === void 0 || typeof streamedResponseMessage.function_call === "string") {
+        break;
+      }
+      if (experimental_onFunctionCall) {
+        const functionCall = streamedResponseMessage.function_call;
+        const functionCallResponse = await experimental_onFunctionCall(getCurrentMessages(), functionCall);
+        if (functionCallResponse === void 0)
+          break;
+        updateChatRequest(functionCallResponse);
+      }
+    }
+  }
 }
 
 // react/use-chat.ts
@@ -197,10 +437,10 @@ var getStreamedResponse = async (api, chatRequest, mutate, mutateStreamData, exi
     }
     return responseMessage;
   }
-  const res = await fetch(api, {
-    method: "POST",
-    body: JSON.stringify({
-      messages: constructedMessagesPayload,
+  return await callApi({
+    api,
+    messages: constructedMessagesPayload,
+    body: {
       data: chatRequest.data,
       ...extraMetadataRef.current.body,
       ...(_a = chatRequest.options) == null ? void 0 : _a.body,
@@ -210,95 +450,26 @@ var getStreamedResponse = async (api, chatRequest, mutate, mutateStreamData, exi
       ...chatRequest.function_call !== void 0 && {
         function_call: chatRequest.function_call
       }
-    }),
+    },
     credentials: extraMetadataRef.current.credentials,
     headers: {
       ...extraMetadataRef.current.headers,
       ...(_b = chatRequest.options) == null ? void 0 : _b.headers
     },
-    ...abortControllerRef.current !== null && {
-      signal: abortControllerRef.current.signal
-    }
-  }).catch((err) => {
-    mutate(previousMessages, false);
-    throw err;
+    abortController: () => abortControllerRef.current,
+    appendMessage(message) {
+      mutate([...chatRequest.messages, message], false);
+    },
+    restoreMessagesOnFailure() {
+      mutate(previousMessages, false);
+    },
+    onResponse,
+    onUpdate(merged, data) {
+      mutate([...chatRequest.messages, ...merged], false);
+      mutateStreamData([...existingData || [], ...data || []], false);
+    },
+    onFinish
   });
-  if (onResponse) {
-    try {
-      await onResponse(res);
-    } catch (err) {
-      throw err;
-    }
-  }
-  if (!res.ok) {
-    mutate(previousMessages, false);
-    throw new Error(await res.text() || "Failed to fetch the chat response.");
-  }
-  if (!res.body) {
-    throw new Error("The response body is empty.");
-  }
-  const isComplexMode = res.headers.get(COMPLEX_HEADER) === "true";
-  let responseMessages = [];
-  const reader = res.body.getReader();
-  let responseData = [];
-  if (isComplexMode) {
-    const prefixMap = await parseComplexResponse({
-      reader,
-      abortControllerRef,
-      update(merged, data) {
-        mutate([...chatRequest.messages, ...merged], false);
-        mutateStreamData([...existingData || [], ...data || []], false);
-      }
-    });
-    for (const [type, item] of Object.entries(prefixMap)) {
-      if (onFinish && type === "text") {
-        onFinish(item);
-      }
-      if (type === "data") {
-        responseData.push(item);
-      } else {
-        responseMessages.push(item);
-      }
-    }
-    return { messages: responseMessages, data: responseData };
-  } else {
-    const createdAt = /* @__PURE__ */ new Date();
-    const decode = createChunkDecoder(false);
-    let streamedResponse = "";
-    const replyId = nanoid();
-    let responseMessage = {
-      id: replyId,
-      createdAt,
-      content: "",
-      role: "assistant"
-    };
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      streamedResponse += decode(value);
-      if (streamedResponse.startsWith('{"function_call":')) {
-        responseMessage["function_call"] = streamedResponse;
-      } else {
-        responseMessage["content"] = streamedResponse;
-      }
-      mutate([...chatRequest.messages, { ...responseMessage }], false);
-      if (abortControllerRef.current === null) {
-        reader.cancel();
-        break;
-      }
-    }
-    if (streamedResponse.startsWith('{"function_call":')) {
-      const parsedFunctionCall = JSON.parse(streamedResponse).function_call;
-      responseMessage["function_call"] = parsedFunctionCall;
-      mutate([...chatRequest.messages, { ...responseMessage }]);
-    }
-    if (onFinish) {
-      onFinish(responseMessage);
-    }
-    return responseMessage;
-  }
 };
 function useChat({
   api = "/api/chat",
@@ -324,10 +495,7 @@ function useChat({
     [chatId, "loading"],
     null
   );
-  const { data: streamData, mutate: mutateStreamData } = useSWR(
-    [chatId, "streamData"],
-    null
-  );
+  const { data: streamData, mutate: mutateStreamData } = useSWR([chatId, "streamData"], null);
   const messagesRef = useRef(messages || []);
   useEffect(() => {
     messagesRef.current = messages || [];
@@ -353,8 +521,8 @@ function useChat({
         setError(void 0);
         const abortController = new AbortController();
         abortControllerRef.current = abortController;
-        while (true) {
-          const messagesAndDataOrJustMessage = await getStreamedResponse(
+        await processChatStream({
+          getStreamedResponse: () => getStreamedResponse(
             api,
             chatRequest,
             mutate,
@@ -366,47 +534,13 @@ function useChat({
             onFinish,
             onResponse,
             sendExtraMessageFields
-          );
-          if ("messages" in messagesAndDataOrJustMessage) {
-            let hasFollowingResponse = false;
-            for (const message of messagesAndDataOrJustMessage.messages) {
-              if (message.function_call === void 0 || typeof message.function_call === "string") {
-                continue;
-              }
-              hasFollowingResponse = true;
-              if (experimental_onFunctionCall) {
-                const functionCall = message.function_call;
-                const functionCallResponse = await experimental_onFunctionCall(
-                  messagesRef.current,
-                  functionCall
-                );
-                if (functionCallResponse === void 0) {
-                  hasFollowingResponse = false;
-                  break;
-                }
-                chatRequest = functionCallResponse;
-              }
-            }
-            if (!hasFollowingResponse) {
-              break;
-            }
-          } else {
-            const streamedResponseMessage = messagesAndDataOrJustMessage;
-            if (streamedResponseMessage.function_call === void 0 || typeof streamedResponseMessage.function_call === "string") {
-              break;
-            }
-            if (experimental_onFunctionCall) {
-              const functionCall = streamedResponseMessage.function_call;
-              const functionCallResponse = await experimental_onFunctionCall(
-                messagesRef.current,
-                functionCall
-              );
-              if (functionCallResponse === void 0)
-                break;
-              chatRequest = functionCallResponse;
-            }
-          }
-        }
+          ),
+          experimental_onFunctionCall,
+          updateChatRequest: (chatRequestParam) => {
+            chatRequest = chatRequestParam;
+          },
+          getCurrentMessages: () => messagesRef.current
+        });
         abortControllerRef.current = null;
       } catch (err) {
         if (err.name === "AbortError") {
@@ -703,7 +837,115 @@ function useCompletion({
     isLoading
   };
 }
+
+// react/use-assistant.ts
+import { useState as useState3 } from "react";
+
+// shared/process-message-stream.ts
+async function processMessageStream(reader, processMessage) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      if (buffer.length > 0) {
+        processMessage(buffer);
+      }
+      break;
+    }
+    buffer += decoder.decode(value, { stream: true });
+    let endIndex;
+    while ((endIndex = buffer.indexOf("\n")) !== -1) {
+      processMessage(buffer.substring(0, endIndex).trim());
+      buffer = buffer.substring(endIndex + 1);
+    }
+  }
+}
+
+// react/use-assistant.ts
+function experimental_useAssistant({
+  api,
+  threadId: threadIdParam
+}) {
+  const [messages, setMessages] = useState3([]);
+  const [input, setInput] = useState3("");
+  const [threadId, setThreadId] = useState3(void 0);
+  const [status, setStatus] = useState3("awaiting_message");
+  const [error, setError] = useState3(void 0);
+  const handleInputChange = (e) => {
+    setInput(e.target.value);
+  };
+  const submitMessage = async (e) => {
+    var _a;
+    e.preventDefault();
+    if (input === "") {
+      return;
+    }
+    setStatus("in_progress");
+    setMessages((messages2) => [
+      ...messages2,
+      { id: "", role: "user", content: input }
+    ]);
+    setInput("");
+    const result = await fetch(api, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        // always use user-provided threadId when available:
+        threadId: (_a = threadIdParam != null ? threadIdParam : threadId) != null ? _a : null,
+        message: input
+      })
+    });
+    if (result.body == null) {
+      throw new Error("The response body is empty.");
+    }
+    await processMessageStream(result.body.getReader(), (message) => {
+      try {
+        const { type, value } = parseStreamPart(message);
+        switch (type) {
+          case "assistant_message": {
+            setMessages((messages2) => [
+              ...messages2,
+              {
+                id: value.id,
+                role: value.role,
+                content: value.content[0].text.value
+              }
+            ]);
+            break;
+          }
+          case "assistant_control_data": {
+            setThreadId(value.threadId);
+            setMessages((messages2) => {
+              const lastMessage = messages2[messages2.length - 1];
+              lastMessage.id = value.messageId;
+              return [...messages2.slice(0, messages2.length - 1), lastMessage];
+            });
+            break;
+          }
+          case "error": {
+            setError(value);
+            break;
+          }
+        }
+      } catch (error2) {
+        setError(error2);
+      }
+    });
+    setStatus("awaiting_message");
+  };
+  return {
+    messages,
+    threadId,
+    input,
+    handleInputChange,
+    submitMessage,
+    status,
+    error
+  };
+}
 export {
+  experimental_useAssistant,
   useChat,
   useCompletion
 };