@agentdocumentformat/cli 0.7.8 → 0.8.0

package/dist/chunks/{chunk-LFMB4PAA.mjs → chunk-TKXIH27X.mjs}

@@ -4,6 +4,10 @@ import { dirname as __adfDirname } from 'node:path';
 const require = __adfCreateRequire(import.meta.url);
 const __filename = __adfFileURLToPath(import.meta.url);
 const __dirname = __adfDirname(__filename);
+import {
+  fileRefKind,
+  isFileRefBlock
+} from "./chunk-LKFHERRV.mjs";
 import {
   ZodFirstPartyTypeKind
 } from "./chunk-RIX34QHC.mjs";
@@ -11,6 +15,48 @@ import {
   __export
 } from "./chunk-M2RX3S2T.mjs";
 
+// src/main/providers/media-capabilities.ts
+var MEDIA_KINDS = ["image", "audio", "video"], ALL_MEDIA = Object.freeze({ image: !0, audio: !0, video: !0 }), IMAGE_ONLY_MEDIA = Object.freeze({ image: !0, audio: !1, video: !1 });
+function connectorMedia(provider) {
+  return provider?.media ?? ALL_MEDIA;
+}
+function mediaToggle(model, kind) {
+  return kind === "image" ? model?.multimodal?.image ?? model?.vision ?? !1 : model?.multimodal?.[kind] ?? !1;
+}
+function effectiveMediaSupport(model, provider) {
+  let carried = connectorMedia(provider);
+  return {
+    image: carried.image && mediaToggle(model, "image"),
+    audio: carried.audio && mediaToggle(model, "audio"),
+    video: carried.video && mediaToggle(model, "video")
+  };
+}
+function mediaKindOf(block) {
+  if (block.type === "image_url") return "image";
+  if (block.type === "input_audio") return "audio";
+  if (block.type === "video_url") return "video";
+  if (isFileRefBlock(block) && !block.file_ref.deleted) return fileRefKind(block.file_ref);
+}
+function mediaOmissionReason(kind, model, provider) {
+  return connectorMedia(provider)[kind] ? `${kind} input is off in this agent's model settings` : `${provider?.name || "This provider"} does not accept ${kind} input`;
+}
+function mediaRefusals(model, provider) {
+  let support = effectiveMediaSupport(model, provider), refusals = {};
+  for (let kind of MEDIA_KINDS) support[kind] || (refusals[kind] = mediaOmissionReason(kind, model, provider));
+  return refusals;
+}
+function unsupportedMediaInput(content, model, provider) {
+  if (!content?.length) return null;
+  let refusals = mediaRefusals(model, provider), refused = /* @__PURE__ */ new Set();
+  for (let block of content) {
+    let kind = mediaKindOf(block);
+    kind && refusals[kind] && refused.add(kind);
+  }
+  if (refused.size === 0) return null;
+  let reasons = MEDIA_KINDS.filter((kind) => refused.has(kind)).map((kind) => refusals[kind]), first = reasons[0];
+  return `${[first[0].toUpperCase() + first.slice(1), ...reasons.slice(1)].join("; ")}. Remove the attachment, or change the model settings.`;
+}
+
 // node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error", symbol = Symbol.for(marker), _a, _b, AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
   /**
@@ -217,6 +263,16 @@ Error message: ${getErrorMessage(cause)}`,
     return AISDKError.hasMarker(error40, marker14);
   }
 };
+function isJSONValue(value) {
+  return value === null || typeof value == "string" || typeof value == "number" || typeof value == "boolean" ? !0 : Array.isArray(value) ? value.every(isJSONValue) : typeof value == "object" ? Object.entries(value).every(
+    ([key, val]) => typeof key == "string" && (val === void 0 || isJSONValue(val))
+  ) : !1;
+}
+function isJSONObject(value) {
+  return value != null && typeof value == "object" && Object.entries(value).every(
+    ([key, val]) => typeof key == "string" && (val === void 0 || isJSONValue(val))
+  );
+}
 
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -8845,49 +8901,129 @@ var ParseError = class extends Error {
   constructor(message, options) {
     super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
   }
-};
+}, LF = 10, CR = 13, SPACE = 32;
 function noop(_arg) {
 }
-function createParser(callbacks) {
-  if (typeof callbacks == "function")
+function createParser(config2) {
+  if (typeof config2 == "function")
     throw new TypeError(
-      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+      "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
     );
-  let { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks, incompleteLine = "", isFirstChunk = !0, id, data = "", eventType = "";
-  function feed(newChunk) {
-    let chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
-    for (let line of complete)
-      parseLine(line);
-    incompleteLine = incomplete, isFirstChunk = !1;
-  }
-  function parseLine(line) {
-    if (line === "") {
+  let { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config2, pendingFragments = [], pendingFragmentsLength = 0, isFirstChunk = !0, id, data = "", dataLines = 0, eventType, terminated = !1;
+  function feed(chunk) {
+    if (terminated)
+      throw new Error(
+        "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
+      );
+    if (isFirstChunk && (isFirstChunk = !1, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      let trailing2 = processLines(chunk);
+      trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    let input = pendingFragments.join("");
+    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    let trailing = processLines(input);
+    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+  }
+  function checkBufferSize() {
+    maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = !0, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(
+      new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+        type: "max-buffer-size-exceeded"
+      })
+    )));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        let firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          let valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      let crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex), lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
       dispatchEvent();
       return;
     }
-    if (line.startsWith(":")) {
-      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+    let firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      let valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
       return;
     }
-    let fieldSeparatorIndex = line.indexOf(":");
-    if (fieldSeparatorIndex !== -1) {
-      let field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
-      processField(field, value, line);
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      let value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      value2.includes("\0") || (id = value2);
       return;
     }
-    processField(line, "", line);
+    if (firstCharCode === 58) {
+      if (onComment) {
+        let line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    let line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    let field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
   }
   function processField(field, value, line) {
     switch (field) {
       case "event":
-        eventType = value;
+        eventType = value || void 0;
         break;
       case "data":
-        data = `${data}${value}
-`;
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
         break;
       case "id":
-        id = value.includes("\0") ? void 0 : value;
+        value.includes("\0") || (id = value);
         break;
       case "retry":
         /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
@@ -8909,40 +9045,31 @@ function createParser(callbacks) {
     }
   }
   function dispatchEvent() {
-    data.length > 0 && onEvent({
+    dataLines > 0 && onEvent({
       id,
-      event: eventType || void 0,
-      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
-      // then remove the last character from the data buffer.
-      data: data.endsWith(`
-`) ? data.slice(0, -1) : data
-    }), id = void 0, data = "", eventType = "";
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
   }
   function reset(options = {}) {
-    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = !0, id = void 0, data = "", eventType = "", incompleteLine = "";
+    if (options.consume && pendingFragments.length > 0) {
+      let incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = !0, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = !1;
   }
   return { feed, reset };
 }
-function splitLines(chunk) {
-  let lines = [], incompleteLine = "", searchIndex = 0;
-  for (; searchIndex < chunk.length; ) {
-    let crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
-`, searchIndex), lineEnd = -1;
-    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
-      incompleteLine = chunk.slice(searchIndex);
-      break;
-    } else {
-      let line = chunk.slice(searchIndex, lineEnd);
-      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
-` && searchIndex++;
-    }
-  }
-  return [lines, incompleteLine];
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
 }
 
 // node_modules/eventsource-parser/dist/stream.js
 var EventSourceParserStream = class extends TransformStream {
-  constructor({ onError, onRetry, onComment } = {}) {
+  constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
     let parser;
     super({
       start(controller) {
@@ -8951,10 +9078,11 @@ var EventSourceParserStream = class extends TransformStream {
             controller.enqueue(event);
           },
           onError(error40) {
-            onError === "terminate" ? controller.error(error40) : typeof onError == "function" && onError(error40);
+            typeof onError == "function" && onError(error40), (onError === "terminate" || error40.type === "max-buffer-size-exceeded") && controller.error(error40);
           },
           onRetry,
-          onComment
+          onComment,
+          maxBufferSize
         });
       },
       transform(chunk) {
@@ -8969,35 +9097,39 @@ function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => ({
       ...combinedHeaders,
-      ...currentHeaders ?? {}
+      ...currentHeaders
     }),
     {}
   );
 }
 function createToolNameMapping({
   tools = [],
-  providerToolNames
+  providerToolNames,
+  resolveProviderToolName
 }) {
+  var _a22;
   let customToolNameToProviderToolName = {}, providerToolNameToCustomToolName = {};
   for (let tool2 of tools)
-    if (tool2.type === "provider" && tool2.id in providerToolNames) {
-      let providerToolName = providerToolNames[tool2.id];
+    if (tool2.type === "provider") {
+      let providerToolName = (_a22 = resolveProviderToolName?.(tool2)) != null ? _a22 : tool2.id in providerToolNames ? providerToolNames[tool2.id] : void 0;
+      if (providerToolName == null)
+        continue;
       customToolNameToProviderToolName[tool2.name] = providerToolName, providerToolNameToCustomToolName[providerToolName] = tool2.name;
     }
   return {
     toProviderToolName: (customToolName) => {
-      var _a22;
-      return (_a22 = customToolNameToProviderToolName[customToolName]) != null ? _a22 : customToolName;
+      var _a32;
+      return (_a32 = customToolNameToProviderToolName[customToolName]) != null ? _a32 : customToolName;
     },
     toCustomToolName: (providerToolName) => {
-      var _a22;
-      return (_a22 = providerToolNameToCustomToolName[providerToolName]) != null ? _a22 : providerToolName;
+      var _a32;
+      return (_a32 = providerToolNameToCustomToolName[providerToolName]) != null ? _a32 : providerToolName;
     }
   };
 }
 async function delay(delayInMs, options) {
   if (delayInMs == null)
-    return Promise.resolve();
+    return;
   let signal = options?.abortSignal;
   return new Promise((resolve2, reject) => {
     if (signal?.aborted) {
@@ -9053,10 +9185,10 @@ function convertBase64ToUint8Array(base64String) {
   return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
 }
 function convertUint8ArrayToBase64(array2) {
-  let latin1string = "";
-  for (let i = 0; i < array2.length; i++)
-    latin1string += String.fromCodePoint(array2[i]);
-  return btoa(latin1string);
+  let chunks = [];
+  for (let i = 0; i < array2.length; i += 4096)
+    chunks.push(String.fromCodePoint(...array2.subarray(i, i + 4096)));
+  return btoa(chunks.join(""));
 }
 function convertToBase64(value) {
   return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
@@ -9079,6 +9211,13 @@ function convertToFormData(input, options = {}) {
     }
   return formData;
 }
+async function cancelResponseBody(response) {
+  var _a22;
+  try {
+    await ((_a22 = response.body) == null ? void 0 : _a22.cancel());
+  } catch {
+  }
+}
 var name14 = "AI_DownloadError", marker15 = `vercel.ai.error.${name14}`, symbol16 = Symbol.for(marker15), _a15, _b15, DownloadError = class extends (_b15 = AISDKError, _a15 = symbol16, _b15) {
   constructor({
     url: url2,
@@ -9093,20 +9232,315 @@ var name14 = "AI_DownloadError", marker15 = `vercel.ai.error.${name14}`, symbol1
     return AISDKError.hasMarker(error40, marker15);
   }
 };
-async function downloadBlob(url2) {
+function isBrowserRuntime(globalThisAny = globalThis) {
+  return globalThisAny.window != null;
+}
+function isSameOrigin(url2, baseUrl) {
   try {
-    let response = await fetch(url2);
-    if (!response.ok)
+    return new URL(url2).origin === new URL(baseUrl).origin;
+  } catch {
+    return !1;
+  }
+}
+function validateDownloadUrl(url2) {
+  let parsed;
+  try {
+    parsed = new URL(url2);
+  } catch {
+    throw new DownloadError({
+      url: url2,
+      message: `Invalid URL: ${url2}`
+    });
+  }
+  if (parsed.protocol === "data:")
+    return;
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+    throw new DownloadError({
+      url: url2,
+      message: `URL scheme must be http, https, or data, got ${parsed.protocol}`
+    });
+  let hostname2 = parsed.hostname.toLowerCase().replace(/\.+$/, "");
+  if (!hostname2)
+    throw new DownloadError({
+      url: url2,
+      message: "URL must have a hostname"
+    });
+  if (hostname2 === "localhost" || hostname2.endsWith(".local") || hostname2.endsWith(".localhost"))
+    throw new DownloadError({
+      url: url2,
+      message: `URL with hostname ${hostname2} is not allowed`
+    });
+  if (hostname2.startsWith("[") && hostname2.endsWith("]")) {
+    let ipv63 = hostname2.slice(1, -1);
+    if (isPrivateIPv6(ipv63))
       throw new DownloadError({
+        url: url2,
+        message: `URL with IPv6 address ${hostname2} is not allowed`
+      });
+    return;
+  }
+  if (isIPv4(hostname2) && isPrivateIPv4(hostname2))
+    throw new DownloadError({
+      url: url2,
+      message: `URL with IP address ${hostname2} is not allowed`
+    });
+}
+function validateDownloadAddress({
+  address,
+  family,
+  hostname: hostname2
+}) {
+  if (family === 4 ? !isIPv4(address) || isPrivateIPv4(address) : family === 6 ? isPrivateIPv6(address) : !0)
+    throw new DownloadError({
+      url: hostname2,
+      message: `Hostname ${hostname2} resolved to disallowed IP address ${address}`
+    });
+}
+function isIPv4(hostname2) {
+  let parts = hostname2.split(".");
+  return parts.length !== 4 ? !1 : parts.every((part) => {
+    let num = Number(part);
+    return Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part;
+  });
+}
+function isPrivateIPv4(ip) {
+  let parts = ip.split(".").map(Number), [a, b, c] = parts;
+  return a === 0 || a === 10 || a === 100 && b >= 64 && b <= 127 || a === 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 && c === 0 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 240;
+}
+function parseIPv6(ip) {
+  let address = ip.toLowerCase(), zoneIndex = address.indexOf("%");
+  zoneIndex !== -1 && (address = address.slice(0, zoneIndex));
+  let halves = address.split("::");
+  if (halves.length > 2) return null;
+  let toGroups = (segment) => {
+    if (segment === "") return [];
+    let groups = [], parts = segment.split(":");
+    for (let i = 0; i < parts.length; i++) {
+      let part = parts[i];
+      if (part.includes(".")) {
+        if (i !== parts.length - 1 || !isIPv4(part)) return null;
+        let [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;
+  }, head = toGroups(halves[0]);
+  if (head === null) return null;
+  if (halves.length === 2) {
+    let tail = toGroups(halves[1]);
+    if (tail === null) return null;
+    let fill = 8 - head.length - tail.length;
+    return fill < 0 ? null : [...head, ...new Array(fill).fill(0), ...tail];
+  }
+  return head.length === 8 ? head : null;
+}
+function isPrivateIPv6(ip) {
+  let groups = parseIPv6(ip);
+  if (groups === null) return !0;
+  let topZero = (count) => groups.slice(0, count).every((group) => group === 0);
+  if (topZero(7) && (groups[7] === 0 || groups[7] === 1) || (groups[0] & 65024) === 64512 || (groups[0] & 65472) === 65152 || (groups[0] & 65472) === 65216 || (groups[0] & 65280) === 65280) return !0;
+  if (
+    // ::/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
+  ) {
+    let a = groups[6] >> 8 & 255, b = groups[6] & 255, c = groups[7] >> 8 & 255, d = groups[7] & 255;
+    return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+  }
+  return !1;
+}
+function createSafeLookup(lookup) {
+  return ((hostname2, options, callback) => {
+    lookup(hostname2, { ...options, all: !0 }, (error40, addresses) => {
+      if (error40) {
+        callback(error40);
+        return;
+      }
+      try {
+        let [firstAddress] = addresses;
+        if (firstAddress == null)
+          throw new Error(`Hostname ${hostname2} did not resolve to an address`);
+        for (let { address, family } of addresses)
+          validateDownloadAddress({ address, family, hostname: hostname2 });
+        options.all === !0 ? callback(null, addresses) : callback(
+          null,
+          firstAddress.address,
+          firstAddress.family
+        );
+      } catch (error210) {
+        callback(
+          error210 instanceof Error ? error210 : new Error(String(error210))
+        );
+      }
+    });
+  });
+}
+var safeNodeFetchPromise;
+function isNodeRuntime() {
+  var _a22, _b22, _c;
+  let runtimeProcess = globalThis.process;
+  return ((_a22 = runtimeProcess?.release) == null ? void 0 : _a22.name) === "node" && ((_b22 = runtimeProcess.versions) == null ? void 0 : _b22.bun) == null && ((_c = runtimeProcess.versions) == null ? void 0 : _c.deno) == null && runtimeProcess.title !== "workerd" && globalThis.EdgeRuntime == null;
+}
+async function getDefaultDownloadFetch() {
+  return isNodeRuntime() ? safeNodeFetchPromise ?? (safeNodeFetchPromise = createSafeNodeFetch()) : globalThis.fetch;
+}
+async function createSafeNodeFetch() {
+  let [module, { lookup }] = await Promise.all([
+    loadNodeModule("node:module"),
+    loadNodeModule("node:dns")
+  ]), nodeRequire = module.createRequire(getCurrentModulePath()), { Agent, fetch } = nodeRequire("undici"), dispatcher = new Agent({
+    connect: {
+      lookup: createSafeLookup(lookup)
+    }
+  });
+  return ((input, init) => fetch(
+    input,
+    {
+      ...init,
+      dispatcher
+    }
+  ));
+}
+async function loadNodeModule(id) {
+  var _a22;
+  let processWithBuiltins = globalThis.process, builtinModule = (_a22 = processWithBuiltins?.getBuiltinModule) == null ? void 0 : _a22.call(processWithBuiltins, id);
+  if (builtinModule == null)
+    throw new Error(`Node.js built-in module ${id} is unavailable`);
+  return builtinModule;
+}
+function getCurrentModulePath() {
+  let originalPrepareStackTrace = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_error, callSites) => callSites;
+    let error40 = new Error("Capture current module path");
+    Error.captureStackTrace(error40, getCurrentModulePath);
+    let [caller] = error40.stack, fileName = caller?.getFileName();
+    if (fileName == null)
+      throw new Error("Unable to determine the current module path");
+    return fileName;
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace;
+  }
+}
+var MAX_DOWNLOAD_REDIRECTS = 10;
+async function getValidatedFetch(customFetch) {
+  return customFetch == null || customFetch === globalThis.fetch ? await getDefaultDownloadFetch() : customFetch;
+}
+async function fetchWithValidatedRedirects({
+  url: url2,
+  headers,
+  abortSignal,
+  maxRedirects = MAX_DOWNLOAD_REDIRECTS,
+  fetch: customFetch,
+  trustedOrigin
+}) {
+  var _a22;
+  let baseInit = { signal: abortSignal };
+  headers !== void 0 && (baseInit.headers = headers);
+  let currentUrl = url2;
+  for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount++) {
+    let isTrustedHop = trustedOrigin !== void 0 && isSameOrigin(currentUrl, trustedOrigin);
+    isTrustedHop || validateDownloadUrl(currentUrl);
+    let fetch = isTrustedHop && customFetch != null ? customFetch : isTrustedHop ? globalThis.fetch : await getValidatedFetch(customFetch), response = await fetch(currentUrl, {
+      ...baseInit,
+      redirect: "manual"
+    });
+    if (response.type === "opaqueredirect") {
+      if (!isBrowserRuntime())
+        throw new DownloadError({
+          url: url2,
+          message: `Redirect from ${currentUrl} could not be validated and was blocked`
+        });
+      return await fetch(currentUrl, { ...baseInit, redirect: "follow" });
+    }
+    let location = (_a22 = response.headers) == null ? void 0 : _a22.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: url2,
+    message: `Too many redirects (max ${maxRedirects})`
+  });
+}
+var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
+async function readResponseWithSizeLimit({
+  response,
+  url: url2,
+  maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE
+}) {
+  let contentLength = response.headers.get("content-length");
+  if (contentLength != null) {
+    let length = parseInt(contentLength, 10);
+    if (!isNaN(length) && length > maxBytes)
+      throw await cancelResponseBody(response), new DownloadError({
+        url: url2,
+        message: `Download of ${url2} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
+      });
+  }
+  let body = response.body;
+  if (body == null)
+    return new Uint8Array(0);
+  let reader = body.getReader(), chunks = [], totalBytes = 0;
+  try {
+    for (; ; ) {
+      let { done, value } = await reader.read();
+      if (done)
+        break;
+      if (totalBytes += value.length, totalBytes > maxBytes)
+        throw new DownloadError({
+          url: url2,
+          message: `Download of ${url2} exceeded maximum size of ${maxBytes} bytes.`
+        });
+      chunks.push(value);
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  let result = new Uint8Array(totalBytes), offset = 0;
+  for (let chunk of chunks)
+    result.set(chunk, offset), offset += chunk.length;
+  return result;
+}
+async function downloadBlob(url2, options) {
+  var _a22, _b22;
+  try {
+    let response = await fetchWithValidatedRedirects({
+      url: url2,
+      abortSignal: options?.abortSignal
+    });
+    if (!response.ok)
+      throw await cancelResponseBody(response), new DownloadError({
         url: url2,
         statusCode: response.status,
         statusText: response.statusText
       });
-    return await response.blob();
+    let data = await readResponseWithSizeLimit({
+      response,
+      url: url2,
+      maxBytes: (_a22 = options?.maxBytes) != null ? _a22 : DEFAULT_MAX_DOWNLOAD_SIZE
+    }), contentType = (_b22 = response.headers.get("content-type")) != null ? _b22 : void 0;
+    return new Blob([data], contentType ? { type: contentType } : void 0);
   } catch (error40) {
     throw DownloadError.isInstance(error40) ? error40 : new DownloadError({ url: url2, cause: error40 });
   }
 }
+var EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL = /* @__PURE__ */ Symbol.for(
+  "vercel.ai.embeddingModel.maxInputBytesPerCall"
+);
 var createIdGenerator = ({
   prefix,
   size = 16,
@@ -9135,20 +9569,28 @@ function isAbortError(error40) {
   return (error40 instanceof Error || error40 instanceof DOMException) && (error40.name === "AbortError" || error40.name === "ResponseAborted" || // Next.js
   error40.name === "TimeoutError");
 }
-var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"], BUN_ERROR_CODES = [
+var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"], RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
   "ConnectionRefused",
   "ConnectionClosed",
   "FailedToOpenSocket",
   "ECONNRESET",
   "ECONNREFUSED",
   "ETIMEDOUT",
-  "EPIPE"
-];
-function isBunNetworkError(error40) {
-  if (!(error40 instanceof Error))
-    return !1;
-  let code = error40.code;
-  return !!(typeof code == "string" && BUN_ERROR_CODES.includes(code));
+  "EPIPE",
+  "UND_ERR_SOCKET",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+function findNetworkError(error40) {
+  let visited = /* @__PURE__ */ new Set(), current = error40;
+  for (; current instanceof Error && !visited.has(current); ) {
+    visited.add(current);
+    let errorWithCode = current;
+    if (typeof errorWithCode.code == "string" && RETRYABLE_NETWORK_ERROR_CODES.has(errorWithCode.code))
+      return errorWithCode;
+    current = current.cause;
+  }
 }
 function handleFetchError({
   error: error40,
@@ -9169,8 +9611,19 @@ function handleFetchError({
         // retry when network error
       });
   }
-  return isBunNetworkError(error40) ? new APICallError({
-    message: `Cannot connect to API: ${error40.message}`,
+  let networkError = findNetworkError(error40);
+  return networkError != null ? APICallError.isInstance(error40) ? new APICallError({
+    message: error40.message,
+    cause: error40.cause,
+    url: error40.url,
+    requestBodyValues: error40.requestBodyValues,
+    statusCode: error40.statusCode,
+    responseHeaders: error40.responseHeaders,
+    responseBody: error40.responseBody,
+    data: error40.data,
+    isRetryable: !0
+  }) : new APICallError({
+    message: `Cannot connect to API: ${error40 instanceof Error ? error40.message : networkError.message}`,
     cause: error40,
     url: url2,
     requestBodyValues,
@@ -9203,16 +9656,16 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
     [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
   ), Object.fromEntries(normalizedHeaders.entries());
 }
-var VERSION = "4.0.13", getOriginalFetch = () => globalThis.fetch, getFromApi = async ({
+var VERSION = "4.0.58", getOriginalFetch = () => globalThis.fetch, getFromApi = async ({
   url: url2,
   headers = {},
   successfulResponseHandler,
   failedResponseHandler,
   abortSignal,
-  fetch: fetch2 = getOriginalFetch()
+  fetch = getOriginalFetch()
 }) => {
   try {
-    let response = await fetch2(url2, {
+    let response = await fetch(url2, {
       method: "GET",
       headers: withUserAgentSuffix(
         headers,
@@ -9272,7 +9725,9 @@ function isUrlSupported({
   return url2 = url2.toLowerCase(), mediaType = mediaType.toLowerCase(), Object.entries(supportedUrls).map(([key, value]) => {
     let 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(url2));
+  }).filter(
+    ({ mediaTypePrefix }) => mediaTypePrefix === "" || mediaTypePrefix.endsWith("/") ? mediaType.startsWith(mediaTypePrefix) : mediaType === mediaTypePrefix
+  ).flatMap(({ regexes }) => regexes).some((pattern) => pattern.test(url2));
 }
 function loadApiKey({
   apiKey,
@@ -9288,7 +9743,7 @@ function loadApiKey({
     });
   if (typeof process > "u")
     throw new LoadAPIKeyError({
-      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
+      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables are not supported in this environment.`
     });
   if (apiKey = process.env[environmentVariableName], apiKey == null)
     throw new LoadAPIKeyError({
@@ -9320,7 +9775,7 @@ function mediaTypeToExtension(mediaType) {
     "x-m4a": "m4a"
   }[subtype]) != null ? _a22 : subtype;
 }
-var suspectProtoRx = /"__proto__"\s*:/, suspectConstructorRx = /"constructor"\s*:/;
+var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/, suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
 function _parse2(text) {
   let obj = JSON.parse(text);
   return obj === null || typeof obj != "object" || suspectProtoRx.test(text) === !1 && suspectConstructorRx.test(text) === !1 ? obj : filter(obj);
@@ -9333,7 +9788,7 @@ function filter(obj) {
     for (let node of nodes) {
       if (Object.prototype.hasOwnProperty.call(node, "__proto__"))
         throw new SyntaxError("Object contains forbidden prototype property");
-      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype"))
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor == "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype"))
         throw new SyntaxError("Object contains forbidden prototype property");
       for (let key in node) {
         let value = node[key];
@@ -9358,7 +9813,8 @@ function secureJsonParse(text) {
 }
 function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
   if (jsonSchema2.type === "object" || Array.isArray(jsonSchema2.type) && jsonSchema2.type.includes("object")) {
-    jsonSchema2.additionalProperties = !1;
+    let { additionalProperties } = jsonSchema2;
+    jsonSchema2.additionalProperties = additionalProperties != null && typeof additionalProperties != "boolean" ? visit(additionalProperties) : !1;
     let { properties } = jsonSchema2;
     if (properties != null)
       for (let key of Object.keys(properties))
@@ -9540,7 +9996,7 @@ var emojiRegex = void 0, zodPatterns = {
   /**
    * `a-z` was added to replicate /i flag
    */
-  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9-]*\.)+[a-zA-Z]{2,}$/,
   /**
    * Constructed a valid Unicode RegExp
    *
@@ -10301,15 +10757,25 @@ function isSchema(value) {
   return typeof value == "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === !0 && "jsonSchema" in value && "validate" in value;
 }
 function asSchema(schema) {
-  return schema == null ? jsonSchema({ properties: {}, additionalProperties: !1 }) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
+  return schema == null ? jsonSchema({
+    type: "object",
+    properties: {},
+    additionalProperties: !1
+  }) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
 }
 function standardSchema(standardSchema2) {
   return jsonSchema(
-    () => addAdditionalPropertiesToJsonSchema(
-      standardSchema2["~standard"].jsonSchema.input({
-        target: "draft-07"
-      })
-    ),
+    () => {
+      if (!hasStandardJsonSchema(standardSchema2))
+        throw new Error(
+          `Standard schema vendor '${standardSchema2["~standard"].vendor}' does not support JSON Schema conversion.`
+        );
+      return addAdditionalPropertiesToJsonSchema(
+        standardSchema2["~standard"].jsonSchema.input({
+          target: "draft-07"
+        })
+      );
+    },
     {
       validate: async (value) => {
         let result = await standardSchema2["~standard"].validate(value);
@@ -10324,6 +10790,9 @@ function standardSchema(standardSchema2) {
     }
   );
 }
+function hasStandardJsonSchema(schema) {
+  return schema["~standard"].jsonSchema != null;
+}
 function zod3Schema(zodSchema2, options) {
   var _a22;
   let useReferences = (_a22 = options?.useReferences) != null ? _a22 : !1;
@@ -10425,13 +10894,6 @@ async function safeParseJSON({
     };
   }
 }
-function isParsableJson(input) {
-  try {
-    return secureJsonParse(input), !0;
-  } catch {
-    return !1;
-  }
-}
 function parseJsonEventStream({
   stream,
   schema
@@ -10470,7 +10932,7 @@ var getOriginalFetch2 = () => globalThis.fetch, postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 }) => postToApi({
   url: url2,
   headers: {
@@ -10484,7 +10946,7 @@ var getOriginalFetch2 = () => globalThis.fetch, postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 }), postFormDataToApi = async ({
   url: url2,
   headers,
@@ -10492,7 +10954,7 @@ var getOriginalFetch2 = () => globalThis.fetch, postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 }) => postToApi({
   url: url2,
   headers,
@@ -10503,7 +10965,7 @@ var getOriginalFetch2 = () => globalThis.fetch, postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 }), postToApi = async ({
   url: url2,
   headers = {},
@@ -10511,10 +10973,10 @@ var getOriginalFetch2 = () => globalThis.fetch, postJsonToApi = async ({
   successfulResponseHandler,
   failedResponseHandler,
   abortSignal,
-  fetch: fetch2 = getOriginalFetch2()
+  fetch = getOriginalFetch2()
 }) => {
   try {
-    let response = await fetch2(url2, {
+    let response = await fetch(url2, {
       method: "POST",
       headers: withUserAgentSuffix(
         headers,
@@ -10621,14 +11083,136 @@ function createProviderToolFactoryWithOutputSchema({
   });
 }
 async function resolve(value) {
-  return typeof value == "function" && (value = value()), Promise.resolve(value);
+  return typeof value == "function" && (value = value()), value;
+}
+var retryWithExponentialBackoff = ({
+  maxRetries = 2,
+  initialDelayInMs = 2e3,
+  backoffFactor = 2,
+  abortSignal,
+  shouldRetry,
+  getDelayInMs = ({ exponentialBackoffDelay }) => exponentialBackoffDelay,
+  createRetryError = ({ message }) => new Error(message)
+}) => async (f) => retryWithExponentialBackoffInternal(f, {
+  maxRetries,
+  delayInMs: initialDelayInMs,
+  backoffFactor,
+  abortSignal,
+  shouldRetry,
+  getDelayInMs,
+  createRetryError
+});
+async function retryWithExponentialBackoffInternal(f, {
+  maxRetries,
+  delayInMs,
+  backoffFactor,
+  abortSignal,
+  shouldRetry,
+  getDelayInMs,
+  createRetryError
+}, errors = []) {
+  try {
+    return await f();
+  } catch (error40) {
+    if (isAbortError(error40) || maxRetries === 0)
+      throw error40;
+    let errorMessage = getErrorMessage2(error40), newErrors = [...errors, error40], tryNumber = newErrors.length;
+    if (tryNumber > maxRetries)
+      throw createRetryError({
+        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+        reason: "maxRetriesExceeded",
+        errors: newErrors
+      });
+    if (await shouldRetry(error40) && tryNumber <= maxRetries)
+      return await delay(
+        getDelayInMs({
+          error: error40,
+          exponentialBackoffDelay: delayInMs
+        }),
+        { abortSignal }
+      ), retryWithExponentialBackoffInternal(
+        f,
+        {
+          maxRetries,
+          delayInMs: backoffFactor * delayInMs,
+          backoffFactor,
+          abortSignal,
+          shouldRetry,
+          getDelayInMs,
+          createRetryError
+        },
+        newErrors
+      );
+    throw tryNumber === 1 ? error40 : createRetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
+  }
+}
+var textDecoder = new TextDecoder();
+function wrapResponseBodyStream({
+  stream,
+  url: url2,
+  requestBodyValues,
+  statusCode,
+  responseHeaders
+}) {
+  let reader = stream.getReader(), readerReleased = !1, releaseReader = () => {
+    readerReleased || (reader.releaseLock(), readerReleased = !0);
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        let { done, value } = await reader.read();
+        done ? (releaseReader(), controller.close()) : controller.enqueue(value);
+      } catch (error40) {
+        if (releaseReader(), isAbortError(error40)) {
+          controller.error(error40);
+          return;
+        }
+        controller.error(
+          handleFetchError({
+            error: new APICallError({
+              message: "Failed to process successful response",
+              cause: error40,
+              statusCode,
+              url: url2,
+              responseHeaders,
+              requestBodyValues
+            }),
+            url: url2,
+            requestBodyValues
+          })
+        );
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        releaseReader();
+      }
+    }
+  });
+}
+async function readResponseBodyAsText({
+  response,
+  url: url2
+}) {
+  return textDecoder.decode(
+    await readResponseWithSizeLimit({
+      response,
+      url: url2
+    })
+  );
 }
 var createJsonErrorResponseHandler = ({
   errorSchema,
   errorToMessage,
   isRetryable
 }) => async ({ response, url: url2, requestBodyValues }) => {
-  let responseBody = await response.text(), responseHeaders = extractResponseHeaders(response);
+  let responseBody = await readResponseBodyAsText({ response, url: url2 }), responseHeaders = extractResponseHeaders(response);
   if (responseBody.trim() === "")
     return {
       responseHeaders,
@@ -10674,19 +11258,25 @@ var createJsonErrorResponseHandler = ({
       })
     };
   }
-}, createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
+}, createEventSourceResponseHandler = (chunkSchema) => async ({ response, url: url2, requestBodyValues }) => {
   let responseHeaders = extractResponseHeaders(response);
   if (response.body == null)
     throw new EmptyResponseBodyError({});
   return {
     responseHeaders,
     value: parseJsonEventStream({
-      stream: response.body,
+      stream: wrapResponseBodyStream({
+        stream: response.body,
+        url: url2,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders
+      }),
       schema: chunkSchema
     })
   };
 }, createJsonResponseHandler = (responseSchema) => async ({ response, url: url2, requestBodyValues }) => {
-  let responseBody = await response.text(), parsedResult = await safeParseJSON({
+  let responseBody = await readResponseBodyAsText({ response, url: url2 }), parsedResult = await safeParseJSON({
     text: responseBody,
     schema: responseSchema
   }), responseHeaders = extractResponseHeaders(response);
@@ -10734,6 +11324,259 @@ var createJsonErrorResponseHandler = ({
     });
   }
 };
+function startsWithStructuredValue(value) {
+  if (typeof value != "string")
+    return !1;
+  let firstCharacter = value.trimStart()[0];
+  return firstCharacter === "{" || firstCharacter === "[";
+}
+var StreamingToolCallArgumentState = class {
+  constructor(initialValue = "") {
+    this.structure = { kind: "undetermined" }, this.append(initialValue);
+  }
+  get hasCompleteStructuredValue() {
+    return this.structure.kind === "structured" && this.structure.complete === !0;
+  }
+  append(delta) {
+    let nextStructure = this.structure;
+    for (let character of delta) {
+      if (nextStructure.kind === "undetermined") {
+        if (/\s/.test(character))
+          continue;
+        if (character !== "{" && character !== "[") {
+          nextStructure = { kind: "other" };
+          continue;
+        }
+        nextStructure = {
+          kind: "structured",
+          stack: [character],
+          inString: !1,
+          escaped: !1,
+          complete: !1
+        };
+        continue;
+      }
+      if (!(nextStructure.kind !== "structured" || nextStructure.complete)) {
+        if (nextStructure.inString) {
+          nextStructure.escaped ? nextStructure.escaped = !1 : character === "\\" ? nextStructure.escaped = !0 : character === '"' && (nextStructure.inString = !1);
+          continue;
+        }
+        if (character === '"')
+          nextStructure.inString = !0;
+        else if (character === "{" || character === "[")
+          nextStructure.stack.push(character);
+        else if (character === "}" || character === "]") {
+          let expectedOpening = character === "}" ? "{" : "[";
+          if (nextStructure.stack[nextStructure.stack.length - 1] !== expectedOpening) {
+            nextStructure = { kind: "other" };
+            continue;
+          }
+          nextStructure.stack.pop(), nextStructure.stack.length === 0 && (nextStructure.complete = !0);
+        }
+      }
+    }
+    this.structure = nextStructure;
+  }
+}, StreamingToolCallTracker = class {
+  constructor(controller, options = {}) {
+    this.toolCalls = [], this.toolCallsById = /* @__PURE__ */ new Map(), this.toolCallsByIndex = /* @__PURE__ */ new Map(), this.usedToolCallIds = /* @__PURE__ */ new Set(), this.nextGeneratedIdSuffixes = /* @__PURE__ */ new Map();
+    var _a22, _b22;
+    this.controller = controller, this._generateId = (_a22 = options.generateId) != null ? _a22 : generateId, this.typeValidation = (_b22 = options.typeValidation) != null ? _b22 : "none", this.extractMetadata = options.extractMetadata, this.buildToolCallProviderMetadata = options.buildToolCallProviderMetadata;
+  }
+  processDelta(toolCallDelta) {
+    var _a22, _b22;
+    let wireName = (_a22 = toolCallDelta.function) == null ? void 0 : _a22.name, hasBlankName = typeof wireName == "string" && wireName.trim().length === 0, wireId = this.getNonBlankString(toolCallDelta.id), name22 = this.getNonBlankString(wireName), { index } = toolCallDelta, resolution = this.resolveToolCall({
+      wireId,
+      index,
+      name: name22,
+      hasExplicitCallStart: name22 != null && startsWithStructuredValue((_b22 = toolCallDelta.function) == null ? void 0 : _b22.arguments)
+    });
+    if (resolution.kind === "ambiguous")
+      return;
+    let toolCall;
+    if (resolution.kind === "new") {
+      if (hasBlankName)
+        return;
+      toolCall = this.processNewToolCall(toolCallDelta, {
+        wireId,
+        index,
+        name: name22
+      });
+    } else
+      toolCall = resolution.toolCall, wireId != null && this.associateWireId(toolCall, wireId), this.processExistingToolCall(toolCall, toolCallDelta);
+    index != null && this.associateIndex(toolCall, index);
+  }
+  flush() {
+    let toolCalls = this.toolCalls.every((toolCall) => toolCall.index != null) ? [...this.toolCalls].sort(
+      (a, b) => a.index - b.index || a.sequence - b.sequence
+    ) : this.toolCalls;
+    for (let toolCall of toolCalls)
+      toolCall.hasFinished || this.finishToolCall(toolCall);
+  }
+  resolveToolCall({
+    wireId,
+    index,
+    name: name22,
+    hasExplicitCallStart
+  }) {
+    let indexedToolCalls = index != null ? this.toolCallsByIndex.get(index) : void 0, matchingIndexedToolCalls = this.filterToolCallsByName(
+      indexedToolCalls,
+      name22
+    );
+    if (wireId != null) {
+      let toolCallsWithId = this.toolCallsById.get(wireId);
+      if (toolCallsWithId != null) {
+        if (index != null) {
+          let matchingToolCalls = matchingIndexedToolCalls.filter(
+            (toolCall) => toolCallsWithId.has(toolCall)
+          ), matchingToolCall = this.resolveMatchingToolCall(
+            matchingToolCalls,
+            hasExplicitCallStart
+          );
+          return matchingToolCall.kind !== "new" ? matchingToolCall : name22 != null ? { kind: "new" } : indexedToolCalls != null ? { kind: "ambiguous" } : this.resolveMatchingToolCall([...toolCallsWithId], !1);
+        }
+        if (name22 != null) {
+          let matchingToolCalls = [...toolCallsWithId].filter(
+            (toolCall) => toolCall.function.name === name22
+          );
+          return this.resolveMatchingToolCall(
+            matchingToolCalls,
+            hasExplicitCallStart
+          );
+        }
+        return this.resolveMatchingToolCall([...toolCallsWithId], !1);
+      }
+      return matchingIndexedToolCalls.length > 0 ? hasExplicitCallStart ? { kind: "new" } : this.resolveMatchingToolCall(matchingIndexedToolCalls, !1) : { kind: "new" };
+    }
+    if (indexedToolCalls != null)
+      return this.resolveMatchingToolCall(
+        matchingIndexedToolCalls,
+        hasExplicitCallStart
+      );
+    if (name22 != null)
+      return { kind: "new" };
+    let unfinishedToolCalls = this.toolCalls.filter(
+      (toolCall) => !toolCall.hasFinished
+    );
+    return unfinishedToolCalls.length === 1 ? { kind: "existing", toolCall: unfinishedToolCalls[0] } : unfinishedToolCalls.length > 1 ? { kind: "ambiguous" } : { kind: "new" };
+  }
+  filterToolCallsByName(toolCalls, name22) {
+    return toolCalls == null ? [] : [...toolCalls].filter(
+      (toolCall) => name22 == null || toolCall.function.name === name22
+    );
+  }
+  resolveMatchingToolCall(toolCalls, hasExplicitCallStart) {
+    if (toolCalls.length === 0)
+      return { kind: "new" };
+    if (!hasExplicitCallStart)
+      return toolCalls.length === 1 ? { kind: "existing", toolCall: toolCalls[0] } : { kind: "ambiguous" };
+    let continuableToolCalls = toolCalls.filter(
+      (toolCall) => !toolCall.argumentState.hasCompleteStructuredValue
+    );
+    return continuableToolCalls.length === 1 ? { kind: "existing", toolCall: continuableToolCalls[0] } : continuableToolCalls.length > 1 ? { kind: "ambiguous" } : { kind: "new" };
+  }
+  processNewToolCall(toolCallDelta, {
+    wireId,
+    index,
+    name: name22
+  }) {
+    var _a22, _b22, _c, _d, _e;
+    if (this.typeValidation === "required") {
+      if (toolCallDelta.type !== "function")
+        throw new InvalidResponseDataError({
+          data: toolCallDelta,
+          message: "Expected 'function' type."
+        });
+    } else if (this.typeValidation === "if-present" && toolCallDelta.type != null && toolCallDelta.type !== "function")
+      throw new InvalidResponseDataError({
+        data: toolCallDelta,
+        message: "Expected 'function' type."
+      });
+    if (name22 == null)
+      throw new InvalidResponseDataError({
+        data: toolCallDelta,
+        message: "Expected 'function.name' to be a string."
+      });
+    let id = this.createToolCallId(wireId);
+    this.controller.enqueue({
+      type: "tool-input-start",
+      id,
+      toolName: name22
+    });
+    let toolCall = {
+      id,
+      index: index ?? void 0,
+      sequence: this.toolCalls.length,
+      type: "function",
+      function: {
+        name: name22,
+        arguments: (_b22 = (_a22 = toolCallDelta.function) == null ? void 0 : _a22.arguments) != null ? _b22 : ""
+      },
+      argumentState: new StreamingToolCallArgumentState(
+        (_d = (_c = toolCallDelta.function) == null ? void 0 : _c.arguments) != null ? _d : ""
+      ),
+      hasFinished: !1,
+      metadata: (_e = this.extractMetadata) == null ? void 0 : _e.call(this, toolCallDelta)
+    };
+    return this.toolCalls.push(toolCall), wireId != null && this.associateWireId(toolCall, wireId), toolCall.function.arguments.length > 0 && this.controller.enqueue({
+      type: "tool-input-delta",
+      id: toolCall.id,
+      delta: toolCall.function.arguments
+    }), toolCall;
+  }
+  associateWireId(toolCall, wireId) {
+    let toolCallsWithId = this.toolCallsById.get(wireId);
+    toolCallsWithId == null && (toolCallsWithId = /* @__PURE__ */ new Set(), this.toolCallsById.set(wireId, toolCallsWithId)), toolCallsWithId.add(toolCall);
+  }
+  associateIndex(toolCall, index) {
+    let toolCallsWithIndex = this.toolCallsByIndex.get(index);
+    toolCallsWithIndex == null && (toolCallsWithIndex = /* @__PURE__ */ new Set(), this.toolCallsByIndex.set(index, toolCallsWithIndex)), toolCallsWithIndex.add(toolCall);
+  }
+  createToolCallId(wireId) {
+    var _a22, _b22;
+    if (wireId != null && !this.usedToolCallIds.has(wireId))
+      return this.usedToolCallIds.add(wireId), wireId;
+    let generatedId = (_a22 = this.getNonBlankString(this._generateId())) != null ? _a22 : "tool-call";
+    if (!this.usedToolCallIds.has(generatedId))
+      return this.usedToolCallIds.add(generatedId), generatedId;
+    let initialSuffix = (_b22 = this.nextGeneratedIdSuffixes.get(generatedId)) != null ? _b22 : 1, maximumSuffix = initialSuffix + this.usedToolCallIds.size;
+    for (let suffix = initialSuffix; suffix <= maximumSuffix; suffix++) {
+      let suffixedId = `${generatedId}-${suffix}`;
+      if (!this.usedToolCallIds.has(suffixedId))
+        return this.usedToolCallIds.add(suffixedId), this.nextGeneratedIdSuffixes.set(generatedId, suffix + 1), suffixedId;
+    }
+    throw new Error("Failed to create a unique tool call ID.");
+  }
+  getNonBlankString(value) {
+    return value != null && value.trim().length > 0 ? value : void 0;
+  }
+  processExistingToolCall(toolCall, toolCallDelta) {
+    var _a22;
+    !toolCall.hasFinished && ((_a22 = toolCallDelta.function) == null ? void 0 : _a22.arguments) != null && (toolCall.argumentState.append(toolCallDelta.function.arguments), toolCall.function.arguments += toolCallDelta.function.arguments, this.controller.enqueue({
+      type: "tool-input-delta",
+      id: toolCall.id,
+      delta: toolCallDelta.function.arguments
+    }));
+  }
+  finishToolCall(toolCall) {
+    var _a22;
+    this.controller.enqueue({
+      type: "tool-input-end",
+      id: toolCall.id
+    });
+    let providerMetadata = (_a22 = this.buildToolCallProviderMetadata) == null ? void 0 : _a22.call(
+      this,
+      toolCall.metadata
+    );
+    this.controller.enqueue({
+      type: "tool-call",
+      toolCallId: toolCall.id,
+      toolName: toolCall.function.name,
+      input: toolCall.function.arguments,
+      ...providerMetadata ? { providerMetadata } : {}
+    }), toolCall.hasFinished = !0;
+  }
+};
 function withoutTrailingSlash(url2) {
   return url2?.replace(/\/$/, "");
 }
@@ -10766,19 +11609,24 @@ export {
   TooManyEmbeddingValuesForCallError,
   TypeValidationError,
   UnsupportedFunctionalityError,
+  isJSONObject,
   toJSONSchema,
   safeParseAsync2 as safeParseAsync,
   external_exports,
   combineHeaders,
   createToolNameMapping,
-  delay,
   DelayedPromise,
   convertBase64ToUint8Array,
   convertUint8ArrayToBase64,
   convertToBase64,
   convertToFormData,
+  cancelResponseBody,
   DownloadError,
+  fetchWithValidatedRedirects,
+  DEFAULT_MAX_DOWNLOAD_SIZE,
+  readResponseWithSizeLimit,
   downloadBlob,
+  EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL,
   createIdGenerator,
   generateId,
   getErrorMessage2,
@@ -10791,24 +11639,37 @@ export {
   loadApiKey,
   loadOptionalSetting,
   mediaTypeToExtension,
+  secureJsonParse,
   lazySchema,
   jsonSchema,
   asSchema,
   zodSchema,
   validateTypes,
   safeValidateTypes,
+  parseJSON,
   safeParseJSON,
-  isParsableJson,
+  parseJsonEventStream,
   parseProviderOptions,
   postJsonToApi,
   postFormDataToApi,
   createProviderToolFactory,
   createProviderToolFactoryWithOutputSchema,
   resolve,
+  retryWithExponentialBackoff,
   createJsonErrorResponseHandler,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
   createBinaryResponseHandler,
+  StreamingToolCallTracker,
   withoutTrailingSlash,
-  executeTool
+  executeTool,
+  MEDIA_KINDS,
+  ALL_MEDIA,
+  IMAGE_ONLY_MEDIA,
+  connectorMedia,
+  effectiveMediaSupport,
+  mediaKindOf,
+  mediaOmissionReason,
+  mediaRefusals,
+  unsupportedMediaInput
 };