ai 2.2.23 → 2.2.25

package/dist/index.mjs

@@ -116,57 +116,134 @@ function readableFromAsyncIterable(iterable) {
   });
 }
 
-// shared/utils.ts
-import { customAlphabet } from "nanoid/non-secure";
-var nanoid = customAlphabet(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  7
-);
-function createChunkDecoder(complex) {
-  const decoder = new TextDecoder();
-  if (!complex) {
-    return function(chunk) {
-      if (!chunk)
-        return "";
-      return decoder.decode(chunk, { stream: true });
+// 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
     };
   }
-  return function(chunk) {
-    const decoded = decoder.decode(chunk, { stream: true }).split("\n").filter((line) => line !== "");
-    return decoded.map(getStreamStringTypeAndValue).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(":");
-  if (firstSeperatorIndex === -1) {
-    throw new Error("Failed to parse stream string");
+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 };
   }
-  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: "" };
+};
+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 };
   }
-  try {
-    parsedVal = JSON.parse(val);
-  } catch (e) {
-    console.error("Failed to parse JSON value:", val);
+};
+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
+    };
   }
-  return { type, value: parsedVal };
 };
-var COMPLEX_HEADER = "X-Experimental-Stream-Data";
+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)}
+`;
+}
 
 // streams/stream-data.ts
 var experimental_StreamData = class {
@@ -191,7 +268,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);
@@ -210,7 +287,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);
         }
@@ -248,11 +325,76 @@ 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)));
     }
   });
 }
 
+// streams/aws-bedrock-stream.ts
+async function* asDeltaIterable(response, extractTextDeltaFromChunk) {
+  var _a, _b;
+  const decoder = new TextDecoder();
+  for await (const chunk of (_a = response.body) != null ? _a : []) {
+    const bytes = (_b = chunk.chunk) == null ? void 0 : _b.bytes;
+    if (bytes != null) {
+      const chunkText = decoder.decode(bytes);
+      const chunkJSON = JSON.parse(chunkText);
+      const delta = extractTextDeltaFromChunk(chunkJSON);
+      if (delta != null) {
+        yield delta;
+      }
+    }
+  }
+}
+function AWSBedrockAnthropicStream(response, callbacks) {
+  return AWSBedrockStream(response, callbacks, (chunk) => chunk.completion);
+}
+function AWSBedrockCohereStream(response, callbacks) {
+  return AWSBedrockStream(
+    response,
+    callbacks,
+    // As of 2023-11-17, Bedrock does not support streaming for Cohere,
+    // so we take the full generation:
+    (chunk) => {
+      var _a, _b;
+      return (_b = (_a = chunk.generations) == null ? void 0 : _a[0]) == null ? void 0 : _b.text;
+    }
+  );
+}
+function AWSBedrockLlama2Stream(response, callbacks) {
+  return AWSBedrockStream(response, callbacks, (chunk) => chunk.generation);
+}
+function AWSBedrockStream(response, callbacks, extractTextDeltaFromChunk) {
+  return readableFromAsyncIterable(
+    asDeltaIterable(response, extractTextDeltaFromChunk)
+  ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(
+    createStreamDataTransformer(callbacks == null ? void 0 : callbacks.experimental_streamData)
+  );
+}
+
+// shared/utils.ts
+import { customAlphabet } from "nanoid/non-secure";
+var nanoid = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+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);
+  };
+}
+var isStreamStringEqualToType = (type, value) => value.startsWith(`${StreamStringPrefixes[type]}:`) && value.endsWith("\n");
+var COMPLEX_HEADER = "X-Experimental-Stream-Data";
+
 // streams/openai-stream.ts
 function parseOpenAIStream() {
   const extract = chunkToText();
@@ -356,7 +498,7 @@ function createFunctionCallTransformer(callbacks) {
       }
       if (!isFunctionStreamingIn) {
         controller.enqueue(
-          isComplexMode ? textEncoder.encode(getStreamString("text", message)) : chunk
+          isComplexMode ? textEncoder.encode(formatStreamPart("text", message)) : chunk
         );
         return;
       } else {
@@ -398,13 +540,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;
           }
@@ -669,18 +815,22 @@ async function ReplicateStream(res, cb, options) {
   );
 }
 
-// react/parse-complex-response.ts
+// 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();
@@ -717,7 +867,7 @@ async function parseComplexResponse({
           };
         } else {
           prefixMap["text"] = {
-            id: nanoid(),
+            id: generateId(),
             role: "assistant",
             content: value2,
             createdAt
@@ -726,37 +876,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;
@@ -764,7 +901,12 @@ async function parseComplexResponse({
     }
   }
   onFinish == null ? void 0 : onFinish(prefixMap);
-  return prefixMap;
+  return {
+    messages: [prefixMap.text, prefixMap.function_call].filter(
+      Boolean
+    ),
+    data: prefixMap.data
+  };
 }
 
 // streams/streaming-react-response.ts
@@ -839,8 +981,61 @@ 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,
+  AWSBedrockAnthropicStream,
+  AWSBedrockCohereStream,
+  AWSBedrockLlama2Stream,
+  AWSBedrockStream,
   AnthropicStream,
   COMPLEX_HEADER,
   CohereStream,
@@ -848,16 +1043,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.23",
+  "version": "2.2.25",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -64,6 +64,7 @@
     "swrv": "1.0.4"
   },
   "devDependencies": {
+    "@aws-sdk/client-bedrock-runtime": "3.451.0",
     "@edge-runtime/jest-environment": "1.1.0-beta.31",
     "@huggingface/inference": "2.6.4",
     "@testing-library/jest-dom": "^6.1.4",
@@ -82,8 +83,8 @@
     "ts-jest": "29.0.3",
     "tsup": "^6.7.0",
     "typescript": "5.1.3",
-    "@vercel/ai-tsconfig": "0.0.0",
-    "eslint-config-vercel-ai": "0.0.0"
+    "eslint-config-vercel-ai": "0.0.0",
+    "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "react": "^18.2.0",

package/prompts/dist/index.d.ts

@@ -33,6 +33,13 @@ interface Message {
     function_call?: string | FunctionCall;
 }
 
+/**
+ * A prompt constructor for Anthropic models.
+ * Does not support `function` messages.
+ * @see https://docs.anthropic.com/claude/reference/getting-started-with-the-api
+ */
+declare function experimental_buildAnthropicPrompt(messages: Pick<Message, 'content' | 'role'>[]): string;
+
 /**
  * A prompt constructor for the HuggingFace StarChat Beta model.
  * Does not support `function` messages.
@@ -52,4 +59,4 @@ declare function experimental_buildOpenAssistantPrompt(messages: Pick<Message, '
  */
 declare function experimental_buildLlama2Prompt(messages: Pick<Message, 'content' | 'role'>[]): string;
 
-export { experimental_buildLlama2Prompt, experimental_buildOpenAssistantPrompt, experimental_buildStarChatBetaPrompt };
+export { experimental_buildAnthropicPrompt, experimental_buildLlama2Prompt, experimental_buildOpenAssistantPrompt, experimental_buildStarChatBetaPrompt };

package/prompts/dist/index.js

@@ -20,12 +20,28 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // prompts/index.ts
 var prompts_exports = {};
 __export(prompts_exports, {
+  experimental_buildAnthropicPrompt: () => experimental_buildAnthropicPrompt,
   experimental_buildLlama2Prompt: () => experimental_buildLlama2Prompt,
   experimental_buildOpenAssistantPrompt: () => experimental_buildOpenAssistantPrompt,
   experimental_buildStarChatBetaPrompt: () => experimental_buildStarChatBetaPrompt
 });
 module.exports = __toCommonJS(prompts_exports);
 
+// prompts/anthropic.ts
+function experimental_buildAnthropicPrompt(messages) {
+  return messages.map(({ content, role }) => {
+    if (role === "user") {
+      return `
+
+Human: ${content}`;
+    } else {
+      return `
+
+Assistant: ${content}`;
+    }
+  }) + "\n\nAssistant:";
+}
+
 // prompts/huggingface.ts
 function experimental_buildStarChatBetaPrompt(messages) {
   return messages.map(({ content, role }) => {
@@ -83,6 +99,7 @@ ${content}
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  experimental_buildAnthropicPrompt,
   experimental_buildLlama2Prompt,
   experimental_buildOpenAssistantPrompt,
   experimental_buildStarChatBetaPrompt

package/prompts/dist/index.mjs

@@ -1,3 +1,18 @@
+// prompts/anthropic.ts
+function experimental_buildAnthropicPrompt(messages) {
+  return messages.map(({ content, role }) => {
+    if (role === "user") {
+      return `
+
+Human: ${content}`;
+    } else {
+      return `
+
+Assistant: ${content}`;
+    }
+  }) + "\n\nAssistant:";
+}
+
 // prompts/huggingface.ts
 function experimental_buildStarChatBetaPrompt(messages) {
   return messages.map(({ content, role }) => {
@@ -54,6 +69,7 @@ ${content}
   return startPrompt + conversation.join("") + endPrompt;
 }
 export {
+  experimental_buildAnthropicPrompt,
   experimental_buildLlama2Prompt,
   experimental_buildOpenAssistantPrompt,
   experimental_buildStarChatBetaPrompt

package/react/dist/index.d.ts

@@ -283,7 +283,7 @@ 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[];
@@ -337,7 +337,21 @@ 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[];
+    threadId: string | undefined;
+    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 = {