@probelabs/probe 0.6.0-rc334 → 0.6.0-rc335

package/cjs/index.cjs

@@ -18326,6 +18326,218 @@ var init_v3 = __esm({
   }
 });
 
+// node_modules/eventsource-parser/dist/index.js
+function noop(_arg) {
+}
+function createParser(config2) {
+  if (typeof config2 == "function")
+    throw new TypeError(
+      "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config2, pendingFragments = [];
+  let pendingFragmentsLength = 0, isFirstChunk = true, id, data2 = "", dataLines = 0, eventType, terminated = false;
+  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 = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const 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);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    const trailing = processLines(input);
+    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+  }
+  function checkBufferSize() {
+    maxBufferSize !== void 0 && (pendingFragmentsLength + data2.length <= maxBufferSize || (terminated = true, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data2 = "", 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: data2 }), id = void 0, data2 = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const 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, data2 = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data2 = dataLines === 0 ? value : `${data2}
+${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; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let 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;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data2 = dataLines === 0 ? value2 : `${data2}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      value2.includes("\0") || (id = value2);
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset2 = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset2);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data2 = dataLines === 0 ? value : `${data2}
+${value}`, dataLines++;
+        break;
+      case "id":
+        value.includes("\0") || (id = value);
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data: data2
+    }), id = void 0, data2 = "", dataLines = 0, eventType = void 0;
+  }
+  function reset2(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true, id = void 0, data2 = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = false;
+  }
+  return { feed, reset: reset2 };
+}
+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;
+}
+var ParseError, LF, CR, SPACE;
+var init_dist2 = __esm({
+  "node_modules/eventsource-parser/dist/index.js"() {
+    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;
+  }
+});
+
+// node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream;
+var init_stream = __esm({
+  "node_modules/eventsource-parser/dist/stream.js"() {
+    init_dist2();
+    EventSourceParserStream = class extends TransformStream {
+      constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
+        let parser;
+        super({
+          start(controller) {
+            parser = createParser({
+              onEvent: (event) => {
+                controller.enqueue(event);
+              },
+              onError(error40) {
+                typeof onError == "function" && onError(error40), (onError === "terminate" || error40.type === "max-buffer-size-exceeded") && controller.error(error40);
+              },
+              onRetry,
+              onComment,
+              maxBufferSize
+            });
+          },
+          transform(chunk) {
+            parser.feed(chunk);
+          }
+        });
+      }
+    };
+  }
+});
+
 // node_modules/@ai-sdk/provider-utils/dist/index.mjs
 function combineHeaders(...headers) {
   return headers.reduce(
@@ -18339,6 +18551,11 @@ function combineHeaders(...headers) {
 function extractResponseHeaders(response) {
   return Object.fromEntries([...response.headers]);
 }
+function convertBase64ToUint8Array(base64String) {
+  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
+  const latin1string = atob2(base64Url);
+  return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
+}
 function convertUint8ArrayToBase64(array2) {
   let latin1string = "";
   for (let i = 0; i < array2.length; i++) {
@@ -18349,6 +18566,28 @@ function convertUint8ArrayToBase64(array2) {
 function convertToBase64(value) {
   return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
 }
+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;
+}
 async function cancelResponseBody(response) {
   var _a22;
   try {
@@ -18356,6 +18595,202 @@ async function cancelResponseBody(response) {
   } catch (e) {
   }
 }
+function isBrowserRuntime(globalThisAny = globalThis) {
+  return globalThisAny.window != null;
+}
+function validateDownloadUrl(url2) {
+  let parsed;
+  try {
+    parsed = new URL(url2);
+  } catch (e) {
+    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}`
+    });
+  }
+  const 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("]")) {
+    const 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)) {
+    if (isPrivateIPv4(hostname2)) {
+      throw new DownloadError({
+        url: url2,
+        message: `URL with IP address ${hostname2} is not allowed`
+      });
+    }
+    return;
+  }
+}
+function validateDownloadAddress({
+  address,
+  family,
+  hostname: hostname2
+}) {
+  const isUnsafe = family === 4 ? !isIPv4(address) || isPrivateIPv4(address) : family === 6 ? isPrivateIPv6(address) : true;
+  if (isUnsafe) {
+    throw new DownloadError({
+      url: hostname2,
+      message: `Hostname ${hostname2} resolved to disallowed IP address ${address}`
+    });
+  }
+}
+function isIPv4(hostname2) {
+  const parts = hostname2.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((part) => {
+    const num = Number(part);
+    return Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part;
+  });
+}
+function isPrivateIPv4(ip) {
+  const parts = ip.split(".").map(Number);
+  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 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 head2 = toGroups(halves[0]);
+  if (head2 === null) return null;
+  if (halves.length === 2) {
+    const tail = toGroups(halves[1]);
+    if (tail === null) return null;
+    const fill = 8 - head2.length - tail.length;
+    if (fill < 0) return null;
+    return [...head2, ...new Array(fill).fill(0), ...tail];
+  }
+  return head2.length === 8 ? head2 : 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}`);
+  }
+  return false;
+}
+function createSafeLookup(lookup) {
+  return ((hostname2, options, callback) => {
+    lookup(hostname2, { ...options, all: true }, (error40, addresses) => {
+      if (error40) {
+        callback(error40);
+        return;
+      }
+      try {
+        const [firstAddress] = addresses;
+        if (firstAddress == null) {
+          throw new Error(`Hostname ${hostname2} did not resolve to an address`);
+        }
+        for (const { address, family } of addresses) {
+          validateDownloadAddress({ address, family, hostname: hostname2 });
+        }
+        if (options.all === true) {
+          callback(null, addresses);
+        } else {
+          callback(
+            null,
+            firstAddress.address,
+            firstAddress.family
+          );
+        }
+      } catch (error210) {
+        callback(
+          error210 instanceof Error ? error210 : new Error(String(error210))
+        );
+      }
+    });
+  });
+}
+function isNodeRuntime() {
+  var _a22, _b22;
+  const runtimeProcess = globalThis.process;
+  return ((_a22 = runtimeProcess == null ? void 0 : runtimeProcess.release) == null ? void 0 : _a22.name) === "node" && ((_b22 = runtimeProcess.versions) == null ? void 0 : _b22.bun) == null;
+}
+async function getDefaultDownloadFetch() {
+  if (!isNodeRuntime() || !initialGlobalFetchIsNodeDefault || globalThis.fetch !== initialGlobalFetch) {
+    return globalThis.fetch;
+  }
+  return safeNodeFetchPromise != null ? safeNodeFetchPromise : safeNodeFetchPromise = createSafeNodeFetch();
+}
 function isNodeDefaultFetch(fetch2) {
   if (typeof fetch2 !== "function") {
     return false;
@@ -18363,6 +18798,92 @@ function isNodeDefaultFetch(fetch2) {
   const source = Function.prototype.toString.call(fetch2);
   return source.includes("internal/deps/undici") || source.includes("lazy loading of undici");
 }
+async function createSafeNodeFetch() {
+  const [{ createRequire: createRequire2 }, { lookup }] = await Promise.all([
+    loadNodeModule("node:module"),
+    loadNodeModule("node:dns")
+  ]);
+  const { Agent, fetch: fetch2 } = createRequire2(getCurrentModulePath())(
+    "undici"
+  );
+  const dispatcher = new Agent({
+    connect: {
+      lookup: createSafeLookup(lookup)
+    }
+  });
+  return ((input, init) => fetch2(
+    input,
+    {
+      ...init,
+      dispatcher
+    }
+  ));
+}
+async function loadNodeModule(id) {
+  var _a22;
+  const processWithBuiltins = globalThis.process;
+  const builtinModule = (_a22 = processWithBuiltins == null ? void 0 : 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() {
+  const originalPrepareStackTrace = Error.prepareStackTrace;
+  try {
+    Error.prepareStackTrace = (_error, callSites) => callSites;
+    const error40 = new Error("Capture current module path");
+    Error.captureStackTrace(error40, getCurrentModulePath);
+    const [caller] = error40.stack;
+    const fileName = caller == null ? void 0 : caller.getFileName();
+    if (fileName == null) {
+      throw new Error("Unable to determine the current module path");
+    }
+    return fileName;
+  } finally {
+    Error.prepareStackTrace = originalPrepareStackTrace;
+  }
+}
+async function fetchWithValidatedRedirects({
+  url: url2,
+  headers,
+  abortSignal,
+  maxRedirects = MAX_DOWNLOAD_REDIRECTS
+}) {
+  const baseInit = { signal: abortSignal };
+  if (headers !== void 0) {
+    baseInit.headers = headers;
+  }
+  let currentUrl = url2;
+  for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount++) {
+    validateDownloadUrl(currentUrl);
+    const fetch2 = await getDefaultDownloadFetch();
+    const response = await fetch2(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 fetch2(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: url2,
+    message: `Too many redirects (max ${maxRedirects})`
+  });
+}
 async function readResponseWithSizeLimit({
   response,
   url: url2,
@@ -18417,6 +18938,35 @@ async function readResponseWithSizeLimit({
   }
   return result;
 }
+async function downloadBlob(url2, options) {
+  var _a22, _b22;
+  try {
+    const response = await fetchWithValidatedRedirects({
+      url: url2,
+      abortSignal: options == null ? void 0 : options.abortSignal
+    });
+    if (!response.ok) {
+      await cancelResponseBody(response);
+      throw new DownloadError({
+        url: url2,
+        statusCode: response.status,
+        statusText: response.statusText
+      });
+    }
+    const data2 = await readResponseWithSizeLimit({
+      response,
+      url: url2,
+      maxBytes: (_a22 = options == null ? void 0 : options.maxBytes) != null ? _a22 : DEFAULT_MAX_DOWNLOAD_SIZE
+    });
+    const contentType = (_b22 = response.headers.get("content-type")) != null ? _b22 : void 0;
+    return new Blob([data2], contentType ? { type: contentType } : void 0);
+  } catch (error40) {
+    if (DownloadError.isInstance(error40)) {
+      throw error40;
+    }
+    throw new DownloadError({ url: url2, cause: error40 });
+  }
+}
 function isAbortError(error40) {
   return (error40 instanceof Error || error40 instanceof DOMException) && (error40.name === "AbortError" || error40.name === "ResponseAborted" || // Next.js
   error40.name === "TimeoutError");
@@ -19636,6 +20186,21 @@ async function safeParseJSON({
     };
   }
 }
+function parseJsonEventStream({
+  stream: stream2,
+  schema
+}) {
+  return stream2.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
+    new TransformStream({
+      async transform({ data: data2 }, controller) {
+        if (data2 === "[DONE]") {
+          return;
+        }
+        controller.enqueue(await safeParseJSON({ text: data2, schema }));
+      }
+    })
+  );
+}
 async function parseProviderOptions({
   provider,
   providerOptions,
@@ -19663,6 +20228,62 @@ async function resolve(value) {
   }
   return Promise.resolve(value);
 }
+function wrapResponseBodyStream({
+  stream: stream2,
+  url: url2,
+  requestBodyValues,
+  statusCode,
+  responseHeaders
+}) {
+  const reader = stream2.getReader();
+  let readerReleased = false;
+  const releaseReader = () => {
+    if (!readerReleased) {
+      reader.releaseLock();
+      readerReleased = true;
+    }
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          releaseReader();
+          controller.close();
+        } else {
+          controller.enqueue(value);
+        }
+      } catch (error40) {
+        releaseReader();
+        if (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
@@ -19681,8 +20302,8 @@ function stripFileExtension(filename) {
 function withoutTrailingSlash(url2) {
   return url2 == null ? void 0 : url2.replace(/\/$/, "");
 }
-var btoa2, atob2, name14, marker15, symbol16, _a15, _b15, DownloadError, initialGlobalFetch, initialGlobalFetchIsNodeDefault, DEFAULT_MAX_DOWNLOAD_SIZE, createIdGenerator, generateId, FETCH_FAILED_ERROR_MESSAGES, RETRYABLE_NETWORK_ERROR_CODES, VERSION, DEFAULT_SCHEMA_PREFIX, DEFAULT_SCHEMA_SUFFIX, DEFAULT_GENERIC_SUFFIX, suspectProtoRx, suspectConstructorRx, ignoreOverride, defaultOptions, getDefaultOptions, parseCatchDef, integerDateParser, isJsonSchema7AllOfType, emojiRegex2, zodPatterns, ALPHA_NUMERIC, primitiveMappings, asAnyOf, parseOptionalDef, parsePipelineDef, parseReadonlyDef, selectParser, getRelativePath, get$ref, addMeta, getRefs, zod3ToJsonSchema, schemaSymbol, getOriginalFetch2, postJsonToApi, postToApi, textDecoder, createJsonErrorResponseHandler, createJsonResponseHandler;
-var init_dist2 = __esm({
+var btoa2, atob2, name14, marker15, symbol16, _a15, _b15, DownloadError, safeNodeFetchPromise, initialGlobalFetch, initialGlobalFetchIsNodeDefault, MAX_DOWNLOAD_REDIRECTS, DEFAULT_MAX_DOWNLOAD_SIZE, createIdGenerator, generateId, FETCH_FAILED_ERROR_MESSAGES, RETRYABLE_NETWORK_ERROR_CODES, VERSION, DEFAULT_SCHEMA_PREFIX, DEFAULT_SCHEMA_SUFFIX, DEFAULT_GENERIC_SUFFIX, suspectProtoRx, suspectConstructorRx, ignoreOverride, defaultOptions, getDefaultOptions, parseCatchDef, integerDateParser, isJsonSchema7AllOfType, emojiRegex2, zodPatterns, ALPHA_NUMERIC, primitiveMappings, asAnyOf, parseOptionalDef, parsePipelineDef, parseReadonlyDef, selectParser, getRelativePath, get$ref, addMeta, getRefs, zod3ToJsonSchema, schemaSymbol, getOriginalFetch2, postJsonToApi, postFormDataToApi, postToApi, textDecoder, createJsonErrorResponseHandler, createEventSourceResponseHandler, createJsonResponseHandler;
+var init_dist3 = __esm({
   "node_modules/@ai-sdk/provider-utils/dist/index.mjs"() {
     init_dist();
     init_dist();
@@ -19695,6 +20316,7 @@ var init_dist2 = __esm({
     init_v3();
     init_v3();
     init_v3();
+    init_stream();
     init_dist();
     init_dist();
     init_dist();
@@ -19722,6 +20344,7 @@ var init_dist2 = __esm({
     };
     initialGlobalFetch = globalThis.fetch;
     initialGlobalFetchIsNodeDefault = isNodeDefaultFetch(initialGlobalFetch);
+    MAX_DOWNLOAD_REDIRECTS = 10;
     DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
     createIdGenerator = ({
       prefix,
@@ -20130,6 +20753,26 @@ var init_dist2 = __esm({
       abortSignal,
       fetch: fetch2
     });
+    postFormDataToApi = async ({
+      url: url2,
+      headers,
+      formData,
+      failedResponseHandler,
+      successfulResponseHandler,
+      abortSignal,
+      fetch: fetch2
+    }) => postToApi({
+      url: url2,
+      headers,
+      body: {
+        content: formData,
+        values: Object.fromEntries(formData.entries())
+      },
+      failedResponseHandler,
+      successfulResponseHandler,
+      abortSignal,
+      fetch: fetch2
+    });
     postToApi = async ({
       url: url2,
       headers = {},
@@ -20254,6 +20897,25 @@ var init_dist2 = __esm({
         };
       }
     };
+    createEventSourceResponseHandler = (chunkSchema) => async ({ response, url: url2, requestBodyValues }) => {
+      const responseHeaders = extractResponseHeaders(response);
+      if (response.body == null) {
+        throw new EmptyResponseBodyError({});
+      }
+      return {
+        responseHeaders,
+        value: parseJsonEventStream({
+          stream: wrapResponseBodyStream({
+            stream: response.body,
+            url: url2,
+            requestBodyValues,
+            statusCode: response.status,
+            responseHeaders
+          }),
+          schema: chunkSchema
+        })
+      };
+    };
     createJsonResponseHandler = (responseSchema) => async ({ response, url: url2, requestBodyValues }) => {
       const responseBody = await readResponseBodyAsText({ response, url: url2 });
       const parsedResult = await safeParseJSON({
@@ -20281,6 +20943,1758 @@ var init_dist2 = __esm({
   }
 });
 
+// node_modules/@ai-sdk/openai-compatible/dist/index.mjs
+function toCamelCase(str) {
+  return str.replace(/[_-]([a-z])/g, (g) => g[1].toUpperCase());
+}
+function resolveProviderOptionsKey(rawName, providerOptions) {
+  const camelName = toCamelCase(rawName);
+  if (camelName !== rawName && (providerOptions == null ? void 0 : providerOptions[camelName]) != null) {
+    return camelName;
+  }
+  return rawName;
+}
+function convertOpenAICompatibleChatUsage(usage) {
+  var _a17, _b16, _c, _d, _e, _f;
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      },
+      raw: void 0
+    };
+  }
+  const promptTokens = (_a17 = usage.prompt_tokens) != null ? _a17 : 0;
+  const completionTokens = (_b16 = usage.completion_tokens) != null ? _b16 : 0;
+  const cacheReadTokens = (_d = (_c = usage.prompt_tokens_details) == null ? void 0 : _c.cached_tokens) != null ? _d : 0;
+  const reasoningTokens = (_f = (_e = usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0;
+  return {
+    inputTokens: {
+      total: promptTokens,
+      noCache: promptTokens - cacheReadTokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: completionTokens,
+      text: Math.max(0, completionTokens - reasoningTokens),
+      reasoning: reasoningTokens
+    },
+    raw: usage
+  };
+}
+function getOpenAIMetadata(message) {
+  var _a17, _b16;
+  return (_b16 = (_a17 = message == null ? void 0 : message.providerOptions) == null ? void 0 : _a17.openaiCompatible) != null ? _b16 : {};
+}
+function getAudioFormat(mediaType) {
+  switch (mediaType) {
+    case "audio/wav":
+      return "wav";
+    case "audio/mp3":
+    case "audio/mpeg":
+      return "mp3";
+    default:
+      return null;
+  }
+}
+function convertToOpenAICompatibleChatMessages(prompt) {
+  var _a17, _b16, _c;
+  const messages = [];
+  for (const { role, content, ...message } of prompt) {
+    const metadata = getOpenAIMetadata({ ...message });
+    switch (role) {
+      case "system": {
+        messages.push({ role: "system", content, ...metadata });
+        break;
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({
+            role: "user",
+            content: content[0].text,
+            ...getOpenAIMetadata(content[0])
+          });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            var _a22;
+            const partMetadata = getOpenAIMetadata(part);
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text, ...partMetadata };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    },
+                    ...partMetadata
+                  };
+                }
+                if (part.mediaType.startsWith("audio/")) {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "audio file parts with URLs"
+                    });
+                  }
+                  const format2 = getAudioFormat(part.mediaType);
+                  if (format2 === null) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: `audio media type ${part.mediaType}`
+                    });
+                  }
+                  return {
+                    type: "input_audio",
+                    input_audio: {
+                      data: convertToBase64(part.data),
+                      format: format2
+                    },
+                    ...partMetadata
+                  };
+                }
+                if (part.mediaType === "application/pdf") {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "PDF file parts with URLs"
+                    });
+                  }
+                  return {
+                    type: "file",
+                    file: {
+                      filename: (_a22 = part.filename) != null ? _a22 : "document.pdf",
+                      file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
+                    },
+                    ...partMetadata
+                  };
+                }
+                if (part.mediaType.startsWith("text/")) {
+                  const textContent = part.data instanceof URL ? part.data.toString() : typeof part.data === "string" ? new TextDecoder().decode(
+                    convertBase64ToUint8Array(part.data)
+                  ) : new TextDecoder().decode(part.data);
+                  return {
+                    type: "text",
+                    text: textContent,
+                    ...partMetadata
+                  };
+                }
+                throw new UnsupportedFunctionalityError({
+                  functionality: `file part media type ${part.mediaType}`
+                });
+              }
+            }
+          }),
+          ...metadata
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        let reasoning = "";
+        const toolCalls = [];
+        for (const part of content) {
+          const partMetadata = getOpenAIMetadata(part);
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "reasoning": {
+              reasoning += part.text;
+              break;
+            }
+            case "tool-call": {
+              const thoughtSignature = (_b16 = (_a17 = part.providerOptions) == null ? void 0 : _a17.google) == null ? void 0 : _b16.thoughtSignature;
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                },
+                ...partMetadata,
+                // Include extra_content for Google Gemini thought signatures
+                ...thoughtSignature ? {
+                  extra_content: {
+                    google: {
+                      thought_signature: String(thoughtSignature)
+                    }
+                  }
+                } : {}
+              });
+              break;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: toolCalls.length > 0 ? text || null : text,
+          ...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+          ...metadata
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "execution-denied":
+              contentValue = (_c = output.reason) != null ? _c : "Tool call execution denied.";
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+          const toolResponseMetadata = getOpenAIMetadata(toolResponse);
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+            ...toolResponseMetadata
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return messages;
+}
+function getResponseMetadata({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id != null ? id : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
+}
+function mapOpenAICompatibleFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+function prepareTools({
+  tools: tools2,
+  toolChoice
+}) {
+  tools2 = (tools2 == null ? void 0 : tools2.length) ? tools2 : void 0;
+  const toolWarnings = [];
+  if (tools2 == null) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  const openaiCompatTools = [];
+  for (const tool6 of tools2) {
+    if (tool6.type === "provider") {
+      toolWarnings.push({
+        type: "unsupported",
+        feature: `provider-defined tool ${tool6.id}`
+      });
+    } else {
+      openaiCompatTools.push({
+        type: "function",
+        function: {
+          name: tool6.name,
+          description: tool6.description,
+          parameters: tool6.inputSchema,
+          ...tool6.strict != null ? { strict: tool6.strict } : {}
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiCompatTools, toolChoice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiCompatTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+function convertOpenAICompatibleContent(content) {
+  if (content == null) {
+    return [];
+  }
+  if (typeof content === "string") {
+    return content.length > 0 ? [{ type: "text", text: content }] : [];
+  }
+  const result = [];
+  for (const part of content) {
+    if (part.type === "text" && typeof part.text === "string") {
+      if (part.text.length > 0) {
+        result.push({ type: "text", text: part.text });
+      }
+    } else if (part.type === "thinking" && Array.isArray(part.thinking)) {
+      const reasoningText = part.thinking.filter(
+        (chunk) => chunk != null && typeof chunk === "object" && "type" in chunk && chunk.type === "text" && "text" in chunk && typeof chunk.text === "string"
+      ).map((chunk) => chunk.text).join("");
+      if (reasoningText.length > 0) {
+        result.push({ type: "reasoning", text: reasoningText });
+      }
+    }
+  }
+  return result;
+}
+function convertOpenAICompatibleCompletionUsage(usage) {
+  var _a17, _b16;
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      },
+      raw: void 0
+    };
+  }
+  const promptTokens = (_a17 = usage.prompt_tokens) != null ? _a17 : 0;
+  const completionTokens = (_b16 = usage.completion_tokens) != null ? _b16 : 0;
+  return {
+    inputTokens: {
+      total: promptTokens,
+      noCache: promptTokens,
+      cacheRead: void 0,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: completionTokens,
+      text: completionTokens,
+      reasoning: void 0
+    },
+    raw: usage
+  };
+}
+function convertToOpenAICompatibleCompletionPrompt({
+  prompt,
+  user = "user",
+  assistant = "assistant"
+}) {
+  let text = "";
+  if (prompt[0].role === "system") {
+    text += `${prompt[0].content}
+
+`;
+    prompt = prompt.slice(1);
+  }
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        throw new InvalidPromptError({
+          message: "Unexpected system message in prompt: ${content}",
+          prompt
+        });
+      }
+      case "user": {
+        const userMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+          }
+        }).filter(Boolean).join("");
+        text += `${user}:
+${userMessage}
+
+`;
+        break;
+      }
+      case "assistant": {
+        const assistantMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+            case "tool-call": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "tool-call messages"
+              });
+            }
+          }
+        }).join("");
+        text += `${assistant}:
+${assistantMessage}
+
+`;
+        break;
+      }
+      case "tool": {
+        throw new UnsupportedFunctionalityError({
+          functionality: "tool messages"
+        });
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  text += `${assistant}:
+`;
+  return {
+    prompt: text,
+    stopSequences: [`
+${user}:`]
+  };
+}
+function getResponseMetadata2({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id != null ? id : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
+}
+function mapOpenAICompatibleFinishReason2(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+async function fileToBlob(file2) {
+  if (file2.type === "url") {
+    return downloadBlob(file2.url);
+  }
+  const data2 = file2.data instanceof Uint8Array ? file2.data : convertBase64ToUint8Array(file2.data);
+  return new Blob([data2], { type: file2.mediaType });
+}
+function createOpenAICompatible(options) {
+  const baseURL = withoutTrailingSlash(options.baseURL);
+  const providerName = options.name;
+  const headers = {
+    ...options.apiKey && { Authorization: `Bearer ${options.apiKey}` },
+    ...options.headers
+  };
+  const getHeaders = () => withUserAgentSuffix(headers, `ai-sdk/openai-compatible/${VERSION2}`);
+  const getCommonModelConfig = (modelType) => ({
+    provider: `${providerName}.${modelType}`,
+    url: ({ path: path9 }) => {
+      const url2 = new URL(`${baseURL}${path9}`);
+      if (options.queryParams) {
+        url2.search = new URLSearchParams(options.queryParams).toString();
+      }
+      return url2.toString();
+    },
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createLanguageModel2 = (modelId) => createChatModel(modelId);
+  const createChatModel = (modelId) => new OpenAICompatibleChatLanguageModel(modelId, {
+    ...getCommonModelConfig("chat"),
+    includeUsage: options.includeUsage,
+    supportsStructuredOutputs: options.supportsStructuredOutputs,
+    supportedUrls: options.supportedUrls,
+    transformRequestBody: options.transformRequestBody,
+    metadataExtractor: options.metadataExtractor,
+    convertUsage: options.convertUsage
+  });
+  const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(modelId, {
+    ...getCommonModelConfig("completion"),
+    includeUsage: options.includeUsage
+  });
+  const createEmbeddingModel = (modelId) => new OpenAICompatibleEmbeddingModel(modelId, {
+    ...getCommonModelConfig("embedding")
+  });
+  const createImageModel = (modelId) => new OpenAICompatibleImageModel(modelId, getCommonModelConfig("image"));
+  const provider = (modelId) => createLanguageModel2(modelId);
+  provider.specificationVersion = "v3";
+  provider.languageModel = createLanguageModel2;
+  provider.chatModel = createChatModel;
+  provider.completionModel = createCompletionModel;
+  provider.embeddingModel = createEmbeddingModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.imageModel = createImageModel;
+  return provider;
+}
+var openaiCompatibleErrorDataSchema, defaultOpenAICompatibleErrorStructure, openaiCompatibleLanguageModelChatOptions, OpenAICompatibleChatLanguageModel, openaiCompatibleTokenUsageSchema, openAICompatibleContentSchema, OpenAICompatibleChatResponseSchema, chunkBaseSchema, createOpenAICompatibleChatChunkSchema, openaiCompatibleLanguageModelCompletionOptions, OpenAICompatibleCompletionLanguageModel, usageSchema, openaiCompatibleCompletionResponseSchema, createOpenAICompatibleCompletionChunkSchema, openaiCompatibleEmbeddingModelOptions, OpenAICompatibleEmbeddingModel, openaiTextEmbeddingResponseSchema, OpenAICompatibleImageModel, openaiCompatibleImageResponseSchema, VERSION2;
+var init_dist4 = __esm({
+  "node_modules/@ai-sdk/openai-compatible/dist/index.mjs"() {
+    init_dist();
+    init_dist3();
+    init_v4();
+    init_v4();
+    init_dist();
+    init_dist3();
+    init_v4();
+    init_dist();
+    init_dist3();
+    init_v4();
+    init_dist();
+    init_v4();
+    init_dist();
+    init_dist3();
+    init_v4();
+    init_v4();
+    init_dist3();
+    init_v4();
+    init_dist3();
+    openaiCompatibleErrorDataSchema = external_exports.object({
+      error: external_exports.object({
+        message: external_exports.string(),
+        // The additional information below is handled loosely to support
+        // OpenAI-compatible providers that have slightly different error
+        // responses:
+        type: external_exports.string().nullish(),
+        param: external_exports.any().nullish(),
+        code: external_exports.union([external_exports.string(), external_exports.number()]).nullish()
+      })
+    });
+    defaultOpenAICompatibleErrorStructure = {
+      errorSchema: openaiCompatibleErrorDataSchema,
+      errorToMessage: (data2) => data2.error.message
+    };
+    openaiCompatibleLanguageModelChatOptions = external_exports.object({
+      /**
+       * A unique identifier representing your end-user, which can help the provider to
+       * monitor and detect abuse.
+       */
+      user: external_exports.string().optional(),
+      /**
+       * Reasoning effort for reasoning models. Defaults to `medium`.
+       */
+      reasoningEffort: external_exports.string().optional(),
+      /**
+       * Controls the verbosity of the generated text. Defaults to `medium`.
+       */
+      textVerbosity: external_exports.string().optional(),
+      /**
+       * Whether to use strict JSON schema validation.
+       * When true, the model uses constrained decoding to guarantee schema compliance.
+       * Only used when the provider supports structured outputs and a schema is provided.
+       *
+       * @default true
+       */
+      strictJsonSchema: external_exports.boolean().optional()
+    });
+    OpenAICompatibleChatLanguageModel = class {
+      // type inferred via constructor
+      constructor(modelId, config2) {
+        this.specificationVersion = "v3";
+        var _a17, _b16;
+        this.modelId = modelId;
+        this.config = config2;
+        const errorStructure = (_a17 = config2.errorStructure) != null ? _a17 : defaultOpenAICompatibleErrorStructure;
+        this.chunkSchema = createOpenAICompatibleChatChunkSchema(
+          errorStructure.errorSchema
+        );
+        this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
+        this.supportsStructuredOutputs = (_b16 = config2.supportsStructuredOutputs) != null ? _b16 : false;
+      }
+      get provider() {
+        return this.config.provider;
+      }
+      get providerOptionsName() {
+        return this.config.provider.split(".")[0].trim();
+      }
+      get supportedUrls() {
+        var _a17, _b16, _c;
+        return (_c = (_b16 = (_a17 = this.config).supportedUrls) == null ? void 0 : _b16.call(_a17)) != null ? _c : {};
+      }
+      transformRequestBody(args) {
+        var _a17, _b16, _c;
+        return (_c = (_b16 = (_a17 = this.config).transformRequestBody) == null ? void 0 : _b16.call(_a17, args)) != null ? _c : args;
+      }
+      convertUsage(usage) {
+        var _a17, _b16, _c;
+        return (_c = (_b16 = (_a17 = this.config).convertUsage) == null ? void 0 : _b16.call(_a17, usage)) != null ? _c : convertOpenAICompatibleChatUsage(usage);
+      }
+      async getArgs({
+        prompt,
+        maxOutputTokens,
+        temperature,
+        topP,
+        topK,
+        frequencyPenalty,
+        presencePenalty,
+        providerOptions,
+        stopSequences,
+        responseFormat,
+        seed,
+        toolChoice,
+        tools: tools2
+      }) {
+        var _a17, _b16, _c, _d, _e;
+        const warnings = [];
+        const deprecatedOptions = await parseProviderOptions({
+          provider: "openai-compatible",
+          providerOptions,
+          schema: openaiCompatibleLanguageModelChatOptions
+        });
+        if (deprecatedOptions != null) {
+          warnings.push({
+            type: "other",
+            message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
+          });
+        }
+        const compatibleOptions = Object.assign(
+          deprecatedOptions != null ? deprecatedOptions : {},
+          (_a17 = await parseProviderOptions({
+            provider: "openaiCompatible",
+            providerOptions,
+            schema: openaiCompatibleLanguageModelChatOptions
+          })) != null ? _a17 : {},
+          (_b16 = await parseProviderOptions({
+            provider: this.providerOptionsName,
+            providerOptions,
+            schema: openaiCompatibleLanguageModelChatOptions
+          })) != null ? _b16 : {},
+          (_c = await parseProviderOptions({
+            provider: toCamelCase(this.providerOptionsName),
+            providerOptions,
+            schema: openaiCompatibleLanguageModelChatOptions
+          })) != null ? _c : {}
+        );
+        const strictJsonSchema = (_d = compatibleOptions == null ? void 0 : compatibleOptions.strictJsonSchema) != null ? _d : true;
+        if (topK != null) {
+          warnings.push({ type: "unsupported", feature: "topK" });
+        }
+        if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
+          warnings.push({
+            type: "unsupported",
+            feature: "responseFormat",
+            details: "JSON response format schema is only supported with structuredOutputs"
+          });
+        }
+        const {
+          tools: openaiTools,
+          toolChoice: openaiToolChoice,
+          toolWarnings
+        } = prepareTools({
+          tools: tools2,
+          toolChoice
+        });
+        const metadataKey = resolveProviderOptionsKey(
+          this.providerOptionsName,
+          providerOptions
+        );
+        return {
+          metadataKey,
+          args: {
+            // model id:
+            model: this.modelId,
+            // model specific settings:
+            user: compatibleOptions.user,
+            // standardized settings:
+            max_tokens: maxOutputTokens,
+            temperature,
+            top_p: topP,
+            frequency_penalty: frequencyPenalty,
+            presence_penalty: presencePenalty,
+            response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
+              type: "json_schema",
+              json_schema: {
+                schema: responseFormat.schema,
+                strict: strictJsonSchema,
+                name: (_e = responseFormat.name) != null ? _e : "response",
+                description: responseFormat.description
+              }
+            } : { type: "json_object" } : void 0,
+            stop: stopSequences,
+            seed,
+            ...Object.fromEntries(
+              Object.entries({
+                ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
+                ...providerOptions == null ? void 0 : providerOptions[toCamelCase(this.providerOptionsName)]
+              }).filter(
+                ([key]) => !Object.keys(
+                  openaiCompatibleLanguageModelChatOptions.shape
+                ).includes(key)
+              )
+            ),
+            reasoning_effort: compatibleOptions.reasoningEffort,
+            verbosity: compatibleOptions.textVerbosity,
+            // messages:
+            messages: convertToOpenAICompatibleChatMessages(prompt),
+            // tools:
+            tools: openaiTools,
+            tool_choice: openaiToolChoice
+          },
+          warnings: [...warnings, ...toolWarnings]
+        };
+      }
+      async doGenerate(options) {
+        var _a17, _b16, _c, _d, _e, _f, _g, _h;
+        const { args, warnings, metadataKey } = await this.getArgs({ ...options });
+        const transformedBody = this.transformRequestBody(args);
+        const body = JSON.stringify(transformedBody);
+        const {
+          responseHeaders,
+          value: responseBody,
+          rawValue: rawResponse
+        } = await postJsonToApi({
+          url: this.config.url({
+            path: "/chat/completions",
+            modelId: this.modelId
+          }),
+          headers: combineHeaders(this.config.headers(), options.headers),
+          body: transformedBody,
+          failedResponseHandler: this.failedResponseHandler,
+          successfulResponseHandler: createJsonResponseHandler(
+            OpenAICompatibleChatResponseSchema
+          ),
+          abortSignal: options.abortSignal,
+          fetch: this.config.fetch
+        });
+        const choice = responseBody.choices[0];
+        const content = [];
+        content.push(...convertOpenAICompatibleContent(choice.message.content));
+        const reasoning = (_a17 = choice.message.reasoning_content) != null ? _a17 : choice.message.reasoning;
+        if (reasoning != null && reasoning.length > 0) {
+          content.push({
+            type: "reasoning",
+            text: reasoning
+          });
+        }
+        if (choice.message.tool_calls != null) {
+          for (const toolCall of choice.message.tool_calls) {
+            const thoughtSignature = (_c = (_b16 = toolCall.extra_content) == null ? void 0 : _b16.google) == null ? void 0 : _c.thought_signature;
+            content.push({
+              type: "tool-call",
+              toolCallId: (_d = toolCall.id) != null ? _d : generateId(),
+              toolName: toolCall.function.name,
+              input: toolCall.function.arguments,
+              ...thoughtSignature ? {
+                providerMetadata: {
+                  [metadataKey]: { thoughtSignature }
+                }
+              } : {}
+            });
+          }
+        }
+        const providerMetadata = {
+          [metadataKey]: {},
+          ...await ((_f = (_e = this.config.metadataExtractor) == null ? void 0 : _e.extractMetadata) == null ? void 0 : _f.call(_e, {
+            parsedBody: rawResponse
+          }))
+        };
+        const completionTokenDetails = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens_details;
+        if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
+          providerMetadata[metadataKey].acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
+        }
+        if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
+          providerMetadata[metadataKey].rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
+        }
+        return {
+          content,
+          finishReason: {
+            unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+            raw: (_h = choice.finish_reason) != null ? _h : void 0
+          },
+          usage: this.convertUsage(responseBody.usage),
+          providerMetadata,
+          request: { body },
+          response: {
+            ...getResponseMetadata(responseBody),
+            headers: responseHeaders,
+            body: rawResponse
+          },
+          warnings
+        };
+      }
+      async doStream(options) {
+        var _a17;
+        const { args, warnings, metadataKey } = await this.getArgs({ ...options });
+        const body = this.transformRequestBody({
+          ...args,
+          stream: true,
+          // only include stream_options when in strict compatibility mode:
+          stream_options: this.config.includeUsage ? { include_usage: true } : void 0
+        });
+        const metadataExtractor = (_a17 = this.config.metadataExtractor) == null ? void 0 : _a17.createStreamExtractor();
+        const { responseHeaders, value: response } = await postJsonToApi({
+          url: this.config.url({
+            path: "/chat/completions",
+            modelId: this.modelId
+          }),
+          headers: combineHeaders(this.config.headers(), options.headers),
+          body,
+          failedResponseHandler: this.failedResponseHandler,
+          successfulResponseHandler: createEventSourceResponseHandler(
+            this.chunkSchema
+          ),
+          abortSignal: options.abortSignal,
+          fetch: this.config.fetch
+        });
+        const toolCalls = [];
+        const pendingToolCalls = /* @__PURE__ */ new Map();
+        let finishReason;
+        let usage = void 0;
+        let isFirstChunk = true;
+        const providerOptionsName = metadataKey;
+        let isActiveReasoning = false;
+        let isActiveText = false;
+        const convertUsage = (usage2) => this.convertUsage(usage2);
+        return {
+          stream: response.pipeThrough(
+            new TransformStream({
+              start(controller) {
+                controller.enqueue({ type: "stream-start", warnings });
+              },
+              transform(chunk, controller) {
+                var _a22, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
+                if (options.includeRawChunks) {
+                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+                }
+                if (!chunk.success) {
+                  finishReason = { unified: "error", raw: void 0 };
+                  controller.enqueue({ type: "error", error: chunk.error });
+                  return;
+                }
+                metadataExtractor == null ? void 0 : metadataExtractor.processChunk(chunk.rawValue);
+                if ("error" in chunk.value) {
+                  finishReason = { unified: "error", raw: void 0 };
+                  controller.enqueue({
+                    type: "error",
+                    error: chunk.value.error
+                  });
+                  return;
+                }
+                const value = chunk.value;
+                if (isFirstChunk) {
+                  isFirstChunk = false;
+                  controller.enqueue({
+                    type: "response-metadata",
+                    ...getResponseMetadata(value)
+                  });
+                }
+                if (value.usage != null) {
+                  usage = value.usage;
+                }
+                const choice = value.choices[0];
+                if ((choice == null ? void 0 : choice.finish_reason) != null) {
+                  finishReason = {
+                    unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+                    raw: (_a22 = choice.finish_reason) != null ? _a22 : void 0
+                  };
+                }
+                if ((choice == null ? void 0 : choice.delta) == null) {
+                  return;
+                }
+                const delta = choice.delta;
+                const enqueueReasoningDelta = (reasoningDelta) => {
+                  if (isActiveText) {
+                    controller.enqueue({ type: "text-end", id: "txt-0" });
+                    isActiveText = false;
+                  }
+                  if (!isActiveReasoning) {
+                    controller.enqueue({
+                      type: "reasoning-start",
+                      id: "reasoning-0"
+                    });
+                    isActiveReasoning = true;
+                  }
+                  controller.enqueue({
+                    type: "reasoning-delta",
+                    id: "reasoning-0",
+                    delta: reasoningDelta
+                  });
+                };
+                const enqueueTextDelta = (textDelta) => {
+                  if (isActiveReasoning) {
+                    controller.enqueue({
+                      type: "reasoning-end",
+                      id: "reasoning-0"
+                    });
+                    isActiveReasoning = false;
+                  }
+                  if (!isActiveText) {
+                    controller.enqueue({ type: "text-start", id: "txt-0" });
+                    isActiveText = true;
+                  }
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: "txt-0",
+                    delta: textDelta
+                  });
+                };
+                const reasoningContent = (_b16 = delta.reasoning_content) != null ? _b16 : delta.reasoning;
+                if (reasoningContent) {
+                  enqueueReasoningDelta(reasoningContent);
+                }
+                for (const contentPart of convertOpenAICompatibleContent(
+                  delta.content
+                )) {
+                  if (contentPart.type === "reasoning") {
+                    enqueueReasoningDelta(contentPart.text);
+                  } else {
+                    enqueueTextDelta(contentPart.text);
+                  }
+                }
+                if (delta.tool_calls != null) {
+                  if (isActiveReasoning) {
+                    controller.enqueue({
+                      type: "reasoning-end",
+                      id: "reasoning-0"
+                    });
+                    isActiveReasoning = false;
+                  }
+                  for (const toolCallDelta of delta.tool_calls) {
+                    const index = (_c = toolCallDelta.index) != null ? _c : toolCalls.length;
+                    if (toolCalls[index] == null) {
+                      if (toolCallDelta.index != null) {
+                        let pending = pendingToolCalls.get(index);
+                        if (pending == null) {
+                          pending = {
+                            id: (_d = toolCallDelta.id) != null ? _d : null,
+                            bufferedArguments: "",
+                            thoughtSignature: (_g = (_f = (_e = toolCallDelta.extra_content) == null ? void 0 : _e.google) == null ? void 0 : _f.thought_signature) != null ? _g : void 0
+                          };
+                          pendingToolCalls.set(index, pending);
+                        } else {
+                          if (pending.id == null && toolCallDelta.id != null) {
+                            pending.id = toolCallDelta.id;
+                          }
+                          if (pending.thoughtSignature == null && ((_i = (_h = toolCallDelta.extra_content) == null ? void 0 : _h.google) == null ? void 0 : _i.thought_signature) != null) {
+                            pending.thoughtSignature = toolCallDelta.extra_content.google.thought_signature;
+                          }
+                        }
+                        const argumentsDelta = (_j = toolCallDelta.function) == null ? void 0 : _j.arguments;
+                        if (argumentsDelta != null) {
+                          pending.bufferedArguments += argumentsDelta;
+                        }
+                        const name15 = (_k = toolCallDelta.function) == null ? void 0 : _k.name;
+                        if (name15 == null) {
+                          continue;
+                        }
+                        pendingToolCalls.delete(index);
+                        if (pending.id == null) {
+                          throw new InvalidResponseDataError({
+                            data: toolCallDelta,
+                            message: `Expected 'id' to be a string.`
+                          });
+                        }
+                        controller.enqueue({
+                          type: "tool-input-start",
+                          id: pending.id,
+                          toolName: name15
+                        });
+                        toolCalls[index] = {
+                          id: pending.id,
+                          type: "function",
+                          function: {
+                            name: name15,
+                            arguments: pending.bufferedArguments
+                          },
+                          hasFinished: false,
+                          thoughtSignature: pending.thoughtSignature
+                        };
+                      } else {
+                        if (toolCallDelta.id == null) {
+                          throw new InvalidResponseDataError({
+                            data: toolCallDelta,
+                            message: `Expected 'id' to be a string.`
+                          });
+                        }
+                        if (((_l = toolCallDelta.function) == null ? void 0 : _l.name) == null) {
+                          throw new InvalidResponseDataError({
+                            data: toolCallDelta,
+                            message: `Expected 'function.name' to be a string.`
+                          });
+                        }
+                        controller.enqueue({
+                          type: "tool-input-start",
+                          id: toolCallDelta.id,
+                          toolName: toolCallDelta.function.name
+                        });
+                        toolCalls[index] = {
+                          id: toolCallDelta.id,
+                          type: "function",
+                          function: {
+                            name: toolCallDelta.function.name,
+                            arguments: (_m = toolCallDelta.function.arguments) != null ? _m : ""
+                          },
+                          hasFinished: false,
+                          thoughtSignature: (_p = (_o = (_n = toolCallDelta.extra_content) == null ? void 0 : _n.google) == null ? void 0 : _o.thought_signature) != null ? _p : void 0
+                        };
+                      }
+                      const toolCall2 = toolCalls[index];
+                      if (((_q = toolCall2.function) == null ? void 0 : _q.name) != null && ((_r = toolCall2.function) == null ? void 0 : _r.arguments) != null) {
+                        if (toolCall2.function.arguments.length > 0) {
+                          controller.enqueue({
+                            type: "tool-input-delta",
+                            id: toolCall2.id,
+                            delta: toolCall2.function.arguments
+                          });
+                        }
+                      }
+                      continue;
+                    }
+                    const toolCall = toolCalls[index];
+                    if (toolCall.hasFinished) {
+                      continue;
+                    }
+                    if (((_s = toolCallDelta.function) == null ? void 0 : _s.arguments) != null) {
+                      toolCall.function.arguments += (_u = (_t = toolCallDelta.function) == null ? void 0 : _t.arguments) != null ? _u : "";
+                    }
+                    controller.enqueue({
+                      type: "tool-input-delta",
+                      id: toolCall.id,
+                      delta: (_v = toolCallDelta.function.arguments) != null ? _v : ""
+                    });
+                  }
+                }
+              },
+              flush(controller) {
+                var _a22, _b16, _c, _d, _e;
+                if (isActiveReasoning) {
+                  controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+                }
+                if (isActiveText) {
+                  controller.enqueue({ type: "text-end", id: "txt-0" });
+                }
+                for (const [index, pending] of pendingToolCalls) {
+                  throw new InvalidResponseDataError({
+                    data: {
+                      index,
+                      id: pending.id,
+                      function: { arguments: pending.bufferedArguments }
+                    },
+                    message: `Expected 'function.name' to be a string.`
+                  });
+                }
+                for (const toolCall of toolCalls.filter(
+                  (toolCall2) => !toolCall2.hasFinished
+                )) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.id
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: (_a22 = toolCall.id) != null ? _a22 : generateId(),
+                    toolName: toolCall.function.name,
+                    input: toolCall.function.arguments,
+                    ...toolCall.thoughtSignature ? {
+                      providerMetadata: {
+                        [providerOptionsName]: {
+                          thoughtSignature: toolCall.thoughtSignature
+                        }
+                      }
+                    } : {}
+                  });
+                }
+                if (finishReason == null) {
+                  finishReason = { unified: "error", raw: void 0 };
+                  controller.enqueue({
+                    type: "error",
+                    error: new InvalidResponseDataError({
+                      data: void 0,
+                      message: "Response stream ended without a finish reason."
+                    })
+                  });
+                }
+                const providerMetadata = {
+                  [providerOptionsName]: {},
+                  ...metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata()
+                };
+                if (((_b16 = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _b16.accepted_prediction_tokens) != null) {
+                  providerMetadata[providerOptionsName].acceptedPredictionTokens = (_c = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _c.accepted_prediction_tokens;
+                }
+                if (((_d = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _d.rejected_prediction_tokens) != null) {
+                  providerMetadata[providerOptionsName].rejectedPredictionTokens = (_e = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _e.rejected_prediction_tokens;
+                }
+                controller.enqueue({
+                  type: "finish",
+                  finishReason,
+                  usage: convertUsage(usage),
+                  providerMetadata
+                });
+              }
+            })
+          ),
+          request: { body },
+          response: { headers: responseHeaders }
+        };
+      }
+    };
+    openaiCompatibleTokenUsageSchema = external_exports.looseObject({
+      prompt_tokens: external_exports.number().nullish(),
+      completion_tokens: external_exports.number().nullish(),
+      total_tokens: external_exports.number().nullish(),
+      prompt_tokens_details: external_exports.looseObject({
+        cached_tokens: external_exports.number().nullish()
+      }).nullish(),
+      completion_tokens_details: external_exports.looseObject({
+        reasoning_tokens: external_exports.number().nullish(),
+        accepted_prediction_tokens: external_exports.number().nullish(),
+        rejected_prediction_tokens: external_exports.number().nullish()
+      }).nullish()
+    }).nullish();
+    openAICompatibleContentSchema = external_exports.union([
+      external_exports.string(),
+      external_exports.array(
+        external_exports.looseObject({
+          type: external_exports.string()
+        })
+      )
+    ]).nullish();
+    OpenAICompatibleChatResponseSchema = external_exports.looseObject({
+      id: external_exports.string().nullish(),
+      created: external_exports.number().nullish(),
+      model: external_exports.string().nullish(),
+      choices: external_exports.array(
+        external_exports.object({
+          message: external_exports.object({
+            role: external_exports.literal("assistant").nullish(),
+            content: openAICompatibleContentSchema,
+            reasoning_content: external_exports.string().nullish(),
+            reasoning: external_exports.string().nullish(),
+            tool_calls: external_exports.array(
+              external_exports.object({
+                id: external_exports.string().nullish(),
+                function: external_exports.object({
+                  name: external_exports.string(),
+                  arguments: external_exports.string()
+                }),
+                // Support for Google Gemini thought signatures via OpenAI compatibility
+                extra_content: external_exports.object({
+                  google: external_exports.object({
+                    thought_signature: external_exports.string().nullish()
+                  }).nullish()
+                }).nullish()
+              })
+            ).nullish()
+          }),
+          finish_reason: external_exports.string().nullish()
+        })
+      ),
+      usage: openaiCompatibleTokenUsageSchema
+    });
+    chunkBaseSchema = external_exports.looseObject({
+      id: external_exports.string().nullish(),
+      created: external_exports.number().nullish(),
+      model: external_exports.string().nullish(),
+      choices: external_exports.array(
+        external_exports.object({
+          delta: external_exports.object({
+            role: external_exports.enum(["assistant", ""]).nullish(),
+            content: openAICompatibleContentSchema,
+            // Most openai-compatible models set `reasoning_content`, but some
+            // providers serving `gpt-oss` set `reasoning`. See #7866
+            reasoning_content: external_exports.string().nullish(),
+            reasoning: external_exports.string().nullish(),
+            tool_calls: external_exports.array(
+              external_exports.object({
+                index: external_exports.number().nullish(),
+                //google does not send index
+                id: external_exports.string().nullish(),
+                function: external_exports.object({
+                  name: external_exports.string().nullish(),
+                  arguments: external_exports.string().nullish()
+                }),
+                // Support for Google Gemini thought signatures via OpenAI compatibility
+                extra_content: external_exports.object({
+                  google: external_exports.object({
+                    thought_signature: external_exports.string().nullish()
+                  }).nullish()
+                }).nullish()
+              })
+            ).nullish()
+          }).nullish(),
+          finish_reason: external_exports.string().nullish()
+        })
+      ),
+      usage: openaiCompatibleTokenUsageSchema
+    });
+    createOpenAICompatibleChatChunkSchema = (errorSchema) => external_exports.union([chunkBaseSchema, errorSchema]);
+    openaiCompatibleLanguageModelCompletionOptions = external_exports.object({
+      /**
+       * Echo back the prompt in addition to the completion.
+       */
+      echo: external_exports.boolean().optional(),
+      /**
+       * Modify the likelihood of specified tokens appearing in the completion.
+       *
+       * Accepts a JSON object that maps tokens (specified by their token ID in
+       * the GPT tokenizer) to an associated bias value from -100 to 100.
+       */
+      logitBias: external_exports.record(external_exports.string(), external_exports.number()).optional(),
+      /**
+       * The suffix that comes after a completion of inserted text.
+       */
+      suffix: external_exports.string().optional(),
+      /**
+       * A unique identifier representing your end-user, which can help providers to
+       * monitor and detect abuse.
+       */
+      user: external_exports.string().optional()
+    });
+    OpenAICompatibleCompletionLanguageModel = class {
+      // type inferred via constructor
+      constructor(modelId, config2) {
+        this.specificationVersion = "v3";
+        var _a17;
+        this.modelId = modelId;
+        this.config = config2;
+        const errorStructure = (_a17 = config2.errorStructure) != null ? _a17 : defaultOpenAICompatibleErrorStructure;
+        this.chunkSchema = createOpenAICompatibleCompletionChunkSchema(
+          errorStructure.errorSchema
+        );
+        this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
+      }
+      get provider() {
+        return this.config.provider;
+      }
+      get providerOptionsName() {
+        return this.config.provider.split(".")[0].trim();
+      }
+      get supportedUrls() {
+        var _a17, _b16, _c;
+        return (_c = (_b16 = (_a17 = this.config).supportedUrls) == null ? void 0 : _b16.call(_a17)) != null ? _c : {};
+      }
+      async getArgs({
+        prompt,
+        maxOutputTokens,
+        temperature,
+        topP,
+        topK,
+        frequencyPenalty,
+        presencePenalty,
+        stopSequences: userStopSequences,
+        responseFormat,
+        seed,
+        providerOptions,
+        tools: tools2,
+        toolChoice
+      }) {
+        var _a17, _b16;
+        const warnings = [];
+        const completionOptions = Object.assign(
+          (_a17 = await parseProviderOptions({
+            provider: this.providerOptionsName,
+            providerOptions,
+            schema: openaiCompatibleLanguageModelCompletionOptions
+          })) != null ? _a17 : {},
+          (_b16 = await parseProviderOptions({
+            provider: toCamelCase(this.providerOptionsName),
+            providerOptions,
+            schema: openaiCompatibleLanguageModelCompletionOptions
+          })) != null ? _b16 : {}
+        );
+        if (topK != null) {
+          warnings.push({ type: "unsupported", feature: "topK" });
+        }
+        if (tools2 == null ? void 0 : tools2.length) {
+          warnings.push({ type: "unsupported", feature: "tools" });
+        }
+        if (toolChoice != null) {
+          warnings.push({ type: "unsupported", feature: "toolChoice" });
+        }
+        if (responseFormat != null && responseFormat.type !== "text") {
+          warnings.push({
+            type: "unsupported",
+            feature: "responseFormat",
+            details: "JSON response format is not supported."
+          });
+        }
+        const { prompt: completionPrompt, stopSequences } = convertToOpenAICompatibleCompletionPrompt({ prompt });
+        const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
+        return {
+          args: {
+            // model id:
+            model: this.modelId,
+            // model specific settings:
+            echo: completionOptions.echo,
+            logit_bias: completionOptions.logitBias,
+            suffix: completionOptions.suffix,
+            user: completionOptions.user,
+            // standardized settings:
+            max_tokens: maxOutputTokens,
+            temperature,
+            top_p: topP,
+            frequency_penalty: frequencyPenalty,
+            presence_penalty: presencePenalty,
+            seed,
+            ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
+            ...providerOptions == null ? void 0 : providerOptions[toCamelCase(this.providerOptionsName)],
+            // prompt:
+            prompt: completionPrompt,
+            // stop sequences:
+            stop: stop.length > 0 ? stop : void 0
+          },
+          warnings
+        };
+      }
+      async doGenerate(options) {
+        const { args, warnings } = await this.getArgs(options);
+        const {
+          responseHeaders,
+          value: response,
+          rawValue: rawResponse
+        } = await postJsonToApi({
+          url: this.config.url({
+            path: "/completions",
+            modelId: this.modelId
+          }),
+          headers: combineHeaders(this.config.headers(), options.headers),
+          body: args,
+          failedResponseHandler: this.failedResponseHandler,
+          successfulResponseHandler: createJsonResponseHandler(
+            openaiCompatibleCompletionResponseSchema
+          ),
+          abortSignal: options.abortSignal,
+          fetch: this.config.fetch
+        });
+        const choice = response.choices[0];
+        const content = [];
+        if (choice.text != null && choice.text.length > 0) {
+          content.push({ type: "text", text: choice.text });
+        }
+        return {
+          content,
+          usage: convertOpenAICompatibleCompletionUsage(response.usage),
+          finishReason: {
+            unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+            raw: choice.finish_reason
+          },
+          request: { body: args },
+          response: {
+            ...getResponseMetadata2(response),
+            headers: responseHeaders,
+            body: rawResponse
+          },
+          warnings
+        };
+      }
+      async doStream(options) {
+        const { args, warnings } = await this.getArgs(options);
+        const body = {
+          ...args,
+          stream: true,
+          // only include stream_options when in strict compatibility mode:
+          stream_options: this.config.includeUsage ? { include_usage: true } : void 0
+        };
+        const { responseHeaders, value: response } = await postJsonToApi({
+          url: this.config.url({
+            path: "/completions",
+            modelId: this.modelId
+          }),
+          headers: combineHeaders(this.config.headers(), options.headers),
+          body,
+          failedResponseHandler: this.failedResponseHandler,
+          successfulResponseHandler: createEventSourceResponseHandler(
+            this.chunkSchema
+          ),
+          abortSignal: options.abortSignal,
+          fetch: this.config.fetch
+        });
+        let finishReason = {
+          unified: "other",
+          raw: void 0
+        };
+        let usage = void 0;
+        let isFirstChunk = true;
+        return {
+          stream: response.pipeThrough(
+            new TransformStream({
+              start(controller) {
+                controller.enqueue({ type: "stream-start", warnings });
+              },
+              transform(chunk, controller) {
+                var _a17;
+                if (options.includeRawChunks) {
+                  controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+                }
+                if (!chunk.success) {
+                  finishReason = { unified: "error", raw: void 0 };
+                  controller.enqueue({ type: "error", error: chunk.error });
+                  return;
+                }
+                const value = chunk.value;
+                if ("error" in value) {
+                  finishReason = { unified: "error", raw: void 0 };
+                  controller.enqueue({ type: "error", error: value.error });
+                  return;
+                }
+                if (isFirstChunk) {
+                  isFirstChunk = false;
+                  controller.enqueue({
+                    type: "response-metadata",
+                    ...getResponseMetadata2(value)
+                  });
+                  controller.enqueue({
+                    type: "text-start",
+                    id: "0"
+                  });
+                }
+                if (value.usage != null) {
+                  usage = value.usage;
+                }
+                const choice = value.choices[0];
+                if ((choice == null ? void 0 : choice.finish_reason) != null) {
+                  finishReason = {
+                    unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+                    raw: (_a17 = choice.finish_reason) != null ? _a17 : void 0
+                  };
+                }
+                if ((choice == null ? void 0 : choice.text) != null) {
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: "0",
+                    delta: choice.text
+                  });
+                }
+              },
+              flush(controller) {
+                if (!isFirstChunk) {
+                  controller.enqueue({ type: "text-end", id: "0" });
+                }
+                controller.enqueue({
+                  type: "finish",
+                  finishReason,
+                  usage: convertOpenAICompatibleCompletionUsage(usage)
+                });
+              }
+            })
+          ),
+          request: { body },
+          response: { headers: responseHeaders }
+        };
+      }
+    };
+    usageSchema = external_exports.looseObject({
+      prompt_tokens: external_exports.number(),
+      completion_tokens: external_exports.number(),
+      total_tokens: external_exports.number()
+    });
+    openaiCompatibleCompletionResponseSchema = external_exports.object({
+      id: external_exports.string().nullish(),
+      created: external_exports.number().nullish(),
+      model: external_exports.string().nullish(),
+      choices: external_exports.array(
+        external_exports.object({
+          text: external_exports.string(),
+          finish_reason: external_exports.string()
+        })
+      ),
+      usage: usageSchema.nullish()
+    });
+    createOpenAICompatibleCompletionChunkSchema = (errorSchema) => external_exports.union([
+      external_exports.object({
+        id: external_exports.string().nullish(),
+        created: external_exports.number().nullish(),
+        model: external_exports.string().nullish(),
+        choices: external_exports.array(
+          external_exports.object({
+            text: external_exports.string(),
+            finish_reason: external_exports.string().nullish(),
+            index: external_exports.number()
+          })
+        ),
+        usage: usageSchema.nullish()
+      }),
+      errorSchema
+    ]);
+    openaiCompatibleEmbeddingModelOptions = external_exports.object({
+      /**
+       * The number of dimensions the resulting output embeddings should have.
+       * Only supported in text-embedding-3 and later models.
+       */
+      dimensions: external_exports.number().optional(),
+      /**
+       * A unique identifier representing your end-user, which can help providers to
+       * monitor and detect abuse.
+       */
+      user: external_exports.string().optional()
+    });
+    OpenAICompatibleEmbeddingModel = class {
+      constructor(modelId, config2) {
+        this.specificationVersion = "v3";
+        this.modelId = modelId;
+        this.config = config2;
+      }
+      get provider() {
+        return this.config.provider;
+      }
+      get maxEmbeddingsPerCall() {
+        var _a17;
+        return (_a17 = this.config.maxEmbeddingsPerCall) != null ? _a17 : 2048;
+      }
+      get supportsParallelCalls() {
+        var _a17;
+        return (_a17 = this.config.supportsParallelCalls) != null ? _a17 : true;
+      }
+      get providerOptionsName() {
+        return this.config.provider.split(".")[0].trim();
+      }
+      async doEmbed({
+        values: values2,
+        headers,
+        abortSignal,
+        providerOptions
+      }) {
+        var _a17, _b16, _c;
+        const warnings = [];
+        const deprecatedOptions = await parseProviderOptions({
+          provider: "openai-compatible",
+          providerOptions,
+          schema: openaiCompatibleEmbeddingModelOptions
+        });
+        if (deprecatedOptions != null) {
+          warnings.push({
+            type: "other",
+            message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
+          });
+        }
+        const compatibleOptions = Object.assign(
+          deprecatedOptions != null ? deprecatedOptions : {},
+          (_a17 = await parseProviderOptions({
+            provider: "openaiCompatible",
+            providerOptions,
+            schema: openaiCompatibleEmbeddingModelOptions
+          })) != null ? _a17 : {},
+          (_b16 = await parseProviderOptions({
+            provider: this.providerOptionsName,
+            providerOptions,
+            schema: openaiCompatibleEmbeddingModelOptions
+          })) != null ? _b16 : {}
+        );
+        if (values2.length > this.maxEmbeddingsPerCall) {
+          throw new TooManyEmbeddingValuesForCallError({
+            provider: this.provider,
+            modelId: this.modelId,
+            maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+            values: values2
+          });
+        }
+        const {
+          responseHeaders,
+          value: response,
+          rawValue
+        } = await postJsonToApi({
+          url: this.config.url({
+            path: "/embeddings",
+            modelId: this.modelId
+          }),
+          headers: combineHeaders(this.config.headers(), headers),
+          body: {
+            model: this.modelId,
+            input: values2,
+            encoding_format: "float",
+            dimensions: compatibleOptions.dimensions,
+            user: compatibleOptions.user
+          },
+          failedResponseHandler: createJsonErrorResponseHandler(
+            (_c = this.config.errorStructure) != null ? _c : defaultOpenAICompatibleErrorStructure
+          ),
+          successfulResponseHandler: createJsonResponseHandler(
+            openaiTextEmbeddingResponseSchema
+          ),
+          abortSignal,
+          fetch: this.config.fetch
+        });
+        return {
+          warnings,
+          embeddings: response.data.map((item) => item.embedding),
+          usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
+          providerMetadata: response.providerMetadata,
+          response: { headers: responseHeaders, body: rawValue }
+        };
+      }
+    };
+    openaiTextEmbeddingResponseSchema = external_exports.object({
+      data: external_exports.array(external_exports.object({ embedding: external_exports.array(external_exports.number()) })),
+      usage: external_exports.object({ prompt_tokens: external_exports.number() }).nullish(),
+      providerMetadata: external_exports.record(external_exports.string(), external_exports.record(external_exports.string(), external_exports.any())).optional()
+    });
+    OpenAICompatibleImageModel = class {
+      constructor(modelId, config2) {
+        this.modelId = modelId;
+        this.config = config2;
+        this.specificationVersion = "v3";
+        this.maxImagesPerCall = 10;
+      }
+      get provider() {
+        return this.config.provider;
+      }
+      /**
+       * The provider options key used to extract provider-specific options.
+       */
+      get providerOptionsKey() {
+        return this.config.provider.split(".")[0].trim();
+      }
+      // TODO: deprecate non-camelCase keys and remove in future major version
+      getArgs(providerOptions) {
+        return {
+          ...providerOptions[this.providerOptionsKey],
+          ...providerOptions[toCamelCase(this.providerOptionsKey)]
+        };
+      }
+      async doGenerate({
+        prompt,
+        n,
+        size,
+        aspectRatio,
+        seed,
+        providerOptions,
+        headers,
+        abortSignal,
+        files,
+        mask
+      }) {
+        var _a17, _b16, _c, _d, _e;
+        const warnings = [];
+        if (aspectRatio != null) {
+          warnings.push({
+            type: "unsupported",
+            feature: "aspectRatio",
+            details: "This model does not support aspect ratio. Use `size` instead."
+          });
+        }
+        if (seed != null) {
+          warnings.push({ type: "unsupported", feature: "seed" });
+        }
+        const currentDate = (_c = (_b16 = (_a17 = this.config._internal) == null ? void 0 : _a17.currentDate) == null ? void 0 : _b16.call(_a17)) != null ? _c : /* @__PURE__ */ new Date();
+        const args = this.getArgs(providerOptions);
+        if (files != null && files.length > 0) {
+          const { value: response2, responseHeaders: responseHeaders2 } = await postFormDataToApi({
+            url: this.config.url({
+              path: "/images/edits",
+              modelId: this.modelId
+            }),
+            headers: combineHeaders(this.config.headers(), headers),
+            formData: convertToFormData({
+              model: this.modelId,
+              prompt,
+              image: await Promise.all(files.map((file2) => fileToBlob(file2))),
+              mask: mask != null ? await fileToBlob(mask) : void 0,
+              n,
+              size,
+              ...args
+            }),
+            failedResponseHandler: createJsonErrorResponseHandler(
+              (_d = this.config.errorStructure) != null ? _d : defaultOpenAICompatibleErrorStructure
+            ),
+            successfulResponseHandler: createJsonResponseHandler(
+              openaiCompatibleImageResponseSchema
+            ),
+            abortSignal,
+            fetch: this.config.fetch
+          });
+          return {
+            images: response2.data.map((item) => item.b64_json),
+            warnings,
+            response: {
+              timestamp: currentDate,
+              modelId: this.modelId,
+              headers: responseHeaders2
+            }
+          };
+        }
+        const { value: response, responseHeaders } = await postJsonToApi({
+          url: this.config.url({
+            path: "/images/generations",
+            modelId: this.modelId
+          }),
+          headers: combineHeaders(this.config.headers(), headers),
+          body: {
+            model: this.modelId,
+            prompt,
+            n,
+            size,
+            ...args,
+            response_format: "b64_json"
+          },
+          failedResponseHandler: createJsonErrorResponseHandler(
+            (_e = this.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure
+          ),
+          successfulResponseHandler: createJsonResponseHandler(
+            openaiCompatibleImageResponseSchema
+          ),
+          abortSignal,
+          fetch: this.config.fetch
+        });
+        return {
+          images: response.data.map((item) => item.b64_json),
+          warnings,
+          response: {
+            timestamp: currentDate,
+            modelId: this.modelId,
+            headers: responseHeaders
+          }
+        };
+      }
+    };
+    openaiCompatibleImageResponseSchema = external_exports.object({
+      data: external_exports.array(external_exports.object({ b64_json: external_exports.string() }))
+    });
+    VERSION2 = true ? "2.0.74" : "0.0.0-test";
+  }
+});
+
 // node_modules/@smithy/core/dist-es/submodules/serde/is-array-buffer/is-array-buffer.js
 var isArrayBuffer;
 var init_is_array_buffer = __esm({
@@ -24918,16 +27332,17 @@ var init_aws4fetch_esm = __esm({
 
 // node_modules/@ai-sdk/amazon-bedrock/dist/index.mjs
 function supportsStrictTools(modelId) {
-  return !rejectsNewerSchemaFields(modelId);
+  return !matchesModel(modelId, MODELS_WITHOUT_STRICT_TOOL_SUPPORT);
 }
 function supportsNativeStructuredOutput(modelId) {
-  return !rejectsNewerSchemaFields(modelId);
-}
-function rejectsNewerSchemaFields(modelId) {
-  return MODELS_REJECTING_NEWER_SCHEMA_FIELDS.some(
-    (model) => modelId.includes(model)
+  return !matchesModel(
+    modelId,
+    MODELS_WITHOUT_RELIABLE_NATIVE_STRUCTURED_OUTPUT
   );
 }
+function matchesModel(modelId, models) {
+  return models.some((model) => modelId.includes(model));
+}
 function createBedrockEventStreamDecoder(body, processEvent) {
   const codec = new import_eventstream_codec.EventStreamCodec(import_util_utf8.toUtf8, import_util_utf8.fromUtf8);
   let buffer = new Uint8Array(0);
@@ -24972,7 +27387,7 @@ function createBedrockEventStreamDecoder(body, processEvent) {
     })
   );
 }
-async function prepareTools({
+async function prepareTools2({
   tools: tools2,
   toolChoice,
   modelId,
@@ -25625,6 +28040,9 @@ function mapBedrockFinishReason(finishReason, isJsonResponseFromTool) {
       return "other";
   }
 }
+function isJsonResponseToolName(name15) {
+  return name15 === "json" || name15 === "json<|channel|>commentary";
+}
 function isCohereEmbeddingModel(modelId) {
   return modelId.includes("cohere.embed-");
 }
@@ -25656,7 +28074,7 @@ function createSigV4FetchFunction(getCredentials, fetch2, service = "bedrock") {
     );
     const headersWithUserAgent = withUserAgentSuffix(
       originalHeaders,
-      `ai-sdk/amazon-bedrock/${VERSION2}`,
+      `ai-sdk/amazon-bedrock/${VERSION3}`,
       getRuntimeEnvironmentUserAgent()
     );
     let effectiveBody = (_a17 = init == null ? void 0 : init.body) != null ? _a17 : void 0;
@@ -25714,7 +28132,7 @@ function createApiKeyFetchFunction(apiKey, fetch2) {
     const originalHeaders = normalizeHeaders(init == null ? void 0 : init.headers);
     const headersWithUserAgent = withUserAgentSuffix(
       originalHeaders,
-      `ai-sdk/amazon-bedrock/${VERSION2}`,
+      `ai-sdk/amazon-bedrock/${VERSION3}`,
       getRuntimeEnvironmentUserAgent()
     );
     const finalHeaders = combineHeaders(headersWithUserAgent, {
@@ -25796,7 +28214,7 @@ Original error: ${errorMessage}`
   const getHeaders = () => {
     var _a17;
     const baseHeaders = (_a17 = options.headers) != null ? _a17 : {};
-    return withUserAgentSuffix(baseHeaders, `ai-sdk/amazon-bedrock/${VERSION2}`);
+    return withUserAgentSuffix(baseHeaders, `ai-sdk/amazon-bedrock/${VERSION3}`);
   };
   const getBedrockRuntimeBaseUrl = () => {
     var _a17, _b16;
@@ -25869,38 +28287,38 @@ Original error: ${errorMessage}`
   provider.tools = import_internal.anthropicTools;
   return provider;
 }
-var import_internal, import_internal2, import_eventstream_codec, import_util_utf8, import_internal3, BEDROCK_STOP_REASONS, BEDROCK_IMAGE_MIME_TYPES, BEDROCK_DOCUMENT_MIME_TYPES, bedrockFilePartProviderOptions, amazonBedrockLanguageModelOptions, MODELS_REJECTING_NEWER_SCHEMA_FIELDS, BedrockErrorSchema, createBedrockEventStreamResponseHandler, bedrockReasoningMetadataSchema, anthropicProviderOptions, BedrockChatLanguageModel, JsonObjectTextExtractor, BedrockStopReasonSchema, BedrockAdditionalModelResponseFieldsSchema, BedrockToolUseSchema, BedrockReasoningTextSchema, BedrockRedactedReasoningSchema, AmazonBedrockCacheDetailSchema, BedrockResponseSchema, BedrockStreamSchema, amazonBedrockEmbeddingModelOptionsSchema, BedrockEmbeddingModel, BedrockEmbeddingResponseSchema, modelMaxImagesPerCall, BedrockImageModel, bedrockImageResponseSchema, VERSION2, bedrockRerankingResponseSchema, amazonBedrockRerankingModelOptionsSchema, BedrockRerankingModel, bedrock;
-var init_dist3 = __esm({
+var import_internal, import_internal2, import_eventstream_codec, import_util_utf8, import_internal3, BEDROCK_STOP_REASONS, BEDROCK_IMAGE_MIME_TYPES, BEDROCK_DOCUMENT_MIME_TYPES, bedrockFilePartProviderOptions, amazonBedrockLanguageModelOptions, MODELS_WITHOUT_STRICT_TOOL_SUPPORT, MODELS_WITHOUT_RELIABLE_NATIVE_STRUCTURED_OUTPUT, BedrockErrorSchema, createBedrockEventStreamResponseHandler, bedrockReasoningMetadataSchema, anthropicProviderOptions, BedrockChatLanguageModel, JsonObjectTextExtractor, BedrockStopReasonSchema, BedrockAdditionalModelResponseFieldsSchema, BedrockToolUseSchema, BedrockReasoningTextSchema, BedrockRedactedReasoningSchema, AmazonBedrockCacheDetailSchema, BedrockResponseSchema, BedrockStreamSchema, amazonBedrockEmbeddingModelOptionsSchema, BedrockEmbeddingModel, BedrockEmbeddingResponseSchema, modelMaxImagesPerCall, BedrockImageModel, bedrockImageResponseSchema, VERSION3, bedrockRerankingResponseSchema, amazonBedrockRerankingModelOptionsSchema, BedrockRerankingModel, bedrock;
+var init_dist5 = __esm({
   "node_modules/@ai-sdk/amazon-bedrock/dist/index.mjs"() {
     import_internal = require("@ai-sdk/anthropic/internal");
-    init_dist2();
-    init_dist2();
+    init_dist3();
+    init_dist3();
     import_internal2 = require("@ai-sdk/anthropic/internal");
     init_v4();
     init_v4();
     init_v4();
     init_dist();
-    init_dist2();
+    init_dist3();
     import_eventstream_codec = __toESM(require_dist_cjs2(), 1);
     import_util_utf8 = __toESM(require_dist_cjs3(), 1);
     init_dist();
-    init_dist2();
+    init_dist3();
     import_internal3 = require("@ai-sdk/anthropic/internal");
     init_dist();
-    init_dist2();
+    init_dist3();
     init_v4();
     init_dist();
-    init_dist2();
+    init_dist3();
     init_v4();
     init_v4();
-    init_dist2();
+    init_dist3();
     init_v4();
-    init_dist2();
+    init_dist3();
     init_aws4fetch_esm();
-    init_dist2();
-    init_dist2();
+    init_dist3();
+    init_dist3();
     init_v4();
-    init_dist2();
+    init_dist3();
     init_v4();
     BEDROCK_STOP_REASONS = [
       "stop",
@@ -25944,6 +28362,14 @@ var init_dist3 = __esm({
       }).optional()
     });
     amazonBedrockLanguageModelOptions = external_exports.object({
+      /**
+       * Determines how structured outputs are generated for Anthropic models.
+       *
+       * - `outputFormat`: Use the native `output_config.format` parameter.
+       * - `jsonTool`: Use a special 'json' tool to specify the structured output format.
+       * - `auto`: Use `outputFormat` when supported, otherwise use `jsonTool` (default).
+       */
+      structuredOutputMode: external_exports.enum(["outputFormat", "jsonTool", "auto"]).optional(),
       /**
        * Additional inference parameters that the model supports,
        * beyond the base set of inference parameters that Converse
@@ -25975,13 +28401,18 @@ var init_dist3 = __esm({
        */
       serviceTier: external_exports.enum(["reserved", "priority", "default", "flex"]).optional()
     });
-    MODELS_REJECTING_NEWER_SCHEMA_FIELDS = [
+    MODELS_WITHOUT_STRICT_TOOL_SUPPORT = [
       "claude-opus-4-7",
       "claude-opus-4-8",
       "claude-opus-5",
       "claude-fable-5",
       "claude-sonnet-5"
     ];
+    MODELS_WITHOUT_RELIABLE_NATIVE_STRUCTURED_OUTPUT = [
+      ...MODELS_WITHOUT_STRICT_TOOL_SUPPORT,
+      "claude-sonnet-4-6",
+      "claude-haiku-4-5"
+    ];
     BedrockErrorSchema = external_exports.object({
       message: external_exports.string(),
       type: external_exports.string().nullish()
@@ -26032,7 +28463,8 @@ var init_dist3 = __esm({
       redactedContent: external_exports.string().optional()
     });
     anthropicProviderOptions = external_exports.object({
-      disableParallelToolUse: external_exports.boolean().optional()
+      disableParallelToolUse: external_exports.boolean().optional(),
+      structuredOutputMode: external_exports.enum(["outputFormat", "jsonTool", "auto"]).optional()
     });
     BedrockChatLanguageModel = class {
       constructor(modelId, config2) {
@@ -26059,7 +28491,7 @@ var init_dist3 = __esm({
         toolChoice,
         providerOptions
       }) {
-        var _a17, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+        var _a17, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
         const bedrockOptions = (_a17 = await parseProviderOptions({
           provider: "bedrock",
           providerOptions,
@@ -26117,15 +28549,33 @@ var init_dist3 = __esm({
         const isOpenAIGptOssModel = (_d = openAIModelId == null ? void 0 : openAIModelId.startsWith("openai.gpt-oss-")) != null ? _d : false;
         const isThinkingEnabled = ((_e = bedrockOptions.reasoningConfig) == null ? void 0 : _e.type) === "enabled" || ((_f = bedrockOptions.reasoningConfig) == null ? void 0 : _f.type) === "adaptive";
         const { supportsStructuredOutput: modelSupportsStructuredOutput } = (0, import_internal2.getModelCapabilities)(this.modelId);
-        const useNativeStructuredOutput = isAnthropicModel && supportsNativeStructuredOutput(this.modelId) && (modelSupportsStructuredOutput || isThinkingEnabled) && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null;
-        const useJsonInstructionForStructuredOutput = isAnthropicModel && !supportsStrictTools(this.modelId) && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && tools2 != null && tools2.length > 0;
+        const structuredOutputMode = (_h = (_g = bedrockOptions.structuredOutputMode) != null ? _g : anthropicOptions == null ? void 0 : anthropicOptions.structuredOutputMode) != null ? _h : "auto";
+        if (structuredOutputMode === "jsonTool") {
+          const additionalModelRequestFields = {
+            ...bedrockOptions.additionalModelRequestFields
+          };
+          const outputConfig = additionalModelRequestFields.output_config;
+          if (outputConfig != null && typeof outputConfig === "object" && !Array.isArray(outputConfig)) {
+            const outputConfigWithoutFormat = { ...outputConfig };
+            delete outputConfigWithoutFormat.format;
+            if (Object.keys(outputConfigWithoutFormat).length > 0) {
+              additionalModelRequestFields.output_config = outputConfigWithoutFormat;
+            } else {
+              delete additionalModelRequestFields.output_config;
+            }
+            bedrockOptions.additionalModelRequestFields = additionalModelRequestFields;
+          }
+        }
+        const modelSupportsNativeStructuredOutput = supportsNativeStructuredOutput(this.modelId) && (modelSupportsStructuredOutput || isThinkingEnabled);
+        const useNativeStructuredOutput = isAnthropicModel && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && (structuredOutputMode === "outputFormat" || structuredOutputMode === "auto" && modelSupportsNativeStructuredOutput);
+        const useJsonInstructionForStructuredOutput = !useNativeStructuredOutput && structuredOutputMode !== "jsonTool" && isAnthropicModel && !supportsStrictTools(this.modelId) && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && tools2 != null && tools2.length > 0;
         const jsonResponseTool = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !useNativeStructuredOutput && !useJsonInstructionForStructuredOutput ? {
           type: "function",
           name: "json",
           description: "Respond with a JSON object.",
           inputSchema: responseFormat.schema
         } : void 0;
-        const { toolConfig, additionalTools, toolWarnings, betas } = await prepareTools({
+        const { toolConfig, additionalTools, toolWarnings, betas } = await prepareTools2({
           tools: jsonResponseTool ? [...tools2 != null ? tools2 : [], jsonResponseTool] : tools2,
           toolChoice: jsonResponseTool != null ? { type: "required" } : toolChoice,
           modelId: this.modelId,
@@ -26139,16 +28589,16 @@ var init_dist3 = __esm({
           };
         }
         if (betas.size > 0 || bedrockOptions.anthropicBeta) {
-          const existingBetas = (_g = bedrockOptions.anthropicBeta) != null ? _g : [];
+          const existingBetas = (_i = bedrockOptions.anthropicBeta) != null ? _i : [];
           const mergedBetas = betas.size > 0 ? [...existingBetas, ...Array.from(betas)] : existingBetas;
           bedrockOptions.additionalModelRequestFields = {
             ...bedrockOptions.additionalModelRequestFields,
             anthropic_beta: mergedBetas
           };
         }
-        const thinkingType = (_h = bedrockOptions.reasoningConfig) == null ? void 0 : _h.type;
-        const thinkingBudget = thinkingType === "enabled" ? (_i = bedrockOptions.reasoningConfig) == null ? void 0 : _i.budgetTokens : void 0;
-        const thinkingDisplay = thinkingType === "adaptive" ? (_j = bedrockOptions.reasoningConfig) == null ? void 0 : _j.display : void 0;
+        const thinkingType = (_j = bedrockOptions.reasoningConfig) == null ? void 0 : _j.type;
+        const thinkingBudget = thinkingType === "enabled" ? (_k = bedrockOptions.reasoningConfig) == null ? void 0 : _k.budgetTokens : void 0;
+        const thinkingDisplay = thinkingType === "adaptive" ? (_l = bedrockOptions.reasoningConfig) == null ? void 0 : _l.display : void 0;
         const isAnthropicThinkingEnabled = isAnthropicModel && isThinkingEnabled;
         const inferenceConfig = {
           ...maxOutputTokens != null && { maxTokens: maxOutputTokens },
@@ -26181,7 +28631,7 @@ var init_dist3 = __esm({
             };
           }
         } else if (!isAnthropicModel) {
-          if (((_k = bedrockOptions.reasoningConfig) == null ? void 0 : _k.budgetTokens) != null) {
+          if (((_m = bedrockOptions.reasoningConfig) == null ? void 0 : _m.budgetTokens) != null) {
             warnings.push({
               type: "unsupported",
               feature: "budgetTokens",
@@ -26196,13 +28646,13 @@ var init_dist3 = __esm({
             });
           }
         }
-        const maxReasoningEffort = (_l = bedrockOptions.reasoningConfig) == null ? void 0 : _l.maxReasoningEffort;
+        const maxReasoningEffort = (_n = bedrockOptions.reasoningConfig) == null ? void 0 : _n.maxReasoningEffort;
         if (maxReasoningEffort != null) {
           if (isAnthropicModel) {
             bedrockOptions.additionalModelRequestFields = {
               ...bedrockOptions.additionalModelRequestFields,
               output_config: {
-                ...(_m = bedrockOptions.additionalModelRequestFields) == null ? void 0 : _m.output_config,
+                ...(_o = bedrockOptions.additionalModelRequestFields) == null ? void 0 : _o.output_config,
                 effort: maxReasoningEffort
               }
             };
@@ -26213,7 +28663,7 @@ var init_dist3 = __esm({
             } : {
               ...bedrockOptions.additionalModelRequestFields,
               reasoning: {
-                ...(_n = bedrockOptions.additionalModelRequestFields) == null ? void 0 : _n.reasoning,
+                ...(_p = bedrockOptions.additionalModelRequestFields) == null ? void 0 : _p.reasoning,
                 effort: maxReasoningEffort
               }
             };
@@ -26232,7 +28682,7 @@ var init_dist3 = __esm({
           bedrockOptions.additionalModelRequestFields = {
             ...bedrockOptions.additionalModelRequestFields,
             output_config: {
-              ...(_o = bedrockOptions.additionalModelRequestFields) == null ? void 0 : _o.output_config,
+              ...(_q = bedrockOptions.additionalModelRequestFields) == null ? void 0 : _q.output_config,
               format: {
                 type: "json_schema",
                 schema: (0, import_internal2.sanitizeJsonSchema)(responseFormat.schema)
@@ -26264,7 +28714,7 @@ var init_dist3 = __esm({
             details: "topK is not supported when thinking is enabled"
           });
         }
-        const hasAnyTools = ((_q = (_p = toolConfig.tools) == null ? void 0 : _p.length) != null ? _q : 0) > 0 || additionalTools;
+        const hasAnyTools = ((_s = (_r = toolConfig.tools) == null ? void 0 : _r.length) != null ? _s : 0) > 0 || additionalTools;
         let filteredPrompt = prompt;
         if (!hasAnyTools) {
           const hasToolContent = prompt.some(
@@ -26306,6 +28756,7 @@ var init_dist3 = __esm({
           reasoningConfig: _,
           additionalModelRequestFields: __,
           serviceTier: ___,
+          structuredOutputMode: ____,
           ...filteredBedrockOptions
         } = (providerOptions == null ? void 0 : providerOptions.bedrock) || {};
         const additionalModelResponseFieldPaths = isAnthropicModel ? ["/delta/stop_sequence"] : void 0;
@@ -26412,7 +28863,7 @@ var init_dist3 = __esm({
             }
           }
           if (part.toolUse) {
-            const isJsonResponseTool = usesJsonResponseTool && part.toolUse.name === "json";
+            const isJsonResponseTool = usesJsonResponseTool && isJsonResponseToolName(part.toolUse.name);
             if (isJsonResponseTool) {
               isJsonResponseFromTool = true;
               content.push({
@@ -26747,7 +29198,7 @@ var init_dist3 = __esm({
                 if (((_q = contentBlockStart == null ? void 0 : contentBlockStart.start) == null ? void 0 : _q.toolUse) != null) {
                   const toolUse = contentBlockStart.start.toolUse;
                   const blockIndex = contentBlockStart.contentBlockIndex;
-                  const isJsonResponseTool = usesJsonResponseTool && toolUse.name === "json";
+                  const isJsonResponseTool = usesJsonResponseTool && isJsonResponseToolName(toolUse.name);
                   const normalizedToolCallId = normalizeToolCallId(
                     toolUse.toolUseId,
                     isMistral
@@ -27369,7 +29820,7 @@ var init_dist3 = __esm({
       details: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
       preview: external_exports.unknown().optional()
     });
-    VERSION2 = true ? "4.0.167" : "0.0.0-test";
+    VERSION3 = true ? "4.0.169" : "0.0.0-test";
     bedrockRerankingResponseSchema = lazySchema(
       () => zodSchema(
         external_exports.object({
@@ -27487,10 +29938,17 @@ function createProviderInstance(config2) {
         ...config2.baseURL && { baseURL: config2.baseURL }
       });
     case "openai": {
+      if (config2.baseURL) {
+        const provider = createOpenAICompatible({
+          name: "openai-compatible",
+          baseURL: config2.baseURL,
+          apiKey: config2.apiKey
+        });
+        return provider;
+      }
       const openai = (0, import_openai.createOpenAI)({
         compatibility: "strict",
-        apiKey: config2.apiKey,
-        ...config2.baseURL && { baseURL: config2.baseURL }
+        apiKey: config2.apiKey
       });
       const chatProvider = (modelId, settings) => openai.chat(modelId, settings);
       chatProvider.chat = openai.chat.bind(openai);
@@ -27570,8 +30028,9 @@ var init_provider = __esm({
     "use strict";
     import_anthropic = require("@ai-sdk/anthropic");
     import_openai = require("@ai-sdk/openai");
+    init_dist4();
     import_google = require("@ai-sdk/google");
-    init_dist3();
+    init_dist5();
     DEFAULT_MODELS = {
       anthropic: "claude-sonnet-4-6",
       openai: "gpt-5.2",
@@ -33672,7 +36131,7 @@ var require_parser = __commonJS({
       /* LispType.None */
     });
     var lispTypes = /* @__PURE__ */ new Map();
-    var ParseError = class extends Error {
+    var ParseError2 = class extends Error {
       constructor(message, code) {
         super(message + ": " + code.substring(0, 40));
         this.code = code;
@@ -34607,7 +37066,7 @@ var require_parser = __commonJS({
               lispTypes.get(type)?.(constants, type, part, res, expect, ctx);
             } catch (e) {
               if (topLevel && e instanceof SyntaxError) {
-                throw new ParseError(e.message, str);
+                throw new ParseError2(e.message, str);
               }
               throw e;
             }
@@ -34619,7 +37078,7 @@ var require_parser = __commonJS({
       }
       if (!res && part.length) {
         if (topLevel) {
-          throw new ParseError(`Unexpected token after ${lastType}: ${part.char(0)}`, str);
+          throw new ParseError2(`Unexpected token after ${lastType}: ${part.char(0)}`, str);
         }
         throw new SyntaxError(`Unexpected token after ${lastType}: ${part.char(0)}`);
       }
@@ -34914,7 +37373,7 @@ var require_parser = __commonJS({
     }
     function parse11(code, eager = false, expression = false) {
       if (typeof code !== "string")
-        throw new ParseError(`Cannot parse ${code}`, code);
+        throw new ParseError2(`Cannot parse ${code}`, code);
       let str = " " + code;
       const constants = { strings: [], literals: [], regexes: [], eager };
       str = extractConstants(constants, str).str;
@@ -34924,7 +37383,7 @@ var require_parser = __commonJS({
       }
       return { tree: lispifyFunction(new utils.CodeString(str), constants, expression), constants };
     }
-    exports2.ParseError = ParseError;
+    exports2.ParseError = ParseError2;
     exports2.checkRegex = checkRegex;
     exports2.default = parse11;
     exports2.expectTypes = expectTypes;
@@ -55266,12 +57725,12 @@ var init_apply = __esm({
 });
 
 // node_modules/lodash-es/noop.js
-function noop() {
+function noop2() {
 }
 var noop_default;
 var init_noop = __esm({
   "node_modules/lodash-es/noop.js"() {
-    noop_default = noop;
+    noop_default = noop2;
   }
 });
 
@@ -77220,9 +79679,9 @@ var require_arrayIncludesWith = __commonJS({
 // node_modules/lodash/noop.js
 var require_noop = __commonJS({
   "node_modules/lodash/noop.js"(exports2, module2) {
-    function noop2() {
+    function noop3() {
     }
-    module2.exports = noop2;
+    module2.exports = noop3;
   }
 });
 
@@ -77230,10 +79689,10 @@ var require_noop = __commonJS({
 var require_createSet = __commonJS({
   "node_modules/lodash/_createSet.js"(exports2, module2) {
     var Set3 = require_Set();
-    var noop2 = require_noop();
+    var noop3 = require_noop();
     var setToArray2 = require_setToArray();
     var INFINITY5 = 1 / 0;
-    var createSet2 = !(Set3 && 1 / setToArray2(new Set3([, -0]))[1] == INFINITY5) ? noop2 : function(values2) {
+    var createSet2 = !(Set3 && 1 / setToArray2(new Set3([, -0]))[1] == INFINITY5) ? noop3 : function(values2) {
       return new Set3(values2);
     };
     module2.exports = createSet2;
@@ -88350,7 +90809,7 @@ var require_utils2 = __commonJS({
   "node_modules/fast-uri/lib/utils.js"(exports2, module2) {
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
-    var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isIPv42 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
     var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
     var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
     var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
@@ -88450,7 +90909,7 @@ var require_utils2 = __commonJS({
         const part = parts[i];
         if (part === "") return void 0;
         if (part.indexOf(".") !== -1) {
-          if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
+          if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv42(part)) return void 0;
           hextetCount += 2;
           continue;
         }
@@ -88801,7 +91260,7 @@ var require_utils2 = __commonJS({
       }
       if (component.host !== void 0) {
         let host = component.host;
-        if (!isIPv4(host)) {
+        if (!isIPv42(host)) {
           let ipV6res = normalizeIPv6(host);
           if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
             host = normalizePercentEncoding(host, true);
@@ -88834,7 +91293,7 @@ var require_utils2 = __commonJS({
       encodeFragment,
       escapePreservingEscapes,
       removeDotSegments,
-      isIPv4,
+      isIPv4: isIPv42,
       isUUID,
       normalizeIPv6,
       stringArrayToHexStripped
@@ -89057,7 +91516,7 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports2, module2) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils2();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4: isIPv42, nonSimpleDomain } = require_utils2();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
     var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
@@ -89102,7 +91561,7 @@ var require_fast_uri = __commonJS({
       const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
       const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
       const resolvedHost = resolved.host;
-      const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+      const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv42(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
       canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
       const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
       if (resolved.error && !encodedASCIIHost) {
@@ -89350,7 +91809,7 @@ var require_fast_uri = __commonJS({
           malformedAuthorityOrPort = true;
         }
         if (parsed.host) {
-          const ipv4result = isIPv4(parsed.host);
+          const ipv4result = isIPv42(parsed.host);
           if (ipv4result === false) {
             const bracketedIPLiteral = parsed.host[0] === "[" && parsed.host[parsed.host.length - 1] === "]";
             const ipv6result = normalizeIPv6(parsed.host);