@apertis/ai-sdk-provider 2.0.1 → 3.0.0

package/dist/index.js

@@ -1,4 +1,4 @@
-// node_modules/.pnpm/@ai-sdk+provider@3.0.4/node_modules/@ai-sdk/provider/dist/index.mjs
+// node_modules/.pnpm/@ai-sdk+provider@3.0.8/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
 var symbol = Symbol.for(marker);
 var _a;
@@ -268,34 +268,61 @@ var symbol13 = Symbol.for(marker13);
 var _a13;
 var _b13;
 var TypeValidationError = class _TypeValidationError extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
-  constructor({ value, cause }) {
+  constructor({
+    value,
+    cause,
+    context
+  }) {
+    let contextPrefix = "Type validation failed";
+    if (context == null ? void 0 : context.field) {
+      contextPrefix += ` for ${context.field}`;
+    }
+    if ((context == null ? void 0 : context.entityName) || (context == null ? void 0 : context.entityId)) {
+      contextPrefix += " (";
+      const parts = [];
+      if (context.entityName) {
+        parts.push(context.entityName);
+      }
+      if (context.entityId) {
+        parts.push(`id: "${context.entityId}"`);
+      }
+      contextPrefix += parts.join(", ");
+      contextPrefix += ")";
+    }
     super({
       name: name12,
-      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+      message: `${contextPrefix}: Value: ${JSON.stringify(value)}.
 Error message: ${getErrorMessage(cause)}`,
       cause
     });
     this[_a13] = true;
     this.value = value;
+    this.context = context;
   }
   static isInstance(error) {
     return AISDKError.hasMarker(error, marker13);
   }
   /**
    * Wraps an error into a TypeValidationError.
-   * If the cause is already a TypeValidationError with the same value, it returns the cause.
+   * If the cause is already a TypeValidationError with the same value and context, it returns the cause.
    * Otherwise, it creates a new TypeValidationError.
    *
    * @param {Object} params - The parameters for wrapping the error.
    * @param {unknown} params.value - The value that failed validation.
    * @param {unknown} params.cause - The original error or cause of the validation failure.
+   * @param {TypeValidationContext} params.context - Optional context about what is being validated.
    * @returns {TypeValidationError} A TypeValidationError instance.
    */
   static wrap({
     value,
-    cause
+    cause,
+    context
   }) {
-    return _TypeValidationError.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError({ value, cause });
+    var _a152, _b152, _c;
+    if (_TypeValidationError.isInstance(cause) && cause.value === value && ((_a152 = cause.context) == null ? void 0 : _a152.field) === (context == null ? void 0 : context.field) && ((_b152 = cause.context) == null ? void 0 : _b152.entityName) === (context == null ? void 0 : context.entityName) && ((_c = cause.context) == null ? void 0 : _c.entityId) === (context == null ? void 0 : context.entityId)) {
+      return cause;
+    }
+    return new _TypeValidationError({ value, cause, context });
   }
 };
 var name13 = "AI_UnsupportedFunctionalityError";
@@ -317,7 +344,7 @@ 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
+// node_modules/.pnpm/@ai-sdk+provider-utils@4.0.23_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
 import * as z4 from "zod/v4";
 import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
 import { ZodFirstPartyTypeKind } from "zod/v3";
@@ -452,11 +479,57 @@ 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@4.0.23_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+function combineHeaders(...headers) {
+  return headers.reduce(
+    (combinedHeaders, currentHeaders) => ({
+      ...combinedHeaders,
+      ...currentHeaders != null ? currentHeaders : {}
+    }),
+    {}
+  );
+}
 function extractResponseHeaders(response) {
   return Object.fromEntries([...response.headers]);
 }
 var { btoa, atob } = globalThis;
+function convertBase64ToUint8Array(base64String) {
+  const base64Url = base64String.replace(/-/g, "+").replace(/_/g, "/");
+  const latin1string = atob(base64Url);
+  return Uint8Array.from(latin1string, (byte) => byte.codePointAt(0));
+}
+function convertUint8ArrayToBase64(array) {
+  let latin1string = "";
+  for (let i = 0; i < array.length; i++) {
+    latin1string += String.fromCodePoint(array[i]);
+  }
+  return btoa(latin1string);
+}
+function convertToBase64(value) {
+  return value instanceof Uint8Array ? convertUint8ArrayToBase64(value) : value;
+}
+function convertToFormData(input, options = {}) {
+  const { useArrayBrackets = true } = options;
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(input)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 1) {
+        formData.append(key, value[0]);
+        continue;
+      }
+      const arrayKey = useArrayBrackets ? `${key}[]` : key;
+      for (const item of value) {
+        formData.append(arrayKey, item);
+      }
+      continue;
+    }
+    formData.append(key, value);
+  }
+  return formData;
+}
 var name14 = "AI_DownloadError";
 var marker15 = `vercel.ai.error.${name14}`;
 var symbol15 = Symbol.for(marker15);
@@ -480,6 +553,187 @@ var DownloadError = class extends (_b15 = AISDKError, _a15 = symbol15, _b15) {
     return AISDKError.hasMarker(error, marker15);
   }
 };
+var DEFAULT_MAX_DOWNLOAD_SIZE = 2 * 1024 * 1024 * 1024;
+async function readResponseWithSizeLimit({
+  response,
+  url,
+  maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE
+}) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength != null) {
+    const length = parseInt(contentLength, 10);
+    if (!isNaN(length) && length > maxBytes) {
+      throw new DownloadError({
+        url,
+        message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes (Content-Length: ${length}).`
+      });
+    }
+  }
+  const body = response.body;
+  if (body == null) {
+    return new Uint8Array(0);
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      totalBytes += value.length;
+      if (totalBytes > maxBytes) {
+        throw new DownloadError({
+          url,
+          message: `Download of ${url} exceeded maximum size of ${maxBytes} bytes.`
+        });
+      }
+      chunks.push(value);
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  const result = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+function validateDownloadUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (e) {
+    throw new DownloadError({
+      url,
+      message: `Invalid URL: ${url}`
+    });
+  }
+  if (parsed.protocol === "data:") {
+    return;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new DownloadError({
+      url,
+      message: `URL scheme must be http, https, or data, got ${parsed.protocol}`
+    });
+  }
+  const hostname = parsed.hostname;
+  if (!hostname) {
+    throw new DownloadError({
+      url,
+      message: `URL must have a hostname`
+    });
+  }
+  if (hostname === "localhost" || hostname.endsWith(".local") || hostname.endsWith(".localhost")) {
+    throw new DownloadError({
+      url,
+      message: `URL with hostname ${hostname} is not allowed`
+    });
+  }
+  if (hostname.startsWith("[") && hostname.endsWith("]")) {
+    const ipv6 = hostname.slice(1, -1);
+    if (isPrivateIPv6(ipv6)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IPv6 address ${hostname} is not allowed`
+      });
+    }
+    return;
+  }
+  if (isIPv4(hostname)) {
+    if (isPrivateIPv4(hostname)) {
+      throw new DownloadError({
+        url,
+        message: `URL with IP address ${hostname} is not allowed`
+      });
+    }
+    return;
+  }
+}
+function isIPv4(hostname) {
+  const parts = hostname.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((part) => {
+    const num = Number(part);
+    return Number.isInteger(num) && num >= 0 && num <= 255 && String(num) === part;
+  });
+}
+function isPrivateIPv4(ip) {
+  const parts = ip.split(".").map(Number);
+  const [a, b] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  return false;
+}
+function isPrivateIPv6(ip) {
+  const normalized = ip.toLowerCase();
+  if (normalized === "::1") return true;
+  if (normalized === "::") return true;
+  if (normalized.startsWith("::ffff:")) {
+    const mappedPart = normalized.slice(7);
+    if (isIPv4(mappedPart)) {
+      return isPrivateIPv4(mappedPart);
+    }
+    const hexParts = mappedPart.split(":");
+    if (hexParts.length === 2) {
+      const high = parseInt(hexParts[0], 16);
+      const low = parseInt(hexParts[1], 16);
+      if (!isNaN(high) && !isNaN(low)) {
+        const a = high >> 8 & 255;
+        const b = high & 255;
+        const c = low >> 8 & 255;
+        const d = low & 255;
+        return isPrivateIPv4(`${a}.${b}.${c}.${d}`);
+      }
+    }
+  }
+  if (normalized.startsWith("fc") || normalized.startsWith("fd")) return true;
+  if (normalized.startsWith("fe80")) return true;
+  return false;
+}
+async function downloadBlob(url, options) {
+  var _a22, _b22;
+  validateDownloadUrl(url);
+  try {
+    const response = await fetch(url, {
+      signal: options == null ? void 0 : options.abortSignal
+    });
+    if (response.redirected) {
+      validateDownloadUrl(response.url);
+    }
+    if (!response.ok) {
+      throw new DownloadError({
+        url,
+        statusCode: response.status,
+        statusText: response.statusText
+      });
+    }
+    const data = await readResponseWithSizeLimit({
+      response,
+      url,
+      maxBytes: (_a22 = options == null ? void 0 : options.maxBytes) != null ? _a22 : DEFAULT_MAX_DOWNLOAD_SIZE
+    });
+    const contentType = (_b22 = response.headers.get("content-type")) != null ? _b22 : void 0;
+    return new Blob([data], contentType ? { type: contentType } : void 0);
+  } catch (error) {
+    if (DownloadError.isInstance(error)) {
+      throw error;
+    }
+    throw new DownloadError({ url, cause: error });
+  }
+}
 var createIdGenerator = ({
   prefix,
   size = 16,
@@ -511,6 +765,25 @@ function isAbortError(error) {
   error.name === "TimeoutError");
 }
 var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+var BUN_ERROR_CODES = [
+  "ConnectionRefused",
+  "ConnectionClosed",
+  "FailedToOpenSocket",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EPIPE"
+];
+function isBunNetworkError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  if (typeof code === "string" && BUN_ERROR_CODES.includes(code)) {
+    return true;
+  }
+  return false;
+}
 function handleFetchError({
   error,
   url,
@@ -532,6 +805,15 @@ function handleFetchError({
       });
     }
   }
+  if (isBunNetworkError(error)) {
+    return new APICallError({
+      message: `Cannot connect to API: ${error.message}`,
+      cause: error,
+      url,
+      requestBodyValues,
+      isRetryable: true
+    });
+  }
   return error;
 }
 function getRuntimeEnvironmentUserAgent(globalThisAny = globalThis) {
@@ -580,41 +862,9 @@ 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 suspectProtoRx = /"__proto__"\s*:/;
-var suspectConstructorRx = /"constructor"\s*:/;
+var VERSION = true ? "4.0.23" : "0.0.0-test";
+var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
 function _parse(text) {
   const obj = JSON.parse(text);
   if (obj === null || typeof obj !== "object") {
@@ -634,7 +884,7 @@ function filter(obj) {
       if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
         throw new SyntaxError("Object contains forbidden prototype property");
       }
-      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
         throw new SyntaxError("Object contains forbidden prototype property");
       }
       for (const key in node) {
@@ -1885,17 +2135,19 @@ function zodSchema(zodSchema2, options) {
 }
 async function validateTypes({
   value,
-  schema
+  schema,
+  context
 }) {
-  const result = await safeValidateTypes({ value, schema });
+  const result = await safeValidateTypes({ value, schema, context });
   if (!result.success) {
-    throw TypeValidationError.wrap({ value, cause: result.error });
+    throw TypeValidationError.wrap({ value, cause: result.error, context });
   }
   return result.value;
 }
 async function safeValidateTypes({
   value,
-  schema
+  schema,
+  context
 }) {
   const actualSchema = asSchema(schema);
   try {
@@ -1908,13 +2160,13 @@ async function safeValidateTypes({
     }
     return {
       success: false,
-      error: TypeValidationError.wrap({ value, cause: result.error }),
+      error: TypeValidationError.wrap({ value, cause: result.error, context }),
       rawValue: value
     };
   } catch (error) {
     return {
       success: false,
-      error: TypeValidationError.wrap({ value, cause: error }),
+      error: TypeValidationError.wrap({ value, cause: error, context }),
       rawValue: value
     };
   }
@@ -1954,6 +2206,14 @@ async function safeParseJSON({
     };
   }
 }
+function isParsableJson(input) {
+  try {
+    secureJsonParse(input);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
 function parseJsonEventStream({
   stream,
   schema
@@ -1969,6 +2229,27 @@ function parseJsonEventStream({
     })
   );
 }
+async function parseProviderOptions({
+  provider,
+  providerOptions,
+  schema
+}) {
+  if ((providerOptions == null ? void 0 : providerOptions[provider]) == null) {
+    return void 0;
+  }
+  const parsedProviderOptions = await safeValidateTypes({
+    value: providerOptions[provider],
+    schema
+  });
+  if (!parsedProviderOptions.success) {
+    throw new InvalidArgumentError({
+      argument: "providerOptions",
+      message: `invalid ${provider} provider options`,
+      cause: parsedProviderOptions.error
+    });
+  }
+  return parsedProviderOptions.value;
+}
 var getOriginalFetch2 = () => globalThis.fetch;
 var postJsonToApi = async ({
   url,
@@ -1993,6 +2274,26 @@ var postJsonToApi = async ({
   abortSignal,
   fetch: fetch2
 });
+var postFormDataToApi = async ({
+  url,
+  headers,
+  formData,
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch: fetch2
+}) => postToApi({
+  url,
+  headers,
+  body: {
+    content: formData,
+    values: Object.fromEntries(formData.entries())
+  },
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch: fetch2
+});
 var postToApi = async ({
   url,
   headers = {},
@@ -2157,853 +2458,1676 @@ function withoutTrailingSlash(url) {
   return url == null ? void 0 : url.replace(/\/$/, "");
 }
 
-// src/apertis-error.ts
-import { z } from "zod";
-var apertisErrorSchema = z.object({
+// node_modules/.pnpm/@ai-sdk+openai-compatible@2.0.41_zod@3.25.76/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
+import { z as z3 } from "zod/v4";
+import { z } from "zod/v4";
+import { z as z2 } from "zod/v4";
+import { z as z5 } from "zod/v4";
+import { z as z42 } from "zod/v4";
+import { z as z7 } from "zod/v4";
+import { z as z6 } from "zod/v4";
+import { z as z8 } from "zod/v4";
+function toCamelCase(str) {
+  return str.replace(/[_-]([a-z])/g, (g) => g[1].toUpperCase());
+}
+function resolveProviderOptionsKey(rawName, providerOptions) {
+  const camelName = toCamelCase(rawName);
+  if (camelName !== rawName && (providerOptions == null ? void 0 : providerOptions[camelName]) != null) {
+    return camelName;
+  }
+  return rawName;
+}
+var openaiCompatibleErrorDataSchema = z.object({
   error: z.object({
     message: z.string(),
-    type: z.string().optional(),
-    code: z.string().nullable().optional(),
-    param: z.string().nullable().optional()
+    // The additional information below is handled loosely to support
+    // OpenAI-compatible providers that have slightly different error
+    // responses:
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
   })
 });
-var apertisFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: apertisErrorSchema,
-  errorToMessage: (error) => error.error.message
-});
-
-// src/schemas/chat-response.ts
-import { z as z2 } from "zod";
-var openAIChatResponseSchema = z2.object({
-  id: z2.string().optional(),
-  object: z2.literal("chat.completion").optional(),
-  created: z2.number().optional(),
-  model: z2.string().optional(),
-  choices: z2.array(
-    z2.object({
-      index: z2.number(),
-      message: z2.object({
-        role: z2.literal("assistant"),
-        content: z2.string().nullable(),
-        tool_calls: z2.array(
-          z2.object({
-            id: z2.string(),
-            type: z2.literal("function"),
-            function: z2.object({
-              name: z2.string(),
-              arguments: z2.string()
-            })
-          })
-        ).optional()
-      }),
-      finish_reason: z2.string().nullable(),
-      logprobs: z2.any().nullable().optional()
-    })
-  ),
-  usage: z2.object({
-    prompt_tokens: z2.number(),
-    completion_tokens: z2.number(),
-    total_tokens: z2.number().optional()
-  }).optional()
-});
-var openAIChatChunkSchema = z2.object({
-  id: z2.string().optional(),
-  object: z2.literal("chat.completion.chunk").optional(),
-  created: z2.number().optional(),
-  model: z2.string().optional(),
-  choices: z2.array(
-    z2.object({
-      index: z2.number(),
-      delta: z2.object({
-        role: z2.literal("assistant").optional(),
-        content: z2.string().nullable().optional(),
-        tool_calls: z2.array(
-          z2.object({
-            index: z2.number(),
-            id: z2.string().optional(),
-            type: z2.literal("function").optional(),
-            function: z2.object({
-              name: z2.string().optional(),
-              arguments: z2.string().optional()
-            }).optional()
-          })
-        ).optional()
-      }),
-      finish_reason: z2.string().nullable().optional()
-    })
-  ),
-  usage: z2.object({
-    prompt_tokens: z2.number(),
-    completion_tokens: z2.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 defaultOpenAICompatibleErrorStructure = {
+  errorSchema: openaiCompatibleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+};
+function convertOpenAICompatibleChatUsage(usage) {
+  var _a16, _b16, _c, _d, _e, _f;
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      },
+      raw: void 0
+    };
   }
-}
-function mapApertisFinishReason(finishReason) {
+  const promptTokens = (_a16 = usage.prompt_tokens) != null ? _a16 : 0;
+  const completionTokens = (_b16 = usage.completion_tokens) != null ? _b16 : 0;
+  const cacheReadTokens = (_d = (_c = usage.prompt_tokens_details) == null ? void 0 : _c.cached_tokens) != null ? _d : 0;
+  const reasoningTokens = (_f = (_e = usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0;
   return {
-    unified: normalizeFinishReason(finishReason),
-    raw: finishReason ?? void 0
+    inputTokens: {
+      total: promptTokens,
+      noCache: promptTokens - cacheReadTokens,
+      cacheRead: cacheReadTokens,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: completionTokens,
+      text: completionTokens - reasoningTokens,
+      reasoning: reasoningTokens
+    },
+    raw: usage
   };
 }
-function mapApertisFinishReasonV2(finishReason) {
-  return normalizeFinishReason(finishReason);
+function getOpenAIMetadata(message) {
+  var _a16, _b16;
+  return (_b16 = (_a16 = message == null ? void 0 : message.providerOptions) == null ? void 0 : _a16.openaiCompatible) != null ? _b16 : {};
 }
-
-// src/utils/convert-to-openai-messages.ts
-function convertToOpenAIMessages(prompt) {
+function getAudioFormat(mediaType) {
+  switch (mediaType) {
+    case "audio/wav":
+      return "wav";
+    case "audio/mp3":
+    case "audio/mpeg":
+      return "mp3";
+    default:
+      return null;
+  }
+}
+function convertToOpenAICompatibleChatMessages(prompt) {
+  var _a16, _b16, _c;
   const messages = [];
-  for (const 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) => {
+            var _a22;
+            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.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    },
+                    ...partMetadata
+                  };
+                }
+                if (part.mediaType.startsWith("audio/")) {
                   if (part.data instanceof URL) {
-                    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")}`;
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "audio file parts with URLs"
+                    });
+                  }
+                  const format = getAudioFormat(part.mediaType);
+                  if (format === null) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: `audio media type ${part.mediaType}`
+                    });
                   }
                   return {
-                    type: "image_url",
-                    image_url: { url }
+                    type: "input_audio",
+                    input_audio: {
+                      data: convertToBase64(part.data),
+                      format
+                    },
+                    ...partMetadata
+                  };
+                }
+                if (part.mediaType === "application/pdf") {
+                  if (part.data instanceof URL) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "PDF file parts with URLs"
+                    });
+                  }
+                  return {
+                    type: "file",
+                    file: {
+                      filename: (_a22 = part.filename) != null ? _a22 : "document.pdf",
+                      file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
+                    },
+                    ...partMetadata
+                  };
+                }
+                if (part.mediaType.startsWith("text/")) {
+                  const textContent = part.data instanceof URL ? part.data.toString() : typeof part.data === "string" ? new TextDecoder().decode(
+                    convertBase64ToUint8Array(part.data)
+                  ) : new TextDecoder().decode(part.data);
+                  return {
+                    type: "text",
+                    text: textContent,
+                    ...partMetadata
                   };
                 }
-                throw new Error(
-                  `Unsupported file type: ${part.mediaType}. Only image/* is supported.`
-                );
+                throw new UnsupportedFunctionalityError({
+                  functionality: `file part media type ${part.mediaType}`
+                });
               }
-              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 = "";
+        let reasoning = "";
+        const toolCalls = [];
+        for (const part of content) {
+          const partMetadata = getOpenAIMetadata(part);
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "reasoning": {
+              reasoning += part.text;
+              break;
+            }
+            case "tool-call": {
+              const thoughtSignature = (_b16 = (_a16 = part.providerOptions) == null ? void 0 : _a16.google) == null ? void 0 : _b16.thoughtSignature;
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                },
+                ...partMetadata,
+                // Include extra_content for Google Gemini thought signatures
+                ...thoughtSignature ? {
+                  extra_content: {
+                    google: {
+                      thought_signature: String(thoughtSignature)
+                    }
+                  }
+                } : {}
+              });
+              break;
+            }
           }
-          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,
+          ...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+          ...metadata
         });
         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 "tool": {
+        for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "execution-denied":
+              contentValue = (_c = output.reason) != null ? _c : "Tool execution denied.";
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
           }
+          const toolResponseMetadata = getOpenAIMetadata(toolResponse);
           messages.push({
             role: "tool",
-            tool_call_id: result.toolCallId,
-            content
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+            ...toolResponseMetadata
           });
         }
         break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
     }
   }
   return messages;
 }
-
-// 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 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 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 void 0;
+      return "other";
   }
 }
-
-// src/apertis-chat-language-model.ts
-var ApertisChatLanguageModel = class {
-  constructor(modelId, settings, config) {
-    this.modelId = modelId;
-    this.settings = settings;
-    this.config = config;
-  }
-  specificationVersion = "v3";
+var openaiCompatibleLanguageModelChatOptions = z2.object({
   /**
-   * Supported URL patterns for different media types.
-   * Supports HTTP(S) image URLs for direct URL passing.
+   * A unique identifier representing your end-user, which can help the provider to
+   * monitor and detect abuse.
    */
-  supportedUrls = {
-    "image/*": [/^https?:\/\/.+$/]
-  };
-  get provider() {
-    return this.config.provider;
+  user: z2.string().optional(),
+  /**
+   * Reasoning effort for reasoning models. Defaults to `medium`.
+   */
+  reasoningEffort: z2.string().optional(),
+  /**
+   * Controls the verbosity of the generated text. Defaults to `medium`.
+   */
+  textVerbosity: z2.string().optional(),
+  /**
+   * Whether to use strict JSON schema validation.
+   * When true, the model uses constrained decoding to guarantee schema compliance.
+   * Only used when the provider supports structured outputs and a schema is provided.
+   *
+   * @default true
+   */
+  strictJsonSchema: z2.boolean().optional()
+});
+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") {
+      toolWarnings.push({
+        type: "unsupported",
+        feature: `provider-defined tool ${tool.id}`
+      });
+    } else {
+      openaiCompatTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema,
+          ...tool.strict != null ? { strict: tool.strict } : {}
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiCompatTools, toolChoice: void 0, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiCompatTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+var OpenAICompatibleChatLanguageModel = class {
+  // type inferred via constructor
+  constructor(modelId, config) {
+    this.specificationVersion = "v3";
+    var _a16, _b16;
+    this.modelId = modelId;
+    this.config = config;
+    const errorStructure = (_a16 = config.errorStructure) != null ? _a16 : defaultOpenAICompatibleErrorStructure;
+    this.chunkSchema = createOpenAICompatibleChatChunkSchema(
+      errorStructure.errorSchema
+    );
+    this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
+    this.supportsStructuredOutputs = (_b16 = config.supportsStructuredOutputs) != null ? _b16 : false;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  get supportedUrls() {
+    var _a16, _b16, _c;
+    return (_c = (_b16 = (_a16 = this.config).supportedUrls) == null ? void 0 : _b16.call(_a16)) != null ? _c : {};
+  }
+  transformRequestBody(args) {
+    var _a16, _b16, _c;
+    return (_c = (_b16 = (_a16 = this.config).transformRequestBody) == null ? void 0 : _b16.call(_a16, args)) != null ? _c : args;
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    providerOptions,
+    stopSequences,
+    responseFormat,
+    seed,
+    toolChoice,
+    tools
+  }) {
+    var _a16, _b16, _c, _d, _e;
+    const warnings = [];
+    const deprecatedOptions = await parseProviderOptions({
+      provider: "openai-compatible",
+      providerOptions,
+      schema: openaiCompatibleLanguageModelChatOptions
+    });
+    if (deprecatedOptions != null) {
+      warnings.push({
+        type: "other",
+        message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
+      });
+    }
+    const compatibleOptions = Object.assign(
+      deprecatedOptions != null ? deprecatedOptions : {},
+      (_a16 = await parseProviderOptions({
+        provider: "openaiCompatible",
+        providerOptions,
+        schema: openaiCompatibleLanguageModelChatOptions
+      })) != null ? _a16 : {},
+      (_b16 = await parseProviderOptions({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleLanguageModelChatOptions
+      })) != null ? _b16 : {},
+      (_c = await parseProviderOptions({
+        provider: toCamelCase(this.providerOptionsName),
+        providerOptions,
+        schema: openaiCompatibleLanguageModelChatOptions
+      })) != null ? _c : {}
+    );
+    const strictJsonSchema = (_d = compatibleOptions == null ? void 0 : compatibleOptions.strictJsonSchema) != null ? _d : true;
+    if (topK != null) {
+      warnings.push({ type: "unsupported", feature: "topK" });
+    }
+    if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !this.supportsStructuredOutputs) {
+      warnings.push({
+        type: "unsupported",
+        feature: "responseFormat",
+        details: "JSON response format schema is only supported with structuredOutputs"
+      });
+    }
+    const {
+      tools: openaiTools,
+      toolChoice: openaiToolChoice,
+      toolWarnings
+    } = prepareTools({
+      tools,
+      toolChoice
+    });
+    const metadataKey = resolveProviderOptionsKey(
+      this.providerOptionsName,
+      providerOptions
+    );
+    return {
+      metadataKey,
+      args: {
+        // model id:
+        model: this.modelId,
+        // model specific settings:
+        user: compatibleOptions.user,
+        // standardized settings:
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? this.supportsStructuredOutputs === true && responseFormat.schema != null ? {
+          type: "json_schema",
+          json_schema: {
+            schema: responseFormat.schema,
+            strict: strictJsonSchema,
+            name: (_e = responseFormat.name) != null ? _e : "response",
+            description: responseFormat.description
+          }
+        } : { type: "json_object" } : void 0,
+        stop: stopSequences,
+        seed,
+        ...Object.fromEntries(
+          Object.entries({
+            ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
+            ...providerOptions == null ? void 0 : providerOptions[toCamelCase(this.providerOptionsName)]
+          }).filter(
+            ([key]) => !Object.keys(
+              openaiCompatibleLanguageModelChatOptions.shape
+            ).includes(key)
+          )
+        ),
+        reasoning_effort: compatibleOptions.reasoningEffort,
+        verbosity: compatibleOptions.textVerbosity,
+        // messages:
+        messages: convertToOpenAICompatibleChatMessages(prompt),
+        // tools:
+        tools: openaiTools,
+        tool_choice: openaiToolChoice
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
   }
   async doGenerate(options) {
-    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 _a16, _b16, _c, _d, _e, _f, _g, _h;
+    const { args, warnings, metadataKey } = await this.getArgs({ ...options });
+    const transformedBody = this.transformRequestBody(args);
+    const body = JSON.stringify(transformedBody);
+    const {
+      responseHeaders,
+      value: responseBody,
+      rawValue: rawResponse
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: "/chat/completions",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: transformedBody,
+      failedResponseHandler: this.failedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
-        openAIChatResponseSchema
+        OpenAICompatibleChatResponseSchema
       ),
-      fetch: this.config.fetch,
-      abortSignal: options.abortSignal
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
     });
-    const choice = response.choices[0];
+    const choice = responseBody.choices[0];
     const content = [];
-    if (choice.message.content) {
+    const text = choice.message.content;
+    if (text != null && text.length > 0) {
+      content.push({ type: "text", text });
+    }
+    const reasoning = (_a16 = choice.message.reasoning_content) != null ? _a16 : choice.message.reasoning;
+    if (reasoning != null && reasoning.length > 0) {
       content.push({
-        type: "text",
-        text: choice.message.content
+        type: "reasoning",
+        text: reasoning
       });
     }
-    if (choice.message.tool_calls) {
-      for (const tc of choice.message.tool_calls) {
+    if (choice.message.tool_calls != null) {
+      for (const toolCall of choice.message.tool_calls) {
+        const thoughtSignature = (_c = (_b16 = toolCall.extra_content) == null ? void 0 : _b16.google) == null ? void 0 : _c.thought_signature;
         content.push({
           type: "tool-call",
-          toolCallId: tc.id,
-          toolName: tc.function.name,
-          input: tc.function.arguments
+          toolCallId: (_d = toolCall.id) != null ? _d : generateId(),
+          toolName: toolCall.function.name,
+          input: toolCall.function.arguments,
+          ...thoughtSignature ? {
+            providerMetadata: {
+              [metadataKey]: { thoughtSignature }
+            }
+          } : {}
         });
       }
     }
+    const providerMetadata = {
+      [metadataKey]: {},
+      ...await ((_f = (_e = this.config.metadataExtractor) == null ? void 0 : _e.extractMetadata) == null ? void 0 : _f.call(_e, {
+        parsedBody: rawResponse
+      }))
+    };
+    const completionTokenDetails = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens_details;
+    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
+      providerMetadata[metadataKey].acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
+    }
+    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
+      providerMetadata[metadataKey].rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
+    }
     return {
       content,
-      finishReason: 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
-        }
+      finishReason: {
+        unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+        raw: (_h = choice.finish_reason) != null ? _h : void 0
+      },
+      usage: convertOpenAICompatibleChatUsage(responseBody.usage),
+      providerMetadata,
+      request: { body },
+      response: {
+        ...getResponseMetadata(responseBody),
+        headers: responseHeaders,
+        body: rawResponse
       },
-      warnings: [],
-      request: { body }
+      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(),
+    var _a16;
+    const { args, warnings, metadataKey } = await this.getArgs({ ...options });
+    const body = this.transformRequestBody({
+      ...args,
+      stream: true,
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.includeUsage ? { include_usage: true } : void 0
+    });
+    const metadataExtractor = (_a16 = this.config.metadataExtractor) == null ? void 0 : _a16.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: 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);
+    const toolCalls = [];
+    let finishReason = {
+      unified: "other",
+      raw: void 0
+    };
+    let usage = void 0;
+    let isFirstChunk = true;
+    const providerOptionsName = metadataKey;
+    let isActiveReasoning = false;
+    let isActiveText = false;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            var _a22, _b16, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+            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
-            });
-            textId = null;
-          }
-          for (const [, buffer] of toolCallBuffers) {
-            if (buffer.name) {
+            if (!chunk.success) {
+              finishReason = { unified: "error", raw: void 0 };
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            metadataExtractor == null ? void 0 : metadataExtractor.processChunk(chunk.rawValue);
+            if ("error" in chunk.value) {
+              finishReason = { unified: "error", raw: void 0 };
               controller.enqueue({
-                type: "tool-call",
-                toolCallId: buffer.id,
-                toolName: buffer.name,
-                input: buffer.arguments
+                type: "error",
+                error: chunk.value.error.message
               });
+              return;
             }
-          }
-          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
+            const value = chunk.value;
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata(value)
+              });
+            }
+            if (value.usage != null) {
+              usage = value.usage;
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = {
+                unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+                raw: (_a22 = choice.finish_reason) != null ? _a22 : void 0
+              };
+            }
+            if ((choice == null ? void 0 : choice.delta) == null) {
+              return;
+            }
+            const delta = choice.delta;
+            const reasoningContent = (_b16 = delta.reasoning_content) != null ? _b16 : 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 (isActiveReasoning) {
+                controller.enqueue({
+                  type: "reasoning-end",
+                  id: "reasoning-0"
+                });
+                isActiveReasoning = false;
+              }
+              if (!isActiveText) {
+                controller.enqueue({ type: "text-start", id: "txt-0" });
+                isActiveText = true;
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: "txt-0",
+                delta: delta.content
+              });
+            }
+            if (delta.tool_calls != null) {
+              if (isActiveReasoning) {
+                controller.enqueue({
+                  type: "reasoning-end",
+                  id: "reasoning-0"
+                });
+                isActiveReasoning = false;
+              }
+              for (const toolCallDelta of delta.tool_calls) {
+                const index = (_c = toolCallDelta.index) != null ? _c : toolCalls.length;
+                if (toolCalls[index] == null) {
+                  if (toolCallDelta.id == null) {
+                    throw new InvalidResponseDataError({
+                      data: toolCallDelta,
+                      message: `Expected 'id' to be a string.`
+                    });
+                  }
+                  if (((_d = toolCallDelta.function) == null ? void 0 : _d.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: (_e = toolCallDelta.function.arguments) != null ? _e : ""
+                    },
+                    hasFinished: false,
+                    thoughtSignature: (_h = (_g = (_f = toolCallDelta.extra_content) == null ? void 0 : _f.google) == null ? void 0 : _g.thought_signature) != null ? _h : void 0
+                  };
+                  const toolCall2 = toolCalls[index];
+                  if (((_i = toolCall2.function) == null ? void 0 : _i.name) != null && ((_j = toolCall2.function) == null ? void 0 : _j.arguments) != null) {
+                    if (toolCall2.function.arguments.length > 0) {
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        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: (_k = toolCall2.id) != null ? _k : generateId(),
+                        toolName: toolCall2.function.name,
+                        input: toolCall2.function.arguments,
+                        ...toolCall2.thoughtSignature ? {
+                          providerMetadata: {
+                            [providerOptionsName]: {
+                              thoughtSignature: toolCall2.thoughtSignature
+                            }
+                          }
+                        } : {}
+                      });
+                      toolCall2.hasFinished = true;
+                    }
+                  }
+                  continue;
+                }
+                const toolCall = toolCalls[index];
+                if (toolCall.hasFinished) {
+                  continue;
+                }
+                if (((_l = toolCallDelta.function) == null ? void 0 : _l.arguments) != null) {
+                  toolCall.function.arguments += (_n = (_m = toolCallDelta.function) == null ? void 0 : _m.arguments) != null ? _n : "";
+                }
+                controller.enqueue({
+                  type: "tool-input-delta",
+                  id: toolCall.id,
+                  delta: (_o = toolCallDelta.function.arguments) != null ? _o : ""
+                });
+                if (((_p = toolCall.function) == null ? void 0 : _p.name) != null && ((_q = toolCall.function) == null ? void 0 : _q.arguments) != null && isParsableJson(toolCall.function.arguments)) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.id
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: (_r = toolCall.id) != null ? _r : generateId(),
+                    toolName: toolCall.function.name,
+                    input: toolCall.function.arguments,
+                    ...toolCall.thoughtSignature ? {
+                      providerMetadata: {
+                        [providerOptionsName]: {
+                          thoughtSignature: toolCall.thoughtSignature
+                        }
+                      }
+                    } : {}
+                  });
+                  toolCall.hasFinished = true;
+                }
+              }
+            }
+          },
+          flush(controller) {
+            var _a22, _b16, _c, _d, _e;
+            if (isActiveReasoning) {
+              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+            }
+            if (isActiveText) {
+              controller.enqueue({ type: "text-end", id: "txt-0" });
+            }
+            for (const toolCall of toolCalls.filter(
+              (toolCall2) => !toolCall2.hasFinished
+            )) {
+              controller.enqueue({
+                type: "tool-input-end",
+                id: toolCall.id
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: (_a22 = toolCall.id) != null ? _a22 : generateId(),
+                toolName: toolCall.function.name,
+                input: toolCall.function.arguments,
+                ...toolCall.thoughtSignature ? {
+                  providerMetadata: {
+                    [providerOptionsName]: {
+                      thoughtSignature: toolCall.thoughtSignature
+                    }
+                  }
+                } : {}
+              });
+            }
+            const providerMetadata = {
+              [providerOptionsName]: {},
+              ...metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata()
+            };
+            if (((_b16 = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _b16.accepted_prediction_tokens) != null) {
+              providerMetadata[providerOptionsName].acceptedPredictionTokens = (_c = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _c.accepted_prediction_tokens;
+            }
+            if (((_d = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _d.rejected_prediction_tokens) != null) {
+              providerMetadata[providerOptionsName].rejectedPredictionTokens = (_e = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _e.rejected_prediction_tokens;
             }
-          });
-        }
-      },
-      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: convertOpenAICompatibleChatUsage(usage),
+              providerMetadata
             });
           }
-        }
-      }
-    });
-    return {
-      stream: response.pipeThrough(transformStream),
-      request: { body }
+        })
+      ),
+      request: { body },
+      response: { headers: responseHeaders }
     };
   }
-  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
+};
+var openaiCompatibleTokenUsageSchema = z3.looseObject({
+  prompt_tokens: z3.number().nullish(),
+  completion_tokens: z3.number().nullish(),
+  total_tokens: z3.number().nullish(),
+  prompt_tokens_details: z3.object({
+    cached_tokens: z3.number().nullish()
+  }).nullish(),
+  completion_tokens_details: z3.object({
+    reasoning_tokens: z3.number().nullish(),
+    accepted_prediction_tokens: z3.number().nullish(),
+    rejected_prediction_tokens: z3.number().nullish()
+  }).nullish()
+}).nullish();
+var OpenAICompatibleChatResponseSchema = z3.looseObject({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      message: z3.object({
+        role: z3.literal("assistant").nullish(),
+        content: z3.string().nullish(),
+        reasoning_content: z3.string().nullish(),
+        reasoning: z3.string().nullish(),
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string().nullish(),
+            function: z3.object({
+              name: z3.string(),
+              arguments: z3.string()
+            }),
+            // Support for Google Gemini thought signatures via OpenAI compatibility
+            extra_content: z3.object({
+              google: z3.object({
+                thought_signature: z3.string().nullish()
+              }).nullish()
+            }).nullish()
+          })
+        ).nullish()
+      }),
+      finish_reason: z3.string().nullish()
+    })
+  ),
+  usage: openaiCompatibleTokenUsageSchema
+});
+var chunkBaseSchema = z3.looseObject({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      delta: z3.object({
+        role: z3.enum(["assistant"]).nullish(),
+        content: z3.string().nullish(),
+        // Most openai-compatible models set `reasoning_content`, but some
+        // providers serving `gpt-oss` set `reasoning`. See #7866
+        reasoning_content: z3.string().nullish(),
+        reasoning: z3.string().nullish(),
+        tool_calls: z3.array(
+          z3.object({
+            index: z3.number().nullish(),
+            //google does not send index
+            id: z3.string().nullish(),
+            function: z3.object({
+              name: z3.string().nullish(),
+              arguments: z3.string().nullish()
+            }),
+            // Support for Google Gemini thought signatures via OpenAI compatibility
+            extra_content: z3.object({
+              google: z3.object({
+                thought_signature: z3.string().nullish()
+              }).nullish()
+            }).nullish()
+          })
+        ).nullish()
+      }).nullish(),
+      finish_reason: z3.string().nullish()
+    })
+  ),
+  usage: openaiCompatibleTokenUsageSchema
+});
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => z3.union([chunkBaseSchema, errorSchema]);
+function convertOpenAICompatibleCompletionUsage(usage) {
+  var _a16, _b16;
+  if (usage == null) {
+    return {
+      inputTokens: {
+        total: void 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: void 0,
+        text: void 0,
+        reasoning: void 0
+      },
+      raw: void 0
     };
-    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"
-    );
   }
-};
+  const promptTokens = (_a16 = usage.prompt_tokens) != null ? _a16 : 0;
+  const completionTokens = (_b16 = usage.completion_tokens) != null ? _b16 : 0;
+  return {
+    inputTokens: {
+      total: promptTokens,
+      noCache: promptTokens,
+      cacheRead: void 0,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: completionTokens,
+      text: completionTokens,
+      reasoning: void 0
+    },
+    raw: usage
+  };
+}
+function convertToOpenAICompatibleCompletionPrompt({
+  prompt,
+  user = "user",
+  assistant = "assistant"
+}) {
+  let text = "";
+  if (prompt[0].role === "system") {
+    text += `${prompt[0].content}
+
+`;
+    prompt = prompt.slice(1);
+  }
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        throw new InvalidPromptError({
+          message: "Unexpected system message in prompt: ${content}",
+          prompt
+        });
+      }
+      case "user": {
+        const userMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+          }
+        }).filter(Boolean).join("");
+        text += `${user}:
+${userMessage}
+
+`;
+        break;
+      }
+      case "assistant": {
+        const assistantMessage = content.map((part) => {
+          switch (part.type) {
+            case "text": {
+              return part.text;
+            }
+            case "tool-call": {
+              throw new UnsupportedFunctionalityError({
+                functionality: "tool-call messages"
+              });
+            }
+          }
+        }).join("");
+        text += `${assistant}:
+${assistantMessage}
 
-// src/apertis-chat-language-model-v2.ts
-var ApertisChatLanguageModelV2 = class {
-  constructor(modelId, settings, config) {
+`;
+        break;
+      }
+      case "tool": {
+        throw new UnsupportedFunctionalityError({
+          functionality: "tool messages"
+        });
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  text += `${assistant}:
+`;
+  return {
+    prompt: text,
+    stopSequences: [`
+${user}:`]
+  };
+}
+function getResponseMetadata2({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id != null ? id : void 0,
+    modelId: model != null ? model : void 0,
+    timestamp: created != null ? new Date(created * 1e3) : void 0
+  };
+}
+function mapOpenAICompatibleFinishReason2(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+var openaiCompatibleLanguageModelCompletionOptions = z42.object({
+  /**
+   * Echo back the prompt in addition to the completion.
+   */
+  echo: z42.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: z42.record(z42.string(), z42.number()).optional(),
+  /**
+   * The suffix that comes after a completion of inserted text.
+   */
+  suffix: z42.string().optional(),
+  /**
+   * A unique identifier representing your end-user, which can help providers to
+   * monitor and detect abuse.
+   */
+  user: z42.string().optional()
+});
+var OpenAICompatibleCompletionLanguageModel = class {
+  // type inferred via constructor
+  constructor(modelId, config) {
+    this.specificationVersion = "v3";
+    var _a16;
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
+    const errorStructure = (_a16 = config.errorStructure) != null ? _a16 : defaultOpenAICompatibleErrorStructure;
+    this.chunkSchema = createOpenAICompatibleCompletionChunkSchema(
+      errorStructure.errorSchema
+    );
+    this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
   }
-  specificationVersion = "v2";
-  supportedUrls = {
-    "image/*": [/^https?:\/\/.+$/]
-  };
   get provider() {
     return this.config.provider;
   }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  get supportedUrls() {
+    var _a16, _b16, _c;
+    return (_c = (_b16 = (_a16 = this.config).supportedUrls) == null ? void 0 : _b16.call(_a16)) != null ? _c : {};
+  }
+  async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences: userStopSequences,
+    responseFormat,
+    seed,
+    providerOptions,
+    tools,
+    toolChoice
+  }) {
+    var _a16, _b16;
+    const warnings = [];
+    const completionOptions = Object.assign(
+      (_a16 = await parseProviderOptions({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleLanguageModelCompletionOptions
+      })) != null ? _a16 : {},
+      (_b16 = await parseProviderOptions({
+        provider: toCamelCase(this.providerOptionsName),
+        providerOptions,
+        schema: openaiCompatibleLanguageModelCompletionOptions
+      })) != null ? _b16 : {}
+    );
+    if (topK != null) {
+      warnings.push({ type: "unsupported", feature: "topK" });
+    }
+    if (tools == null ? void 0 : tools.length) {
+      warnings.push({ type: "unsupported", feature: "tools" });
+    }
+    if (toolChoice != null) {
+      warnings.push({ type: "unsupported", feature: "toolChoice" });
+    }
+    if (responseFormat != null && responseFormat.type !== "text") {
+      warnings.push({
+        type: "unsupported",
+        feature: "responseFormat",
+        details: "JSON response format is not supported."
+      });
+    }
+    const { prompt: completionPrompt, stopSequences } = convertToOpenAICompatibleCompletionPrompt({ prompt });
+    const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
+    return {
+      args: {
+        // model id:
+        model: this.modelId,
+        // model specific settings:
+        echo: completionOptions.echo,
+        logit_bias: completionOptions.logitBias,
+        suffix: completionOptions.suffix,
+        user: completionOptions.user,
+        // standardized settings:
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        seed,
+        ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
+        ...providerOptions == null ? void 0 : providerOptions[toCamelCase(this.providerOptionsName)],
+        // prompt:
+        prompt: completionPrompt,
+        // stop sequences:
+        stop: stop.length > 0 ? stop : void 0
+      },
+      warnings
+    };
+  }
   async doGenerate(options) {
-    const body = this.buildRequestBody(options, false);
-    const { value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: this.config.headers(),
-      body,
-      failedResponseHandler: apertisFailedResponseHandler,
+    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
+      usage: convertOpenAICompatibleCompletionUsage(response.usage),
+      finishReason: {
+        unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+        raw: choice.finish_reason
+      },
+      request: { body: args },
+      response: {
+        ...getResponseMetadata2(response),
+        headers: responseHeaders,
+        body: rawResponse
       },
-      warnings: [],
-      request: { body }
+      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: ""
+    let finishReason = {
+      unified: "other",
+      raw: void 0
+    };
+    let usage = void 0;
+    let isFirstChunk = true;
+    return {
+      stream: response.pipeThrough(
+        new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
+          transform(chunk, controller) {
+            var _a16;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
+            if (!chunk.success) {
+              finishReason = { unified: "error", raw: void 0 };
+              controller.enqueue({ type: "error", error: chunk.error });
+              return;
+            }
+            const value = chunk.value;
+            if ("error" in value) {
+              finishReason = { unified: "error", raw: void 0 };
+              controller.enqueue({ type: "error", error: value.error });
+              return;
+            }
+            if (isFirstChunk) {
+              isFirstChunk = false;
+              controller.enqueue({
+                type: "response-metadata",
+                ...getResponseMetadata2(value)
+              });
+              controller.enqueue({
+                type: "text-start",
+                id: "0"
+              });
+            }
+            if (value.usage != null) {
+              usage = value.usage;
+            }
+            const choice = value.choices[0];
+            if ((choice == null ? void 0 : choice.finish_reason) != null) {
+              finishReason = {
+                unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+                raw: (_a16 = choice.finish_reason) != null ? _a16 : void 0
               };
-              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
-            });
-            textId = null;
-          }
-          for (const [, buffer] of toolCallBuffers) {
-            if (buffer.name) {
+            if ((choice == null ? void 0 : choice.text) != null) {
               controller.enqueue({
-                type: "tool-call",
-                toolCallId: buffer.id,
-                toolName: buffer.name,
-                input: buffer.arguments
+                type: "text-delta",
+                id: "0",
+                delta: choice.text
               });
             }
-          }
-          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
+          },
+          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: convertOpenAICompatibleCompletionUsage(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
-import { z as z3 } from "zod";
-var openAIEmbeddingResponseSchema = z3.object({
-  object: z3.literal("list").optional(),
-  data: z3.array(
-    z3.object({
-      object: z3.literal("embedding").optional(),
-      embedding: z3.array(z3.number()),
-      index: z3.number()
+var usageSchema = z5.object({
+  prompt_tokens: z5.number(),
+  completion_tokens: z5.number(),
+  total_tokens: z5.number()
+});
+var openaiCompatibleCompletionResponseSchema = z5.object({
+  id: z5.string().nullish(),
+  created: z5.number().nullish(),
+  model: z5.string().nullish(),
+  choices: z5.array(
+    z5.object({
+      text: z5.string(),
+      finish_reason: z5.string()
     })
   ),
-  model: z3.string().optional(),
-  usage: z3.object({
-    prompt_tokens: z3.number(),
-    total_tokens: z3.number()
-  }).optional()
+  usage: usageSchema.nullish()
 });
-
-// src/apertis-embedding-model.ts
-var ApertisEmbeddingModel = class {
-  constructor(modelId, settings, config) {
+var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => z5.union([
+  z5.object({
+    id: z5.string().nullish(),
+    created: z5.number().nullish(),
+    model: z5.string().nullish(),
+    choices: z5.array(
+      z5.object({
+        text: z5.string(),
+        finish_reason: z5.string().nullish(),
+        index: z5.number()
+      })
+    ),
+    usage: usageSchema.nullish()
+  }),
+  errorSchema
+]);
+var openaiCompatibleEmbeddingModelOptions = z6.object({
+  /**
+   * The number of dimensions the resulting output embeddings should have.
+   * Only supported in text-embedding-3 and later models.
+   */
+  dimensions: z6.number().optional(),
+  /**
+   * A unique identifier representing your end-user, which can help providers to
+   * monitor and detect abuse.
+   */
+  user: z6.string().optional()
+});
+var OpenAICompatibleEmbeddingModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v3";
     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;
+  get maxEmbeddingsPerCall() {
+    var _a16;
+    return (_a16 = this.config.maxEmbeddingsPerCall) != null ? _a16 : 2048;
+  }
+  get supportsParallelCalls() {
+    var _a16;
+    return (_a16 = this.config.supportsParallelCalls) != null ? _a16 : true;
+  }
+  get providerOptionsName() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    var _a16, _b16, _c;
+    const warnings = [];
+    const deprecatedOptions = await parseProviderOptions({
+      provider: "openai-compatible",
+      providerOptions,
+      schema: openaiCompatibleEmbeddingModelOptions
+    });
+    if (deprecatedOptions != null) {
+      warnings.push({
+        type: "other",
+        message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
+      });
     }
-    if (this.settings.user !== void 0) {
-      body.user = this.settings.user;
+    const compatibleOptions = Object.assign(
+      deprecatedOptions != null ? deprecatedOptions : {},
+      (_a16 = await parseProviderOptions({
+        provider: "openaiCompatible",
+        providerOptions,
+        schema: openaiCompatibleEmbeddingModelOptions
+      })) != null ? _a16 : {},
+      (_b16 = await parseProviderOptions({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleEmbeddingModelOptions
+      })) != null ? _b16 : {}
+    );
+    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 {
+      warnings,
       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 = z7.object({
+  data: z7.array(z7.object({ embedding: z7.array(z7.number()) })),
+  usage: z7.object({ prompt_tokens: z7.number() }).nullish(),
+  providerMetadata: z7.record(z7.string(), z7.record(z7.string(), z7.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 = "v3";
+    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"
+  /**
+   * The provider options key used to extract provider-specific options.
+   */
+  get providerOptionsKey() {
+    return this.config.provider.split(".")[0].trim();
+  }
+  // TODO: deprecate non-camelCase keys and remove in future major version
+  getArgs(providerOptions) {
+    return {
+      ...providerOptions[this.providerOptionsKey],
+      ...providerOptions[toCamelCase(this.providerOptionsKey)]
     };
-    if (this.settings.dimensions !== void 0) {
-      body.dimensions = this.settings.dimensions;
+  }
+  async doGenerate({
+    prompt,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal,
+    files,
+    mask
+  }) {
+    var _a16, _b16, _c, _d, _e;
+    const warnings = [];
+    if (aspectRatio != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "aspectRatio",
+        details: "This model does not support aspect ratio. Use `size` instead."
+      });
     }
-    if (this.settings.user !== void 0) {
-      body.user = this.settings.user;
+    if (seed != null) {
+      warnings.push({ type: "unsupported", feature: "seed" });
     }
-    const { value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/embeddings`,
-      headers: this.config.headers(),
-      body,
-      failedResponseHandler: apertisFailedResponseHandler,
+    const currentDate = (_c = (_b16 = (_a16 = this.config._internal) == null ? void 0 : _a16.currentDate) == null ? void 0 : _b16.call(_a16)) != null ? _c : /* @__PURE__ */ new Date();
+    const args = this.getArgs(providerOptions);
+    if (files != null && files.length > 0) {
+      const { value: response2, responseHeaders: responseHeaders2 } = await postFormDataToApi({
+        url: this.config.url({
+          path: "/images/edits",
+          modelId: this.modelId
+        }),
+        headers: combineHeaders(this.config.headers(), headers),
+        formData: convertToFormData({
+          model: this.modelId,
+          prompt,
+          image: await Promise.all(files.map((file) => fileToBlob(file))),
+          mask: mask != null ? await fileToBlob(mask) : void 0,
+          n,
+          size,
+          ...args
+        }),
+        failedResponseHandler: createJsonErrorResponseHandler(
+          (_d = this.config.errorStructure) != null ? _d : defaultOpenAICompatibleErrorStructure
+        ),
+        successfulResponseHandler: createJsonResponseHandler(
+          openaiCompatibleImageResponseSchema
+        ),
+        abortSignal,
+        fetch: this.config.fetch
+      });
+      return {
+        images: response2.data.map((item) => item.b64_json),
+        warnings,
+        response: {
+          timestamp: currentDate,
+          modelId: this.modelId,
+          headers: responseHeaders2
+        }
+      };
+    }
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: "/images/generations",
+        modelId: this.modelId
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        prompt,
+        n,
+        size,
+        ...args,
+        response_format: "b64_json"
+      },
+      failedResponseHandler: createJsonErrorResponseHandler(
+        (_e = this.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure
+      ),
       successfulResponseHandler: createJsonResponseHandler(
-        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 };
+var openaiCompatibleImageResponseSchema = z8.object({
+  data: z8.array(z8.object({ b64_json: z8.string() }))
+});
+async function fileToBlob(file) {
+  if (file.type === "url") {
+    return downloadBlob(file.url);
+  }
+  const data = file.data instanceof Uint8Array ? file.data : convertBase64ToUint8Array(file.data);
+  return new Blob([data], { type: file.mediaType });
 }
-function createApertis(options = {}) {
-  const { baseURL, getHeaders, fetch: fetchImpl } = initializeProvider(options);
-  const createChatModel = (modelId, settings = {}) => new ApertisChatLanguageModelV2(modelId, settings, {
-    provider: "apertis.chat",
-    baseURL,
+var VERSION2 = true ? "2.0.41" : "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,
+    transformRequestBody: options.transformRequestBody,
+    metadataExtractor: options.metadataExtractor
   });
-  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.specificationVersion = "v3";
+  provider.languageModel = createLanguageModel;
+  provider.chatModel = createChatModel;
+  provider.completionModel = createCompletionModel;
+  provider.embeddingModel = createEmbeddingModel;
+  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();
 export {
   apertis,
-  createApertis,
-  createApertisV3
+  createApertis
 };
 //# sourceMappingURL=index.js.map