@apertis/ai-sdk-provider 2.1.0 → 3.0.0

package/dist/index.cjs

@@ -6,8 +6,8 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name14 in all)
-    __defProp(target, name14, { get: all[name14], enumerable: true });
+  for (var name15 in all)
+    __defProp(target, name15, { get: all[name15], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -35,7 +35,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// node_modules/.pnpm/@ai-sdk+provider@2.0.1/node_modules/@ai-sdk/provider/dist/index.mjs
+// node_modules/.pnpm/@ai-sdk+provider@3.0.8/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
 var symbol = Symbol.for(marker);
 var _a;
@@ -50,13 +50,13 @@ var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
    * @param {unknown} [params.cause] - The underlying cause of the error.
    */
   constructor({
-    name: name14,
+    name: name142,
     message,
     cause
   }) {
     super(message);
     this[_a] = true;
-    this.name = name14;
+    this.name = name142;
     this.cause = cause;
   }
   /**
@@ -67,8 +67,8 @@ var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
   static isInstance(error) {
     return _AISDKError.hasMarker(error, marker);
   }
-  static hasMarker(error, marker15) {
-    const markerSymbol = Symbol.for(marker15);
+  static hasMarker(error, marker152) {
+    const markerSymbol = Symbol.for(marker152);
     return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
   }
 };
@@ -305,34 +305,61 @@ var symbol13 = Symbol.for(marker13);
 var _a13;
 var _b13;
 var TypeValidationError = class _TypeValidationError extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
-  constructor({ value, cause }) {
+  constructor({
+    value,
+    cause,
+    context
+  }) {
+    let contextPrefix = "Type validation failed";
+    if (context == null ? void 0 : context.field) {
+      contextPrefix += ` for ${context.field}`;
+    }
+    if ((context == null ? void 0 : context.entityName) || (context == null ? void 0 : context.entityId)) {
+      contextPrefix += " (";
+      const parts = [];
+      if (context.entityName) {
+        parts.push(context.entityName);
+      }
+      if (context.entityId) {
+        parts.push(`id: "${context.entityId}"`);
+      }
+      contextPrefix += parts.join(", ");
+      contextPrefix += ")";
+    }
     super({
       name: name12,
-      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+      message: `${contextPrefix}: Value: ${JSON.stringify(value)}.
 Error message: ${getErrorMessage(cause)}`,
       cause
     });
     this[_a13] = true;
     this.value = value;
+    this.context = context;
   }
   static isInstance(error) {
     return AISDKError.hasMarker(error, marker13);
   }
   /**
    * Wraps an error into a TypeValidationError.
-   * If the cause is already a TypeValidationError with the same value, it returns the cause.
+   * If the cause is already a TypeValidationError with the same value and context, it returns the cause.
    * Otherwise, it creates a new TypeValidationError.
    *
    * @param {Object} params - The parameters for wrapping the error.
    * @param {unknown} params.value - The value that failed validation.
    * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @param {TypeValidationContext} params.context - Optional context about what is being validated.
    * @returns {TypeValidationError} A TypeValidationError instance.
    */
   static wrap({
     value,
-    cause
+    cause,
+    context
   }) {
-    return _TypeValidationError.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError({ value, cause });
+    var _a152, _b152, _c;
+    if (_TypeValidationError.isInstance(cause) && cause.value === value && ((_a152 = cause.context) == null ? void 0 : _a152.field) === (context == null ? void 0 : context.field) && ((_b152 = cause.context) == null ? void 0 : _b152.entityName) === (context == null ? void 0 : context.entityName) && ((_c = cause.context) == null ? void 0 : _c.entityId) === (context == null ? void 0 : context.entityId)) {
+      return cause;
+    }
+    return new _TypeValidationError({ value, cause, context });
   }
 };
 var name13 = "AI_UnsupportedFunctionalityError";
@@ -354,6 +381,12 @@ var UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = sym
   }
 };
 
+// node_modules/.pnpm/@ai-sdk+provider-utils@4.0.23_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+var z4 = __toESM(require("zod/v4"), 1);
+var import_v3 = require("zod/v3");
+var import_v32 = require("zod/v3");
+var import_v33 = require("zod/v3");
+
 // node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/index.js
 var ParseError = class extends Error {
   constructor(message, options) {
@@ -481,11 +514,7 @@ var EventSourceParserStream = class extends TransformStream {
   }
 };
 
-// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.20_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
-var z4 = __toESM(require("zod/v4"), 1);
-var import_v3 = require("zod/v3");
-var import_v32 = require("zod/v3");
-var import_v33 = require("zod/v3");
+// node_modules/.pnpm/@ai-sdk+provider-utils@4.0.23_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
 function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => ({
@@ -498,6 +527,248 @@ function combineHeaders(...headers) {
 function extractResponseHeaders(response) {
   return Object.fromEntries([...response.headers]);
 }
+var { btoa, atob } = globalThis;
+function convertBase64ToUint8Array(base64String) {
+  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
+  const latin1string = atob(base64Url);
+  return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
+}
+function convertUint8ArrayToBase64(array) {
+  let latin1string = "";
+  for (let i = 0; i < array.length; i++) {
+    latin1string += String.fromCodePoint(array[i]);
+  }
+  return btoa(latin1string);
+}
+function convertToBase64(value) {
+  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+}
+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;
+}
+var name14 = "AI_DownloadError";
+var marker15 = `vercel.ai.error.${name14}`;
+var symbol15 = Symbol.for(marker15);
+var _a15;
+var _b15;
+var DownloadError = class extends (_b15 = AISDKError, _a15 = symbol15, _b15) {
+  constructor({
+    url,
+    statusCode,
+    statusText,
+    cause,
+    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
+  }) {
+    super({ name: name14, message, cause });
+    this[_a15] = true;
+    this.url = url;
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker15);
+  }
+};
+var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
+async function readResponseWithSizeLimit({
+  response,
+  url,
+  maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE
+}) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength != null) {
+    const length = parseInt(contentLength, 10);
+    if (!isNaN(length) && length > maxBytes) {
+      throw new DownloadError({
+        url,
+        message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
+      });
+    }
+  }
+  const body = response.body;
+  if (body == null) {
+    return new Uint8Array(0);
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      totalBytes += value.length;
+      if (totalBytes > maxBytes) {
+        throw new DownloadError({
+          url,
+          message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes.`
+        });
+      }
+      chunks.push(value);
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  const result = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function validateDownloadUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (e) {
+    throw new DownloadError({
+      url,
+      message: `Invalid URL: ${url}`
+    });
+  }
+  if (parsed.protocol === "data:") {
+    return;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new DownloadError({
+      url,
+      message: `URL scheme must be http, https, or data, got ${parsed.protocol}`
+    });
+  }
+  const hostname = parsed.hostname;
+  if (!hostname) {
+    throw new DownloadError({
+      url,
+      message: `URL must have a hostname`
+    });
+  }
+  if (hostname === "localhost" || hostname.endsWith(".local") || hostname.endsWith(".localhost")) {
+    throw new DownloadError({
+      url,
+      message: `URL with hostname ${hostname} is not allowed`
+    });
+  }
+  if (hostname.startsWith("[") && hostname.endsWith("]")) {
+    const ipv6 = hostname.slice(1, -1);
+    if (isPrivateIPv6(ipv6)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IPv6 address ${hostname} is not allowed`
+      });
+    }
+    return;
+  }
+  if (isIPv4(hostname)) {
+    if (isPrivateIPv4(hostname)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IP address ${hostname} is not allowed`
+      });
+    }
+    return;
+  }
+}
+function isIPv4(hostname) {
+  const parts = hostname.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] = parts;
+  if (a === 0) return true;
+  if (a === 10) 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 === 168) return true;
+  return false;
+}
+function isPrivateIPv6(ip) {
+  const normalized = ip.toLowerCase();
+  if (normalized === "::1") return true;
+  if (normalized === "::") return true;
+  if (normalized.startsWith("::ffff:")) {
+    const mappedPart = normalized.slice(7);
+    if (isIPv4(mappedPart)) {
+      return isPrivateIPv4(mappedPart);
+    }
+    const hexParts = mappedPart.split(":");
+    if (hexParts.length === 2) {
+      const high = parseInt(hexParts[0], 16);
+      const low = parseInt(hexParts[1], 16);
+      if (!isNaN(high) && !isNaN(low)) {
+        const a = high >> 8 & 255;
+        const b = high & 255;
+        const c = low >> 8 & 255;
+        const d = low & 255;
+        return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+      }
+    }
+  }
+  if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
+  if (normalized.startsWith("fe80")) return true;
+  return false;
+}
+async function downloadBlob(url, options) {
+  var _a22, _b22;
+  validateDownloadUrl(url);
+  try {
+    const response = await fetch(url, {
+      signal: options == null ? void 0 : options.abortSignal
+    });
+    if (response.redirected) {
+      validateDownloadUrl(response.url);
+    }
+    if (!response.ok) {
+      throw new DownloadError({
+        url,
+        statusCode: response.status,
+        statusText: response.statusText
+      });
+    }
+    const data = await readResponseWithSizeLimit({
+      response,
+      url,
+      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([data], contentType ? { type: contentType } : void 0);
+  } catch (error) {
+    if (DownloadError.isInstance(error)) {
+      throw error;
+    }
+    throw new DownloadError({ url, cause: error });
+  }
+}
 var createIdGenerator = ({
   prefix,
   size = 16,
@@ -529,6 +800,25 @@ function isAbortError(error) {
   error.name === "TimeoutError");
 }
 var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+var BUN_ERROR_CODES = [
+  "ConnectionRefused",
+  "ConnectionClosed",
+  "FailedToOpenSocket",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EPIPE"
+];
+function isBunNetworkError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  if (typeof code === "string" && BUN_ERROR_CODES.includes(code)) {
+    return true;
+  }
+  return false;
+}
 function handleFetchError({
   error,
   url,
@@ -550,17 +840,26 @@ function handleFetchError({
       });
     }
   }
+  if (isBunNetworkError(error)) {
+    return new APICallError({
+      message: `Cannot connect to API: ${error.message}`,
+      cause: error,
+      url,
+      requestBodyValues,
+      isRetryable: true
+    });
+  }
   return error;
 }
 function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
-  var _a15, _b15, _c;
+  var _a22, _b22, _c;
   if (globalThisAny.window) {
     return `runtime/browser`;
   }
-  if ((_a15 = globalThisAny.navigator) == null ? void 0 : _a15.userAgent) {
+  if ((_a22 = globalThisAny.navigator) == null ? void 0 : _a22.userAgent) {
     return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
   }
-  if ((_c = (_b15 = globalThisAny.process) == null ? void 0 : _b15.versions) == null ? void 0 : _c.node) {
+  if ((_c = (_b22 = globalThisAny.process) == null ? void 0 : _b22.versions) == null ? void 0 : _c.node) {
     return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
   }
   if (globalThisAny.EdgeRuntime) {
@@ -598,9 +897,9 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
   );
   return Object.fromEntries(normalizedHeaders.entries());
 }
-var VERSION = true ? "3.0.20" : "0.0.0-test";
-var suspectProtoRx = /"__proto__"\s*:/;
-var suspectConstructorRx = /"constructor"\s*:/;
+var VERSION = true ? "4.0.23" : "0.0.0-test";
+var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
 function _parse(text) {
   const obj = JSON.parse(text);
   if (obj === null || typeof obj !== "object") {
@@ -620,7 +919,7 @@ function filter(obj) {
       if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
         throw new SyntaxError("Object contains forbidden prototype property");
       }
-      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
         throw new SyntaxError("Object contains forbidden prototype property");
       }
       for (const key in node) {
@@ -631,75 +930,1278 @@ function filter(obj) {
       }
     }
   }
-  return obj;
+  return obj;
+}
+function secureJsonParse(text) {
+  const { stackTraceLimit } = Error;
+  try {
+    Error.stackTraceLimit = 0;
+  } catch (e) {
+    return _parse(text);
+  }
+  try {
+    return _parse(text);
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit;
+  }
+}
+function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
+  if (jsonSchema2.type === "object" || Array.isArray(jsonSchema2.type) && jsonSchema2.type.includes("object")) {
+    jsonSchema2.additionalProperties = false;
+    const { properties } = jsonSchema2;
+    if (properties != null) {
+      for (const key of Object.keys(properties)) {
+        properties[key] = visit(properties[key]);
+      }
+    }
+  }
+  if (jsonSchema2.items != null) {
+    jsonSchema2.items = Array.isArray(jsonSchema2.items) ? jsonSchema2.items.map(visit) : visit(jsonSchema2.items);
+  }
+  if (jsonSchema2.anyOf != null) {
+    jsonSchema2.anyOf = jsonSchema2.anyOf.map(visit);
+  }
+  if (jsonSchema2.allOf != null) {
+    jsonSchema2.allOf = jsonSchema2.allOf.map(visit);
+  }
+  if (jsonSchema2.oneOf != null) {
+    jsonSchema2.oneOf = jsonSchema2.oneOf.map(visit);
+  }
+  const { definitions } = jsonSchema2;
+  if (definitions != null) {
+    for (const key of Object.keys(definitions)) {
+      definitions[key] = visit(definitions[key]);
+    }
+  }
+  return jsonSchema2;
+}
+function visit(def) {
+  if (typeof def === "boolean") return def;
+  return addAdditionalPropertiesToJsonSchema(def);
+}
+var ignoreOverride = /* @__PURE__ */ Symbol(
+  "Let zodToJsonSchema decide on which parser to use"
+);
+var defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+function parseAnyDef() {
+  return {};
+}
+function parseArrayDef(def, refs) {
+  var _a22, _b22, _c;
+  const res = {
+    type: "array"
+  };
+  if (((_a22 = def.type) == null ? void 0 : _a22._def) && ((_c = (_b22 = def.type) == null ? void 0 : _b22._def) == null ? void 0 : _c.typeName) !== import_v32.ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    res.minItems = def.minLength.value;
+  }
+  if (def.maxLength) {
+    res.maxItems = def.maxLength.value;
+  }
+  if (def.exactLength) {
+    res.minItems = def.exactLength.value;
+    res.maxItems = def.exactLength.value;
+  }
+  return res;
+}
+function parseBigintDef(def) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks) return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        if (check.inclusive) {
+          res.minimum = check.value;
+        } else {
+          res.exclusiveMinimum = check.value;
+        }
+        break;
+      case "max":
+        if (check.inclusive) {
+          res.maximum = check.value;
+        } else {
+          res.exclusiveMaximum = check.value;
+        }
+        break;
+      case "multipleOf":
+        res.multipleOf = check.value;
+        break;
+    }
+  }
+  return res;
+}
+function parseBooleanDef() {
+  return { type: "boolean" };
+}
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+var parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy != null ? overrideDateStrategy : refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser(def);
+  }
+}
+var integerDateParser = (def) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        res.minimum = check.value;
+        break;
+      case "max":
+        res.maximum = check.value;
+        break;
+    }
+  }
+  return res;
+};
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
+}
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+var isJsonSchema7AllOfType = (type) => {
+  if ("type" in type && type.type === "string") return false;
+  return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? { allOf: mergedAllOf } : void 0;
+}
+function parseLiteralDef(def) {
+  const parsedType = typeof def.value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: def.value
+  };
+}
+var emojiRegex = void 0;
+var zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex === void 0) {
+      emojiRegex = RegExp(
+        "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
+        "u"
+      );
+    }
+    return emojiRegex;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
+          break;
+        case "max":
+          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat(res, "email", check.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat(res, "idn-email", check.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern(res, zodPatterns.email, check.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat(res, "uri", check.message, refs);
+          break;
+        case "uuid":
+          addFormat(res, "uuid", check.message, refs);
+          break;
+        case "regex":
+          addPattern(res, check.regex, check.message, refs);
+          break;
+        case "cuid":
+          addPattern(res, zodPatterns.cuid, check.message, refs);
+          break;
+        case "cuid2":
+          addPattern(res, zodPatterns.cuid2, check.message, refs);
+          break;
+        case "startsWith":
+          addPattern(
+            res,
+            RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`),
+            check.message,
+            refs
+          );
+          break;
+        case "endsWith":
+          addPattern(
+            res,
+            RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`),
+            check.message,
+            refs
+          );
+          break;
+        case "datetime":
+          addFormat(res, "date-time", check.message, refs);
+          break;
+        case "date":
+          addFormat(res, "date", check.message, refs);
+          break;
+        case "time":
+          addFormat(res, "time", check.message, refs);
+          break;
+        case "duration":
+          addFormat(res, "duration", check.message, refs);
+          break;
+        case "length":
+          res.minLength = typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value;
+          res.maxLength = typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value;
+          break;
+        case "includes": {
+          addPattern(
+            res,
+            RegExp(escapeLiteralCheckValue(check.value, refs)),
+            check.message,
+            refs
+          );
+          break;
+        }
+        case "ip": {
+          if (check.version !== "v6") {
+            addFormat(res, "ipv4", check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addFormat(res, "ipv6", check.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern(res, zodPatterns.base64url, check.message, refs);
+          break;
+        case "jwt":
+          addPattern(res, zodPatterns.jwt, check.message, refs);
+          break;
+        case "cidr": {
+          if (check.version !== "v6") {
+            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern(res, zodPatterns.emoji(), check.message, refs);
+          break;
+        case "ulid": {
+          addPattern(res, zodPatterns.ulid, check.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat(res, "binary", check.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              res.contentEncoding = "base64";
+              break;
+            }
+            case "pattern:zod": {
+              addPattern(res, zodPatterns.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern(res, zodPatterns.nanoid, check.message, refs);
+        }
+        case "toLowerCase":
+        case "toUpperCase":
+        case "trim":
+          break;
+        default:
+          /* @__PURE__ */ ((_) => {
+          })(check);
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+var ALPHA_NUMERIC = new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
+);
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat(schema, value, message, refs) {
+  var _a22;
+  if (schema.format || ((_a22 = schema.anyOf) == null ? void 0 : _a22.some((x) => x.format))) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format
+      });
+      delete schema.format;
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    schema.format = value;
+  }
+}
+function addPattern(schema, regex, message, refs) {
+  var _a22;
+  if (schema.pattern || ((_a22 = schema.allOf) == null ? void 0 : _a22.some((x) => x.pattern))) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern
+      });
+      delete schema.pattern;
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    schema.pattern = stringifyRegExpWithFlags(regex, refs);
+  }
+}
+function stringifyRegExpWithFlags(regex, refs) {
+  var _a22;
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    // Case-insensitive
+    m: regex.flags.includes("m"),
+    // `^` and `$` matches adjacent to newline characters
+    s: regex.flags.includes("s")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === "-" && ((_a22 = source[i + 2]) == null ? void 0 : _a22.match(/[a-z]/))) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === "[") {
+      inCharGroup = true;
+    }
+  }
+  try {
+    new RegExp(pattern);
+  } catch (e) {
+    console.warn(
+      `Could not convert regex pattern at ${refs.currentPath.join(
+        "/"
+      )} to a flag-independent form! Falling back to the flag-ignorant source`
+    );
+    return regex.source;
+  }
+  return pattern;
+}
+function parseRecordDef(def, refs) {
+  var _a22, _b22, _c, _d, _e, _f;
+  const schema = {
+    type: "object",
+    additionalProperties: (_a22 = parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    })) != null ? _a22 : refs.allowedAdditionalProperties
+  };
+  if (((_b22 = def.keyType) == null ? void 0 : _b22._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v33.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
+    const { type, ...keyType } = parseBrandedDef(
+      def.keyType._def,
+      refs
+    );
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || parseAnyDef();
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef();
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+function parseNativeEnumDef(def) {
+  const object = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object[object[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object[key]);
+  const parsedTypes = Array.from(
+    new Set(actualValues.map((values) => typeof values))
+  );
+  return {
+    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: actualValues
+  };
+}
+function parseNeverDef() {
+  return { not: parseAnyDef() };
+}
+function parseNullDef() {
+  return {
+    type: "null"
+  };
+}
+var primitiveMappings = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every(
+    (x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length)
+  )) {
+    const types = options.reduce((types2, x) => {
+      const type = primitiveMappings[x._def.typeName];
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options.reduce(
+      (acc, x) => {
+        const type = typeof x._def.value;
+        switch (type) {
+          case "string":
+          case "number":
+          case "boolean":
+            return [...acc, type];
+          case "bigint":
+            return [...acc, "integer"];
+          case "object":
+            if (x._def.value === null) return [...acc, "null"];
+          case "symbol":
+          case "undefined":
+          case "function":
+          default:
+            return acc;
+        }
+      },
+      []
+    );
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce(
+          (acc, x) => {
+            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+          },
+          []
+        )
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce(
+        (acc, x) => [
+          ...acc,
+          ...x._def.values.filter((x2) => !acc.includes(x2))
+        ],
+        []
+      )
+    };
+  }
+  return asAnyOf(def, refs);
+}
+var asAnyOf = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
+    (x, i) => parseDef(x._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "anyOf", `${i}`]
+    })
+  ).filter(
+    (x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
+  );
+  return anyOf.length ? { anyOf } : void 0;
+};
+function parseNullableDef(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
+    def.innerType._def.typeName
+  ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    return {
+      type: [
+        primitiveMappings[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+function parseNumberDef(def) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks) return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "int":
+        res.type = "integer";
+        break;
+      case "min":
+        if (check.inclusive) {
+          res.minimum = check.value;
+        } else {
+          res.exclusiveMinimum = check.value;
+        }
+        break;
+      case "max":
+        if (check.inclusive) {
+          res.maximum = check.value;
+        } else {
+          res.exclusiveMaximum = check.value;
+        }
+        break;
+      case "multipleOf":
+        res.multipleOf = check.value;
+        break;
+    }
+  }
+  return res;
+}
+function parseObjectDef(def, refs) {
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  const shape = def.shape();
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    if (propDef === void 0 || propDef._def === void 0) {
+      continue;
+    }
+    const propOptional = safeIsOptional(propDef);
+    const parsedDef = parseDef(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "properties", propName],
+      propertyPath: [...refs.currentPath, "properties", propName]
+    });
+    if (parsedDef === void 0) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+  if (required.length) {
+    result.required = required;
+  }
+  const additionalProperties = decideAdditionalProperties(def, refs);
+  if (additionalProperties !== void 0) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") {
+    return parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    });
+  }
+  switch (def.unknownKeys) {
+    case "passthrough":
+      return refs.allowedAdditionalProperties;
+    case "strict":
+      return refs.rejectedAdditionalProperties;
+    case "strip":
+      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+  }
+}
+function safeIsOptional(schema) {
+  try {
+    return schema.isOptional();
+  } catch (e) {
+    return true;
+  }
+}
+var parseOptionalDef = (def, refs) => {
+  var _a22;
+  if (refs.currentPath.toString() === ((_a22 = refs.propertyPath) == null ? void 0 : _a22.toString())) {
+    return parseDef(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? { anyOf: [{ not: parseAnyDef() }, innerSchema] } : parseAnyDef();
+};
+var parsePipelineDef = (def, refs) => {
+  if (refs.pipeStrategy === "input") {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef(def.out._def, refs);
+  }
+  const a = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+  });
+  return {
+    allOf: [a, b].filter((x) => x !== void 0)
+  };
+};
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+function parseSetDef(def, refs) {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.minSize) {
+    schema.minItems = def.minSize.value;
+  }
+  if (def.maxSize) {
+    schema.maxItems = def.maxSize.value;
+  }
+  return schema;
+}
+function parseTupleDef(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map(
+        (x, i) => parseDef(x._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "items", `${i}`]
+        })
+      ).reduce(
+        (acc, x) => x === void 0 ? acc : [...acc, x],
+        []
+      ),
+      additionalItems: parseDef(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map(
+        (x, i) => parseDef(x._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "items", `${i}`]
+        })
+      ).reduce(
+        (acc, x) => x === void 0 ? acc : [...acc, x],
+        []
+      )
+    };
+  }
+}
+function parseUndefinedDef() {
+  return {
+    not: parseAnyDef()
+  };
+}
+function parseUnknownDef() {
+  return parseAnyDef();
+}
+var parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+var selectParser = (def, typeName, refs) => {
+  switch (typeName) {
+    case import_v3.ZodFirstPartyTypeKind.ZodString:
+      return parseStringDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodNumber:
+      return parseNumberDef(def);
+    case import_v3.ZodFirstPartyTypeKind.ZodObject:
+      return parseObjectDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodBigInt:
+      return parseBigintDef(def);
+    case import_v3.ZodFirstPartyTypeKind.ZodBoolean:
+      return parseBooleanDef();
+    case import_v3.ZodFirstPartyTypeKind.ZodDate:
+      return parseDateDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodUndefined:
+      return parseUndefinedDef();
+    case import_v3.ZodFirstPartyTypeKind.ZodNull:
+      return parseNullDef();
+    case import_v3.ZodFirstPartyTypeKind.ZodArray:
+      return parseArrayDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodUnion:
+    case import_v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodTuple:
+      return parseTupleDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodRecord:
+      return parseRecordDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodLiteral:
+      return parseLiteralDef(def);
+    case import_v3.ZodFirstPartyTypeKind.ZodEnum:
+      return parseEnumDef(def);
+    case import_v3.ZodFirstPartyTypeKind.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case import_v3.ZodFirstPartyTypeKind.ZodNullable:
+      return parseNullableDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodMap:
+      return parseMapDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodSet:
+      return parseSetDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodLazy:
+      return () => def.getter()._def;
+    case import_v3.ZodFirstPartyTypeKind.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodNaN:
+    case import_v3.ZodFirstPartyTypeKind.ZodNever:
+      return parseNeverDef();
+    case import_v3.ZodFirstPartyTypeKind.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodAny:
+      return parseAnyDef();
+    case import_v3.ZodFirstPartyTypeKind.ZodUnknown:
+      return parseUnknownDef();
+    case import_v3.ZodFirstPartyTypeKind.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodCatch:
+      return parseCatchDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case import_v3.ZodFirstPartyTypeKind.ZodFunction:
+    case import_v3.ZodFirstPartyTypeKind.ZodVoid:
+    case import_v3.ZodFirstPartyTypeKind.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)(typeName);
+  }
+};
+var getRelativePath = (pathA, pathB) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i]) break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+function parseDef(def, refs, forceResolution = false) {
+  var _a22;
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = (_a22 = refs.override) == null ? void 0 : _a22.call(
+      refs,
+      def,
+      refs,
+      seenItem,
+      forceResolution
+    );
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+    if (seenSchema !== void 0) {
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+  const jsonSchema2 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema2) {
+    addMeta(def, refs, jsonSchema2);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema2, def, refs);
+    newItem.jsonSchema = jsonSchema2;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema2;
+  return jsonSchema2;
 }
-function secureJsonParse(text) {
-  const { stackTraceLimit } = Error;
-  try {
-    Error.stackTraceLimit = 0;
-  } catch (e) {
-    return _parse(text);
+var get$ref = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case "none":
+    case "seen": {
+      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+        console.warn(
+          `Recursive reference detected at ${refs.currentPath.join(
+            "/"
+          )}! Defaulting to any`
+        );
+        return parseAnyDef();
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef() : void 0;
+    }
   }
-  try {
-    return _parse(text);
-  } finally {
-    Error.stackTraceLimit = stackTraceLimit;
+};
+var addMeta = (def, refs, jsonSchema2) => {
+  if (def.description) {
+    jsonSchema2.description = def.description;
+  }
+  return jsonSchema2;
+};
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(
+      Object.entries(_options.definitions).map(([name22, def]) => [
+        def._def,
+        {
+          def: def._def,
+          path: [..._options.basePath, _options.definitionPath, name22],
+          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+          jsonSchema: void 0
+        }
+      ])
+    )
+  };
+};
+var zod3ToJsonSchema = (schema, options) => {
+  var _a22;
+  const refs = getRefs(options);
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
+    (acc, [name32, schema2]) => {
+      var _a32;
+      return {
+        ...acc,
+        [name32]: (_a32 = parseDef(
+          schema2._def,
+          {
+            ...refs,
+            currentPath: [...refs.basePath, refs.definitionPath, name32]
+          },
+          true
+        )) != null ? _a32 : parseAnyDef()
+      };
+    },
+    {}
+  ) : void 0;
+  const name22 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
+  const main = (_a22 = parseDef(
+    schema._def,
+    name22 === void 0 ? refs : {
+      ...refs,
+      currentPath: [...refs.basePath, refs.definitionPath, name22]
+    },
+    false
+  )) != null ? _a22 : parseAnyDef();
+  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+  if (title !== void 0) {
+    main.title = title;
   }
+  const combined = name22 === void 0 ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name22
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name22]: main
+    }
+  };
+  combined.$schema = "http://json-schema.org/draft-07/schema#";
+  return combined;
+};
+var schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
+function jsonSchema(jsonSchema2, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol]: true,
+    _type: void 0,
+    // should never be used directly
+    get jsonSchema() {
+      if (typeof jsonSchema2 === "function") {
+        jsonSchema2 = jsonSchema2();
+      }
+      return jsonSchema2;
+    },
+    validate
+  };
 }
-var validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
-function validator(validate) {
-  return { [validatorSymbol]: true, validate };
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
 }
-function isValidator(value) {
-  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
+function asSchema(schema) {
+  return schema == null ? jsonSchema({ properties: {}, additionalProperties: false }) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
 }
-function asValidator(value) {
-  return isValidator(value) ? value : typeof value === "function" ? value() : standardSchemaValidator(value);
+function standardSchema(standardSchema2) {
+  return jsonSchema(
+    () => addAdditionalPropertiesToJsonSchema(
+      standardSchema2["~standard"].jsonSchema.input({
+        target: "draft-07"
+      })
+    ),
+    {
+      validate: async (value) => {
+        const result = await standardSchema2["~standard"].validate(value);
+        return "value" in result ? { success: true, value: result.value } : {
+          success: false,
+          error: new TypeValidationError({
+            value,
+            cause: result.issues
+          })
+        };
+      }
+    }
+  );
 }
-function standardSchemaValidator(standardSchema) {
-  return validator(async (value) => {
-    const result = await standardSchema["~standard"].validate(value);
-    return result.issues == null ? { success: true, value: result.value } : {
-      success: false,
-      error: new TypeValidationError({
-        value,
-        cause: result.issues
+function zod3Schema(zodSchema2, options) {
+  var _a22;
+  const useReferences = (_a22 = options == null ? void 0 : options.useReferences) != null ? _a22 : false;
+  return jsonSchema(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => zod3ToJsonSchema(zodSchema2, {
+      $refStrategy: useReferences ? "root" : "none"
+    }),
+    {
+      validate: async (value) => {
+        const result = await zodSchema2.safeParseAsync(value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+function zod4Schema(zodSchema2, options) {
+  var _a22;
+  const useReferences = (_a22 = options == null ? void 0 : options.useReferences) != null ? _a22 : false;
+  return jsonSchema(
+    // defer json schema creation to avoid unnecessary computation when only validation is needed
+    () => addAdditionalPropertiesToJsonSchema(
+      z4.toJSONSchema(zodSchema2, {
+        target: "draft-7",
+        io: "input",
+        reused: useReferences ? "ref" : "inline"
       })
-    };
-  });
+    ),
+    {
+      validate: async (value) => {
+        const result = await z4.safeParseAsync(zodSchema2, value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+function isZod4Schema(zodSchema2) {
+  return "_zod" in zodSchema2;
+}
+function zodSchema(zodSchema2, options) {
+  if (isZod4Schema(zodSchema2)) {
+    return zod4Schema(zodSchema2, options);
+  } else {
+    return zod3Schema(zodSchema2, options);
+  }
 }
 async function validateTypes({
   value,
-  schema
+  schema,
+  context
 }) {
-  const result = await safeValidateTypes({ value, schema });
+  const result = await safeValidateTypes({ value, schema, context });
   if (!result.success) {
-    throw TypeValidationError.wrap({ value, cause: result.error });
+    throw TypeValidationError.wrap({ value, cause: result.error, context });
   }
   return result.value;
 }
 async function safeValidateTypes({
   value,
-  schema
+  schema,
+  context
 }) {
-  const validator2 = asValidator(schema);
+  const actualSchema = asSchema(schema);
   try {
-    if (validator2.validate == null) {
+    if (actualSchema.validate == null) {
       return { success: true, value, rawValue: value };
     }
-    const result = await validator2.validate(value);
+    const result = await actualSchema.validate(value);
     if (result.success) {
       return { success: true, value: result.value, rawValue: value };
     }
     return {
       success: false,
-      error: TypeValidationError.wrap({ value, cause: result.error }),
+      error: TypeValidationError.wrap({ value, cause: result.error, context }),
       rawValue: value
     };
   } catch (error) {
     return {
       success: false,
-      error: TypeValidationError.wrap({ value, cause: error }),
+      error: TypeValidationError.wrap({ value, cause: error, context }),
       rawValue: value
     };
   }
@@ -791,7 +2293,7 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch
+  fetch: fetch2
 }) => postToApi({
   url,
   headers: {
@@ -805,7 +2307,27 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch
+  fetch: fetch2
+});
+var postFormDataToApi = async ({
+  url,
+  headers,
+  formData,
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch: fetch2
+}) => postToApi({
+  url,
+  headers,
+  body: {
+    content: formData,
+    values: Object.fromEntries(formData.entries())
+  },
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch: fetch2
 });
 var postToApi = async ({
   url,
@@ -814,10 +2336,10 @@ var postToApi = async ({
   successfulResponseHandler,
   failedResponseHandler,
   abortSignal,
-  fetch = getOriginalFetch2()
+  fetch: fetch2 = getOriginalFetch2()
 }) => {
   try {
-    const response = await fetch(url, {
+    const response = await fetch2(url, {
       method: "POST",
       headers: withUserAgentSuffix(
         headers,
@@ -967,25 +2489,11 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
     rawValue: parsedResult.rawValue
   };
 };
-var ALPHA_NUMERIC = new Set(
-  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
-);
-var { btoa, atob } = globalThis;
-function convertUint8ArrayToBase64(array) {
-  let latin1string = "";
-  for (let i = 0; i < array.length; i++) {
-    latin1string += String.fromCodePoint(array[i]);
-  }
-  return btoa(latin1string);
-}
-function convertToBase64(value) {
-  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
-}
 function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
 
-// node_modules/.pnpm/@ai-sdk+openai-compatible@1.0.30_zod@3.25.76/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
+// node_modules/.pnpm/@ai-sdk+openai-compatible@2.0.41_zod@3.25.76/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
 var import_v4 = require("zod/v4");
 var import_v42 = require("zod/v4");
 var import_v43 = require("zod/v4");
@@ -994,11 +2502,85 @@ var import_v45 = require("zod/v4");
 var import_v46 = require("zod/v4");
 var import_v47 = require("zod/v4");
 var import_v48 = require("zod/v4");
+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;
+}
+var openaiCompatibleErrorDataSchema = import_v42.z.object({
+  error: import_v42.z.object({
+    message: import_v42.z.string(),
+    // The additional information below is handled loosely to support
+    // OpenAI-compatible providers that have slightly different error
+    // responses:
+    type: import_v42.z.string().nullish(),
+    param: import_v42.z.any().nullish(),
+    code: import_v42.z.union([import_v42.z.string(), import_v42.z.number()]).nullish()
+  })
+});
+var defaultOpenAICompatibleErrorStructure = {
+  errorSchema: openaiCompatibleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+};
+function convertOpenAICompatibleChatUsage(usage) {
+  var _a16, _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 = (_a16 = usage.prompt_tokens) != null ? _a16 : 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: completionTokens - reasoningTokens,
+      reasoning: reasoningTokens
+    },
+    raw: usage
+  };
+}
 function getOpenAIMetadata(message) {
-  var _a15, _b15;
-  return (_b15 = (_a15 = message == null ? void 0 : message.providerOptions) == null ? void 0 : _a15.openaiCompatible) != null ? _b15 : {};
+  var _a16, _b16;
+  return (_b16 = (_a16 = message == null ? void 0 : message.providerOptions) == null ? void 0 : _a16.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 _a16, _b16, _c;
   const messages = [];
   for (const { role, content, ...message } of prompt) {
     const metadata = getOpenAIMetadata({ ...message });
@@ -1019,6 +2601,7 @@ function convertToOpenAICompatibleChatMessages(prompt) {
         messages.push({
           role: "user",
           content: content.map((part) => {
+            var _a22;
             const partMetadata = getOpenAIMetadata(part);
             switch (part.type) {
               case "text": {
@@ -1034,11 +2617,56 @@ function convertToOpenAICompatibleChatMessages(prompt) {
                     },
                     ...partMetadata
                   };
-                } else {
-                  throw new UnsupportedFunctionalityError({
-                    functionality: `file part media type ${part.mediaType}`
-                  });
                 }
+                if (part.mediaType.startsWith("audio/")) {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "audio file parts with URLs"
+                    });
+                  }
+                  const format = getAudioFormat(part.mediaType);
+                  if (format === null) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: `audio media type ${part.mediaType}`
+                    });
+                  }
+                  return {
+                    type: "input_audio",
+                    input_audio: {
+                      data: convertToBase64(part.data),
+                      format
+                    },
+                    ...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}`
+                });
               }
             }
           }),
@@ -1048,6 +2676,7 @@ function convertToOpenAICompatibleChatMessages(prompt) {
       }
       case "assistant": {
         let text = "";
+        let reasoning = "";
         const toolCalls = [];
         for (const part of content) {
           const partMetadata = getOpenAIMetadata(part);
@@ -1056,7 +2685,12 @@ function convertToOpenAICompatibleChatMessages(prompt) {
               text += part.text;
               break;
             }
+            case "reasoning": {
+              reasoning += part.text;
+              break;
+            }
             case "tool-call": {
+              const thoughtSignature = (_b16 = (_a16 = part.providerOptions) == null ? void 0 : _a16.google) == null ? void 0 : _b16.thoughtSignature;
               toolCalls.push({
                 id: part.toolCallId,
                 type: "function",
@@ -1064,7 +2698,15 @@ function convertToOpenAICompatibleChatMessages(prompt) {
                   name: part.toolName,
                   arguments: JSON.stringify(part.input)
                 },
-                ...partMetadata
+                ...partMetadata,
+                // Include extra_content for Google Gemini thought signatures
+                ...thoughtSignature ? {
+                  extra_content: {
+                    google: {
+                      thought_signature: String(thoughtSignature)
+                    }
+                  }
+                } : {}
               });
               break;
             }
@@ -1073,6 +2715,7 @@ function convertToOpenAICompatibleChatMessages(prompt) {
         messages.push({
           role: "assistant",
           content: text,
+          ...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
           tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
           ...metadata
         });
@@ -1080,6 +2723,9 @@ function convertToOpenAICompatibleChatMessages(prompt) {
       }
       case "tool": {
         for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
           const output = toolResponse.output;
           let contentValue;
           switch (output.type) {
@@ -1087,6 +2733,9 @@ function convertToOpenAICompatibleChatMessages(prompt) {
             case "error-text":
               contentValue = output.value;
               break;
+            case "execution-denied":
+              contentValue = (_c = output.reason) != null ? _c : "Tool execution denied.";
+              break;
             case "content":
             case "json":
             case "error-json":
@@ -1134,39 +2783,32 @@ function mapOpenAICompatibleFinishReason(finishReason) {
     case "tool_calls":
       return "tool-calls";
     default:
-      return "unknown";
+      return "other";
   }
 }
-var openaiCompatibleProviderOptions = import_v42.z.object({
+var openaiCompatibleLanguageModelChatOptions = import_v43.z.object({
   /**
    * A unique identifier representing your end-user, which can help the provider to
    * monitor and detect abuse.
    */
-  user: import_v42.z.string().optional(),
+  user: import_v43.z.string().optional(),
   /**
    * Reasoning effort for reasoning models. Defaults to `medium`.
    */
-  reasoningEffort: import_v42.z.string().optional(),
+  reasoningEffort: import_v43.z.string().optional(),
   /**
    * Controls the verbosity of the generated text. Defaults to `medium`.
    */
-  textVerbosity: import_v42.z.string().optional()
-});
-var openaiCompatibleErrorDataSchema = import_v43.z.object({
-  error: import_v43.z.object({
-    message: import_v43.z.string(),
-    // The additional information below is handled loosely to support
-    // OpenAI-compatible providers that have slightly different error
-    // responses:
-    type: import_v43.z.string().nullish(),
-    param: import_v43.z.any().nullish(),
-    code: import_v43.z.union([import_v43.z.string(), import_v43.z.number()]).nullish()
-  })
+  textVerbosity: import_v43.z.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: import_v43.z.boolean().optional()
 });
-var defaultOpenAICompatibleErrorStructure = {
-  errorSchema: openaiCompatibleErrorDataSchema,
-  errorToMessage: (data) => data.error.message
-};
 function prepareTools({
   tools,
   toolChoice
@@ -1178,15 +2820,19 @@ function prepareTools({
   }
   const openaiCompatTools = [];
   for (const tool of tools) {
-    if (tool.type === "provider-defined") {
-      toolWarnings.push({ type: "unsupported-tool", tool });
+    if (tool.type === "provider") {
+      toolWarnings.push({
+        type: "unsupported",
+        feature: `provider-defined tool ${tool.id}`
+      });
     } else {
       openaiCompatTools.push({
         type: "function",
         function: {
           name: tool.name,
           description: tool.description,
-          parameters: tool.inputSchema
+          parameters: tool.inputSchema,
+          ...tool.strict != null ? { strict: tool.strict } : {}
         }
       });
     }
@@ -1220,16 +2866,16 @@ function prepareTools({
 var OpenAICompatibleChatLanguageModel = class {
   // type inferred via constructor
   constructor(modelId, config) {
-    this.specificationVersion = "v2";
-    var _a15, _b15;
+    this.specificationVersion = "v3";
+    var _a16, _b16;
     this.modelId = modelId;
     this.config = config;
-    const errorStructure = (_a15 = config.errorStructure) != null ? _a15 : defaultOpenAICompatibleErrorStructure;
+    const errorStructure = (_a16 = config.errorStructure) != null ? _a16 : defaultOpenAICompatibleErrorStructure;
     this.chunkSchema = createOpenAICompatibleChatChunkSchema(
       errorStructure.errorSchema
     );
     this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
-    this.supportsStructuredOutputs = (_b15 = config.supportsStructuredOutputs) != null ? _b15 : false;
+    this.supportsStructuredOutputs = (_b16 = config.supportsStructuredOutputs) != null ? _b16 : false;
   }
   get provider() {
     return this.config.provider;
@@ -1238,8 +2884,12 @@ var OpenAICompatibleChatLanguageModel = class {
     return this.config.provider.split(".")[0].trim();
   }
   get supportedUrls() {
-    var _a15, _b15, _c;
-    return (_c = (_b15 = (_a15 = this.config).supportedUrls) == null ? void 0 : _b15.call(_a15)) != null ? _c : {};
+    var _a16, _b16, _c;
+    return (_c = (_b16 = (_a16 = this.config).supportedUrls) == null ? void 0 : _b16.call(_a16)) != null ? _c : {};
+  }
+  transformRequestBody(args) {
+    var _a16, _b16, _c;
+    return (_c = (_b16 = (_a16 = this.config).transformRequestBody) == null ? void 0 : _b16.call(_a16, args)) != null ? _c : args;
   }
   async getArgs({
     prompt,
@@ -1256,27 +2906,45 @@ var OpenAICompatibleChatLanguageModel = class {
     toolChoice,
     tools
   }) {
-    var _a15, _b15, _c, _d;
+    var _a16, _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(
-      (_a15 = await parseProviderOptions({
-        provider: "openai-compatible",
+      deprecatedOptions != null ? deprecatedOptions : {},
+      (_a16 = await parseProviderOptions({
+        provider: "openaiCompatible",
         providerOptions,
-        schema: openaiCompatibleProviderOptions
-      })) != null ? _a15 : {},
-      (_b15 = await parseProviderOptions({
+        schema: openaiCompatibleLanguageModelChatOptions
+      })) != null ? _a16 : {},
+      (_b16 = await parseProviderOptions({
         provider: this.providerOptionsName,
         providerOptions,
-        schema: openaiCompatibleProviderOptions
-      })) != null ? _b15 : {}
+        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-setting", setting: "topK" });
+      warnings.push({ type: "unsupported", feature: "topK" });
     }
     if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "responseFormat",
+        type: "unsupported",
+        feature: "responseFormat",
         details: "JSON response format schema is only supported with structuredOutputs"
       });
     }
@@ -1288,7 +2956,12 @@ var OpenAICompatibleChatLanguageModel = class {
       tools,
       toolChoice
     });
+    const metadataKey = resolveProviderOptionsKey(
+      this.providerOptionsName,
+      providerOptions
+    );
     return {
+      metadataKey,
       args: {
         // model id:
         model: this.modelId,
@@ -1304,17 +2977,21 @@ var OpenAICompatibleChatLanguageModel = class {
           type: "json_schema",
           json_schema: {
             schema: responseFormat.schema,
-            name: (_c = responseFormat.name) != null ? _c : "response",
+            strict: strictJsonSchema,
+            name: (_e = responseFormat.name) != null ? _e : "response",
             description: responseFormat.description
           }
         } : { type: "json_object" } : void 0,
         stop: stopSequences,
         seed,
         ...Object.fromEntries(
-          Object.entries(
-            (_d = providerOptions == null ? void 0 : providerOptions[this.providerOptionsName]) != null ? _d : {}
-          ).filter(
-            ([key]) => !Object.keys(openaiCompatibleProviderOptions.shape).includes(key)
+          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,
@@ -1329,9 +3006,10 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a15, _b15, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
-    const { args, warnings } = await this.getArgs({ ...options });
-    const body = JSON.stringify(args);
+    var _a16, _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,
@@ -1342,7 +3020,7 @@ var OpenAICompatibleChatLanguageModel = class {
         modelId: this.modelId
       }),
       headers: combineHeaders(this.config.headers(), options.headers),
-      body: args,
+      body: transformedBody,
       failedResponseHandler: this.failedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
         OpenAICompatibleChatResponseSchema
@@ -1356,7 +3034,7 @@ var OpenAICompatibleChatLanguageModel = class {
     if (text != null && text.length > 0) {
       content.push({ type: "text", text });
     }
-    const reasoning = (_a15 = choice.message.reasoning_content) != null ? _a15 : choice.message.reasoning;
+    const reasoning = (_a16 = choice.message.reasoning_content) != null ? _a16 : choice.message.reasoning;
     if (reasoning != null && reasoning.length > 0) {
       content.push({
         type: "reasoning",
@@ -1365,37 +3043,40 @@ var OpenAICompatibleChatLanguageModel = class {
     }
     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: (_b15 = toolCall.id) != null ? _b15 : generateId(),
+          toolCallId: (_d = toolCall.id) != null ? _d : generateId(),
           toolName: toolCall.function.name,
-          input: toolCall.function.arguments
+          input: toolCall.function.arguments,
+          ...thoughtSignature ? {
+            providerMetadata: {
+              [metadataKey]: { thoughtSignature }
+            }
+          } : {}
         });
       }
     }
     const providerMetadata = {
-      [this.providerOptionsName]: {},
-      ...await ((_d = (_c = this.config.metadataExtractor) == null ? void 0 : _c.extractMetadata) == null ? void 0 : _d.call(_c, {
+      [metadataKey]: {},
+      ...await ((_f = (_e = this.config.metadataExtractor) == null ? void 0 : _e.extractMetadata) == null ? void 0 : _f.call(_e, {
         parsedBody: rawResponse
       }))
     };
-    const completionTokenDetails = (_e = responseBody.usage) == null ? void 0 : _e.completion_tokens_details;
+    const completionTokenDetails = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens_details;
     if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
-      providerMetadata[this.providerOptionsName].acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
+      providerMetadata[metadataKey].acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
     }
     if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
-      providerMetadata[this.providerOptionsName].rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
+      providerMetadata[metadataKey].rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
     }
     return {
       content,
-      finishReason: mapOpenAICompatibleFinishReason(choice.finish_reason),
-      usage: {
-        inputTokens: (_g = (_f = responseBody.usage) == null ? void 0 : _f.prompt_tokens) != null ? _g : void 0,
-        outputTokens: (_i = (_h = responseBody.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : void 0,
-        totalTokens: (_k = (_j = responseBody.usage) == null ? void 0 : _j.total_tokens) != null ? _k : void 0,
-        reasoningTokens: (_n = (_m = (_l = responseBody.usage) == null ? void 0 : _l.completion_tokens_details) == null ? void 0 : _m.reasoning_tokens) != null ? _n : void 0,
-        cachedInputTokens: (_q = (_p = (_o = responseBody.usage) == null ? void 0 : _o.prompt_tokens_details) == null ? void 0 : _p.cached_tokens) != null ? _q : void 0
+      finishReason: {
+        unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+        raw: (_h = choice.finish_reason) != null ? _h : void 0
       },
+      usage: convertOpenAICompatibleChatUsage(responseBody.usage),
       providerMetadata,
       request: { body },
       response: {
@@ -1407,15 +3088,15 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
   async doStream(options) {
-    var _a15;
-    const { args, warnings } = await this.getArgs({ ...options });
-    const body = {
+    var _a16;
+    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 = (_a15 = this.config.metadataExtractor) == null ? void 0 : _a15.createStreamExtractor();
+    });
+    const metadataExtractor = (_a16 = this.config.metadataExtractor) == null ? void 0 : _a16.createStreamExtractor();
     const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
@@ -1431,22 +3112,13 @@ var OpenAICompatibleChatLanguageModel = class {
       fetch: this.config.fetch
     });
     const toolCalls = [];
-    let finishReason = "unknown";
-    const usage = {
-      completionTokens: void 0,
-      completionTokensDetails: {
-        reasoningTokens: void 0,
-        acceptedPredictionTokens: void 0,
-        rejectedPredictionTokens: void 0
-      },
-      promptTokens: void 0,
-      promptTokensDetails: {
-        cachedTokens: void 0
-      },
-      totalTokens: void 0
+    let finishReason = {
+      unified: "other",
+      raw: void 0
     };
+    let usage = void 0;
     let isFirstChunk = true;
-    const providerOptionsName = this.providerOptionsName;
+    const providerOptionsName = metadataKey;
     let isActiveReasoning = false;
     let isActiveText = false;
     return {
@@ -1455,24 +3127,26 @@ var OpenAICompatibleChatLanguageModel = class {
           start(controller) {
             controller.enqueue({ type: "stream-start", warnings });
           },
-          // TODO we lost type safety on Chunk, most likely due to the error schema. MUST FIX
           transform(chunk, controller) {
-            var _a22, _b15, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+            var _a22, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
             if (!chunk.success) {
-              finishReason = "error";
+              finishReason = { unified: "error", raw: void 0 };
               controller.enqueue({ type: "error", error: chunk.error });
               return;
             }
-            const value = chunk.value;
             metadataExtractor == null ? void 0 : metadataExtractor.processChunk(chunk.rawValue);
-            if ("error" in value) {
-              finishReason = "error";
-              controller.enqueue({ type: "error", error: value.error.message });
+            if ("error" in chunk.value) {
+              finishReason = { unified: "error", raw: void 0 };
+              controller.enqueue({
+                type: "error",
+                error: chunk.value.error.message
+              });
               return;
             }
+            const value = chunk.value;
             if (isFirstChunk) {
               isFirstChunk = false;
               controller.enqueue({
@@ -1481,40 +3155,20 @@ var OpenAICompatibleChatLanguageModel = class {
               });
             }
             if (value.usage != null) {
-              const {
-                prompt_tokens,
-                completion_tokens,
-                total_tokens,
-                prompt_tokens_details,
-                completion_tokens_details
-              } = value.usage;
-              usage.promptTokens = prompt_tokens != null ? prompt_tokens : void 0;
-              usage.completionTokens = completion_tokens != null ? completion_tokens : void 0;
-              usage.totalTokens = total_tokens != null ? total_tokens : void 0;
-              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens) != null) {
-                usage.completionTokensDetails.reasoningTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens;
-              }
-              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.accepted_prediction_tokens) != null) {
-                usage.completionTokensDetails.acceptedPredictionTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.accepted_prediction_tokens;
-              }
-              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.rejected_prediction_tokens) != null) {
-                usage.completionTokensDetails.rejectedPredictionTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.rejected_prediction_tokens;
-              }
-              if ((prompt_tokens_details == null ? void 0 : prompt_tokens_details.cached_tokens) != null) {
-                usage.promptTokensDetails.cachedTokens = prompt_tokens_details == null ? void 0 : prompt_tokens_details.cached_tokens;
-              }
+              usage = value.usage;
             }
             const choice = value.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
-              finishReason = mapOpenAICompatibleFinishReason(
-                choice.finish_reason
-              );
+              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 reasoningContent = (_a22 = delta.reasoning_content) != null ? _a22 : delta.reasoning;
+            const reasoningContent = (_b16 = delta.reasoning_content) != null ? _b16 : delta.reasoning;
             if (reasoningContent) {
               if (!isActiveReasoning) {
                 controller.enqueue({
@@ -1530,6 +3184,13 @@ var OpenAICompatibleChatLanguageModel = class {
               });
             }
             if (delta.content) {
+              if (isActiveReasoning) {
+                controller.enqueue({
+                  type: "reasoning-end",
+                  id: "reasoning-0"
+                });
+                isActiveReasoning = false;
+              }
               if (!isActiveText) {
                 controller.enqueue({ type: "text-start", id: "txt-0" });
                 isActiveText = true;
@@ -1541,8 +3202,15 @@ var OpenAICompatibleChatLanguageModel = class {
               });
             }
             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 = toolCallDelta.index;
+                const index = (_c = toolCallDelta.index) != null ? _c : toolCalls.length;
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.id == null) {
                     throw new InvalidResponseDataError({
@@ -1550,7 +3218,7 @@ var OpenAICompatibleChatLanguageModel = class {
                       message: `Expected 'id' to be a string.`
                     });
                   }
-                  if (((_b15 = toolCallDelta.function) == null ? void 0 : _b15.name) == null) {
+                  if (((_d = toolCallDelta.function) == null ? void 0 : _d.name) == null) {
                     throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
@@ -1566,12 +3234,13 @@ var OpenAICompatibleChatLanguageModel = class {
                     type: "function",
                     function: {
                       name: toolCallDelta.function.name,
-                      arguments: (_c = toolCallDelta.function.arguments) != null ? _c : ""
+                      arguments: (_e = toolCallDelta.function.arguments) != null ? _e : ""
                     },
-                    hasFinished: false
+                    hasFinished: false,
+                    thoughtSignature: (_h = (_g = (_f = toolCallDelta.extra_content) == null ? void 0 : _f.google) == null ? void 0 : _g.thought_signature) != null ? _h : void 0
                   };
                   const toolCall2 = toolCalls[index];
-                  if (((_d = toolCall2.function) == null ? void 0 : _d.name) != null && ((_e = toolCall2.function) == null ? void 0 : _e.arguments) != null) {
+                  if (((_i = toolCall2.function) == null ? void 0 : _i.name) != null && ((_j = toolCall2.function) == null ? void 0 : _j.arguments) != null) {
                     if (toolCall2.function.arguments.length > 0) {
                       controller.enqueue({
                         type: "tool-input-delta",
@@ -1586,9 +3255,16 @@ var OpenAICompatibleChatLanguageModel = class {
                       });
                       controller.enqueue({
                         type: "tool-call",
-                        toolCallId: (_f = toolCall2.id) != null ? _f : generateId(),
+                        toolCallId: (_k = toolCall2.id) != null ? _k : generateId(),
                         toolName: toolCall2.function.name,
-                        input: toolCall2.function.arguments
+                        input: toolCall2.function.arguments,
+                        ...toolCall2.thoughtSignature ? {
+                          providerMetadata: {
+                            [providerOptionsName]: {
+                              thoughtSignature: toolCall2.thoughtSignature
+                            }
+                          }
+                        } : {}
                       });
                       toolCall2.hasFinished = true;
                     }
@@ -1599,24 +3275,31 @@ var OpenAICompatibleChatLanguageModel = class {
                 if (toolCall.hasFinished) {
                   continue;
                 }
-                if (((_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null) {
-                  toolCall.function.arguments += (_i = (_h = toolCallDelta.function) == null ? void 0 : _h.arguments) != null ? _i : "";
+                if (((_l = toolCallDelta.function) == null ? void 0 : _l.arguments) != null) {
+                  toolCall.function.arguments += (_n = (_m = toolCallDelta.function) == null ? void 0 : _m.arguments) != null ? _n : "";
                 }
                 controller.enqueue({
                   type: "tool-input-delta",
                   id: toolCall.id,
-                  delta: (_j = toolCallDelta.function.arguments) != null ? _j : ""
+                  delta: (_o = toolCallDelta.function.arguments) != null ? _o : ""
                 });
-                if (((_k = toolCall.function) == null ? void 0 : _k.name) != null && ((_l = toolCall.function) == null ? void 0 : _l.arguments) != null && isParsableJson(toolCall.function.arguments)) {
+                if (((_p = toolCall.function) == null ? void 0 : _p.name) != null && ((_q = toolCall.function) == null ? void 0 : _q.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-input-end",
                     id: toolCall.id
                   });
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallId: (_m = toolCall.id) != null ? _m : generateId(),
+                    toolCallId: (_r = toolCall.id) != null ? _r : generateId(),
                     toolName: toolCall.function.name,
-                    input: toolCall.function.arguments
+                    input: toolCall.function.arguments,
+                    ...toolCall.thoughtSignature ? {
+                      providerMetadata: {
+                        [providerOptionsName]: {
+                          thoughtSignature: toolCall.thoughtSignature
+                        }
+                      }
+                    } : {}
                   });
                   toolCall.hasFinished = true;
                 }
@@ -1624,7 +3307,7 @@ var OpenAICompatibleChatLanguageModel = class {
             }
           },
           flush(controller) {
-            var _a22, _b15, _c, _d, _e, _f;
+            var _a22, _b16, _c, _d, _e;
             if (isActiveReasoning) {
               controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
             }
@@ -1642,29 +3325,30 @@ var OpenAICompatibleChatLanguageModel = class {
                 type: "tool-call",
                 toolCallId: (_a22 = toolCall.id) != null ? _a22 : generateId(),
                 toolName: toolCall.function.name,
-                input: toolCall.function.arguments
+                input: toolCall.function.arguments,
+                ...toolCall.thoughtSignature ? {
+                  providerMetadata: {
+                    [providerOptionsName]: {
+                      thoughtSignature: toolCall.thoughtSignature
+                    }
+                  }
+                } : {}
               });
             }
             const providerMetadata = {
               [providerOptionsName]: {},
               ...metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata()
             };
-            if (usage.completionTokensDetails.acceptedPredictionTokens != null) {
-              providerMetadata[providerOptionsName].acceptedPredictionTokens = usage.completionTokensDetails.acceptedPredictionTokens;
+            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 (usage.completionTokensDetails.rejectedPredictionTokens != null) {
-              providerMetadata[providerOptionsName].rejectedPredictionTokens = usage.completionTokensDetails.rejectedPredictionTokens;
+            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: {
-                inputTokens: (_b15 = usage.promptTokens) != null ? _b15 : void 0,
-                outputTokens: (_c = usage.completionTokens) != null ? _c : void 0,
-                totalTokens: (_d = usage.totalTokens) != null ? _d : void 0,
-                reasoningTokens: (_e = usage.completionTokensDetails.reasoningTokens) != null ? _e : void 0,
-                cachedInputTokens: (_f = usage.promptTokensDetails.cachedTokens) != null ? _f : void 0
-              },
+              usage: convertOpenAICompatibleChatUsage(usage),
               providerMetadata
             });
           }
@@ -1675,7 +3359,7 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
 };
-var openaiCompatibleTokenUsageSchema = import_v4.z.object({
+var openaiCompatibleTokenUsageSchema = import_v4.z.looseObject({
   prompt_tokens: import_v4.z.number().nullish(),
   completion_tokens: import_v4.z.number().nullish(),
   total_tokens: import_v4.z.number().nullish(),
@@ -1688,7 +3372,7 @@ var openaiCompatibleTokenUsageSchema = import_v4.z.object({
     rejected_prediction_tokens: import_v4.z.number().nullish()
   }).nullish()
 }).nullish();
-var OpenAICompatibleChatResponseSchema = import_v4.z.object({
+var OpenAICompatibleChatResponseSchema = import_v4.z.looseObject({
   id: import_v4.z.string().nullish(),
   created: import_v4.z.number().nullish(),
   model: import_v4.z.string().nullish(),
@@ -1705,7 +3389,13 @@ var OpenAICompatibleChatResponseSchema = import_v4.z.object({
             function: import_v4.z.object({
               name: import_v4.z.string(),
               arguments: import_v4.z.string()
-            })
+            }),
+            // Support for Google Gemini thought signatures via OpenAI compatibility
+            extra_content: import_v4.z.object({
+              google: import_v4.z.object({
+                thought_signature: import_v4.z.string().nullish()
+              }).nullish()
+            }).nullish()
           })
         ).nullish()
       }),
@@ -1714,38 +3404,78 @@ var OpenAICompatibleChatResponseSchema = import_v4.z.object({
   ),
   usage: openaiCompatibleTokenUsageSchema
 });
-var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v4.z.union([
-  import_v4.z.object({
-    id: import_v4.z.string().nullish(),
-    created: import_v4.z.number().nullish(),
-    model: import_v4.z.string().nullish(),
-    choices: import_v4.z.array(
-      import_v4.z.object({
-        delta: import_v4.z.object({
-          role: import_v4.z.enum(["assistant"]).nullish(),
-          content: import_v4.z.string().nullish(),
-          // Most openai-compatible models set `reasoning_content`, but some
-          // providers serving `gpt-oss` set `reasoning`. See #7866
-          reasoning_content: import_v4.z.string().nullish(),
-          reasoning: import_v4.z.string().nullish(),
-          tool_calls: import_v4.z.array(
-            import_v4.z.object({
-              index: import_v4.z.number(),
-              id: import_v4.z.string().nullish(),
-              function: import_v4.z.object({
-                name: import_v4.z.string().nullish(),
-                arguments: import_v4.z.string().nullish()
-              })
-            })
-          ).nullish()
-        }).nullish(),
-        finish_reason: import_v4.z.string().nullish()
-      })
-    ),
-    usage: openaiCompatibleTokenUsageSchema
-  }),
-  errorSchema
-]);
+var chunkBaseSchema = import_v4.z.looseObject({
+  id: import_v4.z.string().nullish(),
+  created: import_v4.z.number().nullish(),
+  model: import_v4.z.string().nullish(),
+  choices: import_v4.z.array(
+    import_v4.z.object({
+      delta: import_v4.z.object({
+        role: import_v4.z.enum(["assistant"]).nullish(),
+        content: import_v4.z.string().nullish(),
+        // Most openai-compatible models set `reasoning_content`, but some
+        // providers serving `gpt-oss` set `reasoning`. See #7866
+        reasoning_content: import_v4.z.string().nullish(),
+        reasoning: import_v4.z.string().nullish(),
+        tool_calls: import_v4.z.array(
+          import_v4.z.object({
+            index: import_v4.z.number().nullish(),
+            //google does not send index
+            id: import_v4.z.string().nullish(),
+            function: import_v4.z.object({
+              name: import_v4.z.string().nullish(),
+              arguments: import_v4.z.string().nullish()
+            }),
+            // Support for Google Gemini thought signatures via OpenAI compatibility
+            extra_content: import_v4.z.object({
+              google: import_v4.z.object({
+                thought_signature: import_v4.z.string().nullish()
+              }).nullish()
+            }).nullish()
+          })
+        ).nullish()
+      }).nullish(),
+      finish_reason: import_v4.z.string().nullish()
+    })
+  ),
+  usage: openaiCompatibleTokenUsageSchema
+});
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v4.z.union([chunkBaseSchema, errorSchema]);
+function convertOpenAICompatibleCompletionUsage(usage) {
+  var _a16, _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 = (_a16 = usage.prompt_tokens) != null ? _a16 : 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",
@@ -1841,10 +3571,10 @@ function mapOpenAICompatibleFinishReason2(finishReason) {
     case "tool_calls":
       return "tool-calls";
     default:
-      return "unknown";
+      return "other";
   }
 }
-var openaiCompatibleCompletionProviderOptions = import_v45.z.object({
+var openaiCompatibleLanguageModelCompletionOptions = import_v45.z.object({
   /**
    * Echo back the prompt in addition to the completion.
    */
@@ -1869,11 +3599,11 @@ var openaiCompatibleCompletionProviderOptions = import_v45.z.object({
 var OpenAICompatibleCompletionLanguageModel = class {
   // type inferred via constructor
   constructor(modelId, config) {
-    this.specificationVersion = "v2";
-    var _a15;
+    this.specificationVersion = "v3";
+    var _a16;
     this.modelId = modelId;
     this.config = config;
-    const errorStructure = (_a15 = config.errorStructure) != null ? _a15 : defaultOpenAICompatibleErrorStructure;
+    const errorStructure = (_a16 = config.errorStructure) != null ? _a16 : defaultOpenAICompatibleErrorStructure;
     this.chunkSchema = createOpenAICompatibleCompletionChunkSchema(
       errorStructure.errorSchema
     );
@@ -1886,8 +3616,8 @@ var OpenAICompatibleCompletionLanguageModel = class {
     return this.config.provider.split(".")[0].trim();
   }
   get supportedUrls() {
-    var _a15, _b15, _c;
-    return (_c = (_b15 = (_a15 = this.config).supportedUrls) == null ? void 0 : _b15.call(_a15)) != null ? _c : {};
+    var _a16, _b16, _c;
+    return (_c = (_b16 = (_a16 = this.config).supportedUrls) == null ? void 0 : _b16.call(_a16)) != null ? _c : {};
   }
   async getArgs({
     prompt,
@@ -1904,26 +3634,33 @@ var OpenAICompatibleCompletionLanguageModel = class {
     tools,
     toolChoice
   }) {
-    var _a15;
+    var _a16, _b16;
     const warnings = [];
-    const completionOptions = (_a15 = await parseProviderOptions({
-      provider: this.providerOptionsName,
-      providerOptions,
-      schema: openaiCompatibleCompletionProviderOptions
-    })) != null ? _a15 : {};
+    const completionOptions = Object.assign(
+      (_a16 = await parseProviderOptions({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleLanguageModelCompletionOptions
+      })) != null ? _a16 : {},
+      (_b16 = await parseProviderOptions({
+        provider: toCamelCase(this.providerOptionsName),
+        providerOptions,
+        schema: openaiCompatibleLanguageModelCompletionOptions
+      })) != null ? _b16 : {}
+    );
     if (topK != null) {
-      warnings.push({ type: "unsupported-setting", setting: "topK" });
+      warnings.push({ type: "unsupported", feature: "topK" });
     }
     if (tools == null ? void 0 : tools.length) {
-      warnings.push({ type: "unsupported-setting", setting: "tools" });
+      warnings.push({ type: "unsupported", feature: "tools" });
     }
     if (toolChoice != null) {
-      warnings.push({ type: "unsupported-setting", setting: "toolChoice" });
+      warnings.push({ type: "unsupported", feature: "toolChoice" });
     }
     if (responseFormat != null && responseFormat.type !== "text") {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "responseFormat",
+        type: "unsupported",
+        feature: "responseFormat",
         details: "JSON response format is not supported."
       });
     }
@@ -1946,6 +3683,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
         presence_penalty: presencePenalty,
         seed,
         ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
+        ...providerOptions == null ? void 0 : providerOptions[toCamelCase(this.providerOptionsName)],
         // prompt:
         prompt: completionPrompt,
         // stop sequences:
@@ -1955,7 +3693,6 @@ var OpenAICompatibleCompletionLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a15, _b15, _c, _d, _e, _f;
     const { args, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
@@ -1982,12 +3719,11 @@ var OpenAICompatibleCompletionLanguageModel = class {
     }
     return {
       content,
-      usage: {
-        inputTokens: (_b15 = (_a15 = response.usage) == null ? void 0 : _a15.prompt_tokens) != null ? _b15 : void 0,
-        outputTokens: (_d = (_c = response.usage) == null ? void 0 : _c.completion_tokens) != null ? _d : void 0,
-        totalTokens: (_f = (_e = response.usage) == null ? void 0 : _e.total_tokens) != null ? _f : void 0
+      usage: convertOpenAICompatibleCompletionUsage(response.usage),
+      finishReason: {
+        unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+        raw: choice.finish_reason
       },
-      finishReason: mapOpenAICompatibleFinishReason2(choice.finish_reason),
       request: { body: args },
       response: {
         ...getResponseMetadata2(response),
@@ -2019,12 +3755,11 @@ var OpenAICompatibleCompletionLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    let finishReason = "unknown";
-    const usage = {
-      inputTokens: void 0,
-      outputTokens: void 0,
-      totalTokens: void 0
+    let finishReason = {
+      unified: "other",
+      raw: void 0
     };
+    let usage = void 0;
     let isFirstChunk = true;
     return {
       stream: response.pipeThrough(
@@ -2033,18 +3768,18 @@ var OpenAICompatibleCompletionLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a15, _b15, _c;
+            var _a16;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
             if (!chunk.success) {
-              finishReason = "error";
+              finishReason = { unified: "error", raw: void 0 };
               controller.enqueue({ type: "error", error: chunk.error });
               return;
             }
             const value = chunk.value;
             if ("error" in value) {
-              finishReason = "error";
+              finishReason = { unified: "error", raw: void 0 };
               controller.enqueue({ type: "error", error: value.error });
               return;
             }
@@ -2060,15 +3795,14 @@ var OpenAICompatibleCompletionLanguageModel = class {
               });
             }
             if (value.usage != null) {
-              usage.inputTokens = (_a15 = value.usage.prompt_tokens) != null ? _a15 : void 0;
-              usage.outputTokens = (_b15 = value.usage.completion_tokens) != null ? _b15 : void 0;
-              usage.totalTokens = (_c = value.usage.total_tokens) != null ? _c : void 0;
+              usage = value.usage;
             }
             const choice = value.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
-              finishReason = mapOpenAICompatibleFinishReason2(
-                choice.finish_reason
-              );
+              finishReason = {
+                unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+                raw: (_a16 = choice.finish_reason) != null ? _a16 : void 0
+              };
             }
             if ((choice == null ? void 0 : choice.text) != null) {
               controller.enqueue({
@@ -2085,7 +3819,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
             controller.enqueue({
               type: "finish",
               finishReason,
-              usage
+              usage: convertOpenAICompatibleCompletionUsage(usage)
             });
           }
         })
@@ -2128,7 +3862,7 @@ var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => import_v44.z.
   }),
   errorSchema
 ]);
-var openaiCompatibleEmbeddingProviderOptions = import_v47.z.object({
+var openaiCompatibleEmbeddingModelOptions = import_v47.z.object({
   /**
    * The number of dimensions the resulting output embeddings should have.
    * Only supported in text-embedding-3 and later models.
@@ -2142,7 +3876,7 @@ var openaiCompatibleEmbeddingProviderOptions = import_v47.z.object({
 });
 var OpenAICompatibleEmbeddingModel = class {
   constructor(modelId, config) {
-    this.specificationVersion = "v2";
+    this.specificationVersion = "v3";
     this.modelId = modelId;
     this.config = config;
   }
@@ -2150,12 +3884,12 @@ var OpenAICompatibleEmbeddingModel = class {
     return this.config.provider;
   }
   get maxEmbeddingsPerCall() {
-    var _a15;
-    return (_a15 = this.config.maxEmbeddingsPerCall) != null ? _a15 : 2048;
+    var _a16;
+    return (_a16 = this.config.maxEmbeddingsPerCall) != null ? _a16 : 2048;
   }
   get supportsParallelCalls() {
-    var _a15;
-    return (_a15 = this.config.supportsParallelCalls) != null ? _a15 : true;
+    var _a16;
+    return (_a16 = this.config.supportsParallelCalls) != null ? _a16 : true;
   }
   get providerOptionsName() {
     return this.config.provider.split(".")[0].trim();
@@ -2166,18 +3900,31 @@ var OpenAICompatibleEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    var _a15, _b15, _c;
+    var _a16, _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(
-      (_a15 = await parseProviderOptions({
-        provider: "openai-compatible",
+      deprecatedOptions != null ? deprecatedOptions : {},
+      (_a16 = await parseProviderOptions({
+        provider: "openaiCompatible",
         providerOptions,
-        schema: openaiCompatibleEmbeddingProviderOptions
-      })) != null ? _a15 : {},
-      (_b15 = await parseProviderOptions({
+        schema: openaiCompatibleEmbeddingModelOptions
+      })) != null ? _a16 : {},
+      (_b16 = await parseProviderOptions({
         provider: this.providerOptionsName,
         providerOptions,
-        schema: openaiCompatibleEmbeddingProviderOptions
-      })) != null ? _b15 : {}
+        schema: openaiCompatibleEmbeddingModelOptions
+      })) != null ? _b16 : {}
     );
     if (values.length > this.maxEmbeddingsPerCall) {
       throw new TooManyEmbeddingValuesForCallError({
@@ -2214,6 +3961,7 @@ var OpenAICompatibleEmbeddingModel = class {
       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,
@@ -2230,12 +3978,25 @@ var OpenAICompatibleImageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v2";
+    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,
@@ -2244,21 +4005,59 @@ var OpenAICompatibleImageModel = class {
     seed,
     providerOptions,
     headers,
-    abortSignal
+    abortSignal,
+    files,
+    mask
   }) {
-    var _a15, _b15, _c, _d, _e;
+    var _a16, _b16, _c, _d, _e;
     const warnings = [];
     if (aspectRatio != null) {
       warnings.push({
-        type: "unsupported-setting",
-        setting: "aspectRatio",
+        type: "unsupported",
+        feature: "aspectRatio",
         details: "This model does not support aspect ratio. Use `size` instead."
       });
     }
     if (seed != null) {
-      warnings.push({ type: "unsupported-setting", setting: "seed" });
+      warnings.push({ type: "unsupported", feature: "seed" });
+    }
+    const currentDate = (_c = (_b16 = (_a16 = this.config._internal) == null ? void 0 : _a16.currentDate) == null ? void 0 : _b16.call(_a16)) != 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((file) => fileToBlob(file))),
+          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 currentDate = (_c = (_b15 = (_a15 = this.config._internal) == null ? void 0 : _a15.currentDate) == null ? void 0 : _b15.call(_a15)) != null ? _c : /* @__PURE__ */ new Date();
     const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/images/generations",
@@ -2270,7 +4069,7 @@ var OpenAICompatibleImageModel = class {
         prompt,
         n,
         size,
-        ...(_d = providerOptions.openai) != null ? _d : {},
+        ...args,
         response_format: "b64_json"
       },
       failedResponseHandler: createJsonErrorResponseHandler(
@@ -2296,7 +4095,14 @@ var OpenAICompatibleImageModel = class {
 var openaiCompatibleImageResponseSchema = import_v48.z.object({
   data: import_v48.z.array(import_v48.z.object({ b64_json: import_v48.z.string() }))
 });
-var VERSION2 = true ? "1.0.30" : "0.0.0-test";
+async function fileToBlob(file) {
+  if (file.type === "url") {
+    return downloadBlob(file.url);
+  }
+  const data = file.data instanceof Uint8Array ? file.data : convertBase64ToUint8Array(file.data);
+  return new Blob([data], { type: file.mediaType });
+}
+var VERSION2 = true ? "2.0.41" : "0.0.0-test";
 function createOpenAICompatible(options) {
   const baseURL = withoutTrailingSlash(options.baseURL);
   const providerName = options.name;
@@ -2321,7 +4127,9 @@ function createOpenAICompatible(options) {
   const createChatModel = (modelId) => new OpenAICompatibleChatLanguageModel(modelId, {
     ...getCommonModelConfig("chat"),
     includeUsage: options.includeUsage,
-    supportsStructuredOutputs: options.supportsStructuredOutputs
+    supportsStructuredOutputs: options.supportsStructuredOutputs,
+    transformRequestBody: options.transformRequestBody,
+    metadataExtractor: options.metadataExtractor
   });
   const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(modelId, {
     ...getCommonModelConfig("completion"),
@@ -2332,9 +4140,11 @@ function createOpenAICompatible(options) {
   });
   const createImageModel = (modelId) => new OpenAICompatibleImageModel(modelId, getCommonModelConfig("image"));
   const provider = (modelId) => createLanguageModel(modelId);
+  provider.specificationVersion = "v3";
   provider.languageModel = createLanguageModel;
   provider.chatModel = createChatModel;
   provider.completionModel = createCompletionModel;
+  provider.embeddingModel = createEmbeddingModel;
   provider.textEmbeddingModel = createEmbeddingModel;
   provider.imageModel = createImageModel;
   return provider;