ai 2.2.22 → 2.2.24

package/dist/index.mjs

@@ -116,6 +116,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
 import { customAlphabet } from "nanoid/non-secure";
 var nanoid = customAlphabet(
@@ -133,36 +262,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
@@ -188,7 +291,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);
@@ -207,7 +310,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);
         }
@@ -245,7 +348,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)));
     }
   });
 }
@@ -353,7 +456,7 @@ function createFunctionCallTransformer(callbacks) {
       }
       if (!isFunctionStreamingIn) {
         controller.enqueue(
-          isComplexMode ? textEncoder.encode(getStreamString("text", message)) : chunk
+          isComplexMode ? textEncoder.encode(formatStreamPart("text", message)) : chunk
         );
         return;
       } else {
@@ -395,13 +498,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;
           }
@@ -666,6 +773,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) {
@@ -674,6 +875,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();
@@ -705,6 +939,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"
+    }
+  });
+}
 export {
   AIStream,
   AnthropicStream,
@@ -714,16 +997,14 @@ export {
   LangChainStream,
   OpenAIStream,
   ReplicateStream,
-  StreamStringPrefixes,
   StreamingTextResponse,
   createCallbacksTransformer,
   createChunkDecoder,
   createEventStreamTransformer,
   createStreamDataTransformer,
+  experimental_AssistantResponse,
   experimental_StreamData,
   experimental_StreamingReactResponse,
-  getStreamString,
-  getStreamStringTypeAndValue,
   isStreamStringEqualToType,
   nanoid,
   readableFromAsyncIterable,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "2.2.22",
+  "version": "2.2.24",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -54,10 +54,6 @@
       "require": "./solid/dist/index.js"
     }
   },
-  "jest": {
-    "preset": "ts-jest",
-    "testEnvironment": "node"
-  },
   "dependencies": {
     "eventsource-parser": "1.0.0",
     "nanoid": "3.3.6",
@@ -70,12 +66,17 @@
   "devDependencies": {
     "@edge-runtime/jest-environment": "1.1.0-beta.31",
     "@huggingface/inference": "2.6.4",
+    "@testing-library/jest-dom": "^6.1.4",
+    "@testing-library/react": "^14.0.0",
+    "@testing-library/user-event": "^14.5.1",
     "@types/jest": "29.2.0",
     "@types/node": "^17.0.12",
     "@types/react": "^18.2.8",
     "@types/react-dom": "^18.2.0",
     "eslint": "^7.32.0",
     "jest": "29.2.1",
+    "jest-environment-jsdom": "^29.7.0",
+    "jsdom": "^22.1.0",
     "langchain": "0.0.172",
     "openai": "4.16.1",
     "ts-jest": "29.0.3",
@@ -132,6 +133,9 @@
     "lint": "eslint \"./**/*.ts*\"",
     "type-check": "tsc --noEmit",
     "prettier-check": "prettier --check \"./**/*.ts*\"",
-    "test": "jest --forceExit --env @edge-runtime/jest-environment .test.ts && jest --forceExit --env node .test.ts"
+    "test": "pnpm test:node && pnpm test:edge && pnpm test:ui",
+    "test:edge": "jest --forceExit --config jest.node.config.js --env @edge-runtime/jest-environment .test.ts ",
+    "test:node": "jest --forceExit --config jest.node.config.js --env node .test.ts",
+    "test:ui": "jest --forceExit --config jest.ui.config.js .ui.test.ts"
   }
 }

package/react/dist/index.d.ts

@@ -62,6 +62,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 = {
@@ -72,6 +73,7 @@ type ChatRequestOptions = {
     options?: RequestOptions;
     functions?: Array<Function>;
     function_call?: FunctionCall;
+    data?: Record<string, string>;
 };
 type UseChatOptions = {
     /**
@@ -197,6 +199,25 @@ type UseCompletionOptions = {
      */
     body?: object;
 };
+type JSONValue = null | string | number | boolean | {
+    [x: string]: JSONValue;
+} | Array<JSONValue>;
+
+/**
+ * A stream wrapper to send custom JSON-encoded data back to the client.
+ */
+declare class experimental_StreamData {
+    private encoder;
+    private controller;
+    stream: TransformStream<Uint8Array, Uint8Array>;
+    private isClosedPromise;
+    private isClosedPromiseResolver;
+    private isClosed;
+    private data;
+    constructor();
+    close(): Promise<void>;
+    append(value: JSONValue): void;
+}
 
 /**
  * This is a naive implementation of the streaming React response API.
@@ -207,6 +228,7 @@ type UseCompletionOptions = {
  * 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;
 /**
  * A utility class for streaming React responses.
@@ -215,7 +237,9 @@ declare class experimental_StreamingReactResponse {
     constructor(res: ReadableStream, options?: {
         ui?: (message: {
             content: string;
+            data?: JSONValue[] | undefined;
         }) => UINode | Promise<UINode>;
+        data?: experimental_StreamData;
     });
 }
 
@@ -259,10 +283,11 @@ type UseChatHelpers = {
     /** Whether the API request is in progress */
     isLoading: boolean;
     /** Additional data added on the server via StreamData */
-    data?: any;
+    data?: JSONValue[] | undefined;
 };
 type StreamingReactResponseAction = (payload: {
     messages: Message[];
+    data?: Record<string, string>;
 }) => Promise<experimental_StreamingReactResponse>;
 declare function useChat({ api, id, initialMessages, initialInput, sendExtraMessageFields, experimental_onFunctionCall, onResponse, onFinish, onError, credentials, headers, body, }?: Omit<UseChatOptions, 'api'> & {
     api?: string | StreamingReactResponseAction;
@@ -312,7 +337,20 @@ type UseCompletionHelpers = {
 };
 declare function useCompletion({ api, id, initialCompletion, initialInput, credentials, headers, body, onResponse, onFinish, onError, }?: UseCompletionOptions): UseCompletionHelpers;
 
-export { CreateMessage, Message, UseChatHelpers, UseChatOptions, UseCompletionHelpers, useChat, useCompletion };
+type AssistantStatus = 'in_progress' | 'awaiting_message';
+declare function experimental_useAssistant({ api, threadId: threadIdParam, }: {
+    api: string;
+    threadId?: string | undefined;
+}): {
+    messages: Message[];
+    input: string;
+    handleInputChange: (e: any) => void;
+    submitMessage: (e: any) => Promise<void>;
+    status: AssistantStatus;
+    error: unknown;
+};
+
+export { AssistantStatus, CreateMessage, Message, UseChatHelpers, UseChatOptions, UseCompletionHelpers, experimental_useAssistant, useChat, useCompletion };
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
 type Props = {