ai 2.2.26 → 2.2.28

package/react/dist/index.d.ts

@@ -42,7 +42,7 @@ interface Message {
     createdAt?: Date;
     content: string;
     ui?: string | JSX.Element | JSX.Element[] | null | undefined;
-    role: 'system' | 'user' | 'assistant' | 'function';
+    role: 'system' | 'user' | 'assistant' | 'function' | 'data';
     /**
      * 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.
@@ -54,6 +54,7 @@ interface Message {
      * not be set.
      */
     function_call?: string | FunctionCall;
+    data?: JSONValue;
 }
 type CreateMessage = Omit<Message, 'id'> & {
     id?: Message['id'];
@@ -298,6 +299,7 @@ type StreamingReactResponseAction = (payload: {
 }) => Promise<experimental_StreamingReactResponse>;
 declare function useChat({ api, id, initialMessages, initialInput, sendExtraMessageFields, experimental_onFunctionCall, onResponse, onFinish, onError, credentials, headers, body, generateId, }?: Omit<UseChatOptions, 'api'> & {
     api?: string | StreamingReactResponseAction;
+    key?: string;
 }): UseChatHelpers;
 
 type UseCompletionHelpers = {
@@ -341,6 +343,8 @@ type UseCompletionHelpers = {
     handleSubmit: (e: React.FormEvent<HTMLFormElement>) => void;
     /** Whether the API request is in progress */
     isLoading: boolean;
+    /** Additional data added on the server via StreamData */
+    data?: JSONValue[] | undefined;
 };
 declare function useCompletion({ api, id, initialCompletion, initialInput, credentials, headers, body, onResponse, onFinish, onError, }?: UseCompletionOptions): UseCompletionHelpers;
 
@@ -363,12 +367,16 @@ type UseAssistantHelpers = {
     /** Current error, if any */
     error: undefined | unknown;
 };
-declare function experimental_useAssistant({ api, threadId: threadIdParam, }: {
+type UseAssistantOptions = {
     api: string;
     threadId?: string | undefined;
-}): UseAssistantHelpers;
+    credentials?: RequestCredentials;
+    headers?: Record<string, string> | Headers;
+    body?: object;
+};
+declare function experimental_useAssistant({ api, threadId: threadIdParam, credentials, headers, body, }: UseAssistantOptions): UseAssistantHelpers;
 
-export { AssistantStatus, CreateMessage, Message, UseAssistantHelpers, UseChatHelpers, UseChatOptions, UseCompletionHelpers, experimental_useAssistant, useChat, useCompletion };
+export { AssistantStatus, CreateMessage, Message, UseAssistantHelpers, UseAssistantOptions, UseChatHelpers, UseChatOptions, UseCompletionHelpers, experimental_useAssistant, useChat, useCompletion };
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
 type Props = {

package/react/dist/index.js

@@ -41,9 +41,6 @@ module.exports = __toCommonJS(react_exports);
 var import_react = require("react");
 var import_swr = __toESM(require("swr"));
 
-// shared/utils.ts
-var import_non_secure = require("nanoid/non-secure");
-
 // shared/stream-parts.ts
 var textStreamPart = {
   code: "0",
@@ -90,7 +87,7 @@ var errorStreamPart = {
     return { type: "error", value };
   }
 };
-var assistantMessage = {
+var assistantMessageStreamPart = {
   code: "4",
   name: "assistant_message",
   parse: (value) => {
@@ -107,7 +104,7 @@ var assistantMessage = {
     };
   }
 };
-var assistantControlData = {
+var assistantControlDataStreamPart = {
   code: "5",
   name: "assistant_control_data",
   parse: (value) => {
@@ -125,29 +122,47 @@ var assistantControlData = {
     };
   }
 };
+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 streamParts = [
   textStreamPart,
   functionCallStreamPart,
   dataStreamPart,
   errorStreamPart,
-  assistantMessage,
-  assistantControlData
+  assistantMessageStreamPart,
+  assistantControlDataStreamPart,
+  dataMessageStreamPart
 ];
 var streamPartsByCode = {
   [textStreamPart.code]: textStreamPart,
   [functionCallStreamPart.code]: functionCallStreamPart,
   [dataStreamPart.code]: dataStreamPart,
   [errorStreamPart.code]: errorStreamPart,
-  [assistantMessage.code]: assistantMessage,
-  [assistantControlData.code]: assistantControlData
+  [assistantMessageStreamPart.code]: assistantMessageStreamPart,
+  [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
+  [dataMessageStreamPart.code]: dataMessageStreamPart
 };
 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
+  [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
+  [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
+  [dataMessageStreamPart.name]: dataMessageStreamPart.code
 };
 var validCodes = streamParts.map((part) => part.code);
 var parseStreamPart = (line) => {
@@ -165,7 +180,51 @@ var parseStreamPart = (line) => {
   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/utils.ts
+var import_non_secure = require("nanoid/non-secure");
 var nanoid = (0, import_non_secure.customAlphabet)(
   "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
   7
@@ -196,80 +255,47 @@ async function parseComplexResponse({
   getCurrentDate = () => /* @__PURE__ */ new Date()
 }) {
   const createdAt = getCurrentDate();
-  const decode = createChunkDecoder(true);
   const prefixMap = {
     data: []
   };
-  const NEWLINE = "\n".charCodeAt(0);
-  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;
-    }
-    let concatenatedChunks = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      concatenatedChunks.set(chunk, offset);
-      offset += chunk.length;
-    }
-    chunks.length = 0;
-    totalLength = 0;
-    const lines = decode(concatenatedChunks);
-    if (typeof lines === "string") {
-      throw new Error(
-        "Invalid response format. Complex mode was set but the response is a string. This should never happen."
-      );
-    }
-    for (const { type, value: value2 } of lines) {
-      if (type === "text") {
-        if (prefixMap["text"]) {
-          prefixMap["text"] = {
-            ...prefixMap["text"],
-            content: (prefixMap["text"].content || "") + value2
-          };
-        } else {
-          prefixMap["text"] = {
-            id: generateId(),
-            role: "assistant",
-            content: value2,
-            createdAt
-          };
-        }
-      }
-      let functionCallMessage = null;
-      if (type === "function_call") {
-        prefixMap["function_call"] = {
+  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: generateId(),
           role: "assistant",
-          content: "",
-          function_call: value2.function_call,
-          name: value2.function_call.name,
+          content: value,
           createdAt
         };
-        functionCallMessage = prefixMap["function_call"];
-      }
-      if (type === "data") {
-        prefixMap["data"].push(...value2);
-      }
-      const responseMessage = prefixMap["text"];
-      const merged = [functionCallMessage, responseMessage].filter(
-        Boolean
-      );
-      update(merged, [...prefixMap["data"]]);
-      if ((abortControllerRef == null ? void 0 : abortControllerRef.current) === null) {
-        reader.cancel();
-        break;
       }
     }
+    let functionCallMessage = null;
+    if (type === "function_call") {
+      prefixMap["function_call"] = {
+        id: generateId(),
+        role: "assistant",
+        content: "",
+        function_call: value.function_call,
+        name: value.function_call.name,
+        createdAt
+      };
+      functionCallMessage = prefixMap["function_call"];
+    }
+    if (type === "data") {
+      prefixMap["data"].push(...value);
+    }
+    const responseMessage = prefixMap["text"];
+    const merged = [functionCallMessage, responseMessage].filter(
+      Boolean
+    );
+    update(merged, [...prefixMap["data"]]);
   }
   onFinish == null ? void 0 : onFinish(prefixMap);
   return {
@@ -280,8 +306,8 @@ async function parseComplexResponse({
   };
 }
 
-// shared/call-api.ts
-async function callApi({
+// shared/call-chat-api.ts
+async function callChatApi({
   api,
   messages,
   body,
@@ -476,7 +502,7 @@ var getStreamedResponse = async (api, chatRequest, mutate, mutateStreamData, exi
     }
     return responseMessage;
   }
-  return await callApi({
+  return await callChatApi({
     api,
     messages: constructedMessagesPayload,
     body: {
@@ -527,16 +553,20 @@ function useChat({
   generateId = nanoid
 } = {}) {
   const hookId = (0, import_react.useId)();
-  const chatId = id || hookId;
+  const idKey = id != null ? id : hookId;
+  const chatKey = typeof api === "string" ? [api, idKey] : idKey;
   const [initialMessagesFallback] = (0, import_react.useState)([]);
-  const { data: messages, mutate } = (0, import_swr.default)([api, chatId], null, {
-    fallbackData: initialMessages != null ? initialMessages : initialMessagesFallback
-  });
+  const { data: messages, mutate } = (0, import_swr.default)(
+    [chatKey, "messages"],
+    null,
+    { fallbackData: initialMessages != null ? initialMessages : initialMessagesFallback }
+  );
   const { data: isLoading = false, mutate: mutateLoading } = (0, import_swr.default)(
-    [chatId, "loading"],
+    [chatKey, "loading"],
     null
   );
-  const { data: streamData, mutate: mutateStreamData } = (0, import_swr.default)([chatId, "streamData"], null);
+  const { data: streamData, mutate: mutateStreamData } = (0, import_swr.default)([chatKey, "streamData"], null);
+  const { data: error = void 0, mutate: setError } = (0, import_swr.default)([chatKey, "error"], null);
   const messagesRef = (0, import_react.useRef)(messages || []);
   (0, import_react.useEffect)(() => {
     messagesRef.current = messages || [];
@@ -554,7 +584,6 @@ function useChat({
       body
     };
   }, [credentials, headers, body]);
-  const [error, setError] = (0, import_react.useState)();
   const triggerRequest = (0, import_react.useCallback)(
     async (chatRequest) => {
       try {
@@ -610,8 +639,8 @@ function useChat({
       streamData,
       sendExtraMessageFields,
       experimental_onFunctionCall,
-      messagesRef.current,
-      abortControllerRef.current,
+      messagesRef,
+      abortControllerRef,
       generateId
     ]
   );
@@ -715,24 +744,110 @@ function useChat({
 var import_react2 = require("react");
 var import_swr2 = __toESM(require("swr"));
 
-// 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);
+// shared/call-completion-api.ts
+async function callCompletionApi({
+  api,
+  prompt,
+  credentials,
+  headers,
+  body,
+  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;
       }
-      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);
+    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();
+    const isComplexMode = res.headers.get(COMPLEX_HEADER) === "true";
+    if (isComplexMode) {
+      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;
+          }
+        }
+      }
+    } else {
+      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;
+        }
+      }
+    }
+    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);
   }
 }
 
@@ -758,6 +873,7 @@ function useCompletion({
     [completionId, "loading"],
     null
   );
+  const { data: streamData, mutate: mutateStreamData } = (0, import_swr2.default)([completionId, "streamData"], null);
   const [error, setError] = (0, import_react2.useState)(void 0);
   const completion = data;
   const [abortController, setAbortController] = (0, import_react2.useState)(null);
@@ -774,90 +890,26 @@ function useCompletion({
     };
   }, [credentials, headers, body]);
   const triggerRequest = (0, import_react2.useCallback)(
-    async (prompt, options) => {
-      try {
-        mutateLoading(true);
-        setError(void 0);
-        const abortController2 = new AbortController();
-        setAbortController(abortController2);
-        mutate("", false);
-        const res = await fetch(api, {
-          method: "POST",
-          body: JSON.stringify({
-            prompt,
-            ...extraMetadataRef.current.body,
-            ...options == null ? void 0 : options.body
-          }),
-          credentials: extraMetadataRef.current.credentials,
-          headers: {
-            ...extraMetadataRef.current.headers,
-            ...options == null ? void 0 : options.headers
-          },
-          signal: abortController2.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();
-        const isComplexMode = res.headers.get(COMPLEX_HEADER) === "true";
-        if (isComplexMode) {
-          await processMessageStream(reader, (message) => {
-            const { type, value } = parseStreamPart(message);
-            if (type === "text") {
-              result += value;
-              mutate(result, false);
-            }
-          });
-        } else {
-          const decoder = createChunkDecoder();
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              break;
-            }
-            result += decoder(value);
-            mutate(result, false);
-            if (abortController2 === null) {
-              reader.cancel();
-              break;
-            }
-          }
-        }
-        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 {
-        mutateLoading(false);
+    async (prompt, options) => callCompletionApi({
+      api,
+      prompt,
+      credentials: extraMetadataRef.current.credentials,
+      headers: { ...extraMetadataRef.current.headers, ...options == null ? void 0 : options.headers },
+      body: {
+        ...extraMetadataRef.current.body,
+        ...options == null ? void 0 : options.body
+      },
+      setCompletion: (completion2) => mutate(completion2, false),
+      setLoading: mutateLoading,
+      setError,
+      setAbortController,
+      onResponse,
+      onFinish,
+      onError,
+      onData: (data2) => {
+        mutateStreamData([...streamData || [], ...data2 || []], false);
       }
-    },
+    }),
     [
       mutate,
       mutateLoading,
@@ -867,7 +919,9 @@ function useCompletion({
       onResponse,
       onFinish,
       onError,
-      setError
+      setError,
+      streamData,
+      mutateStreamData
     ]
   );
   const stop = (0, import_react2.useCallback)(() => {
@@ -911,7 +965,8 @@ function useCompletion({
     setInput,
     handleInputChange,
     handleSubmit,
-    isLoading
+    isLoading,
+    data: streamData
   };
 }
 
@@ -919,7 +974,10 @@ function useCompletion({
 var import_react3 = require("react");
 function experimental_useAssistant({
   api,
-  threadId: threadIdParam
+  threadId: threadIdParam,
+  credentials,
+  headers,
+  body
 }) {
   const [messages, setMessages] = (0, import_react3.useState)([]);
   const [input, setInput] = (0, import_react3.useState)("");
@@ -943,8 +1001,10 @@ function experimental_useAssistant({
     setInput("");
     const result = await fetch(api, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      credentials,
+      headers: { "Content-Type": "application/json", ...headers },
       body: JSON.stringify({
+        ...body,
         // always use user-provided threadId when available:
         threadId: (_b = threadIdParam != null ? threadIdParam : threadId) != null ? _b : null,
         message: input,
@@ -955,9 +1015,10 @@ function experimental_useAssistant({
     if (result.body == null) {
       throw new Error("The response body is empty.");
     }
-    await processMessageStream(result.body.getReader(), (message) => {
-      try {
-        const { type, value } = parseStreamPart(message);
+    try {
+      for await (const { type, value } of readDataStream(
+        result.body.getReader()
+      )) {
         switch (type) {
           case "assistant_message": {
             setMessages((messages2) => [
@@ -970,6 +1031,21 @@ function experimental_useAssistant({
             ]);
             break;
           }
+          case "data_message": {
+            setMessages((messages2) => {
+              var _a2;
+              return [
+                ...messages2,
+                {
+                  id: (_a2 = value.id) != null ? _a2 : "",
+                  role: "data",
+                  content: "",
+                  data: value.data
+                }
+              ];
+            });
+            break;
+          }
           case "assistant_control_data": {
             setThreadId(value.threadId);
             setMessages((messages2) => {
@@ -984,10 +1060,10 @@ function experimental_useAssistant({
             break;
           }
         }
-      } catch (error2) {
-        setError(error2);
       }
-    });
+    } catch (error2) {
+      setError(error2);
+    }
     setStatus("awaiting_message");
   };
   return {
@@ -1006,3 +1082,4 @@ function experimental_useAssistant({
   useChat,
   useCompletion
 });
+//# sourceMappingURL=index.js.map