@llmgateway/ai-sdk-provider 1.0.3 → 2.0.0

package/dist/index.js

@@ -1,10 +1,12 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -20,21 +22,9 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
 var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+  for (var name14 in all)
+    __defProp(target, name14, { get: all[name14], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -44,6 +34,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -55,75 +53,1005 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/llmgateway-facade.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+// node_modules/.pnpm/@ai-sdk+provider@2.0.0-beta.1/node_modules/@ai-sdk/provider/dist/index.mjs
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _AISDKError = class _AISDKError2 extends Error {
+  /**
+   * Creates an AI SDK Error.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {string} params.name - The name of the error.
+   * @param {string} params.message - The error message.
+   * @param {unknown} [params.cause] - The underlying cause of the error.
+   */
+  constructor({
+    name: name14,
+    message,
+    cause
+  }) {
+    super(message);
+    this[_a] = true;
+    this.name = name14;
+    this.cause = cause;
+  }
+  /**
+   * Checks if the given error is an AI SDK Error.
+   * @param {unknown} error - The error to check.
+   * @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+   */
+  static isInstance(error) {
+    return _AISDKError2.hasMarker(error, marker);
+  }
+  static hasMarker(error, marker15) {
+    const markerSymbol = Symbol.for(marker15);
+    return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
+  }
+};
+_a = symbol;
+var AISDKError = _AISDKError;
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+var APICallError = class extends AISDKError {
+  constructor({
+    message,
+    url,
+    requestBodyValues,
+    statusCode,
+    responseHeaders,
+    responseBody,
+    cause,
+    isRetryable = statusCode != null && (statusCode === 408 || // request timeout
+    statusCode === 409 || // conflict
+    statusCode === 429 || // too many requests
+    statusCode >= 500),
+    // server error
+    data
+  }) {
+    super({ name, message, cause });
+    this[_a2] = true;
+    this.url = url;
+    this.requestBodyValues = requestBodyValues;
+    this.statusCode = statusCode;
+    this.responseHeaders = responseHeaders;
+    this.responseBody = responseBody;
+    this.isRetryable = isRetryable;
+    this.data = data;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker2);
+  }
+};
+_a2 = symbol2;
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+var EmptyResponseBodyError = class extends AISDKError {
+  // used in isInstance
+  constructor({ message = "Empty response body" } = {}) {
+    super({ name: name2, message });
+    this[_a3] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker3);
+  }
+};
+_a3 = symbol3;
+function getErrorMessage(error) {
+  if (error == null) {
+    return "unknown error";
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return JSON.stringify(error);
+}
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var InvalidArgumentError = class extends AISDKError {
+  constructor({
+    message,
+    cause,
+    argument
+  }) {
+    super({ name: name3, message, cause });
+    this[_a4] = true;
+    this.argument = argument;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker4);
+  }
+};
+_a4 = symbol4;
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+var InvalidPromptError = class extends AISDKError {
+  constructor({
+    prompt,
+    message,
+    cause
+  }) {
+    super({ name: name4, message: `Invalid prompt: ${message}`, cause });
+    this[_a5] = true;
+    this.prompt = prompt;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker5);
+  }
+};
+_a5 = symbol5;
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+var InvalidResponseDataError = class extends AISDKError {
+  constructor({
+    data,
+    message = `Invalid response data: ${JSON.stringify(data)}.`
+  }) {
+    super({ name: name5, message });
+    this[_a6] = true;
+    this.data = data;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker6);
+  }
+};
+_a6 = symbol6;
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var JSONParseError = class extends AISDKError {
+  constructor({ text, cause }) {
+    super({
+      name: name6,
+      message: `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a7] = true;
+    this.text = text;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker7);
+  }
+};
+_a7 = symbol7;
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+var LoadAPIKeyError = class extends AISDKError {
+  // used in isInstance
+  constructor({ message }) {
+    super({ name: name7, message });
+    this[_a8] = true;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker8);
+  }
+};
+_a8 = symbol8;
+var name8 = "AI_LoadSettingError";
+var marker9 = `vercel.ai.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+_a9 = symbol9;
+var name9 = "AI_NoContentGeneratedError";
+var marker10 = `vercel.ai.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+_a10 = symbol10;
+var name10 = "AI_NoSuchModelError";
+var marker11 = `vercel.ai.error.${name10}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+_a11 = symbol11;
+var name11 = "AI_TooManyEmbeddingValuesForCallError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+_a12 = symbol12;
+var name12 = "AI_TypeValidationError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+var _TypeValidationError = class _TypeValidationError2 extends AISDKError {
+  constructor({ value, cause }) {
+    super({
+      name: name12,
+      message: `Type validation failed: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+      cause
+    });
+    this[_a13] = true;
+    this.value = value;
+  }
+  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.
+   * 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.
+   * @returns {TypeValidationError} A TypeValidationError instance.
+   */
+  static wrap({
+    value,
+    cause
+  }) {
+    return _TypeValidationError2.isInstance(cause) && cause.value === value ? cause : new _TypeValidationError2({ value, cause });
+  }
+};
+_a13 = symbol13;
+var TypeValidationError = _TypeValidationError;
+var name13 = "AI_UnsupportedFunctionalityError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+var UnsupportedFunctionalityError = class extends AISDKError {
+  constructor({
+    functionality,
+    message = `'${functionality}' functionality not supported.`
+  }) {
+    super({ name: name13, message });
+    this[_a14] = true;
+    this.functionality = functionality;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker14);
+  }
+};
+_a14 = symbol14;
 
-// src/schemas/reasoning-details.ts
+// node_modules/.pnpm/eventsource-parser@3.0.3/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+  let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
+  function feed(newChunk) {
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    for (const line of complete)
+      parseLine(line);
+    incompleteLine = incomplete, isFirstChunk = false;
+  }
+  function parseLine(line) {
+    if (line === "") {
+      dispatchEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex !== -1) {
+      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
+      return;
+    }
+    processField(line, "", line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data = `${data}${value}
+`;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    data.length > 0 && onEvent({
+      id,
+      event: eventType || void 0,
+      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+      // then remove the last character from the data buffer.
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+    }), id = void 0, data = "", eventType = "";
+  }
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
+  }
+  return { feed, reset };
+}
+function splitLines(chunk) {
+  const lines = [];
+  let incompleteLine = "", searchIndex = 0;
+  for (; searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+    let lineEnd = -1;
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
+      break;
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+    }
+  }
+  return [lines, incompleteLine];
+}
+
+// node_modules/.pnpm/eventsource-parser@3.0.3/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+};
+
+// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.0-beta.5_zod@3.25.34/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+var z4 = __toESM(require("zod/v4"), 1);
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/Options.js
+var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/selectParser.js
+var import_zod4 = require("zod");
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
 var import_zod = require("zod");
-var ReasoningDetailSummarySchema = import_zod.z.object({
-  type: import_zod.z.literal("reasoning.summary" /* Summary */),
-  summary: import_zod.z.string()
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+var import_zod2 = require("zod");
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.34/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+var import_zod3 = require("zod");
+
+// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.0-beta.5_zod@3.25.34/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+function combineHeaders(...headers) {
+  return headers.reduce(
+    (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
+    {}
+  );
+}
+function extractResponseHeaders(response) {
+  return Object.fromEntries([...response.headers]);
+}
+var createIdGenerator = ({
+  prefix,
+  size = 16,
+  alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  separator = "-"
+} = {}) => {
+  const generator = () => {
+    const alphabetLength = alphabet.length;
+    const chars = new Array(size);
+    for (let i = 0; i < size; i++) {
+      chars[i] = alphabet[Math.random() * alphabetLength | 0];
+    }
+    return chars.join("");
+  };
+  if (prefix == null) {
+    return generator;
+  }
+  if (alphabet.includes(separator)) {
+    throw new InvalidArgumentError({
+      argument: "separator",
+      message: `The separator "${separator}" must not be part of the alphabet "${alphabet}".`
+    });
+  }
+  return () => `${prefix}${separator}${generator()}`;
+};
+var generateId = createIdGenerator();
+function isAbortError(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
+  error.name === "TimeoutError");
+}
+var FETCH_FAILED_ERROR_MESSAGES = ["fetch failed", "failed to fetch"];
+function handleFetchError({
+  error,
+  url,
+  requestBodyValues
+}) {
+  if (isAbortError(error)) {
+    return error;
+  }
+  if (error instanceof TypeError && FETCH_FAILED_ERROR_MESSAGES.includes(error.message.toLowerCase())) {
+    const cause = error.cause;
+    if (cause != null) {
+      return new APICallError({
+        message: `Cannot connect to API: ${cause.message}`,
+        cause,
+        url,
+        requestBodyValues,
+        isRetryable: true
+        // retry when network error
+      });
+    }
+  }
+  return error;
+}
+function removeUndefinedEntries(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter(([_key, value]) => value != null)
+  );
+}
+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*:/;
+function _parse(text) {
+  const obj = JSON.parse(text);
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
+    return obj;
+  }
+  return filter(obj);
+}
+function filter(obj) {
+  let next = [obj];
+  while (next.length) {
+    const nodes = next;
+    next = [];
+    for (const node of nodes) {
+      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")) {
+        throw new SyntaxError("Object contains forbidden prototype property");
+      }
+      for (const key in node) {
+        const value = node[key];
+        if (value && typeof value === "object") {
+          next.push(value);
+        }
+      }
+    }
+  }
+  return obj;
+}
+function secureJsonParse(text) {
+  const { stackTraceLimit } = Error;
+  Error.stackTraceLimit = 0;
+  try {
+    return _parse(text);
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit;
+  }
+}
+var validatorSymbol = Symbol.for("vercel.ai.validator");
+function validator(validate) {
+  return { [validatorSymbol]: true, validate };
+}
+function isValidator(value) {
+  return typeof value === "object" && value !== null && validatorSymbol in value && value[validatorSymbol] === true && "validate" in value;
+}
+function asValidator(value) {
+  return isValidator(value) ? value : standardSchemaValidator(value);
+}
+function standardSchemaValidator(standardSchema) {
+  return validator(async (value) => {
+    const result = await standardSchema["~standard"].validate(value);
+    return result.issues == null ? { success: true, value: result.value } : {
+      success: false,
+      error: new TypeValidationError({
+        value,
+        cause: result.issues
+      })
+    };
+  });
+}
+async function validateTypes({
+  value,
+  schema
+}) {
+  const result = await safeValidateTypes({ value, schema });
+  if (!result.success) {
+    throw TypeValidationError.wrap({ value, cause: result.error });
+  }
+  return result.value;
+}
+async function safeValidateTypes({
+  value,
+  schema
+}) {
+  const validator2 = asValidator(schema);
+  try {
+    if (validator2.validate == null) {
+      return { success: true, value, rawValue: value };
+    }
+    const result = await validator2.validate(value);
+    if (result.success) {
+      return { success: true, value: result.value, rawValue: value };
+    }
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: result.error }),
+      rawValue: value
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: TypeValidationError.wrap({ value, cause: error }),
+      rawValue: value
+    };
+  }
+}
+async function parseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = secureJsonParse(text);
+    if (schema == null) {
+      return value;
+    }
+    return validateTypes({ value, schema });
+  } catch (error) {
+    if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) {
+      throw error;
+    }
+    throw new JSONParseError({ text, cause: error });
+  }
+}
+async function safeParseJSON({
+  text,
+  schema
+}) {
+  try {
+    const value = secureJsonParse(text);
+    if (schema == null) {
+      return { success: true, value, rawValue: value };
+    }
+    return await safeValidateTypes({ value, schema });
+  } catch (error) {
+    return {
+      success: false,
+      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error }),
+      rawValue: void 0
+    };
+  }
+}
+function isParsableJson(input) {
+  try {
+    secureJsonParse(input);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function parseJsonEventStream({
+  stream,
+  schema
+}) {
+  return stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).pipeThrough(
+    new TransformStream({
+      async transform({ data }, controller) {
+        if (data === "[DONE]") {
+          return;
+        }
+        controller.enqueue(await safeParseJSON({ text: data, schema }));
+      }
+    })
+  );
+}
+var getOriginalFetch2 = () => globalThis.fetch;
+var postJsonToApi = async ({
+  url,
+  headers,
+  body,
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch
+}) => postToApi({
+  url,
+  headers: __spreadValues({
+    "Content-Type": "application/json"
+  }, headers),
+  body: {
+    content: JSON.stringify(body),
+    values: body
+  },
+  failedResponseHandler,
+  successfulResponseHandler,
+  abortSignal,
+  fetch
 });
-var ReasoningDetailEncryptedSchema = import_zod.z.object({
-  type: import_zod.z.literal("reasoning.encrypted" /* Encrypted */),
-  data: import_zod.z.string()
+var postToApi = async ({
+  url,
+  headers = {},
+  body,
+  successfulResponseHandler,
+  failedResponseHandler,
+  abortSignal,
+  fetch = getOriginalFetch2()
+}) => {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: removeUndefinedEntries(headers),
+      body: body.content,
+      signal: abortSignal
+    });
+    const responseHeaders = extractResponseHeaders(response);
+    if (!response.ok) {
+      let errorInformation;
+      try {
+        errorInformation = await failedResponseHandler({
+          response,
+          url,
+          requestBodyValues: body.values
+        });
+      } catch (error) {
+        if (isAbortError(error) || APICallError.isInstance(error)) {
+          throw error;
+        }
+        throw new APICallError({
+          message: "Failed to process error response",
+          cause: error,
+          statusCode: response.status,
+          url,
+          responseHeaders,
+          requestBodyValues: body.values
+        });
+      }
+      throw errorInformation.value;
+    }
+    try {
+      return await successfulResponseHandler({
+        response,
+        url,
+        requestBodyValues: body.values
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        if (isAbortError(error) || APICallError.isInstance(error)) {
+          throw error;
+        }
+      }
+      throw new APICallError({
+        message: "Failed to process successful response",
+        cause: error,
+        statusCode: response.status,
+        url,
+        responseHeaders,
+        requestBodyValues: body.values
+      });
+    }
+  } catch (error) {
+    throw handleFetchError({ error, url, requestBodyValues: body.values });
+  }
+};
+var createJsonErrorResponseHandler = ({
+  errorSchema,
+  errorToMessage,
+  isRetryable
+}) => async ({ response, url, requestBodyValues }) => {
+  const responseBody = await response.text();
+  const responseHeaders = extractResponseHeaders(response);
+  if (responseBody.trim() === "") {
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+      })
+    };
+  }
+  try {
+    const parsedError = await parseJSON({
+      text: responseBody,
+      schema: errorSchema
+    });
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: errorToMessage(parsedError),
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        data: parsedError,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response, parsedError)
+      })
+    };
+  } catch (parseError) {
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: response.statusText,
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        isRetryable: isRetryable == null ? void 0 : isRetryable(response)
+      })
+    };
+  }
+};
+var createEventSourceResponseHandler = (chunkSchema) => async ({ response }) => {
+  const responseHeaders = extractResponseHeaders(response);
+  if (response.body == null) {
+    throw new EmptyResponseBodyError({});
+  }
+  return {
+    responseHeaders,
+    value: parseJsonEventStream({
+      stream: response.body,
+      schema: chunkSchema
+    })
+  };
+};
+var createJsonResponseHandler = (responseSchema) => async ({ response, url, requestBodyValues }) => {
+  const responseBody = await response.text();
+  const parsedResult = await safeParseJSON({
+    text: responseBody,
+    schema: responseSchema
+  });
+  const responseHeaders = extractResponseHeaders(response);
+  if (!parsedResult.success) {
+    throw new APICallError({
+      message: "Invalid JSON response",
+      cause: parsedResult.error,
+      statusCode: response.status,
+      responseHeaders,
+      responseBody,
+      url,
+      requestBodyValues
+    });
+  }
+  return {
+    responseHeaders,
+    value: parsedResult.value,
+    rawValue: parsedResult.rawValue
+  };
+};
+var schemaSymbol = Symbol.for("vercel.ai.schema");
+var { btoa, atob } = globalThis;
+function convertUint8ArrayToBase64(array) {
+  let latin1string = "";
+  for (let i = 0; i < array.length; i++) {
+    latin1string += String.fromCodePoint(array[i]);
+  }
+  return btoa(latin1string);
+}
+function withoutTrailingSlash(url) {
+  return url == null ? void 0 : url.replace(/\/$/, "");
+}
+
+// src/schemas/reasoning-details.ts
+var import_v4 = require("zod/v4");
+var ReasoningDetailSummarySchema = import_v4.z.object({
+  type: import_v4.z.literal("reasoning.summary" /* Summary */),
+  summary: import_v4.z.string()
+});
+var ReasoningDetailEncryptedSchema = import_v4.z.object({
+  type: import_v4.z.literal("reasoning.encrypted" /* Encrypted */),
+  data: import_v4.z.string()
 });
-var ReasoningDetailTextSchema = import_zod.z.object({
-  type: import_zod.z.literal("reasoning.text" /* Text */),
-  text: import_zod.z.string().nullish(),
-  signature: import_zod.z.string().nullish()
+var ReasoningDetailTextSchema = import_v4.z.object({
+  type: import_v4.z.literal("reasoning.text" /* Text */),
+  text: import_v4.z.string().nullish(),
+  signature: import_v4.z.string().nullish()
 });
-var ReasoningDetailUnionSchema = import_zod.z.union([
+var ReasoningDetailUnionSchema = import_v4.z.union([
   ReasoningDetailSummarySchema,
   ReasoningDetailEncryptedSchema,
   ReasoningDetailTextSchema
 ]);
-var ReasoningDetailsWithUnknownSchema = import_zod.z.union([
+var ReasoningDetailsWithUnknownSchema = import_v4.z.union([
   ReasoningDetailUnionSchema,
-  import_zod.z.unknown().transform(() => null)
+  import_v4.z.unknown().transform(() => null)
 ]);
-var ReasoningDetailArraySchema = import_zod.z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
+var ReasoningDetailArraySchema = import_v4.z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
 
-// src/llmgateway-chat-language-model.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+// src/schemas/error-response.ts
+var import_v42 = require("zod/v4");
+var LLMGatewayErrorResponseSchema = import_v42.z.object({
+  error: import_v42.z.object({
+    code: import_v42.z.union([import_v42.z.string(), import_v42.z.number()]).nullable().optional().default(null),
+    message: import_v42.z.string(),
+    type: import_v42.z.string().nullable().optional().default(null),
+    param: import_v42.z.any().nullable().optional().default(null)
+  })
+});
+var llmgatewayFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: LLMGatewayErrorResponseSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+// src/utils/map-finish-reason.ts
+function mapLLMGatewayFinishReason(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
 
-// src/convert-to-llmgateway-chat-messages.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
+// src/chat/is-url.ts
+function isUrl({
+  url,
+  protocols
+}) {
+  try {
+    const urlObj = new URL(url);
+    return protocols.has(urlObj.protocol);
+  } catch (_) {
+    return false;
+  }
+}
+
+// src/chat/file-url-utils.ts
+function getFileUrl({
+  part,
+  defaultMediaType
+}) {
+  var _a15, _b;
+  if (part.data instanceof Uint8Array) {
+    const base64 = convertUint8ArrayToBase64(part.data);
+    return `data:${(_a15 = part.mediaType) != null ? _a15 : defaultMediaType};base64,${base64}`;
+  }
+  const stringUrl = part.data.toString();
+  if (isUrl({
+    url: stringUrl,
+    protocols: /* @__PURE__ */ new Set(["http:", "https:"])
+  })) {
+    return stringUrl;
+  }
+  return stringUrl.startsWith("data:") ? stringUrl : `data:${(_b = part.mediaType) != null ? _b : defaultMediaType};base64,${stringUrl}`;
+}
+
+// src/chat/convert-to-llmgateway-chat-messages.ts
 function getCacheControl(providerMetadata) {
-  var _a, _b, _c;
+  var _a15, _b, _c;
   const anthropic = providerMetadata == null ? void 0 : providerMetadata.anthropic;
   const llmgateway2 = providerMetadata == null ? void 0 : providerMetadata.llmgateway;
-  return (_c = (_b = (_a = llmgateway2 == null ? void 0 : llmgateway2.cacheControl) != null ? _a : llmgateway2 == null ? void 0 : llmgateway2.cache_control) != null ? _b : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
+  return (_c = (_b = (_a15 = llmgateway2 == null ? void 0 : llmgateway2.cacheControl) != null ? _a15 : llmgateway2 == null ? void 0 : llmgateway2.cache_control) != null ? _b : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
 }
 function convertToLLMGatewayChatMessages(prompt) {
-  var _a, _b, _c;
+  var _a15, _b, _c;
   const messages = [];
-  for (const { role, content, providerMetadata } of prompt) {
+  for (const { role, content, providerOptions } of prompt) {
     switch (role) {
       case "system": {
         messages.push({
           role: "system",
           content,
-          cache_control: getCacheControl(providerMetadata)
+          cache_control: getCacheControl(providerOptions)
         });
         break;
       }
       case "user": {
-        if (content.length === 1 && ((_a = content[0]) == null ? void 0 : _a.type) === "text") {
+        if (content.length === 1 && ((_a15 = content[0]) == null ? void 0 : _a15.type) === "text") {
+          const cacheControl = (_b = getCacheControl(providerOptions)) != null ? _b : getCacheControl(content[0].providerOptions);
+          const contentWithCacheControl = cacheControl ? [
+            {
+              type: "text",
+              text: content[0].text,
+              cache_control: cacheControl
+            }
+          ] : content[0].text;
           messages.push({
             role: "user",
-            content: content[0].text,
-            cache_control: (_b = getCacheControl(providerMetadata)) != null ? _b : getCacheControl(content[0].providerMetadata)
+            content: contentWithCacheControl
           });
           break;
         }
-        const messageCacheControl = getCacheControl(providerMetadata);
+        const messageCacheControl = getCacheControl(providerOptions);
         const contentParts = content.map(
           (part) => {
-            var _a2, _b2, _c2, _d;
-            const cacheControl = (_a2 = getCacheControl(part.providerMetadata)) != null ? _a2 : messageCacheControl;
+            var _a16, _b2, _c2, _d, _e, _f;
+            const cacheControl = (_a16 = getCacheControl(part.providerOptions)) != null ? _a16 : messageCacheControl;
             switch (part.type) {
               case "text":
                 return {
@@ -132,33 +1060,55 @@ function convertToLLMGatewayChatMessages(prompt) {
                   // For text parts, only use part-specific cache control
                   cache_control: cacheControl
                 };
-              case "image":
-                return {
-                  type: "image_url",
-                  image_url: {
-                    url: part.image instanceof URL ? part.image.toString() : `data:${(_b2 = part.mimeType) != null ? _b2 : "image/jpeg"};base64,${(0, import_provider_utils.convertUint8ArrayToBase64)(
-                      part.image
-                    )}`
-                  },
-                  // For image parts, use part-specific or message-level cache control
-                  cache_control: cacheControl
-                };
-              case "file":
+              case "file": {
+                if ((_b2 = part.mediaType) == null ? void 0 : _b2.startsWith("image/")) {
+                  const url = getFileUrl({
+                    part,
+                    defaultMediaType: "image/jpeg"
+                  });
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url
+                    },
+                    // For image parts, use part-specific or message-level cache control
+                    cache_control: cacheControl
+                  };
+                }
+                const fileName = String(
+                  (_f = (_e = (_d = (_c2 = part.providerOptions) == null ? void 0 : _c2.llmgateway) == null ? void 0 : _d.filename) != null ? _e : part.filename) != null ? _f : ""
+                );
+                const fileData = getFileUrl({
+                  part,
+                  defaultMediaType: "application/pdf"
+                });
+                if (isUrl({
+                  url: fileData,
+                  protocols: /* @__PURE__ */ new Set(["http:", "https:"])
+                })) {
+                  return {
+                    type: "file",
+                    file: {
+                      filename: fileName,
+                      file_data: fileData
+                    }
+                  };
+                }
                 return {
                   type: "file",
                   file: {
-                    filename: String(
-                      (_d = (_c2 = part.providerMetadata) == null ? void 0 : _c2.llmgateway) == null ? void 0 : _d.filename
-                    ),
-                    file_data: part.data instanceof Uint8Array ? `data:${part.mimeType};base64,${(0, import_provider_utils.convertUint8ArrayToBase64)(part.data)}` : `data:${part.mimeType};base64,${part.data}`
+                    filename: fileName,
+                    file_data: fileData
                   },
                   cache_control: cacheControl
                 };
+              }
               default: {
-                const _exhaustiveCheck = part;
-                throw new Error(
-                  `Unsupported content part type: ${_exhaustiveCheck}`
-                );
+                return {
+                  type: "text",
+                  text: "",
+                  cache_control: cacheControl
+                };
               }
             }
           }
@@ -186,7 +1136,7 @@ function convertToLLMGatewayChatMessages(prompt) {
                 type: "function",
                 function: {
                   name: part.toolName,
-                  arguments: JSON.stringify(part.args)
+                  arguments: JSON.stringify(part.input)
                 }
               });
               break;
@@ -195,23 +1145,14 @@ function convertToLLMGatewayChatMessages(prompt) {
               reasoning += part.text;
               reasoningDetails.push({
                 type: "reasoning.text" /* Text */,
-                text: part.text,
-                signature: part.signature
-              });
-              break;
-            }
-            case "redacted-reasoning": {
-              reasoningDetails.push({
-                type: "reasoning.encrypted" /* Encrypted */,
-                data: part.data
+                text: part.text
               });
               break;
             }
             case "file":
               break;
             default: {
-              const _exhaustiveCheck = part;
-              throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
+              break;
             }
           }
         }
@@ -221,95 +1162,188 @@ function convertToLLMGatewayChatMessages(prompt) {
           tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
           reasoning: reasoning || void 0,
           reasoning_details: reasoningDetails.length > 0 ? reasoningDetails : void 0,
-          cache_control: getCacheControl(providerMetadata)
+          cache_control: getCacheControl(providerOptions)
         });
         break;
       }
       case "tool": {
         for (const toolResponse of content) {
+          const content2 = getToolResultContent(toolResponse);
           messages.push({
             role: "tool",
             tool_call_id: toolResponse.toolCallId,
-            content: JSON.stringify(toolResponse.result),
-            cache_control: (_c = getCacheControl(providerMetadata)) != null ? _c : getCacheControl(toolResponse.providerMetadata)
+            content: content2,
+            cache_control: (_c = getCacheControl(providerOptions)) != null ? _c : getCacheControl(toolResponse.providerOptions)
           });
         }
         break;
       }
       default: {
-        const _exhaustiveCheck = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+        break;
       }
     }
   }
   return messages;
 }
-
-// src/map-llmgateway-chat-logprobs.ts
-function mapLLMGatewayChatLogProbsOutput(logprobs) {
-  var _a, _b;
-  return (_b = (_a = logprobs == null ? void 0 : logprobs.content) == null ? void 0 : _a.map(({ token, logprob, top_logprobs }) => ({
-    token,
-    logprob,
-    topLogprobs: top_logprobs ? top_logprobs.map(({ token: token2, logprob: logprob2 }) => ({
-      token: token2,
-      logprob: logprob2
-    })) : []
-  }))) != null ? _b : void 0;
+function getToolResultContent(input) {
+  return input.output.type === "text" ? input.output.value : JSON.stringify(input.output.value);
 }
 
-// src/map-llmgateway-finish-reason.ts
-function mapLLMGatewayFinishReason(finishReason) {
-  switch (finishReason) {
-    case "stop":
-      return "stop";
-    case "length":
-      return "length";
-    case "content_filter":
-      return "content-filter";
-    case "function_call":
-    case "tool_calls":
-      return "tool-calls";
-    default:
-      return "unknown";
+// src/chat/get-tool-choice.ts
+var import_v43 = require("zod/v4");
+var ChatCompletionToolChoiceSchema = import_v43.z.union([
+  import_v43.z.literal("auto"),
+  import_v43.z.literal("none"),
+  import_v43.z.literal("required"),
+  import_v43.z.object({
+    type: import_v43.z.literal("function"),
+    function: import_v43.z.object({
+      name: import_v43.z.string()
+    })
+  })
+]);
+function getChatCompletionToolChoice(toolChoice) {
+  switch (toolChoice.type) {
+    case "auto":
+    case "none":
+    case "required":
+      return toolChoice.type;
+    case "tool": {
+      return {
+        type: "function",
+        function: { name: toolChoice.toolName }
+      };
+    }
+    default: {
+      toolChoice;
+      throw new Error(`Invalid tool choice type: ${toolChoice}`);
+    }
   }
 }
 
-// src/llmgateway-error.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
-var LLMGatewayErrorResponseSchema = import_zod2.z.object({
-  error: import_zod2.z.object({
-    message: import_zod2.z.string(),
-    type: import_zod2.z.string(),
-    param: import_zod2.z.any().nullable(),
-    code: import_zod2.z.string().nullable()
-  })
+// src/chat/schemas.ts
+var import_v44 = require("zod/v4");
+var LLMGatewayChatCompletionBaseResponseSchema = import_v44.z.object({
+  id: import_v44.z.string().optional(),
+  model: import_v44.z.string().optional(),
+  usage: import_v44.z.object({
+    prompt_tokens: import_v44.z.number(),
+    prompt_tokens_details: import_v44.z.object({
+      cached_tokens: import_v44.z.number()
+    }).nullish(),
+    completion_tokens: import_v44.z.number(),
+    completion_tokens_details: import_v44.z.object({
+      reasoning_tokens: import_v44.z.number()
+    }).nullish(),
+    total_tokens: import_v44.z.number(),
+    cost: import_v44.z.number().optional(),
+    cost_details: import_v44.z.object({
+      upstream_inference_cost: import_v44.z.number().nullish()
+    }).nullish()
+  }).nullish()
 });
-var llmgatewayFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
-  errorSchema: LLMGatewayErrorResponseSchema,
-  errorToMessage: (data) => data.error.message
+var LLMGatewayNonStreamChatCompletionResponseSchema = LLMGatewayChatCompletionBaseResponseSchema.extend({
+  choices: import_v44.z.array(
+    import_v44.z.object({
+      message: import_v44.z.object({
+        role: import_v44.z.literal("assistant"),
+        content: import_v44.z.string().nullable().optional(),
+        reasoning: import_v44.z.string().nullable().optional(),
+        reasoning_details: ReasoningDetailArraySchema.nullish(),
+        tool_calls: import_v44.z.array(
+          import_v44.z.object({
+            id: import_v44.z.string().optional().nullable(),
+            type: import_v44.z.literal("function"),
+            function: import_v44.z.object({
+              name: import_v44.z.string(),
+              arguments: import_v44.z.string()
+            })
+          })
+        ).optional()
+      }),
+      index: import_v44.z.number().nullish(),
+      logprobs: import_v44.z.object({
+        content: import_v44.z.array(
+          import_v44.z.object({
+            token: import_v44.z.string(),
+            logprob: import_v44.z.number(),
+            top_logprobs: import_v44.z.array(
+              import_v44.z.object({
+                token: import_v44.z.string(),
+                logprob: import_v44.z.number()
+              })
+            )
+          })
+        ).nullable()
+      }).nullable().optional(),
+      finish_reason: import_v44.z.string().optional().nullable()
+    })
+  )
 });
+var LLMGatewayStreamChatCompletionChunkSchema = import_v44.z.union([
+  LLMGatewayChatCompletionBaseResponseSchema.extend({
+    choices: import_v44.z.array(
+      import_v44.z.object({
+        delta: import_v44.z.object({
+          role: import_v44.z.enum(["assistant"]).optional(),
+          content: import_v44.z.string().nullish(),
+          reasoning: import_v44.z.string().nullish().optional(),
+          reasoning_details: ReasoningDetailArraySchema.nullish(),
+          tool_calls: import_v44.z.array(
+            import_v44.z.object({
+              index: import_v44.z.number().nullish(),
+              id: import_v44.z.string().nullish(),
+              type: import_v44.z.literal("function").optional(),
+              function: import_v44.z.object({
+                name: import_v44.z.string().nullish(),
+                arguments: import_v44.z.string().nullish()
+              })
+            })
+          ).nullish()
+        }).nullish(),
+        logprobs: import_v44.z.object({
+          content: import_v44.z.array(
+            import_v44.z.object({
+              token: import_v44.z.string(),
+              logprob: import_v44.z.number(),
+              top_logprobs: import_v44.z.array(
+                import_v44.z.object({
+                  token: import_v44.z.string(),
+                  logprob: import_v44.z.number()
+                })
+              )
+            })
+          ).nullable()
+        }).nullish(),
+        finish_reason: import_v44.z.string().nullable().optional(),
+        index: import_v44.z.number().nullish()
+      })
+    )
+  }),
+  LLMGatewayErrorResponseSchema
+]);
 
-// src/llmgateway-chat-language-model.ts
-function isFunctionTool(tool) {
-  return "parameters" in tool;
-}
+// src/chat/index.ts
 var LLMGatewayChatLanguageModel = class {
   constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
+    this.provider = "llmgateway";
     this.defaultObjectGenerationMode = "tool";
+    this.supportedUrls = {
+      "image/*": [
+        /^data:image\/[a-zA-Z]+;base64,/,
+        /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp)$/i
+      ],
+      // 'text/*': [/^data:text\//, /^https?:\/\/.+$/],
+      "application/*": [/^data:application\//, /^https?:\/\/.+$/]
+    };
     this.modelId = modelId;
     this.settings = settings;
     this.config = config;
   }
-  get provider() {
-    return this.config.provider;
-  }
   getArgs({
-    mode,
     prompt,
-    maxTokens,
+    maxOutputTokens,
     temperature,
     topP,
     frequencyPenalty,
@@ -318,12 +1352,10 @@ var LLMGatewayChatLanguageModel = class {
     stopSequences,
     responseFormat,
     topK,
-    providerMetadata
+    tools,
+    toolChoice
   }) {
-    var _a;
-    const type = mode.type;
-    const extraCallingBody = (_a = providerMetadata == null ? void 0 : providerMetadata.llmgateway) != null ? _a : {};
-    const baseArgs = __spreadValues(__spreadValues(__spreadValues({
+    const baseArgs = __spreadValues(__spreadValues({
       // model id:
       model: this.modelId,
       models: this.settings.models,
@@ -334,7 +1366,7 @@ var LLMGatewayChatLanguageModel = class {
       user: this.settings.user,
       parallel_tool_calls: this.settings.parallelToolCalls,
       // standardized settings:
-      max_tokens: maxTokens,
+      max_tokens: maxOutputTokens,
       temperature,
       top_p: topP,
       frequency_penalty: frequencyPenalty,
@@ -349,97 +1381,72 @@ var LLMGatewayChatLanguageModel = class {
       include_reasoning: this.settings.includeReasoning,
       reasoning: this.settings.reasoning,
       usage: this.settings.usage
-    }, this.config.extraBody), this.settings.extraBody), extraCallingBody);
-    switch (type) {
-      case "regular": {
-        return __spreadValues(__spreadValues({}, baseArgs), prepareToolsAndToolChoice(mode));
-      }
-      case "object-json": {
-        return __spreadProps(__spreadValues({}, baseArgs), {
-          response_format: { type: "json_object" }
-        });
-      }
-      case "object-tool": {
-        return __spreadProps(__spreadValues({}, baseArgs), {
-          tool_choice: { type: "function", function: { name: mode.tool.name } },
-          tools: [
-            {
-              type: "function",
-              function: {
-                name: mode.tool.name,
-                description: mode.tool.description,
-                parameters: mode.tool.parameters
-              }
-            }
-          ]
-        });
-      }
-      // Handle all non-text types with a single default case
-      default: {
-        const _exhaustiveCheck = type;
-        throw new import_provider.UnsupportedFunctionalityError({
-          functionality: `${_exhaustiveCheck} mode`
-        });
-      }
+    }, this.config.extraBody), this.settings.extraBody);
+    if ((responseFormat == null ? void 0 : responseFormat.type) === "json") {
+      return __spreadProps(__spreadValues({}, baseArgs), {
+        response_format: { type: "json_object" }
+      });
+    }
+    if (tools && tools.length > 0) {
+      const mappedTools = tools.filter((tool) => tool.type === "function").map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.type,
+          parameters: tool.inputSchema
+        }
+      }));
+      return __spreadProps(__spreadValues({}, baseArgs), {
+        tools: mappedTools,
+        tool_choice: toolChoice ? getChatCompletionToolChoice(toolChoice) : void 0
+      });
     }
+    return baseArgs;
   }
   async doGenerate(options) {
-    var _b, _c, _d, _e, _f, _g, _h, _i, _j;
-    const args = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    const providerOptions = options.providerOptions || {};
+    const llmgatewayOptions = providerOptions.llmgateway || {};
+    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), llmgatewayOptions);
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body: args,
       failedResponseHandler: llmgatewayFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         LLMGatewayNonStreamChatCompletionResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const _a = args, { messages: rawPrompt } = _a, rawSettings = __objRest(_a, ["messages"]);
     const choice = response.choices[0];
     if (!choice) {
       throw new Error("No choice in response");
     }
     const usageInfo = response.usage ? {
-      promptTokens: (_b = response.usage.prompt_tokens) != null ? _b : 0,
-      completionTokens: (_c = response.usage.completion_tokens) != null ? _c : 0
+      inputTokens: (_a15 = response.usage.prompt_tokens) != null ? _a15 : 0,
+      outputTokens: (_b = response.usage.completion_tokens) != null ? _b : 0,
+      totalTokens: ((_c = response.usage.prompt_tokens) != null ? _c : 0) + ((_d = response.usage.completion_tokens) != null ? _d : 0),
+      reasoningTokens: (_f = (_e = response.usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0,
+      cachedInputTokens: (_h = (_g = response.usage.prompt_tokens_details) == null ? void 0 : _g.cached_tokens) != null ? _h : 0
     } : {
-      promptTokens: 0,
-      completionTokens: 0
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      reasoningTokens: 0,
+      cachedInputTokens: 0
     };
-    const providerMetadata = {};
-    if (response.usage && ((_d = this.settings.usage) == null ? void 0 : _d.include)) {
-      providerMetadata.llmgateway = {
-        usage: {
-          promptTokens: response.usage.prompt_tokens,
-          promptTokensDetails: response.usage.prompt_tokens_details ? {
-            cachedTokens: (_e = response.usage.prompt_tokens_details.cached_tokens) != null ? _e : 0
-          } : void 0,
-          completionTokens: response.usage.completion_tokens,
-          completionTokensDetails: response.usage.completion_tokens_details ? {
-            reasoningTokens: (_f = response.usage.completion_tokens_details.reasoning_tokens) != null ? _f : 0
-          } : void 0,
-          cost: response.usage.cost,
-          totalTokens: (_g = response.usage.total_tokens) != null ? _g : 0
-        }
-      };
-    }
-    const hasProviderMetadata = Object.keys(providerMetadata).length > 0;
-    const reasoningDetails = (_h = choice.message.reasoning_details) != null ? _h : [];
+    const reasoningDetails = (_i = choice.message.reasoning_details) != null ? _i : [];
     const reasoning = reasoningDetails.length > 0 ? reasoningDetails.map((detail) => {
-      var _a2;
       switch (detail.type) {
         case "reasoning.text" /* Text */: {
           if (detail.text) {
             return {
-              type: "text",
-              text: detail.text,
-              signature: (_a2 = detail.signature) != null ? _a2 : void 0
+              type: "reasoning",
+              text: detail.text
             };
           }
           break;
@@ -447,7 +1454,7 @@ var LLMGatewayChatLanguageModel = class {
         case "reasoning.summary" /* Summary */: {
           if (detail.summary) {
             return {
-              type: "text",
+              type: "reasoning",
               text: detail.summary
             };
           }
@@ -456,85 +1463,119 @@ var LLMGatewayChatLanguageModel = class {
         case "reasoning.encrypted" /* Encrypted */: {
           if (detail.data) {
             return {
-              type: "redacted",
-              data: detail.data
+              type: "reasoning",
+              text: "[REDACTED]"
             };
           }
           break;
         }
         default: {
-          detail;
+          const _exhaustiveCheck = detail;
+          return _exhaustiveCheck;
         }
       }
       return null;
     }).filter((p) => p !== null) : choice.message.reasoning ? [
       {
-        type: "text",
+        type: "reasoning",
         text: choice.message.reasoning
       }
     ] : [];
-    return __spreadValues({
-      response: {
-        id: response.id,
-        modelId: response.model
-      },
-      text: (_i = choice.message.content) != null ? _i : void 0,
-      reasoning,
-      toolCalls: (_j = choice.message.tool_calls) == null ? void 0 : _j.map((toolCall) => {
-        var _a2;
-        return {
-          toolCallType: "function",
-          toolCallId: (_a2 = toolCall.id) != null ? _a2 : (0, import_provider_utils3.generateId)(),
+    const content = [];
+    content.push(...reasoning);
+    if (choice.message.content) {
+      content.push({
+        type: "text",
+        text: choice.message.content
+      });
+    }
+    if (choice.message.tool_calls) {
+      for (const toolCall of choice.message.tool_calls) {
+        content.push({
+          type: "tool-call",
+          toolCallId: (_j = toolCall.id) != null ? _j : generateId(),
           toolName: toolCall.function.name,
-          args: toolCall.function.arguments
-        };
-      }),
+          input: toolCall.function.arguments
+        });
+      }
+    }
+    return {
+      content,
       finishReason: mapLLMGatewayFinishReason(choice.finish_reason),
       usage: usageInfo,
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
       warnings: [],
-      logprobs: mapLLMGatewayChatLogProbsOutput(choice.logprobs)
-    }, hasProviderMetadata ? { providerMetadata } : {});
+      providerMetadata: {
+        llmgateway: {
+          usage: {
+            promptTokens: (_k = usageInfo.inputTokens) != null ? _k : 0,
+            completionTokens: (_l = usageInfo.outputTokens) != null ? _l : 0,
+            totalTokens: (_m = usageInfo.totalTokens) != null ? _m : 0,
+            cost: (_n = response.usage) == null ? void 0 : _n.cost,
+            promptTokensDetails: {
+              cachedTokens: (_q = (_p = (_o = response.usage) == null ? void 0 : _o.prompt_tokens_details) == null ? void 0 : _p.cached_tokens) != null ? _q : 0
+            },
+            completionTokensDetails: {
+              reasoningTokens: (_t = (_s = (_r = response.usage) == null ? void 0 : _r.completion_tokens_details) == null ? void 0 : _s.reasoning_tokens) != null ? _t : 0
+            },
+            costDetails: {
+              upstreamInferenceCost: (_w = (_v = (_u = response.usage) == null ? void 0 : _u.cost_details) == null ? void 0 : _v.upstream_inference_cost) != null ? _w : 0
+            }
+          }
+        }
+      },
+      request: { body: args },
+      response: {
+        id: response.id,
+        modelId: response.model,
+        headers: responseHeaders
+      }
+    };
   }
   async doStream(options) {
-    var _a, _c;
-    const args = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    var _a15;
+    const providerOptions = options.providerOptions || {};
+    const llmgatewayOptions = providerOptions.llmgateway || {};
+    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), llmgatewayOptions);
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body: __spreadProps(__spreadValues({}, args), {
         stream: true,
         // only include stream_options when in strict compatibility mode:
         stream_options: this.config.compatibility === "strict" ? __spreadValues({
           include_usage: true
-        }, ((_a = this.settings.usage) == null ? void 0 : _a.include) ? { include_usage: true } : {}) : void 0
+        }, ((_a15 = this.settings.usage) == null ? void 0 : _a15.include) ? { include_usage: true } : {}) : void 0
       }),
       failedResponseHandler: llmgatewayFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         LLMGatewayStreamChatCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const _b = args, { messages: rawPrompt } = _b, rawSettings = __objRest(_b, ["messages"]);
     const toolCalls = [];
     let finishReason = "other";
-    let usage = {
-      promptTokens: Number.NaN,
-      completionTokens: Number.NaN
+    const usage = {
+      inputTokens: Number.NaN,
+      outputTokens: Number.NaN,
+      totalTokens: Number.NaN,
+      reasoningTokens: Number.NaN,
+      cachedInputTokens: Number.NaN
     };
-    let logprobs;
     const llmgatewayUsage = {};
-    const shouldIncludeUsageAccounting = !!((_c = this.settings.usage) == null ? void 0 : _c.include);
+    let textStarted = false;
+    let reasoningStarted = false;
+    let textId;
+    let reasoningId;
+    let llmgatewayResponseId;
     return {
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
-            var _a2, _b2, _c2, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+            var _a16, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -547,6 +1588,7 @@ var LLMGatewayChatLanguageModel = class {
               return;
             }
             if (value.id) {
+              llmgatewayResponseId = value.id;
               controller.enqueue({
                 type: "response-metadata",
                 id: value.id
@@ -559,20 +1601,23 @@ var LLMGatewayChatLanguageModel = class {
               });
             }
             if (value.usage != null) {
-              usage = {
-                promptTokens: value.usage.prompt_tokens,
-                completionTokens: value.usage.completion_tokens
-              };
+              usage.inputTokens = value.usage.prompt_tokens;
+              usage.outputTokens = value.usage.completion_tokens;
+              usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
               llmgatewayUsage.promptTokens = value.usage.prompt_tokens;
               if (value.usage.prompt_tokens_details) {
+                const cachedInputTokens = (_a16 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a16 : 0;
+                usage.cachedInputTokens = cachedInputTokens;
                 llmgatewayUsage.promptTokensDetails = {
-                  cachedTokens: (_a2 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a2 : 0
+                  cachedTokens: cachedInputTokens
                 };
               }
               llmgatewayUsage.completionTokens = value.usage.completion_tokens;
               if (value.usage.completion_tokens_details) {
+                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
+                usage.reasoningTokens = reasoningTokens;
                 llmgatewayUsage.completionTokensDetails = {
-                  reasoningTokens: (_b2 = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b2 : 0
+                  reasoningTokens
                 };
               }
               llmgatewayUsage.cost = value.usage.cost;
@@ -586,51 +1631,39 @@ var LLMGatewayChatLanguageModel = class {
               return;
             }
             const delta = choice.delta;
-            if (delta.content != null) {
-              controller.enqueue({
-                type: "text-delta",
-                textDelta: delta.content
-              });
-            }
-            if (delta.reasoning != null) {
+            const emitReasoningChunk = (chunkText) => {
+              if (!reasoningStarted) {
+                reasoningId = llmgatewayResponseId || generateId();
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: reasoningId
+                });
+                reasoningStarted = true;
+              }
               controller.enqueue({
-                type: "reasoning",
-                textDelta: delta.reasoning
+                type: "reasoning-delta",
+                delta: chunkText,
+                id: reasoningId || generateId()
               });
-            }
+            };
             if (delta.reasoning_details && delta.reasoning_details.length > 0) {
               for (const detail of delta.reasoning_details) {
                 switch (detail.type) {
                   case "reasoning.text" /* Text */: {
                     if (detail.text) {
-                      controller.enqueue({
-                        type: "reasoning",
-                        textDelta: detail.text
-                      });
-                    }
-                    if (detail.signature) {
-                      controller.enqueue({
-                        type: "reasoning-signature",
-                        signature: detail.signature
-                      });
+                      emitReasoningChunk(detail.text);
                     }
                     break;
                   }
                   case "reasoning.encrypted" /* Encrypted */: {
                     if (detail.data) {
-                      controller.enqueue({
-                        type: "redacted-reasoning",
-                        data: detail.data
-                      });
+                      emitReasoningChunk("[REDACTED]");
                     }
                     break;
                   }
                   case "reasoning.summary" /* Summary */: {
                     if (detail.summary) {
-                      controller.enqueue({
-                        type: "reasoning",
-                        textDelta: detail.summary
-                      });
+                      emitReasoningChunk(detail.summary);
                     }
                     break;
                   }
@@ -640,34 +1673,42 @@ var LLMGatewayChatLanguageModel = class {
                   }
                 }
               }
+            } else if (delta.reasoning != null) {
+              emitReasoningChunk(delta.reasoning);
             }
-            const mappedLogprobs = mapLLMGatewayChatLogProbsOutput(
-              choice == null ? void 0 : choice.logprobs
-            );
-            if (mappedLogprobs == null ? void 0 : mappedLogprobs.length) {
-              if (logprobs === void 0) {
-                logprobs = [];
+            if (delta.content != null) {
+              if (!textStarted) {
+                textId = llmgatewayResponseId || generateId();
+                controller.enqueue({
+                  type: "text-start",
+                  id: textId
+                });
+                textStarted = true;
               }
-              logprobs.push(...mappedLogprobs);
+              controller.enqueue({
+                type: "text-delta",
+                delta: delta.content,
+                id: textId || generateId()
+              });
             }
             if (delta.tool_calls != null) {
               for (const toolCallDelta of delta.tool_calls) {
-                const index = toolCallDelta.index;
+                const index = (_c = toolCallDelta.index) != null ? _c : toolCalls.length - 1;
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.type !== "function") {
-                    throw new import_provider.InvalidResponseDataError({
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function' type.`
                     });
                   }
                   if (toolCallDelta.id == null) {
-                    throw new import_provider.InvalidResponseDataError({
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'id' to be a string.`
                     });
                   }
-                  if (((_c2 = toolCallDelta.function) == null ? void 0 : _c2.name) == null) {
-                    throw new import_provider.InvalidResponseDataError({
+                  if (((_d = toolCallDelta.function) == null ? void 0 : _d.name) == null) {
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
                     });
@@ -677,28 +1718,36 @@ var LLMGatewayChatLanguageModel = class {
                     type: "function",
                     function: {
                       name: toolCallDelta.function.name,
-                      arguments: (_d = toolCallDelta.function.arguments) != null ? _d : ""
+                      arguments: (_e = toolCallDelta.function.arguments) != null ? _e : ""
                     },
+                    inputStarted: false,
                     sent: false
                   };
                   const toolCall2 = toolCalls[index];
                   if (toolCall2 == null) {
                     throw new Error("Tool call is missing");
                   }
-                  if (((_e = toolCall2.function) == null ? void 0 : _e.name) != null && ((_f = toolCall2.function) == null ? void 0 : _f.arguments) != null && (0, import_provider_utils3.isParsableJson)(toolCall2.function.arguments)) {
+                  if (((_f = toolCall2.function) == null ? void 0 : _f.name) != null && ((_g = toolCall2.function) == null ? void 0 : _g.arguments) != null && isParsableJson(toolCall2.function.arguments)) {
+                    toolCall2.inputStarted = true;
                     controller.enqueue({
-                      type: "tool-call-delta",
-                      toolCallType: "function",
-                      toolCallId: toolCall2.id,
-                      toolName: toolCall2.function.name,
-                      argsTextDelta: toolCall2.function.arguments
+                      type: "tool-input-start",
+                      id: toolCall2.id,
+                      toolName: toolCall2.function.name
+                    });
+                    controller.enqueue({
+                      type: "tool-input-delta",
+                      id: toolCall2.id,
+                      delta: toolCall2.function.arguments
+                    });
+                    controller.enqueue({
+                      type: "tool-input-end",
+                      id: toolCall2.id
                     });
                     controller.enqueue({
                       type: "tool-call",
-                      toolCallType: "function",
-                      toolCallId: (_g = toolCall2.id) != null ? _g : (0, import_provider_utils3.generateId)(),
+                      toolCallId: toolCall2.id,
                       toolName: toolCall2.function.name,
-                      args: toolCall2.function.arguments
+                      input: toolCall2.function.arguments
                     });
                     toolCall2.sent = true;
                   }
@@ -708,23 +1757,28 @@ var LLMGatewayChatLanguageModel = class {
                 if (toolCall == null) {
                   throw new Error("Tool call is missing");
                 }
+                if (!toolCall.inputStarted) {
+                  toolCall.inputStarted = true;
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCall.id,
+                    toolName: toolCall.function.name
+                  });
+                }
                 if (((_h = toolCallDelta.function) == null ? void 0 : _h.arguments) != null) {
                   toolCall.function.arguments += (_j = (_i = toolCallDelta.function) == null ? void 0 : _i.arguments) != null ? _j : "";
                 }
                 controller.enqueue({
-                  type: "tool-call-delta",
-                  toolCallType: "function",
-                  toolCallId: toolCall.id,
-                  toolName: toolCall.function.name,
-                  argsTextDelta: (_k = toolCallDelta.function.arguments) != null ? _k : ""
+                  type: "tool-input-delta",
+                  id: toolCall.id,
+                  delta: (_k = toolCallDelta.function.arguments) != null ? _k : ""
                 });
-                if (((_l = toolCall.function) == null ? void 0 : _l.name) != null && ((_m = toolCall.function) == null ? void 0 : _m.arguments) != null && (0, import_provider_utils3.isParsableJson)(toolCall.function.arguments)) {
+                if (((_l = toolCall.function) == null ? void 0 : _l.name) != null && ((_m = toolCall.function) == null ? void 0 : _m.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallType: "function",
-                    toolCallId: (_n = toolCall.id) != null ? _n : (0, import_provider_utils3.generateId)(),
+                    toolCallId: (_n = toolCall.id) != null ? _n : generateId(),
                     toolName: toolCall.function.name,
-                    args: toolCall.function.arguments
+                    input: toolCall.function.arguments
                   });
                   toolCall.sent = true;
                 }
@@ -732,198 +1786,54 @@ var LLMGatewayChatLanguageModel = class {
             }
           },
           flush(controller) {
-            var _a2;
+            var _a16;
             if (finishReason === "tool-calls") {
               for (const toolCall of toolCalls) {
-                if (!toolCall.sent) {
+                if (toolCall && !toolCall.sent) {
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallType: "function",
-                    toolCallId: (_a2 = toolCall.id) != null ? _a2 : (0, import_provider_utils3.generateId)(),
+                    toolCallId: (_a16 = toolCall.id) != null ? _a16 : generateId(),
                     toolName: toolCall.function.name,
                     // Coerce invalid arguments to an empty JSON object
-                    args: (0, import_provider_utils3.isParsableJson)(toolCall.function.arguments) ? toolCall.function.arguments : "{}"
+                    input: isParsableJson(toolCall.function.arguments) ? toolCall.function.arguments : "{}"
                   });
                   toolCall.sent = true;
                 }
               }
             }
-            const providerMetadata = {};
-            if (shouldIncludeUsageAccounting && (llmgatewayUsage.totalTokens !== void 0 || llmgatewayUsage.cost !== void 0 || llmgatewayUsage.promptTokensDetails !== void 0 || llmgatewayUsage.completionTokensDetails !== void 0)) {
-              providerMetadata.llmgateway = {
-                usage: llmgatewayUsage
-              };
+            if (textStarted) {
+              controller.enqueue({
+                type: "text-end",
+                id: textId || generateId()
+              });
+            }
+            if (reasoningStarted) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: reasoningId || generateId()
+              });
             }
-            const hasProviderMetadata = Object.keys(providerMetadata).length > 0 && shouldIncludeUsageAccounting;
-            controller.enqueue(__spreadValues({
+            controller.enqueue({
               type: "finish",
               finishReason,
-              logprobs,
-              usage
-            }, hasProviderMetadata ? { providerMetadata } : {}));
+              usage,
+              providerMetadata: {
+                llmgateway: {
+                  usage: llmgatewayUsage
+                }
+              }
+            });
           }
         })
       ),
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
-      warnings: []
+      warnings: [],
+      request: { body: args },
+      response: { headers: responseHeaders }
     };
   }
 };
-var LLMGatewayChatCompletionBaseResponseSchema = import_zod3.z.object({
-  id: import_zod3.z.string().optional(),
-  model: import_zod3.z.string().optional(),
-  usage: import_zod3.z.object({
-    prompt_tokens: import_zod3.z.number(),
-    prompt_tokens_details: import_zod3.z.object({
-      cached_tokens: import_zod3.z.number()
-    }).nullish(),
-    completion_tokens: import_zod3.z.number(),
-    completion_tokens_details: import_zod3.z.object({
-      reasoning_tokens: import_zod3.z.number()
-    }).nullish(),
-    total_tokens: import_zod3.z.number(),
-    cost: import_zod3.z.number().optional()
-  }).nullish()
-});
-var LLMGatewayNonStreamChatCompletionResponseSchema = LLMGatewayChatCompletionBaseResponseSchema.extend({
-  choices: import_zod3.z.array(
-    import_zod3.z.object({
-      message: import_zod3.z.object({
-        role: import_zod3.z.literal("assistant"),
-        content: import_zod3.z.string().nullable().optional(),
-        reasoning: import_zod3.z.string().nullable().optional(),
-        reasoning_details: ReasoningDetailArraySchema.nullish(),
-        tool_calls: import_zod3.z.array(
-          import_zod3.z.object({
-            id: import_zod3.z.string().optional().nullable(),
-            type: import_zod3.z.literal("function"),
-            function: import_zod3.z.object({
-              name: import_zod3.z.string(),
-              arguments: import_zod3.z.string()
-            })
-          })
-        ).optional()
-      }),
-      index: import_zod3.z.number(),
-      logprobs: import_zod3.z.object({
-        content: import_zod3.z.array(
-          import_zod3.z.object({
-            token: import_zod3.z.string(),
-            logprob: import_zod3.z.number(),
-            top_logprobs: import_zod3.z.array(
-              import_zod3.z.object({
-                token: import_zod3.z.string(),
-                logprob: import_zod3.z.number()
-              })
-            )
-          })
-        ).nullable()
-      }).nullable().optional(),
-      finish_reason: import_zod3.z.string().optional().nullable()
-    })
-  )
-});
-var LLMGatewayStreamChatCompletionChunkSchema = import_zod3.z.union([
-  LLMGatewayChatCompletionBaseResponseSchema.extend({
-    choices: import_zod3.z.array(
-      import_zod3.z.object({
-        delta: import_zod3.z.object({
-          role: import_zod3.z.enum(["assistant"]).optional(),
-          content: import_zod3.z.string().nullish(),
-          reasoning: import_zod3.z.string().nullish().optional(),
-          reasoning_details: ReasoningDetailArraySchema.nullish(),
-          tool_calls: import_zod3.z.array(
-            import_zod3.z.object({
-              index: import_zod3.z.number(),
-              id: import_zod3.z.string().nullish(),
-              type: import_zod3.z.literal("function").optional(),
-              function: import_zod3.z.object({
-                name: import_zod3.z.string().nullish(),
-                arguments: import_zod3.z.string().nullish()
-              })
-            })
-          ).nullish()
-        }).nullish(),
-        logprobs: import_zod3.z.object({
-          content: import_zod3.z.array(
-            import_zod3.z.object({
-              token: import_zod3.z.string(),
-              logprob: import_zod3.z.number(),
-              top_logprobs: import_zod3.z.array(
-                import_zod3.z.object({
-                  token: import_zod3.z.string(),
-                  logprob: import_zod3.z.number()
-                })
-              )
-            })
-          ).nullable()
-        }).nullish(),
-        finish_reason: import_zod3.z.string().nullable().optional(),
-        index: import_zod3.z.number()
-      })
-    )
-  }),
-  LLMGatewayErrorResponseSchema
-]);
-function prepareToolsAndToolChoice(mode) {
-  var _a;
-  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
-  if (tools == null) {
-    return { tools: void 0, tool_choice: void 0 };
-  }
-  const mappedTools = tools.map((tool) => {
-    if (isFunctionTool(tool)) {
-      return {
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters
-        }
-      };
-    }
-    return {
-      type: "function",
-      function: {
-        name: tool.name
-      }
-    };
-  });
-  const toolChoice = mode.toolChoice;
-  if (toolChoice == null) {
-    return { tools: mappedTools, tool_choice: void 0 };
-  }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-    case "none":
-    case "required":
-      return { tools: mappedTools, tool_choice: type };
-    case "tool":
-      return {
-        tools: mappedTools,
-        tool_choice: {
-          type: "function",
-          function: {
-            name: toolChoice.toolName
-          }
-        }
-      };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new Error(`Unsupported tool choice type: ${_exhaustiveCheck}`);
-    }
-  }
-}
-
-// src/llmgateway-completion-language-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_zod4 = require("zod");
 
-// src/convert-to-llmgateway-completion-prompt.ts
-var import_provider2 = require("@ai-sdk/provider");
+// src/completion/convert-to-llmgateway-completion-prompt.ts
 function convertToLLMGatewayCompletionPrompt({
   prompt,
   inputFormat,
@@ -943,8 +1853,8 @@ function convertToLLMGatewayCompletionPrompt({
   for (const { role, content } of prompt) {
     switch (role) {
       case "system": {
-        throw new import_provider2.InvalidPromptError({
-          message: "Unexpected system message in prompt: ${content}",
+        throw new InvalidPromptError({
+          message: `Unexpected system message in prompt: ${content}`,
           prompt
         });
       }
@@ -954,21 +1864,13 @@ function convertToLLMGatewayCompletionPrompt({
             case "text": {
               return part.text;
             }
-            case "image": {
-              throw new import_provider2.UnsupportedFunctionalityError({
-                functionality: "images"
-              });
-            }
             case "file": {
-              throw new import_provider2.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError({
                 functionality: "file attachments"
               });
             }
             default: {
-              const _exhaustiveCheck = part;
-              throw new Error(
-                `Unsupported content type: ${_exhaustiveCheck}`
-              );
+              return "";
             }
           }
         }).join("");
@@ -979,39 +1881,38 @@ ${userMessage}
         break;
       }
       case "assistant": {
-        const assistantMessage = content.map((part) => {
-          switch (part.type) {
-            case "text": {
-              return part.text;
-            }
-            case "tool-call": {
-              throw new import_provider2.UnsupportedFunctionalityError({
-                functionality: "tool-call messages"
-              });
-            }
-            case "reasoning": {
-              throw new import_provider2.UnsupportedFunctionalityError({
-                functionality: "reasoning messages"
-              });
-            }
-            case "redacted-reasoning": {
-              throw new import_provider2.UnsupportedFunctionalityError({
-                functionality: "redacted reasoning messages"
-              });
-            }
-            case "file": {
-              throw new import_provider2.UnsupportedFunctionalityError({
-                functionality: "file attachments"
-              });
-            }
-            default: {
-              const _exhaustiveCheck = part;
-              throw new Error(
-                `Unsupported content type: ${_exhaustiveCheck}`
-              );
+        const assistantMessage = content.map(
+          (part) => {
+            switch (part.type) {
+              case "text": {
+                return part.text;
+              }
+              case "tool-call": {
+                throw new UnsupportedFunctionalityError({
+                  functionality: "tool-call messages"
+                });
+              }
+              case "tool-result": {
+                throw new UnsupportedFunctionalityError({
+                  functionality: "tool-result messages"
+                });
+              }
+              case "reasoning": {
+                throw new UnsupportedFunctionalityError({
+                  functionality: "reasoning messages"
+                });
+              }
+              case "file": {
+                throw new UnsupportedFunctionalityError({
+                  functionality: "file attachments"
+                });
+              }
+              default: {
+                return "";
+              }
             }
           }
-        }).join("");
+        ).join("");
         text += `${assistant}:
 ${assistantMessage}
 
@@ -1019,13 +1920,12 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new import_provider2.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError({
           functionality: "tool messages"
         });
       }
       default: {
-        const _exhaustiveCheck = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+        break;
       }
     }
   }
@@ -1036,40 +1936,63 @@ ${assistantMessage}
   };
 }
 
-// src/map-llmgateway-completion-logprobs.ts
-function mapLLMGatewayCompletionLogprobs(logprobs) {
-  return logprobs == null ? void 0 : logprobs.tokens.map((token, index) => {
-    var _a, _b;
-    return {
-      token,
-      logprob: (_a = logprobs.token_logprobs[index]) != null ? _a : 0,
-      topLogprobs: logprobs.top_logprobs ? Object.entries((_b = logprobs.top_logprobs[index]) != null ? _b : {}).map(
-        ([token2, logprob]) => ({
-          token: token2,
-          logprob
-        })
-      ) : []
-    };
-  });
-}
+// src/completion/schemas.ts
+var import_v45 = require("zod/v4");
+var LLMGatewayCompletionChunkSchema = import_v45.z.union([
+  import_v45.z.object({
+    id: import_v45.z.string().optional(),
+    model: import_v45.z.string().optional(),
+    choices: import_v45.z.array(
+      import_v45.z.object({
+        text: import_v45.z.string(),
+        reasoning: import_v45.z.string().nullish().optional(),
+        reasoning_details: ReasoningDetailArraySchema.nullish(),
+        finish_reason: import_v45.z.string().nullish(),
+        index: import_v45.z.number().nullish(),
+        logprobs: import_v45.z.object({
+          tokens: import_v45.z.array(import_v45.z.string()),
+          token_logprobs: import_v45.z.array(import_v45.z.number()),
+          top_logprobs: import_v45.z.array(import_v45.z.record(import_v45.z.string(), import_v45.z.number())).nullable()
+        }).nullable().optional()
+      })
+    ),
+    usage: import_v45.z.object({
+      prompt_tokens: import_v45.z.number(),
+      prompt_tokens_details: import_v45.z.object({
+        cached_tokens: import_v45.z.number()
+      }).nullish(),
+      completion_tokens: import_v45.z.number(),
+      completion_tokens_details: import_v45.z.object({
+        reasoning_tokens: import_v45.z.number()
+      }).nullish(),
+      total_tokens: import_v45.z.number(),
+      cost: import_v45.z.number().optional()
+    }).nullish()
+  }),
+  LLMGatewayErrorResponseSchema
+]);
 
-// src/llmgateway-completion-language-model.ts
+// src/completion/index.ts
 var LLMGatewayCompletionLanguageModel = class {
   constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
+    this.provider = "llmgateway";
+    this.supportedUrls = {
+      "image/*": [
+        /^data:image\/[a-zA-Z]+;base64,/,
+        /^https?:\/\/.+\.(jpg|jpeg|png|gif|webp)$/i
+      ],
+      "text/*": [/^data:text\//, /^https?:\/\/.+$/],
+      "application/*": [/^data:application\//, /^https?:\/\/.+$/]
+    };
     this.defaultObjectGenerationMode = void 0;
     this.modelId = modelId;
     this.settings = settings;
     this.config = config;
   }
-  get provider() {
-    return this.config.provider;
-  }
   getArgs({
-    mode,
-    inputFormat,
     prompt,
-    maxTokens,
+    maxOutputTokens,
     temperature,
     topP,
     frequencyPenalty,
@@ -1078,16 +2001,24 @@ var LLMGatewayCompletionLanguageModel = class {
     responseFormat,
     topK,
     stopSequences,
-    providerMetadata
+    tools,
+    toolChoice
   }) {
-    var _a, _b;
-    const type = mode.type;
-    const extraCallingBody = (_a = providerMetadata == null ? void 0 : providerMetadata.llmgateway) != null ? _a : {};
     const { prompt: completionPrompt } = convertToLLMGatewayCompletionPrompt({
       prompt,
-      inputFormat
+      inputFormat: "prompt"
     });
-    const baseArgs = __spreadValues(__spreadValues(__spreadValues({
+    if (tools == null ? void 0 : tools.length) {
+      throw new UnsupportedFunctionalityError({
+        functionality: "tools"
+      });
+    }
+    if (toolChoice) {
+      throw new UnsupportedFunctionalityError({
+        functionality: "toolChoice"
+      });
+    }
+    return __spreadValues(__spreadValues({
       // model id:
       model: this.modelId,
       models: this.settings.models,
@@ -1097,7 +2028,7 @@ var LLMGatewayCompletionLanguageModel = class {
       suffix: this.settings.suffix,
       user: this.settings.user,
       // standardized settings:
-      max_tokens: maxTokens,
+      max_tokens: maxOutputTokens,
       temperature,
       top_p: topP,
       frequency_penalty: frequencyPenalty,
@@ -1107,59 +2038,31 @@ var LLMGatewayCompletionLanguageModel = class {
       response_format: responseFormat,
       top_k: topK,
       // prompt:
-      prompt: completionPrompt
-    }, this.config.extraBody), this.settings.extraBody), extraCallingBody);
-    switch (type) {
-      case "regular": {
-        if ((_b = mode.tools) == null ? void 0 : _b.length) {
-          throw new import_provider3.UnsupportedFunctionalityError({
-            functionality: "tools"
-          });
-        }
-        if (mode.toolChoice) {
-          throw new import_provider3.UnsupportedFunctionalityError({
-            functionality: "toolChoice"
-          });
-        }
-        return baseArgs;
-      }
-      case "object-json": {
-        throw new import_provider3.UnsupportedFunctionalityError({
-          functionality: "object-json mode"
-        });
-      }
-      case "object-tool": {
-        throw new import_provider3.UnsupportedFunctionalityError({
-          functionality: "object-tool mode"
-        });
-      }
-      // Handle all non-text types with a single default case
-      default: {
-        const _exhaustiveCheck = type;
-        throw new import_provider3.UnsupportedFunctionalityError({
-          functionality: `${_exhaustiveCheck} mode`
-        });
-      }
-    }
+      prompt: completionPrompt,
+      // LLMGateway specific settings:
+      include_reasoning: this.settings.includeReasoning,
+      reasoning: this.settings.reasoning
+    }, this.config.extraBody), this.settings.extraBody);
   }
   async doGenerate(options) {
-    var _b, _c, _d, _e, _f;
-    const args = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
+    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+    const providerOptions = options.providerOptions || {};
+    const llmgatewayOptions = providerOptions.llmgateway || {};
+    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), llmgatewayOptions);
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body: args,
       failedResponseHandler: llmgatewayFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         LLMGatewayCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const _a = args, { prompt: rawPrompt } = _a, rawSettings = __objRest(_a, ["prompt"]);
     if ("error" in response) {
       throw new Error(`${response.error.message}`);
     }
@@ -1168,54 +2071,62 @@ var LLMGatewayCompletionLanguageModel = class {
       throw new Error("No choice in LLMGateway completion response");
     }
     return {
-      response: {
-        id: response.id,
-        modelId: response.model
-      },
-      text: (_b = choice.text) != null ? _b : "",
-      reasoning: choice.reasoning || void 0,
+      content: [
+        {
+          type: "text",
+          text: (_a15 = choice.text) != null ? _a15 : ""
+        }
+      ],
+      finishReason: mapLLMGatewayFinishReason(choice.finish_reason),
       usage: {
-        promptTokens: (_d = (_c = response.usage) == null ? void 0 : _c.prompt_tokens) != null ? _d : 0,
-        completionTokens: (_f = (_e = response.usage) == null ? void 0 : _e.completion_tokens) != null ? _f : 0
+        inputTokens: (_c = (_b = response.usage) == null ? void 0 : _b.prompt_tokens) != null ? _c : 0,
+        outputTokens: (_e = (_d = response.usage) == null ? void 0 : _d.completion_tokens) != null ? _e : 0,
+        totalTokens: ((_g = (_f = response.usage) == null ? void 0 : _f.prompt_tokens) != null ? _g : 0) + ((_i = (_h = response.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : 0),
+        reasoningTokens: (_l = (_k = (_j = response.usage) == null ? void 0 : _j.completion_tokens_details) == null ? void 0 : _k.reasoning_tokens) != null ? _l : 0,
+        cachedInputTokens: (_o = (_n = (_m = response.usage) == null ? void 0 : _m.prompt_tokens_details) == null ? void 0 : _n.cached_tokens) != null ? _o : 0
       },
-      finishReason: mapLLMGatewayFinishReason(choice.finish_reason),
-      logprobs: mapLLMGatewayCompletionLogprobs(choice.logprobs),
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
-      warnings: []
+      warnings: [],
+      response: {
+        headers: responseHeaders
+      }
     };
   }
   async doStream(options) {
-    const args = this.getArgs(options);
-    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
+    const providerOptions = options.providerOptions || {};
+    const llmgatewayOptions = providerOptions.llmgateway || {};
+    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), llmgatewayOptions);
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), options.headers),
-      body: __spreadProps(__spreadValues({}, this.getArgs(options)), {
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: __spreadProps(__spreadValues({}, args), {
         stream: true,
         // only include stream_options when in strict compatibility mode:
         stream_options: this.config.compatibility === "strict" ? { include_usage: true } : void 0
       }),
       failedResponseHandler: llmgatewayFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         LLMGatewayCompletionChunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const _a = args, { prompt: rawPrompt } = _a, rawSettings = __objRest(_a, ["prompt"]);
     let finishReason = "other";
-    let usage = {
-      promptTokens: Number.NaN,
-      completionTokens: Number.NaN
+    const usage = {
+      inputTokens: Number.NaN,
+      outputTokens: Number.NaN,
+      totalTokens: Number.NaN,
+      reasoningTokens: Number.NaN,
+      cachedInputTokens: Number.NaN
     };
-    let logprobs;
+    const llmgatewayUsage = {};
     return {
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
+            var _a15, _b;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -1228,10 +2139,27 @@ var LLMGatewayCompletionLanguageModel = class {
               return;
             }
             if (value.usage != null) {
-              usage = {
-                promptTokens: value.usage.prompt_tokens,
-                completionTokens: value.usage.completion_tokens
-              };
+              usage.inputTokens = value.usage.prompt_tokens;
+              usage.outputTokens = value.usage.completion_tokens;
+              usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
+              llmgatewayUsage.promptTokens = value.usage.prompt_tokens;
+              if (value.usage.prompt_tokens_details) {
+                const cachedInputTokens = (_a15 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a15 : 0;
+                usage.cachedInputTokens = cachedInputTokens;
+                llmgatewayUsage.promptTokensDetails = {
+                  cachedTokens: cachedInputTokens
+                };
+              }
+              llmgatewayUsage.completionTokens = value.usage.completion_tokens;
+              if (value.usage.completion_tokens_details) {
+                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
+                usage.reasoningTokens = reasoningTokens;
+                llmgatewayUsage.completionTokensDetails = {
+                  reasoningTokens
+                };
+              }
+              llmgatewayUsage.cost = value.usage.cost;
+              llmgatewayUsage.totalTokens = value.usage.total_tokens;
             }
             const choice = value.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
@@ -1240,69 +2168,40 @@ var LLMGatewayCompletionLanguageModel = class {
             if ((choice == null ? void 0 : choice.text) != null) {
               controller.enqueue({
                 type: "text-delta",
-                textDelta: choice.text
+                delta: choice.text,
+                id: generateId()
               });
             }
-            const mappedLogprobs = mapLLMGatewayCompletionLogprobs(
-              choice == null ? void 0 : choice.logprobs
-            );
-            if (mappedLogprobs == null ? void 0 : mappedLogprobs.length) {
-              if (logprobs === void 0) {
-                logprobs = [];
-              }
-              logprobs.push(...mappedLogprobs);
-            }
           },
           flush(controller) {
             controller.enqueue({
               type: "finish",
               finishReason,
-              logprobs,
-              usage
+              usage,
+              providerMetadata: {
+                llmgateway: {
+                  usage: llmgatewayUsage
+                }
+              }
             });
           }
         })
       ),
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
-      warnings: []
+      response: {
+        headers: responseHeaders
+      }
     };
   }
 };
-var LLMGatewayCompletionChunkSchema = import_zod4.z.union([
-  import_zod4.z.object({
-    id: import_zod4.z.string().optional(),
-    model: import_zod4.z.string().optional(),
-    choices: import_zod4.z.array(
-      import_zod4.z.object({
-        text: import_zod4.z.string(),
-        reasoning: import_zod4.z.string().nullish().optional(),
-        reasoning_details: ReasoningDetailArraySchema.nullish(),
-        finish_reason: import_zod4.z.string().nullish(),
-        index: import_zod4.z.number(),
-        logprobs: import_zod4.z.object({
-          tokens: import_zod4.z.array(import_zod4.z.string()),
-          token_logprobs: import_zod4.z.array(import_zod4.z.number()),
-          top_logprobs: import_zod4.z.array(import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number())).nullable()
-        }).nullable().optional()
-      })
-    ),
-    usage: import_zod4.z.object({
-      prompt_tokens: import_zod4.z.number(),
-      completion_tokens: import_zod4.z.number()
-    }).optional().nullable()
-  }),
-  LLMGatewayErrorResponseSchema
-]);
 
-// src/llmgateway-facade.ts
+// src/facade.ts
 var LLMGateway = class {
   /**
    * Creates a new LLMGateway provider instance.
    */
   constructor(options = {}) {
-    var _a, _b;
-    this.baseURL = (_b = (0, import_provider_utils5.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : options.baseURL)) != null ? _b : "https://api.llmgateway.io/v1";
+    var _a15, _b;
+    this.baseURL = (_b = withoutTrailingSlash((_a15 = options.baseURL) != null ? _a15 : options.baseUrl)) != null ? _b : "https://api.llmgateway.io/v1";
     this.apiKey = options.apiKey;
     this.headers = options.headers;
   }
@@ -1310,9 +2209,9 @@ var LLMGateway = class {
     return {
       baseURL: this.baseURL,
       headers: () => __spreadValues({
-        Authorization: `Bearer ${(0, import_provider_utils5.loadApiKey)({
+        Authorization: `Bearer ${loadApiKey({
           apiKey: this.apiKey,
-          environmentVariableName: "LLMGATEWAY_API_KEY",
+          environmentVariableName: "LLM_GATEWAY_API_KEY",
           description: "LLMGateway"
         })}`
       }, this.headers)
@@ -1336,16 +2235,15 @@ var LLMGateway = class {
   }
 };
 
-// src/llmgateway-provider.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+// src/provider.ts
 function createLLMGateway(options = {}) {
-  var _a, _b, _c;
-  const baseURL = (_b = (0, import_provider_utils6.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : options.baseURL)) != null ? _b : "https://api.llmgateway.io/v1";
+  var _a15, _b, _c;
+  const baseURL = (_b = withoutTrailingSlash((_a15 = options.baseURL) != null ? _a15 : options.baseUrl)) != null ? _b : "https://api.llmgateway.io/v1";
   const compatibility = (_c = options.compatibility) != null ? _c : "compatible";
   const getHeaders = () => __spreadValues({
-    Authorization: `Bearer ${(0, import_provider_utils6.loadApiKey)({
+    Authorization: `Bearer ${loadApiKey({
       apiKey: options.apiKey,
-      environmentVariableName: "LLMGATEWAY_API_KEY",
+      environmentVariableName: "LLM_GATEWAY_API_KEY",
       description: "LLMGateway"
     })}`
   }, options.headers);