@openrouter/ai-sdk-provider 0.7.2 → 1.0.0-beta.1

package/dist/internal/index.mjs

@@ -17,21 +17,830 @@ 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];
+
+// 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;
+_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;
+
+// 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.2_zod@3.25.74/node_modules/@ai-sdk/provider-utils/dist/index.mjs
+import * as z4 from "zod/v4";
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.74/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.74/node_modules/zod-to-json-schema/dist/esm/selectParser.js
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod";
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.74/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+import { ZodFirstPartyTypeKind } from "zod";
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.74/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2 } from "zod";
+
+// node_modules/.pnpm/zod-to-json-schema@3.24.5_zod@3.25.74/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.74/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+import { ZodOptional } from "zod";
+
+// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.0-beta.2_zod@3.25.74/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 === "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)
+  );
+}
+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;
     }
-  return target;
+    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 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);
+}
 
 // src/schemas/reasoning-details.ts
-import { z } from "zod";
+import { z } from "zod/v4";
 var ReasoningDetailSummarySchema = z.object({
   type: z.literal("reasoning.summary" /* Summary */),
   summary: z.string()
@@ -56,56 +865,79 @@ var ReasoningDetailsWithUnknownSchema = z.union([
 ]);
 var ReasoningDetailArraySchema = z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
 
-// src/openrouter-chat-language-model.ts
-import {
-  InvalidResponseDataError,
-  UnsupportedFunctionalityError
-} from "@ai-sdk/provider";
-import {
-  combineHeaders,
-  createEventSourceResponseHandler,
-  createJsonResponseHandler,
-  generateId,
-  isParsableJson,
-  postJsonToApi
-} from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod";
+// src/schemas/error-response.ts
+import { z as z2 } from "zod/v4";
+var OpenRouterErrorResponseSchema = z2.object({
+  error: z2.object({
+    code: z2.union([z2.string(), z2.number()]).nullable(),
+    message: z2.string(),
+    type: z2.string().nullable(),
+    param: z2.any().nullable()
+  })
+});
+var openrouterFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: OpenRouterErrorResponseSchema,
+  errorToMessage: (data) => data.error.message
+});
 
-// src/convert-to-openrouter-chat-messages.ts
-import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
+// src/utils/map-finish-reason.ts
+function mapOpenRouterFinishReason(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/convert-to-openrouter-chat-messages.ts
 function getCacheControl(providerMetadata) {
-  var _a, _b, _c;
+  var _a15, _b, _c;
   const anthropic = providerMetadata == null ? void 0 : providerMetadata.anthropic;
   const openrouter = providerMetadata == null ? void 0 : providerMetadata.openrouter;
-  return (_c = (_b = (_a = openrouter == null ? void 0 : openrouter.cacheControl) != null ? _a : openrouter == null ? void 0 : openrouter.cache_control) != null ? _b : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
+  return (_c = (_b = (_a15 = openrouter == null ? void 0 : openrouter.cacheControl) != null ? _a15 : openrouter == null ? void 0 : openrouter.cache_control) != null ? _b : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
 }
 function convertToOpenRouterChatMessages(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, _g;
+            const cacheControl = (_a16 = getCacheControl(part.providerOptions)) != null ? _a16 : messageCacheControl;
             switch (part.type) {
               case "text":
                 return {
@@ -114,33 +946,35 @@ function convertToOpenRouterChatMessages(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,${convertUint8ArrayToBase64(
-                      part.image
-                    )}`
-                  },
-                  // For image parts, use part-specific or message-level cache control
-                  cache_control: cacheControl
-                };
               case "file":
+                if ((_b2 = part.mediaType) == null ? void 0 : _b2.startsWith("image/")) {
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${(_c2 = part.mediaType) != null ? _c2 : "image/jpeg"};base64,${convertUint8ArrayToBase64(
+                        part.data instanceof Uint8Array ? part.data : new Uint8Array()
+                      )}`
+                    },
+                    // For image parts, use part-specific or message-level cache control
+                    cache_control: cacheControl
+                  };
+                }
                 return {
                   type: "file",
                   file: {
                     filename: String(
-                      (_d = (_c2 = part.providerMetadata) == null ? void 0 : _c2.openrouter) == null ? void 0 : _d.filename
+                      (_g = (_f = (_e = (_d = part.providerOptions) == null ? void 0 : _d.openrouter) == null ? void 0 : _e.filename) != null ? _f : part.filename) != null ? _g : ""
                     ),
-                    file_data: part.data instanceof Uint8Array ? `data:${part.mimeType};base64,${convertUint8ArrayToBase64(part.data)}` : `data:${part.mimeType};base64,${part.data}`
+                    file_data: part.data instanceof Uint8Array ? `data:${part.mediaType};base64,${convertUint8ArrayToBase64(part.data)}` : `data:${part.mediaType};base64,${part.data}`
                   },
                   cache_control: cacheControl
                 };
               default: {
-                const _exhaustiveCheck = part;
-                throw new Error(
-                  `Unsupported content part type: ${_exhaustiveCheck}`
-                );
+                return {
+                  type: "text",
+                  text: "",
+                  cache_control: cacheControl
+                };
               }
             }
           }
@@ -168,7 +1002,7 @@ function convertToOpenRouterChatMessages(prompt) {
                 type: "function",
                 function: {
                   name: part.toolName,
-                  arguments: JSON.stringify(part.args)
+                  arguments: JSON.stringify(part.input)
                 }
               });
               break;
@@ -177,23 +1011,14 @@ function convertToOpenRouterChatMessages(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;
             }
           }
         }
@@ -203,95 +1028,185 @@ function convertToOpenRouterChatMessages(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-openrouter-chat-logprobs.ts
-function mapOpenRouterChatLogProbsOutput(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-openrouter-finish-reason.ts
-function mapOpenRouterFinishReason(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
+import { z as z3 } from "zod/v4";
+var ChatCompletionToolChoiceSchema = z3.union([
+  z3.literal("auto"),
+  z3.literal("none"),
+  z3.literal("required"),
+  z3.object({
+    type: z3.literal("function"),
+    function: z3.object({
+      name: z3.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/openrouter-error.ts
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod";
-var OpenRouterErrorResponseSchema = z2.object({
-  error: z2.object({
-    code: z2.union([z2.string(), z2.number()]).nullable(),
-    message: z2.string(),
-    type: z2.string().nullable(),
-    param: z2.any().nullable()
-  })
+// src/chat/schemas.ts
+import { z as z5 } from "zod/v4";
+var OpenRouterChatCompletionBaseResponseSchema = z5.object({
+  id: z5.string().optional(),
+  model: z5.string().optional(),
+  usage: z5.object({
+    prompt_tokens: z5.number(),
+    prompt_tokens_details: z5.object({
+      cached_tokens: z5.number()
+    }).nullish(),
+    completion_tokens: z5.number(),
+    completion_tokens_details: z5.object({
+      reasoning_tokens: z5.number()
+    }).nullish(),
+    total_tokens: z5.number(),
+    cost: z5.number().optional()
+  }).nullish()
 });
-var openrouterFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: OpenRouterErrorResponseSchema,
-  errorToMessage: (data) => data.error.message
+var OpenRouterNonStreamChatCompletionResponseSchema = OpenRouterChatCompletionBaseResponseSchema.extend({
+  choices: z5.array(
+    z5.object({
+      message: z5.object({
+        role: z5.literal("assistant"),
+        content: z5.string().nullable().optional(),
+        reasoning: z5.string().nullable().optional(),
+        reasoning_details: ReasoningDetailArraySchema.nullish(),
+        tool_calls: z5.array(
+          z5.object({
+            id: z5.string().optional().nullable(),
+            type: z5.literal("function"),
+            function: z5.object({
+              name: z5.string(),
+              arguments: z5.string()
+            })
+          })
+        ).optional()
+      }),
+      index: z5.number().nullish(),
+      logprobs: z5.object({
+        content: z5.array(
+          z5.object({
+            token: z5.string(),
+            logprob: z5.number(),
+            top_logprobs: z5.array(
+              z5.object({
+                token: z5.string(),
+                logprob: z5.number()
+              })
+            )
+          })
+        ).nullable()
+      }).nullable().optional(),
+      finish_reason: z5.string().optional().nullable()
+    })
+  )
 });
+var OpenRouterStreamChatCompletionChunkSchema = z5.union([
+  OpenRouterChatCompletionBaseResponseSchema.extend({
+    choices: z5.array(
+      z5.object({
+        delta: z5.object({
+          role: z5.enum(["assistant"]).optional(),
+          content: z5.string().nullish(),
+          reasoning: z5.string().nullish().optional(),
+          reasoning_details: ReasoningDetailArraySchema.nullish(),
+          tool_calls: z5.array(
+            z5.object({
+              index: z5.number().nullish(),
+              id: z5.string().nullish(),
+              type: z5.literal("function").optional(),
+              function: z5.object({
+                name: z5.string().nullish(),
+                arguments: z5.string().nullish()
+              })
+            })
+          ).nullish()
+        }).nullish(),
+        logprobs: z5.object({
+          content: z5.array(
+            z5.object({
+              token: z5.string(),
+              logprob: z5.number(),
+              top_logprobs: z5.array(
+                z5.object({
+                  token: z5.string(),
+                  logprob: z5.number()
+                })
+              )
+            })
+          ).nullable()
+        }).nullish(),
+        finish_reason: z5.string().nullable().optional(),
+        index: z5.number().nullish()
+      })
+    )
+  }),
+  OpenRouterErrorResponseSchema
+]);
 
-// src/openrouter-chat-language-model.ts
-function isFunctionTool(tool) {
-  return "parameters" in tool;
-}
+// src/chat/index.ts
 var OpenRouterChatLanguageModel = class {
   constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
+    this.provider = "openrouter";
     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,
@@ -300,12 +1215,10 @@ var OpenRouterChatLanguageModel = class {
     stopSequences,
     responseFormat,
     topK,
-    providerMetadata
+    tools,
+    toolChoice
   }) {
-    var _a;
-    const type = mode.type;
-    const extraCallingBody = (_a = providerMetadata == null ? void 0 : providerMetadata.openrouter) != null ? _a : {};
-    const baseArgs = __spreadValues(__spreadValues(__spreadValues({
+    const baseArgs = __spreadValues(__spreadValues({
       // model id:
       model: this.modelId,
       models: this.settings.models,
@@ -316,7 +1229,7 @@ var OpenRouterChatLanguageModel = 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,
@@ -331,44 +1244,34 @@ var OpenRouterChatLanguageModel = 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 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 postJsonToApi({
+    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
+    const providerOptions = options.providerOptions || {};
+    const openrouterOptions = providerOptions.openrouter || {};
+    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
@@ -382,46 +1285,33 @@ var OpenRouterChatLanguageModel = class {
       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.openrouter = {
-        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 reasoning = reasoningDetails.length > 0 ? reasoningDetails.map((detail) => {
-      var _a2;
+    const reasoningDetails = (_i = choice.message.reasoning_details) != null ? _i : [];
+    reasoningDetails.length > 0 ? reasoningDetails.map((detail) => {
+      var _a16;
       switch (detail.type) {
         case "reasoning.text" /* Text */: {
           if (detail.text) {
             return {
               type: "text",
               text: detail.text,
-              signature: (_a2 = detail.signature) != null ? _a2 : void 0
+              signature: (_a16 = detail.signature) != null ? _a16 : void 0
             };
           }
           break;
@@ -455,34 +1345,58 @@ var OpenRouterChatLanguageModel = class {
         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 : generateId(),
+    const content = [];
+    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: mapOpenRouterFinishReason(choice.finish_reason),
       usage: usageInfo,
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
       warnings: [],
-      logprobs: mapOpenRouterChatLogProbsOutput(choice.logprobs)
-    }, hasProviderMetadata ? { providerMetadata } : {});
+      providerMetadata: {
+        openrouter: {
+          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
+            }
+          }
+        }
+      },
+      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 postJsonToApi({
+    var _a15;
+    const providerOptions = options.providerOptions || {};
+    const openrouterOptions = providerOptions.openrouter || {};
+    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
@@ -493,7 +1407,7 @@ var OpenRouterChatLanguageModel = class {
         // 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: openrouterFailedResponseHandler,
       successfulResponseHandler: createEventSourceResponseHandler(
@@ -502,21 +1416,21 @@ var OpenRouterChatLanguageModel = class {
       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 openrouterUsage = {};
-    const shouldIncludeUsageAccounting = !!((_c = this.settings.usage) == null ? void 0 : _c.include);
     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, _o;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -541,20 +1455,23 @@ var OpenRouterChatLanguageModel = 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;
               openrouterUsage.promptTokens = value.usage.prompt_tokens;
               if (value.usage.prompt_tokens_details) {
+                const cachedInputTokens = (_a16 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a16 : 0;
+                usage.cachedInputTokens = cachedInputTokens;
                 openrouterUsage.promptTokensDetails = {
-                  cachedTokens: (_a2 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a2 : 0
+                  cachedTokens: cachedInputTokens
                 };
               }
               openrouterUsage.completionTokens = value.usage.completion_tokens;
               if (value.usage.completion_tokens_details) {
+                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
+                usage.reasoningTokens = reasoningTokens;
                 openrouterUsage.completionTokensDetails = {
-                  reasoningTokens: (_b2 = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b2 : 0
+                  reasoningTokens
                 };
               }
               openrouterUsage.cost = value.usage.cost;
@@ -571,13 +1488,15 @@ var OpenRouterChatLanguageModel = class {
             if (delta.content != null) {
               controller.enqueue({
                 type: "text-delta",
-                textDelta: delta.content
+                delta: delta.content,
+                id: generateId()
               });
             }
             if (delta.reasoning != null) {
               controller.enqueue({
-                type: "reasoning",
-                textDelta: delta.reasoning
+                type: "reasoning-delta",
+                delta: delta.reasoning,
+                id: generateId()
               });
             }
             if (delta.reasoning_details && delta.reasoning_details.length > 0) {
@@ -586,14 +1505,15 @@ var OpenRouterChatLanguageModel = class {
                   case "reasoning.text" /* Text */: {
                     if (detail.text) {
                       controller.enqueue({
-                        type: "reasoning",
-                        textDelta: detail.text
+                        type: "reasoning-delta",
+                        delta: detail.text,
+                        id: generateId()
                       });
                     }
                     if (detail.signature) {
                       controller.enqueue({
-                        type: "reasoning-signature",
-                        signature: detail.signature
+                        type: "reasoning-end",
+                        id: generateId()
                       });
                     }
                     break;
@@ -601,8 +1521,9 @@ var OpenRouterChatLanguageModel = class {
                   case "reasoning.encrypted" /* Encrypted */: {
                     if (detail.data) {
                       controller.enqueue({
-                        type: "redacted-reasoning",
-                        data: detail.data
+                        type: "reasoning-delta",
+                        delta: "[REDACTED]",
+                        id: generateId()
                       });
                     }
                     break;
@@ -610,8 +1531,9 @@ var OpenRouterChatLanguageModel = class {
                   case "reasoning.summary" /* Summary */: {
                     if (detail.summary) {
                       controller.enqueue({
-                        type: "reasoning",
-                        textDelta: detail.summary
+                        type: "reasoning-delta",
+                        delta: detail.summary,
+                        id: generateId()
                       });
                     }
                     break;
@@ -623,18 +1545,9 @@ var OpenRouterChatLanguageModel = class {
                 }
               }
             }
-            const mappedLogprobs = mapOpenRouterChatLogProbsOutput(
-              choice == null ? void 0 : choice.logprobs
-            );
-            if (mappedLogprobs == null ? void 0 : mappedLogprobs.length) {
-              if (logprobs === void 0) {
-                logprobs = [];
-              }
-              logprobs.push(...mappedLogprobs);
-            }
             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 InvalidResponseDataError({
@@ -648,7 +1561,7 @@ var OpenRouterChatLanguageModel = class {
                       message: `Expected 'id' to be a string.`
                     });
                   }
-                  if (((_c2 = toolCallDelta.function) == null ? void 0 : _c2.name) == null) {
+                  if (((_d = toolCallDelta.function) == null ? void 0 : _d.name) == null) {
                     throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
@@ -659,7 +1572,7 @@ var OpenRouterChatLanguageModel = class {
                     type: "function",
                     function: {
                       name: toolCallDelta.function.name,
-                      arguments: (_d = toolCallDelta.function.arguments) != null ? _d : ""
+                      arguments: (_e = toolCallDelta.function.arguments) != null ? _e : ""
                     },
                     sent: false
                   };
@@ -667,20 +1580,26 @@ var OpenRouterChatLanguageModel = class {
                   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 && 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)) {
                     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 : generateId(),
+                      toolCallId: toolCall2.id,
                       toolName: toolCall2.function.name,
-                      args: toolCall2.function.arguments
+                      input: toolCall2.function.arguments
                     });
                     toolCall2.sent = true;
                   }
@@ -690,23 +1609,27 @@ var OpenRouterChatLanguageModel = class {
                 if (toolCall == null) {
                   throw new Error("Tool call is missing");
                 }
-                if (((_h = toolCallDelta.function) == null ? void 0 : _h.arguments) != null) {
-                  toolCall.function.arguments += (_j = (_i = toolCallDelta.function) == null ? void 0 : _i.arguments) != null ? _j : "";
+                if (((_h = toolCallDelta.function) == null ? void 0 : _h.name) != null) {
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCall.id,
+                    toolName: toolCall.function.name
+                  });
+                }
+                if (((_i = toolCallDelta.function) == null ? void 0 : _i.arguments) != null) {
+                  toolCall.function.arguments += (_k = (_j = toolCallDelta.function) == null ? void 0 : _j.arguments) != null ? _k : "";
                 }
                 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: (_l = toolCallDelta.function.arguments) != null ? _l : ""
                 });
-                if (((_l = toolCall.function) == null ? void 0 : _l.name) != null && ((_m = toolCall.function) == null ? void 0 : _m.arguments) != null && isParsableJson(toolCall.function.arguments)) {
+                if (((_m = toolCall.function) == null ? void 0 : _m.name) != null && ((_n = toolCall.function) == null ? void 0 : _n.arguments) != null && isParsableJson(toolCall.function.arguments)) {
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallType: "function",
-                    toolCallId: (_n = toolCall.id) != null ? _n : generateId(),
+                    toolCallId: (_o = toolCall.id) != null ? _o : generateId(),
                     toolName: toolCall.function.name,
-                    args: toolCall.function.arguments
+                    input: toolCall.function.arguments
                   });
                   toolCall.sent = true;
                 }
@@ -714,206 +1637,42 @@ var OpenRouterChatLanguageModel = class {
             }
           },
           flush(controller) {
-            var _a2;
+            var _a16;
             if (finishReason === "tool-calls") {
               for (const toolCall of toolCalls) {
                 if (!toolCall.sent) {
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallType: "function",
-                    toolCallId: (_a2 = toolCall.id) != null ? _a2 : generateId(),
+                    toolCallId: (_a16 = toolCall.id) != null ? _a16 : generateId(),
                     toolName: toolCall.function.name,
                     // Coerce invalid arguments to an empty JSON object
-                    args: isParsableJson(toolCall.function.arguments) ? toolCall.function.arguments : "{}"
+                    input: isParsableJson(toolCall.function.arguments) ? toolCall.function.arguments : "{}"
                   });
                   toolCall.sent = true;
                 }
               }
             }
-            const providerMetadata = {};
-            if (shouldIncludeUsageAccounting && (openrouterUsage.totalTokens !== void 0 || openrouterUsage.cost !== void 0 || openrouterUsage.promptTokensDetails !== void 0 || openrouterUsage.completionTokensDetails !== void 0)) {
-              providerMetadata.openrouter = {
-                usage: openrouterUsage
-              };
-            }
-            const hasProviderMetadata = Object.keys(providerMetadata).length > 0 && shouldIncludeUsageAccounting;
-            controller.enqueue(__spreadValues({
+            controller.enqueue({
               type: "finish",
               finishReason,
-              logprobs,
-              usage
-            }, hasProviderMetadata ? { providerMetadata } : {}));
+              usage,
+              providerMetadata: {
+                openrouter: {
+                  usage: openrouterUsage
+                }
+              }
+            });
           }
         })
       ),
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
-      warnings: []
+      warnings: [],
+      request: { body: args },
+      response: { headers: responseHeaders }
     };
   }
 };
-var OpenRouterChatCompletionBaseResponseSchema = z3.object({
-  id: z3.string().optional(),
-  model: z3.string().optional(),
-  usage: z3.object({
-    prompt_tokens: z3.number(),
-    prompt_tokens_details: z3.object({
-      cached_tokens: z3.number()
-    }).nullish(),
-    completion_tokens: z3.number(),
-    completion_tokens_details: z3.object({
-      reasoning_tokens: z3.number()
-    }).nullish(),
-    total_tokens: z3.number(),
-    cost: z3.number().optional()
-  }).nullish()
-});
-var OpenRouterNonStreamChatCompletionResponseSchema = OpenRouterChatCompletionBaseResponseSchema.extend({
-  choices: z3.array(
-    z3.object({
-      message: z3.object({
-        role: z3.literal("assistant"),
-        content: z3.string().nullable().optional(),
-        reasoning: z3.string().nullable().optional(),
-        reasoning_details: ReasoningDetailArraySchema.nullish(),
-        tool_calls: z3.array(
-          z3.object({
-            id: z3.string().optional().nullable(),
-            type: z3.literal("function"),
-            function: z3.object({
-              name: z3.string(),
-              arguments: z3.string()
-            })
-          })
-        ).optional()
-      }),
-      index: z3.number(),
-      logprobs: z3.object({
-        content: z3.array(
-          z3.object({
-            token: z3.string(),
-            logprob: z3.number(),
-            top_logprobs: z3.array(
-              z3.object({
-                token: z3.string(),
-                logprob: z3.number()
-              })
-            )
-          })
-        ).nullable()
-      }).nullable().optional(),
-      finish_reason: z3.string().optional().nullable()
-    })
-  )
-});
-var OpenRouterStreamChatCompletionChunkSchema = z3.union([
-  OpenRouterChatCompletionBaseResponseSchema.extend({
-    choices: z3.array(
-      z3.object({
-        delta: z3.object({
-          role: z3.enum(["assistant"]).optional(),
-          content: z3.string().nullish(),
-          reasoning: z3.string().nullish().optional(),
-          reasoning_details: ReasoningDetailArraySchema.nullish(),
-          tool_calls: z3.array(
-            z3.object({
-              index: z3.number(),
-              id: z3.string().nullish(),
-              type: z3.literal("function").optional(),
-              function: z3.object({
-                name: z3.string().nullish(),
-                arguments: z3.string().nullish()
-              })
-            })
-          ).nullish()
-        }).nullish(),
-        logprobs: z3.object({
-          content: z3.array(
-            z3.object({
-              token: z3.string(),
-              logprob: z3.number(),
-              top_logprobs: z3.array(
-                z3.object({
-                  token: z3.string(),
-                  logprob: z3.number()
-                })
-              )
-            })
-          ).nullable()
-        }).nullish(),
-        finish_reason: z3.string().nullable().optional(),
-        index: z3.number()
-      })
-    )
-  }),
-  OpenRouterErrorResponseSchema
-]);
-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/openrouter-completion-language-model.ts
-import { UnsupportedFunctionalityError as UnsupportedFunctionalityError3 } from "@ai-sdk/provider";
-import {
-  combineHeaders as combineHeaders2,
-  createEventSourceResponseHandler as createEventSourceResponseHandler2,
-  createJsonResponseHandler as createJsonResponseHandler2,
-  postJsonToApi as postJsonToApi2
-} from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod";
 
-// src/convert-to-openrouter-completion-prompt.ts
-import {
-  InvalidPromptError,
-  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
-} from "@ai-sdk/provider";
+// src/completion/convert-to-openrouter-completion-prompt.ts
 function convertToOpenRouterCompletionPrompt({
   prompt,
   inputFormat,
@@ -934,7 +1693,7 @@ function convertToOpenRouterCompletionPrompt({
     switch (role) {
       case "system": {
         throw new InvalidPromptError({
-          message: "Unexpected system message in prompt: ${content}",
+          message: `Unexpected system message in prompt: ${content}`,
           prompt
         });
       }
@@ -944,21 +1703,13 @@ function convertToOpenRouterCompletionPrompt({
             case "text": {
               return part.text;
             }
-            case "image": {
-              throw new UnsupportedFunctionalityError2({
-                functionality: "images"
-              });
-            }
             case "file": {
-              throw new UnsupportedFunctionalityError2({
+              throw new UnsupportedFunctionalityError({
                 functionality: "file attachments"
               });
             }
             default: {
-              const _exhaustiveCheck = part;
-              throw new Error(
-                `Unsupported content type: ${_exhaustiveCheck}`
-              );
+              return "";
             }
           }
         }).join("");
@@ -969,39 +1720,38 @@ ${userMessage}
         break;
       }
       case "assistant": {
-        const assistantMessage = content.map((part) => {
-          switch (part.type) {
-            case "text": {
-              return part.text;
-            }
-            case "tool-call": {
-              throw new UnsupportedFunctionalityError2({
-                functionality: "tool-call messages"
-              });
-            }
-            case "reasoning": {
-              throw new UnsupportedFunctionalityError2({
-                functionality: "reasoning messages"
-              });
-            }
-            case "redacted-reasoning": {
-              throw new UnsupportedFunctionalityError2({
-                functionality: "redacted reasoning messages"
-              });
-            }
-            case "file": {
-              throw new UnsupportedFunctionalityError2({
-                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}
 
@@ -1009,13 +1759,12 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new UnsupportedFunctionalityError2({
+        throw new UnsupportedFunctionalityError({
           functionality: "tool messages"
         });
       }
       default: {
-        const _exhaustiveCheck = role;
-        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+        break;
       }
     }
   }
@@ -1026,40 +1775,63 @@ ${assistantMessage}
   };
 }
 
-// src/map-openrouter-completion-logprobs.ts
-function mapOpenRouterCompletionLogProbs(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
+import { z as z6 } from "zod/v4";
+var OpenRouterCompletionChunkSchema = z6.union([
+  z6.object({
+    id: z6.string().optional(),
+    model: z6.string().optional(),
+    choices: z6.array(
+      z6.object({
+        text: z6.string(),
+        reasoning: z6.string().nullish().optional(),
+        reasoning_details: ReasoningDetailArraySchema.nullish(),
+        finish_reason: z6.string().nullish(),
+        index: z6.number().nullish(),
+        logprobs: z6.object({
+          tokens: z6.array(z6.string()),
+          token_logprobs: z6.array(z6.number()),
+          top_logprobs: z6.array(z6.record(z6.string(), z6.number())).nullable()
+        }).nullable().optional()
+      })
+    ),
+    usage: z6.object({
+      prompt_tokens: z6.number(),
+      prompt_tokens_details: z6.object({
+        cached_tokens: z6.number()
+      }).nullish(),
+      completion_tokens: z6.number(),
+      completion_tokens_details: z6.object({
+        reasoning_tokens: z6.number()
+      }).nullish(),
+      total_tokens: z6.number(),
+      cost: z6.number().optional()
+    }).nullish()
+  }),
+  OpenRouterErrorResponseSchema
+]);
 
-// src/openrouter-completion-language-model.ts
+// src/completion/index.ts
 var OpenRouterCompletionLanguageModel = class {
   constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
+    this.specificationVersion = "v2";
+    this.provider = "openrouter";
+    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,
@@ -1068,16 +1840,24 @@ var OpenRouterCompletionLanguageModel = class {
     responseFormat,
     topK,
     stopSequences,
-    providerMetadata
+    tools,
+    toolChoice
   }) {
-    var _a, _b;
-    const type = mode.type;
-    const extraCallingBody = (_a = providerMetadata == null ? void 0 : providerMetadata.openrouter) != null ? _a : {};
     const { prompt: completionPrompt } = convertToOpenRouterCompletionPrompt({
       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,
@@ -1087,7 +1867,7 @@ var OpenRouterCompletionLanguageModel = class {
       suffix: this.settings.suffix,
       user: this.settings.user,
       // standardized settings:
-      max_tokens: maxTokens,
+      max_tokens: maxOutputTokens,
       temperature,
       top_p: topP,
       frequency_penalty: frequencyPenalty,
@@ -1101,58 +1881,27 @@ var OpenRouterCompletionLanguageModel = class {
       // OpenRouter specific settings:
       include_reasoning: this.settings.includeReasoning,
       reasoning: this.settings.reasoning
-    }, this.config.extraBody), this.settings.extraBody), extraCallingBody);
-    switch (type) {
-      case "regular": {
-        if ((_b = mode.tools) == null ? void 0 : _b.length) {
-          throw new UnsupportedFunctionalityError3({
-            functionality: "tools"
-          });
-        }
-        if (mode.toolChoice) {
-          throw new UnsupportedFunctionalityError3({
-            functionality: "toolChoice"
-          });
-        }
-        return baseArgs;
-      }
-      case "object-json": {
-        throw new UnsupportedFunctionalityError3({
-          functionality: "object-json mode"
-        });
-      }
-      case "object-tool": {
-        throw new UnsupportedFunctionalityError3({
-          functionality: "object-tool mode"
-        });
-      }
-      // Handle all non-text types with a single default case
-      default: {
-        const _exhaustiveCheck = type;
-        throw new UnsupportedFunctionalityError3({
-          functionality: `${_exhaustiveCheck} mode`
-        });
-      }
-    }
+    }, 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 postJsonToApi2({
+    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+    const providerOptions = options.providerOptions || {};
+    const openrouterOptions = providerOptions.openrouter || {};
+    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: combineHeaders2(this.config.headers(), options.headers),
+      headers: combineHeaders(this.config.headers(), options.headers),
       body: args,
       failedResponseHandler: openrouterFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler2(
+      successfulResponseHandler: createJsonResponseHandler(
         OpenRouterCompletionChunkSchema
       ),
       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}`);
     }
@@ -1161,54 +1910,62 @@ var OpenRouterCompletionLanguageModel = class {
       throw new Error("No choice in OpenRouter 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: mapOpenRouterFinishReason(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: mapOpenRouterFinishReason(choice.finish_reason),
-      logprobs: mapOpenRouterCompletionLogProbs(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 postJsonToApi2({
+    const providerOptions = options.providerOptions || {};
+    const openrouterOptions = providerOptions.openrouter || {};
+    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
+    const { value: response, responseHeaders } = await postJsonToApi({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: combineHeaders2(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: openrouterFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler2(
+      successfulResponseHandler: createEventSourceResponseHandler(
         OpenRouterCompletionChunkSchema
       ),
       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 openrouterUsage = {};
     return {
       stream: response.pipeThrough(
         new TransformStream({
           transform(chunk, controller) {
+            var _a15, _b;
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -1221,10 +1978,27 @@ var OpenRouterCompletionLanguageModel = 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;
+              openrouterUsage.promptTokens = value.usage.prompt_tokens;
+              if (value.usage.prompt_tokens_details) {
+                const cachedInputTokens = (_a15 = value.usage.prompt_tokens_details.cached_tokens) != null ? _a15 : 0;
+                usage.cachedInputTokens = cachedInputTokens;
+                openrouterUsage.promptTokensDetails = {
+                  cachedTokens: cachedInputTokens
+                };
+              }
+              openrouterUsage.completionTokens = value.usage.completion_tokens;
+              if (value.usage.completion_tokens_details) {
+                const reasoningTokens = (_b = value.usage.completion_tokens_details.reasoning_tokens) != null ? _b : 0;
+                usage.reasoningTokens = reasoningTokens;
+                openrouterUsage.completionTokensDetails = {
+                  reasoningTokens
+                };
+              }
+              openrouterUsage.cost = value.usage.cost;
+              openrouterUsage.totalTokens = value.usage.total_tokens;
             }
             const choice = value.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
@@ -1233,60 +2007,31 @@ var OpenRouterCompletionLanguageModel = class {
             if ((choice == null ? void 0 : choice.text) != null) {
               controller.enqueue({
                 type: "text-delta",
-                textDelta: choice.text
+                delta: choice.text,
+                id: generateId()
               });
             }
-            const mappedLogprobs = mapOpenRouterCompletionLogProbs(
-              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: {
+                openrouter: {
+                  usage: openrouterUsage
+                }
+              }
             });
           }
         })
       ),
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
-      warnings: []
+      response: {
+        headers: responseHeaders
+      }
     };
   }
 };
-var OpenRouterCompletionChunkSchema = z4.union([
-  z4.object({
-    id: z4.string().optional(),
-    model: z4.string().optional(),
-    choices: z4.array(
-      z4.object({
-        text: z4.string(),
-        reasoning: z4.string().nullish().optional(),
-        reasoning_details: ReasoningDetailArraySchema.nullish(),
-        finish_reason: z4.string().nullish(),
-        index: z4.number(),
-        logprobs: z4.object({
-          tokens: z4.array(z4.string()),
-          token_logprobs: z4.array(z4.number()),
-          top_logprobs: z4.array(z4.record(z4.string(), z4.number())).nullable()
-        }).nullable().optional()
-      })
-    ),
-    usage: z4.object({
-      prompt_tokens: z4.number(),
-      completion_tokens: z4.number()
-    }).optional().nullable()
-  }),
-  OpenRouterErrorResponseSchema
-]);
 export {
   OpenRouterChatLanguageModel,
   OpenRouterCompletionLanguageModel