@ai-sdk/provider-utils 5.0.0-beta.4 → 5.0.0-beta.49

package/dist/index.js

@@ -1,98 +1,7 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DEFAULT_MAX_DOWNLOAD_SIZE: () => DEFAULT_MAX_DOWNLOAD_SIZE,
-  DelayedPromise: () => DelayedPromise,
-  DownloadError: () => DownloadError,
-  EventSourceParserStream: () => import_stream2.EventSourceParserStream,
-  VERSION: () => VERSION,
-  asSchema: () => asSchema,
-  combineHeaders: () => combineHeaders,
-  convertAsyncIteratorToReadableStream: () => convertAsyncIteratorToReadableStream,
-  convertBase64ToUint8Array: () => convertBase64ToUint8Array,
-  convertImageModelFileToDataUri: () => convertImageModelFileToDataUri,
-  convertToBase64: () => convertToBase64,
-  convertToFormData: () => convertToFormData,
-  convertUint8ArrayToBase64: () => convertUint8ArrayToBase64,
-  createBinaryResponseHandler: () => createBinaryResponseHandler,
-  createEventSourceResponseHandler: () => createEventSourceResponseHandler,
-  createIdGenerator: () => createIdGenerator,
-  createJsonErrorResponseHandler: () => createJsonErrorResponseHandler,
-  createJsonResponseHandler: () => createJsonResponseHandler,
-  createProviderToolFactory: () => createProviderToolFactory,
-  createProviderToolFactoryWithOutputSchema: () => createProviderToolFactoryWithOutputSchema,
-  createStatusCodeErrorResponseHandler: () => createStatusCodeErrorResponseHandler,
-  createToolNameMapping: () => createToolNameMapping,
-  delay: () => delay,
-  downloadBlob: () => downloadBlob,
-  dynamicTool: () => dynamicTool,
-  executeTool: () => executeTool,
-  extractResponseHeaders: () => extractResponseHeaders,
-  generateId: () => generateId,
-  getErrorMessage: () => getErrorMessage,
-  getFromApi: () => getFromApi,
-  getRuntimeEnvironmentUserAgent: () => getRuntimeEnvironmentUserAgent,
-  injectJsonInstructionIntoMessages: () => injectJsonInstructionIntoMessages,
-  isAbortError: () => isAbortError,
-  isNonNullable: () => isNonNullable,
-  isParsableJson: () => isParsableJson,
-  isUrlSupported: () => isUrlSupported,
-  jsonSchema: () => jsonSchema,
-  lazySchema: () => lazySchema,
-  loadApiKey: () => loadApiKey,
-  loadOptionalSetting: () => loadOptionalSetting,
-  loadSetting: () => loadSetting,
-  mediaTypeToExtension: () => mediaTypeToExtension,
-  normalizeHeaders: () => normalizeHeaders,
-  parseJSON: () => parseJSON,
-  parseJsonEventStream: () => parseJsonEventStream,
-  parseProviderOptions: () => parseProviderOptions,
-  postFormDataToApi: () => postFormDataToApi,
-  postJsonToApi: () => postJsonToApi,
-  postToApi: () => postToApi,
-  readResponseWithSizeLimit: () => readResponseWithSizeLimit,
-  removeUndefinedEntries: () => removeUndefinedEntries,
-  resolve: () => resolve,
-  safeParseJSON: () => safeParseJSON,
-  safeValidateTypes: () => safeValidateTypes,
-  stripFileExtension: () => stripFileExtension,
-  tool: () => tool,
-  validateDownloadUrl: () => validateDownloadUrl,
-  validateTypes: () => validateTypes,
-  withUserAgentSuffix: () => withUserAgentSuffix,
-  withoutTrailingSlash: () => withoutTrailingSlash,
-  zodSchema: () => zodSchema
-});
-module.exports = __toCommonJS(index_exports);
+// src/as-array.ts
+function asArray(value) {
+  return value === void 0 ? [] : Array.isArray(value) ? value : [value];
+}
 
 // src/combine-headers.ts
 function combineHeaders(...headers) {
@@ -143,6 +52,68 @@ function convertAsyncIteratorToReadableStream(iterator) {
   });
 }
 
+// src/uint8-utils.ts
+var { btoa, atob } = globalThis;
+function convertBase64ToUint8Array(base64String) {
+  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
+  const latin1string = atob(base64Url);
+  return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
+}
+function convertUint8ArrayToBase64(array) {
+  let latin1string = "";
+  for (let i = 0; i < array.length; i++) {
+    latin1string += String.fromCodePoint(array[i]);
+  }
+  return btoa(latin1string);
+}
+function convertToBase64(value) {
+  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+}
+
+// src/convert-inline-file-data-to-uint8-array.ts
+function convertInlineFileDataToUint8Array(data) {
+  if (data.type === "text") {
+    return new TextEncoder().encode(data.text);
+  }
+  if (data.data instanceof Uint8Array) {
+    return data.data;
+  }
+  if (data.data instanceof ArrayBuffer) {
+    return new Uint8Array(data.data);
+  }
+  return convertBase64ToUint8Array(data.data);
+}
+
+// src/convert-image-model-file-to-data-uri.ts
+function convertImageModelFileToDataUri(file) {
+  if (file.type === "url") return file.url;
+  return `data:${file.mediaType};base64,${typeof file.data === "string" ? file.data : convertUint8ArrayToBase64(file.data)}`;
+}
+
+// src/convert-to-form-data.ts
+function convertToFormData(input, options = {}) {
+  const { useArrayBrackets = true } = options;
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(input)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 1) {
+        formData.append(key, value[0]);
+        continue;
+      }
+      const arrayKey = useArrayBrackets ? `${key}[]` : key;
+      for (const item of value) {
+        formData.append(arrayKey, item);
+      }
+      continue;
+    }
+    formData.append(key, value);
+  }
+  return formData;
+}
+
 // src/create-tool-name-mapping.ts
 function createToolNameMapping({
   tools = [],
@@ -246,66 +217,294 @@ var DelayedPromise = class {
   }
 };
 
-// src/extract-response-headers.ts
-function extractResponseHeaders(response) {
-  return Object.fromEntries([...response.headers]);
-}
-
-// src/uint8-utils.ts
-var { btoa, atob } = globalThis;
-function convertBase64ToUint8Array(base64String) {
-  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
-  const latin1string = atob(base64Url);
-  return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
-}
-function convertUint8ArrayToBase64(array) {
-  let latin1string = "";
-  for (let i = 0; i < array.length; i++) {
-    latin1string += String.fromCodePoint(array[i]);
+// src/detect-media-type.ts
+var imageMediaTypeSignatures = [
+  {
+    mediaType: "image/gif",
+    bytesPrefix: [71, 73, 70]
+    // GIF
+  },
+  {
+    mediaType: "image/png",
+    bytesPrefix: [137, 80, 78, 71]
+    // PNG
+  },
+  {
+    mediaType: "image/jpeg",
+    bytesPrefix: [255, 216]
+    // JPEG
+  },
+  {
+    mediaType: "image/webp",
+    bytesPrefix: [
+      82,
+      73,
+      70,
+      70,
+      // "RIFF"
+      null,
+      null,
+      null,
+      null,
+      // file size (variable)
+      87,
+      69,
+      66,
+      80
+      // "WEBP"
+    ]
+  },
+  {
+    mediaType: "image/bmp",
+    bytesPrefix: [66, 77]
+  },
+  {
+    mediaType: "image/tiff",
+    bytesPrefix: [73, 73, 42, 0]
+  },
+  {
+    mediaType: "image/tiff",
+    bytesPrefix: [77, 77, 0, 42]
+  },
+  {
+    mediaType: "image/avif",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      32,
+      102,
+      116,
+      121,
+      112,
+      97,
+      118,
+      105,
+      102
+    ]
+  },
+  {
+    mediaType: "image/heic",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      32,
+      102,
+      116,
+      121,
+      112,
+      104,
+      101,
+      105,
+      99
+    ]
   }
-  return btoa(latin1string);
+];
+var documentMediaTypeSignatures = [
+  {
+    mediaType: "application/pdf",
+    bytesPrefix: [37, 80, 68, 70]
+    // %PDF
+  }
+];
+var audioMediaTypeSignatures = [
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 251]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 250]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 243]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 242]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 227]
+  },
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 226]
+  },
+  {
+    mediaType: "audio/wav",
+    bytesPrefix: [
+      82,
+      // R
+      73,
+      // I
+      70,
+      // F
+      70,
+      // F
+      null,
+      null,
+      null,
+      null,
+      87,
+      // W
+      65,
+      // A
+      86,
+      // V
+      69
+      // E
+    ]
+  },
+  {
+    mediaType: "audio/ogg",
+    bytesPrefix: [79, 103, 103, 83]
+  },
+  {
+    mediaType: "audio/flac",
+    bytesPrefix: [102, 76, 97, 67]
+  },
+  {
+    mediaType: "audio/aac",
+    bytesPrefix: [64, 21, 0, 0]
+  },
+  {
+    mediaType: "audio/mp4",
+    bytesPrefix: [102, 116, 121, 112]
+  },
+  {
+    mediaType: "audio/webm",
+    bytesPrefix: [26, 69, 223, 163]
+  }
+];
+var videoMediaTypeSignatures = [
+  {
+    mediaType: "video/mp4",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      null,
+      102,
+      116,
+      121,
+      112
+      // ftyp
+    ]
+  },
+  {
+    mediaType: "video/webm",
+    bytesPrefix: [26, 69, 223, 163]
+    // EBML
+  },
+  {
+    mediaType: "video/quicktime",
+    bytesPrefix: [
+      0,
+      0,
+      0,
+      20,
+      102,
+      116,
+      121,
+      112,
+      113,
+      116
+      // ftypqt
+    ]
+  },
+  {
+    mediaType: "video/x-msvideo",
+    bytesPrefix: [82, 73, 70, 70]
+    // RIFF (AVI)
+  }
+];
+var stripID3 = (data) => {
+  const bytes = typeof data === "string" ? 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 detectMediaTypeBySignatures({
+  data,
+  signatures
+}) {
+  const processedData = stripID3TagsIfPresent(data);
+  const bytes = typeof processedData === "string" ? convertBase64ToUint8Array(
+    processedData.substring(0, Math.min(processedData.length, 24))
+  ) : processedData;
+  for (const signature of signatures) {
+    if (bytes.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
+      (byte, index) => byte === null || bytes[index] === byte
+    )) {
+      return signature.mediaType;
+    }
+  }
+  return void 0;
+}
+var topLevelSignatureTables = {
+  image: imageMediaTypeSignatures,
+  audio: audioMediaTypeSignatures,
+  video: videoMediaTypeSignatures,
+  application: documentMediaTypeSignatures
+};
+function detectMediaType({
+  data,
+  topLevelType
+}) {
+  if (topLevelType === void 0) {
+    return detectMediaTypeBySignatures({
+      data,
+      signatures: [
+        ...imageMediaTypeSignatures,
+        ...documentMediaTypeSignatures,
+        ...audioMediaTypeSignatures,
+        ...videoMediaTypeSignatures
+      ]
+    });
+  }
+  const signatures = topLevelSignatureTables[topLevelType];
+  if (signatures === void 0) {
+    return void 0;
+  }
+  return detectMediaTypeBySignatures({ data, signatures });
 }
-function convertToBase64(value) {
-  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+function getTopLevelMediaType(mediaType) {
+  const slashIndex = mediaType.indexOf("/");
+  return slashIndex === -1 ? mediaType : mediaType.substring(0, slashIndex);
 }
-
-// src/convert-image-model-file-to-data-uri.ts
-function convertImageModelFileToDataUri(file) {
-  if (file.type === "url") return file.url;
-  return `data:${file.mediaType};base64,${typeof file.data === "string" ? file.data : convertUint8ArrayToBase64(file.data)}`;
+function isFullMediaType(mediaType) {
+  const slashIndex = mediaType.indexOf("/");
+  if (slashIndex === -1) {
+    return false;
+  }
+  const subtype = mediaType.substring(slashIndex + 1);
+  return subtype.length > 0 && subtype !== "*";
 }
 
-// src/convert-to-form-data.ts
-function convertToFormData(input, options = {}) {
-  const { useArrayBrackets = true } = options;
-  const formData = new FormData();
-  for (const [key, value] of Object.entries(input)) {
-    if (value == null) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      if (value.length === 1) {
-        formData.append(key, value[0]);
-        continue;
-      }
-      const arrayKey = useArrayBrackets ? `${key}[]` : key;
-      for (const item of value) {
-        formData.append(arrayKey, item);
-      }
-      continue;
-    }
-    formData.append(key, value);
+// src/cancel-response-body.ts
+async function cancelResponseBody(response) {
+  var _a2;
+  try {
+    await ((_a2 = response.body) == null ? void 0 : _a2.cancel());
+  } catch (e) {
   }
-  return formData;
 }
 
 // src/download-error.ts
-var import_provider = require("@ai-sdk/provider");
+import { AISDKError } from "@ai-sdk/provider";
 var name = "AI_DownloadError";
 var marker = `vercel.ai.error.${name}`;
 var symbol = Symbol.for(marker);
 var _a, _b;
-var DownloadError = class extends (_b = import_provider.AISDKError, _a = symbol, _b) {
+var DownloadError = class extends (_b = AISDKError, _a = symbol, _b) {
   constructor({
     url,
     statusCode,
@@ -320,63 +519,13 @@ var DownloadError = class extends (_b = import_provider.AISDKError, _a = symbol,
     this.statusText = statusText;
   }
   static isInstance(error) {
-    return import_provider.AISDKError.hasMarker(error, marker);
+    return AISDKError.hasMarker(error, marker);
   }
 };
 
-// src/read-response-with-size-limit.ts
-var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
-async function readResponseWithSizeLimit({
-  response,
-  url,
-  maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE
-}) {
-  const contentLength = response.headers.get("content-length");
-  if (contentLength != null) {
-    const length = parseInt(contentLength, 10);
-    if (!isNaN(length) && length > maxBytes) {
-      throw new DownloadError({
-        url,
-        message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
-      });
-    }
-  }
-  const body = response.body;
-  if (body == null) {
-    return new Uint8Array(0);
-  }
-  const reader = body.getReader();
-  const chunks = [];
-  let totalBytes = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      totalBytes += value.length;
-      if (totalBytes > maxBytes) {
-        throw new DownloadError({
-          url,
-          message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes.`
-        });
-      }
-      chunks.push(value);
-    }
-  } finally {
-    try {
-      await reader.cancel();
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  const result = new Uint8Array(totalBytes);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return result;
+// src/is-browser-runtime.ts
+function isBrowserRuntime(globalThisAny = globalThis) {
+  return globalThisAny.window != null;
 }
 
 // src/validate-download-url.ts
@@ -390,13 +539,16 @@ function validateDownloadUrl(url) {
       message: `Invalid URL: ${url}`
     });
   }
+  if (parsed.protocol === "data:") {
+    return;
+  }
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
     throw new DownloadError({
       url,
-      message: `URL scheme must be http or https, got ${parsed.protocol}`
+      message: `URL scheme must be http, https, or data, got ${parsed.protocol}`
     });
   }
-  const hostname = parsed.hostname;
+  const hostname = parsed.hostname.toLowerCase().replace(/\.+$/, "");
   if (!hostname) {
     throw new DownloadError({
       url,
@@ -439,54 +591,190 @@ function isIPv4(hostname) {
 }
 function isPrivateIPv4(ip) {
   const parts = ip.split(".").map(Number);
-  const [a, b] = parts;
+  const [a, b, c] = parts;
   if (a === 0) return true;
   if (a === 10) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
   if (a === 127) return true;
   if (a === 169 && b === 254) return true;
   if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
   if (a === 192 && b === 168) return true;
+  if (a === 198 && (b === 18 || b === 19)) return true;
+  if (a >= 240) return true;
   return false;
 }
-function isPrivateIPv6(ip) {
-  const normalized = ip.toLowerCase();
-  if (normalized === "::1") return true;
-  if (normalized === "::") return true;
-  if (normalized.startsWith("::ffff:")) {
-    const mappedPart = normalized.slice(7);
-    if (isIPv4(mappedPart)) {
-      return isPrivateIPv4(mappedPart);
-    }
-    const hexParts = mappedPart.split(":");
-    if (hexParts.length === 2) {
-      const high = parseInt(hexParts[0], 16);
-      const low = parseInt(hexParts[1], 16);
-      if (!isNaN(high) && !isNaN(low)) {
-        const a = high >> 8 & 255;
-        const b = high & 255;
-        const c = low >> 8 & 255;
-        const d = low & 255;
-        return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+function parseIPv6(ip) {
+  let address = ip.toLowerCase();
+  const zoneIndex = address.indexOf("%");
+  if (zoneIndex !== -1) {
+    address = address.slice(0, zoneIndex);
+  }
+  const halves = address.split("::");
+  if (halves.length > 2) return null;
+  const toGroups = (segment) => {
+    if (segment === "") return [];
+    const groups = [];
+    const parts = segment.split(":");
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (part.includes(".")) {
+        if (i !== parts.length - 1 || !isIPv4(part)) return null;
+        const [a, b, c, d] = part.split(".").map(Number);
+        groups.push(a << 8 | b, c << 8 | d);
+        continue;
       }
+      if (!/^[0-9a-f]{1,4}$/.test(part)) return null;
+      groups.push(parseInt(part, 16));
     }
+    return groups;
+  };
+  const head = toGroups(halves[0]);
+  if (head === null) return null;
+  if (halves.length === 2) {
+    const tail = toGroups(halves[1]);
+    if (tail === null) return null;
+    const fill = 8 - head.length - tail.length;
+    if (fill < 0) return null;
+    return [...head, ...new Array(fill).fill(0), ...tail];
+  }
+  return head.length === 8 ? head : null;
+}
+function isPrivateIPv6(ip) {
+  const groups = parseIPv6(ip);
+  if (groups === null) return true;
+  const topZero = (count) => groups.slice(0, count).every((group) => group === 0);
+  if (topZero(7) && (groups[7] === 0 || groups[7] === 1)) return true;
+  if ((groups[0] & 65024) === 64512) return true;
+  if ((groups[0] & 65472) === 65152) return true;
+  if ((groups[0] & 65472) === 65216) return true;
+  if ((groups[0] & 65280) === 65280) return true;
+  const embedsIPv4 = (
+    // ::/96 — IPv4-compatible (deprecated)
+    topZero(6) || // ::ffff:0:0/96 — IPv4-mapped (ffff in group 5)
+    topZero(5) && groups[5] === 65535 || // ::ffff:0:0/96 — IPv4-translated form (ffff in group 4, group 5 zero)
+    topZero(4) && groups[4] === 65535 && groups[5] === 0 || // 64:ff9b::/96 — NAT64 well-known prefix
+    groups[0] === 100 && groups[1] === 65435 && groups[2] === 0 && groups[3] === 0 && groups[4] === 0 && groups[5] === 0 || // 64:ff9b:1::/48 — NAT64 local-use prefix
+    groups[0] === 100 && groups[1] === 65435 && groups[2] === 1
+  );
+  if (embedsIPv4) {
+    const a = groups[6] >> 8 & 255;
+    const b = groups[6] & 255;
+    const c = groups[7] >> 8 & 255;
+    const d = groups[7] & 255;
+    return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
   }
-  if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
-  if (normalized.startsWith("fe80")) return true;
   return false;
 }
 
+// src/fetch-with-validated-redirects.ts
+var MAX_DOWNLOAD_REDIRECTS = 10;
+async function fetchWithValidatedRedirects({
+  url,
+  headers,
+  abortSignal,
+  maxRedirects = MAX_DOWNLOAD_REDIRECTS
+}) {
+  const baseInit = { signal: abortSignal };
+  if (headers !== void 0) {
+    baseInit.headers = headers;
+  }
+  let currentUrl = url;
+  for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount++) {
+    validateDownloadUrl(currentUrl);
+    const response = await fetch(currentUrl, {
+      ...baseInit,
+      redirect: "manual"
+    });
+    if (response.type === "opaqueredirect") {
+      if (!isBrowserRuntime()) {
+        throw new DownloadError({
+          url,
+          message: `Redirect from ${currentUrl} could not be validated and was blocked`
+        });
+      }
+      return await fetch(currentUrl, { ...baseInit, redirect: "follow" });
+    }
+    const location = response.headers.get("location");
+    if (response.status >= 300 && response.status < 400 && location) {
+      await cancelResponseBody(response);
+      currentUrl = new URL(location, currentUrl).toString();
+      continue;
+    }
+    return response;
+  }
+  throw new DownloadError({
+    url,
+    message: `Too many redirects (max ${maxRedirects})`
+  });
+}
+
+// src/read-response-with-size-limit.ts
+var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
+async function readResponseWithSizeLimit({
+  response,
+  url,
+  maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE
+}) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength != null) {
+    const length = parseInt(contentLength, 10);
+    if (!isNaN(length) && length > maxBytes) {
+      await cancelResponseBody(response);
+      throw new DownloadError({
+        url,
+        message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
+      });
+    }
+  }
+  const body = response.body;
+  if (body == null) {
+    return new Uint8Array(0);
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      totalBytes += value.length;
+      if (totalBytes > maxBytes) {
+        throw new DownloadError({
+          url,
+          message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes.`
+        });
+      }
+      chunks.push(value);
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  const result = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
 // src/download-blob.ts
 async function downloadBlob(url, options) {
   var _a2, _b2;
-  validateDownloadUrl(url);
   try {
-    const response = await fetch(url, {
-      signal: options == null ? void 0 : options.abortSignal
+    const response = await fetchWithValidatedRedirects({
+      url,
+      abortSignal: options == null ? void 0 : options.abortSignal
     });
-    if (response.redirected) {
-      validateDownloadUrl(response.url);
-    }
     if (!response.ok) {
+      await cancelResponseBody(response);
       throw new DownloadError({
         url,
         statusCode: response.status,
@@ -508,8 +796,32 @@ async function downloadBlob(url, options) {
   }
 }
 
+// src/extract-lines.ts
+function extractLines({
+  text,
+  startLine,
+  endLine
+}) {
+  if (startLine == null && endLine == null) return text;
+  const lineEnding = text.includes("\r\n") ? "\r\n" : text.includes("\n") ? "\n" : text.includes("\r") ? "\r" : "\n";
+  const lines = text.split(lineEnding);
+  const start = Math.max(1, startLine != null ? startLine : 1) - 1;
+  const end = Math.min(lines.length, endLine != null ? endLine : lines.length);
+  return lines.slice(start, end).join(lineEnding);
+}
+
+// src/extract-response-headers.ts
+function extractResponseHeaders(response) {
+  return Object.fromEntries([...response.headers]);
+}
+
+// src/filter-nullable.ts
+function filterNullable(...values) {
+  return values.filter((value) => value != null);
+}
+
 // src/generate-id.ts
-var import_provider2 = require("@ai-sdk/provider");
+import { InvalidArgumentError } from "@ai-sdk/provider";
 var createIdGenerator = ({
   prefix,
   size = 16,
@@ -528,7 +840,7 @@ var createIdGenerator = ({
     return generator;
   }
   if (alphabet.includes(separator)) {
-    throw new import_provider2.InvalidArgumentError({
+    throw new InvalidArgumentError({
       argument: "separator",
       message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
     });
@@ -538,24 +850,13 @@ var createIdGenerator = ({
 var generateId = createIdGenerator();
 
 // src/get-error-message.ts
-function getErrorMessage(error) {
-  if (error == null) {
-    return "unknown error";
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return JSON.stringify(error);
-}
+import { getErrorMessage } from "@ai-sdk/provider";
 
 // src/get-from-api.ts
-var import_provider4 = require("@ai-sdk/provider");
+import { APICallError as APICallError2 } from "@ai-sdk/provider";
 
 // src/handle-fetch-error.ts
-var import_provider3 = require("@ai-sdk/provider");
+import { APICallError } from "@ai-sdk/provider";
 
 // src/is-abort-error.ts
 function isAbortError(error) {
@@ -595,7 +896,7 @@ function handleFetchError({
   if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
     const cause = error.cause;
     if (cause != null) {
-      return new import_provider3.APICallError({
+      return new APICallError({
         message: `Cannot connect to API: ${cause.message}`,
         cause,
         url,
@@ -606,7 +907,7 @@ function handleFetchError({
     }
   }
   if (isBunNetworkError(error)) {
-    return new import_provider3.APICallError({
+    return new APICallError({
       message: `Cannot connect to API: ${error.message}`,
       cause: error,
       url,
@@ -670,7 +971,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
 }
 
 // src/version.ts
-var VERSION = true ? "5.0.0-beta.4" : "0.0.0-test";
+var VERSION = true ? "5.0.0-beta.49" : "0.0.0-test";
 
 // src/get-from-api.ts
 var getOriginalFetch = () => globalThis.fetch;
@@ -702,10 +1003,10 @@ var getFromApi = async ({
           requestBodyValues: {}
         });
       } catch (error) {
-        if (isAbortError(error) || import_provider4.APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError2.isInstance(error)) {
           throw error;
         }
-        throw new import_provider4.APICallError({
+        throw new APICallError2({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -724,11 +1025,11 @@ var getFromApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError(error) || import_provider4.APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError2.isInstance(error)) {
           throw error;
         }
       }
-      throw new import_provider4.APICallError({
+      throw new APICallError2({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -781,11 +1082,31 @@ function injectJsonInstructionIntoMessages({
   ];
 }
 
+// src/is-buffer.ts
+function isBuffer(value) {
+  var _a2, _b2;
+  return (_b2 = (_a2 = globalThis.Buffer) == null ? void 0 : _a2.isBuffer(value)) != null ? _b2 : false;
+}
+
+// src/is-same-origin.ts
+function isSameOrigin(url, baseUrl) {
+  try {
+    return new URL(url).origin === new URL(baseUrl).origin;
+  } catch (e) {
+    return false;
+  }
+}
+
 // src/is-non-nullable.ts
 function isNonNullable(value) {
   return value != null;
 }
 
+// src/is-provider-reference.ts
+function isProviderReference(data) {
+  return typeof data === "object" && data !== null && !(data instanceof Uint8Array) && !(data instanceof URL) && !(data instanceof ArrayBuffer) && !isBuffer(data) && !("type" in data);
+}
+
 // src/is-url-supported.ts
 function isUrlSupported({
   mediaType,
@@ -794,14 +1115,23 @@ function isUrlSupported({
 }) {
   url = url.toLowerCase();
   mediaType = mediaType.toLowerCase();
+  const isTopLevelOnly = !mediaType.includes("/");
   return Object.entries(supportedUrls).map(([key, value]) => {
     const mediaType2 = key.toLowerCase();
     return mediaType2 === "*" || mediaType2 === "*/*" ? { mediaTypePrefix: "", regexes: value } : { mediaTypePrefix: mediaType2.replace(/\*/, ""), regexes: value };
-  }).filter(({ mediaTypePrefix }) => mediaType.startsWith(mediaTypePrefix)).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url));
+  }).filter(({ mediaTypePrefix }) => {
+    if (mediaTypePrefix === "") {
+      return true;
+    }
+    if (isTopLevelOnly) {
+      return `${mediaType}/` === mediaTypePrefix;
+    }
+    return mediaType.startsWith(mediaTypePrefix);
+  }).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url));
 }
 
 // src/load-api-key.ts
-var import_provider5 = require("@ai-sdk/provider");
+import { LoadAPIKeyError } from "@ai-sdk/provider";
 function loadApiKey({
   apiKey,
   environmentVariableName,
@@ -812,23 +1142,23 @@ function loadApiKey({
     return apiKey;
   }
   if (apiKey != null) {
-    throw new import_provider5.LoadAPIKeyError({
+    throw new LoadAPIKeyError({
       message: `${description} API key must be a string.`
     });
   }
   if (typeof process === "undefined") {
-    throw new import_provider5.LoadAPIKeyError({
-      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
+    throw new LoadAPIKeyError({
+      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables are not supported in this environment.`
     });
   }
   apiKey = process.env[environmentVariableName];
   if (apiKey == null) {
-    throw new import_provider5.LoadAPIKeyError({
+    throw new LoadAPIKeyError({
       message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
     });
   }
   if (typeof apiKey !== "string") {
-    throw new import_provider5.LoadAPIKeyError({
+    throw new LoadAPIKeyError({
       message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
     });
   }
@@ -854,7 +1184,7 @@ function loadOptionalSetting({
 }
 
 // src/load-setting.ts
-var import_provider6 = require("@ai-sdk/provider");
+import { LoadSettingError } from "@ai-sdk/provider";
 function loadSetting({
   settingValue,
   environmentVariableName,
@@ -865,29 +1195,86 @@ function loadSetting({
     return settingValue;
   }
   if (settingValue != null) {
-    throw new import_provider6.LoadSettingError({
+    throw new LoadSettingError({
       message: `${description} setting must be a string.`
     });
   }
   if (typeof process === "undefined") {
-    throw new import_provider6.LoadSettingError({
-      message: `${description} setting is missing. Pass it using the '${settingName}' parameter. Environment variables is not supported in this environment.`
+    throw new LoadSettingError({
+      message: `${description} setting is missing. Pass it using the '${settingName}' parameter. Environment variables are not supported in this environment.`
     });
   }
   settingValue = process.env[environmentVariableName];
   if (settingValue == null) {
-    throw new import_provider6.LoadSettingError({
+    throw new LoadSettingError({
       message: `${description} setting is missing. Pass it using the '${settingName}' parameter or the ${environmentVariableName} environment variable.`
     });
   }
   if (typeof settingValue !== "string") {
-    throw new import_provider6.LoadSettingError({
+    throw new LoadSettingError({
       message: `${description} setting must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
     });
   }
   return settingValue;
 }
 
+// src/map-reasoning-to-provider.ts
+function isCustomReasoning(reasoning) {
+  return reasoning !== void 0 && reasoning !== "provider-default";
+}
+function mapReasoningToProviderEffort({
+  reasoning,
+  effortMap,
+  warnings
+}) {
+  const mapped = effortMap[reasoning];
+  if (mapped == null) {
+    warnings.push({
+      type: "unsupported",
+      feature: "reasoning",
+      details: `reasoning "${reasoning}" is not supported by this model.`
+    });
+    return void 0;
+  }
+  if (mapped !== reasoning) {
+    warnings.push({
+      type: "compatibility",
+      feature: "reasoning",
+      details: `reasoning "${reasoning}" is not directly supported by this model. mapped to effort "${mapped}".`
+    });
+  }
+  return mapped;
+}
+var DEFAULT_REASONING_BUDGET_PERCENTAGES = {
+  minimal: 0.02,
+  low: 0.1,
+  medium: 0.3,
+  high: 0.6,
+  xhigh: 0.9
+};
+function mapReasoningToProviderBudget({
+  reasoning,
+  maxOutputTokens,
+  maxReasoningBudget,
+  minReasoningBudget = 1024,
+  budgetPercentages = DEFAULT_REASONING_BUDGET_PERCENTAGES,
+  warnings
+}) {
+  const pct = budgetPercentages[reasoning];
+  if (pct == null) {
+    warnings.push({
+      type: "unsupported",
+      feature: "reasoning",
+      details: `reasoning "${reasoning}" is not supported by this model.`
+    });
+    return void 0;
+  }
+  return Math.min(
+    maxReasoningBudget,
+    Math.max(minReasoningBudget, Math.round(maxOutputTokens * pct))
+  );
+}
+
 // src/media-type-to-extension.ts
 function mediaTypeToExtension(mediaType) {
   var _a2;
@@ -902,7 +1289,10 @@ function mediaTypeToExtension(mediaType) {
 }
 
 // src/parse-json.ts
-var import_provider9 = require("@ai-sdk/provider");
+import {
+  JSONParseError,
+  TypeValidationError as TypeValidationError3
+} from "@ai-sdk/provider";
 
 // src/secure-json-parse.ts
 var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
@@ -954,11 +1344,13 @@ function secureJsonParse(text) {
 }
 
 // src/validate-types.ts
-var import_provider8 = require("@ai-sdk/provider");
+import {
+  TypeValidationError as TypeValidationError2
+} from "@ai-sdk/provider";
 
 // src/schema.ts
-var import_provider7 = require("@ai-sdk/provider");
-var z4 = __toESM(require("zod/v4"));
+import { TypeValidationError } from "@ai-sdk/provider";
+import * as z4 from "zod/v4";
 
 // src/add-additional-properties-to-json-schema.ts
 function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
@@ -1030,7 +1422,7 @@ var getDefaultOptions = (options) => typeof options === "string" ? {
 };
 
 // src/to-json-schema/zod3-to-json-schema/select-parser.ts
-var import_v33 = require("zod/v3");
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
 
 // src/to-json-schema/zod3-to-json-schema/parsers/any.ts
 function parseAnyDef() {
@@ -1038,13 +1430,13 @@ function parseAnyDef() {
 }
 
 // src/to-json-schema/zod3-to-json-schema/parsers/array.ts
-var import_v3 = require("zod/v3");
+import { ZodFirstPartyTypeKind } from "zod/v3";
 function parseArrayDef(def, refs) {
   var _a2, _b2, _c;
   const res = {
     type: "array"
   };
-  if (((_a2 = def.type) == null ? void 0 : _a2._def) && ((_c = (_b2 = def.type) == null ? void 0 : _b2._def) == null ? void 0 : _c.typeName) !== import_v3.ZodFirstPartyTypeKind.ZodAny) {
+  if (((_a2 = def.type) == null ? void 0 : _a2._def) && ((_c = (_b2 = def.type) == null ? void 0 : _b2._def) == null ? void 0 : _c.typeName) !== ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
@@ -1114,7 +1506,7 @@ function parseDateDef(def, refs, overrideDateStrategy) {
   const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
   if (Array.isArray(strategy)) {
     return {
-      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+      anyOf: strategy.map((item) => parseDateDef(def, refs, item))
     };
   }
   switch (strategy) {
@@ -1195,7 +1587,7 @@ function parseIntersectionDef(def, refs) {
     } else {
       let nestedSchema = schema;
       if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema;
+        const { additionalProperties: _additionalProperties, ...rest } = schema;
         nestedSchema = rest;
       }
       mergedAllOf.push(nestedSchema);
@@ -1219,7 +1611,9 @@ function parseLiteralDef(def) {
 }
 
 // src/to-json-schema/zod3-to-json-schema/parsers/record.ts
-var import_v32 = require("zod/v3");
+import {
+  ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2
+} from "zod/v3";
 
 // src/to-json-schema/zod3-to-json-schema/parsers/string.ts
 var emojiRegex = void 0;
@@ -1567,21 +1961,21 @@ function parseRecordDef(def, refs) {
       currentPath: [...refs.currentPath, "additionalProperties"]
     })) != null ? _a2 : refs.allowedAdditionalProperties
   };
-  if (((_b2 = def.keyType) == null ? void 0 : _b2._def.typeName) === import_v32.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
-    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+  if (((_b2 = def.keyType) == null ? void 0 : _b2._def.typeName) === ZodFirstPartyTypeKind2.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+    const { type: _type, ...keyType } = parseStringDef(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
     };
-  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v32.ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === ZodFirstPartyTypeKind2.ZodEnum) {
     return {
       ...schema,
       propertyNames: {
         enum: def.keyType._def.values
       }
     };
-  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === import_v32.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v32.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
-    const { type, ...keyType } = parseBrandedDef(
+  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+    const { type: _type, ...keyType } = parseBrandedDef(
       def.keyType._def,
       refs
     );
@@ -1858,16 +2252,18 @@ var parsePipelineDef = (def, refs) => {
   } else if (refs.pipeStrategy === "output") {
     return parseDef(def.out._def, refs);
   }
-  const a = parseDef(def.in._def, {
+  const inputSchema = parseDef(def.in._def, {
     ...refs,
     currentPath: [...refs.currentPath, "allOf", "0"]
   });
-  const b = parseDef(def.out._def, {
+  const outputSchema = parseDef(def.out._def, {
     ...refs,
-    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+    currentPath: [...refs.currentPath, "allOf", inputSchema ? "1" : "0"]
   });
   return {
-    allOf: [a, b].filter((x) => x !== void 0)
+    allOf: [inputSchema, outputSchema].filter(
+      (schema) => schema !== void 0
+    )
   };
 };
 
@@ -1954,73 +2350,73 @@ var parseReadonlyDef = (def, refs) => {
 // src/to-json-schema/zod3-to-json-schema/select-parser.ts
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case import_v33.ZodFirstPartyTypeKind.ZodString:
+    case ZodFirstPartyTypeKind3.ZodString:
       return parseStringDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodNumber:
+    case ZodFirstPartyTypeKind3.ZodNumber:
       return parseNumberDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodObject:
+    case ZodFirstPartyTypeKind3.ZodObject:
       return parseObjectDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodBigInt:
+    case ZodFirstPartyTypeKind3.ZodBigInt:
       return parseBigintDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodBoolean:
+    case ZodFirstPartyTypeKind3.ZodBoolean:
       return parseBooleanDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodDate:
+    case ZodFirstPartyTypeKind3.ZodDate:
       return parseDateDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodUndefined:
+    case ZodFirstPartyTypeKind3.ZodUndefined:
       return parseUndefinedDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodNull:
+    case ZodFirstPartyTypeKind3.ZodNull:
       return parseNullDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodArray:
+    case ZodFirstPartyTypeKind3.ZodArray:
       return parseArrayDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodUnion:
-    case import_v33.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case ZodFirstPartyTypeKind3.ZodUnion:
+    case ZodFirstPartyTypeKind3.ZodDiscriminatedUnion:
       return parseUnionDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodIntersection:
+    case ZodFirstPartyTypeKind3.ZodIntersection:
       return parseIntersectionDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodTuple:
+    case ZodFirstPartyTypeKind3.ZodTuple:
       return parseTupleDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodRecord:
+    case ZodFirstPartyTypeKind3.ZodRecord:
       return parseRecordDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodLiteral:
+    case ZodFirstPartyTypeKind3.ZodLiteral:
       return parseLiteralDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodEnum:
+    case ZodFirstPartyTypeKind3.ZodEnum:
       return parseEnumDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case ZodFirstPartyTypeKind3.ZodNativeEnum:
       return parseNativeEnumDef(def);
-    case import_v33.ZodFirstPartyTypeKind.ZodNullable:
+    case ZodFirstPartyTypeKind3.ZodNullable:
       return parseNullableDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodOptional:
+    case ZodFirstPartyTypeKind3.ZodOptional:
       return parseOptionalDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodMap:
+    case ZodFirstPartyTypeKind3.ZodMap:
       return parseMapDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodSet:
+    case ZodFirstPartyTypeKind3.ZodSet:
       return parseSetDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodLazy:
+    case ZodFirstPartyTypeKind3.ZodLazy:
       return () => def.getter()._def;
-    case import_v33.ZodFirstPartyTypeKind.ZodPromise:
+    case ZodFirstPartyTypeKind3.ZodPromise:
       return parsePromiseDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodNaN:
-    case import_v33.ZodFirstPartyTypeKind.ZodNever:
+    case ZodFirstPartyTypeKind3.ZodNaN:
+    case ZodFirstPartyTypeKind3.ZodNever:
       return parseNeverDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodEffects:
+    case ZodFirstPartyTypeKind3.ZodEffects:
       return parseEffectsDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodAny:
+    case ZodFirstPartyTypeKind3.ZodAny:
       return parseAnyDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodUnknown:
+    case ZodFirstPartyTypeKind3.ZodUnknown:
       return parseUnknownDef();
-    case import_v33.ZodFirstPartyTypeKind.ZodDefault:
+    case ZodFirstPartyTypeKind3.ZodDefault:
       return parseDefaultDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodBranded:
+    case ZodFirstPartyTypeKind3.ZodBranded:
       return parseBrandedDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodReadonly:
+    case ZodFirstPartyTypeKind3.ZodReadonly:
       return parseReadonlyDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodCatch:
+    case ZodFirstPartyTypeKind3.ZodCatch:
       return parseCatchDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodPipeline:
+    case ZodFirstPartyTypeKind3.ZodPipeline:
       return parsePipelineDef(def, refs);
-    case import_v33.ZodFirstPartyTypeKind.ZodFunction:
-    case import_v33.ZodFirstPartyTypeKind.ZodVoid:
-    case import_v33.ZodFirstPartyTypeKind.ZodSymbol:
+    case ZodFirstPartyTypeKind3.ZodFunction:
+    case ZodFirstPartyTypeKind3.ZodVoid:
+    case ZodFirstPartyTypeKind3.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)(typeName);
@@ -2205,7 +2601,11 @@ function isSchema(value) {
   return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
 }
 function asSchema(schema) {
-  return schema == null ? jsonSchema({ properties: {}, additionalProperties: false }) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
+  return schema == null ? jsonSchema({
+    type: "object",
+    properties: {},
+    additionalProperties: false
+  }) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
 }
 function standardSchema(standardSchema2) {
   return jsonSchema(
@@ -2219,7 +2619,7 @@ function standardSchema(standardSchema2) {
         const result = await standardSchema2["~standard"].validate(value);
         return "value" in result ? { success: true, value: result.value } : {
           success: false,
-          error: new import_provider7.TypeValidationError({
+          error: new TypeValidationError({
             value,
             cause: result.issues
           })
@@ -2283,7 +2683,7 @@ async function validateTypes({
 }) {
   const result = await safeValidateTypes({ value, schema, context });
   if (!result.success) {
-    throw import_provider8.TypeValidationError.wrap({ value, cause: result.error, context });
+    throw TypeValidationError2.wrap({ value, cause: result.error, context });
   }
   return result.value;
 }
@@ -2303,13 +2703,13 @@ async function safeValidateTypes({
     }
     return {
       success: false,
-      error: import_provider8.TypeValidationError.wrap({ value, cause: result.error, context }),
+      error: TypeValidationError2.wrap({ value, cause: result.error, context }),
       rawValue: value
     };
   } catch (error) {
     return {
       success: false,
-      error: import_provider8.TypeValidationError.wrap({ value, cause: error, context }),
+      error: TypeValidationError2.wrap({ value, cause: error, context }),
       rawValue: value
     };
   }
@@ -2325,12 +2725,12 @@ async function parseJSON({
     if (schema == null) {
       return value;
     }
-    return validateTypes({ value, schema });
+    return await validateTypes({ value, schema });
   } catch (error) {
-    if (import_provider9.JSONParseError.isInstance(error) || import_provider9.TypeValidationError.isInstance(error)) {
+    if (JSONParseError.isInstance(error) || TypeValidationError3.isInstance(error)) {
       throw error;
     }
-    throw new import_provider9.JSONParseError({ text, cause: error });
+    throw new JSONParseError({ text, cause: error });
   }
 }
 async function safeParseJSON({
@@ -2346,7 +2746,7 @@ async function safeParseJSON({
   } catch (error) {
     return {
       success: false,
-      error: import_provider9.JSONParseError.isInstance(error) ? error : new import_provider9.JSONParseError({ text, cause: error }),
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error }),
       rawValue: void 0
     };
   }
@@ -2361,12 +2761,14 @@ function isParsableJson(input) {
 }
 
 // src/parse-json-event-stream.ts
-var import_stream = require("eventsource-parser/stream");
+import {
+  EventSourceParserStream
+} from "eventsource-parser/stream";
 function parseJsonEventStream({
   stream,
   schema
 }) {
-  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new import_stream.EventSourceParserStream()).pipeThrough(
+  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
     new TransformStream({
       async transform({ data }, controller) {
         if (data === "[DONE]") {
@@ -2379,7 +2781,7 @@ function parseJsonEventStream({
 }
 
 // src/parse-provider-options.ts
-var import_provider10 = require("@ai-sdk/provider");
+import { InvalidArgumentError as InvalidArgumentError2 } from "@ai-sdk/provider";
 async function parseProviderOptions({
   provider,
   providerOptions,
@@ -2393,7 +2795,7 @@ async function parseProviderOptions({
     schema
   });
   if (!parsedProviderOptions.success) {
-    throw new import_provider10.InvalidArgumentError({
+    throw new InvalidArgumentError2({
       argument: "providerOptions",
       message: `invalid ${provider} provider options`,
       cause: parsedProviderOptions.error
@@ -2403,7 +2805,7 @@ async function parseProviderOptions({
 }
 
 // src/post-to-api.ts
-var import_provider11 = require("@ai-sdk/provider");
+import { APICallError as APICallError3 } from "@ai-sdk/provider";
 var getOriginalFetch2 = () => globalThis.fetch;
 var postJsonToApi = async ({
   url,
@@ -2413,7 +2815,7 @@ var postJsonToApi = async ({
   successfulResponseHandler,
   abortSignal,
   fetch: fetch2
-}) => postToApi({
+}) => await postToApi({
   url,
   headers: {
     "Content-Type": "application/json",
@@ -2436,7 +2838,7 @@ var postFormDataToApi = async ({
   successfulResponseHandler,
   abortSignal,
   fetch: fetch2
-}) => postToApi({
+}) => await postToApi({
   url,
   headers,
   body: {
@@ -2478,10 +2880,10 @@ var postToApi = async ({
           requestBodyValues: body.values
         });
       } catch (error) {
-        if (isAbortError(error) || import_provider11.APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError3.isInstance(error)) {
           throw error;
         }
-        throw new import_provider11.APICallError({
+        throw new APICallError3({
           message: "Failed to process error response",
           cause: error,
           statusCode: response.status,
@@ -2500,11 +2902,11 @@ var postToApi = async ({
       });
     } catch (error) {
       if (error instanceof Error) {
-        if (isAbortError(error) || import_provider11.APICallError.isInstance(error)) {
+        if (isAbortError(error) || APICallError3.isInstance(error)) {
           throw error;
         }
       }
-      throw new import_provider11.APICallError({
+      throw new APICallError3({
         message: "Failed to process successful response",
         cause: error,
         statusCode: response.status,
@@ -2526,8 +2928,8 @@ function dynamicTool(tool2) {
   return { ...tool2, type: "dynamic" };
 }
 
-// src/provider-tool-factory.ts
-function createProviderToolFactory({
+// src/provider-defined-tool-factory.ts
+function createProviderDefinedToolFactory({
   id,
   inputSchema
 }) {
@@ -2542,6 +2944,7 @@ function createProviderToolFactory({
     ...args
   }) => tool({
     type: "provider",
+    isProviderExecuted: false,
     id,
     args,
     inputSchema,
@@ -2554,11 +2957,10 @@ function createProviderToolFactory({
     onInputAvailable
   });
 }
-function createProviderToolFactoryWithOutputSchema({
+function createProviderDefinedToolFactoryWithOutputSchema({
   id,
   inputSchema,
-  outputSchema,
-  supportsDeferredResults
+  outputSchema
 }) {
   return ({
     execute,
@@ -2570,6 +2972,7 @@ function createProviderToolFactoryWithOutputSchema({
     ...args
   }) => tool({
     type: "provider",
+    isProviderExecuted: false,
     id,
     args,
     inputSchema,
@@ -2579,6 +2982,31 @@ function createProviderToolFactoryWithOutputSchema({
     toModelOutput,
     onInputStart,
     onInputDelta,
+    onInputAvailable
+  });
+}
+
+// src/provider-executed-tool-factory.ts
+function createProviderExecutedToolFactory({
+  id,
+  inputSchema,
+  outputSchema,
+  supportsDeferredResults
+}) {
+  return ({
+    onInputStart,
+    onInputDelta,
+    onInputAvailable,
+    ...args
+  }) => tool({
+    type: "provider",
+    isProviderExecuted: true,
+    id,
+    args,
+    inputSchema,
+    outputSchema,
+    onInputStart,
+    onInputDelta,
     onInputAvailable,
     supportsDeferredResults
   });
@@ -2599,8 +3027,53 @@ async function resolve(value) {
   return Promise.resolve(value);
 }
 
+// src/resolve-full-media-type.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+function resolveFullMediaType({
+  part
+}) {
+  if (isFullMediaType(part.mediaType)) {
+    return part.mediaType;
+  }
+  if (part.data.type === "data") {
+    const detected = detectMediaType({
+      data: part.data.data,
+      topLevelType: getTopLevelMediaType(part.mediaType)
+    });
+    if (detected) {
+      return detected;
+    }
+    throw new UnsupportedFunctionalityError({
+      functionality: `file of media type "${part.mediaType}" must specify subtype since it could not be auto-detected`
+    });
+  }
+  throw new UnsupportedFunctionalityError({
+    functionality: `file of media type "${part.mediaType}" must specify subtype since it is not passed as inline bytes`
+  });
+}
+
+// src/resolve-provider-reference.ts
+import {
+  NoSuchProviderReferenceError
+} from "@ai-sdk/provider";
+function resolveProviderReference({
+  reference,
+  provider
+}) {
+  const id = reference[provider];
+  if (id != null) {
+    return id;
+  }
+  throw new NoSuchProviderReferenceError({
+    provider,
+    reference
+  });
+}
+
 // src/response-handler.ts
-var import_provider12 = require("@ai-sdk/provider");
+import { APICallError as APICallError4, EmptyResponseBodyError } from "@ai-sdk/provider";
 var createJsonErrorResponseHandler = ({
   errorSchema,
   errorToMessage,
@@ -2611,7 +3084,7 @@ var createJsonErrorResponseHandler = ({
   if (responseBody.trim() === "") {
     return {
       responseHeaders,
-      value: new import_provider12.APICallError({
+      value: new APICallError4({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -2629,7 +3102,7 @@ var createJsonErrorResponseHandler = ({
     });
     return {
       responseHeaders,
-      value: new import_provider12.APICallError({
+      value: new APICallError4({
         message: errorToMessage(parsedError),
         url,
         requestBodyValues,
@@ -2640,10 +3113,10 @@ var createJsonErrorResponseHandler = ({
         isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
       })
     };
-  } catch (parseError) {
+  } catch (e) {
     return {
       responseHeaders,
-      value: new import_provider12.APICallError({
+      value: new APICallError4({
         message: response.statusText,
         url,
         requestBodyValues,
@@ -2658,7 +3131,7 @@ var createJsonErrorResponseHandler = ({
 var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
-    throw new import_provider12.EmptyResponseBodyError({});
+    throw new EmptyResponseBodyError({});
   }
   return {
     responseHeaders,
@@ -2676,7 +3149,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
   });
   const responseHeaders = extractResponseHeaders(response);
   if (!parsedResult.success) {
-    throw new import_provider12.APICallError({
+    throw new APICallError4({
       message: "Invalid JSON response",
       cause: parsedResult.error,
       statusCode: response.status,
@@ -2695,7 +3168,7 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
 var createBinaryResponseHandler = () => async ({ response, url, requestBodyValues }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (!response.body) {
-    throw new import_provider12.APICallError({
+    throw new APICallError4({
       message: "Response body is empty",
       url,
       requestBodyValues,
@@ -2711,7 +3184,7 @@ var createBinaryResponseHandler = () => async ({ response, url, requestBodyValue
       value: new Uint8Array(buffer)
     };
   } catch (error) {
-    throw new import_provider12.APICallError({
+    throw new APICallError4({
       message: "Failed to read response as array buffer",
       url,
       requestBodyValues,
@@ -2727,7 +3200,7 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   const responseBody = await response.text();
   return {
     responseHeaders,
-    value: new import_provider12.APICallError({
+    value: new APICallError4({
       message: response.statusText,
       url,
       requestBodyValues,
@@ -2738,6 +3211,185 @@ var createStatusCodeErrorResponseHandler = () => async ({ response, url, request
   };
 };
 
+// src/is-json-serializable.ts
+function isJSONSerializable(value) {
+  if (value === null || value === void 0) return true;
+  const type = typeof value;
+  if (type === "string" || type === "number" || type === "boolean") return true;
+  if (type === "function" || type === "symbol" || type === "bigint")
+    return false;
+  if (Array.isArray(value)) {
+    return value.every(isJSONSerializable);
+  }
+  if (Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.values(value).every(
+      isJSONSerializable
+    );
+  }
+  return false;
+}
+
+// src/serialize-model-options.ts
+function serializeModelOptions(options) {
+  const serializableConfig = {};
+  for (const [key, value] of Object.entries(options.config)) {
+    if (key === "headers") {
+      const resolvedHeaders = resolveSync(value);
+      if (isJSONSerializable(resolvedHeaders)) {
+        serializableConfig[key] = resolvedHeaders;
+      }
+    } else if (isJSONSerializable(value)) {
+      serializableConfig[key] = value;
+    }
+  }
+  return { modelId: options.modelId, config: serializableConfig };
+}
+function resolveSync(value) {
+  let next = value;
+  if (typeof value === "function") {
+    next = value();
+  }
+  if (next instanceof Promise) {
+    throw new Error("Promise returned from resolveSync");
+  }
+  return next;
+}
+
+// src/streaming-tool-call-tracker.ts
+import {
+  InvalidResponseDataError
+} from "@ai-sdk/provider";
+var StreamingToolCallTracker = class {
+  constructor(controller, options = {}) {
+    this.toolCalls = [];
+    var _a2, _b2;
+    this.controller = controller;
+    this._generateId = (_a2 = options.generateId) != null ? _a2 : generateId;
+    this.typeValidation = (_b2 = options.typeValidation) != null ? _b2 : "none";
+    this.extractMetadata = options.extractMetadata;
+    this.buildToolCallProviderMetadata = options.buildToolCallProviderMetadata;
+  }
+  /**
+   * Process a tool call delta from a streaming response chunk.
+   * Emits tool-input-start, tool-input-delta, tool-input-end, and tool-call
+   * events as appropriate.
+   */
+  processDelta(toolCallDelta) {
+    var _a2;
+    const index = (_a2 = toolCallDelta.index) != null ? _a2 : this.toolCalls.length;
+    if (this.toolCalls[index] == null) {
+      this.processNewToolCall(index, toolCallDelta);
+    } else {
+      this.processExistingToolCall(index, toolCallDelta);
+    }
+  }
+  /**
+   * Finalize any unfinished tool calls. Should be called during the stream's
+   * flush handler to ensure all tool calls are properly completed.
+   */
+  flush() {
+    for (const toolCall of this.toolCalls) {
+      if (!toolCall.hasFinished) {
+        this.finishToolCall(toolCall);
+      }
+    }
+  }
+  processNewToolCall(index, toolCallDelta) {
+    var _a2, _b2, _c;
+    if (this.typeValidation === "required") {
+      if (toolCallDelta.type !== "function") {
+        throw new InvalidResponseDataError({
+          data: toolCallDelta,
+          message: `Expected 'function' type.`
+        });
+      }
+    } else if (this.typeValidation === "if-present") {
+      if (toolCallDelta.type != null && toolCallDelta.type !== "function") {
+        throw new InvalidResponseDataError({
+          data: toolCallDelta,
+          message: `Expected 'function' type.`
+        });
+      }
+    }
+    if (toolCallDelta.id == null) {
+      throw new InvalidResponseDataError({
+        data: toolCallDelta,
+        message: `Expected 'id' to be a string.`
+      });
+    }
+    if (((_a2 = toolCallDelta.function) == null ? void 0 : _a2.name) == null) {
+      throw new InvalidResponseDataError({
+        data: toolCallDelta,
+        message: `Expected 'function.name' to be a string.`
+      });
+    }
+    this.controller.enqueue({
+      type: "tool-input-start",
+      id: toolCallDelta.id,
+      toolName: toolCallDelta.function.name
+    });
+    const metadata = (_b2 = this.extractMetadata) == null ? void 0 : _b2.call(this, toolCallDelta);
+    this.toolCalls[index] = {
+      id: toolCallDelta.id,
+      type: "function",
+      function: {
+        name: toolCallDelta.function.name,
+        arguments: (_c = toolCallDelta.function.arguments) != null ? _c : ""
+      },
+      hasFinished: false,
+      metadata
+    };
+    const toolCall = this.toolCalls[index];
+    if (toolCall.function.arguments.length > 0) {
+      this.controller.enqueue({
+        type: "tool-input-delta",
+        id: toolCall.id,
+        delta: toolCall.function.arguments
+      });
+    }
+    if (isParsableJson(toolCall.function.arguments)) {
+      this.finishToolCall(toolCall);
+    }
+  }
+  processExistingToolCall(index, toolCallDelta) {
+    var _a2;
+    const toolCall = this.toolCalls[index];
+    if (toolCall.hasFinished) {
+      return;
+    }
+    if (((_a2 = toolCallDelta.function) == null ? void 0 : _a2.arguments) != null) {
+      toolCall.function.arguments += toolCallDelta.function.arguments;
+      this.controller.enqueue({
+        type: "tool-input-delta",
+        id: toolCall.id,
+        delta: toolCallDelta.function.arguments
+      });
+    }
+    if (isParsableJson(toolCall.function.arguments)) {
+      this.finishToolCall(toolCall);
+    }
+  }
+  finishToolCall(toolCall) {
+    var _a2, _b2;
+    this.controller.enqueue({
+      type: "tool-input-end",
+      id: toolCall.id
+    });
+    const providerMetadata = (_a2 = this.buildToolCallProviderMetadata) == null ? void 0 : _a2.call(
+      this,
+      toolCall.metadata
+    );
+    this.controller.enqueue({
+      type: "tool-call",
+      toolCallId: (_b2 = toolCall.id) != null ? _b2 : this._generateId(),
+      toolName: toolCall.function.name,
+      input: toolCall.function.arguments,
+      ...providerMetadata ? { providerMetadata } : {}
+    });
+    toolCall.hasFinished = true;
+  }
+};
+
 // src/strip-file-extension.ts
 function stripFileExtension(filename) {
   const firstDotIndex = filename.indexOf(".");
@@ -2749,6 +3401,11 @@ function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
 
+// src/types/executable-tool.ts
+function isExecutableTool(tool2) {
+  return tool2 != null && typeof tool2.execute === "function";
+}
+
 // src/is-async-iterable.ts
 function isAsyncIterable(obj) {
   return obj != null && typeof obj[Symbol.asyncIterator] === "function";
@@ -2756,11 +3413,11 @@ function isAsyncIterable(obj) {
 
 // src/types/execute-tool.ts
 async function* executeTool({
-  execute,
+  tool: tool2,
   input,
   options
 }) {
-  const result = execute(input, options);
+  const result = tool2.execute(input, options);
   if (isAsyncIterable(result)) {
     let lastOutput;
     for await (const output of result) {
@@ -2774,19 +3431,27 @@ async function* executeTool({
 }
 
 // src/index.ts
-var import_stream2 = require("eventsource-parser/stream");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
+import {
+  EventSourceParserStream as EventSourceParserStream2
+} from "eventsource-parser/stream";
+export {
   DEFAULT_MAX_DOWNLOAD_SIZE,
   DelayedPromise,
   DownloadError,
-  EventSourceParserStream,
+  EventSourceParserStream2 as EventSourceParserStream,
+  StreamingToolCallTracker,
   VERSION,
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
+  asArray,
   asSchema,
+  cancelResponseBody,
   combineHeaders,
   convertAsyncIteratorToReadableStream,
   convertBase64ToUint8Array,
   convertImageModelFileToDataUri,
+  convertInlineFileDataToUint8Array,
   convertToBase64,
   convertToFormData,
   convertUint8ArrayToBase64,
@@ -2795,29 +3460,44 @@ var import_stream2 = require("eventsource-parser/stream");
   createIdGenerator,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
-  createProviderToolFactory,
-  createProviderToolFactoryWithOutputSchema,
+  createProviderDefinedToolFactory,
+  createProviderDefinedToolFactoryWithOutputSchema,
+  createProviderExecutedToolFactory,
   createStatusCodeErrorResponseHandler,
   createToolNameMapping,
   delay,
+  detectMediaType,
   downloadBlob,
   dynamicTool,
   executeTool,
+  extractLines,
   extractResponseHeaders,
+  fetchWithValidatedRedirects,
+  filterNullable,
   generateId,
   getErrorMessage,
   getFromApi,
   getRuntimeEnvironmentUserAgent,
+  getTopLevelMediaType,
   injectJsonInstructionIntoMessages,
   isAbortError,
+  isBrowserRuntime,
+  isBuffer,
+  isCustomReasoning,
+  isExecutableTool,
+  isFullMediaType,
   isNonNullable,
   isParsableJson,
+  isProviderReference,
+  isSameOrigin,
   isUrlSupported,
   jsonSchema,
   lazySchema,
   loadApiKey,
   loadOptionalSetting,
   loadSetting,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
   mediaTypeToExtension,
   normalizeHeaders,
   parseJSON,
@@ -2829,8 +3509,11 @@ var import_stream2 = require("eventsource-parser/stream");
   readResponseWithSizeLimit,
   removeUndefinedEntries,
   resolve,
+  resolveFullMediaType,
+  resolveProviderReference,
   safeParseJSON,
   safeValidateTypes,
+  serializeModelOptions,
   stripFileExtension,
   tool,
   validateDownloadUrl,
@@ -2838,5 +3521,5 @@ var import_stream2 = require("eventsource-parser/stream");
   withUserAgentSuffix,
   withoutTrailingSlash,
   zodSchema
-});
+};
 //# sourceMappingURL=index.js.map