ai 4.1.62 → 4.1.64

package/dist/index.mjs

@@ -802,12 +802,6 @@ var DefaultEmbedManyResult = class {
   }
 };
 
-// core/generate-image/generate-image.ts
-import {
-  convertBase64ToUint8Array,
-  convertUint8ArrayToBase64
-} from "@ai-sdk/provider-utils";
-
 // errors/no-image-generated-error.ts
 import { AISDKError as AISDKError3 } from "@ai-sdk/provider";
 var name3 = "AI_NoImageGeneratedError";
@@ -830,6 +824,126 @@ var NoImageGeneratedError = class extends AISDKError3 {
 };
 _a3 = symbol3;
 
+// core/generate-text/generated-file.ts
+import {
+  convertBase64ToUint8Array,
+  convertUint8ArrayToBase64
+} from "@ai-sdk/provider-utils";
+var DefaultGeneratedFile = class {
+  constructor({
+    data,
+    mimeType
+  }) {
+    const isUint8Array = data instanceof Uint8Array;
+    this.base64Data = isUint8Array ? void 0 : data;
+    this.uint8ArrayData = isUint8Array ? data : void 0;
+    this.mimeType = mimeType;
+  }
+  // lazy conversion with caching to avoid unnecessary conversion overhead:
+  get base64() {
+    if (this.base64Data == null) {
+      this.base64Data = convertUint8ArrayToBase64(this.uint8ArrayData);
+    }
+    return this.base64Data;
+  }
+  // lazy conversion with caching to avoid unnecessary conversion overhead:
+  get uint8Array() {
+    if (this.uint8ArrayData == null) {
+      this.uint8ArrayData = convertBase64ToUint8Array(this.base64Data);
+    }
+    return this.uint8ArrayData;
+  }
+};
+var DefaultGeneratedFileWithType = class extends DefaultGeneratedFile {
+  constructor(options) {
+    super(options);
+    this.type = "file";
+  }
+};
+
+// core/util/detect-image-mimetype.ts
+var mimeTypeSignatures = [
+  {
+    mimeType: "image/gif",
+    bytesPrefix: [71, 73, 70],
+    base64Prefix: "R0lG"
+  },
+  {
+    mimeType: "image/png",
+    bytesPrefix: [137, 80, 78, 71],
+    base64Prefix: "iVBORw"
+  },
+  {
+    mimeType: "image/jpeg",
+    bytesPrefix: [255, 216],
+    base64Prefix: "/9j/"
+  },
+  {
+    mimeType: "image/webp",
+    bytesPrefix: [82, 73, 70, 70],
+    base64Prefix: "UklGRg"
+  },
+  {
+    mimeType: "image/bmp",
+    bytesPrefix: [66, 77],
+    base64Prefix: "Qk"
+  },
+  {
+    mimeType: "image/tiff",
+    bytesPrefix: [73, 73, 42, 0],
+    base64Prefix: "SUkqAA"
+  },
+  {
+    mimeType: "image/tiff",
+    bytesPrefix: [77, 77, 0, 42],
+    base64Prefix: "TU0AKg"
+  },
+  {
+    mimeType: "image/avif",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      32,
+      102,
+      116,
+      121,
+      112,
+      97,
+      118,
+      105,
+      102
+    ],
+    base64Prefix: "AAAAIGZ0eXBhdmlm"
+  },
+  {
+    mimeType: "image/heic",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      32,
+      102,
+      116,
+      121,
+      112,
+      104,
+      101,
+      105,
+      99
+    ],
+    base64Prefix: "AAAAIGZ0eXBoZWlj"
+  }
+];
+function detectImageMimeType(image) {
+  for (const signature of mimeTypeSignatures) {
+    if (typeof image === "string" ? image.startsWith(signature.base64Prefix) : image.length >= signature.bytesPrefix.length && signature.bytesPrefix.every((byte, index) => image[index] === byte)) {
+      return signature.mimeType;
+    }
+  }
+  return void 0;
+}
+
 // core/generate-image/generate-image.ts
 async function generateImage({
   model,
@@ -841,10 +955,7 @@ async function generateImage({
   providerOptions,
   maxRetries: maxRetriesArg,
   abortSignal,
-  headers,
-  _internal = {
-    currentDate: () => /* @__PURE__ */ new Date()
-  }
+  headers
 }) {
   var _a17;
   const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
@@ -878,7 +989,15 @@ async function generateImage({
   const responses = [];
   for (const result of results) {
     images.push(
-      ...result.images.map((image) => new DefaultGeneratedImage({ image }))
+      ...result.images.map(
+        (image) => {
+          var _a18;
+          return new DefaultGeneratedFile({
+            data: image,
+            mimeType: (_a18 = detectImageMimeType(image)) != null ? _a18 : "image/png"
+          });
+        }
+      )
     );
     warnings.push(...result.warnings);
     responses.push(result.response);
@@ -898,27 +1017,6 @@ var DefaultGenerateImageResult = class {
     return this.images[0];
   }
 };
-var DefaultGeneratedImage = class {
-  constructor({ image }) {
-    const isUint8Array = image instanceof Uint8Array;
-    this.base64Data = isUint8Array ? void 0 : image;
-    this.uint8ArrayData = isUint8Array ? image : void 0;
-  }
-  // lazy conversion with caching to avoid unnecessary conversion overhead:
-  get base64() {
-    if (this.base64Data == null) {
-      this.base64Data = convertUint8ArrayToBase64(this.uint8ArrayData);
-    }
-    return this.base64Data;
-  }
-  // lazy conversion with caching to avoid unnecessary conversion overhead:
-  get uint8Array() {
-    if (this.uint8ArrayData == null) {
-      this.uint8ArrayData = convertBase64ToUint8Array(this.base64Data);
-    }
-    return this.uint8ArrayData;
-  }
-};
 
 // core/generate-object/generate-object.ts
 import {
@@ -1007,22 +1105,6 @@ async function download({
   }
 }
 
-// core/util/detect-image-mimetype.ts
-var mimeTypeSignatures = [
-  { mimeType: "image/gif", bytes: [71, 73, 70] },
-  { mimeType: "image/png", bytes: [137, 80, 78, 71] },
-  { mimeType: "image/jpeg", bytes: [255, 216] },
-  { mimeType: "image/webp", bytes: [82, 73, 70, 70] }
-];
-function detectImageMimeType(image) {
-  for (const { bytes, mimeType } of mimeTypeSignatures) {
-    if (image.length >= bytes.length && bytes.every((byte, index) => image[index] === byte)) {
-      return mimeType;
-    }
-  }
-  return void 0;
-}
-
 // core/prompt/data-content.ts
 import {
   convertBase64ToUint8Array as convertBase64ToUint8Array2,
@@ -1199,11 +1281,50 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
           // remove empty text parts:
           (part) => part.type !== "text" || part.text !== ""
         ).map((part) => {
-          const { experimental_providerMetadata, providerOptions, ...rest } = part;
-          return {
-            ...rest,
-            providerMetadata: providerOptions != null ? providerOptions : experimental_providerMetadata
-          };
+          var _a18;
+          const providerOptions = (_a18 = part.providerOptions) != null ? _a18 : part.experimental_providerMetadata;
+          switch (part.type) {
+            case "file": {
+              return {
+                type: "file",
+                data: part.data instanceof URL ? part.data : convertDataContentToBase64String(part.data),
+                filename: part.filename,
+                mimeType: part.mimeType,
+                providerMetadata: providerOptions
+              };
+            }
+            case "reasoning": {
+              return {
+                type: "reasoning",
+                text: part.text,
+                signature: part.signature,
+                providerMetadata: providerOptions
+              };
+            }
+            case "redacted-reasoning": {
+              return {
+                type: "redacted-reasoning",
+                data: part.data,
+                providerMetadata: providerOptions
+              };
+            }
+            case "text": {
+              return {
+                type: "text",
+                text: part.text,
+                providerMetadata: providerOptions
+              };
+            }
+            case "tool-call": {
+              return {
+                type: "tool-call",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                args: part.args,
+                providerMetadata: providerOptions
+              };
+            }
+          }
         }),
         providerMetadata: (_e = message.providerOptions) != null ? _e : message.experimental_providerMetadata
       };
@@ -1563,12 +1684,11 @@ function convertToCoreMessages(messages, options) {
             const content2 = [];
             for (const part of block) {
               switch (part.type) {
-                case "text":
-                  content2.push({
-                    type: "text",
-                    text: part.text
-                  });
+                case "file":
+                case "text": {
+                  content2.push(part);
                   break;
+                }
                 case "reasoning": {
                   for (const detail of part.details) {
                     switch (detail.type) {
@@ -1649,9 +1769,6 @@ function convertToCoreMessages(messages, options) {
           let block = [];
           for (const part of message.parts) {
             switch (part.type) {
-              case "reasoning":
-                block.push(part);
-                break;
               case "text": {
                 if (blockHasToolInvocations) {
                   processBlock2();
@@ -1659,6 +1776,11 @@ function convertToCoreMessages(messages, options) {
                 block.push(part);
                 break;
               }
+              case "file":
+              case "reasoning": {
+                block.push(part);
+                break;
+              }
               case "tool-invocation": {
                 if (((_b = part.toolInvocation.step) != null ? _b : 0) !== currentStep) {
                   processBlock2();
@@ -1774,6 +1896,7 @@ function detectSingleMessageCharacteristics(message) {
   if (typeof message === "object" && message !== null && (message.role === "function" || // UI-only role
   message.role === "data" || // UI-only role
   "toolInvocations" in message || // UI-specific field
+  "parts" in message || // UI-specific field
   "experimental_attachments" in message)) {
     return "has-ui-specific-parts";
   } else if (typeof message === "object" && message !== null && "content" in message && (Array.isArray(message.content) || // Core messages can have array content
@@ -1903,6 +2026,7 @@ var coreAssistantMessageSchema = z6.object({
     z6.array(
       z6.union([
         textPartSchema,
+        filePartSchema,
         reasoningPartSchema,
         redactedReasoningPartSchema,
         toolCallPartSchema
@@ -3812,6 +3936,7 @@ function asReasoningText(reasoning) {
 // core/generate-text/to-response-messages.ts
 function toResponseMessages({
   text: text2 = "",
+  files,
   reasoning,
   tools,
   toolCalls,
@@ -3826,6 +3951,12 @@ function toResponseMessages({
       ...reasoning.map(
         (part) => part.type === "text" ? { ...part, type: "reasoning" } : { ...part, type: "redacted-reasoning" }
       ),
+      // TODO language model v2: switch to order response content (instead of type-based ordering)
+      ...files.map((file) => ({
+        type: "file",
+        data: file.base64,
+        mimeType: file.mimeType
+      })),
       { type: "text", text: text2 },
       ...toolCalls
     ],
@@ -4115,6 +4246,7 @@ async function generateText({
           responseMessages.push(
             ...toResponseMessages({
               text: text2,
+              files: asFiles(currentModelResponse.files),
               reasoning: asReasoningDetails(currentModelResponse.reasoning),
               tools: tools != null ? tools : {},
               toolCalls: currentToolCalls,
@@ -4130,6 +4262,7 @@ async function generateText({
           // TODO v5: rename reasoning to reasoningText (and use reasoning for composite array)
           reasoning: asReasoningText(currentReasoningDetails),
           reasoningDetails: currentReasoningDetails,
+          files: asFiles(currentModelResponse.files),
           sources: (_e = currentModelResponse.sources) != null ? _e : [],
           toolCalls: currentToolCalls,
           toolResults: currentToolResults,
@@ -4171,6 +4304,7 @@ async function generateText({
       );
       return new DefaultGenerateTextResult({
         text: text2,
+        files: asFiles(currentModelResponse.files),
         reasoning: asReasoningText(currentReasoningDetails),
         reasoningDetails: currentReasoningDetails,
         sources,
@@ -4280,6 +4414,7 @@ async function executeTools({
 var DefaultGenerateTextResult = class {
   constructor(options) {
     this.text = options.text;
+    this.files = options.files;
     this.reasoning = options.reasoning;
     this.reasoningDetails = options.reasoningDetails;
     this.toolCalls = options.toolCalls;
@@ -4309,6 +4444,10 @@ function asReasoningDetails(reasoning) {
   }
   return reasoning;
 }
+function asFiles(files) {
+  var _a17;
+  return (_a17 = files == null ? void 0 : files.map((file) => new DefaultGeneratedFile(file))) != null ? _a17 : [];
+}
 
 // core/generate-text/output.ts
 var output_exports = {};
@@ -4647,6 +4786,15 @@ function runToolsTransformation({
           controller.enqueue(chunk);
           break;
         }
+        case "file": {
+          controller.enqueue(
+            new DefaultGeneratedFileWithType({
+              data: chunk.data,
+              mimeType: chunk.mimeType
+            })
+          );
+          break;
+        }
         case "tool-call-delta": {
           if (toolCallStreaming) {
             if (!activeToolCalls[chunk.toolCallId]) {
@@ -4954,6 +5102,7 @@ var DefaultStreamTextResult = class {
     this.reasoningPromise = new DelayedPromise();
     this.reasoningDetailsPromise = new DelayedPromise();
     this.sourcesPromise = new DelayedPromise();
+    this.filesPromise = new DelayedPromise();
     this.toolCallsPromise = new DelayedPromise();
     this.toolResultsPromise = new DelayedPromise();
     this.requestPromise = new DelayedPromise();
@@ -4972,6 +5121,7 @@ var DefaultStreamTextResult = class {
     let recordedContinuationText = "";
     let recordedFullText = "";
     let stepReasoning = [];
+    let stepFiles = [];
     let activeReasoningText = void 0;
     let recordedStepSources = [];
     const recordedSources = [];
@@ -5024,6 +5174,9 @@ var DefaultStreamTextResult = class {
         if (part.type === "redacted-reasoning") {
           stepReasoning.push({ type: "redacted", data: part.data });
         }
+        if (part.type === "file") {
+          stepFiles.push(part);
+        }
         if (part.type === "source") {
           recordedSources.push(part.source);
           recordedStepSources.push(part.source);
@@ -5037,6 +5190,7 @@ var DefaultStreamTextResult = class {
         if (part.type === "step-finish") {
           const stepMessages = toResponseMessages({
             text: recordedContinuationText,
+            files: stepFiles,
             reasoning: stepReasoning,
             tools: tools != null ? tools : {},
             toolCalls: recordedToolCalls,
@@ -5063,6 +5217,7 @@ var DefaultStreamTextResult = class {
             text: recordedStepText,
             reasoning: asReasoningText(stepReasoning),
             reasoningDetails: stepReasoning,
+            files: stepFiles,
             sources: recordedStepSources,
             toolCalls: recordedToolCalls,
             toolResults: recordedToolResults,
@@ -5086,6 +5241,7 @@ var DefaultStreamTextResult = class {
           recordedStepText = "";
           recordedStepSources = [];
           stepReasoning = [];
+          stepFiles = [];
           activeReasoningText = void 0;
           if (nextStepType !== "done") {
             stepType = nextStepType;
@@ -5131,6 +5287,7 @@ var DefaultStreamTextResult = class {
           self.usagePromise.resolve(usage);
           self.textPromise.resolve(recordedFullText);
           self.sourcesPromise.resolve(recordedSources);
+          self.filesPromise.resolve(lastStep.files);
           self.stepsPromise.resolve(recordedSteps);
           await (onFinish == null ? void 0 : onFinish({
             finishReason,
@@ -5139,6 +5296,7 @@ var DefaultStreamTextResult = class {
             text: recordedFullText,
             reasoning: lastStep.reasoning,
             reasoningDetails: lastStep.reasoningDetails,
+            files: lastStep.files,
             sources: lastStep.sources,
             toolCalls: lastStep.toolCalls,
             toolResults: lastStep.toolResults,
@@ -5331,6 +5489,7 @@ var DefaultStreamTextResult = class {
           const stepToolCalls = [];
           const stepToolResults = [];
           const stepReasoning2 = [];
+          const stepFiles2 = [];
           let activeReasoningText2 = void 0;
           let stepFinishReason = "unknown";
           let stepUsage = {
@@ -5476,6 +5635,11 @@ var DefaultStreamTextResult = class {
                       });
                       break;
                     }
+                    case "file": {
+                      stepFiles2.push(chunk);
+                      controller.enqueue(chunk);
+                      break;
+                    }
                     case "source":
                     case "tool-call-streaming-start":
                     case "tool-call-delta": {
@@ -5594,6 +5758,7 @@ var DefaultStreamTextResult = class {
                       responseMessages.push(
                         ...toResponseMessages({
                           text: stepText,
+                          files: stepFiles2,
                           reasoning: stepReasoning2,
                           tools: tools != null ? tools : {},
                           toolCalls: stepToolCalls,
@@ -5674,6 +5839,9 @@ var DefaultStreamTextResult = class {
   get sources() {
     return this.sourcesPromise.value;
   }
+  get files() {
+    return this.filesPromise.value;
+  }
   get toolCalls() {
     return this.toolCallsPromise.value;
   }
@@ -5792,6 +5960,15 @@ var DefaultStreamTextResult = class {
               }
               break;
             }
+            case "file": {
+              controller.enqueue(
+                formatDataStreamPart2("file", {
+                  mimeType: chunk.mimeType,
+                  data: chunk.base64
+                })
+              );
+              break;
+            }
             case "source": {
               if (sendSources) {
                 controller.enqueue(
@@ -6307,6 +6484,7 @@ function appendClientMessage({
 import {
   extractMaxToolInvocationStep
 } from "@ai-sdk/ui-utils";
+import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
 function appendResponseMessages({
   messages,
   responseMessages,
@@ -6387,6 +6565,19 @@ function appendResponseMessages({
               }
               case "tool-call":
                 break;
+              case "file":
+                if (part.data instanceof URL) {
+                  throw new AISDKError18({
+                    name: "InvalidAssistantFileData",
+                    message: "File data cannot be a URL"
+                  });
+                }
+                parts.push({
+                  type: "file",
+                  mimeType: part.mimeType,
+                  data: convertDataContentToBase64String(part.data)
+                });
+                break;
             }
           }
         }
@@ -6510,7 +6701,7 @@ function customProvider({
 var experimental_customProvider = customProvider;
 
 // core/registry/no-such-provider-error.ts
-import { AISDKError as AISDKError18, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError19, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
@@ -6529,7 +6720,7 @@ var NoSuchProviderError = class extends NoSuchModelError3 {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return AISDKError18.hasMarker(error, marker16);
+    return AISDKError19.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;