@apertis/ai-sdk-provider 2.0.0 → 2.1.0

package/dist/index.cjs

@@ -6,8 +6,8 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name15 in all)
-    __defProp(target, name15, { get: all[name15], enumerable: true });
+  for (var name14 in all)
+    __defProp(target, name14, { get: all[name14], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -31,12 +31,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   apertis: () => apertis,
-  createApertis: () => createApertis,
-  createApertisV3: () => createApertisV3
+  createApertis: () => createApertis
 });
 module.exports = __toCommonJS(index_exports);
 
-// node_modules/.pnpm/@ai-sdk+provider@3.0.4/node_modules/@ai-sdk/provider/dist/index.mjs
+// node_modules/.pnpm/@ai-sdk+provider@2.0.1/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
 var symbol = Symbol.for(marker);
 var _a;
@@ -51,13 +50,13 @@ var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
    * @param {unknown} [params.cause] - The underlying cause of the error.
    */
   constructor({
-    name: name142,
+    name: name14,
     message,
     cause
   }) {
     super(message);
     this[_a] = true;
-    this.name = name142;
+    this.name = name14;
     this.cause = cause;
   }
   /**
@@ -68,8 +67,8 @@ var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
   static isInstance(error) {
     return _AISDKError.hasMarker(error, marker);
   }
-  static hasMarker(error, marker152) {
-    const markerSymbol = Symbol.for(marker152);
+  static hasMarker(error, marker15) {
+    const markerSymbol = Symbol.for(marker15);
     return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
   }
 };
@@ -355,12 +354,6 @@ var UnsupportedFunctionalityError = class extends (_b14 = AISDKError, _a14 = sym
   }
 };
 
-// node_modules/.pnpm/@ai-sdk+provider-utils@4.0.8_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
-var z4 = __toESM(require("zod/v4"), 1);
-var import_v3 = require("zod/v3");
-var import_v32 = require("zod/v3");
-var import_v33 = require("zod/v3");
-
 // node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/index.js
 var ParseError = class extends Error {
   constructor(message, options) {
@@ -488,34 +481,23 @@ var EventSourceParserStream = class extends TransformStream {
   }
 };
 
-// node_modules/.pnpm/@ai-sdk+provider-utils@4.0.8_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.20_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+var z4 = __toESM(require("zod/v4"), 1);
+var import_v3 = require("zod/v3");
+var import_v32 = require("zod/v3");
+var import_v33 = require("zod/v3");
+function combineHeaders(...headers) {
+  return headers.reduce(
+    (combinedHeaders, currentHeaders) => ({
+      ...combinedHeaders,
+      ...currentHeaders != null ? currentHeaders : {}
+    }),
+    {}
+  );
+}
 function extractResponseHeaders(response) {
   return Object.fromEntries([...response.headers]);
 }
-var { btoa, atob } = globalThis;
-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,
@@ -571,14 +553,14 @@ function handleFetchError({
   return error;
 }
 function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
-  var _a22, _b22, _c;
+  var _a15, _b15, _c;
   if (globalThisAny.window) {
     return `runtime/browser`;
   }
-  if ((_a22 = globalThisAny.navigator) == null ? void 0 : _a22.userAgent) {
+  if ((_a15 = globalThisAny.navigator) == null ? void 0 : _a15.userAgent) {
     return `runtime/${globalThisAny.navigator.userAgent.toLowerCase()}`;
   }
-  if ((_c = (_b22 = globalThisAny.process) == null ? void 0 : _b22.versions) == null ? void 0 : _c.node) {
+  if ((_c = (_b15 = globalThisAny.process) == null ? void 0 : _b15.versions) == null ? void 0 : _c.node) {
     return `runtime/node.js/${globalThisAny.process.version.substring(0)}`;
   }
   if (globalThisAny.EdgeRuntime) {
@@ -616,39 +598,7 @@ function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
   );
   return Object.fromEntries(normalizedHeaders.entries());
 }
-var VERSION = true ? "4.0.8" : "0.0.0-test";
-function loadApiKey({
-  apiKey,
-  environmentVariableName,
-  apiKeyParameterName = "apiKey",
-  description
-}) {
-  if (typeof apiKey === "string") {
-    return apiKey;
-  }
-  if (apiKey != null) {
-    throw new LoadAPIKeyError({
-      message: `${description} API key must be a string.`
-    });
-  }
-  if (typeof process === "undefined") {
-    throw new LoadAPIKeyError({
-      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter. Environment variables is not supported in this environment.`
-    });
-  }
-  apiKey = process.env[environmentVariableName];
-  if (apiKey == null) {
-    throw new LoadAPIKeyError({
-      message: `${description} API key is missing. Pass it using the '${apiKeyParameterName}' parameter or the ${environmentVariableName} environment variable.`
-    });
-  }
-  if (typeof apiKey !== "string") {
-    throw new LoadAPIKeyError({
-      message: `${description} API key must be a string. The value of the ${environmentVariableName} environment variable is not a string.`
-    });
-  }
-  return apiKey;
-}
+var VERSION = true ? "3.0.20" : "0.0.0-test";
 var suspectProtoRx = /"__proto__"\s*:/;
 var suspectConstructorRx = /"constructor"\s*:/;
 function _parse(text) {
@@ -696,1314 +646,142 @@ function secureJsonParse(text) {
     Error.stackTraceLimit = stackTraceLimit;
   }
 }
-function addAdditionalPropertiesToJsonSchema(jsonSchema2) {
-  if (jsonSchema2.type === "object" || Array.isArray(jsonSchema2.type) && jsonSchema2.type.includes("object")) {
-    jsonSchema2.additionalProperties = false;
-    const { properties } = jsonSchema2;
-    if (properties != null) {
-      for (const key of Object.keys(properties)) {
-        properties[key] = visit(properties[key]);
-      }
-    }
-  }
-  if (jsonSchema2.items != null) {
-    jsonSchema2.items = Array.isArray(jsonSchema2.items) ? jsonSchema2.items.map(visit) : visit(jsonSchema2.items);
-  }
-  if (jsonSchema2.anyOf != null) {
-    jsonSchema2.anyOf = jsonSchema2.anyOf.map(visit);
-  }
-  if (jsonSchema2.allOf != null) {
-    jsonSchema2.allOf = jsonSchema2.allOf.map(visit);
-  }
-  if (jsonSchema2.oneOf != null) {
-    jsonSchema2.oneOf = jsonSchema2.oneOf.map(visit);
-  }
-  const { definitions } = jsonSchema2;
-  if (definitions != null) {
-    for (const key of Object.keys(definitions)) {
-      definitions[key] = visit(definitions[key]);
-    }
-  }
-  return jsonSchema2;
+var validatorSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.validator");
+function validator(validate) {
+  return { [validatorSymbol]: true, validate };
 }
-function visit(def) {
-  if (typeof def === "boolean") return def;
-  return addAdditionalPropertiesToJsonSchema(def);
+function isValidator(value) {
+  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
 }
-var ignoreOverride = /* @__PURE__ */ Symbol(
-  "Let zodToJsonSchema decide on which parser to use"
-);
-var defaultOptions = {
-  name: void 0,
-  $refStrategy: "root",
-  basePath: ["#"],
-  effectStrategy: "input",
-  pipeStrategy: "all",
-  dateStrategy: "format:date-time",
-  mapStrategy: "entries",
-  removeAdditionalStrategy: "passthrough",
-  allowedAdditionalProperties: true,
-  rejectedAdditionalProperties: false,
-  definitionPath: "definitions",
-  strictUnions: false,
-  definitions: {},
-  errorMessages: false,
-  patternStrategy: "escape",
-  applyRegexFlags: false,
-  emailStrategy: "format:email",
-  base64Strategy: "contentEncoding:base64",
-  nameStrategy: "ref"
-};
-var getDefaultOptions = (options) => typeof options === "string" ? {
-  ...defaultOptions,
-  name: options
-} : {
-  ...defaultOptions,
-  ...options
-};
-function parseAnyDef() {
-  return {};
+function asValidator(value) {
+  return isValidator(value) ? value : typeof value === "function" ? 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, {
-      ...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;
-    }
+async function validateTypes({
+  value,
+  schema
+}) {
+  const result = await safeValidateTypes({ value, schema });
+  if (!result.success) {
+    throw TypeValidationError.wrap({ value, cause: result.error });
   }
-  return res;
-}
-function parseBooleanDef() {
-  return { type: "boolean" };
-}
-function parseBrandedDef(_def, refs) {
-  return parseDef(_def.type._def, refs);
+  return result.value;
 }
-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)) {
+async function safeValidateTypes({
+  value,
+  schema
+}) {
+  const validator2 = asValidator(schema);
+  try {
+    if (validator2.validate == null) {
+      return { success: true, value, rawValue: value };
+    }
+    const result = await validator2.validate(value);
+    if (result.success) {
+      return { success: true, value: result.value, rawValue: value };
+    }
     return {
-      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: result.error }),
+      rawValue: value
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: error }),
+      rawValue: value
     };
-  }
-  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;
+async function parseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = secureJsonParse(text);
+    if (schema == null) {
+      return value;
+    }
+    return validateTypes({ value, schema });
+  } catch (error) {
+    if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) {
+      throw error;
     }
+    throw new JSONParseError({ text, cause: error });
   }
-  return res;
-};
-function parseDefaultDef(_def, refs) {
-  return {
-    ...parseDef(_def.innerType._def, refs),
-    default: _def.defaultValue()
-  };
 }
-function parseEffectsDef(_def, refs) {
-  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef();
-}
-function parseEnumDef(def) {
-  return {
-    type: "string",
-    enum: Array.from(def.values)
-  };
-}
-var isJsonSchema7AllOfType = (type) => {
-  if ("type" in type && type.type === "string") return false;
-  return "allOf" in type;
-};
-function parseIntersectionDef(def, refs) {
-  const allOf = [
-    parseDef(def.left._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "0"]
-    }),
-    parseDef(def.right._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "1"]
-    })
-  ].filter((x) => !!x);
-  const mergedAllOf = [];
-  allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType(schema)) {
-      mergedAllOf.push(...schema.allOf);
-    } else {
-      let nestedSchema = schema;
-      if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema;
-        nestedSchema = rest;
-      }
-      mergedAllOf.push(nestedSchema);
+async function safeParseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = secureJsonParse(text);
+    if (schema == null) {
+      return { success: true, value, rawValue: value };
     }
-  });
-  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 await safeValidateTypes({ value, schema });
+  } catch (error) {
     return {
-      type: Array.isArray(def.value) ? "array" : "object"
+      success: false,
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error }),
+      rawValue: void 0
     };
   }
-  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);
-      }
-    }
+function isParsableJson(input) {
+  try {
+    secureJsonParse(input);
+    return true;
+  } catch (e) {
+    return false;
   }
-  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 parseJsonEventStream({
+  stream,
+  schema
+}) {
+  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
+    new TransformStream({
+      async transform({ data }, controller) {
+        if (data === "[DONE]") {
+          return;
+        }
+        controller.enqueue(await safeParseJSON({ text: data, schema }));
+      }
+    })
+  );
 }
-function addFormat(schema, value, message, refs) {
-  var _a22;
-  if (schema.format || ((_a22 = schema.anyOf) == null ? void 0 : _a22.some((x) => x.format))) {
-    if (!schema.anyOf) {
-      schema.anyOf = [];
-    }
-    if (schema.format) {
-      schema.anyOf.push({
-        format: schema.format
-      });
-      delete schema.format;
-    }
-    schema.anyOf.push({
-      format: value,
-      ...message && refs.errorMessages && { errorMessage: { format: message } }
-    });
-  } else {
-    schema.format = value;
+async function parseProviderOptions({
+  provider,
+  providerOptions,
+  schema
+}) {
+  if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
+    return void 0;
   }
-}
-function addPattern(schema, regex, message, refs) {
-  var _a22;
-  if (schema.pattern || ((_a22 = schema.allOf) == null ? void 0 : _a22.some((x) => x.pattern))) {
-    if (!schema.allOf) {
-      schema.allOf = [];
-    }
-    if (schema.pattern) {
-      schema.allOf.push({
-        pattern: schema.pattern
-      });
-      delete schema.pattern;
-    }
-    schema.allOf.push({
-      pattern: stringifyRegExpWithFlags(regex, refs),
-      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+  const parsedProviderOptions = await safeValidateTypes({
+    value: providerOptions[provider],
+    schema
+  });
+  if (!parsedProviderOptions.success) {
+    throw new InvalidArgumentError({
+      argument: "providerOptions",
+      message: `invalid ${provider} provider options`,
+      cause: parsedProviderOptions.error
     });
-  } else {
-    schema.pattern = stringifyRegExpWithFlags(regex, refs);
   }
-}
-function stringifyRegExpWithFlags(regex, refs) {
-  var _a22;
-  if (!refs.applyRegexFlags || !regex.flags) {
-    return regex.source;
-  }
-  const flags = {
-    i: regex.flags.includes("i"),
-    // Case-insensitive
-    m: regex.flags.includes("m"),
-    // `^` and `$` matches adjacent to newline characters
-    s: regex.flags.includes("s")
-    // `.` matches newlines
-  };
-  const source = flags.i ? regex.source.toLowerCase() : regex.source;
-  let pattern = "";
-  let isEscaped = false;
-  let inCharGroup = false;
-  let inCharRange = false;
-  for (let i = 0; i < source.length; i++) {
-    if (isEscaped) {
-      pattern += source[i];
-      isEscaped = false;
-      continue;
-    }
-    if (flags.i) {
-      if (inCharGroup) {
-        if (source[i].match(/[a-z]/)) {
-          if (inCharRange) {
-            pattern += source[i];
-            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
-            inCharRange = false;
-          } else if (source[i + 1] === "-" && ((_a22 = source[i + 2]) == null ? void 0 : _a22.match(/[a-z]/))) {
-            pattern += source[i];
-            inCharRange = true;
-          } else {
-            pattern += `${source[i]}${source[i].toUpperCase()}`;
-          }
-          continue;
-        }
-      } else if (source[i].match(/[a-z]/)) {
-        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
-        continue;
-      }
-    }
-    if (flags.m) {
-      if (source[i] === "^") {
-        pattern += `(^|(?<=[\r
-]))`;
-        continue;
-      } else if (source[i] === "$") {
-        pattern += `($|(?=[\r
-]))`;
-        continue;
-      }
-    }
-    if (flags.s && source[i] === ".") {
-      pattern += inCharGroup ? `${source[i]}\r
-` : `[${source[i]}\r
-]`;
-      continue;
-    }
-    pattern += source[i];
-    if (source[i] === "\\") {
-      isEscaped = true;
-    } else if (inCharGroup && source[i] === "]") {
-      inCharGroup = false;
-    } else if (!inCharGroup && source[i] === "[") {
-      inCharGroup = true;
-    }
-  }
-  try {
-    new RegExp(pattern);
-  } catch (e) {
-    console.warn(
-      `Could not convert regex pattern at ${refs.currentPath.join(
-        "/"
-      )} to a flag-independent form! Falling back to the flag-ignorant source`
-    );
-    return regex.source;
-  }
-  return pattern;
-}
-function parseRecordDef(def, refs) {
-  var _a22, _b22, _c, _d, _e, _f;
-  const schema = {
-    type: "object",
-    additionalProperties: (_a22 = parseDef(def.valueType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    })) != null ? _a22 : refs.allowedAdditionalProperties
-  };
-  if (((_b22 = def.keyType) == null ? void 0 : _b22._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
-    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodEnum) {
-    return {
-      ...schema,
-      propertyNames: {
-        enum: def.keyType._def.values
-      }
-    };
-  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === import_v33.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === import_v33.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
-    const { type, ...keyType } = parseBrandedDef(
-      def.keyType._def,
-      refs
-    );
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  }
-  return schema;
-}
-function parseMapDef(def, refs) {
-  if (refs.mapStrategy === "record") {
-    return parseRecordDef(def, refs);
-  }
-  const keys = parseDef(def.keyType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "0"]
-  }) || parseAnyDef();
-  const values = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "1"]
-  }) || parseAnyDef();
-  return {
-    type: "array",
-    maxItems: 125,
-    items: {
-      type: "array",
-      items: [keys, values],
-      minItems: 2,
-      maxItems: 2
-    }
-  };
-}
-function parseNativeEnumDef(def) {
-  const object = def.values;
-  const actualKeys = Object.keys(def.values).filter((key) => {
-    return typeof object[object[key]] !== "number";
-  });
-  const actualValues = actualKeys.map((key) => object[key]);
-  const parsedTypes = Array.from(
-    new Set(actualValues.map((values) => typeof values))
-  );
-  return {
-    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
-    enum: actualValues
-  };
-}
-function parseNeverDef() {
-  return { not: parseAnyDef() };
-}
-function parseNullDef() {
-  return {
-    type: "null"
-  };
-}
-var primitiveMappings = {
-  ZodString: "string",
-  ZodNumber: "number",
-  ZodBigInt: "integer",
-  ZodBoolean: "boolean",
-  ZodNull: "null"
-};
-function parseUnionDef(def, refs) {
-  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-  if (options.every(
-    (x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length)
-  )) {
-    const types = options.reduce((types2, x) => {
-      const type = primitiveMappings[x._def.typeName];
-      return type && !types2.includes(type) ? [...types2, type] : types2;
-    }, []);
-    return {
-      type: types.length > 1 ? types : types[0]
-    };
-  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types = options.reduce(
-      (acc, x) => {
-        const type = typeof x._def.value;
-        switch (type) {
-          case "string":
-          case "number":
-          case "boolean":
-            return [...acc, type];
-          case "bigint":
-            return [...acc, "integer"];
-          case "object":
-            if (x._def.value === null) return [...acc, "null"];
-          case "symbol":
-          case "undefined":
-          case "function":
-          default:
-            return acc;
-        }
-      },
-      []
-    );
-    if (types.length === options.length) {
-      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
-      return {
-        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-        enum: options.reduce(
-          (acc, x) => {
-            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
-          },
-          []
-        )
-      };
-    }
-  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
-    return {
-      type: "string",
-      enum: options.reduce(
-        (acc, x) => [
-          ...acc,
-          ...x._def.values.filter((x2) => !acc.includes(x2))
-        ],
-        []
-      )
-    };
-  }
-  return asAnyOf(def, refs);
-}
-var asAnyOf = (def, refs) => {
-  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map(
-    (x, i) => parseDef(x._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "anyOf", `${i}`]
-    })
-  ).filter(
-    (x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0)
-  );
-  return anyOf.length ? { anyOf } : void 0;
-};
-function parseNullableDef(def, refs) {
-  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(
-    def.innerType._def.typeName
-  ) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
-    return {
-      type: [
-        primitiveMappings[def.innerType._def.typeName],
-        "null"
-      ]
-    };
-  }
-  const base = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "0"]
-  });
-  return base && { anyOf: [base, { type: "null" }] };
-}
-function parseNumberDef(def) {
-  const res = {
-    type: "number"
-  };
-  if (!def.checks) return res;
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "int":
-        res.type = "integer";
-        break;
-      case "min":
-        if (check.inclusive) {
-          res.minimum = check.value;
-        } else {
-          res.exclusiveMinimum = check.value;
-        }
-        break;
-      case "max":
-        if (check.inclusive) {
-          res.maximum = check.value;
-        } else {
-          res.exclusiveMaximum = check.value;
-        }
-        break;
-      case "multipleOf":
-        res.multipleOf = check.value;
-        break;
-    }
-  }
-  return res;
-}
-function parseObjectDef(def, refs) {
-  const result = {
-    type: "object",
-    properties: {}
-  };
-  const required = [];
-  const shape = def.shape();
-  for (const propName in shape) {
-    let propDef = shape[propName];
-    if (propDef === void 0 || propDef._def === void 0) {
-      continue;
-    }
-    const propOptional = safeIsOptional(propDef);
-    const parsedDef = parseDef(propDef._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "properties", propName],
-      propertyPath: [...refs.currentPath, "properties", propName]
-    });
-    if (parsedDef === void 0) {
-      continue;
-    }
-    result.properties[propName] = parsedDef;
-    if (!propOptional) {
-      required.push(propName);
-    }
-  }
-  if (required.length) {
-    result.required = required;
-  }
-  const additionalProperties = decideAdditionalProperties(def, refs);
-  if (additionalProperties !== void 0) {
-    result.additionalProperties = additionalProperties;
-  }
-  return result;
-}
-function decideAdditionalProperties(def, refs) {
-  if (def.catchall._def.typeName !== "ZodNever") {
-    return parseDef(def.catchall._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    });
-  }
-  switch (def.unknownKeys) {
-    case "passthrough":
-      return refs.allowedAdditionalProperties;
-    case "strict":
-      return refs.rejectedAdditionalProperties;
-    case "strip":
-      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
-  }
-}
-function safeIsOptional(schema) {
-  try {
-    return schema.isOptional();
-  } catch (e) {
-    return true;
-  }
-}
-var parseOptionalDef = (def, refs) => {
-  var _a22;
-  if (refs.currentPath.toString() === ((_a22 = refs.propertyPath) == null ? void 0 : _a22.toString())) {
-    return parseDef(def.innerType._def, refs);
-  }
-  const innerSchema = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "1"]
-  });
-  return innerSchema ? { anyOf: [{ not: parseAnyDef() }, innerSchema] } : parseAnyDef();
-};
-var parsePipelineDef = (def, refs) => {
-  if (refs.pipeStrategy === "input") {
-    return parseDef(def.in._def, refs);
-  } else if (refs.pipeStrategy === "output") {
-    return parseDef(def.out._def, refs);
-  }
-  const a = parseDef(def.in._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", "0"]
-  });
-  const b = parseDef(def.out._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
-  });
-  return {
-    allOf: [a, b].filter((x) => x !== void 0)
-  };
-};
-function parsePromiseDef(def, refs) {
-  return parseDef(def.type._def, refs);
-}
-function parseSetDef(def, refs) {
-  const items = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items"]
-  });
-  const schema = {
-    type: "array",
-    uniqueItems: true,
-    items
-  };
-  if (def.minSize) {
-    schema.minItems = def.minSize.value;
-  }
-  if (def.maxSize) {
-    schema.maxItems = def.maxSize.value;
-  }
-  return schema;
-}
-function parseTupleDef(def, refs) {
-  if (def.rest) {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      items: def.items.map(
-        (x, i) => parseDef(x._def, {
-          ...refs,
-          currentPath: [...refs.currentPath, "items", `${i}`]
-        })
-      ).reduce(
-        (acc, x) => x === void 0 ? acc : [...acc, x],
-        []
-      ),
-      additionalItems: parseDef(def.rest._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "additionalItems"]
-      })
-    };
-  } else {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      maxItems: def.items.length,
-      items: def.items.map(
-        (x, i) => parseDef(x._def, {
-          ...refs,
-          currentPath: [...refs.currentPath, "items", `${i}`]
-        })
-      ).reduce(
-        (acc, x) => x === void 0 ? acc : [...acc, x],
-        []
-      )
-    };
-  }
-}
-function parseUndefinedDef() {
-  return {
-    not: parseAnyDef()
-  };
-}
-function parseUnknownDef() {
-  return parseAnyDef();
-}
-var parseReadonlyDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
-};
-var selectParser = (def, typeName, refs) => {
-  switch (typeName) {
-    case import_v3.ZodFirstPartyTypeKind.ZodString:
-      return parseStringDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodNumber:
-      return parseNumberDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodObject:
-      return parseObjectDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodBigInt:
-      return parseBigintDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodBoolean:
-      return parseBooleanDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodDate:
-      return parseDateDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodUndefined:
-      return parseUndefinedDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodNull:
-      return parseNullDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodArray:
-      return parseArrayDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodUnion:
-    case import_v3.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-      return parseUnionDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodIntersection:
-      return parseIntersectionDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodTuple:
-      return parseTupleDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodRecord:
-      return parseRecordDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodLiteral:
-      return parseLiteralDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodEnum:
-      return parseEnumDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodNativeEnum:
-      return parseNativeEnumDef(def);
-    case import_v3.ZodFirstPartyTypeKind.ZodNullable:
-      return parseNullableDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodOptional:
-      return parseOptionalDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodMap:
-      return parseMapDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodSet:
-      return parseSetDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodLazy:
-      return () => def.getter()._def;
-    case import_v3.ZodFirstPartyTypeKind.ZodPromise:
-      return parsePromiseDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodNaN:
-    case import_v3.ZodFirstPartyTypeKind.ZodNever:
-      return parseNeverDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodEffects:
-      return parseEffectsDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodAny:
-      return parseAnyDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodUnknown:
-      return parseUnknownDef();
-    case import_v3.ZodFirstPartyTypeKind.ZodDefault:
-      return parseDefaultDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodBranded:
-      return parseBrandedDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodReadonly:
-      return parseReadonlyDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodCatch:
-      return parseCatchDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodPipeline:
-      return parsePipelineDef(def, refs);
-    case import_v3.ZodFirstPartyTypeKind.ZodFunction:
-    case import_v3.ZodFirstPartyTypeKind.ZodVoid:
-    case import_v3.ZodFirstPartyTypeKind.ZodSymbol:
-      return void 0;
-    default:
-      return /* @__PURE__ */ ((_) => void 0)(typeName);
-  }
-};
-var getRelativePath = (pathA, pathB) => {
-  let i = 0;
-  for (; i < pathA.length && i < pathB.length; i++) {
-    if (pathA[i] !== pathB[i]) break;
-  }
-  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
-};
-function parseDef(def, refs, forceResolution = false) {
-  var _a22;
-  const seenItem = refs.seen.get(def);
-  if (refs.override) {
-    const overrideResult = (_a22 = refs.override) == null ? void 0 : _a22.call(
-      refs,
-      def,
-      refs,
-      seenItem,
-      forceResolution
-    );
-    if (overrideResult !== ignoreOverride) {
-      return overrideResult;
-    }
-  }
-  if (seenItem && !forceResolution) {
-    const seenSchema = get$ref(seenItem, refs);
-    if (seenSchema !== void 0) {
-      return seenSchema;
-    }
-  }
-  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
-  refs.seen.set(def, newItem);
-  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
-  const jsonSchema2 = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
-  if (jsonSchema2) {
-    addMeta(def, refs, jsonSchema2);
-  }
-  if (refs.postProcess) {
-    const postProcessResult = refs.postProcess(jsonSchema2, def, refs);
-    newItem.jsonSchema = jsonSchema2;
-    return postProcessResult;
-  }
-  newItem.jsonSchema = jsonSchema2;
-  return jsonSchema2;
-}
-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 {
-    ..._options,
-    currentPath,
-    propertyPath: void 0,
-    seen: new Map(
-      Object.entries(_options.definitions).map(([name22, def]) => [
-        def._def,
-        {
-          def: def._def,
-          path: [..._options.basePath, _options.definitionPath, name22],
-          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-          jsonSchema: void 0
-        }
-      ])
-    )
-  };
-};
-var zod3ToJsonSchema = (schema, options) => {
-  var _a22;
-  const refs = getRefs(options);
-  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce(
-    (acc, [name32, schema2]) => {
-      var _a32;
-      return {
-        ...acc,
-        [name32]: (_a32 = parseDef(
-          schema2._def,
-          {
-            ...refs,
-            currentPath: [...refs.basePath, refs.definitionPath, name32]
-          },
-          true
-        )) != null ? _a32 : parseAnyDef()
-      };
-    },
-    {}
-  ) : void 0;
-  const name22 = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
-  const main = (_a22 = parseDef(
-    schema._def,
-    name22 === void 0 ? refs : {
-      ...refs,
-      currentPath: [...refs.basePath, refs.definitionPath, name22]
-    },
-    false
-  )) != null ? _a22 : parseAnyDef();
-  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
-  if (title !== void 0) {
-    main.title = title;
-  }
-  const combined = name22 === void 0 ? definitions ? {
-    ...main,
-    [refs.definitionPath]: definitions
-  } : main : {
-    $ref: [
-      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
-      refs.definitionPath,
-      name22
-    ].join("/"),
-    [refs.definitionPath]: {
-      ...definitions,
-      [name22]: main
-    }
-  };
-  combined.$schema = "http://json-schema.org/draft-07/schema#";
-  return combined;
-};
-var schemaSymbol = /* @__PURE__ */ Symbol.for("vercel.ai.schema");
-function jsonSchema(jsonSchema2, {
-  validate
-} = {}) {
-  return {
-    [schemaSymbol]: true,
-    _type: void 0,
-    // should never be used directly
-    get jsonSchema() {
-      if (typeof jsonSchema2 === "function") {
-        jsonSchema2 = jsonSchema2();
-      }
-      return jsonSchema2;
-    },
-    validate
-  };
-}
-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(
-    () => addAdditionalPropertiesToJsonSchema(
-      standardSchema2["~standard"].jsonSchema.input({
-        target: "draft-07"
-      })
-    ),
-    {
-      validate: async (value) => {
-        const result = await standardSchema2["~standard"].validate(value);
-        return "value" in result ? { success: true, value: result.value } : {
-          success: false,
-          error: new TypeValidationError({
-            value,
-            cause: result.issues
-          })
-        };
-      }
-    }
-  );
-}
-function 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
-}) {
-  const result = await safeValidateTypes({ value, schema });
-  if (!result.success) {
-    throw TypeValidationError.wrap({ value, cause: result.error });
-  }
-  return result.value;
-}
-async function safeValidateTypes({
-  value,
-  schema
-}) {
-  const actualSchema = asSchema(schema);
-  try {
-    if (actualSchema.validate == null) {
-      return { success: true, value, rawValue: value };
-    }
-    const result = await actualSchema.validate(value);
-    if (result.success) {
-      return { success: true, value: result.value, rawValue: value };
-    }
-    return {
-      success: false,
-      error: TypeValidationError.wrap({ value, cause: result.error }),
-      rawValue: value
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: TypeValidationError.wrap({ value, cause: error }),
-      rawValue: value
-    };
-  }
-}
-async function parseJSON({
-  text,
-  schema
-}) {
-  try {
-    const value = secureJsonParse(text);
-    if (schema == null) {
-      return value;
-    }
-    return validateTypes({ value, schema });
-  } catch (error) {
-    if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) {
-      throw error;
-    }
-    throw new JSONParseError({ text, cause: error });
-  }
-}
-async function safeParseJSON({
-  text,
-  schema
-}) {
-  try {
-    const value = secureJsonParse(text);
-    if (schema == null) {
-      return { success: true, value, rawValue: value };
-    }
-    return await safeValidateTypes({ value, schema });
-  } catch (error) {
-    return {
-      success: false,
-      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error }),
-      rawValue: void 0
-    };
-  }
-}
-function parseJsonEventStream({
-  stream,
-  schema
-}) {
-  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
-    new TransformStream({
-      async transform({ data }, controller) {
-        if (data === "[DONE]") {
-          return;
-        }
-        controller.enqueue(await safeParseJSON({ text: data, schema }));
-      }
-    })
-  );
+  return parsedProviderOptions.value;
 }
 var getOriginalFetch2 = () => globalThis.fetch;
 var postJsonToApi = async ({
@@ -2013,7 +791,7 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 }) => postToApi({
   url,
   headers: {
@@ -2027,7 +805,7 @@ var postJsonToApi = async ({
   failedResponseHandler,
   successfulResponseHandler,
   abortSignal,
-  fetch: fetch2
+  fetch
 });
 var postToApi = async ({
   url,
@@ -2036,10 +814,10 @@ var postToApi = async ({
   successfulResponseHandler,
   failedResponseHandler,
   abortSignal,
-  fetch: fetch2 = getOriginalFetch2()
+  fetch = getOriginalFetch2()
 }) => {
   try {
-    const response = await fetch2(url, {
+    const response = await fetch(url, {
       method: "POST",
       headers: withUserAgentSuffix(
         headers,
@@ -2189,856 +967,1393 @@ var createJsonResponseHandler = (responseSchema) => async ({ response, url, requ
     rawValue: parsedResult.rawValue
   };
 };
-function withoutTrailingSlash(url) {
-  return url == null ? void 0 : url.replace(/\/$/, "");
-}
-
-// src/apertis-error.ts
-var import_zod = require("zod");
-var apertisErrorSchema = import_zod.z.object({
-  error: import_zod.z.object({
-    message: import_zod.z.string(),
-    type: import_zod.z.string().optional(),
-    code: import_zod.z.string().nullable().optional(),
-    param: import_zod.z.string().nullable().optional()
-  })
-});
-var apertisFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: apertisErrorSchema,
-  errorToMessage: (error) => error.error.message
-});
-
-// src/schemas/chat-response.ts
-var import_zod2 = require("zod");
-var openAIChatResponseSchema = import_zod2.z.object({
-  id: import_zod2.z.string().optional(),
-  object: import_zod2.z.literal("chat.completion").optional(),
-  created: import_zod2.z.number().optional(),
-  model: import_zod2.z.string().optional(),
-  choices: import_zod2.z.array(
-    import_zod2.z.object({
-      index: import_zod2.z.number(),
-      message: import_zod2.z.object({
-        role: import_zod2.z.literal("assistant"),
-        content: import_zod2.z.string().nullable(),
-        tool_calls: import_zod2.z.array(
-          import_zod2.z.object({
-            id: import_zod2.z.string(),
-            type: import_zod2.z.literal("function"),
-            function: import_zod2.z.object({
-              name: import_zod2.z.string(),
-              arguments: import_zod2.z.string()
-            })
-          })
-        ).optional()
-      }),
-      finish_reason: import_zod2.z.string().nullable(),
-      logprobs: import_zod2.z.any().nullable().optional()
-    })
-  ),
-  usage: import_zod2.z.object({
-    prompt_tokens: import_zod2.z.number(),
-    completion_tokens: import_zod2.z.number(),
-    total_tokens: import_zod2.z.number().optional()
-  }).optional()
-});
-var openAIChatChunkSchema = import_zod2.z.object({
-  id: import_zod2.z.string().optional(),
-  object: import_zod2.z.literal("chat.completion.chunk").optional(),
-  created: import_zod2.z.number().optional(),
-  model: import_zod2.z.string().optional(),
-  choices: import_zod2.z.array(
-    import_zod2.z.object({
-      index: import_zod2.z.number(),
-      delta: import_zod2.z.object({
-        role: import_zod2.z.literal("assistant").optional(),
-        content: import_zod2.z.string().nullable().optional(),
-        tool_calls: import_zod2.z.array(
-          import_zod2.z.object({
-            index: import_zod2.z.number(),
-            id: import_zod2.z.string().optional(),
-            type: import_zod2.z.literal("function").optional(),
-            function: import_zod2.z.object({
-              name: import_zod2.z.string().optional(),
-              arguments: import_zod2.z.string().optional()
-            }).optional()
-          })
-        ).optional()
-      }),
-      finish_reason: import_zod2.z.string().nullable().optional()
-    })
-  ),
-  usage: import_zod2.z.object({
-    prompt_tokens: import_zod2.z.number(),
-    completion_tokens: import_zod2.z.number()
-  }).nullish()
-});
-
-// src/utils/map-finish-reason.ts
-function normalizeFinishReason(finishReason) {
-  switch (finishReason) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "tool_calls":
-      return "tool-calls";
-    case "content_filter":
-      return "content-filter";
-    default:
-      return "other";
+var ALPHA_NUMERIC = new Set(
+  "ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789"
+);
+var { btoa, atob } = globalThis;
+function convertUint8ArrayToBase64(array) {
+  let latin1string = "";
+  for (let i = 0; i < array.length; i++) {
+    latin1string += String.fromCodePoint(array[i]);
   }
+  return btoa(latin1string);
 }
-function mapApertisFinishReason(finishReason) {
-  return {
-    unified: normalizeFinishReason(finishReason),
-    raw: finishReason ?? void 0
-  };
+function convertToBase64(value) {
+  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
 }
-function mapApertisFinishReasonV2(finishReason) {
-  return normalizeFinishReason(finishReason);
+function withoutTrailingSlash(url) {
+  return url == null ? void 0 : url.replace(/\/$/, "");
 }
 
-// src/utils/convert-to-openai-messages.ts
-function convertToOpenAIMessages(prompt) {
+// node_modules/.pnpm/@ai-sdk+openai-compatible@1.0.30_zod@3.25.76/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
+var import_v4 = require("zod/v4");
+var import_v42 = require("zod/v4");
+var import_v43 = require("zod/v4");
+var import_v44 = require("zod/v4");
+var import_v45 = require("zod/v4");
+var import_v46 = require("zod/v4");
+var import_v47 = require("zod/v4");
+var import_v48 = require("zod/v4");
+function getOpenAIMetadata(message) {
+  var _a15, _b15;
+  return (_b15 = (_a15 = message == null ? void 0 : message.providerOptions) == null ? void 0 : _a15.openaiCompatible) != null ? _b15 : {};
+}
+function convertToOpenAICompatibleChatMessages(prompt) {
   const messages = [];
-  for (const message of prompt) {
-    switch (message.role) {
-      case "system":
-        messages.push({ role: "system", content: message.content });
+  for (const { role, content, ...message } of prompt) {
+    const metadata = getOpenAIMetadata({ ...message });
+    switch (role) {
+      case "system": {
+        messages.push({ role: "system", content, ...metadata });
         break;
-      case "user":
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({
+            role: "user",
+            content: content[0].text,
+            ...getOpenAIMetadata(content[0])
+          });
+          break;
+        }
         messages.push({
           role: "user",
-          content: message.content.map((part) => {
+          content: content.map((part) => {
+            const partMetadata = getOpenAIMetadata(part);
             switch (part.type) {
-              case "text":
-                return { type: "text", text: part.text };
+              case "text": {
+                return { type: "text", text: part.text, ...partMetadata };
+              }
               case "file": {
-                if (part.mediaType?.startsWith("image/")) {
-                  let url;
-                  if (part.data instanceof URL) {
-                    url = part.data.toString();
-                  } else if (typeof part.data === "string") {
-                    if (part.data.startsWith("http://") || part.data.startsWith("https://")) {
-                      url = part.data;
-                    } else {
-                      url = `data:${part.mediaType};base64,${part.data}`;
-                    }
-                  } else {
-                    url = `data:${part.mediaType};base64,${Buffer.from(part.data).toString("base64")}`;
-                  }
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
                   return {
                     type: "image_url",
-                    image_url: { url }
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    },
+                    ...partMetadata
                   };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
                 }
-                throw new Error(
-                  `Unsupported file type: ${part.mediaType}. Only image/* is supported.`
-                );
               }
-              default:
-                throw new Error(
-                  `Unsupported user content part type: ${part.type}`
-                );
             }
-          })
+          }),
+          ...metadata
         });
         break;
+      }
       case "assistant": {
-        const textContent = message.content.filter((p) => p.type === "text").map((p) => p.text).join("");
-        const toolCalls = message.content.filter((p) => p.type === "tool-call").map((tc) => {
-          let arguments_str = "{}";
-          try {
-            arguments_str = typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input);
-          } catch {
-            arguments_str = "{}";
+        let text = "";
+        const toolCalls = [];
+        for (const part of content) {
+          const partMetadata = getOpenAIMetadata(part);
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                },
+                ...partMetadata
+              });
+              break;
+            }
           }
-          return {
-            id: tc.toolCallId,
-            type: "function",
-            function: { name: tc.toolName, arguments: arguments_str }
-          };
-        });
+        }
         messages.push({
           role: "assistant",
-          content: textContent || null,
-          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+          content: text,
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+          ...metadata
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+          const toolResponseMetadata = getOpenAIMetadata(toolResponse);
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+            ...toolResponseMetadata
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return messages;
+}
+function getResponseMetadata({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id != null ? id : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
+}
+function mapOpenAICompatibleFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+var openaiCompatibleProviderOptions = import_v42.z.object({
+  /**
+   * A unique identifier representing your end-user, which can help the provider to
+   * monitor and detect abuse.
+   */
+  user: import_v42.z.string().optional(),
+  /**
+   * Reasoning effort for reasoning models. Defaults to `medium`.
+   */
+  reasoningEffort: import_v42.z.string().optional(),
+  /**
+   * Controls the verbosity of the generated text. Defaults to `medium`.
+   */
+  textVerbosity: import_v42.z.string().optional()
+});
+var openaiCompatibleErrorDataSchema = import_v43.z.object({
+  error: import_v43.z.object({
+    message: import_v43.z.string(),
+    // The additional information below is handled loosely to support
+    // OpenAI-compatible providers that have slightly different error
+    // responses:
+    type: import_v43.z.string().nullish(),
+    param: import_v43.z.any().nullish(),
+    code: import_v43.z.union([import_v43.z.string(), import_v43.z.number()]).nullish()
+  })
+});
+var defaultOpenAICompatibleErrorStructure = {
+  errorSchema: openaiCompatibleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+};
+function prepareTools({
+  tools,
+  toolChoice
+}) {
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: void 0, toolChoice: void 0, toolWarnings };
+  }
+  const openaiCompatTools = [];
+  for (const tool of tools) {
+    if (tool.type === "provider-defined") {
+      toolWarnings.push({ type: "unsupported-tool", tool });
+    } else {
+      openaiCompatTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiCompatTools, toolChoice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiCompatTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+var OpenAICompatibleChatLanguageModel = class {
+  // type inferred via constructor
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    var _a15, _b15;
+    this.modelId = modelId;
+    this.config = config;
+    const errorStructure = (_a15 = config.errorStructure) != null ? _a15 : defaultOpenAICompatibleErrorStructure;
+    this.chunkSchema = createOpenAICompatibleChatChunkSchema(
+      errorStructure.errorSchema
+    );
+    this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
+    this.supportsStructuredOutputs = (_b15 = config.supportsStructuredOutputs) != null ? _b15 : false;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  get supportedUrls() {
+    var _a15, _b15, _c;
+    return (_c = (_b15 = (_a15 = this.config).supportedUrls) == null ? void 0 : _b15.call(_a15)) != null ? _c : {};
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    providerOptions,
+    stopSequences,
+    responseFormat,
+    seed,
+    toolChoice,
+    tools
+  }) {
+    var _a15, _b15, _c, _d;
+    const warnings = [];
+    const compatibleOptions = Object.assign(
+      (_a15 = await parseProviderOptions({
+        provider: "openai-compatible",
+        providerOptions,
+        schema: openaiCompatibleProviderOptions
+      })) != null ? _a15 : {},
+      (_b15 = await parseProviderOptions({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleProviderOptions
+      })) != null ? _b15 : {}
+    );
+    if (topK != null) {
+      warnings.push({ type: "unsupported-setting", setting: "topK" });
+    }
+    if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format schema is only supported with structuredOutputs"
+      });
+    }
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      toolWarnings
+    } = prepareTools({
+      tools,
+      toolChoice
+    });
+    return {
+      args: {
+        // model id:
+        model: this.modelId,
+        // model specific settings:
+        user: compatibleOptions.user,
+        // standardized settings:
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
+          type: "json_schema",
+          json_schema: {
+            schema: responseFormat.schema,
+            name: (_c = responseFormat.name) != null ? _c : "response",
+            description: responseFormat.description
+          }
+        } : { type: "json_object" } : void 0,
+        stop: stopSequences,
+        seed,
+        ...Object.fromEntries(
+          Object.entries(
+            (_d = providerOptions == null ? void 0 : providerOptions[this.providerOptionsName]) != null ? _d : {}
+          ).filter(
+            ([key]) => !Object.keys(openaiCompatibleProviderOptions.shape).includes(key)
+          )
+        ),
+        reasoning_effort: compatibleOptions.reasoningEffort,
+        verbosity: compatibleOptions.textVerbosity,
+        // messages:
+        messages: convertToOpenAICompatibleChatMessages(prompt),
+        // tools:
+        tools: openaiTools,
+        tool_choice: openaiToolChoice
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
+  }
+  async doGenerate(options) {
+    var _a15, _b15, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+    const { args, warnings } = await this.getArgs({ ...options });
+    const body = JSON.stringify(args);
+    const {
+      responseHeaders,
+      value: responseBody,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        OpenAICompatibleChatResponseSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const choice = responseBody.choices[0];
+    const content = [];
+    const text = choice.message.content;
+    if (text != null && text.length > 0) {
+      content.push({ type: "text", text });
+    }
+    const reasoning = (_a15 = choice.message.reasoning_content) != null ? _a15 : choice.message.reasoning;
+    if (reasoning != null && reasoning.length > 0) {
+      content.push({
+        type: "reasoning",
+        text: reasoning
+      });
+    }
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: (_b15 = toolCall.id) != null ? _b15 : generateId(),
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments
+        });
+      }
+    }
+    const providerMetadata = {
+      [this.providerOptionsName]: {},
+      ...await ((_d = (_c = this.config.metadataExtractor) == null ? void 0 : _c.extractMetadata) == null ? void 0 : _d.call(_c, {
+        parsedBody: rawResponse
+      }))
+    };
+    const completionTokenDetails = (_e = responseBody.usage) == null ? void 0 : _e.completion_tokens_details;
+    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
+      providerMetadata[this.providerOptionsName].acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
+    }
+    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
+      providerMetadata[this.providerOptionsName].rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
+    }
+    return {
+      content,
+      finishReason: mapOpenAICompatibleFinishReason(choice.finish_reason),
+      usage: {
+        inputTokens: (_g = (_f = responseBody.usage) == null ? void 0 : _f.prompt_tokens) != null ? _g : void 0,
+        outputTokens: (_i = (_h = responseBody.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : void 0,
+        totalTokens: (_k = (_j = responseBody.usage) == null ? void 0 : _j.total_tokens) != null ? _k : void 0,
+        reasoningTokens: (_n = (_m = (_l = responseBody.usage) == null ? void 0 : _l.completion_tokens_details) == null ? void 0 : _m.reasoning_tokens) != null ? _n : void 0,
+        cachedInputTokens: (_q = (_p = (_o = responseBody.usage) == null ? void 0 : _o.prompt_tokens_details) == null ? void 0 : _p.cached_tokens) != null ? _q : void 0
+      },
+      providerMetadata,
+      request: { body },
+      response: {
+        ...getResponseMetadata(responseBody),
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      warnings
+    };
+  }
+  async doStream(options) {
+    var _a15;
+    const { args, warnings } = await this.getArgs({ ...options });
+    const body = {
+      ...args,
+      stream: true,
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.includeUsage ? { include_usage: true } : void 0
+    };
+    const metadataExtractor = (_a15 = this.config.metadataExtractor) == null ? void 0 : _a15.createStreamExtractor();
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: this.failedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        this.chunkSchema
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const toolCalls = [];
+    let finishReason = "unknown";
+    const usage = {
+      completionTokens: void 0,
+      completionTokensDetails: {
+        reasoningTokens: void 0,
+        acceptedPredictionTokens: void 0,
+        rejectedPredictionTokens: void 0
+      },
+      promptTokens: void 0,
+      promptTokensDetails: {
+        cachedTokens: void 0
+      },
+      totalTokens: void 0
+    };
+    let isFirstChunk = true;
+    const providerOptionsName = this.providerOptionsName;
+    let isActiveReasoning = false;
+    let isActiveText = false;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          // TODO we lost type safety on Chunk, most likely due to the error schema. MUST FIX
+          transform(chunk, controller) {
+            var _a22, _b15, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
+            if (!chunk.success) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            metadataExtractor == null ? void 0 : metadataExtractor.processChunk(chunk.rawValue);
+            if ("error" in value) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: value.error.message });
+              return;
+            }
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata(value)
+              });
+            }
+            if (value.usage != null) {
+              const {
+                prompt_tokens,
+                completion_tokens,
+                total_tokens,
+                prompt_tokens_details,
+                completion_tokens_details
+              } = value.usage;
+              usage.promptTokens = prompt_tokens != null ? prompt_tokens : void 0;
+              usage.completionTokens = completion_tokens != null ? completion_tokens : void 0;
+              usage.totalTokens = total_tokens != null ? total_tokens : void 0;
+              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens) != null) {
+                usage.completionTokensDetails.reasoningTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens;
+              }
+              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.accepted_prediction_tokens) != null) {
+                usage.completionTokensDetails.acceptedPredictionTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.accepted_prediction_tokens;
+              }
+              if ((completion_tokens_details == null ? void 0 : completion_tokens_details.rejected_prediction_tokens) != null) {
+                usage.completionTokensDetails.rejectedPredictionTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.rejected_prediction_tokens;
+              }
+              if ((prompt_tokens_details == null ? void 0 : prompt_tokens_details.cached_tokens) != null) {
+                usage.promptTokensDetails.cachedTokens = prompt_tokens_details == null ? void 0 : prompt_tokens_details.cached_tokens;
+              }
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = mapOpenAICompatibleFinishReason(
+                choice.finish_reason
+              );
+            }
+            if ((choice == null ? void 0 : choice.delta) == null) {
+              return;
+            }
+            const delta = choice.delta;
+            const reasoningContent = (_a22 = delta.reasoning_content) != null ? _a22 : delta.reasoning;
+            if (reasoningContent) {
+              if (!isActiveReasoning) {
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: "reasoning-0"
+                });
+                isActiveReasoning = true;
+              }
+              controller.enqueue({
+                type: "reasoning-delta",
+                id: "reasoning-0",
+                delta: reasoningContent
+              });
+            }
+            if (delta.content) {
+              if (!isActiveText) {
+                controller.enqueue({ type: "text-start", id: "txt-0" });
+                isActiveText = true;
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: "txt-0",
+                delta: delta.content
+              });
+            }
+            if (delta.tool_calls != null) {
+              for (const toolCallDelta of delta.tool_calls) {
+                const index = toolCallDelta.index;
+                if (toolCalls[index] == null) {
+                  if (toolCallDelta.id == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'id' to be a string.`
+                    });
+                  }
+                  if (((_b15 = toolCallDelta.function) == null ? void 0 : _b15.name) == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'function.name' to be a string.`
+                    });
+                  }
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCallDelta.id,
+                    toolName: toolCallDelta.function.name
+                  });
+                  toolCalls[index] = {
+                    id: toolCallDelta.id,
+                    type: "function",
+                    function: {
+                      name: toolCallDelta.function.name,
+                      arguments: (_c = toolCallDelta.function.arguments) != null ? _c : ""
+                    },
+                    hasFinished: false
+                  };
+                  const toolCall2 = toolCalls[index];
+                  if (((_d = toolCall2.function) == null ? void 0 : _d.name) != null && ((_e = toolCall2.function) == null ? void 0 : _e.arguments) != null) {
+                    if (toolCall2.function.arguments.length > 0) {
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        id: toolCall2.id,
+                        delta: toolCall2.function.arguments
+                      });
+                    }
+                    if (isParsableJson(toolCall2.function.arguments)) {
+                      controller.enqueue({
+                        type: "tool-input-end",
+                        id: toolCall2.id
+                      });
+                      controller.enqueue({
+                        type: "tool-call",
+                        toolCallId: (_f = toolCall2.id) != null ? _f : generateId(),
+                        toolName: toolCall2.function.name,
+                        input: toolCall2.function.arguments
+                      });
+                      toolCall2.hasFinished = true;
+                    }
+                  }
+                  continue;
+                }
+                const toolCall = toolCalls[index];
+                if (toolCall.hasFinished) {
+                  continue;
+                }
+                if (((_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null) {
+                  toolCall.function.arguments += (_i = (_h = toolCallDelta.function) == null ? void 0 : _h.arguments) != null ? _i : "";
+                }
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.id,
+                  delta: (_j = toolCallDelta.function.arguments) != null ? _j : ""
+                });
+                if (((_k = toolCall.function) == null ? void 0 : _k.name) != null && ((_l = toolCall.function) == null ? void 0 : _l.arguments) != null && isParsableJson(toolCall.function.arguments)) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.id
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: (_m = toolCall.id) != null ? _m : generateId(),
+                    toolName: toolCall.function.name,
+                    input: toolCall.function.arguments
+                  });
+                  toolCall.hasFinished = true;
+                }
+              }
+            }
+          },
+          flush(controller) {
+            var _a22, _b15, _c, _d, _e, _f;
+            if (isActiveReasoning) {
+              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+            }
+            if (isActiveText) {
+              controller.enqueue({ type: "text-end", id: "txt-0" });
+            }
+            for (const toolCall of toolCalls.filter(
+              (toolCall2) => !toolCall2.hasFinished
+            )) {
+              controller.enqueue({
+                type: "tool-input-end",
+                id: toolCall.id
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: (_a22 = toolCall.id) != null ? _a22 : generateId(),
+                toolName: toolCall.function.name,
+                input: toolCall.function.arguments
+              });
+            }
+            const providerMetadata = {
+              [providerOptionsName]: {},
+              ...metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata()
+            };
+            if (usage.completionTokensDetails.acceptedPredictionTokens != null) {
+              providerMetadata[providerOptionsName].acceptedPredictionTokens = usage.completionTokensDetails.acceptedPredictionTokens;
+            }
+            if (usage.completionTokensDetails.rejectedPredictionTokens != null) {
+              providerMetadata[providerOptionsName].rejectedPredictionTokens = usage.completionTokensDetails.rejectedPredictionTokens;
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage: {
+                inputTokens: (_b15 = usage.promptTokens) != null ? _b15 : void 0,
+                outputTokens: (_c = usage.completionTokens) != null ? _c : void 0,
+                totalTokens: (_d = usage.totalTokens) != null ? _d : void 0,
+                reasoningTokens: (_e = usage.completionTokensDetails.reasoningTokens) != null ? _e : void 0,
+                cachedInputTokens: (_f = usage.promptTokensDetails.cachedTokens) != null ? _f : void 0
+              },
+              providerMetadata
+            });
+          }
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
+    };
+  }
+};
+var openaiCompatibleTokenUsageSchema = import_v4.z.object({
+  prompt_tokens: import_v4.z.number().nullish(),
+  completion_tokens: import_v4.z.number().nullish(),
+  total_tokens: import_v4.z.number().nullish(),
+  prompt_tokens_details: import_v4.z.object({
+    cached_tokens: import_v4.z.number().nullish()
+  }).nullish(),
+  completion_tokens_details: import_v4.z.object({
+    reasoning_tokens: import_v4.z.number().nullish(),
+    accepted_prediction_tokens: import_v4.z.number().nullish(),
+    rejected_prediction_tokens: import_v4.z.number().nullish()
+  }).nullish()
+}).nullish();
+var OpenAICompatibleChatResponseSchema = import_v4.z.object({
+  id: import_v4.z.string().nullish(),
+  created: import_v4.z.number().nullish(),
+  model: import_v4.z.string().nullish(),
+  choices: import_v4.z.array(
+    import_v4.z.object({
+      message: import_v4.z.object({
+        role: import_v4.z.literal("assistant").nullish(),
+        content: import_v4.z.string().nullish(),
+        reasoning_content: import_v4.z.string().nullish(),
+        reasoning: import_v4.z.string().nullish(),
+        tool_calls: import_v4.z.array(
+          import_v4.z.object({
+            id: import_v4.z.string().nullish(),
+            function: import_v4.z.object({
+              name: import_v4.z.string(),
+              arguments: import_v4.z.string()
+            })
+          })
+        ).nullish()
+      }),
+      finish_reason: import_v4.z.string().nullish()
+    })
+  ),
+  usage: openaiCompatibleTokenUsageSchema
+});
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v4.z.union([
+  import_v4.z.object({
+    id: import_v4.z.string().nullish(),
+    created: import_v4.z.number().nullish(),
+    model: import_v4.z.string().nullish(),
+    choices: import_v4.z.array(
+      import_v4.z.object({
+        delta: import_v4.z.object({
+          role: import_v4.z.enum(["assistant"]).nullish(),
+          content: import_v4.z.string().nullish(),
+          // Most openai-compatible models set `reasoning_content`, but some
+          // providers serving `gpt-oss` set `reasoning`. See #7866
+          reasoning_content: import_v4.z.string().nullish(),
+          reasoning: import_v4.z.string().nullish(),
+          tool_calls: import_v4.z.array(
+            import_v4.z.object({
+              index: import_v4.z.number(),
+              id: import_v4.z.string().nullish(),
+              function: import_v4.z.object({
+                name: import_v4.z.string().nullish(),
+                arguments: import_v4.z.string().nullish()
+              })
+            })
+          ).nullish()
+        }).nullish(),
+        finish_reason: import_v4.z.string().nullish()
+      })
+    ),
+    usage: openaiCompatibleTokenUsageSchema
+  }),
+  errorSchema
+]);
+function convertToOpenAICompatibleCompletionPrompt({
+  prompt,
+  user = "user",
+  assistant = "assistant"
+}) {
+  let text = "";
+  if (prompt[0].role === "system") {
+    text += `${prompt[0].content}
+
+`;
+    prompt = prompt.slice(1);
+  }
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        throw new InvalidPromptError({
+          message: "Unexpected system message in prompt: ${content}",
+          prompt
         });
+      }
+      case "user": {
+        const userMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+          }
+        }).filter(Boolean).join("");
+        text += `${user}:
+${userMessage}
+
+`;
         break;
       }
-      case "tool":
-        for (const result of message.content) {
-          if (result.type !== "tool-result") continue;
-          let content = "{}";
-          const output = result.output;
-          if (typeof output === "string") {
-            content = output;
-          } else if (Array.isArray(output)) {
-            const textParts = output.filter((p) => p.type === "text").map((p) => p.text);
-            content = textParts.join("");
-          } else {
-            try {
-              content = JSON.stringify(output);
-            } catch {
-              content = "{}";
+      case "assistant": {
+        const assistantMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+            case "tool-call": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "tool-call messages"
+              });
             }
           }
-          messages.push({
-            role: "tool",
-            tool_call_id: result.toolCallId,
-            content
-          });
-        }
+        }).join("");
+        text += `${assistant}:
+${assistantMessage}
+
+`;
         break;
+      }
+      case "tool": {
+        throw new UnsupportedFunctionalityError({
+          functionality: "tool messages"
+        });
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
     }
   }
-  return messages;
+  text += `${assistant}:
+`;
+  return {
+    prompt: text,
+    stopSequences: [`
+${user}:`]
+  };
 }
-
-// src/utils/convert-to-openai-tools.ts
-function convertToOpenAITools(tools) {
-  if (!tools || tools.length === 0) return void 0;
-  return tools.map((tool) => ({
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.inputSchema
-    }
-  }));
+function getResponseMetadata2({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id != null ? id : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
 }
-function convertToOpenAIToolChoice(toolChoice) {
-  if (!toolChoice) return void 0;
-  switch (toolChoice.type) {
-    case "none":
-      return "none";
-    case "auto":
-      return "auto";
-    case "required":
-      return "required";
-    case "tool":
-      if (!toolChoice.toolName) return void 0;
-      return {
-        type: "function",
-        function: { name: toolChoice.toolName }
-      };
+function mapOpenAICompatibleFinishReason2(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
     default:
-      return void 0;
+      return "unknown";
   }
 }
-
-// src/apertis-chat-language-model.ts
-var ApertisChatLanguageModel = class {
-  constructor(modelId, settings, config) {
+var openaiCompatibleCompletionProviderOptions = import_v45.z.object({
+  /**
+   * Echo back the prompt in addition to the completion.
+   */
+  echo: import_v45.z.boolean().optional(),
+  /**
+   * Modify the likelihood of specified tokens appearing in the completion.
+   *
+   * Accepts a JSON object that maps tokens (specified by their token ID in
+   * the GPT tokenizer) to an associated bias value from -100 to 100.
+   */
+  logitBias: import_v45.z.record(import_v45.z.string(), import_v45.z.number()).optional(),
+  /**
+   * The suffix that comes after a completion of inserted text.
+   */
+  suffix: import_v45.z.string().optional(),
+  /**
+   * A unique identifier representing your end-user, which can help providers to
+   * monitor and detect abuse.
+   */
+  user: import_v45.z.string().optional()
+});
+var OpenAICompatibleCompletionLanguageModel = class {
+  // type inferred via constructor
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    var _a15;
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
+    const errorStructure = (_a15 = config.errorStructure) != null ? _a15 : defaultOpenAICompatibleErrorStructure;
+    this.chunkSchema = createOpenAICompatibleCompletionChunkSchema(
+      errorStructure.errorSchema
+    );
+    this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
   }
-  specificationVersion = "v3";
-  /**
-   * Supported URL patterns for different media types.
-   * Supports HTTP(S) image URLs for direct URL passing.
-   */
-  supportedUrls = {
-    "image/*": [/^https?:\/\/.+$/]
-  };
   get provider() {
     return this.config.provider;
   }
-  async doGenerate(options) {
-    const body = this.buildRequestBody(options, false);
-    const { value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: this.config.headers(),
-      body,
-      failedResponseHandler: apertisFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        openAIChatResponseSchema
-      ),
-      fetch: this.config.fetch,
-      abortSignal: options.abortSignal
-    });
-    const choice = response.choices[0];
-    const content = [];
-    if (choice.message.content) {
-      content.push({
-        type: "text",
-        text: choice.message.content
-      });
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  get supportedUrls() {
+    var _a15, _b15, _c;
+    return (_c = (_b15 = (_a15 = this.config).supportedUrls) == null ? void 0 : _b15.call(_a15)) != null ? _c : {};
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences: userStopSequences,
+    responseFormat,
+    seed,
+    providerOptions,
+    tools,
+    toolChoice
+  }) {
+    var _a15;
+    const warnings = [];
+    const completionOptions = (_a15 = await parseProviderOptions({
+      provider: this.providerOptionsName,
+      providerOptions,
+      schema: openaiCompatibleCompletionProviderOptions
+    })) != null ? _a15 : {};
+    if (topK != null) {
+      warnings.push({ type: "unsupported-setting", setting: "topK" });
     }
-    if (choice.message.tool_calls) {
-      for (const tc of choice.message.tool_calls) {
-        content.push({
-          type: "tool-call",
-          toolCallId: tc.id,
-          toolName: tc.function.name,
-          input: tc.function.arguments
-        });
-      }
+    if (tools == null ? void 0 : tools.length) {
+      warnings.push({ type: "unsupported-setting", setting: "tools" });
+    }
+    if (toolChoice != null) {
+      warnings.push({ type: "unsupported-setting", setting: "toolChoice" });
+    }
+    if (responseFormat != null && responseFormat.type !== "text") {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "responseFormat",
+        details: "JSON response format is not supported."
+      });
     }
+    const { prompt: completionPrompt, stopSequences } = convertToOpenAICompatibleCompletionPrompt({ prompt });
+    const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
     return {
-      content,
-      finishReason: mapApertisFinishReason(choice.finish_reason),
-      usage: {
-        inputTokens: {
-          total: response.usage?.prompt_tokens ?? 0,
-          noCache: void 0,
-          cacheRead: void 0,
-          cacheWrite: void 0
-        },
-        outputTokens: {
-          total: response.usage?.completion_tokens ?? 0,
-          text: void 0,
-          reasoning: void 0
-        }
-      },
-      warnings: [],
-      request: { body }
-    };
-  }
-  async doStream(options) {
-    const body = this.buildRequestBody(options, true);
-    const { value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: this.config.headers(),
-      body,
-      failedResponseHandler: apertisFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler(
-        openAIChatChunkSchema
-      ),
-      fetch: this.config.fetch,
-      abortSignal: options.abortSignal
-    });
-    const toolCallBuffers = /* @__PURE__ */ new Map();
-    let textId = null;
-    const transformStream = new TransformStream({
-      transform(parseResult, controller) {
-        if (!parseResult.success) {
-          return;
-        }
-        const chunk = parseResult.value;
-        const choice = chunk.choices[0];
-        if (!choice) return;
-        if (choice.delta.content) {
-          if (!textId) {
-            textId = generateId();
-            controller.enqueue({
-              type: "text-start",
-              id: textId
-            });
-          }
-          controller.enqueue({
-            type: "text-delta",
-            id: textId,
-            delta: choice.delta.content
-          });
-        }
-        if (choice.delta.tool_calls) {
-          for (const tc of choice.delta.tool_calls) {
-            let buffer = toolCallBuffers.get(tc.index);
-            if (!buffer) {
-              buffer = { id: tc.id ?? generateId(), name: "", arguments: "" };
-              toolCallBuffers.set(tc.index, buffer);
-            }
-            if (tc.id) buffer.id = tc.id;
-            if (tc.function?.name) buffer.name += tc.function.name;
-            if (tc.function?.arguments)
-              buffer.arguments += tc.function.arguments;
-          }
-        }
-        if (choice.finish_reason) {
-          if (textId) {
-            controller.enqueue({
-              type: "text-end",
-              id: textId
-            });
-          }
-          for (const [, buffer] of toolCallBuffers) {
-            if (buffer.name) {
-              controller.enqueue({
-                type: "tool-call",
-                toolCallId: buffer.id,
-                toolName: buffer.name,
-                input: buffer.arguments
-              });
-            }
-          }
-          toolCallBuffers.clear();
-          controller.enqueue({
-            type: "finish",
-            finishReason: mapApertisFinishReason(choice.finish_reason),
-            usage: {
-              inputTokens: {
-                total: chunk.usage?.prompt_tokens ?? 0,
-                noCache: void 0,
-                cacheRead: void 0,
-                cacheWrite: void 0
-              },
-              outputTokens: {
-                total: chunk.usage?.completion_tokens ?? 0,
-                text: void 0,
-                reasoning: void 0
-              }
-            }
-          });
-        }
+      args: {
+        // model id:
+        model: this.modelId,
+        // model specific settings:
+        echo: completionOptions.echo,
+        logit_bias: completionOptions.logitBias,
+        suffix: completionOptions.suffix,
+        user: completionOptions.user,
+        // standardized settings:
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        seed,
+        ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
+        // prompt:
+        prompt: completionPrompt,
+        // stop sequences:
+        stop: stop.length > 0 ? stop : void 0
       },
-      flush(controller) {
-        if (textId) {
-          controller.enqueue({
-            type: "text-end",
-            id: textId
-          });
-        }
-        for (const [, buffer] of toolCallBuffers) {
-          if (buffer.name) {
-            controller.enqueue({
-              type: "tool-call",
-              toolCallId: buffer.id,
-              toolName: buffer.name,
-              input: buffer.arguments
-            });
-          }
-        }
-      }
-    });
-    return {
-      stream: response.pipeThrough(transformStream),
-      request: { body }
-    };
-  }
-  buildRequestBody(options, stream) {
-    const tools = this.filterFunctionTools(options.tools);
-    const responseFormat = options.responseFormat?.type === "json" ? { type: "json_object" } : void 0;
-    const body = {
-      model: this.modelId,
-      messages: convertToOpenAIMessages(options.prompt),
-      stream
+      warnings
     };
-    if (stream) body.stream_options = { include_usage: true };
-    if (options.temperature !== void 0)
-      body.temperature = options.temperature;
-    if (options.maxOutputTokens !== void 0)
-      body.max_tokens = options.maxOutputTokens;
-    if (options.topP !== void 0) body.top_p = options.topP;
-    if (options.frequencyPenalty !== void 0)
-      body.frequency_penalty = options.frequencyPenalty;
-    if (options.presencePenalty !== void 0)
-      body.presence_penalty = options.presencePenalty;
-    if (options.stopSequences !== void 0) body.stop = options.stopSequences;
-    if (options.seed !== void 0) body.seed = options.seed;
-    const convertedTools = convertToOpenAITools(tools);
-    if (convertedTools !== void 0) body.tools = convertedTools;
-    const convertedToolChoice = convertToOpenAIToolChoice(options.toolChoice);
-    if (convertedToolChoice !== void 0)
-      body.tool_choice = convertedToolChoice;
-    if (responseFormat !== void 0) body.response_format = responseFormat;
-    if (this.settings.user !== void 0) body.user = this.settings.user;
-    if (this.settings.logprobs !== void 0)
-      body.logprobs = this.settings.logprobs;
-    if (this.settings.topLogprobs !== void 0)
-      body.top_logprobs = this.settings.topLogprobs;
-    return body;
-  }
-  filterFunctionTools(tools) {
-    if (!tools) return void 0;
-    return tools.filter(
-      (tool) => tool.type === "function"
-    );
-  }
-};
-
-// src/apertis-chat-language-model-v2.ts
-var ApertisChatLanguageModelV2 = class {
-  constructor(modelId, settings, config) {
-    this.modelId = modelId;
-    this.settings = settings;
-    this.config = config;
-  }
-  specificationVersion = "v2";
-  supportedUrls = {
-    "image/*": [/^https?:\/\/.+$/]
-  };
-  get provider() {
-    return this.config.provider;
   }
   async doGenerate(options) {
-    const body = this.buildRequestBody(options, false);
-    const { value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: this.config.headers(),
-      body,
-      failedResponseHandler: apertisFailedResponseHandler,
+    var _a15, _b15, _c, _d, _e, _f;
+    const { args, warnings } = await this.getArgs(options);
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: this.failedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
-        openAIChatResponseSchema
+        openaiCompatibleCompletionResponseSchema
       ),
-      fetch: this.config.fetch,
-      abortSignal: options.abortSignal
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
     });
     const choice = response.choices[0];
     const content = [];
-    if (choice.message.content) {
-      content.push({
-        type: "text",
-        text: choice.message.content
-      });
-    }
-    if (choice.message.tool_calls) {
-      for (const tc of choice.message.tool_calls) {
-        content.push({
-          type: "tool-call",
-          toolCallId: tc.id,
-          toolName: tc.function.name,
-          input: tc.function.arguments
-        });
-      }
+    if (choice.text != null && choice.text.length > 0) {
+      content.push({ type: "text", text: choice.text });
     }
     return {
       content,
-      finishReason: mapApertisFinishReasonV2(choice.finish_reason),
       usage: {
-        inputTokens: response.usage?.prompt_tokens ?? 0,
-        outputTokens: response.usage?.completion_tokens ?? 0,
-        totalTokens: response.usage?.total_tokens ?? void 0
+        inputTokens: (_b15 = (_a15 = response.usage) == null ? void 0 : _a15.prompt_tokens) != null ? _b15 : void 0,
+        outputTokens: (_d = (_c = response.usage) == null ? void 0 : _c.completion_tokens) != null ? _d : void 0,
+        totalTokens: (_f = (_e = response.usage) == null ? void 0 : _e.total_tokens) != null ? _f : void 0
       },
-      warnings: [],
-      request: { body }
+      finishReason: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+      request: { body: args },
+      response: {
+        ...getResponseMetadata2(response),
+        headers: responseHeaders,
+        body: rawResponse
+      },
+      warnings
     };
   }
   async doStream(options) {
-    const body = this.buildRequestBody(options, true);
-    const { value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: this.config.headers(),
+    const { args, warnings } = await this.getArgs(options);
+    const body = {
+      ...args,
+      stream: true,
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.includeUsage ? { include_usage: true } : void 0
+    };
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: "/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body,
-      failedResponseHandler: apertisFailedResponseHandler,
+      failedResponseHandler: this.failedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
-        openAIChatChunkSchema
+        this.chunkSchema
       ),
-      fetch: this.config.fetch,
-      abortSignal: options.abortSignal
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
     });
-    const toolCallBuffers = /* @__PURE__ */ new Map();
-    let textId = null;
-    const transformStream = new TransformStream({
-      transform(parseResult, controller) {
-        if (!parseResult.success) {
-          return;
-        }
-        const chunk = parseResult.value;
-        const choice = chunk.choices[0];
-        if (!choice) return;
-        if (choice.delta.content) {
-          if (!textId) {
-            textId = generateId();
-            controller.enqueue({
-              type: "text-start",
-              id: textId
-            });
-          }
-          controller.enqueue({
-            type: "text-delta",
-            id: textId,
-            delta: choice.delta.content
-          });
-        }
-        if (choice.delta.tool_calls) {
-          for (const tc of choice.delta.tool_calls) {
-            let buffer = toolCallBuffers.get(tc.index);
-            if (!buffer) {
-              buffer = {
-                id: tc.id ?? generateId(),
-                name: "",
-                arguments: ""
-              };
-              toolCallBuffers.set(tc.index, buffer);
+    let finishReason = "unknown";
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
+    };
+    let isFirstChunk = true;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            var _a15, _b15, _c;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
-            if (tc.id) buffer.id = tc.id;
-            if (tc.function?.name) buffer.name += tc.function.name;
-            if (tc.function?.arguments)
-              buffer.arguments += tc.function.arguments;
-          }
-        }
-        if (choice.finish_reason) {
-          if (textId) {
-            controller.enqueue({
-              type: "text-end",
-              id: textId
-            });
-          }
-          for (const [, buffer] of toolCallBuffers) {
-            if (buffer.name) {
+            if (!chunk.success) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if ("error" in value) {
+              finishReason = "error";
+              controller.enqueue({ type: "error", error: value.error });
+              return;
+            }
+            if (isFirstChunk) {
+              isFirstChunk = false;
               controller.enqueue({
-                type: "tool-call",
-                toolCallId: buffer.id,
-                toolName: buffer.name,
-                input: buffer.arguments
+                type: "response-metadata",
+                ...getResponseMetadata2(value)
+              });
+              controller.enqueue({
+                type: "text-start",
+                id: "0"
               });
             }
-          }
-          toolCallBuffers.clear();
-          controller.enqueue({
-            type: "finish",
-            finishReason: mapApertisFinishReasonV2(choice.finish_reason),
-            usage: {
-              inputTokens: chunk.usage?.prompt_tokens ?? 0,
-              outputTokens: chunk.usage?.completion_tokens ?? 0,
-              totalTokens: void 0
+            if (value.usage != null) {
+              usage.inputTokens = (_a15 = value.usage.prompt_tokens) != null ? _a15 : void 0;
+              usage.outputTokens = (_b15 = value.usage.completion_tokens) != null ? _b15 : void 0;
+              usage.totalTokens = (_c = value.usage.total_tokens) != null ? _c : void 0;
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = mapOpenAICompatibleFinishReason2(
+                choice.finish_reason
+              );
+            }
+            if ((choice == null ? void 0 : choice.text) != null) {
+              controller.enqueue({
+                type: "text-delta",
+                id: "0",
+                delta: choice.text
+              });
+            }
+          },
+          flush(controller) {
+            if (!isFirstChunk) {
+              controller.enqueue({ type: "text-end", id: "0" });
             }
-          });
-        }
-      },
-      flush(controller) {
-        if (textId) {
-          controller.enqueue({
-            type: "text-end",
-            id: textId
-          });
-        }
-        for (const [, buffer] of toolCallBuffers) {
-          if (buffer.name) {
             controller.enqueue({
-              type: "tool-call",
-              toolCallId: buffer.id,
-              toolName: buffer.name,
-              input: buffer.arguments
+              type: "finish",
+              finishReason,
+              usage
             });
           }
-        }
-      }
-    });
-    return {
-      stream: response.pipeThrough(transformStream),
-      request: { body }
-    };
-  }
-  buildRequestBody(options, stream) {
-    const tools = this.filterFunctionTools(options.tools);
-    const responseFormat = options.responseFormat?.type === "json" ? { type: "json_object" } : void 0;
-    const body = {
-      model: this.modelId,
-      messages: convertToOpenAIMessages(options.prompt),
-      stream
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
     };
-    if (stream) body.stream_options = { include_usage: true };
-    if (options.temperature !== void 0)
-      body.temperature = options.temperature;
-    if (options.maxOutputTokens !== void 0)
-      body.max_tokens = options.maxOutputTokens;
-    if (options.topP !== void 0) body.top_p = options.topP;
-    if (options.frequencyPenalty !== void 0)
-      body.frequency_penalty = options.frequencyPenalty;
-    if (options.presencePenalty !== void 0)
-      body.presence_penalty = options.presencePenalty;
-    if (options.stopSequences !== void 0) body.stop = options.stopSequences;
-    if (options.seed !== void 0) body.seed = options.seed;
-    const convertedTools = convertToOpenAITools(tools);
-    if (convertedTools !== void 0) body.tools = convertedTools;
-    const convertedToolChoice = convertToOpenAIToolChoice(options.toolChoice);
-    if (convertedToolChoice !== void 0)
-      body.tool_choice = convertedToolChoice;
-    if (responseFormat !== void 0) body.response_format = responseFormat;
-    if (this.settings.user !== void 0) body.user = this.settings.user;
-    if (this.settings.logprobs !== void 0)
-      body.logprobs = this.settings.logprobs;
-    if (this.settings.topLogprobs !== void 0)
-      body.top_logprobs = this.settings.topLogprobs;
-    return body;
-  }
-  filterFunctionTools(tools) {
-    if (!tools) return void 0;
-    return tools.filter(
-      (tool) => tool.type === "function"
-    );
   }
 };
-
-// src/schemas/embedding-response.ts
-var import_zod3 = require("zod");
-var openAIEmbeddingResponseSchema = import_zod3.z.object({
-  object: import_zod3.z.literal("list").optional(),
-  data: import_zod3.z.array(
-    import_zod3.z.object({
-      object: import_zod3.z.literal("embedding").optional(),
-      embedding: import_zod3.z.array(import_zod3.z.number()),
-      index: import_zod3.z.number()
+var usageSchema = import_v44.z.object({
+  prompt_tokens: import_v44.z.number(),
+  completion_tokens: import_v44.z.number(),
+  total_tokens: import_v44.z.number()
+});
+var openaiCompatibleCompletionResponseSchema = import_v44.z.object({
+  id: import_v44.z.string().nullish(),
+  created: import_v44.z.number().nullish(),
+  model: import_v44.z.string().nullish(),
+  choices: import_v44.z.array(
+    import_v44.z.object({
+      text: import_v44.z.string(),
+      finish_reason: import_v44.z.string()
     })
   ),
-  model: import_zod3.z.string().optional(),
-  usage: import_zod3.z.object({
-    prompt_tokens: import_zod3.z.number(),
-    total_tokens: import_zod3.z.number()
-  }).optional()
+  usage: usageSchema.nullish()
 });
-
-// src/apertis-embedding-model.ts
-var ApertisEmbeddingModel = class {
-  constructor(modelId, settings, config) {
+var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => import_v44.z.union([
+  import_v44.z.object({
+    id: import_v44.z.string().nullish(),
+    created: import_v44.z.number().nullish(),
+    model: import_v44.z.string().nullish(),
+    choices: import_v44.z.array(
+      import_v44.z.object({
+        text: import_v44.z.string(),
+        finish_reason: import_v44.z.string().nullish(),
+        index: import_v44.z.number()
+      })
+    ),
+    usage: usageSchema.nullish()
+  }),
+  errorSchema
+]);
+var openaiCompatibleEmbeddingProviderOptions = import_v47.z.object({
+  /**
+   * The number of dimensions the resulting output embeddings should have.
+   * Only supported in text-embedding-3 and later models.
+   */
+  dimensions: import_v47.z.number().optional(),
+  /**
+   * A unique identifier representing your end-user, which can help providers to
+   * monitor and detect abuse.
+   */
+  user: import_v47.z.string().optional()
+});
+var OpenAICompatibleEmbeddingModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
-    this.maxEmbeddingsPerCall = settings.maxEmbeddingsPerCall ?? 2048;
-    this.supportsParallelCalls = settings.supportsParallelCalls ?? true;
   }
-  specificationVersion = "v3";
-  maxEmbeddingsPerCall;
-  supportsParallelCalls;
   get provider() {
     return this.config.provider;
   }
-  async doEmbed(options) {
-    const body = {
-      model: this.modelId,
-      input: options.values,
-      encoding_format: "float"
-    };
-    if (this.settings.dimensions !== void 0) {
-      body.dimensions = this.settings.dimensions;
-    }
-    if (this.settings.user !== void 0) {
-      body.user = this.settings.user;
+  get maxEmbeddingsPerCall() {
+    var _a15;
+    return (_a15 = this.config.maxEmbeddingsPerCall) != null ? _a15 : 2048;
+  }
+  get supportsParallelCalls() {
+    var _a15;
+    return (_a15 = this.config.supportsParallelCalls) != null ? _a15 : true;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    var _a15, _b15, _c;
+    const compatibleOptions = Object.assign(
+      (_a15 = await parseProviderOptions({
+        provider: "openai-compatible",
+        providerOptions,
+        schema: openaiCompatibleEmbeddingProviderOptions
+      })) != null ? _a15 : {},
+      (_b15 = await parseProviderOptions({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleEmbeddingProviderOptions
+      })) != null ? _b15 : {}
+    );
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
     }
-    const { value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/embeddings`,
-      headers: this.config.headers(),
-      body,
-      failedResponseHandler: apertisFailedResponseHandler,
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/embeddings",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        input: values,
+        encoding_format: "float",
+        dimensions: compatibleOptions.dimensions,
+        user: compatibleOptions.user
+      },
+      failedResponseHandler: createJsonErrorResponseHandler(
+        (_c = this.config.errorStructure) != null ? _c : defaultOpenAICompatibleErrorStructure
+      ),
       successfulResponseHandler: createJsonResponseHandler(
-        openAIEmbeddingResponseSchema
+        openaiTextEmbeddingResponseSchema
       ),
-      fetch: this.config.fetch,
-      abortSignal: options.abortSignal
+      abortSignal,
+      fetch: this.config.fetch
     });
     return {
       embeddings: response.data.map((item) => item.embedding),
       usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
-      warnings: []
+      providerMetadata: response.providerMetadata,
+      response: { headers: responseHeaders, body: rawValue }
     };
   }
 };
-
-// src/apertis-embedding-model-v2.ts
-var ApertisEmbeddingModelV2 = class {
-  constructor(modelId, settings, config) {
+var openaiTextEmbeddingResponseSchema = import_v46.z.object({
+  data: import_v46.z.array(import_v46.z.object({ embedding: import_v46.z.array(import_v46.z.number()) })),
+  usage: import_v46.z.object({ prompt_tokens: import_v46.z.number() }).nullish(),
+  providerMetadata: import_v46.z.record(import_v46.z.string(), import_v46.z.record(import_v46.z.string(), import_v46.z.any())).optional()
+});
+var OpenAICompatibleImageModel = class {
+  constructor(modelId, config) {
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
-    this.maxEmbeddingsPerCall = settings.maxEmbeddingsPerCall ?? 2048;
-    this.supportsParallelCalls = settings.supportsParallelCalls ?? true;
+    this.specificationVersion = "v2";
+    this.maxImagesPerCall = 10;
   }
-  specificationVersion = "v2";
-  maxEmbeddingsPerCall;
-  supportsParallelCalls;
   get provider() {
     return this.config.provider;
   }
-  async doEmbed(options) {
-    const body = {
-      model: this.modelId,
-      input: options.values,
-      encoding_format: "float"
-    };
-    if (this.settings.dimensions !== void 0) {
-      body.dimensions = this.settings.dimensions;
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal
+  }) {
+    var _a15, _b15, _c, _d, _e;
+    const warnings = [];
+    if (aspectRatio != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "aspectRatio",
+        details: "This model does not support aspect ratio. Use `size` instead."
+      });
     }
-    if (this.settings.user !== void 0) {
-      body.user = this.settings.user;
+    if (seed != null) {
+      warnings.push({ type: "unsupported-setting", setting: "seed" });
     }
-    const { value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/embeddings`,
-      headers: this.config.headers(),
-      body,
-      failedResponseHandler: apertisFailedResponseHandler,
+    const currentDate = (_c = (_b15 = (_a15 = this.config._internal) == null ? void 0 : _a15.currentDate) == null ? void 0 : _b15.call(_a15)) != null ? _c : /* @__PURE__ */ new Date();
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: "/images/generations",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        prompt,
+        n,
+        size,
+        ...(_d = providerOptions.openai) != null ? _d : {},
+        response_format: "b64_json"
+      },
+      failedResponseHandler: createJsonErrorResponseHandler(
+        (_e = this.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure
+      ),
       successfulResponseHandler: createJsonResponseHandler(
-        openAIEmbeddingResponseSchema
+        openaiCompatibleImageResponseSchema
       ),
-      fetch: this.config.fetch,
-      abortSignal: options.abortSignal
+      abortSignal,
+      fetch: this.config.fetch
     });
     return {
-      embeddings: response.data.map((item) => item.embedding),
-      usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0
+      images: response.data.map((item) => item.b64_json),
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders
+      }
     };
   }
 };
-
-// src/apertis-provider.ts
-function initializeProvider(options = {}) {
-  const baseURL = withoutTrailingSlash(options.baseURL) ?? "https://api.apertis.ai/v1";
-  const getHeaders = () => ({
-    ...options.headers,
-    Authorization: `Bearer ${loadApiKey({
-      apiKey: options.apiKey,
-      environmentVariableName: "APERTIS_API_KEY",
-      description: "Apertis API key"
-    })}`,
-    "Content-Type": "application/json"
-  });
-  return { baseURL, getHeaders, fetch: options.fetch };
-}
-function createApertis(options = {}) {
-  const { baseURL, getHeaders, fetch: fetchImpl } = initializeProvider(options);
-  const createChatModel = (modelId, settings = {}) => new ApertisChatLanguageModelV2(modelId, settings, {
-    provider: "apertis.chat",
-    baseURL,
+var openaiCompatibleImageResponseSchema = import_v48.z.object({
+  data: import_v48.z.array(import_v48.z.object({ b64_json: import_v48.z.string() }))
+});
+var VERSION2 = true ? "1.0.30" : "0.0.0-test";
+function createOpenAICompatible(options) {
+  const baseURL = withoutTrailingSlash(options.baseURL);
+  const providerName = options.name;
+  const headers = {
+    ...options.apiKey && { Authorization: `Bearer ${options.apiKey}` },
+    ...options.headers
+  };
+  const getHeaders = () => withUserAgentSuffix(headers, `ai-sdk/openai-compatible/${VERSION2}`);
+  const getCommonModelConfig = (modelType) => ({
+    provider: `${providerName}.${modelType}`,
+    url: ({ path }) => {
+      const url = new URL(`${baseURL}${path}`);
+      if (options.queryParams) {
+        url.search = new URLSearchParams(options.queryParams).toString();
+      }
+      return url.toString();
+    },
     headers: getHeaders,
-    fetch: fetchImpl
+    fetch: options.fetch
   });
-  const createEmbeddingModel = (modelId, settings = {}) => new ApertisEmbeddingModelV2(modelId, settings, {
-    provider: "apertis.embedding",
-    baseURL,
-    headers: getHeaders,
-    fetch: fetchImpl
+  const createLanguageModel = (modelId) => createChatModel(modelId);
+  const createChatModel = (modelId) => new OpenAICompatibleChatLanguageModel(modelId, {
+    ...getCommonModelConfig("chat"),
+    includeUsage: options.includeUsage,
+    supportsStructuredOutputs: options.supportsStructuredOutputs
   });
-  const provider = Object.assign(
-    (modelId, settings) => createChatModel(modelId, settings),
-    {
-      specificationVersion: "v2",
-      chat: createChatModel,
-      languageModel: (modelId) => createChatModel(modelId),
-      textEmbeddingModel: createEmbeddingModel,
-      imageModel: () => {
-        throw new Error("Image models are not supported by Apertis");
-      }
-    }
-  );
-  return provider;
-}
-function createApertisV3(options = {}) {
-  const { baseURL, getHeaders, fetch: fetchImpl } = initializeProvider(options);
-  const createChatModel = (modelId, settings = {}) => new ApertisChatLanguageModel(modelId, settings, {
-    provider: "apertis.chat",
-    baseURL,
-    headers: getHeaders,
-    fetch: fetchImpl
+  const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(modelId, {
+    ...getCommonModelConfig("completion"),
+    includeUsage: options.includeUsage
   });
-  const createEmbeddingModel = (modelId, settings = {}) => new ApertisEmbeddingModel(modelId, settings, {
-    provider: "apertis.embedding",
-    baseURL,
-    headers: getHeaders,
-    fetch: fetchImpl
+  const createEmbeddingModel = (modelId) => new OpenAICompatibleEmbeddingModel(modelId, {
+    ...getCommonModelConfig("embedding")
   });
-  const provider = Object.assign(
-    (modelId, settings) => createChatModel(modelId, settings),
-    {
-      specificationVersion: "v3",
-      chat: createChatModel,
-      languageModel: (modelId) => createChatModel(modelId),
-      embeddingModel: (modelId) => createEmbeddingModel(modelId),
-      textEmbeddingModel: createEmbeddingModel,
-      imageModel: () => {
-        throw new Error("Image models are not supported by Apertis");
-      }
-    }
-  );
+  const createImageModel = (modelId) => new OpenAICompatibleImageModel(modelId, getCommonModelConfig("image"));
+  const provider = (modelId) => createLanguageModel(modelId);
+  provider.languageModel = createLanguageModel;
+  provider.chatModel = createChatModel;
+  provider.completionModel = createCompletionModel;
+  provider.textEmbeddingModel = createEmbeddingModel;
+  provider.imageModel = createImageModel;
   return provider;
 }
+
+// src/apertis-provider.ts
+function createApertis(options = {}) {
+  return createOpenAICompatible({
+    name: "apertis",
+    baseURL: options.baseURL ?? "https://api.apertis.ai/v1",
+    apiKey: options.apiKey ?? process.env.APERTIS_API_KEY,
+    headers: options.headers,
+    fetch: options.fetch
+  });
+}
 var apertis = createApertis();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   apertis,
-  createApertis,
-  createApertisV3
+  createApertis
 });
 //# sourceMappingURL=index.cjs.map