@llmgateway/ai-sdk-provider 2.5.1 → 3.0.0

package/dist/index.js

@@ -22,9 +22,21 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 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") {
@@ -53,11 +65,12 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// node_modules/.pnpm/@ai-sdk+provider@2.0.0-beta.1/node_modules/@ai-sdk/provider/dist/index.mjs
+// node_modules/.pnpm/@ai-sdk+provider@3.0.2/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
 var symbol = Symbol.for(marker);
 var _a;
-var _AISDKError = class _AISDKError2 extends Error {
+var _b;
+var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
   /**
    * Creates an AI SDK Error.
    *
@@ -67,13 +80,13 @@ var _AISDKError = class _AISDKError2 extends Error {
    * @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;
   }
   /**
@@ -82,20 +95,19 @@ var _AISDKError = class _AISDKError2 extends Error {
    * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
    */
   static isInstance(error) {
-    return _AISDKError2.hasMarker(error, marker);
+    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;
   }
 };
-_a = symbol;
-var AISDKError = _AISDKError;
 var name = "AI_APICallError";
 var marker2 = `vercel.ai.error.${name}`;
 var symbol2 = Symbol.for(marker2);
 var _a2;
-var APICallError = class extends AISDKError {
+var _b2;
+var APICallError = class extends (_b2 = AISDKError, _a2 = symbol2, _b2) {
   constructor({
     message,
     url,
@@ -125,12 +137,12 @@ var APICallError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker2);
   }
 };
-_a2 = symbol2;
 var name2 = "AI_EmptyResponseBodyError";
 var marker3 = `vercel.ai.error.${name2}`;
 var symbol3 = Symbol.for(marker3);
 var _a3;
-var EmptyResponseBodyError = class extends AISDKError {
+var _b3;
+var EmptyResponseBodyError = class extends (_b3 = AISDKError, _a3 = symbol3, _b3) {
   // used in isInstance
   constructor({ message = "Empty response body" } = {}) {
     super({ name: name2, message });
@@ -140,7 +152,6 @@ var EmptyResponseBodyError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker3);
   }
 };
-_a3 = symbol3;
 function getErrorMessage(error) {
   if (error == null) {
     return "unknown error";
@@ -157,7 +168,8 @@ var name3 = "AI_InvalidArgumentError";
 var marker4 = `vercel.ai.error.${name3}`;
 var symbol4 = Symbol.for(marker4);
 var _a4;
-var InvalidArgumentError = class extends AISDKError {
+var _b4;
+var InvalidArgumentError = class extends (_b4 = AISDKError, _a4 = symbol4, _b4) {
   constructor({
     message,
     cause,
@@ -171,12 +183,12 @@ var InvalidArgumentError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker4);
   }
 };
-_a4 = symbol4;
 var name4 = "AI_InvalidPromptError";
 var marker5 = `vercel.ai.error.${name4}`;
 var symbol5 = Symbol.for(marker5);
 var _a5;
-var InvalidPromptError = class extends AISDKError {
+var _b5;
+var InvalidPromptError = class extends (_b5 = AISDKError, _a5 = symbol5, _b5) {
   constructor({
     prompt,
     message,
@@ -190,12 +202,12 @@ var InvalidPromptError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker5);
   }
 };
-_a5 = symbol5;
 var name5 = "AI_InvalidResponseDataError";
 var marker6 = `vercel.ai.error.${name5}`;
 var symbol6 = Symbol.for(marker6);
 var _a6;
-var InvalidResponseDataError = class extends AISDKError {
+var _b6;
+var InvalidResponseDataError = class extends (_b6 = AISDKError, _a6 = symbol6, _b6) {
   constructor({
     data,
     message = `Invalid response data: ${JSON.stringify(data)}.`
@@ -208,12 +220,12 @@ var InvalidResponseDataError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker6);
   }
 };
-_a6 = symbol6;
 var name6 = "AI_JSONParseError";
 var marker7 = `vercel.ai.error.${name6}`;
 var symbol7 = Symbol.for(marker7);
 var _a7;
-var JSONParseError = class extends AISDKError {
+var _b7;
+var JSONParseError = class extends (_b7 = AISDKError, _a7 = symbol7, _b7) {
   constructor({ text, cause }) {
     super({
       name: name6,
@@ -228,12 +240,12 @@ Error message: ${getErrorMessage(cause)}`,
     return AISDKError.hasMarker(error, marker7);
   }
 };
-_a7 = symbol7;
 var name7 = "AI_LoadAPIKeyError";
 var marker8 = `vercel.ai.error.${name7}`;
 var symbol8 = Symbol.for(marker8);
 var _a8;
-var LoadAPIKeyError = class extends AISDKError {
+var _b8;
+var LoadAPIKeyError = class extends (_b8 = AISDKError, _a8 = symbol8, _b8) {
   // used in isInstance
   constructor({ message }) {
     super({ name: name7, message });
@@ -243,32 +255,86 @@ var LoadAPIKeyError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker8);
   }
 };
-_a8 = symbol8;
 var name8 = "AI_LoadSettingError";
 var marker9 = `vercel.ai.error.${name8}`;
 var symbol9 = Symbol.for(marker9);
 var _a9;
-_a9 = symbol9;
+var _b9;
+var LoadSettingError = class extends (_b9 = AISDKError, _a9 = symbol9, _b9) {
+  // used in isInstance
+  constructor({ message }) {
+    super({ name: name8, message });
+    this[_a9] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker9);
+  }
+};
 var name9 = "AI_NoContentGeneratedError";
 var marker10 = `vercel.ai.error.${name9}`;
 var symbol10 = Symbol.for(marker10);
 var _a10;
-_a10 = symbol10;
+var _b10;
+var NoContentGeneratedError = class extends (_b10 = AISDKError, _a10 = symbol10, _b10) {
+  // used in isInstance
+  constructor({
+    message = "No content generated."
+  } = {}) {
+    super({ name: name9, message });
+    this[_a10] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker10);
+  }
+};
 var name10 = "AI_NoSuchModelError";
 var marker11 = `vercel.ai.error.${name10}`;
 var symbol11 = Symbol.for(marker11);
 var _a11;
-_a11 = symbol11;
+var _b11;
+var NoSuchModelError = class extends (_b11 = AISDKError, _a11 = symbol11, _b11) {
+  constructor({
+    errorName = name10,
+    modelId,
+    modelType,
+    message = `No such ${modelType}: ${modelId}`
+  }) {
+    super({ name: errorName, message });
+    this[_a11] = true;
+    this.modelId = modelId;
+    this.modelType = modelType;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker11);
+  }
+};
 var name11 = "AI_TooManyEmbeddingValuesForCallError";
 var marker12 = `vercel.ai.error.${name11}`;
 var symbol12 = Symbol.for(marker12);
 var _a12;
-_a12 = symbol12;
+var _b12;
+var TooManyEmbeddingValuesForCallError = class extends (_b12 = AISDKError, _a12 = symbol12, _b12) {
+  constructor(options) {
+    super({
+      name: name11,
+      message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
+    });
+    this[_a12] = true;
+    this.provider = options.provider;
+    this.modelId = options.modelId;
+    this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
+    this.values = options.values;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker12);
+  }
+};
 var name12 = "AI_TypeValidationError";
 var marker13 = `vercel.ai.error.${name12}`;
 var symbol13 = Symbol.for(marker13);
 var _a13;
-var _TypeValidationError = class _TypeValidationError2 extends AISDKError {
+var _b13;
+var TypeValidationError = class _TypeValidationError extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
   constructor({ value, cause }) {
     super({
       name: name12,
@@ -296,16 +362,15 @@ Error message: ${getErrorMessage(cause)}`,
     value,
     cause
   }) {
-    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
+    return _TypeValidationError.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError({ value, cause });
   }
 };
-_a13 = symbol13;
-var TypeValidationError = _TypeValidationError;
 var name13 = "AI_UnsupportedFunctionalityError";
 var marker14 = `vercel.ai.error.${name13}`;
 var symbol14 = Symbol.for(marker14);
 var _a14;
-var UnsupportedFunctionalityError = class extends AISDKError {
+var _b14;
+var UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = symbol14, _b14) {
   constructor({
     functionality,
     message = `'${functionality}' functionality not supported.`
@@ -318,9 +383,14 @@ var UnsupportedFunctionalityError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker14);
   }
 };
-_a14 = symbol14;
 
-// node_modules/.pnpm/eventsource-parser@3.0.3/node_modules/eventsource-parser/dist/index.js
+// node_modules/.pnpm/@ai-sdk+provider-utils@4.0.4_zod@3.25.34/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) {
     super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
@@ -411,7 +481,7 @@ function splitLines(chunk) {
     const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
 `, searchIndex);
     let lineEnd = -1;
-    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
       incompleteLine = chunk.slice(searchIndex);
       break;
     } else {
@@ -423,7 +493,7 @@ function splitLines(chunk) {
   return [lines, incompleteLine];
 }
 
-// node_modules/.pnpm/eventsource-parser@3.0.3/node_modules/eventsource-parser/dist/stream.js
+// node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/stream.js
 var EventSourceParserStream = class extends TransformStream {
   constructor({ onError, onRetry, onComment } = {}) {
     let parser;
@@ -447,28 +517,7 @@ var EventSourceParserStream = class extends TransformStream {
   }
 };
 
-// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.0-beta.5_zod@3.25.34/node_modules/@ai-sdk/provider-utils/dist/index.mjs
-var z4 = __toESM(require("zod/v4"), 1);
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/Options.js
-var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/selectParser.js
-var import_zod4 = require("zod");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
-var import_zod = require("zod");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
-var import_zod2 = require("zod");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
-var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
-var import_zod3 = require("zod");
-
-// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.0-beta.5_zod@3.25.34/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+// node_modules/.pnpm/@ai-sdk+provider-utils@4.0.4_zod@3.25.34/node_modules/@ai-sdk/provider-utils/dist/index.mjs
 function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
@@ -478,6 +527,37 @@ function combineHeaders(...headers) {
 function extractResponseHeaders(response) {
   return Object.fromEntries([...response.headers]);
 }
+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);
+}
+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 createIdGenerator = ({
   prefix,
   size = 16,
@@ -505,7 +585,7 @@ var createIdGenerator = ({
 };
 var generateId = createIdGenerator();
 function isAbortError(error) {
-  return error instanceof Error && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
+  return (error instanceof Error || error instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
   error.name === "TimeoutError");
 }
 var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
@@ -532,11 +612,53 @@ function handleFetchError({
   }
   return error;
 }
-function removeUndefinedEntries(record) {
-  return Object.fromEntries(
-    Object.entries(record).filter(([_key, value]) => value != null)
+function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
+  var _a22, _b22, _c;
+  if (globalThisAny.window) {
+    return `runtime/browser`;
+  }
+  if ((_a22 = globalThisAny.navigator) == null ? void 0 : _a22.userAgent) {
+    return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
+  }
+  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) {
+    return `runtime/vercel-edge`;
+  }
+  return "runtime/unknown";
+}
+function normalizeHeaders(headers) {
+  if (headers == null) {
+    return {};
+  }
+  const normalized = {};
+  if (headers instanceof Headers) {
+    headers.forEach((value, key) => {
+      normalized[key.toLowerCase()] = value;
+    });
+  } else {
+    if (!Array.isArray(headers)) {
+      headers = Object.entries(headers);
+    }
+    for (const [key, value] of headers) {
+      if (value != null) {
+        normalized[key.toLowerCase()] = value;
+      }
+    }
+  }
+  return normalized;
+}
+function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
+  const normalizedHeaders = new Headers(normalizeHeaders(headers));
+  const currentUserAgentHeader = normalizedHeaders.get("user-agent") || "";
+  normalizedHeaders.set(
+    "user-agent",
+    [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ")
   );
+  return Object.fromEntries(normalizedHeaders.entries());
 }
+var VERSION = true ? "4.0.4" : "0.0.0-test";
 function loadApiKey({
   apiKey,
   environmentVariableName,
@@ -605,35 +727,1205 @@ function filter(obj) {
 }
 function secureJsonParse(text) {
   const { stackTraceLimit } = Error;
-  Error.stackTraceLimit = 0;
+  try {
+    Error.stackTraceLimit = 0;
+  } catch (e) {
+    return _parse(text);
+  }
   try {
     return _parse(text);
   } finally {
     Error.stackTraceLimit = stackTraceLimit;
   }
 }
-var validatorSymbol = Symbol.for("vercel.ai.validator");
-function validator(validate) {
-  return { [validatorSymbol]: true, validate };
+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 isValidator(value) {
-  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
+function visit(def) {
+  if (typeof def === "boolean") return def;
+  return addAdditionalPropertiesToJsonSchema(def);
 }
-function asValidator(value) {
-  return isValidator(value) ? value : standardSchemaValidator(value);
+var ignoreOverride = 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" ? __spreadProps(__spreadValues({}, defaultOptions), {
+  name: options
+}) : __spreadValues(__spreadValues({}, defaultOptions), options);
+function parseAnyDef() {
+  return {};
 }
-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 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, __spreadProps(__spreadValues({}, 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 __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, refs), {
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    })),
+    parseDef(def.right._def, __spreadProps(__spreadValues({}, 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 _a16 = schema, { additionalProperties } = _a16, rest = __objRest(_a16, ["additionalProperties"]);
+        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(__spreadValues({
+      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(__spreadValues({
+      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, __spreadProps(__spreadValues({}, 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 _a16 = parseStringDef(def.keyType._def, refs), { type } = _a16, keyType = __objRest(_a16, ["type"]);
+    return __spreadProps(__spreadValues({}, schema), {
+      propertyNames: keyType
+    });
+  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodEnum) {
+    return __spreadProps(__spreadValues({}, 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 _b16 = parseBrandedDef(
+      def.keyType._def,
+      refs
+    ), { type } = _b16, keyType = __objRest(_b16, ["type"]);
+    return __spreadProps(__spreadValues({}, schema), {
+      propertyNames: keyType
+    });
+  }
+  return schema;
+}
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, __spreadProps(__spreadValues({}, refs), {
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  })) || parseAnyDef();
+  const values = parseDef(def.valueType._def, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, refs), {
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  }));
+  const b = parseDef(def.out._def, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, refs), {
+          currentPath: [...refs.currentPath, "items", `${i}`]
+        }))
+      ).reduce(
+        (acc, x) => x === void 0 ? acc : [...acc, x],
+        []
+      ),
+      additionalItems: parseDef(def.rest._def, __spreadProps(__spreadValues({}, 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, __spreadProps(__spreadValues({}, 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;
+}
+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;
+    }
+  }
+};
+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 __spreadProps(__spreadValues({}, _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 __spreadProps(__spreadValues({}, acc), {
+        [name32]: (_a32 = parseDef(
+          schema2._def,
+          __spreadProps(__spreadValues({}, 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 : __spreadProps(__spreadValues({}, 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 ? __spreadProps(__spreadValues({}, main), {
+    [refs.definitionPath]: definitions
+  }) : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name22
+    ].join("/"),
+    [refs.definitionPath]: __spreadProps(__spreadValues({}, definitions), {
+      [name22]: main
+    })
+  };
+  combined.$schema = "http://json-schema.org/draft-07/schema#";
+  return combined;
+};
+var schemaSymbol = 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
+  };
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+  return schema == null ? jsonSchema({ properties: {}, additionalProperties: false }) : isSchema(schema) ? schema : "~standard" in schema ? schema["~standard"].vendor === "zod" ? zodSchema(schema) : standardSchema(schema) : schema();
+}
+function standardSchema(standardSchema2) {
+  return jsonSchema(
+    () => 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 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
@@ -648,12 +1940,12 @@ async function safeValidateTypes({
   value,
   schema
 }) {
-  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 };
     }
@@ -736,7 +2028,7 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch
+  fetch: fetch2
 }) => postToApi({
   url,
   headers: __spreadValues({
@@ -749,7 +2041,7 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch
+  fetch: fetch2
 });
 var postToApi = async ({
   url,
@@ -758,12 +2050,16 @@ 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: removeUndefinedEntries(headers),
+      headers: withUserAgentSuffix(
+        headers,
+        `ai-sdk/provider-utils/${VERSION}`,
+        getRuntimeEnvironmentUserAgent()
+      ),
       body: body.content,
       signal: abortSignal
     });
@@ -907,15 +2203,6 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
     rawValue: parsedResult.rawValue
   };
 };
-var schemaSymbol = Symbol.for("vercel.ai.schema");
-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 withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
@@ -996,10 +2283,10 @@ function getFileUrl({
   part,
   defaultMediaType
 }) {
-  var _a15, _b;
+  var _a16, _b16;
   if (part.data instanceof Uint8Array) {
     const base64 = convertUint8ArrayToBase64(part.data);
-    return `data:${(_a15 = part.mediaType) != null ? _a15 : defaultMediaType};base64,${base64}`;
+    return `data:${(_a16 = part.mediaType) != null ? _a16 : defaultMediaType};base64,${base64}`;
   }
   const stringUrl = part.data.toString();
   if (isUrl({
@@ -1008,12 +2295,12 @@ function getFileUrl({
   })) {
     return stringUrl;
   }
-  return stringUrl.startsWith("data:") ? stringUrl : `data:${(_b = part.mediaType) != null ? _b : defaultMediaType};base64,${stringUrl}`;
+  return stringUrl.startsWith("data:") ? stringUrl : `data:${(_b16 = part.mediaType) != null ? _b16 : defaultMediaType};base64,${stringUrl}`;
 }
 function getMediaType(dataUrl, defaultMediaType) {
-  var _a15;
+  var _a16;
   const match = dataUrl.match(/^data:([^;]+)/);
-  return match ? (_a15 = match[1]) != null ? _a15 : defaultMediaType : defaultMediaType;
+  return match ? (_a16 = match[1]) != null ? _a16 : defaultMediaType : defaultMediaType;
 }
 function getBase64FromDataUrl(dataUrl) {
   const match = dataUrl.match(/^data:[^;]*;base64,(.+)$/);
@@ -1021,14 +2308,14 @@ function getBase64FromDataUrl(dataUrl) {
 }
 
 // src/chat/convert-to-llmgateway-chat-messages.ts
-function getCacheControl(providerMetadata) {
-  var _a15, _b, _c;
-  const anthropic = providerMetadata == null ? void 0 : providerMetadata.anthropic;
-  const llmgateway2 = providerMetadata == null ? void 0 : providerMetadata.llmgateway;
-  return (_c = (_b = (_a15 = llmgateway2 == null ? void 0 : llmgateway2.cacheControl) != null ? _a15 : llmgateway2 == null ? void 0 : llmgateway2.cache_control) != null ? _b : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
+function getCacheControl(providerOptions) {
+  var _a16, _b16, _c;
+  const anthropic = providerOptions == null ? void 0 : providerOptions.anthropic;
+  const llmgateway2 = providerOptions == null ? void 0 : providerOptions.llmgateway;
+  return (_c = (_b16 = (_a16 = llmgateway2 == null ? void 0 : llmgateway2.cacheControl) != null ? _a16 : llmgateway2 == null ? void 0 : llmgateway2.cache_control) != null ? _b16 : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
 }
 function convertToLLMGatewayChatMessages(prompt) {
-  var _a15, _b, _c;
+  var _a16, _b16, _c;
   const messages = [];
   for (const { role, content, providerOptions } of prompt) {
     switch (role) {
@@ -1041,8 +2328,8 @@ function convertToLLMGatewayChatMessages(prompt) {
         break;
       }
       case "user": {
-        if (content.length === 1 && ((_a15 = content[0]) == null ? void 0 : _a15.type) === "text") {
-          const cacheControl = (_b = getCacheControl(providerOptions)) != null ? _b : getCacheControl(content[0].providerOptions);
+        if (content.length === 1 && ((_a16 = content[0]) == null ? void 0 : _a16.type) === "text") {
+          const cacheControl = (_b16 = getCacheControl(providerOptions)) != null ? _b16 : getCacheControl(content[0].providerOptions);
           const contentWithCacheControl = cacheControl ? [
             {
               type: "text",
@@ -1059,8 +2346,8 @@ function convertToLLMGatewayChatMessages(prompt) {
         const messageCacheControl = getCacheControl(providerOptions);
         const contentParts = content.map(
           (part) => {
-            var _a16, _b2, _c2, _d, _e, _f;
-            const cacheControl = (_a16 = getCacheControl(part.providerOptions)) != null ? _a16 : messageCacheControl;
+            var _a17, _b17, _c2, _d, _e, _f;
+            const cacheControl = (_a17 = getCacheControl(part.providerOptions)) != null ? _a17 : messageCacheControl;
             switch (part.type) {
               case "text":
                 return {
@@ -1070,7 +2357,7 @@ function convertToLLMGatewayChatMessages(prompt) {
                   cache_control: cacheControl
                 };
               case "file": {
-                if ((_b2 = part.mediaType) == null ? void 0 : _b2.startsWith("image/")) {
+                if ((_b17 = part.mediaType) == null ? void 0 : _b17.startsWith("image/")) {
                   const url = getFileUrl({
                     part,
                     defaultMediaType: "image/jpeg"
@@ -1169,7 +2456,7 @@ function convertToLLMGatewayChatMessages(prompt) {
           role: "assistant",
           content: text,
           tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
-          reasoning: reasoning || void 0,
+          reasoningText: reasoning || void 0,
           reasoning_details: reasoningDetails.length > 0 ? reasoningDetails : void 0,
           cache_control: getCacheControl(providerOptions)
         });
@@ -1274,6 +2561,7 @@ var LLMGatewayNonStreamChatCompletionResponseSchema = LLMGatewayChatCompletionBa
         role: import_v45.z.literal("assistant"),
         content: import_v45.z.string().nullable().optional(),
         reasoning: import_v45.z.string().nullable().optional(),
+        reasoningText: import_v45.z.string().nullable().optional(),
         reasoning_details: ReasoningDetailArraySchema.nullish(),
         images: ImageResponseArraySchema.nullish(),
         tool_calls: import_v45.z.array(
@@ -1314,6 +2602,7 @@ var LLMGatewayStreamChatCompletionChunkSchema = import_v45.z.union([
           role: import_v45.z.enum(["assistant"]).optional(),
           content: import_v45.z.string().nullish(),
           reasoning: import_v45.z.string().nullish().optional(),
+          reasoningText: import_v45.z.string().nullish().optional(),
           reasoning_details: ReasoningDetailArraySchema.nullish(),
           images: ImageResponseArraySchema.nullish(),
           tool_calls: import_v45.z.array(
@@ -1406,7 +2695,7 @@ var LLMGatewayChatLanguageModel = class {
       messages: convertToLLMGatewayChatMessages(prompt),
       // LLMGateway specific settings:
       include_reasoning: this.settings.includeReasoning,
-      reasoning: this.settings.reasoning,
+      reasoningText: this.settings.reasoningText,
       usage: this.settings.usage
     }, this.config.extraBody), this.settings.extraBody);
     if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
@@ -1433,7 +2722,7 @@ var LLMGatewayChatLanguageModel = class {
         function: {
           name: tool.name,
           description: tool.type,
-          parameters: tool.inputSchema
+          inputSchema: tool.inputSchema
         }
       }));
       return __spreadProps(__spreadValues({}, baseArgs), {
@@ -1444,10 +2733,11 @@ var LLMGatewayChatLanguageModel = class {
     return baseArgs;
   }
   async doGenerate(options) {
-    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    var _a16, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
     const providerOptions = options.providerOptions || {};
     const llmgatewayOptions = providerOptions.llmgateway || {};
     const args = __spreadValues(__spreadValues({}, this.getArgs(options)), llmgatewayOptions);
+    const includeUsageAccounting = ((_a16 = args.usage) == null ? void 0 : _a16.include) === true;
     const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
@@ -1467,11 +2757,11 @@ var LLMGatewayChatLanguageModel = class {
       throw new Error("No choice in response");
     }
     const usageInfo = response.usage ? {
-      inputTokens: (_a15 = response.usage.prompt_tokens) != null ? _a15 : 0,
-      outputTokens: (_b = response.usage.completion_tokens) != null ? _b : 0,
-      totalTokens: ((_c = response.usage.prompt_tokens) != null ? _c : 0) + ((_d = response.usage.completion_tokens) != null ? _d : 0),
-      reasoningTokens: (_f = (_e = response.usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0,
-      cachedInputTokens: (_h = (_g = response.usage.prompt_tokens_details) == null ? void 0 : _g.cached_tokens) != null ? _h : 0
+      inputTokens: (_b16 = response.usage.prompt_tokens) != null ? _b16 : 0,
+      outputTokens: (_c = response.usage.completion_tokens) != null ? _c : 0,
+      totalTokens: ((_d = response.usage.prompt_tokens) != null ? _d : 0) + ((_e = response.usage.completion_tokens) != null ? _e : 0),
+      reasoningTokens: (_g = (_f = response.usage.completion_tokens_details) == null ? void 0 : _f.reasoning_tokens) != null ? _g : 0,
+      cachedInputTokens: (_i = (_h = response.usage.prompt_tokens_details) == null ? void 0 : _h.cached_tokens) != null ? _i : 0
     } : {
       inputTokens: 0,
       outputTokens: 0,
@@ -1479,7 +2769,7 @@ var LLMGatewayChatLanguageModel = class {
       reasoningTokens: 0,
       cachedInputTokens: 0
     };
-    const reasoningDetails = (_i = choice.message.reasoning_details) != null ? _i : [];
+    const reasoningDetails = (_j = choice.message.reasoning_details) != null ? _j : [];
     const reasoning = reasoningDetails.length > 0 ? reasoningDetails.map((detail) => {
       switch (detail.type) {
         case "reasoning.text" /* Text */: {
@@ -1517,10 +2807,10 @@ var LLMGatewayChatLanguageModel = class {
       return null;
     }).filter(
       (p) => p !== null
-    ) : choice.message.reasoning ? [
+    ) : choice.message.reasoningText ? [
       {
         type: "reasoning",
-        text: choice.message.reasoning
+        text: choice.message.reasoningText
       }
     ] : [];
     const content = [];
@@ -1535,7 +2825,7 @@ var LLMGatewayChatLanguageModel = class {
       for (const toolCall of choice.message.tool_calls) {
         content.push({
           type: "tool-call",
-          toolCallId: (_j = toolCall.id) != null ? _j : generateId(),
+          toolCallId: (_k = toolCall.id) != null ? _k : generateId(),
           toolName: toolCall.function.name,
           input: toolCall.function.arguments
         });
@@ -1560,7 +2850,7 @@ var LLMGatewayChatLanguageModel = class {
             url: annotation.url_citation.url,
             title: annotation.url_citation.title,
             providerMetadata: {
-              openrouter: {
+              llmgateway: {
                 content: annotation.url_citation.content || ""
               }
             }
@@ -1573,25 +2863,25 @@ var LLMGatewayChatLanguageModel = class {
       finishReason: mapLLMGatewayFinishReason(choice.finish_reason),
       usage: usageInfo,
       warnings: [],
-      providerMetadata: {
+      providerMetadata: includeUsageAccounting ? {
         llmgateway: {
           usage: {
-            promptTokens: (_k = usageInfo.inputTokens) != null ? _k : 0,
-            completionTokens: (_l = usageInfo.outputTokens) != null ? _l : 0,
-            totalTokens: (_m = usageInfo.totalTokens) != null ? _m : 0,
-            cost: (_n = response.usage) == null ? void 0 : _n.cost,
+            promptTokens: (_l = usageInfo.inputTokens) != null ? _l : 0,
+            completionTokens: (_m = usageInfo.outputTokens) != null ? _m : 0,
+            totalTokens: (_n = usageInfo.totalTokens) != null ? _n : 0,
+            cost: (_o = response.usage) == null ? void 0 : _o.cost,
             promptTokensDetails: {
-              cachedTokens: (_q = (_p = (_o = response.usage) == null ? void 0 : _o.prompt_tokens_details) == null ? void 0 : _p.cached_tokens) != null ? _q : 0
+              cachedTokens: (_r = (_q = (_p = response.usage) == null ? void 0 : _p.prompt_tokens_details) == null ? void 0 : _q.cached_tokens) != null ? _r : 0
             },
             completionTokensDetails: {
-              reasoningTokens: (_t = (_s = (_r = response.usage) == null ? void 0 : _r.completion_tokens_details) == null ? void 0 : _s.reasoning_tokens) != null ? _t : 0
+              reasoningTokens: (_u = (_t = (_s = response.usage) == null ? void 0 : _s.completion_tokens_details) == null ? void 0 : _t.reasoning_tokens) != null ? _u : 0
             },
             costDetails: {
-              upstreamInferenceCost: (_w = (_v = (_u = response.usage) == null ? void 0 : _u.cost_details) == null ? void 0 : _v.upstream_inference_cost) != null ? _w : 0
+              upstreamInferenceCost: (_x = (_w = (_v = response.usage) == null ? void 0 : _v.cost_details) == null ? void 0 : _w.upstream_inference_cost) != null ? _x : 0
             }
           }
         }
-      },
+      } : void 0,
       request: { body: args },
       response: {
         id: response.id,
@@ -1601,7 +2891,6 @@ var LLMGatewayChatLanguageModel = class {
     };
   }
   async doStream(options) {
-    var _a15;
     const providerOptions = options.providerOptions || {};
     const llmgatewayOptions = providerOptions.llmgateway || {};
     const args = __spreadValues(__spreadValues({}, this.getArgs(options)), llmgatewayOptions);
@@ -1614,9 +2903,7 @@ var LLMGatewayChatLanguageModel = class {
       body: __spreadProps(__spreadValues({}, args), {
         stream: true,
         // only include stream_options when in strict compatibility mode:
-        stream_options: this.config.compatibility === "strict" ? __spreadValues({
-          include_usage: true
-        }, ((_a15 = this.settings.usage) == null ? void 0 : _a15.include) ? { include_usage: true } : {}) : void 0
+        stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
       }),
       failedResponseHandler: llmgatewayFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
@@ -1644,7 +2931,7 @@ var LLMGatewayChatLanguageModel = class {
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
-            var _a16, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+            var _a16, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -1683,7 +2970,7 @@ var LLMGatewayChatLanguageModel = class {
               }
               llmgatewayUsage.completionTokens = value.usage.completion_tokens;
               if (value.usage.completion_tokens_details) {
-                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
+                const reasoningTokens = (_b16 = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b16 : 0;
                 usage.reasoningTokens = reasoningTokens;
                 llmgatewayUsage.completionTokensDetails = {
                   reasoningTokens
@@ -1742,8 +3029,10 @@ var LLMGatewayChatLanguageModel = class {
                   }
                 }
               }
-            } else if (delta.reasoning != null) {
-              emitReasoningChunk(delta.reasoning);
+            } else if (delta.reasoningText != null || "reasoning" in delta && typeof delta.reasoning === "string") {
+              emitReasoningChunk(
+                (_d = (_c = delta.reasoningText) != null ? _c : "reasoning" in delta && typeof delta.reasoning === "string" ? delta.reasoning : void 0) != null ? _d : ""
+              );
             }
             if (delta.content != null) {
               if (!textStarted) {
@@ -1762,7 +3051,7 @@ var LLMGatewayChatLanguageModel = class {
             }
             if (delta.tool_calls != null) {
               for (const toolCallDelta of delta.tool_calls) {
-                const index = (_c = toolCallDelta.index) != null ? _c : toolCalls.length - 1;
+                const index = (_e = toolCallDelta.index) != null ? _e : toolCalls.length - 1;
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.type !== "function") {
                     throw new InvalidResponseDataError({
@@ -1776,7 +3065,7 @@ var LLMGatewayChatLanguageModel = class {
                       message: `Expected 'id' to be a string.`
                     });
                   }
-                  if (((_d = toolCallDelta.function) == null ? void 0 : _d.name) == null) {
+                  if (((_f = toolCallDelta.function) == null ? void 0 : _f.name) == null) {
                     throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
@@ -1787,7 +3076,7 @@ var LLMGatewayChatLanguageModel = class {
                     type: "function",
                     function: {
                       name: toolCallDelta.function.name,
-                      arguments: (_e = toolCallDelta.function.arguments) != null ? _e : ""
+                      arguments: (_g = toolCallDelta.function.arguments) != null ? _g : ""
                     },
                     inputStarted: false,
                     sent: false
@@ -1796,7 +3085,7 @@ var LLMGatewayChatLanguageModel = class {
                   if (toolCall2 == null) {
                     throw new Error("Tool call is missing");
                   }
-                  if (((_f = toolCall2.function) == null ? void 0 : _f.name) != null && ((_g = toolCall2.function) == null ? void 0 : _g.arguments) != null && isParsableJson(toolCall2.function.arguments)) {
+                  if (((_h = toolCall2.function) == null ? void 0 : _h.name) != null && ((_i = toolCall2.function) == null ? void 0 : _i.arguments) != null && isParsableJson(toolCall2.function.arguments)) {
                     toolCall2.inputStarted = true;
                     controller.enqueue({
                       type: "tool-input-start",
@@ -1834,18 +3123,18 @@ var LLMGatewayChatLanguageModel = class {
                     toolName: toolCall.function.name
                   });
                 }
-                if (((_h = toolCallDelta.function) == null ? void 0 : _h.arguments) != null) {
-                  toolCall.function.arguments += (_j = (_i = toolCallDelta.function) == null ? void 0 : _i.arguments) != null ? _j : "";
+                if (((_j = toolCallDelta.function) == null ? void 0 : _j.arguments) != null) {
+                  toolCall.function.arguments += (_l = (_k = toolCallDelta.function) == null ? void 0 : _k.arguments) != null ? _l : "";
                 }
                 controller.enqueue({
                   type: "tool-input-delta",
                   id: toolCall.id,
-                  delta: (_k = toolCallDelta.function.arguments) != null ? _k : ""
+                  delta: (_m = toolCallDelta.function.arguments) != null ? _m : ""
                 });
-                if (((_l = toolCall.function) == null ? void 0 : _l.name) != null && ((_m = toolCall.function) == null ? void 0 : _m.arguments) != null && isParsableJson(toolCall.function.arguments)) {
+                if (((_n = toolCall.function) == null ? void 0 : _n.name) != null && ((_o = toolCall.function) == null ? void 0 : _o.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallId: (_n = toolCall.id) != null ? _n : generateId(),
+                    toolCallId: (_p = toolCall.id) != null ? _p : generateId(),
                     toolName: toolCall.function.name,
                     input: toolCall.function.arguments
                   });
@@ -2023,7 +3312,7 @@ var LLMGatewayCompletionChunkSchema = import_v46.z.union([
     choices: import_v46.z.array(
       import_v46.z.object({
         text: import_v46.z.string(),
-        reasoning: import_v46.z.string().nullish().optional(),
+        reasoningText: import_v46.z.string().nullish().optional(),
         reasoning_details: ReasoningDetailArraySchema.nullish(),
         finish_reason: import_v46.z.string().nullish(),
         index: import_v46.z.number().nullish(),
@@ -2119,11 +3408,11 @@ var LLMGatewayCompletionLanguageModel = class {
       prompt: completionPrompt,
       // LLMGateway specific settings:
       include_reasoning: this.settings.includeReasoning,
-      reasoning: this.settings.reasoning
+      reasoningText: this.settings.reasoningText
     }, this.config.extraBody), this.settings.extraBody);
   }
   async doGenerate(options) {
-    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+    var _a16, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
     const providerOptions = options.providerOptions || {};
     const llmgatewayOptions = providerOptions.llmgateway || {};
     const args = __spreadValues(__spreadValues({}, this.getArgs(options)), llmgatewayOptions);
@@ -2152,12 +3441,12 @@ var LLMGatewayCompletionLanguageModel = class {
       content: [
         {
           type: "text",
-          text: (_a15 = choice.text) != null ? _a15 : ""
+          text: (_a16 = choice.text) != null ? _a16 : ""
         }
       ],
       finishReason: mapLLMGatewayFinishReason(choice.finish_reason),
       usage: {
-        inputTokens: (_c = (_b = response.usage) == null ? void 0 : _b.prompt_tokens) != null ? _c : 0,
+        inputTokens: (_c = (_b16 = response.usage) == null ? void 0 : _b16.prompt_tokens) != null ? _c : 0,
         outputTokens: (_e = (_d = response.usage) == null ? void 0 : _d.completion_tokens) != null ? _e : 0,
         totalTokens: ((_g = (_f = response.usage) == null ? void 0 : _f.prompt_tokens) != null ? _g : 0) + ((_i = (_h = response.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : 0),
         reasoningTokens: (_l = (_k = (_j = response.usage) == null ? void 0 : _j.completion_tokens_details) == null ? void 0 : _k.reasoning_tokens) != null ? _l : 0,
@@ -2204,7 +3493,7 @@ var LLMGatewayCompletionLanguageModel = class {
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
-            var _a15, _b;
+            var _a16, _b16;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -2222,7 +3511,7 @@ var LLMGatewayCompletionLanguageModel = class {
               usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
               llmgatewayUsage.promptTokens = value.usage.prompt_tokens;
               if (value.usage.prompt_tokens_details) {
-                const cachedInputTokens = (_a15 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a15 : 0;
+                const cachedInputTokens = (_a16 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a16 : 0;
                 usage.cachedInputTokens = cachedInputTokens;
                 llmgatewayUsage.promptTokensDetails = {
                   cachedTokens: cachedInputTokens
@@ -2230,7 +3519,7 @@ var LLMGatewayCompletionLanguageModel = class {
               }
               llmgatewayUsage.completionTokens = value.usage.completion_tokens;
               if (value.usage.completion_tokens_details) {
-                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
+                const reasoningTokens = (_b16 = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b16 : 0;
                 usage.reasoningTokens = reasoningTokens;
                 llmgatewayUsage.completionTokensDetails = {
                   reasoningTokens
@@ -2278,8 +3567,8 @@ var LLMGateway = class {
    * Creates a new LLMGateway provider instance.
    */
   constructor(options = {}) {
-    var _a15, _b;
-    this.baseURL = (_b = withoutTrailingSlash((_a15 = options.baseURL) != null ? _a15 : options.baseUrl)) != null ? _b : "https://api.llmgateway.io/v1";
+    var _a16, _b16;
+    this.baseURL = (_b16 = withoutTrailingSlash((_a16 = options.baseURL) != null ? _a16 : options.baseUrl)) != null ? _b16 : "https://api.llmgateway.io/v1";
     this.apiKey = options.apiKey;
     this.headers = options.headers;
   }
@@ -2315,8 +3604,8 @@ var LLMGateway = class {
 
 // src/provider.ts
 function createLLMGateway(options = {}) {
-  var _a15, _b, _c, _d;
-  const baseURL = (_c = (_b = withoutTrailingSlash((_a15 = options.baseURL) != null ? _a15 : options.baseUrl)) != null ? _b : process.env.LLM_GATEWAY_API_BASE) != null ? _c : "https://api.llmgateway.io/v1";
+  var _a16, _b16, _c, _d;
+  const baseURL = (_c = (_b16 = withoutTrailingSlash((_a16 = options.baseURL) != null ? _a16 : options.baseUrl)) != null ? _b16 : process.env.LLM_GATEWAY_API_BASE) != null ? _c : "https://api.llmgateway.io/v1";
   const compatibility = (_d = options.compatibility) != null ? _d : "compatible";
   const getHeaders = () => __spreadValues({
     Authorization: `Bearer ${loadApiKey({