ai 2.2.22 → 2.2.24

package/dist/index.d.ts

@@ -64,6 +64,7 @@ type ChatRequest = {
     options?: RequestOptions;
     functions?: Array<Function>;
     function_call?: FunctionCall;
+    data?: Record<string, string>;
 };
 type FunctionCallHandler = (chatMessages: Message[], functionCall: FunctionCall) => Promise<ChatRequest | void>;
 type RequestOptions = {
@@ -74,6 +75,7 @@ type ChatRequestOptions = {
     options?: RequestOptions;
     functions?: Array<Function>;
     function_call?: FunctionCall;
+    data?: Record<string, string>;
 };
 type UseChatOptions = {
     /**
@@ -202,6 +204,16 @@ type UseCompletionOptions = {
 type JSONValue = null | string | number | boolean | {
     [x: string]: JSONValue;
 } | Array<JSONValue>;
+type AssistantMessage = {
+    id: string;
+    role: 'assistant';
+    content: Array<{
+        type: 'text';
+        text: {
+            value: string;
+        };
+    }>;
+};
 
 type OpenAIStreamCallbacks = AIStreamCallbacksAndOptions & {
     /**
@@ -578,18 +590,26 @@ declare function ReplicateStream(res: Prediction, cb?: AIStreamCallbacksAndOptio
     headers?: Record<string, string>;
 }): Promise<ReadableStream>;
 
-declare const nanoid: (size?: number | undefined) => string;
-declare function createChunkDecoder(): (chunk: Uint8Array | undefined) => string;
-declare function createChunkDecoder(complex: false): (chunk: Uint8Array | undefined) => string;
-declare function createChunkDecoder(complex: true): (chunk: Uint8Array | undefined) => {
-    type: keyof typeof StreamStringPrefixes;
-    value: string;
-}[];
-declare function createChunkDecoder(complex?: boolean): (chunk: Uint8Array | undefined) => {
-    type: keyof typeof StreamStringPrefixes;
-    value: string;
-}[] | string;
-
+interface StreamPart<CODE extends string, NAME extends string, TYPE> {
+    code: CODE;
+    name: NAME;
+    parse: (value: JSONValue) => {
+        type: NAME;
+        value: TYPE;
+    };
+}
+declare const textStreamPart: StreamPart<'0', 'text', string>;
+declare const functionCallStreamPart: StreamPart<'1', 'function_call', {
+    function_call: FunctionCall;
+}>;
+declare const dataStreamPart: StreamPart<'2', 'data', Array<JSONValue>>;
+declare const errorStreamPart: StreamPart<'3', 'error', string>;
+declare const assistantMessage: StreamPart<'4', 'assistant_message', AssistantMessage>;
+declare const assistantControlData: StreamPart<'5', 'assistant_control_data', {
+    threadId: string;
+    messageId: string;
+}>;
+type StreamPartType = ReturnType<typeof textStreamPart.parse> | ReturnType<typeof functionCallStreamPart.parse> | ReturnType<typeof dataStreamPart.parse> | ReturnType<typeof errorStreamPart.parse> | ReturnType<typeof assistantMessage.parse> | ReturnType<typeof assistantControlData.parse>;
 /**
  * The map of prefixes for data in the stream
  *
@@ -611,20 +631,22 @@ declare function createChunkDecoder(complex?: boolean): (chunk: Uint8Array | und
  *```
  */
 declare const StreamStringPrefixes: {
-    readonly text: 0;
-    readonly function_call: 1;
-    readonly data: 2;
+    readonly text: "0";
+    readonly function_call: "1";
+    readonly data: "2";
+    readonly error: "3";
+    readonly assistant_message: "4";
+    readonly assistant_control_data: "5";
 };
-declare const isStreamStringEqualToType: (type: keyof typeof StreamStringPrefixes, value: string) => value is `0:${string}\n` | `1:${string}\n` | `2:${string}\n`;
-/**
- * Prepends a string with a prefix from the `StreamChunkPrefixes`, JSON-ifies it, and appends a new line.
- */
-declare const getStreamString: (type: keyof typeof StreamStringPrefixes, value: JSONValue) => StreamString;
+
+declare const nanoid: (size?: number | undefined) => string;
+declare function createChunkDecoder(): (chunk: Uint8Array | undefined) => string;
+declare function createChunkDecoder(complex: false): (chunk: Uint8Array | undefined) => string;
+declare function createChunkDecoder(complex: true): (chunk: Uint8Array | undefined) => StreamPartType[];
+declare function createChunkDecoder(complex?: boolean): (chunk: Uint8Array | undefined) => StreamPartType[] | string;
+
+declare const isStreamStringEqualToType: (type: keyof typeof StreamStringPrefixes, value: string) => value is `0:${string}\n` | `1:${string}\n` | `2:${string}\n` | `3:${string}\n` | `4:${string}\n` | `5:${string}\n`;
 type StreamString = `${(typeof StreamStringPrefixes)[keyof typeof StreamStringPrefixes]}:${string}\n`;
-declare const getStreamStringTypeAndValue: (line: string) => {
-    type: keyof typeof StreamStringPrefixes;
-    value: string;
-};
 /**
  * A header sent to the client so it knows how to handle parsing the stream (as a deprecated text response or using the new prefixed protocol)
  */
@@ -639,6 +661,7 @@ declare const COMPLEX_HEADER = "X-Experimental-Stream-Data";
  * It is naive as unlike the StreamingTextResponse, it does not send the diff
  * between the rows, but flushing the full payload on each row.
  */
+
 type UINode = string | JSX.Element | JSX.Element[] | null | undefined;
 type Payload = {
     ui: UINode | Promise<UINode>;
@@ -654,8 +677,19 @@ declare class experimental_StreamingReactResponse {
     constructor(res: ReadableStream, options?: {
         ui?: (message: {
             content: string;
+            data?: JSONValue[] | undefined;
         }) => UINode | Promise<UINode>;
+        data?: experimental_StreamData;
     });
 }
 
-export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AnthropicStream, COMPLEX_HEADER, ChatRequest, ChatRequestOptions, CohereStream, CompletionUsage, CreateMessage, FunctionCall, FunctionCallHandler, FunctionCallPayload, HuggingFaceStream, JSONValue, LangChainStream, Message, OpenAIStream, OpenAIStreamCallbacks, ReactResponseRow, ReplicateStream, RequestOptions, StreamString, StreamStringPrefixes, StreamingTextResponse, UseChatOptions, UseCompletionOptions, createCallbacksTransformer, createChunkDecoder, createEventStreamTransformer, createStreamDataTransformer, experimental_StreamData, experimental_StreamingReactResponse, getStreamString, getStreamStringTypeAndValue, isStreamStringEqualToType, nanoid, readableFromAsyncIterable, streamToResponse, trimStartOfStreamHelper };
+declare function experimental_AssistantResponse({ threadId, messageId }: {
+    threadId: string;
+    messageId: string;
+}, process: (stream: {
+    threadId: string;
+    messageId: string;
+    sendMessage: (message: AssistantMessage) => void;
+}) => Promise<void>): Response;
+
+export { AIStream, AIStreamCallbacksAndOptions, AIStreamParser, AnthropicStream, AssistantMessage, COMPLEX_HEADER, ChatRequest, ChatRequestOptions, CohereStream, CompletionUsage, CreateMessage, FunctionCall, FunctionCallHandler, FunctionCallPayload, HuggingFaceStream, JSONValue, LangChainStream, Message, OpenAIStream, OpenAIStreamCallbacks, ReactResponseRow, ReplicateStream, RequestOptions, StreamString, StreamingTextResponse, UseChatOptions, UseCompletionOptions, createCallbacksTransformer, createChunkDecoder, createEventStreamTransformer, createStreamDataTransformer, experimental_AssistantResponse, experimental_StreamData, experimental_StreamingReactResponse, isStreamStringEqualToType, nanoid, readableFromAsyncIterable, streamToResponse, trimStartOfStreamHelper };

package/dist/index.js

@@ -28,16 +28,14 @@ __export(streams_exports, {
   LangChainStream: () => LangChainStream,
   OpenAIStream: () => OpenAIStream,
   ReplicateStream: () => ReplicateStream,
-  StreamStringPrefixes: () => StreamStringPrefixes,
   StreamingTextResponse: () => StreamingTextResponse,
   createCallbacksTransformer: () => createCallbacksTransformer,
   createChunkDecoder: () => createChunkDecoder,
   createEventStreamTransformer: () => createEventStreamTransformer,
   createStreamDataTransformer: () => createStreamDataTransformer,
+  experimental_AssistantResponse: () => experimental_AssistantResponse,
   experimental_StreamData: () => experimental_StreamData,
   experimental_StreamingReactResponse: () => experimental_StreamingReactResponse,
-  getStreamString: () => getStreamString,
-  getStreamStringTypeAndValue: () => getStreamStringTypeAndValue,
   isStreamStringEqualToType: () => isStreamStringEqualToType,
   nanoid: () => nanoid,
   readableFromAsyncIterable: () => readableFromAsyncIterable,
@@ -162,6 +160,135 @@ function readableFromAsyncIterable(iterable) {
   });
 }
 
+// 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);
+};
+function formatStreamPart(type, value) {
+  const streamPart = streamParts.find((part) => part.name === type);
+  if (!streamPart) {
+    throw new Error(`Invalid stream part type: ${type}`);
+  }
+  return `${streamPart.code}:${JSON.stringify(value)}
+`;
+}
+
 // shared/utils.ts
 var import_non_secure = require("nanoid/non-secure");
 var nanoid = (0, import_non_secure.customAlphabet)(
@@ -179,36 +306,10 @@ 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 isStreamStringEqualToType = (type, value) => value.startsWith(`${StreamStringPrefixes[type]}:`) && value.endsWith("\n");
-var getStreamString = (type, value) => `${StreamStringPrefixes[type]}:${JSON.stringify(value)}
-`;
-var getStreamStringTypeAndValue = (line) => {
-  const firstSeperatorIndex = line.indexOf(":");
-  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";
 
 // streams/stream-data.ts
@@ -234,7 +335,7 @@ var experimental_StreamData = class {
       transform: async (chunk, controller) => {
         if (self.data.length > 0) {
           const encodedData = self.encoder.encode(
-            getStreamString("data", JSON.stringify(self.data))
+            formatStreamPart("data", self.data)
           );
           self.data = [];
           controller.enqueue(encodedData);
@@ -253,7 +354,7 @@ var experimental_StreamData = class {
         }
         if (self.data.length) {
           const encodedData = self.encoder.encode(
-            getStreamString("data", JSON.stringify(self.data))
+            formatStreamPart("data", self.data)
           );
           controller.enqueue(encodedData);
         }
@@ -291,7 +392,7 @@ function createStreamDataTransformer(experimental_streamData) {
   return new TransformStream({
     transform: async (chunk, controller) => {
       const message = decoder.decode(chunk);
-      controller.enqueue(encoder.encode(getStreamString("text", message)));
+      controller.enqueue(encoder.encode(formatStreamPart("text", message)));
     }
   });
 }
@@ -399,7 +500,7 @@ function createFunctionCallTransformer(callbacks) {
       }
       if (!isFunctionStreamingIn) {
         controller.enqueue(
-          isComplexMode ? textEncoder.encode(getStreamString("text", message)) : chunk
+          isComplexMode ? textEncoder.encode(formatStreamPart("text", message)) : chunk
         );
         return;
       } else {
@@ -441,13 +542,17 @@ function createFunctionCallTransformer(callbacks) {
           if (!functionResponse) {
             controller.enqueue(
               textEncoder.encode(
-                isComplexMode ? getStreamString("function_call", aggregatedResponse) : aggregatedResponse
+                isComplexMode ? formatStreamPart(
+                  "function_call",
+                  // parse to prevent double-encoding:
+                  JSON.parse(aggregatedResponse)
+                ) : aggregatedResponse
               )
             );
             return;
           } else if (typeof functionResponse === "string") {
             controller.enqueue(
-              isComplexMode ? textEncoder.encode(getStreamString("text", functionResponse)) : textEncoder.encode(functionResponse)
+              isComplexMode ? textEncoder.encode(formatStreamPart("text", functionResponse)) : textEncoder.encode(functionResponse)
             );
             return;
           }
@@ -712,6 +817,100 @@ async function ReplicateStream(res, cb, options) {
   );
 }
 
+// shared/parse-complex-response.ts
+async function parseComplexResponse({
+  reader,
+  abortControllerRef,
+  update,
+  onFinish,
+  generateId = nanoid,
+  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"] = {
+          id: generateId(),
+          role: "assistant",
+          content: "",
+          function_call: value2.function_call,
+          name: value2.function_call.name,
+          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;
+      }
+    }
+  }
+  onFinish == null ? void 0 : onFinish(prefixMap);
+  return {
+    messages: [prefixMap.text, prefixMap.function_call].filter(
+      Boolean
+    ),
+    data: prefixMap.data
+  };
+}
+
 // streams/streaming-react-response.ts
 var experimental_StreamingReactResponse = class {
   constructor(res, options) {
@@ -720,6 +919,39 @@ var experimental_StreamingReactResponse = class {
     let next = new Promise((resolve) => {
       resolveFunc = resolve;
     });
+    if (options == null ? void 0 : options.data) {
+      const processedStream = res.pipeThrough(
+        options.data.stream
+      );
+      let lastPayload = void 0;
+      parseComplexResponse({
+        reader: processedStream.getReader(),
+        update: (merged, data) => {
+          var _a, _b, _c;
+          const content2 = (_b = (_a = merged[0]) == null ? void 0 : _a.content) != null ? _b : "";
+          const ui = ((_c = options == null ? void 0 : options.ui) == null ? void 0 : _c.call(options, { content: content2, data })) || content2;
+          const payload = { ui, content: content2 };
+          const resolvePrevious = resolveFunc;
+          const nextRow = new Promise((resolve) => {
+            resolveFunc = resolve;
+          });
+          resolvePrevious({
+            next: nextRow,
+            ...payload
+          });
+          lastPayload = payload;
+        },
+        onFinish: () => {
+          if (lastPayload !== void 0) {
+            resolveFunc({
+              next: null,
+              ...lastPayload
+            });
+          }
+        }
+      });
+      return next;
+    }
     let content = "";
     const decode = createChunkDecoder();
     const reader = res.getReader();
@@ -751,6 +983,55 @@ var experimental_StreamingReactResponse = class {
     return next;
   }
 };
+
+// streams/assistant-response.ts
+function experimental_AssistantResponse({ threadId, messageId }, process2) {
+  const stream = new ReadableStream({
+    async start(controller) {
+      var _a;
+      const textEncoder = new TextEncoder();
+      const sendMessage = (message) => {
+        controller.enqueue(
+          textEncoder.encode(formatStreamPart("assistant_message", message))
+        );
+      };
+      const sendError = (errorMessage) => {
+        controller.enqueue(
+          textEncoder.encode(formatStreamPart("error", errorMessage))
+        );
+      };
+      controller.enqueue(
+        textEncoder.encode(
+          formatStreamPart("assistant_control_data", {
+            threadId,
+            messageId
+          })
+        )
+      );
+      try {
+        await process2({
+          threadId,
+          messageId,
+          sendMessage
+        });
+      } catch (error) {
+        sendError((_a = error.message) != null ? _a : `${error}`);
+      } finally {
+        controller.close();
+      }
+    },
+    pull(controller) {
+    },
+    cancel() {
+    }
+  });
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/plain; charset=utf-8"
+    }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AIStream,
@@ -761,16 +1042,14 @@ var experimental_StreamingReactResponse = class {
   LangChainStream,
   OpenAIStream,
   ReplicateStream,
-  StreamStringPrefixes,
   StreamingTextResponse,
   createCallbacksTransformer,
   createChunkDecoder,
   createEventStreamTransformer,
   createStreamDataTransformer,
+  experimental_AssistantResponse,
   experimental_StreamData,
   experimental_StreamingReactResponse,
-  getStreamString,
-  getStreamStringTypeAndValue,
   isStreamStringEqualToType,
   nanoid,
   readableFromAsyncIterable,