@openrouter/ai-sdk-provider 1.5.4 → 2.0.1

package/dist/internal/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") {
@@ -52,11 +64,12 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// node_modules/.pnpm/@ai-sdk+provider@2.0.0/node_modules/@ai-sdk/provider/dist/index.mjs
+// node_modules/.pnpm/@ai-sdk+provider@3.0.0/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.
    *
@@ -66,13 +79,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;
   }
   /**
@@ -81,20 +94,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,
@@ -124,12 +136,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 });
@@ -139,7 +151,6 @@ var EmptyResponseBodyError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker3);
   }
 };
-_a3 = symbol3;
 function getErrorMessage(error) {
   if (error == null) {
     return "unknown error";
@@ -156,7 +167,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,
@@ -170,12 +182,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,
@@ -189,12 +201,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)}.`
@@ -207,12 +219,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,
@@ -227,22 +239,42 @@ 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;
-_a8 = symbol8;
+var _b8;
+var LoadAPIKeyError = class extends (_b8 = AISDKError, _a8 = symbol8, _b8) {
+  // used in isInstance
+  constructor({ message }) {
+    super({ name: name7, message });
+    this[_a8] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker8);
+  }
+};
 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;
-var NoContentGeneratedError = class extends AISDKError {
+var _b10;
+var NoContentGeneratedError = class extends (_b10 = AISDKError, _a10 = symbol10, _b10) {
   // used in isInstance
   constructor({
     message = "No content generated."
@@ -254,22 +286,54 @@ var NoContentGeneratedError = class extends AISDKError {
     return AISDKError.hasMarker(error, marker10);
   }
 };
-_a10 = symbol10;
 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,
@@ -297,16 +361,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.`
@@ -319,9 +382,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.1_zod@4.3.5/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;
@@ -412,7 +480,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 {
@@ -424,7 +492,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;
@@ -448,25 +516,7 @@ var EventSourceParserStream = class extends TransformStream {
   }
 };
 
-// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.1_zod@3.25.76/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.6_zod@3.25.76/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.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/selectParser.js
-var import_zod3 = require("zod");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/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.6_zod@3.25.76/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.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
-var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-
-// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.1_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+// node_modules/.pnpm/@ai-sdk+provider-utils@4.0.1_zod@4.3.5/node_modules/@ai-sdk/provider-utils/dist/index.mjs
 function combineHeaders(...headers) {
   return headers.reduce(
     (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
@@ -476,6 +526,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,
@@ -530,11 +611,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.1" : "0.0.0-test";
 var suspectProtoRx = /"__proto__"\s*:/;
 var suspectConstructorRx = /"constructor"\s*:/;
 function _parse(text) {
@@ -571,34 +694,1195 @@ 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") {
+    jsonSchema2.additionalProperties = false;
+    const properties = jsonSchema2.properties;
+    if (properties != null) {
+      for (const property in properties) {
+        properties[property] = addAdditionalPropertiesToJsonSchema(
+          properties[property]
+        );
+      }
+    }
+  }
+  if (jsonSchema2.type === "array" && jsonSchema2.items != null) {
+    if (Array.isArray(jsonSchema2.items)) {
+      jsonSchema2.items = jsonSchema2.items.map(
+        (item) => addAdditionalPropertiesToJsonSchema(item)
+      );
+    } else {
+      jsonSchema2.items = addAdditionalPropertiesToJsonSchema(
+        jsonSchema2.items
+      );
+    }
+  }
+  return jsonSchema2;
 }
-function isValidator(value) {
-  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in 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 asValidator(value) {
-  return isValidator(value) ? value : standardSchemaValidator(value);
+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 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 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,
@@ -614,12 +1898,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 };
     }
@@ -702,7 +1986,7 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch
+  fetch: fetch2
 }) => postToApi({
   url,
   headers: __spreadValues({
@@ -715,7 +1999,7 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch
+  fetch: fetch2
 });
 var postToApi = async ({
   url,
@@ -724,12 +2008,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
     });
@@ -873,15 +2161,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);
-}
 
 // src/schemas/reasoning-details.ts
 var import_v4 = require("zod/v4");
@@ -1009,7 +2288,7 @@ var OpenRouterProviderOptionsSchema = import_v43.z.object({
 }).optional();
 
 // src/utils/map-finish-reason.ts
-function mapOpenRouterFinishReason(finishReason) {
+function mapToUnified(finishReason) {
   switch (finishReason) {
     case "stop":
       return "stop";
@@ -1021,9 +2300,18 @@ function mapOpenRouterFinishReason(finishReason) {
     case "tool_calls":
       return "tool-calls";
     default:
-      return "unknown";
+      return "other";
   }
 }
+function mapOpenRouterFinishReason(finishReason) {
+  return {
+    unified: mapToUnified(finishReason),
+    raw: finishReason != null ? finishReason : void 0
+  };
+}
+function createFinishReason(unified, raw) {
+  return { unified, raw };
+}
 
 // src/types/openrouter-chat-completions-input.ts
 var OPENROUTER_AUDIO_FORMATS = [
@@ -1056,10 +2344,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({
@@ -1068,12 +2356,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,(.+)$/);
@@ -1148,13 +2436,13 @@ Learn more: https://openrouter.ai/docs/features/multimodal/audio`
 
 // src/chat/convert-to-openrouter-chat-messages.ts
 function getCacheControl(providerMetadata) {
-  var _a15, _b, _c;
+  var _a16, _b16, _c;
   const anthropic = providerMetadata == null ? void 0 : providerMetadata.anthropic;
   const openrouter = providerMetadata == null ? void 0 : providerMetadata.openrouter;
-  return (_c = (_b = (_a15 = openrouter == null ? void 0 : openrouter.cacheControl) != null ? _a15 : openrouter == null ? void 0 : openrouter.cache_control) != null ? _b : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
+  return (_c = (_b16 = (_a16 = openrouter == null ? void 0 : openrouter.cacheControl) != null ? _a16 : openrouter == null ? void 0 : openrouter.cache_control) != null ? _b16 : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
 }
 function convertToOpenRouterChatMessages(prompt) {
-  var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  var _a16, _b16, _c, _d, _e, _f, _g, _h, _i, _j;
   const messages = [];
   for (const { role, content, providerOptions } of prompt) {
     switch (role) {
@@ -1167,8 +2455,8 @@ function convertToOpenRouterChatMessages(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",
@@ -1185,8 +2473,8 @@ function convertToOpenRouterChatMessages(prompt) {
         const messageCacheControl = getCacheControl(providerOptions);
         const contentParts = content.map(
           (part) => {
-            var _a16, _b2, _c2, _d2, _e2, _f2, _g2;
-            const cacheControl = (_a16 = getCacheControl(part.providerOptions)) != null ? _a16 : messageCacheControl;
+            var _a17, _b17, _c2, _d2, _e2, _f2, _g2;
+            const cacheControl = (_a17 = getCacheControl(part.providerOptions)) != null ? _a17 : messageCacheControl;
             switch (part.type) {
               case "text":
                 return {
@@ -1196,7 +2484,7 @@ function convertToOpenRouterChatMessages(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"
@@ -1323,6 +2611,9 @@ function convertToOpenRouterChatMessages(prompt) {
       }
       case "tool": {
         for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
           const content2 = getToolResultContent(toolResponse);
           messages.push({
             role: "tool",
@@ -1341,7 +2632,18 @@ function convertToOpenRouterChatMessages(prompt) {
   return messages;
 }
 function getToolResultContent(input) {
-  return input.output.type === "text" ? input.output.value : JSON.stringify(input.output.value);
+  var _a16;
+  switch (input.output.type) {
+    case "text":
+    case "error-text":
+      return input.output.value;
+    case "json":
+    case "error-json":
+    case "content":
+      return JSON.stringify(input.output.value);
+    case "execution-denied":
+      return (_a16 = input.output.reason) != null ? _a16 : "Tool execution denied";
+  }
 }
 
 // src/chat/get-tool-choice.ts
@@ -1584,7 +2886,7 @@ var OpenRouterStreamChatCompletionChunkSchema = import_v46.z.union([
 // src/chat/index.ts
 var OpenRouterChatLanguageModel = class {
   constructor(modelId, settings, config) {
-    this.specificationVersion = "v2";
+    this.specificationVersion = "v3";
     this.provider = "openrouter";
     this.defaultObjectGenerationMode = "tool";
     this.supportsImageUrls = true;
@@ -1614,7 +2916,7 @@ var OpenRouterChatLanguageModel = class {
     tools,
     toolChoice
   }) {
-    var _a15;
+    var _a16;
     const baseArgs = __spreadValues(__spreadValues({
       // model id:
       model: this.modelId,
@@ -1638,7 +2940,7 @@ var OpenRouterChatLanguageModel = class {
         json_schema: __spreadValues({
           schema: responseFormat.schema,
           strict: true,
-          name: (_a15 = responseFormat.name) != null ? _a15 : "response"
+          name: (_a16 = responseFormat.name) != null ? _a16 : "response"
         }, responseFormat.description && {
           description: responseFormat.description
         })
@@ -1677,7 +2979,7 @@ var OpenRouterChatLanguageModel = 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;
     const providerOptions = options.providerOptions || {};
     const openrouterOptions = providerOptions.openrouter || {};
     const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
@@ -1717,19 +3019,31 @@ var OpenRouterChatLanguageModel = class {
       });
     }
     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: {
+        total: (_a16 = response.usage.prompt_tokens) != null ? _a16 : 0,
+        noCache: void 0,
+        cacheRead: (_c = (_b16 = response.usage.prompt_tokens_details) == null ? void 0 : _b16.cached_tokens) != null ? _c : void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: (_d = response.usage.completion_tokens) != null ? _d : 0,
+        text: void 0,
+        reasoning: (_f = (_e = response.usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : void 0
+      }
     } : {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0,
-      reasoningTokens: 0,
-      cachedInputTokens: 0
+      inputTokens: {
+        total: 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: 0,
+        text: void 0,
+        reasoning: void 0
+      }
     };
-    const reasoningDetails = (_i = choice.message.reasoning_details) != null ? _i : [];
+    const reasoningDetails = (_g = choice.message.reasoning_details) != null ? _g : [];
     const reasoning = reasoningDetails.length > 0 ? reasoningDetails.map((detail) => {
       switch (detail.type) {
         case "reasoning.text" /* Text */: {
@@ -1797,7 +3111,7 @@ var OpenRouterChatLanguageModel = class {
       for (const toolCall of choice.message.tool_calls) {
         content.push({
           type: "tool-call",
-          toolCallId: (_j = toolCall.id) != null ? _j : generateId(),
+          toolCallId: (_h = toolCall.id) != null ? _h : generateId(),
           toolName: toolCall.function.name,
           input: toolCall.function.arguments,
           providerMetadata: {
@@ -1835,7 +3149,7 @@ var OpenRouterChatLanguageModel = class {
         }
       }
     }
-    const fileAnnotations = (_k = choice.message.annotations) == null ? void 0 : _k.filter(
+    const fileAnnotations = (_i = choice.message.annotations) == null ? void 0 : _i.filter(
       (a) => a.type === "file"
     );
     const hasToolCalls = choice.message.tool_calls && choice.message.tool_calls.length > 0;
@@ -1843,7 +3157,7 @@ var OpenRouterChatLanguageModel = class {
       (d) => d.type === "reasoning.encrypted" /* Encrypted */ && d.data
     );
     const shouldOverrideFinishReason = hasToolCalls && hasEncryptedReasoning && choice.finish_reason === "stop";
-    const effectiveFinishReason = shouldOverrideFinishReason ? "tool-calls" : mapOpenRouterFinishReason(choice.finish_reason);
+    const effectiveFinishReason = shouldOverrideFinishReason ? createFinishReason("tool-calls", (_j = choice.finish_reason) != null ? _j : void 0) : mapOpenRouterFinishReason(choice.finish_reason);
     return {
       content,
       finishReason: effectiveFinishReason,
@@ -1851,13 +3165,13 @@ var OpenRouterChatLanguageModel = class {
       warnings: [],
       providerMetadata: {
         openrouter: OpenRouterProviderMetadataSchema.parse({
-          provider: (_l = response.provider) != null ? _l : "",
-          reasoning_details: (_m = choice.message.reasoning_details) != null ? _m : [],
+          provider: (_k = response.provider) != null ? _k : "",
+          reasoning_details: (_l = choice.message.reasoning_details) != null ? _l : [],
           annotations: fileAnnotations && fileAnnotations.length > 0 ? fileAnnotations : void 0,
           usage: __spreadValues(__spreadValues(__spreadValues({
-            promptTokens: (_n = usageInfo.inputTokens) != null ? _n : 0,
-            completionTokens: (_o = usageInfo.outputTokens) != null ? _o : 0,
-            totalTokens: (_p = usageInfo.totalTokens) != null ? _p : 0,
+            promptTokens: (_m = usageInfo.inputTokens.total) != null ? _m : 0,
+            completionTokens: (_n = usageInfo.outputTokens.total) != null ? _n : 0,
+            totalTokens: ((_o = usageInfo.inputTokens.total) != null ? _o : 0) + ((_p = usageInfo.outputTokens.total) != null ? _p : 0),
             cost: (_q = response.usage) == null ? void 0 : _q.cost
           }, ((_s = (_r = response.usage) == null ? void 0 : _r.prompt_tokens_details) == null ? void 0 : _s.cached_tokens) != null ? {
             promptTokensDetails: {
@@ -1883,7 +3197,7 @@ var OpenRouterChatLanguageModel = class {
     };
   }
   async doStream(options) {
-    var _a15;
+    var _a16;
     const providerOptions = options.providerOptions || {};
     const openrouterOptions = providerOptions.openrouter || {};
     const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
@@ -1898,7 +3212,7 @@ var OpenRouterChatLanguageModel = class {
         // 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
+        }, ((_a16 = this.settings.usage) == null ? void 0 : _a16.include) ? { include_usage: true } : {}) : void 0
       }),
       failedResponseHandler: openrouterFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
@@ -1908,13 +3222,19 @@ var OpenRouterChatLanguageModel = class {
       fetch: this.config.fetch
     });
     const toolCalls = [];
-    let finishReason = "other";
+    let finishReason = createFinishReason("other");
     const usage = {
-      inputTokens: Number.NaN,
-      outputTokens: Number.NaN,
-      totalTokens: Number.NaN,
-      reasoningTokens: Number.NaN,
-      cachedInputTokens: Number.NaN
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      }
     };
     const openrouterUsage = {};
     const accumulatedReasoningDetails = [];
@@ -1929,15 +3249,15 @@ var OpenRouterChatLanguageModel = class {
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
-            var _a16, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+            var _a17, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
             if (!chunk.success) {
-              finishReason = "error";
+              finishReason = createFinishReason("error");
               controller.enqueue({ type: "error", error: chunk.error });
               return;
             }
             const value = chunk.value;
             if ("error" in value) {
-              finishReason = "error";
+              finishReason = createFinishReason("error");
               controller.enqueue({ type: "error", error: value.error });
               return;
             }
@@ -1958,21 +3278,20 @@ var OpenRouterChatLanguageModel = class {
               });
             }
             if (value.usage != null) {
-              usage.inputTokens = value.usage.prompt_tokens;
-              usage.outputTokens = value.usage.completion_tokens;
-              usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
+              usage.inputTokens.total = value.usage.prompt_tokens;
+              usage.outputTokens.total = value.usage.completion_tokens;
               openrouterUsage.promptTokens = value.usage.prompt_tokens;
               if (value.usage.prompt_tokens_details) {
-                const cachedInputTokens = (_a16 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a16 : 0;
-                usage.cachedInputTokens = cachedInputTokens;
+                const cachedInputTokens = (_a17 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a17 : 0;
+                usage.inputTokens.cacheRead = cachedInputTokens;
                 openrouterUsage.promptTokensDetails = {
                   cachedTokens: cachedInputTokens
                 };
               }
               openrouterUsage.completionTokens = value.usage.completion_tokens;
               if (value.usage.completion_tokens_details) {
-                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
-                usage.reasoningTokens = reasoningTokens;
+                const reasoningTokens = (_b16 = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b16 : 0;
+                usage.outputTokens.reasoning = reasoningTokens;
                 openrouterUsage.completionTokensDetails = {
                   reasoningTokens
                 };
@@ -2231,20 +3550,20 @@ var OpenRouterChatLanguageModel = class {
             }
           },
           flush(controller) {
-            var _a16;
+            var _a17;
             const hasToolCalls = toolCalls.length > 0;
             const hasEncryptedReasoning = accumulatedReasoningDetails.some(
               (d) => d.type === "reasoning.encrypted" /* Encrypted */ && d.data
             );
-            if (hasToolCalls && hasEncryptedReasoning && finishReason === "stop") {
-              finishReason = "tool-calls";
+            if (hasToolCalls && hasEncryptedReasoning && finishReason.unified === "stop") {
+              finishReason = createFinishReason("tool-calls", finishReason.raw);
             }
-            if (finishReason === "tool-calls") {
+            if (finishReason.unified === "tool-calls") {
               for (const toolCall of toolCalls) {
                 if (toolCall && !toolCall.sent) {
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallId: (_a16 = toolCall.id) != null ? _a16 : generateId(),
+                    toolCallId: (_a17 = toolCall.id) != null ? _a17 : generateId(),
                     toolName: toolCall.function.name,
                     // Coerce invalid arguments to an empty JSON object
                     input: isParsableJson(toolCall.function.arguments) ? toolCall.function.arguments : "{}",
@@ -2445,7 +3764,7 @@ var OpenRouterCompletionChunkSchema = import_v47.z.union([
 // src/completion/index.ts
 var OpenRouterCompletionLanguageModel = class {
   constructor(modelId, settings, config) {
-    this.specificationVersion = "v2";
+    this.specificationVersion = "v3";
     this.provider = "openrouter";
     this.supportsImageUrls = true;
     this.supportedUrls = {
@@ -2516,7 +3835,7 @@ var OpenRouterCompletionLanguageModel = class {
     }, 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;
     const providerOptions = options.providerOptions || {};
     const openrouterOptions = providerOptions.openrouter || {};
     const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
@@ -2558,16 +3877,22 @@ var OpenRouterCompletionLanguageModel = class {
       content: [
         {
           type: "text",
-          text: (_a15 = choice.text) != null ? _a15 : ""
+          text: (_a16 = choice.text) != null ? _a16 : ""
         }
       ],
       finishReason: mapOpenRouterFinishReason(choice.finish_reason),
       usage: {
-        inputTokens: (_c = (_b = response.usage) == null ? void 0 : _b.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,
-        cachedInputTokens: (_o = (_n = (_m = response.usage) == null ? void 0 : _m.prompt_tokens_details) == null ? void 0 : _n.cached_tokens) != null ? _o : 0
+        inputTokens: {
+          total: (_c = (_b16 = response.usage) == null ? void 0 : _b16.prompt_tokens) != null ? _c : 0,
+          noCache: void 0,
+          cacheRead: (_f = (_e = (_d = response.usage) == null ? void 0 : _d.prompt_tokens_details) == null ? void 0 : _e.cached_tokens) != null ? _f : void 0,
+          cacheWrite: void 0
+        },
+        outputTokens: {
+          total: (_h = (_g = response.usage) == null ? void 0 : _g.completion_tokens) != null ? _h : 0,
+          text: void 0,
+          reasoning: (_k = (_j = (_i = response.usage) == null ? void 0 : _i.completion_tokens_details) == null ? void 0 : _j.reasoning_tokens) != null ? _k : void 0
+        }
       },
       warnings: [],
       response: {
@@ -2597,47 +3922,52 @@ var OpenRouterCompletionLanguageModel = class {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    let finishReason = "other";
+    let finishReason = createFinishReason("other");
     const usage = {
-      inputTokens: Number.NaN,
-      outputTokens: Number.NaN,
-      totalTokens: Number.NaN,
-      reasoningTokens: Number.NaN,
-      cachedInputTokens: Number.NaN
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      }
     };
     const openrouterUsage = {};
     return {
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
-            var _a15, _b, _c;
+            var _a16, _b16, _c;
             if (!chunk.success) {
-              finishReason = "error";
+              finishReason = createFinishReason("error");
               controller.enqueue({ type: "error", error: chunk.error });
               return;
             }
             const value = chunk.value;
             if ("error" in value) {
-              finishReason = "error";
+              finishReason = createFinishReason("error");
               controller.enqueue({ type: "error", error: value.error });
               return;
             }
             if (value.usage != null) {
-              usage.inputTokens = value.usage.prompt_tokens;
-              usage.outputTokens = value.usage.completion_tokens;
-              usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
+              usage.inputTokens.total = value.usage.prompt_tokens;
+              usage.outputTokens.total = value.usage.completion_tokens;
               openrouterUsage.promptTokens = value.usage.prompt_tokens;
               if (value.usage.prompt_tokens_details) {
-                const cachedInputTokens = (_a15 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a15 : 0;
-                usage.cachedInputTokens = cachedInputTokens;
+                const cachedInputTokens = (_a16 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a16 : 0;
+                usage.inputTokens.cacheRead = cachedInputTokens;
                 openrouterUsage.promptTokensDetails = {
                   cachedTokens: cachedInputTokens
                 };
               }
               openrouterUsage.completionTokens = value.usage.completion_tokens;
               if (value.usage.completion_tokens_details) {
-                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
-                usage.reasoningTokens = reasoningTokens;
+                const reasoningTokens = (_b16 = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b16 : 0;
+                usage.outputTokens.reasoning = reasoningTokens;
                 openrouterUsage.completionTokensDetails = {
                   reasoningTokens
                 };