ai 5.0.0-canary.18 → 5.0.0-canary.19

package/dist/internal/index.js

@@ -21,38 +21,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var internal_exports = {};
 __export(internal_exports, {
   HANGING_STREAM_WARNING_TIME_MS: () => HANGING_STREAM_WARNING_TIME_MS,
-  StreamData: () => StreamData,
   convertToLanguageModelPrompt: () => convertToLanguageModelPrompt,
   createCallbacksTransformer: () => createCallbacksTransformer,
-  formatDataStreamPart: () => formatDataStreamPart,
-  mergeStreams: () => mergeStreams,
   prepareCallSettings: () => prepareCallSettings,
-  prepareResponseHeaders: () => prepareResponseHeaders,
   prepareRetries: () => prepareRetries,
   prepareToolsAndToolChoice: () => prepareToolsAndToolChoice,
   standardizePrompt: () => standardizePrompt
 });
 module.exports = __toCommonJS(internal_exports);
 
-// core/prompt/standardize-prompt.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod7 = require("zod");
+// core/prompt/convert-to-language-model-prompt.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
-// core/prompt/message-conversion-error.ts
+// util/download-error.ts
 var import_provider = require("@ai-sdk/provider");
-var name = "AI_MessageConversionError";
+var name = "AI_DownloadError";
 var marker = `vercel.ai.error.${name}`;
 var symbol = Symbol.for(marker);
 var _a;
-var MessageConversionError = class extends import_provider.AISDKError {
+var DownloadError = class extends import_provider.AISDKError {
   constructor({
-    originalMessage,
-    message
+    url,
+    statusCode,
+    statusText,
+    cause,
+    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
   }) {
-    super({ name, message });
+    super({ name, message, cause });
     this[_a] = true;
-    this.originalMessage = originalMessage;
+    this.url = url;
+    this.statusCode = statusCode;
+    this.statusText = statusText;
   }
   static isInstance(error) {
     return import_provider.AISDKError.hasMarker(error, marker);
@@ -60,270 +59,171 @@ var MessageConversionError = class extends import_provider.AISDKError {
 };
 _a = symbol;
 
-// core/prompt/convert-to-model-messages.ts
-function convertToModelMessages(messages, options) {
-  var _a6, _b;
-  const tools = (_a6 = options == null ? void 0 : options.tools) != null ? _a6 : {};
-  const coreMessages = [];
-  for (let i = 0; i < messages.length; i++) {
-    const message = messages[i];
-    const isLastMessage = i === messages.length - 1;
-    const { role, content } = message;
-    switch (role) {
-      case "system": {
-        coreMessages.push({
-          role: "system",
-          content
-        });
-        break;
-      }
-      case "user": {
-        coreMessages.push({
-          role: "user",
-          content: message.parts.filter(
-            (part) => part.type === "text" || part.type === "file"
-          ).map(
-            (part) => part.type === "file" ? {
-              type: "file",
-              mediaType: part.mediaType,
-              filename: part.filename,
-              data: part.url
-            } : part
-          )
-        });
-        break;
-      }
-      case "assistant": {
-        if (message.parts != null) {
-          let processBlock2 = function() {
-            const content2 = [];
-            for (const part of block) {
-              switch (part.type) {
-                case "text": {
-                  content2.push(part);
-                  break;
-                }
-                case "file": {
-                  content2.push({
-                    type: "file",
-                    mediaType: part.mediaType,
-                    data: part.url
-                  });
-                  break;
-                }
-                case "reasoning": {
-                  content2.push({
-                    type: "reasoning",
-                    text: part.text,
-                    providerOptions: part.providerMetadata
-                  });
-                  break;
-                }
-                case "tool-invocation":
-                  content2.push({
-                    type: "tool-call",
-                    toolCallId: part.toolInvocation.toolCallId,
-                    toolName: part.toolInvocation.toolName,
-                    args: part.toolInvocation.args
-                  });
-                  break;
-                default: {
-                  const _exhaustiveCheck = part;
-                  throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
-                }
-              }
-            }
-            coreMessages.push({
-              role: "assistant",
-              content: content2
-            });
-            const stepInvocations = block.filter(
-              (part) => part.type === "tool-invocation"
-            ).map((part) => part.toolInvocation);
-            if (stepInvocations.length > 0) {
-              coreMessages.push({
-                role: "tool",
-                content: stepInvocations.map(
-                  (toolInvocation) => {
-                    if (!("result" in toolInvocation)) {
-                      throw new MessageConversionError({
-                        originalMessage: message,
-                        message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
-                      });
-                    }
-                    const { toolCallId, toolName, result } = toolInvocation;
-                    const tool = tools[toolName];
-                    return (tool == null ? void 0 : tool.experimental_toToolResultContent) != null ? {
-                      type: "tool-result",
-                      toolCallId,
-                      toolName,
-                      result: tool.experimental_toToolResultContent(result),
-                      experimental_content: tool.experimental_toToolResultContent(result)
-                    } : {
-                      type: "tool-result",
-                      toolCallId,
-                      toolName,
-                      result
-                    };
-                  }
-                )
-              });
-            }
-            block = [];
-            blockHasToolInvocations = false;
-            currentStep++;
-          };
-          var processBlock = processBlock2;
-          let currentStep = 0;
-          let blockHasToolInvocations = false;
-          let block = [];
-          for (const part of message.parts) {
-            switch (part.type) {
-              case "text": {
-                if (blockHasToolInvocations) {
-                  processBlock2();
-                }
-                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();
-                }
-                block.push(part);
-                blockHasToolInvocations = true;
-                break;
-              }
-            }
-          }
-          processBlock2();
-          break;
-        }
-        if (content && !isLastMessage) {
-          coreMessages.push({ role: "assistant", content });
-        }
-        break;
-      }
-      default: {
-        const _exhaustiveCheck = role;
-        throw new MessageConversionError({
-          originalMessage: message,
-          message: `Unsupported role: ${_exhaustiveCheck}`
-        });
-      }
-    }
-  }
-  return coreMessages;
-}
-
-// core/prompt/detect-prompt-type.ts
-function detectPromptType(prompt) {
-  if (!Array.isArray(prompt)) {
-    return "other";
-  }
-  if (prompt.length === 0) {
-    return "messages";
-  }
-  const characteristics = prompt.map(detectSingleMessageCharacteristics);
-  if (characteristics.some((c) => c === "has-ui-specific-parts")) {
-    return "ui-messages";
-  } else if (characteristics.every(
-    (c) => c === "has-core-specific-parts" || c === "message"
-  )) {
-    return "messages";
-  } else {
-    return "other";
-  }
-}
-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
-  "providerOptions" in message)) {
-    return "has-core-specific-parts";
-  } else if (typeof message === "object" && message !== null && "role" in message && "content" in message && typeof message.content === "string" && ["system", "user", "assistant", "tool"].includes(message.role)) {
-    return "message";
-  } else {
-    return "other";
-  }
-}
-
-// core/prompt/message.ts
-var import_zod6 = require("zod");
-
-// core/types/provider-metadata.ts
-var import_zod2 = require("zod");
-
-// core/types/json-value.ts
-var import_zod = require("zod");
-var jsonValueSchema = import_zod.z.lazy(
-  () => import_zod.z.union([
-    import_zod.z.null(),
-    import_zod.z.string(),
-    import_zod.z.number(),
-    import_zod.z.boolean(),
-    import_zod.z.record(import_zod.z.string(), jsonValueSchema),
-    import_zod.z.array(jsonValueSchema)
-  ])
-);
-
-// core/types/provider-metadata.ts
-var providerMetadataSchema = import_zod2.z.record(
-  import_zod2.z.string(),
-  import_zod2.z.record(import_zod2.z.string(), jsonValueSchema)
-);
-
-// core/prompt/content-part.ts
-var import_zod5 = require("zod");
-
-// core/prompt/data-content.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
-
-// core/prompt/split-data-url.ts
-function splitDataUrl(dataUrl) {
+// util/download.ts
+async function download({ url }) {
+  var _a6;
+  const urlText = url.toString();
   try {
-    const [header, base64Content] = dataUrl.split(",");
+    const response = await fetch(urlText);
+    if (!response.ok) {
+      throw new DownloadError({
+        url: urlText,
+        statusCode: response.status,
+        statusText: response.statusText
+      });
+    }
     return {
-      mediaType: header.split(";")[0].split(":")[1],
-      base64Content
+      data: new Uint8Array(await response.arrayBuffer()),
+      mediaType: (_a6 = response.headers.get("content-type")) != null ? _a6 : void 0
     };
   } catch (error) {
-    return {
-      mediaType: void 0,
-      base64Content: void 0
-    };
+    if (DownloadError.isInstance(error)) {
+      throw error;
+    }
+    throw new DownloadError({ url: urlText, cause: error });
   }
 }
 
-// core/prompt/data-content.ts
-var dataContentSchema = import_zod3.z.union([
-  import_zod3.z.string(),
-  import_zod3.z.instanceof(Uint8Array),
-  import_zod3.z.instanceof(ArrayBuffer),
-  import_zod3.z.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => {
-      var _a6, _b;
-      return (_b = (_a6 = globalThis.Buffer) == null ? void 0 : _a6.isBuffer(value)) != null ? _b : false;
-    },
-    { message: "Must be a Buffer" }
-  )
-]);
-function convertToLanguageModelV2DataContent(content) {
-  if (content instanceof Uint8Array) {
-    return { data: content, mediaType: void 0 };
-  }
+// core/util/detect-media-type.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var imageMediaTypeSignatures = [
+  {
+    mediaType: "image/gif",
+    bytesPrefix: [71, 73, 70],
+    base64Prefix: "R0lG"
+  },
+  {
+    mediaType: "image/png",
+    bytesPrefix: [137, 80, 78, 71],
+    base64Prefix: "iVBORw"
+  },
+  {
+    mediaType: "image/jpeg",
+    bytesPrefix: [255, 216],
+    base64Prefix: "/9j/"
+  },
+  {
+    mediaType: "image/webp",
+    bytesPrefix: [82, 73, 70, 70],
+    base64Prefix: "UklGRg"
+  },
+  {
+    mediaType: "image/bmp",
+    bytesPrefix: [66, 77],
+    base64Prefix: "Qk"
+  },
+  {
+    mediaType: "image/tiff",
+    bytesPrefix: [73, 73, 42, 0],
+    base64Prefix: "SUkqAA"
+  },
+  {
+    mediaType: "image/tiff",
+    bytesPrefix: [77, 77, 0, 42],
+    base64Prefix: "TU0AKg"
+  },
+  {
+    mediaType: "image/avif",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      32,
+      102,
+      116,
+      121,
+      112,
+      97,
+      118,
+      105,
+      102
+    ],
+    base64Prefix: "AAAAIGZ0eXBhdmlm"
+  },
+  {
+    mediaType: "image/heic",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      32,
+      102,
+      116,
+      121,
+      112,
+      104,
+      101,
+      105,
+      99
+    ],
+    base64Prefix: "AAAAIGZ0eXBoZWlj"
+  }
+];
+var stripID3 = (data) => {
+  const bytes = typeof data === "string" ? (0, import_provider_utils.convertBase64ToUint8Array)(data) : data;
+  const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
+  return bytes.slice(id3Size + 10);
+};
+function stripID3TagsIfPresent(data) {
+  const hasId3 = typeof data === "string" && data.startsWith("SUQz") || typeof data !== "string" && data.length > 10 && data[0] === 73 && // 'I'
+  data[1] === 68 && // 'D'
+  data[2] === 51;
+  return hasId3 ? stripID3(data) : data;
+}
+function detectMediaType({
+  data,
+  signatures
+}) {
+  const processedData = stripID3TagsIfPresent(data);
+  for (const signature of signatures) {
+    if (typeof processedData === "string" ? processedData.startsWith(signature.base64Prefix) : processedData.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
+      (byte, index) => processedData[index] === byte
+    )) {
+      return signature.mediaType;
+    }
+  }
+  return void 0;
+}
+
+// core/prompt/data-content.ts
+var import_provider2 = require("@ai-sdk/provider");
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_zod = require("zod");
+
+// core/prompt/split-data-url.ts
+function splitDataUrl(dataUrl) {
+  try {
+    const [header, base64Content] = dataUrl.split(",");
+    return {
+      mediaType: header.split(";")[0].split(":")[1],
+      base64Content
+    };
+  } catch (error) {
+    return {
+      mediaType: void 0,
+      base64Content: void 0
+    };
+  }
+}
+
+// core/prompt/data-content.ts
+var dataContentSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.instanceof(Uint8Array),
+  import_zod.z.instanceof(ArrayBuffer),
+  import_zod.z.custom(
+    // Buffer might not be available in some environments such as CloudFlare:
+    (value) => {
+      var _a6, _b;
+      return (_b = (_a6 = globalThis.Buffer) == null ? void 0 : _a6.isBuffer(value)) != null ? _b : false;
+    },
+    { message: "Must be a Buffer" }
+  )
+]);
+function convertToLanguageModelV2DataContent(content) {
+  if (content instanceof Uint8Array) {
+    return { data: content, mediaType: void 0 };
+  }
   if (content instanceof ArrayBuffer) {
     return { data: new Uint8Array(content), mediaType: void 0 };
   }
@@ -348,499 +248,245 @@ function convertToLanguageModelV2DataContent(content) {
   return { data: content, mediaType: void 0 };
 }
 
-// core/prompt/tool-result-content.ts
-var import_zod4 = require("zod");
-var toolResultContentSchema = import_zod4.z.array(
-  import_zod4.z.union([
-    import_zod4.z.object({ type: import_zod4.z.literal("text"), text: import_zod4.z.string() }),
-    import_zod4.z.object({
-      type: import_zod4.z.literal("image"),
-      data: import_zod4.z.string(),
-      mediaType: import_zod4.z.string().optional()
-    })
-  ])
-);
-
-// core/prompt/content-part.ts
-var textPartSchema = import_zod5.z.object({
-  type: import_zod5.z.literal("text"),
-  text: import_zod5.z.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var imagePartSchema = import_zod5.z.object({
-  type: import_zod5.z.literal("image"),
-  image: import_zod5.z.union([dataContentSchema, import_zod5.z.instanceof(URL)]),
-  mediaType: import_zod5.z.string().optional(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var filePartSchema = import_zod5.z.object({
-  type: import_zod5.z.literal("file"),
-  data: import_zod5.z.union([dataContentSchema, import_zod5.z.instanceof(URL)]),
-  filename: import_zod5.z.string().optional(),
-  mediaType: import_zod5.z.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var reasoningPartSchema = import_zod5.z.object({
-  type: import_zod5.z.literal("reasoning"),
-  text: import_zod5.z.string(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var toolCallPartSchema = import_zod5.z.object({
-  type: import_zod5.z.literal("tool-call"),
-  toolCallId: import_zod5.z.string(),
-  toolName: import_zod5.z.string(),
-  args: import_zod5.z.unknown(),
-  providerOptions: providerMetadataSchema.optional()
-});
-var toolResultPartSchema = import_zod5.z.object({
-  type: import_zod5.z.literal("tool-result"),
-  toolCallId: import_zod5.z.string(),
-  toolName: import_zod5.z.string(),
-  result: import_zod5.z.unknown(),
-  content: toolResultContentSchema.optional(),
-  isError: import_zod5.z.boolean().optional(),
-  providerOptions: providerMetadataSchema.optional()
-});
-
-// core/prompt/message.ts
-var systemModelMessageSchema = import_zod6.z.object(
-  {
-    role: import_zod6.z.literal("system"),
-    content: import_zod6.z.string(),
-    providerOptions: providerMetadataSchema.optional()
+// core/prompt/invalid-message-role-error.ts
+var import_provider3 = require("@ai-sdk/provider");
+var name2 = "AI_InvalidMessageRoleError";
+var marker2 = `vercel.ai.error.${name2}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+var InvalidMessageRoleError = class extends import_provider3.AISDKError {
+  constructor({
+    role,
+    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
+  }) {
+    super({ name: name2, message });
+    this[_a2] = true;
+    this.role = role;
   }
-);
-var userModelMessageSchema = import_zod6.z.object({
-  role: import_zod6.z.literal("user"),
-  content: import_zod6.z.union([
-    import_zod6.z.string(),
-    import_zod6.z.array(import_zod6.z.union([textPartSchema, imagePartSchema, filePartSchema]))
-  ]),
-  providerOptions: providerMetadataSchema.optional()
-});
-var assistantModelMessageSchema = import_zod6.z.object({
-  role: import_zod6.z.literal("assistant"),
-  content: import_zod6.z.union([
-    import_zod6.z.string(),
-    import_zod6.z.array(
-      import_zod6.z.union([
-        textPartSchema,
-        filePartSchema,
-        reasoningPartSchema,
-        toolCallPartSchema
-      ])
-    )
-  ]),
-  providerOptions: providerMetadataSchema.optional()
-});
-var toolModelMessageSchema = import_zod6.z.object({
-  role: import_zod6.z.literal("tool"),
-  content: import_zod6.z.array(toolResultPartSchema),
-  providerOptions: providerMetadataSchema.optional()
-});
-var modelMessageSchema = import_zod6.z.union([
-  systemModelMessageSchema,
-  userModelMessageSchema,
-  assistantModelMessageSchema,
-  toolModelMessageSchema
-]);
+  static isInstance(error) {
+    return import_provider3.AISDKError.hasMarker(error, marker2);
+  }
+};
+_a2 = symbol2;
 
-// core/prompt/standardize-prompt.ts
-async function standardizePrompt({
+// core/prompt/convert-to-language-model-prompt.ts
+async function convertToLanguageModelPrompt({
   prompt,
-  tools
+  supportedUrls,
+  downloadImplementation = download
 }) {
-  if (prompt.prompt == null && prompt.messages == null) {
-    throw new import_provider3.InvalidPromptError({
-      prompt,
-      message: "prompt or messages must be defined"
-    });
-  }
-  if (prompt.prompt != null && prompt.messages != null) {
-    throw new import_provider3.InvalidPromptError({
-      prompt,
-      message: "prompt and messages cannot be defined at the same time"
-    });
-  }
-  if (prompt.system != null && typeof prompt.system !== "string") {
-    throw new import_provider3.InvalidPromptError({
-      prompt,
-      message: "system must be a string"
-    });
-  }
-  if (prompt.prompt != null) {
-    if (typeof prompt.prompt !== "string") {
-      throw new import_provider3.InvalidPromptError({
-        prompt,
-        message: "prompt must be a string"
-      });
+  const downloadedAssets = await downloadAssets(
+    prompt.messages,
+    downloadImplementation,
+    supportedUrls
+  );
+  return [
+    ...prompt.system != null ? [{ role: "system", content: prompt.system }] : [],
+    ...prompt.messages.map(
+      (message) => convertToLanguageModelMessage(message, downloadedAssets)
+    )
+  ];
+}
+function convertToLanguageModelMessage(message, downloadedAssets) {
+  const role = message.role;
+  switch (role) {
+    case "system": {
+      return {
+        role: "system",
+        content: message.content,
+        providerOptions: message.providerOptions
+      };
     }
-    return {
-      system: prompt.system,
-      messages: [
-        {
+    case "user": {
+      if (typeof message.content === "string") {
+        return {
           role: "user",
-          content: prompt.prompt
-        }
-      ]
-    };
-  }
-  if (prompt.messages != null) {
-    const promptType = detectPromptType(prompt.messages);
-    if (promptType === "other") {
-      throw new import_provider3.InvalidPromptError({
-        prompt,
-        message: "messages must be an array of ModelMessage or UIMessage"
-      });
-    }
-    const messages = promptType === "ui-messages" ? convertToModelMessages(prompt.messages, {
-      tools
-    }) : prompt.messages;
-    if (messages.length === 0) {
-      throw new import_provider3.InvalidPromptError({
-        prompt,
-        message: "messages must not be empty"
-      });
-    }
-    const validationResult = await (0, import_provider_utils2.safeValidateTypes)({
-      value: messages,
-      schema: import_zod7.z.array(modelMessageSchema)
-    });
-    if (!validationResult.success) {
-      throw new import_provider3.InvalidPromptError({
-        prompt,
-        message: "messages must be an array of ModelMessage or UIMessage",
-        cause: validationResult.error
-      });
-    }
-    return {
-      messages,
-      system: prompt.system
-    };
-  }
-  throw new Error("unreachable");
-}
-
-// core/util/index.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-
-// core/util/data-stream-parts.ts
-var textStreamPart = {
-  code: "0",
-  name: "text",
-  parse: (value) => {
-    if (typeof value !== "string") {
-      throw new Error('"text" parts expect a string value.');
+          content: [{ type: "text", text: message.content }],
+          providerOptions: message.providerOptions
+        };
+      }
+      return {
+        role: "user",
+        content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
+        providerOptions: message.providerOptions
+      };
     }
-    return { type: "text", value };
-  }
-};
-var dataStreamPart = {
-  code: "2",
-  name: "data",
-  parse: (value) => {
-    if (!Array.isArray(value)) {
-      throw new Error('"data" parts expect an array value.');
+    case "assistant": {
+      if (typeof message.content === "string") {
+        return {
+          role: "assistant",
+          content: [{ type: "text", text: message.content }],
+          providerOptions: message.providerOptions
+        };
+      }
+      return {
+        role: "assistant",
+        content: message.content.filter(
+          // remove empty text parts:
+          (part) => part.type !== "text" || part.text !== ""
+        ).map((part) => {
+          const providerOptions = part.providerOptions;
+          switch (part.type) {
+            case "file": {
+              const { data, mediaType } = convertToLanguageModelV2DataContent(
+                part.data
+              );
+              return {
+                type: "file",
+                data,
+                filename: part.filename,
+                mediaType: mediaType != null ? mediaType : part.mediaType,
+                providerOptions
+              };
+            }
+            case "reasoning": {
+              return {
+                type: "reasoning",
+                text: part.text,
+                providerOptions
+              };
+            }
+            case "text": {
+              return {
+                type: "text",
+                text: part.text,
+                providerOptions
+              };
+            }
+            case "tool-call": {
+              return {
+                type: "tool-call",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                args: part.args,
+                providerOptions
+              };
+            }
+          }
+        }),
+        providerOptions: message.providerOptions
+      };
     }
-    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.');
+    case "tool": {
+      return {
+        role: "tool",
+        content: message.content.map((part) => ({
+          type: "tool-result",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          result: part.result,
+          content: part.experimental_content,
+          isError: part.isError,
+          providerOptions: part.providerOptions
+        })),
+        providerOptions: message.providerOptions
+      };
     }
-    return { type: "error", value };
-  }
-};
-var messageAnnotationsStreamPart = {
-  code: "8",
-  name: "message_annotations",
-  parse: (value) => {
-    if (!Array.isArray(value)) {
-      throw new Error('"message_annotations" parts expect an array value.');
+    default: {
+      const _exhaustiveCheck = role;
+      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
     }
-    return { type: "message_annotations", value };
   }
-};
-var toolCallStreamPart = {
-  code: "9",
-  name: "tool_call",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string" || !("args" in value) || typeof value.args !== "object") {
-      throw new Error(
-        '"tool_call" parts expect an object with a "toolCallId", "toolName", and "args" property.'
-      );
+}
+async function downloadAssets(messages, downloadImplementation, supportedUrls) {
+  const urls = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
+    (content) => Array.isArray(content)
+  ).flat().filter(
+    (part) => part.type === "image" || part.type === "file"
+  ).map((part) => {
+    var _a6;
+    const mediaType = (_a6 = part.mediaType) != null ? _a6 : part.type === "image" ? "image/*" : void 0;
+    let data = part.type === "image" ? part.image : part.data;
+    if (typeof data === "string") {
+      try {
+        data = new URL(data);
+      } catch (ignored) {
+      }
     }
+    return { mediaType, data };
+  }).filter(
+    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils3.isUrlSupported)({
+      url: part.data.toString(),
+      mediaType: part.mediaType,
+      supportedUrls
+    })
+  ).map((part) => part.data);
+  const downloadedImages = await Promise.all(
+    urls.map(async (url) => ({
+      url,
+      data: await downloadImplementation({ url })
+    }))
+  );
+  return Object.fromEntries(
+    downloadedImages.map(({ url, data }) => [url.toString(), data])
+  );
+}
+function convertPartToLanguageModelPart(part, downloadedAssets) {
+  var _a6, _b;
+  if (part.type === "text") {
     return {
-      type: "tool_call",
-      value
+      type: "text",
+      text: part.text,
+      providerOptions: part.providerOptions
     };
   }
-};
-var toolResultStreamPart = {
-  code: "a",
-  name: "tool_result",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("result" in value)) {
-      throw new Error(
-        '"tool_result" parts expect an object with a "toolCallId" and a "result" property.'
-      );
-    }
-    return {
-      type: "tool_result",
-      value
-    };
+  let originalData;
+  const type = part.type;
+  switch (type) {
+    case "image":
+      originalData = part.image;
+      break;
+    case "file":
+      originalData = part.data;
+      break;
+    default:
+      throw new Error(`Unsupported part type: ${type}`);
   }
-};
-var toolCallStreamingStartStreamPart = {
-  code: "b",
-  name: "tool_call_streaming_start",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string") {
-      throw new Error(
-        '"tool_call_streaming_start" parts expect an object with a "toolCallId" and "toolName" property.'
-      );
+  const { data: convertedData, mediaType: convertedMediaType } = convertToLanguageModelV2DataContent(originalData);
+  let mediaType = convertedMediaType != null ? convertedMediaType : part.mediaType;
+  let data = convertedData;
+  if (data instanceof URL) {
+    const downloadedFile = downloadedAssets[data.toString()];
+    if (downloadedFile) {
+      data = downloadedFile.data;
+      mediaType = (_a6 = downloadedFile.mediaType) != null ? _a6 : mediaType;
     }
-    return {
-      type: "tool_call_streaming_start",
-      value
-    };
   }
-};
-var toolCallDeltaStreamPart = {
-  code: "c",
-  name: "tool_call_delta",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("argsTextDelta" in value) || typeof value.argsTextDelta !== "string") {
-      throw new Error(
-        '"tool_call_delta" parts expect an object with a "toolCallId" and "argsTextDelta" property.'
-      );
+  switch (type) {
+    case "image": {
+      if (data instanceof Uint8Array || typeof data === "string") {
+        mediaType = (_b = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _b : mediaType;
+      }
+      return {
+        type: "file",
+        mediaType: mediaType != null ? mediaType : "image/*",
+        // any image
+        filename: void 0,
+        data,
+        providerOptions: part.providerOptions
+      };
     }
-    return {
-      type: "tool_call_delta",
-      value
-    };
-  }
-};
-var finishMessageStreamPart = {
-  code: "d",
-  name: "finish_message",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
-      throw new Error(
-        '"finish_message" parts expect an object with a "finishReason" property.'
-      );
-    }
-    const result = {
-      finishReason: value.finishReason
-    };
-    if ("usage" in value && value.usage != null && typeof value.usage === "object") {
-      result.usage = {
-        inputTokens: "inputTokens" in value.usage && typeof value.usage.inputTokens === "number" ? value.usage.inputTokens : void 0,
-        outputTokens: "outputTokens" in value.usage && typeof value.usage.outputTokens === "number" ? value.usage.outputTokens : void 0,
-        totalTokens: "totalTokens" in value.usage && typeof value.usage.totalTokens === "number" ? value.usage.totalTokens : void 0,
-        reasoningTokens: "reasoningTokens" in value.usage && typeof value.usage.reasoningTokens === "number" ? value.usage.reasoningTokens : void 0,
-        cachedInputTokens: "cachedInputTokens" in value.usage && typeof value.usage.cachedInputTokens === "number" ? value.usage.cachedInputTokens : void 0
-      };
-    }
-    return {
-      type: "finish_message",
-      value: result
-    };
-  }
-};
-var finishStepStreamPart = {
-  code: "e",
-  name: "finish_step",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
-      throw new Error(
-        '"finish_step" parts expect an object with a "finishReason" property.'
-      );
-    }
-    const result = {
-      finishReason: value.finishReason,
-      isContinued: false
-    };
-    if ("usage" in value && value.usage != null && typeof value.usage === "object") {
-      result.usage = {
-        inputTokens: "inputTokens" in value.usage && typeof value.usage.inputTokens === "number" ? value.usage.inputTokens : void 0,
-        outputTokens: "outputTokens" in value.usage && typeof value.usage.outputTokens === "number" ? value.usage.outputTokens : void 0,
-        totalTokens: "totalTokens" in value.usage && typeof value.usage.totalTokens === "number" ? value.usage.totalTokens : void 0,
-        reasoningTokens: "reasoningTokens" in value.usage && typeof value.usage.reasoningTokens === "number" ? value.usage.reasoningTokens : void 0,
-        cachedInputTokens: "cachedInputTokens" in value.usage && typeof value.usage.cachedInputTokens === "number" ? value.usage.cachedInputTokens : void 0
-      };
-    }
-    if ("isContinued" in value && typeof value.isContinued === "boolean") {
-      result.isContinued = value.isContinued;
-    }
-    return {
-      type: "finish_step",
-      value: result
-    };
-  }
-};
-var startStepStreamPart = {
-  code: "f",
-  name: "start_step",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("messageId" in value) || typeof value.messageId !== "string") {
-      throw new Error(
-        '"start_step" parts expect an object with an "id" property.'
-      );
-    }
-    return {
-      type: "start_step",
-      value: {
-        messageId: value.messageId
-      }
-    };
-  }
-};
-var reasoningStreamPart = {
-  code: "g",
-  name: "reasoning",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("text" in value) || typeof value.text !== "string" || "providerMetadata" in value && typeof value.providerMetadata !== "object") {
-      throw new Error(
-        '"reasoning" parts expect an object with a "text" property.'
-      );
-    }
-    return {
-      type: "reasoning",
-      value: {
-        text: value.text,
-        providerMetadata: value.providerMetadata
+    case "file": {
+      if (mediaType == null) {
+        throw new Error(`Media type is missing for file part`);
       }
-    };
-  }
-};
-var sourcePart = {
-  code: "h",
-  name: "source",
-  parse: (value) => {
-    if (value == null || typeof value !== "object") {
-      throw new Error('"source" parts expect a Source object.');
-    }
-    return {
-      type: "source",
-      value
-    };
-  }
-};
-var fileStreamPart = {
-  code: "k",
-  name: "file",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("url" in value) || typeof value.url !== "string" || !("mediaType" in value) || typeof value.mediaType !== "string") {
-      throw new Error(
-        '"file" parts expect an object with a "url" and "mediaType" property.'
-      );
+      return {
+        type: "file",
+        mediaType,
+        filename: part.filename,
+        data,
+        providerOptions: part.providerOptions
+      };
     }
-    return { type: "file", value };
-  }
-};
-var reasoningPartFinishStreamPart = {
-  code: "l",
-  name: "reasoning_part_finish",
-  parse: () => {
-    return {
-      type: "reasoning_part_finish",
-      value: {}
-    };
-  }
-};
-var dataStreamParts = [
-  textStreamPart,
-  dataStreamPart,
-  errorStreamPart,
-  messageAnnotationsStreamPart,
-  toolCallStreamPart,
-  toolResultStreamPart,
-  toolCallStreamingStartStreamPart,
-  toolCallDeltaStreamPart,
-  finishMessageStreamPart,
-  finishStepStreamPart,
-  startStepStreamPart,
-  reasoningStreamPart,
-  sourcePart,
-  reasoningPartFinishStreamPart,
-  fileStreamPart
-];
-var dataStreamPartsByCode = Object.fromEntries(
-  dataStreamParts.map((part) => [part.code, part])
-);
-var DataStreamStringPrefixes = Object.fromEntries(
-  dataStreamParts.map((part) => [part.name, part.code])
-);
-var validCodes = dataStreamParts.map((part) => part.code);
-function formatDataStreamPart(type, value) {
-  const streamPart = dataStreamParts.find((part) => part.name === type);
-  if (!streamPart) {
-    throw new Error(`Invalid stream part type: ${type}`);
-  }
-  return `${streamPart.code}:${JSON.stringify(value)}
-`;
-}
-
-// core/util/is-non-empty-object.ts
-function isNonEmptyObject(object) {
-  return object != null && Object.keys(object).length > 0;
-}
-
-// core/prompt/prepare-tools-and-tool-choice.ts
-function prepareToolsAndToolChoice({
-  tools,
-  toolChoice,
-  activeTools
-}) {
-  if (!isNonEmptyObject(tools)) {
-    return {
-      tools: void 0,
-      toolChoice: void 0
-    };
   }
-  const filteredTools = activeTools != null ? Object.entries(tools).filter(
-    ([name6]) => activeTools.includes(name6)
-  ) : Object.entries(tools);
-  return {
-    tools: filteredTools.map(([name6, tool]) => {
-      const toolType = tool.type;
-      switch (toolType) {
-        case void 0:
-        case "function":
-          return {
-            type: "function",
-            name: name6,
-            description: tool.description,
-            parameters: (0, import_provider_utils3.asSchema)(tool.parameters).jsonSchema
-          };
-        case "provider-defined":
-          return {
-            type: "provider-defined",
-            name: name6,
-            id: tool.id,
-            args: tool.args
-          };
-        default: {
-          const exhaustiveCheck = toolType;
-          throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
-        }
-      }
-    }),
-    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
-  };
 }
 
 // errors/invalid-argument-error.ts
 var import_provider4 = require("@ai-sdk/provider");
-var name2 = "AI_InvalidArgumentError";
-var marker2 = `vercel.ai.error.${name2}`;
-var symbol2 = Symbol.for(marker2);
-var _a2;
+var name3 = "AI_InvalidArgumentError";
+var marker3 = `vercel.ai.error.${name3}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
 var InvalidArgumentError = class extends import_provider4.AISDKError {
   constructor({
     parameter,
@@ -848,127 +494,19 @@ var InvalidArgumentError = class extends import_provider4.AISDKError {
     message
   }) {
     super({
-      name: name2,
+      name: name3,
       message: `Invalid argument for parameter ${parameter}: ${message}`
     });
-    this[_a2] = true;
+    this[_a3] = true;
     this.parameter = parameter;
     this.value = value;
   }
   static isInstance(error) {
-    return import_provider4.AISDKError.hasMarker(error, marker2);
-  }
-};
-_a2 = symbol2;
-
-// util/retry-with-exponential-backoff.ts
-var import_provider6 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-
-// util/retry-error.ts
-var import_provider5 = require("@ai-sdk/provider");
-var name3 = "AI_RetryError";
-var marker3 = `vercel.ai.error.${name3}`;
-var symbol3 = Symbol.for(marker3);
-var _a3;
-var RetryError = class extends import_provider5.AISDKError {
-  constructor({
-    message,
-    reason,
-    errors
-  }) {
-    super({ name: name3, message });
-    this[_a3] = true;
-    this.reason = reason;
-    this.errors = errors;
-    this.lastError = errors[errors.length - 1];
-  }
-  static isInstance(error) {
-    return import_provider5.AISDKError.hasMarker(error, marker3);
+    return import_provider4.AISDKError.hasMarker(error, marker3);
   }
 };
 _a3 = symbol3;
 
-// util/retry-with-exponential-backoff.ts
-var retryWithExponentialBackoff = ({
-  maxRetries = 2,
-  initialDelayInMs = 2e3,
-  backoffFactor = 2
-} = {}) => async (f) => _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs: initialDelayInMs,
-  backoffFactor
-});
-async function _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs,
-  backoffFactor
-}, errors = []) {
-  try {
-    return await f();
-  } catch (error) {
-    if ((0, import_provider_utils4.isAbortError)(error)) {
-      throw error;
-    }
-    if (maxRetries === 0) {
-      throw error;
-    }
-    const errorMessage = (0, import_provider_utils4.getErrorMessage)(error);
-    const newErrors = [...errors, error];
-    const tryNumber = newErrors.length;
-    if (tryNumber > maxRetries) {
-      throw new RetryError({
-        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
-        reason: "maxRetriesExceeded",
-        errors: newErrors
-      });
-    }
-    if (error instanceof Error && import_provider6.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      await (0, import_provider_utils4.delay)(delayInMs);
-      return _retryWithExponentialBackoff(
-        f,
-        { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
-        newErrors
-      );
-    }
-    if (tryNumber === 1) {
-      throw error;
-    }
-    throw new RetryError({
-      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
-      reason: "errorNotRetryable",
-      errors: newErrors
-    });
-  }
-}
-
-// core/prompt/prepare-retries.ts
-function prepareRetries({
-  maxRetries
-}) {
-  if (maxRetries != null) {
-    if (!Number.isInteger(maxRetries)) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be an integer"
-      });
-    }
-    if (maxRetries < 0) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be >= 0"
-      });
-    }
-  }
-  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
-  return {
-    maxRetries: maxRetriesResult,
-    retry: retryWithExponentialBackoff({ maxRetries: maxRetriesResult })
-  };
-}
-
 // core/prompt/prepare-call-settings.ts
 function prepareCallSettings({
   maxOutputTokens,
@@ -1062,500 +600,591 @@ function prepareCallSettings({
   };
 }
 
-// core/prompt/convert-to-language-model-prompt.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+// util/retry-with-exponential-backoff.ts
+var import_provider6 = require("@ai-sdk/provider");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
 
-// util/download-error.ts
-var import_provider7 = require("@ai-sdk/provider");
-var name4 = "AI_DownloadError";
+// util/retry-error.ts
+var import_provider5 = require("@ai-sdk/provider");
+var name4 = "AI_RetryError";
 var marker4 = `vercel.ai.error.${name4}`;
 var symbol4 = Symbol.for(marker4);
 var _a4;
-var DownloadError = class extends import_provider7.AISDKError {
+var RetryError = class extends import_provider5.AISDKError {
   constructor({
-    url,
-    statusCode,
-    statusText,
-    cause,
-    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
+    message,
+    reason,
+    errors
   }) {
-    super({ name: name4, message, cause });
+    super({ name: name4, message });
     this[_a4] = true;
-    this.url = url;
-    this.statusCode = statusCode;
-    this.statusText = statusText;
+    this.reason = reason;
+    this.errors = errors;
+    this.lastError = errors[errors.length - 1];
   }
   static isInstance(error) {
-    return import_provider7.AISDKError.hasMarker(error, marker4);
+    return import_provider5.AISDKError.hasMarker(error, marker4);
   }
 };
 _a4 = symbol4;
 
-// util/download.ts
-async function download({ url }) {
-  var _a6;
-  const urlText = url.toString();
-  try {
-    const response = await fetch(urlText);
-    if (!response.ok) {
-      throw new DownloadError({
-        url: urlText,
-        statusCode: response.status,
-        statusText: response.statusText
-      });
-    }
-    return {
-      data: new Uint8Array(await response.arrayBuffer()),
-      mediaType: (_a6 = response.headers.get("content-type")) != null ? _a6 : void 0
-    };
+// util/retry-with-exponential-backoff.ts
+var retryWithExponentialBackoff = ({
+  maxRetries = 2,
+  initialDelayInMs = 2e3,
+  backoffFactor = 2
+} = {}) => async (f) => _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs: initialDelayInMs,
+  backoffFactor
+});
+async function _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs,
+  backoffFactor
+}, errors = []) {
+  try {
+    return await f();
   } catch (error) {
-    if (DownloadError.isInstance(error)) {
+    if ((0, import_provider_utils4.isAbortError)(error)) {
       throw error;
     }
-    throw new DownloadError({ url: urlText, cause: error });
+    if (maxRetries === 0) {
+      throw error;
+    }
+    const errorMessage = (0, import_provider_utils4.getErrorMessage)(error);
+    const newErrors = [...errors, error];
+    const tryNumber = newErrors.length;
+    if (tryNumber > maxRetries) {
+      throw new RetryError({
+        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+        reason: "maxRetriesExceeded",
+        errors: newErrors
+      });
+    }
+    if (error instanceof Error && import_provider6.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+      await (0, import_provider_utils4.delay)(delayInMs);
+      return _retryWithExponentialBackoff(
+        f,
+        { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
+        newErrors
+      );
+    }
+    if (tryNumber === 1) {
+      throw error;
+    }
+    throw new RetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
   }
 }
 
-// core/util/detect-media-type.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var imageMediaTypeSignatures = [
-  {
-    mediaType: "image/gif",
-    bytesPrefix: [71, 73, 70],
-    base64Prefix: "R0lG"
-  },
-  {
-    mediaType: "image/png",
-    bytesPrefix: [137, 80, 78, 71],
-    base64Prefix: "iVBORw"
-  },
-  {
-    mediaType: "image/jpeg",
-    bytesPrefix: [255, 216],
-    base64Prefix: "/9j/"
-  },
-  {
-    mediaType: "image/webp",
-    bytesPrefix: [82, 73, 70, 70],
-    base64Prefix: "UklGRg"
-  },
-  {
-    mediaType: "image/bmp",
-    bytesPrefix: [66, 77],
-    base64Prefix: "Qk"
-  },
-  {
-    mediaType: "image/tiff",
-    bytesPrefix: [73, 73, 42, 0],
-    base64Prefix: "SUkqAA"
-  },
-  {
-    mediaType: "image/tiff",
-    bytesPrefix: [77, 77, 0, 42],
-    base64Prefix: "TU0AKg"
-  },
-  {
-    mediaType: "image/avif",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      32,
-      102,
-      116,
-      121,
-      112,
-      97,
-      118,
-      105,
-      102
-    ],
-    base64Prefix: "AAAAIGZ0eXBhdmlm"
-  },
-  {
-    mediaType: "image/heic",
-    bytesPrefix: [
-      0,
-      0,
-      0,
-      32,
-      102,
-      116,
-      121,
-      112,
-      104,
-      101,
-      105,
-      99
-    ],
-    base64Prefix: "AAAAIGZ0eXBoZWlj"
+// core/prompt/prepare-retries.ts
+function prepareRetries({
+  maxRetries
+}) {
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be an integer"
+      });
+    }
+    if (maxRetries < 0) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be >= 0"
+      });
+    }
   }
-];
-var stripID3 = (data) => {
-  const bytes = typeof data === "string" ? (0, import_provider_utils5.convertBase64ToUint8Array)(data) : data;
-  const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
-  return bytes.slice(id3Size + 10);
-};
-function stripID3TagsIfPresent(data) {
-  const hasId3 = typeof data === "string" && data.startsWith("SUQz") || typeof data !== "string" && data.length > 10 && data[0] === 73 && // 'I'
-  data[1] === 68 && // 'D'
-  data[2] === 51;
-  return hasId3 ? stripID3(data) : data;
+  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
+  return {
+    maxRetries: maxRetriesResult,
+    retry: retryWithExponentialBackoff({ maxRetries: maxRetriesResult })
+  };
 }
-function detectMediaType({
-  data,
-  signatures
+
+// core/util/index.ts
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+
+// core/util/is-non-empty-object.ts
+function isNonEmptyObject(object) {
+  return object != null && Object.keys(object).length > 0;
+}
+
+// core/prompt/prepare-tools-and-tool-choice.ts
+function prepareToolsAndToolChoice({
+  tools,
+  toolChoice,
+  activeTools
 }) {
-  const processedData = stripID3TagsIfPresent(data);
-  for (const signature of signatures) {
-    if (typeof processedData === "string" ? processedData.startsWith(signature.base64Prefix) : processedData.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
-      (byte, index) => processedData[index] === byte
-    )) {
-      return signature.mediaType;
-    }
+  if (!isNonEmptyObject(tools)) {
+    return {
+      tools: void 0,
+      toolChoice: void 0
+    };
   }
-  return void 0;
+  const filteredTools = activeTools != null ? Object.entries(tools).filter(
+    ([name6]) => activeTools.includes(name6)
+  ) : Object.entries(tools);
+  return {
+    tools: filteredTools.map(([name6, tool]) => {
+      const toolType = tool.type;
+      switch (toolType) {
+        case void 0:
+        case "function":
+          return {
+            type: "function",
+            name: name6,
+            description: tool.description,
+            parameters: (0, import_provider_utils5.asSchema)(tool.parameters).jsonSchema
+          };
+        case "provider-defined":
+          return {
+            type: "provider-defined",
+            name: name6,
+            id: tool.id,
+            args: tool.args
+          };
+        default: {
+          const exhaustiveCheck = toolType;
+          throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
+        }
+      }
+    }),
+    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
+  };
 }
 
-// core/prompt/invalid-message-role-error.ts
+// core/prompt/standardize-prompt.ts
 var import_provider8 = require("@ai-sdk/provider");
-var name5 = "AI_InvalidMessageRoleError";
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_zod7 = require("zod");
+
+// core/ui/get-ui-text.ts
+function getUIText(parts) {
+  return parts.map((part) => part.type === "text" ? part.text : "").join("");
+}
+
+// core/prompt/message-conversion-error.ts
+var import_provider7 = require("@ai-sdk/provider");
+var name5 = "AI_MessageConversionError";
 var marker5 = `vercel.ai.error.${name5}`;
 var symbol5 = Symbol.for(marker5);
 var _a5;
-var InvalidMessageRoleError = class extends import_provider8.AISDKError {
+var MessageConversionError = class extends import_provider7.AISDKError {
   constructor({
-    role,
-    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
+    originalMessage,
+    message
   }) {
     super({ name: name5, message });
     this[_a5] = true;
-    this.role = role;
+    this.originalMessage = originalMessage;
   }
   static isInstance(error) {
-    return import_provider8.AISDKError.hasMarker(error, marker5);
+    return import_provider7.AISDKError.hasMarker(error, marker5);
   }
 };
 _a5 = symbol5;
 
-// core/prompt/convert-to-language-model-prompt.ts
-async function convertToLanguageModelPrompt({
-  prompt,
-  supportedUrls,
-  downloadImplementation = download
-}) {
-  const downloadedAssets = await downloadAssets(
-    prompt.messages,
-    downloadImplementation,
-    supportedUrls
-  );
-  return [
-    ...prompt.system != null ? [{ role: "system", content: prompt.system }] : [],
-    ...prompt.messages.map(
-      (message) => convertToLanguageModelMessage(message, downloadedAssets)
-    )
-  ];
-}
-function convertToLanguageModelMessage(message, downloadedAssets) {
-  const role = message.role;
-  switch (role) {
-    case "system": {
-      return {
-        role: "system",
-        content: message.content,
-        providerOptions: message.providerOptions
-      };
-    }
-    case "user": {
-      if (typeof message.content === "string") {
-        return {
-          role: "user",
-          content: [{ type: "text", text: message.content }],
-          providerOptions: message.providerOptions
-        };
+// core/prompt/convert-to-model-messages.ts
+function convertToModelMessages(messages, options) {
+  var _a6, _b;
+  const tools = (_a6 = options == null ? void 0 : options.tools) != null ? _a6 : {};
+  const modelMessages = [];
+  for (const message of messages) {
+    switch (message.role) {
+      case "system": {
+        modelMessages.push({
+          role: "system",
+          content: getUIText(message.parts)
+        });
+        break;
       }
-      return {
-        role: "user",
-        content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
-        providerOptions: message.providerOptions
-      };
-    }
-    case "assistant": {
-      if (typeof message.content === "string") {
-        return {
-          role: "assistant",
-          content: [{ type: "text", text: message.content }],
-          providerOptions: message.providerOptions
-        };
+      case "user": {
+        modelMessages.push({
+          role: "user",
+          content: message.parts.filter(
+            (part) => part.type === "text" || part.type === "file"
+          ).map(
+            (part) => part.type === "file" ? {
+              type: "file",
+              mediaType: part.mediaType,
+              filename: part.filename,
+              data: part.url
+            } : part
+          )
+        });
+        break;
       }
-      return {
-        role: "assistant",
-        content: message.content.filter(
-          // remove empty text parts:
-          (part) => part.type !== "text" || part.text !== ""
-        ).map((part) => {
-          const providerOptions = part.providerOptions;
-          switch (part.type) {
-            case "file": {
-              const { data, mediaType } = convertToLanguageModelV2DataContent(
-                part.data
-              );
-              return {
-                type: "file",
-                data,
-                filename: part.filename,
-                mediaType: mediaType != null ? mediaType : part.mediaType,
-                providerOptions
-              };
-            }
-            case "reasoning": {
-              return {
-                type: "reasoning",
-                text: part.text,
-                providerOptions
-              };
+      case "assistant": {
+        if (message.parts != null) {
+          let processBlock2 = function() {
+            const content = [];
+            for (const part of block) {
+              switch (part.type) {
+                case "text": {
+                  content.push(part);
+                  break;
+                }
+                case "file": {
+                  content.push({
+                    type: "file",
+                    mediaType: part.mediaType,
+                    data: part.url
+                  });
+                  break;
+                }
+                case "reasoning": {
+                  content.push({
+                    type: "reasoning",
+                    text: part.text,
+                    providerOptions: part.providerMetadata
+                  });
+                  break;
+                }
+                case "tool-invocation":
+                  content.push({
+                    type: "tool-call",
+                    toolCallId: part.toolInvocation.toolCallId,
+                    toolName: part.toolInvocation.toolName,
+                    args: part.toolInvocation.args
+                  });
+                  break;
+                default: {
+                  const _exhaustiveCheck = part;
+                  throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
+                }
+              }
             }
-            case "text": {
-              return {
-                type: "text",
-                text: part.text,
-                providerOptions
-              };
+            modelMessages.push({
+              role: "assistant",
+              content
+            });
+            const stepInvocations = block.filter(
+              (part) => part.type === "tool-invocation"
+            ).map((part) => part.toolInvocation);
+            if (stepInvocations.length > 0) {
+              modelMessages.push({
+                role: "tool",
+                content: stepInvocations.map(
+                  (toolInvocation) => {
+                    if (!("result" in toolInvocation)) {
+                      throw new MessageConversionError({
+                        originalMessage: message,
+                        message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
+                      });
+                    }
+                    const { toolCallId, toolName, result } = toolInvocation;
+                    const tool = tools[toolName];
+                    return (tool == null ? void 0 : tool.experimental_toToolResultContent) != null ? {
+                      type: "tool-result",
+                      toolCallId,
+                      toolName,
+                      result: tool.experimental_toToolResultContent(result),
+                      experimental_content: tool.experimental_toToolResultContent(result)
+                    } : {
+                      type: "tool-result",
+                      toolCallId,
+                      toolName,
+                      result
+                    };
+                  }
+                )
+              });
             }
-            case "tool-call": {
-              return {
-                type: "tool-call",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                args: part.args,
-                providerOptions
-              };
+            block = [];
+            blockHasToolInvocations = false;
+            currentStep++;
+          };
+          var processBlock = processBlock2;
+          let currentStep = 0;
+          let blockHasToolInvocations = false;
+          let block = [];
+          for (const part of message.parts) {
+            switch (part.type) {
+              case "text": {
+                if (blockHasToolInvocations) {
+                  processBlock2();
+                }
+                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();
+                }
+                block.push(part);
+                blockHasToolInvocations = true;
+                break;
+              }
             }
           }
-        }),
-        providerOptions: message.providerOptions
-      };
-    }
-    case "tool": {
-      return {
-        role: "tool",
-        content: message.content.map((part) => ({
-          type: "tool-result",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          result: part.result,
-          content: part.experimental_content,
-          isError: part.isError,
-          providerOptions: part.providerOptions
-        })),
-        providerOptions: message.providerOptions
-      };
-    }
-    default: {
-      const _exhaustiveCheck = role;
-      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
-    }
-  }
-}
-async function downloadAssets(messages, downloadImplementation, supportedUrls) {
-  const urls = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
-    (content) => Array.isArray(content)
-  ).flat().filter(
-    (part) => part.type === "image" || part.type === "file"
-  ).map((part) => {
-    var _a6;
-    const mediaType = (_a6 = part.mediaType) != null ? _a6 : part.type === "image" ? "image/*" : void 0;
-    let data = part.type === "image" ? part.image : part.data;
-    if (typeof data === "string") {
-      try {
-        data = new URL(data);
-      } catch (ignored) {
-      }
-    }
-    return { mediaType, data };
-  }).filter(
-    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils6.isUrlSupported)({
-      url: part.data.toString(),
-      mediaType: part.mediaType,
-      supportedUrls
-    })
-  ).map((part) => part.data);
-  const downloadedImages = await Promise.all(
-    urls.map(async (url) => ({
-      url,
-      data: await downloadImplementation({ url })
-    }))
-  );
-  return Object.fromEntries(
-    downloadedImages.map(({ url, data }) => [url.toString(), data])
-  );
-}
-function convertPartToLanguageModelPart(part, downloadedAssets) {
-  var _a6, _b;
-  if (part.type === "text") {
-    return {
-      type: "text",
-      text: part.text,
-      providerOptions: part.providerOptions
-    };
-  }
-  let originalData;
-  const type = part.type;
-  switch (type) {
-    case "image":
-      originalData = part.image;
-      break;
-    case "file":
-      originalData = part.data;
-      break;
-    default:
-      throw new Error(`Unsupported part type: ${type}`);
-  }
-  const { data: convertedData, mediaType: convertedMediaType } = convertToLanguageModelV2DataContent(originalData);
-  let mediaType = convertedMediaType != null ? convertedMediaType : part.mediaType;
-  let data = convertedData;
-  if (data instanceof URL) {
-    const downloadedFile = downloadedAssets[data.toString()];
-    if (downloadedFile) {
-      data = downloadedFile.data;
-      mediaType = (_a6 = downloadedFile.mediaType) != null ? _a6 : mediaType;
-    }
-  }
-  switch (type) {
-    case "image": {
-      if (data instanceof Uint8Array || typeof data === "string") {
-        mediaType = (_b = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _b : mediaType;
+          processBlock2();
+          break;
+        }
+        break;
       }
-      return {
-        type: "file",
-        mediaType: mediaType != null ? mediaType : "image/*",
-        // any image
-        filename: void 0,
-        data,
-        providerOptions: part.providerOptions
-      };
-    }
-    case "file": {
-      if (mediaType == null) {
-        throw new Error(`Media type is missing for file part`);
+      default: {
+        const _exhaustiveCheck = message.role;
+        throw new MessageConversionError({
+          originalMessage: message,
+          message: `Unsupported role: ${_exhaustiveCheck}`
+        });
       }
-      return {
-        type: "file",
-        mediaType,
-        filename: part.filename,
-        data,
-        providerOptions: part.providerOptions
-      };
     }
   }
+  return modelMessages;
 }
 
-// core/util/prepare-response-headers.ts
-function prepareResponseHeaders(headers, {
-  contentType,
-  dataStreamVersion
-}) {
-  const responseHeaders = new Headers(headers != null ? headers : {});
-  if (!responseHeaders.has("Content-Type")) {
-    responseHeaders.set("Content-Type", contentType);
+// core/prompt/detect-prompt-type.ts
+function detectPromptType(prompt) {
+  if (!Array.isArray(prompt)) {
+    return "other";
+  }
+  if (prompt.length === 0) {
+    return "model-messages";
+  }
+  const characteristics = prompt.map(detectSingleMessageCharacteristics);
+  if (characteristics.some((c) => c === "has-ui-specific-parts")) {
+    return "ui-messages";
+  } else if (characteristics.every(
+    (c) => c === "has-core-specific-parts" || c === "message"
+  )) {
+    return "model-messages";
+  } else {
+    return "other";
   }
-  if (dataStreamVersion !== void 0) {
-    responseHeaders.set("X-Vercel-AI-Data-Stream", dataStreamVersion);
+}
+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
+  "providerOptions" in message)) {
+    return "has-core-specific-parts";
+  } else if (typeof message === "object" && message !== null && "role" in message && "content" in message && typeof message.content === "string" && ["system", "user", "assistant", "tool"].includes(message.role)) {
+    return "message";
+  } else {
+    return "other";
   }
-  return responseHeaders;
 }
 
-// core/util/merge-streams.ts
-function mergeStreams(stream1, stream2) {
-  const reader1 = stream1.getReader();
-  const reader2 = stream2.getReader();
-  let lastRead1 = void 0;
-  let lastRead2 = void 0;
-  let stream1Done = false;
-  let stream2Done = false;
-  async function readStream1(controller) {
-    try {
-      if (lastRead1 == null) {
-        lastRead1 = reader1.read();
-      }
-      const result = await lastRead1;
-      lastRead1 = void 0;
-      if (!result.done) {
-        controller.enqueue(result.value);
-      } else {
-        controller.close();
-      }
-    } catch (error) {
-      controller.error(error);
-    }
+// core/prompt/message.ts
+var import_zod6 = require("zod");
+
+// core/types/provider-metadata.ts
+var import_zod3 = require("zod");
+
+// core/types/json-value.ts
+var import_zod2 = require("zod");
+var jsonValueSchema = import_zod2.z.lazy(
+  () => import_zod2.z.union([
+    import_zod2.z.null(),
+    import_zod2.z.string(),
+    import_zod2.z.number(),
+    import_zod2.z.boolean(),
+    import_zod2.z.record(import_zod2.z.string(), jsonValueSchema),
+    import_zod2.z.array(jsonValueSchema)
+  ])
+);
+
+// core/types/provider-metadata.ts
+var providerMetadataSchema = import_zod3.z.record(
+  import_zod3.z.string(),
+  import_zod3.z.record(import_zod3.z.string(), jsonValueSchema)
+);
+
+// core/prompt/content-part.ts
+var import_zod5 = require("zod");
+
+// core/prompt/tool-result-content.ts
+var import_zod4 = require("zod");
+var toolResultContentSchema = import_zod4.z.array(
+  import_zod4.z.union([
+    import_zod4.z.object({ type: import_zod4.z.literal("text"), text: import_zod4.z.string() }),
+    import_zod4.z.object({
+      type: import_zod4.z.literal("image"),
+      data: import_zod4.z.string(),
+      mediaType: import_zod4.z.string().optional()
+    })
+  ])
+);
+
+// core/prompt/content-part.ts
+var textPartSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("text"),
+  text: import_zod5.z.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var imagePartSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("image"),
+  image: import_zod5.z.union([dataContentSchema, import_zod5.z.instanceof(URL)]),
+  mediaType: import_zod5.z.string().optional(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var filePartSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("file"),
+  data: import_zod5.z.union([dataContentSchema, import_zod5.z.instanceof(URL)]),
+  filename: import_zod5.z.string().optional(),
+  mediaType: import_zod5.z.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var reasoningPartSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("reasoning"),
+  text: import_zod5.z.string(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolCallPartSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("tool-call"),
+  toolCallId: import_zod5.z.string(),
+  toolName: import_zod5.z.string(),
+  args: import_zod5.z.unknown(),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolResultPartSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("tool-result"),
+  toolCallId: import_zod5.z.string(),
+  toolName: import_zod5.z.string(),
+  result: import_zod5.z.unknown(),
+  content: toolResultContentSchema.optional(),
+  isError: import_zod5.z.boolean().optional(),
+  providerOptions: providerMetadataSchema.optional()
+});
+
+// core/prompt/message.ts
+var systemModelMessageSchema = import_zod6.z.object(
+  {
+    role: import_zod6.z.literal("system"),
+    content: import_zod6.z.string(),
+    providerOptions: providerMetadataSchema.optional()
   }
-  async function readStream2(controller) {
-    try {
-      if (lastRead2 == null) {
-        lastRead2 = reader2.read();
-      }
-      const result = await lastRead2;
-      lastRead2 = void 0;
-      if (!result.done) {
-        controller.enqueue(result.value);
-      } else {
-        controller.close();
-      }
-    } catch (error) {
-      controller.error(error);
-    }
+);
+var userModelMessageSchema = import_zod6.z.object({
+  role: import_zod6.z.literal("user"),
+  content: import_zod6.z.union([
+    import_zod6.z.string(),
+    import_zod6.z.array(import_zod6.z.union([textPartSchema, imagePartSchema, filePartSchema]))
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var assistantModelMessageSchema = import_zod6.z.object({
+  role: import_zod6.z.literal("assistant"),
+  content: import_zod6.z.union([
+    import_zod6.z.string(),
+    import_zod6.z.array(
+      import_zod6.z.union([
+        textPartSchema,
+        filePartSchema,
+        reasoningPartSchema,
+        toolCallPartSchema
+      ])
+    )
+  ]),
+  providerOptions: providerMetadataSchema.optional()
+});
+var toolModelMessageSchema = import_zod6.z.object({
+  role: import_zod6.z.literal("tool"),
+  content: import_zod6.z.array(toolResultPartSchema),
+  providerOptions: providerMetadataSchema.optional()
+});
+var modelMessageSchema = import_zod6.z.union([
+  systemModelMessageSchema,
+  userModelMessageSchema,
+  assistantModelMessageSchema,
+  toolModelMessageSchema
+]);
+
+// core/prompt/standardize-prompt.ts
+async function standardizePrompt({
+  prompt,
+  tools
+}) {
+  if (prompt.prompt == null && prompt.messages == null) {
+    throw new import_provider8.InvalidPromptError({
+      prompt,
+      message: "prompt or messages must be defined"
+    });
   }
-  return new ReadableStream({
-    async pull(controller) {
-      try {
-        if (stream1Done) {
-          await readStream2(controller);
-          return;
-        }
-        if (stream2Done) {
-          await readStream1(controller);
-          return;
-        }
-        if (lastRead1 == null) {
-          lastRead1 = reader1.read();
-        }
-        if (lastRead2 == null) {
-          lastRead2 = reader2.read();
-        }
-        const { result, reader } = await Promise.race([
-          lastRead1.then((result2) => ({ result: result2, reader: reader1 })),
-          lastRead2.then((result2) => ({ result: result2, reader: reader2 }))
-        ]);
-        if (!result.done) {
-          controller.enqueue(result.value);
-        }
-        if (reader === reader1) {
-          lastRead1 = void 0;
-          if (result.done) {
-            await readStream2(controller);
-            stream1Done = true;
-          }
-        } else {
-          lastRead2 = void 0;
-          if (result.done) {
-            stream2Done = true;
-            await readStream1(controller);
-          }
+  if (prompt.prompt != null && prompt.messages != null) {
+    throw new import_provider8.InvalidPromptError({
+      prompt,
+      message: "prompt and messages cannot be defined at the same time"
+    });
+  }
+  if (prompt.system != null && typeof prompt.system !== "string") {
+    throw new import_provider8.InvalidPromptError({
+      prompt,
+      message: "system must be a string"
+    });
+  }
+  if (prompt.prompt != null) {
+    if (typeof prompt.prompt !== "string") {
+      throw new import_provider8.InvalidPromptError({
+        prompt,
+        message: "prompt must be a string"
+      });
+    }
+    return {
+      system: prompt.system,
+      messages: [
+        {
+          role: "user",
+          content: prompt.prompt
         }
-      } catch (error) {
-        controller.error(error);
-      }
-    },
-    cancel() {
-      reader1.cancel();
-      reader2.cancel();
+      ]
+    };
+  }
+  if (prompt.messages != null) {
+    const promptType = detectPromptType(prompt.messages);
+    if (promptType === "other") {
+      throw new import_provider8.InvalidPromptError({
+        prompt,
+        message: "messages must be an array of ModelMessage or UIMessage"
+      });
     }
-  });
+    const messages = promptType === "ui-messages" ? convertToModelMessages(prompt.messages, {
+      tools
+    }) : prompt.messages;
+    if (messages.length === 0) {
+      throw new import_provider8.InvalidPromptError({
+        prompt,
+        message: "messages must not be empty"
+      });
+    }
+    const validationResult = await (0, import_provider_utils6.safeValidateTypes)({
+      value: messages,
+      schema: import_zod7.z.array(modelMessageSchema)
+    });
+    if (!validationResult.success) {
+      throw new import_provider8.InvalidPromptError({
+        prompt,
+        message: "messages must be an array of ModelMessage or UIMessage",
+        cause: validationResult.error
+      });
+    }
+    return {
+      messages,
+      system: prompt.system
+    };
+  }
+  throw new Error("unreachable");
 }
 
 // streams/stream-callbacks.ts
 function createCallbacksTransformer(callbacks = {}) {
-  const textEncoder = new TextEncoder();
   let aggregatedResponse = "";
   return new TransformStream({
     async start() {
@@ -1563,7 +1192,7 @@ function createCallbacksTransformer(callbacks = {}) {
         await callbacks.onStart();
     },
     async transform(message, controller) {
-      controller.enqueue(textEncoder.encode(message));
+      controller.enqueue(message);
       aggregatedResponse += message;
       if (callbacks.onToken)
         await callbacks.onToken(message);
@@ -1572,9 +1201,6 @@ function createCallbacksTransformer(callbacks = {}) {
       }
     },
     async flush() {
-      if (callbacks.onCompletion) {
-        await callbacks.onCompletion(aggregatedResponse);
-      }
       if (callbacks.onFinal) {
         await callbacks.onFinal(aggregatedResponse);
       }
@@ -1584,79 +1210,12 @@ function createCallbacksTransformer(callbacks = {}) {
 
 // util/constants.ts
 var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
-
-// streams/stream-data.ts
-var StreamData = class {
-  constructor() {
-    this.encoder = new TextEncoder();
-    this.controller = null;
-    this.isClosed = false;
-    this.warningTimeout = null;
-    const self = this;
-    this.stream = new ReadableStream({
-      start: async (controller) => {
-        self.controller = controller;
-        if (process.env.NODE_ENV === "development") {
-          self.warningTimeout = setTimeout(() => {
-            console.warn(
-              "The data stream is hanging. Did you forget to close it with `data.close()`?"
-            );
-          }, HANGING_STREAM_WARNING_TIME_MS);
-        }
-      },
-      pull: (controller) => {
-      },
-      cancel: (reason) => {
-        this.isClosed = true;
-      }
-    });
-  }
-  async close() {
-    if (this.isClosed) {
-      throw new Error("Data Stream has already been closed.");
-    }
-    if (!this.controller) {
-      throw new Error("Stream controller is not initialized.");
-    }
-    this.controller.close();
-    this.isClosed = true;
-    if (this.warningTimeout) {
-      clearTimeout(this.warningTimeout);
-    }
-  }
-  append(value) {
-    if (this.isClosed) {
-      throw new Error("Data Stream has already been closed.");
-    }
-    if (!this.controller) {
-      throw new Error("Stream controller is not initialized.");
-    }
-    this.controller.enqueue(
-      this.encoder.encode(formatDataStreamPart("data", [value]))
-    );
-  }
-  appendMessageAnnotation(value) {
-    if (this.isClosed) {
-      throw new Error("Data Stream has already been closed.");
-    }
-    if (!this.controller) {
-      throw new Error("Stream controller is not initialized.");
-    }
-    this.controller.enqueue(
-      this.encoder.encode(formatDataStreamPart("message_annotations", [value]))
-    );
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HANGING_STREAM_WARNING_TIME_MS,
-  StreamData,
   convertToLanguageModelPrompt,
   createCallbacksTransformer,
-  formatDataStreamPart,
-  mergeStreams,
   prepareCallSettings,
-  prepareResponseHeaders,
   prepareRetries,
   prepareToolsAndToolChoice,
   standardizePrompt