@openrouter/ai-sdk-provider 1.5.4 → 6.0.0-alpha.1

package/dist/index.js

@@ -1,30 +1,11 @@
 "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;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
-  for (var name14 in all)
-    __defProp(target, name14, { get: all[name14], enumerable: true });
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -34,2922 +15,1219 @@ 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
 var index_exports = {};
 __export(index_exports, {
-  OpenRouter: () => OpenRouter,
+  VERSION: () => VERSION,
   createOpenRouter: () => createOpenRouter,
   openrouter: () => openrouter
 });
 module.exports = __toCommonJS(index_exports);
 
-// node_modules/.pnpm/@ai-sdk+provider@2.0.0/node_modules/@ai-sdk/provider/dist/index.mjs
-var marker = "vercel.ai.error";
-var symbol = Symbol.for(marker);
-var _a;
-var _AISDKError = class _AISDKError2 extends Error {
-  /**
-   * 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;
-var NoContentGeneratedError = class extends AISDKError {
-  // used in isInstance
-  constructor({
-    message = "No content generated."
-  } = {}) {
-    super({ name: name9, message });
-    this[_a10] = true;
-  }
-  static isInstance(error) {
-    return AISDKError.hasMarker(error, marker10);
-  }
-};
-_a10 = symbol10;
-var name10 = "AI_NoSuchModelError";
-var marker11 = `vercel.ai.error.${name10}`;
-var symbol11 = Symbol.for(marker11);
-var _a11;
-_a11 = symbol11;
-var 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/openrouter-provider.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_sdk3 = require("@openrouter/sdk");
 
-// 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) {
+// src/chat/openrouter-chat-language-model.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_sdk = require("@openrouter/sdk");
+
+// src/utils/build-provider-metadata.ts
+function filterUndefined(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([_, v]) => v !== void 0)
+  );
 }
-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 buildProviderMetadata(response) {
+  if (!response) {
+    return void 0;
+  }
+  const usage = response.usage;
+  const usageMetadata = usage ? filterUndefined({
+    promptTokens: usage.promptTokens,
+    completionTokens: usage.completionTokens,
+    totalTokens: usage.totalTokens,
+    ...usage.promptTokensDetails && {
+      promptTokensDetails: filterUndefined({
+        cachedTokens: usage.promptTokensDetails.cachedTokens ?? void 0,
+        cacheWriteTokens: usage.promptTokensDetails.cacheWriteTokens ?? void 0,
+        audioTokens: usage.promptTokensDetails.audioTokens ?? void 0,
+        videoTokens: usage.promptTokensDetails.videoTokens ?? void 0
+      })
+    },
+    ...usage.completionTokensDetails && {
+      completionTokensDetails: filterUndefined({
+        reasoningTokens: usage.completionTokensDetails.reasoningTokens ?? void 0,
+        imageTokens: usage.completionTokensDetails.imageTokens ?? void 0
+      })
+    },
+    cost: usage.cost,
+    isByok: usage.isByok,
+    costDetails: usage.costDetails
+  }) : void 0;
+  const metadata = filterUndefined({
+    responseId: response.id,
+    provider: response.provider,
+    usage: usageMetadata
+  });
+  return {
+    openrouter: metadata
+  };
+}
+
+// src/utils/build-usage.ts
+function buildUsage(usage) {
+  if (!usage) {
+    return {
+      inputTokens: {
+        total: 0,
+        noCache: void 0,
+        cacheRead: void 0,
+        cacheWrite: void 0
+      },
+      outputTokens: {
+        total: 0,
+        text: void 0,
+        reasoning: void 0
+      },
+      raw: void 0
+    };
   }
-  function parseLine(line) {
-    if (line === "") {
-      dispatchEvent();
-      return;
-    }
-    if (line.startsWith(":")) {
-      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
-      return;
+  const rawUsage = {
+    inputTokens: usage.inputTokens ?? null,
+    outputTokens: usage.outputTokens ?? null,
+    ...usage.inputTokensDetails && {
+      inputTokensDetails: {
+        cachedTokens: usage.inputTokensDetails.cachedTokens ?? null
+      }
+    },
+    ...usage.outputTokensDetails && {
+      outputTokensDetails: {
+        reasoningTokens: usage.outputTokensDetails.reasoningTokens ?? null
+      }
     }
-    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;
+  };
+  return {
+    inputTokens: {
+      total: usage.inputTokens ?? 0,
+      noCache: void 0,
+      cacheRead: usage.inputTokensDetails?.cachedTokens,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: usage.outputTokens ?? 0,
+      text: void 0,
+      reasoning: usage.outputTokensDetails?.reasoningTokens
+    },
+    raw: rawUsage
+  };
+}
+
+// src/chat/convert-to-openrouter-messages.ts
+function convertToOpenRouterMessages(prompt) {
+  const result = [];
+  for (const message of prompt) {
+    const converted = convertMessage(message);
+    result.push(...converted);
+  }
+  return result;
+}
+function convertMessage(message) {
+  const messageWithOptions = message;
+  const providerOptions = messageWithOptions.providerOptions;
+  const providerMetadata = messageWithOptions.providerMetadata;
+  switch (message.role) {
+    case "system":
+      return [{ role: "system", content: message.content }];
+    case "user":
+      return [convertUserMessage(message.content)];
+    case "assistant":
+      return convertAssistantMessage(message.content, providerMetadata, providerOptions);
+    case "tool":
+      return convertToolMessage(message.content);
+    default: {
+      const _exhaustive = message;
+      throw new Error(`Unknown message role: ${_exhaustive.role}`);
     }
-    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
-          })
-        );
+}
+function convertUserMessage(content) {
+  const convertedContent = [];
+  for (const part of content) {
+    switch (part.type) {
+      case "text": {
+        convertedContent.push({ type: "input_text", text: part.text });
         break;
-      default:
-        onError(
-          new ParseError(
-            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
-            { type: "unknown-field", field, value, line }
-          )
-        );
+      }
+      case "file":
+        convertedContent.push(convertFilePart(part));
         break;
+      default: {
+        const _exhaustive = part;
+        throw new Error(`Unknown user content type: ${_exhaustive.type}`);
+      }
     }
   }
-  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 };
+  return { role: "user", content: convertedContent };
 }
-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++;
-    }
+function convertFilePart(part) {
+  const url = convertDataContent(part.data, part.mediaType);
+  if (part.mediaType.startsWith("image/")) {
+    return {
+      type: "input_image",
+      imageUrl: url,
+      detail: "auto"
+    };
   }
-  return [lines, incompleteLine];
+  return {
+    type: "input_file",
+    fileUrl: url
+  };
 }
-
-// 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);
-      }
-    });
+function convertDataContent(data, mediaType) {
+  if (data instanceof URL) {
+    return data.toString();
   }
-};
-
-// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.1_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
-var z4 = __toESM(require("zod/v4"), 1);
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Options.js
-var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/selectParser.js
-var import_zod3 = require("zod");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
-var import_zod = require("zod");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
-var import_zod2 = require("zod");
-
-// node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
-var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-
-// node_modules/.pnpm/@ai-sdk+provider-utils@3.0.1_zod@3.25.76/node_modules/@ai-sdk/provider-utils/dist/index.mjs
-function combineHeaders(...headers) {
-  return headers.reduce(
-    (combinedHeaders, currentHeaders) => __spreadValues(__spreadValues({}, combinedHeaders), currentHeaders != null ? currentHeaders : {}),
-    {}
-  );
+  if (data instanceof Uint8Array) {
+    const base64 = uint8ArrayToBase64(data);
+    return `data:${mediaType};base64,${base64}`;
+  }
+  if (data.startsWith("http://") || data.startsWith("https://") || data.startsWith("data:")) {
+    return data;
+  }
+  return `data:${mediaType};base64,${data}`;
 }
-function extractResponseHeaders(response) {
-  return Object.fromEntries([...response.headers]);
+function uint8ArrayToBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
 }
-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];
+function extractReasoningDetails(content, providerMetadata, providerOptions) {
+  const messageLevel = providerOptions?.openrouter?.reasoning_details ?? providerMetadata?.openrouter?.reasoning_details;
+  if (messageLevel && Array.isArray(messageLevel) && messageLevel.length > 0) {
+    return messageLevel;
+  }
+  for (const part of content) {
+    if (part.type === "reasoning") {
+      const partWithMeta = part;
+      const partLevel = partWithMeta.providerOptions?.openrouter?.reasoning_details ?? partWithMeta.providerMetadata?.openrouter?.reasoning_details;
+      if (partLevel && Array.isArray(partLevel) && partLevel.length > 0) {
+        return partLevel;
+      }
     }
-    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 instanceof DOMException) && (error.name === "AbortError" || error.name === "ResponseAborted" || // Next.js
-  error.name === "TimeoutError");
+  return void 0;
 }
-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
+function transformReasoningToApiFormat(sdkItems) {
+  const apiItems = [];
+  for (const rawItem of sdkItems) {
+    if (typeof rawItem !== "object" || rawItem === null) {
+      continue;
+    }
+    const item = rawItem;
+    const baseProps = {
+      id: item.id,
+      format: item.format ?? null
+    };
+    let index = item.index ?? 0;
+    if (item.type === "reasoning.text" && item.text !== void 0) {
+      apiItems.push({
+        type: "reasoning.text",
+        text: item.text,
+        signature: item.signature ?? null,
+        index,
+        ...baseProps
+      });
+      continue;
+    }
+    if (item.type === "reasoning.summary" && item.summary !== void 0) {
+      apiItems.push({
+        type: "reasoning.summary",
+        summary: typeof item.summary === "string" ? item.summary : "",
+        index,
+        ...baseProps
       });
+      continue;
+    }
+    if (item.type === "reasoning.encrypted" && item.data !== void 0) {
+      apiItems.push({
+        type: "reasoning.encrypted",
+        data: item.data,
+        index,
+        ...baseProps
+      });
+      continue;
+    }
+    if (item.type === "reasoning" || item.content || item.summary || item.encryptedContent) {
+      if (item.content && Array.isArray(item.content)) {
+        for (const contentItem of item.content) {
+          if (contentItem.type === "reasoning_text" && contentItem.text) {
+            apiItems.push({
+              type: "reasoning.text",
+              text: contentItem.text,
+              signature: item.signature ?? null,
+              index: index++,
+              ...baseProps
+            });
+          }
+        }
+      }
+      if (item.summary && Array.isArray(item.summary)) {
+        for (const summaryItem of item.summary) {
+          if (summaryItem.type === "summary_text" && summaryItem.text) {
+            apiItems.push({
+              type: "reasoning.summary",
+              summary: summaryItem.text,
+              index: index++,
+              ...baseProps
+            });
+          }
+        }
+      }
+      if (item.encryptedContent) {
+        apiItems.push({
+          type: "reasoning.encrypted",
+          data: item.encryptedContent,
+          index: index++,
+          ...baseProps
+        });
+      }
     }
   }
-  return error;
-}
-function removeUndefinedEntries(record) {
-  return Object.fromEntries(
-    Object.entries(record).filter(([_key, value]) => value != null)
-  );
+  return apiItems;
 }
-function loadApiKey({
-  apiKey,
-  environmentVariableName,
-  apiKeyParameterName = "apiKey",
-  description
-}) {
-  if (typeof apiKey === "string") {
-    return apiKey;
+function buildReasoningFromDetails(items) {
+  if (items.length === 0) {
+    return void 0;
   }
-  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.`
-    });
+  const reasoning = {};
+  const textItems = items.filter((i) => i.type === "reasoning.text" && i.text);
+  if (textItems.length > 0) {
+    reasoning.text = textItems.map((i) => i.text).join("");
   }
-  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.`
-    });
+  const summaryItems = items.filter(
+    (i) => i.type === "reasoning.summary" && i.summary
+  );
+  if (summaryItems.length > 0) {
+    reasoning.summary = summaryItems.map((i) => i.summary).join("");
   }
-  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;
+  const encryptedItem = items.find(
+    (i) => i.type === "reasoning.encrypted" && i.data
+  );
+  if (encryptedItem?.data) {
+    reasoning.encrypted = encryptedItem.data;
   }
-  if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
-    return obj;
+  if (!reasoning.text && !reasoning.summary && !reasoning.encrypted) {
+    return void 0;
   }
-  return filter(obj);
+  return reasoning;
 }
-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);
-        }
+function convertAssistantMessage(content, providerMetadata, providerOptions) {
+  const result = [];
+  let textContent = "";
+  const sdkReasoningDetails = extractReasoningDetails(
+    content,
+    providerMetadata,
+    providerOptions
+  );
+  const reasoningItems = sdkReasoningDetails ? transformReasoningToApiFormat(sdkReasoningDetails) : [];
+  const reasoning = buildReasoningFromDetails(reasoningItems);
+  for (const part of content) {
+    switch (part.type) {
+      case "text":
+        textContent += part.text;
+        break;
+      case "reasoning":
+        textContent += part.text;
+        break;
+      case "tool-call":
+        result.push({
+          type: "function_call",
+          callId: part.toolCallId,
+          name: part.toolName,
+          arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input)
+        });
+        break;
+      case "file":
+        break;
+      case "tool-result":
+        result.push(convertToolResult(part));
+        break;
+      default: {
+        const _exhaustive = part;
+        throw new Error(
+          `Unknown assistant content type: ${_exhaustive.type}`
+        );
       }
     }
   }
-  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
-      })
+  if (textContent) {
+    const assistantMessage = {
+      role: "assistant",
+      content: textContent
     };
-  });
-}
-async function validateTypes({
-  value,
-  schema
-}) {
-  const result = await safeValidateTypes({ value, schema });
-  if (!result.success) {
-    throw TypeValidationError.wrap({ value, cause: result.error });
+    if (reasoning) {
+      assistantMessage.reasoning = reasoning;
+    }
+    result.unshift(assistantMessage);
+  } else if (reasoning) {
+    const assistantMessage = {
+      role: "assistant",
+      content: ""
+    };
+    assistantMessage.reasoning = reasoning;
+    result.unshift(assistantMessage);
   }
-  return result.value;
+  return result;
 }
-async function safeValidateTypes({
-  value,
-  schema
-}) {
-  const validator2 = asValidator(schema);
-  try {
-    if (validator2.validate == null) {
-      return { success: true, value, rawValue: value };
+function convertToolMessage(content) {
+  const result = [];
+  for (const part of content) {
+    if (part.type === "tool-result") {
+      result.push(convertToolResult(part));
     }
-    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
-    };
   }
+  return result;
+}
+function convertToolResult(part) {
+  const output = convertToolResultOutput(part.output);
+  return {
+    type: "function_call_output",
+    callId: part.toolCallId,
+    output: output.value,
+    status: output.isError ? "incomplete" : "completed"
+  };
 }
-async function parseJSON({
-  text,
-  schema
-}) {
-  try {
-    const value = secureJsonParse(text);
-    if (schema == null) {
-      return value;
+function convertToolResultOutput(output) {
+  switch (output.type) {
+    case "text":
+      return { value: output.value, isError: false };
+    case "json":
+      return { value: JSON.stringify(output.value), isError: false };
+    case "execution-denied":
+      return {
+        value: `Execution denied: ${output.reason ?? "No reason provided"}`,
+        isError: true
+      };
+    case "error-text":
+      return { value: output.value, isError: true };
+    case "error-json":
+      return { value: JSON.stringify(output.value), isError: true };
+    case "content": {
+      const textParts = output.value.filter((item) => item.type === "text").map((item) => item.text);
+      return { value: textParts.join("\n"), isError: false };
     }
-    return validateTypes({ value, schema });
-  } catch (error) {
-    if (JSONParseError.isInstance(error) || TypeValidationError.isInstance(error)) {
-      throw error;
+    default: {
+      const _exhaustive = output;
+      throw new Error(`Unknown tool result output type: ${_exhaustive.type}`);
     }
-    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 };
+
+// src/chat/extract-reasoning-details.ts
+function extractReasoningDetails2(response) {
+  const extractedDetails = [];
+  for (const outputItem of response.output) {
+    if ("type" in outputItem && outputItem.type === "reasoning") {
+      const reasoningItem = outputItem;
+      extractedDetails.push({
+        type: "reasoning",
+        id: reasoningItem.id,
+        content: reasoningItem.content,
+        summary: reasoningItem.summary,
+        encryptedContent: reasoningItem.encryptedContent,
+        signature: reasoningItem.signature,
+        format: reasoningItem.format
+      });
     }
-    return await safeValidateTypes({ value, schema });
-  } catch (error) {
-    return {
-      success: false,
-      error: JSONParseError.isInstance(error) ? error : new JSONParseError({ text, cause: error }),
-      rawValue: void 0
-    };
   }
+  return extractedDetails.length > 0 ? extractedDetails : void 0;
 }
-function isParsableJson(input) {
-  try {
-    secureJsonParse(input);
-    return true;
-  } catch (e) {
+function hasEncryptedReasoning(reasoningDetails) {
+  if (!reasoningDetails) {
     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
-      });
+  return reasoningDetails.some((d) => {
+    if (typeof d === "object" && d !== null) {
+      const obj = d;
+      return obj.encryptedContent != null || obj.type === "reasoning.encrypted";
     }
-  } 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
+    return false;
   });
-  const responseHeaders = extractResponseHeaders(response);
-  if (!parsedResult.success) {
-    throw new APICallError({
-      message: "Invalid JSON response",
-      cause: parsedResult.error,
-      statusCode: response.status,
-      responseHeaders,
-      responseBody,
-      url,
-      requestBodyValues
-    });
+}
+function buildReasoningProviderMetadata(reasoningDetails) {
+  if (!reasoningDetails || reasoningDetails.length === 0) {
+    return void 0;
   }
   return {
-    responseHeaders,
-    value: parsedResult.value,
-    rawValue: parsedResult.rawValue
+    openrouter: {
+      reasoning_details: reasoningDetails
+    }
   };
-};
-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");
-
-// src/utils/type-guards.ts
-function isDefinedOrNotNull(value) {
-  return value !== null && value !== void 0;
 }
 
-// src/schemas/format.ts
-var ReasoningFormat = /* @__PURE__ */ ((ReasoningFormat2) => {
-  ReasoningFormat2["Unknown"] = "unknown";
-  ReasoningFormat2["OpenAIResponsesV1"] = "openai-responses-v1";
-  ReasoningFormat2["XAIResponsesV1"] = "xai-responses-v1";
-  ReasoningFormat2["AnthropicClaudeV1"] = "anthropic-claude-v1";
-  ReasoningFormat2["GoogleGeminiV1"] = "google-gemini-v1";
-  return ReasoningFormat2;
-})(ReasoningFormat || {});
-
-// src/schemas/reasoning-details.ts
-var CommonReasoningDetailSchema = import_v4.z.object({
-  id: import_v4.z.string().nullish(),
-  format: import_v4.z.enum(ReasoningFormat).nullish(),
-  index: import_v4.z.number().optional()
-}).loose();
-var ReasoningDetailSummarySchema = import_v4.z.object({
-  type: import_v4.z.literal("reasoning.summary" /* Summary */),
-  summary: import_v4.z.string()
-}).extend(CommonReasoningDetailSchema.shape);
-var ReasoningDetailEncryptedSchema = import_v4.z.object({
-  type: import_v4.z.literal("reasoning.encrypted" /* Encrypted */),
-  data: import_v4.z.string()
-}).extend(CommonReasoningDetailSchema.shape);
-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()
-}).extend(CommonReasoningDetailSchema.shape);
-var ReasoningDetailUnionSchema = import_v4.z.union([
-  ReasoningDetailSummarySchema,
-  ReasoningDetailEncryptedSchema,
-  ReasoningDetailTextSchema
-]);
-var ReasoningDetailsWithUnknownSchema = import_v4.z.union([
-  ReasoningDetailUnionSchema,
-  import_v4.z.unknown().transform(() => null)
-]);
-var ReasoningDetailArraySchema = import_v4.z.array(ReasoningDetailsWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
-var OutputUnionToReasoningDetailsSchema = import_v4.z.union([
-  import_v4.z.object({
-    delta: import_v4.z.object({
-      reasoning_details: import_v4.z.array(ReasoningDetailsWithUnknownSchema)
-    })
-  }).transform(
-    (data) => data.delta.reasoning_details.filter(isDefinedOrNotNull)
-  ),
-  import_v4.z.object({
-    message: import_v4.z.object({
-      reasoning_details: import_v4.z.array(ReasoningDetailsWithUnknownSchema)
-    })
-  }).transform(
-    (data) => data.message.reasoning_details.filter(isDefinedOrNotNull)
-  ),
-  import_v4.z.object({
-    text: import_v4.z.string(),
-    reasoning_details: import_v4.z.array(ReasoningDetailsWithUnknownSchema)
-  }).transform((data) => data.reasoning_details.filter(isDefinedOrNotNull))
-]);
-
-// src/schemas/error-response.ts
-var import_v42 = require("zod/v4");
-var OpenRouterErrorResponseSchema = 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)
-  }).passthrough()
-}).passthrough();
-var openrouterFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: OpenRouterErrorResponseSchema,
-  errorToMessage: (data) => data.error.message
-});
-
-// src/schemas/provider-metadata.ts
-var import_v43 = require("zod/v4");
-var FileAnnotationSchema = import_v43.z.object({
-  type: import_v43.z.literal("file"),
-  file: import_v43.z.object({
-    hash: import_v43.z.string(),
-    name: import_v43.z.string(),
-    content: import_v43.z.array(
-      import_v43.z.object({
-        type: import_v43.z.string(),
-        text: import_v43.z.string().optional()
-      }).catchall(import_v43.z.any())
-    ).optional()
-  }).catchall(import_v43.z.any())
-}).catchall(import_v43.z.any());
-var OpenRouterProviderMetadataSchema = import_v43.z.object({
-  provider: import_v43.z.string(),
-  reasoning_details: import_v43.z.array(ReasoningDetailUnionSchema).optional(),
-  annotations: import_v43.z.array(FileAnnotationSchema).optional(),
-  usage: import_v43.z.object({
-    promptTokens: import_v43.z.number(),
-    promptTokensDetails: import_v43.z.object({
-      cachedTokens: import_v43.z.number()
-    }).catchall(import_v43.z.any()).optional(),
-    completionTokens: import_v43.z.number(),
-    completionTokensDetails: import_v43.z.object({
-      reasoningTokens: import_v43.z.number()
-    }).catchall(import_v43.z.any()).optional(),
-    totalTokens: import_v43.z.number(),
-    cost: import_v43.z.number().optional(),
-    costDetails: import_v43.z.object({
-      upstreamInferenceCost: import_v43.z.number()
-    }).catchall(import_v43.z.any()).optional()
-  }).catchall(import_v43.z.any())
-}).catchall(import_v43.z.any());
-var OpenRouterProviderOptionsSchema = import_v43.z.object({
-  openrouter: import_v43.z.object({
-    reasoning_details: import_v43.z.array(ReasoningDetailUnionSchema).optional(),
-    annotations: import_v43.z.array(FileAnnotationSchema).optional()
-  }).optional()
-}).optional();
-
-// src/utils/map-finish-reason.ts
+// src/chat/map-openrouter-finish-reason.ts
 function mapOpenRouterFinishReason(finishReason) {
+  if (finishReason == null) {
+    return { unified: "other", raw: void 0 };
+  }
   switch (finishReason) {
+    case "end_turn":
     case "stop":
-      return "stop";
+    case "stop_sequence":
+      return { unified: "stop", raw: finishReason };
+    case "max_tokens":
     case "length":
-      return "length";
-    case "content_filter":
-      return "content-filter";
-    case "function_call":
+      return { unified: "length", raw: finishReason };
+    case "tool_use":
     case "tool_calls":
-      return "tool-calls";
+      return { unified: "tool-calls", raw: finishReason };
+    case "content_filter":
+      return { unified: "content-filter", raw: finishReason };
+    case "error":
+      return { unified: "error", raw: finishReason };
     default:
-      return "unknown";
-  }
-}
-
-// src/types/openrouter-chat-completions-input.ts
-var OPENROUTER_AUDIO_FORMATS = [
-  "wav",
-  "mp3",
-  "aiff",
-  "aac",
-  "ogg",
-  "flac",
-  "m4a",
-  "pcm16",
-  "pcm24"
-];
-
-// src/chat/is-url.ts
-function isUrl({
-  url,
-  protocols
-}) {
-  try {
-    const urlObj = new URL(url);
-    return protocols.has(urlObj.protocol);
-  } catch (_) {
-    return false;
+      return { unified: "other", raw: finishReason };
   }
 }
 
-// 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;
+// src/chat/openrouter-chat-language-model.ts
+var OpenRouterChatLanguageModel = class {
+  specificationVersion = "v3";
+  provider = "openrouter";
+  modelId;
+  settings;
+  /**
+   * Supported URL patterns by media type.
+   * OpenRouter Chat API only supports image URLs natively.
+   * PDF URLs are not supported - use PDF data URIs or the Responses API instead.
+   */
+  supportedUrls = {
+    "image/*": [/^https?:\/\/.*$/]
+  };
+  constructor(modelId, settings) {
+    this.modelId = modelId;
+    this.settings = settings;
   }
-  return stringUrl.startsWith("data:") ? stringUrl : `data:${(_b = part.mediaType) != null ? _b : defaultMediaType};base64,${stringUrl}`;
-}
-function getMediaType(dataUrl, defaultMediaType) {
-  var _a15;
-  const match = dataUrl.match(/^data:([^;]+)/);
-  return match ? (_a15 = match[1]) != null ? _a15 : defaultMediaType : defaultMediaType;
-}
-function getBase64FromDataUrl(dataUrl) {
-  const match = dataUrl.match(/^data:[^;]*;base64,(.+)$/);
-  return match ? match[1] : dataUrl;
-}
-var MIME_TO_FORMAT = {
-  // MP3 variants
-  mpeg: "mp3",
-  mp3: "mp3",
-  // WAV variants
-  "x-wav": "wav",
-  wave: "wav",
-  wav: "wav",
-  // OGG variants
-  ogg: "ogg",
-  vorbis: "ogg",
-  // AAC variants
-  aac: "aac",
-  "x-aac": "aac",
-  // M4A variants
-  m4a: "m4a",
-  "x-m4a": "m4a",
-  mp4: "m4a",
-  // AIFF variants
-  aiff: "aiff",
-  "x-aiff": "aiff",
-  // FLAC
-  flac: "flac",
-  "x-flac": "flac",
-  // PCM variants
-  pcm16: "pcm16",
-  pcm24: "pcm24"
-};
-function getInputAudioData(part) {
-  const fileData = getFileUrl({
-    part,
-    defaultMediaType: "audio/mpeg"
-  });
-  if (isUrl({
-    url: fileData,
-    protocols: /* @__PURE__ */ new Set(["http:", "https:"])
-  })) {
-    throw new Error(
-      `Audio files cannot be provided as URLs.
-
-OpenRouter requires audio to be base64-encoded. Please:
-1. Download the audio file locally
-2. Read it as a Buffer or Uint8Array
-3. Pass it as the data parameter
-
-The AI SDK will automatically handle base64 encoding.
-
-Learn more: https://openrouter.ai/docs/features/multimodal/audio`
-    );
-  }
-  const data = getBase64FromDataUrl(fileData);
-  const mediaType = part.mediaType || "audio/mpeg";
-  const rawFormat = mediaType.replace("audio/", "");
-  const format = MIME_TO_FORMAT[rawFormat];
-  if (format === void 0) {
-    const supportedList = OPENROUTER_AUDIO_FORMATS.join(", ");
-    throw new Error(
-      `Unsupported audio format: "${mediaType}"
-
-OpenRouter supports the following audio formats: ${supportedList}
-
-Learn more: https://openrouter.ai/docs/features/multimodal/audio`
+  async doGenerate(options) {
+    const warnings = [];
+    const client = new import_sdk.OpenRouter({
+      apiKey: this.settings.apiKey,
+      serverURL: this.settings.baseURL,
+      userAgent: this.settings.userAgent
+    });
+    const openRouterInput = convertToOpenRouterMessages(options.prompt);
+    const tools = convertToolsToResponsesFormat(options.tools, warnings);
+    const toolChoice = convertToolChoiceToResponsesFormat(options.toolChoice);
+    const text = convertResponseFormatToText(options.responseFormat);
+    const requestParams = {
+      model: this.modelId,
+      input: openRouterInput,
+      stream: false,
+      ...options.maxOutputTokens !== void 0 && {
+        maxOutputTokens: options.maxOutputTokens
+      },
+      ...options.temperature !== void 0 && {
+        temperature: options.temperature
+      },
+      ...options.topP !== void 0 && { topP: options.topP },
+      ...tools.length > 0 && { tools },
+      ...toolChoice !== void 0 && { toolChoice },
+      ...text !== void 0 && { text }
+    };
+    const combinedHeaders = (0, import_provider_utils.normalizeHeaders)(
+      (0, import_provider_utils.combineHeaders)(this.settings.headers, options.headers)
     );
-  }
-  return { data, format };
-}
-
-// src/chat/convert-to-openrouter-chat-messages.ts
-function getCacheControl(providerMetadata) {
-  var _a15, _b, _c;
-  const anthropic = providerMetadata == null ? void 0 : providerMetadata.anthropic;
-  const openrouter2 = providerMetadata == null ? void 0 : providerMetadata.openrouter;
-  return (_c = (_b = (_a15 = openrouter2 == null ? void 0 : openrouter2.cacheControl) != null ? _a15 : openrouter2 == null ? void 0 : openrouter2.cache_control) != null ? _b : anthropic == null ? void 0 : anthropic.cacheControl) != null ? _c : anthropic == null ? void 0 : anthropic.cache_control;
-}
-function convertToOpenRouterChatMessages(prompt) {
-  var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-  const messages = [];
-  for (const { role, content, providerOptions } of prompt) {
-    switch (role) {
-      case "system": {
-        messages.push({
-          role: "system",
-          content,
-          cache_control: getCacheControl(providerOptions)
-        });
-        break;
+    const response = await client.beta.responses.send(requestParams, {
+      fetchOptions: {
+        signal: options.abortSignal,
+        headers: combinedHeaders
       }
-      case "user": {
-        if (content.length === 1 && ((_a15 = content[0]) == null ? void 0 : _a15.type) === "text") {
-          const cacheControl = (_b = getCacheControl(providerOptions)) != null ? _b : getCacheControl(content[0].providerOptions);
-          const contentWithCacheControl = cacheControl ? [
-            {
-              type: "text",
-              text: content[0].text,
-              cache_control: cacheControl
-            }
-          ] : content[0].text;
-          messages.push({
-            role: "user",
-            content: contentWithCacheControl
+    });
+    const content = [];
+    const reasoningDetails = extractReasoningDetails2(response);
+    const reasoningMetadata = buildReasoningProviderMetadata(reasoningDetails);
+    for (const outputItem of response.output) {
+      if (outputItem.type === "reasoning") {
+        const reasoningItem = outputItem;
+        const reasoningText = reasoningItem.content?.filter((c) => c.type === "reasoning_text").map((c) => c.text).join("") || reasoningItem.summary?.filter((c) => c.type === "summary_text").map((c) => c.text).join("") || "";
+        if (reasoningText) {
+          content.push({
+            type: "reasoning",
+            text: reasoningText,
+            ...reasoningMetadata && { providerMetadata: reasoningMetadata }
           });
-          break;
         }
-        const messageCacheControl = getCacheControl(providerOptions);
-        const contentParts = content.map(
-          (part) => {
-            var _a16, _b2, _c2, _d2, _e2, _f2, _g2;
-            const cacheControl = (_a16 = getCacheControl(part.providerOptions)) != null ? _a16 : messageCacheControl;
-            switch (part.type) {
-              case "text":
-                return {
-                  type: "text",
-                  text: part.text,
-                  // For text parts, only use part-specific cache control
-                  cache_control: cacheControl
-                };
-              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
-                  };
-                }
-                if ((_c2 = part.mediaType) == null ? void 0 : _c2.startsWith("audio/")) {
-                  return {
-                    type: "input_audio",
-                    input_audio: getInputAudioData(part),
-                    cache_control: cacheControl
-                  };
-                }
-                const fileName = String(
-                  (_g2 = (_f2 = (_e2 = (_d2 = part.providerOptions) == null ? void 0 : _d2.openrouter) == null ? void 0 : _e2.filename) != null ? _f2 : part.filename) != null ? _g2 : ""
-                );
-                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: fileName,
-                    file_data: fileData
-                  },
-                  cache_control: cacheControl
-                };
-              }
-              default: {
-                return {
-                  type: "text",
-                  text: "",
-                  cache_control: cacheControl
-                };
-              }
-            }
-          }
-        );
-        messages.push({
-          role: "user",
-          content: contentParts
-        });
-        break;
-      }
-      case "assistant": {
-        let text = "";
-        let reasoning = "";
-        const toolCalls = [];
-        const accumulatedReasoningDetails = [];
-        for (const part of content) {
-          switch (part.type) {
-            case "text": {
-              text += part.text;
-              break;
-            }
-            case "tool-call": {
-              const partReasoningDetails = (_c = part.providerOptions) == null ? void 0 : _c.openrouter;
-              if ((partReasoningDetails == null ? void 0 : partReasoningDetails.reasoning_details) && Array.isArray(partReasoningDetails.reasoning_details)) {
-                accumulatedReasoningDetails.push(
-                  ...partReasoningDetails.reasoning_details
-                );
-              }
-              toolCalls.push({
-                id: part.toolCallId,
-                type: "function",
-                function: {
-                  name: part.toolName,
-                  arguments: JSON.stringify(part.input)
-                }
-              });
-              break;
-            }
-            case "reasoning": {
-              reasoning += part.text;
-              const parsedPartProviderOptions = OpenRouterProviderOptionsSchema.safeParse(part.providerOptions);
-              if (parsedPartProviderOptions.success && ((_e = (_d = parsedPartProviderOptions.data) == null ? void 0 : _d.openrouter) == null ? void 0 : _e.reasoning_details)) {
-                accumulatedReasoningDetails.push(
-                  ...parsedPartProviderOptions.data.openrouter.reasoning_details
-                );
-              }
-              break;
-            }
-            case "file":
-              break;
-            default: {
-              break;
-            }
+      } else if (outputItem.type === "message") {
+        const messageItem = outputItem;
+        for (const contentItem of messageItem.content) {
+          if (contentItem.type === "output_text" && contentItem.text) {
+            content.push({
+              type: "text",
+              text: contentItem.text
+            });
           }
         }
-        const parsedProviderOptions = OpenRouterProviderOptionsSchema.safeParse(providerOptions);
-        const messageReasoningDetails = parsedProviderOptions.success ? (_g = (_f = parsedProviderOptions.data) == null ? void 0 : _f.openrouter) == null ? void 0 : _g.reasoning_details : void 0;
-        const messageAnnotations = parsedProviderOptions.success ? (_i = (_h = parsedProviderOptions.data) == null ? void 0 : _h.openrouter) == null ? void 0 : _i.annotations : void 0;
-        const finalReasoningDetails = messageReasoningDetails && Array.isArray(messageReasoningDetails) && messageReasoningDetails.length > 0 ? messageReasoningDetails : accumulatedReasoningDetails.length > 0 ? accumulatedReasoningDetails : void 0;
-        messages.push({
-          role: "assistant",
-          content: text,
-          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
-          reasoning: reasoning || void 0,
-          reasoning_details: finalReasoningDetails,
-          annotations: messageAnnotations,
-          cache_control: getCacheControl(providerOptions)
+      } else if (outputItem.type === "function_call") {
+        const functionCallItem = outputItem;
+        content.push({
+          type: "tool-call",
+          toolCallId: functionCallItem.callId,
+          toolName: functionCallItem.name,
+          // Default to empty object when arguments is undefined/empty
+          // (some providers omit arguments for tools with no parameters)
+          input: functionCallItem.arguments || "{}",
+          ...reasoningMetadata && { providerMetadata: reasoningMetadata }
         });
-        break;
-      }
-      case "tool": {
-        for (const toolResponse of content) {
-          const content2 = getToolResultContent(toolResponse);
-          messages.push({
-            role: "tool",
-            tool_call_id: toolResponse.toolCallId,
-            content: content2,
-            cache_control: (_j = getCacheControl(providerOptions)) != null ? _j : getCacheControl(toolResponse.providerOptions)
-          });
-        }
-        break;
       }
-      default: {
-        break;
-      }
-    }
-  }
-  return messages;
-}
-function getToolResultContent(input) {
-  return input.output.type === "text" ? input.output.value : JSON.stringify(input.output.value);
-}
-
-// src/chat/get-tool-choice.ts
-var import_v44 = require("zod/v4");
-var ChatCompletionToolChoiceSchema = import_v44.z.union([
-  import_v44.z.literal("auto"),
-  import_v44.z.literal("none"),
-  import_v44.z.literal("required"),
-  import_v44.z.object({
-    type: import_v44.z.literal("function"),
-    function: import_v44.z.object({
-      name: import_v44.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 InvalidArgumentError({
-        argument: "toolChoice",
-        message: `Invalid tool choice type: ${JSON.stringify(toolChoice)}`
-      });
-    }
-  }
-}
-
-// src/chat/schemas.ts
-var import_v46 = require("zod/v4");
-
-// src/schemas/image.ts
-var import_v45 = require("zod/v4");
-var ImageResponseSchema = import_v45.z.object({
-  type: import_v45.z.literal("image_url"),
-  image_url: import_v45.z.object({
-    url: import_v45.z.string()
-  }).passthrough()
-}).passthrough();
-var ImageResponseWithUnknownSchema = import_v45.z.union([
-  ImageResponseSchema,
-  import_v45.z.unknown().transform(() => null)
-]);
-var ImageResponseArraySchema = import_v45.z.array(ImageResponseWithUnknownSchema).transform((d) => d.filter((d2) => !!d2));
-
-// src/chat/schemas.ts
-var OpenRouterChatCompletionBaseResponseSchema = import_v46.z.object({
-  id: import_v46.z.string().optional(),
-  model: import_v46.z.string().optional(),
-  provider: import_v46.z.string().optional(),
-  usage: import_v46.z.object({
-    prompt_tokens: import_v46.z.number(),
-    prompt_tokens_details: import_v46.z.object({
-      cached_tokens: import_v46.z.number()
-    }).passthrough().nullish(),
-    completion_tokens: import_v46.z.number(),
-    completion_tokens_details: import_v46.z.object({
-      reasoning_tokens: import_v46.z.number()
-    }).passthrough().nullish(),
-    total_tokens: import_v46.z.number(),
-    cost: import_v46.z.number().optional(),
-    cost_details: import_v46.z.object({
-      upstream_inference_cost: import_v46.z.number().nullish()
-    }).passthrough().nullish()
-  }).passthrough().nullish()
-}).passthrough();
-var OpenRouterNonStreamChatCompletionResponseSchema = import_v46.z.union([
-  // Success response with choices
-  OpenRouterChatCompletionBaseResponseSchema.extend({
-    choices: import_v46.z.array(
-      import_v46.z.object({
-        message: import_v46.z.object({
-          role: import_v46.z.literal("assistant"),
-          content: import_v46.z.string().nullable().optional(),
-          reasoning: import_v46.z.string().nullable().optional(),
-          reasoning_details: ReasoningDetailArraySchema.nullish(),
-          images: ImageResponseArraySchema.nullish(),
-          tool_calls: import_v46.z.array(
-            import_v46.z.object({
-              id: import_v46.z.string().optional().nullable(),
-              type: import_v46.z.literal("function"),
-              function: import_v46.z.object({
-                name: import_v46.z.string(),
-                arguments: import_v46.z.string()
-              }).passthrough()
-            }).passthrough()
-          ).optional(),
-          annotations: import_v46.z.array(
-            import_v46.z.union([
-              // URL citation from web search
-              import_v46.z.object({
-                type: import_v46.z.literal("url_citation"),
-                url_citation: import_v46.z.object({
-                  end_index: import_v46.z.number(),
-                  start_index: import_v46.z.number(),
-                  title: import_v46.z.string(),
-                  url: import_v46.z.string(),
-                  content: import_v46.z.string().optional()
-                }).passthrough()
-              }).passthrough(),
-              // File annotation from FileParserPlugin (old format)
-              import_v46.z.object({
-                type: import_v46.z.literal("file_annotation"),
-                file_annotation: import_v46.z.object({
-                  file_id: import_v46.z.string(),
-                  quote: import_v46.z.string().optional()
-                }).passthrough()
-              }).passthrough(),
-              // File annotation from FileParserPlugin (new format)
-              import_v46.z.object({
-                type: import_v46.z.literal("file"),
-                file: import_v46.z.object({
-                  hash: import_v46.z.string(),
-                  name: import_v46.z.string(),
-                  content: import_v46.z.array(
-                    import_v46.z.object({
-                      type: import_v46.z.string(),
-                      text: import_v46.z.string().optional()
-                    }).passthrough()
-                  ).optional()
-                }).passthrough()
-              }).passthrough()
-            ])
-          ).nullish()
-        }).passthrough(),
-        index: import_v46.z.number().nullish(),
-        logprobs: import_v46.z.object({
-          content: import_v46.z.array(
-            import_v46.z.object({
-              token: import_v46.z.string(),
-              logprob: import_v46.z.number(),
-              top_logprobs: import_v46.z.array(
-                import_v46.z.object({
-                  token: import_v46.z.string(),
-                  logprob: import_v46.z.number()
-                }).passthrough()
-              )
-            }).passthrough()
-          ).nullable()
-        }).passthrough().nullable().optional(),
-        finish_reason: import_v46.z.string().optional().nullable()
-      }).passthrough()
-    )
-  }),
-  // Error response (HTTP 200 with error payload)
-  OpenRouterErrorResponseSchema.extend({
-    user_id: import_v46.z.string().optional()
-  })
-]);
-var OpenRouterStreamChatCompletionChunkSchema = import_v46.z.union([
-  OpenRouterChatCompletionBaseResponseSchema.extend({
-    choices: import_v46.z.array(
-      import_v46.z.object({
-        delta: import_v46.z.object({
-          role: import_v46.z.enum(["assistant"]).optional(),
-          content: import_v46.z.string().nullish(),
-          reasoning: import_v46.z.string().nullish().optional(),
-          reasoning_details: ReasoningDetailArraySchema.nullish(),
-          images: ImageResponseArraySchema.nullish(),
-          tool_calls: import_v46.z.array(
-            import_v46.z.object({
-              index: import_v46.z.number().nullish(),
-              id: import_v46.z.string().nullish(),
-              type: import_v46.z.literal("function").optional(),
-              function: import_v46.z.object({
-                name: import_v46.z.string().nullish(),
-                arguments: import_v46.z.string().nullish()
-              }).passthrough()
-            }).passthrough()
-          ).nullish(),
-          annotations: import_v46.z.array(
-            import_v46.z.union([
-              // URL citation from web search
-              import_v46.z.object({
-                type: import_v46.z.literal("url_citation"),
-                url_citation: import_v46.z.object({
-                  end_index: import_v46.z.number(),
-                  start_index: import_v46.z.number(),
-                  title: import_v46.z.string(),
-                  url: import_v46.z.string(),
-                  content: import_v46.z.string().optional()
-                }).passthrough()
-              }).passthrough(),
-              // File annotation from FileParserPlugin (old format)
-              import_v46.z.object({
-                type: import_v46.z.literal("file_annotation"),
-                file_annotation: import_v46.z.object({
-                  file_id: import_v46.z.string(),
-                  quote: import_v46.z.string().optional()
-                }).passthrough()
-              }).passthrough(),
-              // File annotation from FileParserPlugin (new format)
-              import_v46.z.object({
-                type: import_v46.z.literal("file"),
-                file: import_v46.z.object({
-                  hash: import_v46.z.string(),
-                  name: import_v46.z.string(),
-                  content: import_v46.z.array(
-                    import_v46.z.object({
-                      type: import_v46.z.string(),
-                      text: import_v46.z.string().optional()
-                    }).passthrough()
-                  ).optional()
-                }).passthrough()
-              }).passthrough()
-            ])
-          ).nullish()
-        }).passthrough().nullish(),
-        logprobs: import_v46.z.object({
-          content: import_v46.z.array(
-            import_v46.z.object({
-              token: import_v46.z.string(),
-              logprob: import_v46.z.number(),
-              top_logprobs: import_v46.z.array(
-                import_v46.z.object({
-                  token: import_v46.z.string(),
-                  logprob: import_v46.z.number()
-                }).passthrough()
-              )
-            }).passthrough()
-          ).nullable()
-        }).passthrough().nullish(),
-        finish_reason: import_v46.z.string().nullable().optional(),
-        index: import_v46.z.number().nullish()
-      }).passthrough()
-    )
-  }),
-  OpenRouterErrorResponseSchema
-]);
-
-// src/chat/index.ts
-var OpenRouterChatLanguageModel = class {
-  constructor(modelId, settings, config) {
-    this.specificationVersion = "v2";
-    this.provider = "openrouter";
-    this.defaultObjectGenerationMode = "tool";
-    this.supportsImageUrls = true;
-    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;
-  }
-  getArgs({
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    frequencyPenalty,
-    presencePenalty,
-    seed,
-    stopSequences,
-    responseFormat,
-    topK,
-    tools,
-    toolChoice
-  }) {
-    var _a15;
-    const baseArgs = __spreadValues(__spreadValues({
-      // model id:
-      model: this.modelId,
-      models: this.settings.models,
-      // model specific settings:
-      logit_bias: this.settings.logitBias,
-      logprobs: this.settings.logprobs === true || typeof this.settings.logprobs === "number" ? true : void 0,
-      top_logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : void 0 : void 0,
-      user: this.settings.user,
-      parallel_tool_calls: this.settings.parallelToolCalls,
-      // standardized settings:
-      max_tokens: maxOutputTokens,
-      temperature,
-      top_p: topP,
-      frequency_penalty: frequencyPenalty,
-      presence_penalty: presencePenalty,
-      seed,
-      stop: stopSequences,
-      response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
-        type: "json_schema",
-        json_schema: __spreadValues({
-          schema: responseFormat.schema,
-          strict: true,
-          name: (_a15 = responseFormat.name) != null ? _a15 : "response"
-        }, responseFormat.description && {
-          description: responseFormat.description
-        })
-      } : { type: "json_object" } : void 0,
-      top_k: topK,
-      // messages:
-      messages: convertToOpenRouterChatMessages(prompt),
-      // OpenRouter specific settings:
-      include_reasoning: this.settings.includeReasoning,
-      reasoning: this.settings.reasoning,
-      usage: this.settings.usage,
-      // Web search settings:
-      plugins: this.settings.plugins,
-      web_search_options: this.settings.web_search_options,
-      // Provider routing settings:
-      provider: this.settings.provider,
-      // Debug settings:
-      debug: this.settings.debug
-    }, this.config.extraBody), this.settings.extraBody);
-    if (tools && tools.length > 0) {
-      const mappedTools = tools.filter(
-        (tool) => tool.type === "function"
-      ).map((tool) => ({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.inputSchema
-        }
-      }));
-      return __spreadProps(__spreadValues({}, baseArgs), {
-        tools: mappedTools,
-        tool_choice: toolChoice ? getChatCompletionToolChoice(toolChoice) : void 0
-      });
-    }
-    return baseArgs;
-  }
-  async doGenerate(options) {
-    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w;
-    const providerOptions = options.providerOptions || {};
-    const openrouterOptions = providerOptions.openrouter || {};
-    const args = __spreadValues(__spreadValues({}, this.getArgs(options)), openrouterOptions);
-    const { value: responseValue, responseHeaders } = await postJsonToApi({
-      url: this.config.url({
-        path: "/chat/completions",
-        modelId: this.modelId
-      }),
-      headers: combineHeaders(this.config.headers(), options.headers),
-      body: args,
-      failedResponseHandler: openrouterFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        OpenRouterNonStreamChatCompletionResponseSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    if ("error" in responseValue) {
-      const errorData = responseValue.error;
-      throw new APICallError({
-        message: errorData.message,
-        url: this.config.url({
-          path: "/chat/completions",
-          modelId: this.modelId
-        }),
-        requestBodyValues: args,
-        statusCode: 200,
-        responseHeaders,
-        data: errorData
-      });
-    }
-    const response = responseValue;
-    const choice = response.choices[0];
-    if (!choice) {
-      throw new NoContentGeneratedError({
-        message: "No choice in response"
-      });
-    }
-    const usageInfo = response.usage ? {
-      inputTokens: (_a15 = response.usage.prompt_tokens) != null ? _a15 : 0,
-      outputTokens: (_b = response.usage.completion_tokens) != null ? _b : 0,
-      totalTokens: ((_c = response.usage.prompt_tokens) != null ? _c : 0) + ((_d = response.usage.completion_tokens) != null ? _d : 0),
-      reasoningTokens: (_f = (_e = response.usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0,
-      cachedInputTokens: (_h = (_g = response.usage.prompt_tokens_details) == null ? void 0 : _g.cached_tokens) != null ? _h : 0
-    } : {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0,
-      reasoningTokens: 0,
-      cachedInputTokens: 0
-    };
-    const reasoningDetails = (_i = choice.message.reasoning_details) != null ? _i : [];
-    const reasoning = reasoningDetails.length > 0 ? reasoningDetails.map((detail) => {
-      switch (detail.type) {
-        case "reasoning.text" /* Text */: {
-          if (detail.text) {
-            return {
-              type: "reasoning",
-              text: detail.text,
-              providerMetadata: {
-                openrouter: {
-                  reasoning_details: [detail]
-                }
-              }
-            };
-          }
-          break;
-        }
-        case "reasoning.summary" /* Summary */: {
-          if (detail.summary) {
-            return {
-              type: "reasoning",
-              text: detail.summary,
-              providerMetadata: {
-                openrouter: {
-                  reasoning_details: [detail]
-                }
-              }
-            };
-          }
-          break;
-        }
-        case "reasoning.encrypted" /* Encrypted */: {
-          if (detail.data) {
-            return {
-              type: "reasoning",
-              text: "[REDACTED]",
-              providerMetadata: {
-                openrouter: {
-                  reasoning_details: [detail]
-                }
-              }
-            };
-          }
-          break;
-        }
-        default: {
-          detail;
-        }
-      }
-      return null;
-    }).filter((p) => p !== null) : choice.message.reasoning ? [
-      {
-        type: "reasoning",
-        text: choice.message.reasoning
-      }
-    ] : [];
-    const content = [];
-    content.push(...reasoning);
-    if (choice.message.content) {
+    if (response.outputText && !content.some((c) => c.type === "text")) {
       content.push({
         type: "text",
-        text: choice.message.content
+        text: response.outputText
       });
     }
-    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,
-          input: toolCall.function.arguments,
-          providerMetadata: {
-            openrouter: {
-              reasoning_details: reasoningDetails
-            }
-          }
-        });
-      }
-    }
-    if (choice.message.images) {
-      for (const image of choice.message.images) {
-        content.push({
-          type: "file",
-          mediaType: getMediaType(image.image_url.url, "image/jpeg"),
-          data: getBase64FromDataUrl(image.image_url.url)
-        });
-      }
-    }
-    if (choice.message.annotations) {
-      for (const annotation of choice.message.annotations) {
-        if (annotation.type === "url_citation") {
-          content.push({
-            type: "source",
-            sourceType: "url",
-            id: annotation.url_citation.url,
-            url: annotation.url_citation.url,
-            title: annotation.url_citation.title,
-            providerMetadata: {
-              openrouter: {
-                content: annotation.url_citation.content || ""
-              }
-            }
-          });
-        }
-      }
-    }
-    const fileAnnotations = (_k = choice.message.annotations) == null ? void 0 : _k.filter(
-      (a) => a.type === "file"
+    let finishReason = mapOpenRouterFinishReason(
+      response.status === "completed" ? "stop" : response.status ?? "stop"
     );
-    const hasToolCalls = choice.message.tool_calls && choice.message.tool_calls.length > 0;
-    const hasEncryptedReasoning = reasoningDetails.some(
-      (d) => d.type === "reasoning.encrypted" /* Encrypted */ && d.data
+    const hasToolCalls = content.some((c) => c.type === "tool-call");
+    if (hasToolCalls && hasEncryptedReasoning(reasoningDetails) && finishReason.unified === "stop") {
+      finishReason = { unified: "tool-calls", raw: finishReason.raw };
+    }
+    const usage = buildUsage(
+      response.usage ? {
+        inputTokens: response.usage.inputTokens,
+        outputTokens: response.usage.outputTokens
+      } : void 0
     );
-    const shouldOverrideFinishReason = hasToolCalls && hasEncryptedReasoning && choice.finish_reason === "stop";
-    const effectiveFinishReason = shouldOverrideFinishReason ? "tool-calls" : mapOpenRouterFinishReason(choice.finish_reason);
+    const providerMetadata = buildProviderMetadata({
+      id: response.id,
+      provider: void 0,
+      // Responses API doesn't expose provider in response
+      usage: response.usage ? {
+        promptTokens: response.usage.inputTokens,
+        completionTokens: response.usage.outputTokens,
+        totalTokens: response.usage.totalTokens,
+        cost: response.usage.cost ?? void 0,
+        // Map inputTokensDetails -> promptTokensDetails
+        promptTokensDetails: response.usage.inputTokensDetails ? {
+          cachedTokens: response.usage.inputTokensDetails.cachedTokens
+        } : void 0,
+        // Map outputTokensDetails -> completionTokensDetails
+        completionTokensDetails: response.usage.outputTokensDetails ? {
+          reasoningTokens: response.usage.outputTokensDetails.reasoningTokens
+        } : void 0
+      } : void 0
+    });
     return {
       content,
-      finishReason: effectiveFinishReason,
-      usage: usageInfo,
-      warnings: [],
-      providerMetadata: {
-        openrouter: OpenRouterProviderMetadataSchema.parse({
-          provider: (_l = response.provider) != null ? _l : "",
-          reasoning_details: (_m = choice.message.reasoning_details) != null ? _m : [],
-          annotations: fileAnnotations && fileAnnotations.length > 0 ? fileAnnotations : void 0,
-          usage: __spreadValues(__spreadValues(__spreadValues({
-            promptTokens: (_n = usageInfo.inputTokens) != null ? _n : 0,
-            completionTokens: (_o = usageInfo.outputTokens) != null ? _o : 0,
-            totalTokens: (_p = usageInfo.totalTokens) != null ? _p : 0,
-            cost: (_q = response.usage) == null ? void 0 : _q.cost
-          }, ((_s = (_r = response.usage) == null ? void 0 : _r.prompt_tokens_details) == null ? void 0 : _s.cached_tokens) != null ? {
-            promptTokensDetails: {
-              cachedTokens: response.usage.prompt_tokens_details.cached_tokens
-            }
-          } : {}), ((_u = (_t = response.usage) == null ? void 0 : _t.completion_tokens_details) == null ? void 0 : _u.reasoning_tokens) != null ? {
-            completionTokensDetails: {
-              reasoningTokens: response.usage.completion_tokens_details.reasoning_tokens
-            }
-          } : {}), ((_w = (_v = response.usage) == null ? void 0 : _v.cost_details) == null ? void 0 : _w.upstream_inference_cost) != null ? {
-            costDetails: {
-              upstreamInferenceCost: response.usage.cost_details.upstream_inference_cost
-            }
-          } : {})
-        })
+      finishReason,
+      usage,
+      warnings,
+      providerMetadata,
+      request: {
+        body: requestParams
       },
-      request: { body: args },
       response: {
         id: response.id,
-        modelId: response.model,
-        headers: responseHeaders
+        timestamp: new Date(response.createdAt * 1e3),
+        modelId: response.model
       }
     };
   }
   async doStream(options) {
-    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
-      }),
-      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
-        }, ((_a15 = this.settings.usage) == null ? void 0 : _a15.include) ? { include_usage: true } : {}) : void 0
-      }),
-      failedResponseHandler: openrouterFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler(
-        OpenRouterStreamChatCompletionChunkSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
+    const warnings = [];
+    const client = new import_sdk.OpenRouter({
+      apiKey: this.settings.apiKey,
+      serverURL: this.settings.baseURL,
+      userAgent: this.settings.userAgent
     });
-    const toolCalls = [];
-    let finishReason = "other";
-    const usage = {
-      inputTokens: Number.NaN,
-      outputTokens: Number.NaN,
-      totalTokens: Number.NaN,
-      reasoningTokens: Number.NaN,
-      cachedInputTokens: Number.NaN
+    const openRouterInput = convertToOpenRouterMessages(options.prompt);
+    const tools = convertToolsToResponsesFormat(options.tools, warnings);
+    const toolChoice = convertToolChoiceToResponsesFormat(options.toolChoice);
+    const text = convertResponseFormatToText(options.responseFormat);
+    const requestParams = {
+      model: this.modelId,
+      input: openRouterInput,
+      stream: true,
+      ...options.maxOutputTokens !== void 0 && {
+        maxOutputTokens: options.maxOutputTokens
+      },
+      ...options.temperature !== void 0 && {
+        temperature: options.temperature
+      },
+      ...options.topP !== void 0 && { topP: options.topP },
+      ...tools.length > 0 && { tools },
+      ...toolChoice !== void 0 && { toolChoice },
+      ...text !== void 0 && { text }
     };
-    const openrouterUsage = {};
-    const accumulatedReasoningDetails = [];
-    const accumulatedFileAnnotations = [];
-    let textStarted = false;
-    let reasoningStarted = false;
-    let textId;
-    let reasoningId;
-    let openrouterResponseId;
-    let provider;
-    return {
-      stream: response.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            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 });
-              return;
-            }
-            const value = chunk.value;
-            if ("error" in value) {
-              finishReason = "error";
-              controller.enqueue({ type: "error", error: value.error });
-              return;
-            }
-            if (value.provider) {
-              provider = value.provider;
-            }
-            if (value.id) {
-              openrouterResponseId = value.id;
-              controller.enqueue({
-                type: "response-metadata",
-                id: value.id
-              });
-            }
-            if (value.model) {
-              controller.enqueue({
-                type: "response-metadata",
-                modelId: value.model
-              });
-            }
-            if (value.usage != null) {
-              usage.inputTokens = value.usage.prompt_tokens;
-              usage.outputTokens = value.usage.completion_tokens;
-              usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
-              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: 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 upstreamInferenceCost = (_c = value.usage.cost_details) == null ? void 0 : _c.upstream_inference_cost;
-              if (upstreamInferenceCost != null) {
-                openrouterUsage.costDetails = {
-                  upstreamInferenceCost
-                };
-              }
-            }
-            const choice = value.choices[0];
-            if ((choice == null ? void 0 : choice.finish_reason) != null) {
-              finishReason = mapOpenRouterFinishReason(choice.finish_reason);
-            }
-            if ((choice == null ? void 0 : choice.delta) == null) {
-              return;
-            }
-            const delta = choice.delta;
-            const emitReasoningChunk = (chunkText, providerMetadata) => {
-              if (!reasoningStarted) {
-                reasoningId = openrouterResponseId || generateId();
-                controller.enqueue({
-                  providerMetadata,
-                  type: "reasoning-start",
-                  id: reasoningId
-                });
-                reasoningStarted = true;
-              }
-              controller.enqueue({
-                providerMetadata,
-                type: "reasoning-delta",
-                delta: chunkText,
-                id: reasoningId || generateId()
-              });
-            };
-            if (delta.reasoning_details && delta.reasoning_details.length > 0) {
-              for (const detail of delta.reasoning_details) {
-                if (detail.type === "reasoning.text" /* Text */) {
-                  const lastDetail = accumulatedReasoningDetails[accumulatedReasoningDetails.length - 1];
-                  if ((lastDetail == null ? void 0 : lastDetail.type) === "reasoning.text" /* Text */) {
-                    lastDetail.text = (lastDetail.text || "") + (detail.text || "");
-                    lastDetail.signature = lastDetail.signature || detail.signature;
-                    lastDetail.format = lastDetail.format || detail.format;
-                  } else {
-                    accumulatedReasoningDetails.push(__spreadValues({}, detail));
-                  }
-                } else {
-                  accumulatedReasoningDetails.push(detail);
-                }
-              }
-              const reasoningMetadata = {
-                openrouter: {
-                  reasoning_details: delta.reasoning_details
-                }
-              };
-              for (const detail of delta.reasoning_details) {
-                switch (detail.type) {
-                  case "reasoning.text" /* Text */: {
-                    if (detail.text) {
-                      emitReasoningChunk(detail.text, reasoningMetadata);
-                    }
-                    break;
-                  }
-                  case "reasoning.encrypted" /* Encrypted */: {
-                    if (detail.data) {
-                      emitReasoningChunk("[REDACTED]", reasoningMetadata);
-                    }
-                    break;
-                  }
-                  case "reasoning.summary" /* Summary */: {
-                    if (detail.summary) {
-                      emitReasoningChunk(detail.summary, reasoningMetadata);
-                    }
-                    break;
-                  }
-                  default: {
-                    detail;
-                    break;
-                  }
-                }
-              }
-            } else if (delta.reasoning) {
-              emitReasoningChunk(delta.reasoning);
-            }
-            if (delta.content) {
-              if (reasoningStarted && !textStarted) {
-                controller.enqueue({
-                  type: "reasoning-end",
-                  id: reasoningId || generateId()
-                });
-                reasoningStarted = false;
-              }
-              if (!textStarted) {
-                textId = openrouterResponseId || generateId();
-                controller.enqueue({
-                  type: "text-start",
-                  id: textId
-                });
-                textStarted = true;
-              }
-              controller.enqueue({
-                type: "text-delta",
-                delta: delta.content,
-                id: textId || generateId()
-              });
-            }
-            if (delta.annotations) {
-              for (const annotation of delta.annotations) {
-                if (annotation.type === "url_citation") {
-                  controller.enqueue({
-                    type: "source",
-                    sourceType: "url",
-                    id: annotation.url_citation.url,
-                    url: annotation.url_citation.url,
-                    title: annotation.url_citation.title,
-                    providerMetadata: {
-                      openrouter: {
-                        content: annotation.url_citation.content || ""
-                      }
-                    }
-                  });
-                } else if (annotation.type === "file") {
-                  const file = annotation.file;
-                  if (file && typeof file === "object" && "hash" in file && "name" in file) {
-                    accumulatedFileAnnotations.push(
-                      annotation
-                    );
-                  }
-                }
-              }
-            }
-            if (delta.tool_calls != null) {
-              for (const toolCallDelta of delta.tool_calls) {
-                const index = (_d = toolCallDelta.index) != null ? _d : toolCalls.length - 1;
-                if (toolCalls[index] == null) {
-                  if (toolCallDelta.type !== "function") {
-                    throw new InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'function' type.`
-                    });
-                  }
-                  if (toolCallDelta.id == null) {
-                    throw new InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'id' to be a string.`
-                    });
-                  }
-                  if (((_e = toolCallDelta.function) == null ? void 0 : _e.name) == null) {
-                    throw new InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'function.name' to be a string.`
-                    });
-                  }
-                  toolCalls[index] = {
-                    id: toolCallDelta.id,
-                    type: "function",
-                    function: {
-                      name: toolCallDelta.function.name,
-                      arguments: (_f = toolCallDelta.function.arguments) != null ? _f : ""
-                    },
-                    inputStarted: false,
-                    sent: false
-                  };
-                  const toolCall2 = toolCalls[index];
-                  if (toolCall2 == null) {
-                    throw new InvalidResponseDataError({
-                      data: { index, toolCallsLength: toolCalls.length },
-                      message: `Tool call at index ${index} is missing after creation.`
-                    });
-                  }
-                  if (((_g = toolCall2.function) == null ? void 0 : _g.name) != null && ((_h = toolCall2.function) == null ? void 0 : _h.arguments) != null && isParsableJson(toolCall2.function.arguments)) {
-                    toolCall2.inputStarted = true;
-                    controller.enqueue({
-                      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",
-                      toolCallId: toolCall2.id,
-                      toolName: toolCall2.function.name,
-                      input: toolCall2.function.arguments,
-                      providerMetadata: {
-                        openrouter: {
-                          reasoning_details: accumulatedReasoningDetails
-                        }
-                      }
-                    });
-                    toolCall2.sent = true;
-                  }
-                  continue;
-                }
-                const toolCall = toolCalls[index];
-                if (toolCall == null) {
-                  throw new InvalidResponseDataError({
-                    data: {
-                      index,
-                      toolCallsLength: toolCalls.length,
-                      toolCallDelta
-                    },
-                    message: `Tool call at index ${index} is missing during merge.`
-                  });
-                }
-                if (!toolCall.inputStarted) {
-                  toolCall.inputStarted = true;
-                  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-input-delta",
-                  id: toolCall.id,
-                  delta: (_l = toolCallDelta.function.arguments) != null ? _l : ""
-                });
-                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",
-                    toolCallId: (_o = toolCall.id) != null ? _o : generateId(),
-                    toolName: toolCall.function.name,
-                    input: toolCall.function.arguments,
-                    providerMetadata: {
-                      openrouter: {
-                        reasoning_details: accumulatedReasoningDetails
-                      }
-                    }
-                  });
-                  toolCall.sent = true;
-                }
-              }
-            }
-            if (delta.images != null) {
-              for (const image of delta.images) {
-                controller.enqueue({
-                  type: "file",
-                  mediaType: getMediaType(image.image_url.url, "image/jpeg"),
-                  data: getBase64FromDataUrl(image.image_url.url)
-                });
-              }
-            }
-          },
-          flush(controller) {
-            var _a16;
-            const hasToolCalls = toolCalls.length > 0;
-            const hasEncryptedReasoning = accumulatedReasoningDetails.some(
-              (d) => d.type === "reasoning.encrypted" /* Encrypted */ && d.data
-            );
-            if (hasToolCalls && hasEncryptedReasoning && finishReason === "stop") {
-              finishReason = "tool-calls";
-            }
-            if (finishReason === "tool-calls") {
-              for (const toolCall of toolCalls) {
-                if (toolCall && !toolCall.sent) {
-                  controller.enqueue({
-                    type: "tool-call",
-                    toolCallId: (_a16 = toolCall.id) != null ? _a16 : generateId(),
-                    toolName: toolCall.function.name,
-                    // Coerce invalid arguments to an empty JSON object
-                    input: isParsableJson(toolCall.function.arguments) ? toolCall.function.arguments : "{}",
-                    providerMetadata: {
-                      openrouter: {
-                        reasoning_details: accumulatedReasoningDetails
-                      }
-                    }
-                  });
-                  toolCall.sent = true;
-                }
-              }
-            }
-            if (reasoningStarted) {
-              controller.enqueue({
-                type: "reasoning-end",
-                id: reasoningId || generateId()
-              });
-            }
-            if (textStarted) {
-              controller.enqueue({
-                type: "text-end",
-                id: textId || generateId()
-              });
-            }
-            const openrouterMetadata = {
-              usage: openrouterUsage
-            };
-            if (provider !== void 0) {
-              openrouterMetadata.provider = provider;
-            }
-            if (accumulatedReasoningDetails.length > 0) {
-              openrouterMetadata.reasoning_details = accumulatedReasoningDetails;
-            }
-            if (accumulatedFileAnnotations.length > 0) {
-              openrouterMetadata.annotations = accumulatedFileAnnotations;
+    const combinedHeaders = (0, import_provider_utils.normalizeHeaders)(
+      (0, import_provider_utils.combineHeaders)(this.settings.headers, options.headers)
+    );
+    const eventStream = await client.beta.responses.send(requestParams, {
+      fetchOptions: {
+        signal: options.abortSignal,
+        headers: combinedHeaders
+      }
+    });
+    const state = createStreamState();
+    const transformedStream = new ReadableStream({
+      async start(controller) {
+        controller.enqueue({
+          type: "stream-start",
+          warnings
+        });
+        try {
+          for await (const event of eventStream) {
+            const parts = transformResponsesEvent(event, state);
+            for (const part of parts) {
+              controller.enqueue(part);
             }
-            controller.enqueue({
-              type: "finish",
-              finishReason,
-              usage,
-              providerMetadata: {
-                openrouter: openrouterMetadata
-              }
-            });
           }
-        })
-      ),
-      warnings: [],
-      request: { body: args },
-      response: { headers: responseHeaders }
+        } catch (error) {
+          controller.enqueue({
+            type: "error",
+            error
+          });
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return {
+      stream: transformedStream,
+      request: {
+        body: requestParams
+      }
     };
   }
 };
-
-// src/completion/convert-to-openrouter-completion-prompt.ts
-function convertToOpenRouterCompletionPrompt({
-  prompt,
-  inputFormat,
-  user = "user",
-  assistant = "assistant"
-}) {
-  if (inputFormat === "prompt" && prompt.length === 1 && prompt[0] && prompt[0].role === "user" && prompt[0].content.length === 1 && prompt[0].content[0] && prompt[0].content[0].type === "text") {
-    return { prompt: prompt[0].content[0].text };
-  }
-  let text = "";
-  if (prompt[0] && prompt[0].role === "system") {
-    text += `${prompt[0].content}
-
-`;
-    prompt = prompt.slice(1);
-  }
-  for (const { role, content } of prompt) {
-    switch (role) {
-      case "system": {
-        throw new InvalidPromptError({
-          message: `Unexpected system message in prompt: ${content}`,
-          prompt
+function createStreamState() {
+  return {
+    responseId: void 0,
+    responseModel: void 0,
+    responseCreated: void 0,
+    textStarted: false,
+    textId: "text-0",
+    reasoningStarted: false,
+    reasoningId: "reasoning-0",
+    textEnded: false,
+    reasoningEnded: false,
+    sourceIds: [],
+    toolCalls: /* @__PURE__ */ new Map()
+  };
+}
+function transformResponsesEvent(event, state) {
+  const parts = [];
+  switch (event.type) {
+    // Response lifecycle events
+    case "response.created":
+    case "response.in_progress": {
+      if (event.response) {
+        state.responseId = event.response.id;
+        state.responseModel = event.response.model;
+        state.responseCreated = event.response.createdAt;
+      }
+      break;
+    }
+    // Text streaming
+    case "response.output_text.delta": {
+      if (!state.textStarted) {
+        state.textStarted = true;
+        parts.push({
+          type: "text-start",
+          id: state.textId
         });
       }
-      case "user": {
-        const userMessage = content.map((part) => {
-          switch (part.type) {
-            case "text": {
-              return part.text;
-            }
-            case "file": {
-              throw new UnsupportedFunctionalityError({
-                functionality: "file attachments"
-              });
-            }
-            default: {
-              return "";
-            }
-          }
-        }).join("");
-        text += `${user}:
-${userMessage}
-
-`;
-        break;
+      if (event.delta && event.delta.length > 0) {
+        parts.push({
+          type: "text-delta",
+          id: state.textId,
+          delta: event.delta
+        });
       }
-      case "assistant": {
-        const assistantMessage = content.map(
-          (part) => {
-            switch (part.type) {
-              case "text": {
-                return part.text;
-              }
-              case "tool-call": {
-                throw new UnsupportedFunctionalityError({
-                  functionality: "tool-call messages"
-                });
-              }
-              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("");
-        text += `${assistant}:
-${assistantMessage}
-
-`;
-        break;
+      break;
+    }
+    case "response.output_text.done": {
+      if (state.textStarted && !state.textEnded) {
+        state.textEnded = true;
+        parts.push({
+          type: "text-end",
+          id: state.textId
+        });
       }
-      case "tool": {
-        throw new UnsupportedFunctionalityError({
-          functionality: "tool messages"
+      break;
+    }
+    // Reasoning streaming
+    case "response.reasoning_text.delta": {
+      if (!state.reasoningStarted) {
+        state.reasoningStarted = true;
+        parts.push({
+          type: "reasoning-start",
+          id: state.reasoningId
         });
       }
-      default: {
-        break;
+      if (event.delta && event.delta.length > 0) {
+        parts.push({
+          type: "reasoning-delta",
+          id: state.reasoningId,
+          delta: event.delta
+        });
       }
+      break;
     }
-  }
-  text += `${assistant}:
-`;
-  return {
-    prompt: text
-  };
-}
-
-// src/completion/schemas.ts
-var import_v47 = require("zod/v4");
-var OpenRouterCompletionChunkSchema = import_v47.z.union([
-  import_v47.z.object({
-    id: import_v47.z.string().optional(),
-    model: import_v47.z.string().optional(),
-    choices: import_v47.z.array(
-      import_v47.z.object({
-        text: import_v47.z.string(),
-        reasoning: import_v47.z.string().nullish().optional(),
-        reasoning_details: ReasoningDetailArraySchema.nullish(),
-        finish_reason: import_v47.z.string().nullish(),
-        index: import_v47.z.number().nullish(),
-        logprobs: import_v47.z.object({
-          tokens: import_v47.z.array(import_v47.z.string()),
-          token_logprobs: import_v47.z.array(import_v47.z.number()),
-          top_logprobs: import_v47.z.array(import_v47.z.record(import_v47.z.string(), import_v47.z.number())).nullable()
-        }).passthrough().nullable().optional()
-      }).passthrough()
-    ),
-    usage: import_v47.z.object({
-      prompt_tokens: import_v47.z.number(),
-      prompt_tokens_details: import_v47.z.object({
-        cached_tokens: import_v47.z.number()
-      }).passthrough().nullish(),
-      completion_tokens: import_v47.z.number(),
-      completion_tokens_details: import_v47.z.object({
-        reasoning_tokens: import_v47.z.number()
-      }).passthrough().nullish(),
-      total_tokens: import_v47.z.number(),
-      cost: import_v47.z.number().optional(),
-      cost_details: import_v47.z.object({
-        upstream_inference_cost: import_v47.z.number().nullish()
-      }).passthrough().nullish()
-    }).passthrough().nullish()
-  }).passthrough(),
-  OpenRouterErrorResponseSchema
-]);
-
-// src/completion/index.ts
-var OpenRouterCompletionLanguageModel = class {
-  constructor(modelId, settings, config) {
-    this.specificationVersion = "v2";
-    this.provider = "openrouter";
-    this.supportsImageUrls = true;
-    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;
-  }
-  getArgs({
-    prompt,
-    maxOutputTokens,
-    temperature,
-    topP,
-    frequencyPenalty,
-    presencePenalty,
-    seed,
-    responseFormat,
-    topK,
-    stopSequences,
-    tools,
-    toolChoice
-  }) {
-    const { prompt: completionPrompt } = convertToOpenRouterCompletionPrompt({
-      prompt,
-      inputFormat: "prompt"
-    });
-    if (tools == null ? void 0 : tools.length) {
-      throw new UnsupportedFunctionalityError({
-        functionality: "tools"
+    // Function call arguments streaming
+    case "response.function_call_arguments.delta": {
+      const toolCallId = event.itemId;
+      let toolState = state.toolCalls.get(toolCallId);
+      if (!toolState) {
+        toolState = { argumentsStarted: false };
+        state.toolCalls.set(toolCallId, toolState);
+      }
+      if (!toolState.argumentsStarted) {
+        toolState.argumentsStarted = true;
+        parts.push({
+          type: "tool-input-start",
+          id: toolCallId,
+          toolName: toolState.name ?? ""
+          // Will be filled in by output_item.added
+        });
+      }
+      if (event.delta && event.delta.length > 0) {
+        parts.push({
+          type: "tool-input-delta",
+          id: toolCallId,
+          delta: event.delta
+        });
+      }
+      break;
+    }
+    case "response.function_call_arguments.done": {
+      const toolCallId = event.itemId;
+      const toolState = state.toolCalls.get(toolCallId);
+      if (!toolState?.argumentsStarted) {
+        parts.push({
+          type: "tool-input-start",
+          id: toolCallId,
+          toolName: event.name
+        });
+        const args = event.arguments || "{}";
+        parts.push({
+          type: "tool-input-delta",
+          id: toolCallId,
+          delta: args
+        });
+      }
+      parts.push({
+        type: "tool-input-end",
+        id: toolCallId
       });
+      parts.push({
+        type: "tool-call",
+        toolCallId,
+        toolName: event.name,
+        input: event.arguments || "{}"
+      });
+      break;
+    }
+    // Output item events (for function call metadata)
+    case "response.output_item.added": {
+      if (event.item.type === "function_call") {
+        const funcItem = event.item;
+        const toolCallId = funcItem.callId ?? `tool-${event.outputIndex}`;
+        const toolState = state.toolCalls.get(toolCallId) ?? {
+          argumentsStarted: false
+        };
+        toolState.name = funcItem.name;
+        state.toolCalls.set(toolCallId, toolState);
+      }
+      break;
     }
-    if (toolChoice) {
-      throw new UnsupportedFunctionalityError({
-        functionality: "toolChoice"
+    // Annotation events (web search sources)
+    case "response.output_text.annotation.added": {
+      const annotation = event.annotation;
+      if (annotation.type === "url_citation") {
+        const urlAnnotation = annotation;
+        const sourceId = `source-${state.sourceIds.length}`;
+        state.sourceIds.push(sourceId);
+        parts.push({
+          type: "source",
+          sourceType: "url",
+          id: sourceId,
+          url: urlAnnotation.url,
+          title: urlAnnotation.title
+        });
+      }
+      break;
+    }
+    // Response completed - extract final usage data
+    case "response.completed": {
+      if (state.textStarted && !state.textEnded) {
+        state.textEnded = true;
+        parts.push({
+          type: "text-end",
+          id: state.textId
+        });
+      }
+      if (state.reasoningStarted && !state.reasoningEnded) {
+        state.reasoningEnded = true;
+        parts.push({
+          type: "reasoning-end",
+          id: state.reasoningId
+        });
+      }
+      const response = event.response;
+      parts.push({
+        type: "response-metadata",
+        id: response.id,
+        timestamp: response.createdAt ? new Date(response.createdAt * 1e3) : void 0,
+        modelId: response.model
       });
+      const finishReason = mapOpenRouterFinishReason(
+        response.status === "completed" ? "stop" : response.status ?? "stop"
+      );
+      const usage = buildUsage(
+        response.usage ? {
+          inputTokens: response.usage.inputTokens,
+          outputTokens: response.usage.outputTokens
+        } : void 0
+      );
+      const providerMetadata = buildProviderMetadata({
+        id: response.id,
+        provider: void 0,
+        // Responses API doesn't expose provider
+        usage: response.usage ? {
+          promptTokens: response.usage.inputTokens,
+          completionTokens: response.usage.outputTokens,
+          totalTokens: response.usage.totalTokens,
+          cost: response.usage.cost ?? void 0,
+          // Map inputTokensDetails -> promptTokensDetails
+          promptTokensDetails: response.usage.inputTokensDetails ? {
+            cachedTokens: response.usage.inputTokensDetails.cachedTokens
+          } : void 0,
+          // Map outputTokensDetails -> completionTokensDetails
+          completionTokensDetails: response.usage.outputTokensDetails ? {
+            reasoningTokens: response.usage.outputTokensDetails.reasoningTokens
+          } : void 0
+        } : void 0
+      });
+      parts.push({
+        type: "finish",
+        finishReason,
+        usage,
+        providerMetadata
+      });
+      break;
     }
-    return __spreadValues(__spreadValues({
-      // model id:
-      model: this.modelId,
-      models: this.settings.models,
-      // model specific settings:
-      logit_bias: this.settings.logitBias,
-      logprobs: typeof this.settings.logprobs === "number" ? this.settings.logprobs : typeof this.settings.logprobs === "boolean" ? this.settings.logprobs ? 0 : void 0 : void 0,
-      suffix: this.settings.suffix,
-      user: this.settings.user,
-      // standardized settings:
-      max_tokens: maxOutputTokens,
-      temperature,
-      top_p: topP,
-      frequency_penalty: frequencyPenalty,
-      presence_penalty: presencePenalty,
-      seed,
-      stop: stopSequences,
-      response_format: responseFormat,
-      top_k: topK,
-      // prompt:
-      prompt: completionPrompt,
-      // OpenRouter specific settings:
-      include_reasoning: this.settings.includeReasoning,
-      reasoning: this.settings.reasoning
-    }, this.config.extraBody), this.settings.extraBody);
-  }
-  async doGenerate(options) {
-    var _a15, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
-    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: combineHeaders(this.config.headers(), options.headers),
-      body: args,
-      failedResponseHandler: openrouterFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        OpenRouterCompletionChunkSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    if ("error" in response) {
-      const errorData = response.error;
-      throw new APICallError({
-        message: errorData.message,
-        url: this.config.url({
-          path: "/completions",
-          modelId: this.modelId
-        }),
-        requestBodyValues: args,
-        statusCode: 200,
-        responseHeaders,
-        data: errorData
+    // Response incomplete or failed
+    case "response.incomplete":
+    case "response.failed": {
+      if (state.textStarted && !state.textEnded) {
+        state.textEnded = true;
+        parts.push({
+          type: "text-end",
+          id: state.textId
+        });
+      }
+      if (state.reasoningStarted && !state.reasoningEnded) {
+        state.reasoningEnded = true;
+        parts.push({
+          type: "reasoning-end",
+          id: state.reasoningId
+        });
+      }
+      const response = event.response;
+      parts.push({
+        type: "response-metadata",
+        id: response.id,
+        timestamp: response.createdAt ? new Date(response.createdAt * 1e3) : void 0,
+        modelId: response.model
+      });
+      const finishReason = event.type === "response.failed" ? mapOpenRouterFinishReason("error") : mapOpenRouterFinishReason(response.status ?? "incomplete");
+      const usage = buildUsage(
+        response.usage ? {
+          inputTokens: response.usage.inputTokens,
+          outputTokens: response.usage.outputTokens
+        } : void 0
+      );
+      const providerMetadata = buildProviderMetadata({
+        id: response.id,
+        provider: void 0,
+        usage: response.usage ? {
+          promptTokens: response.usage.inputTokens,
+          completionTokens: response.usage.outputTokens,
+          totalTokens: response.usage.totalTokens,
+          cost: response.usage.cost ?? void 0,
+          // Map inputTokensDetails -> promptTokensDetails
+          promptTokensDetails: response.usage.inputTokensDetails ? {
+            cachedTokens: response.usage.inputTokensDetails.cachedTokens
+          } : void 0,
+          // Map outputTokensDetails -> completionTokensDetails
+          completionTokensDetails: response.usage.outputTokensDetails ? {
+            reasoningTokens: response.usage.outputTokensDetails.reasoningTokens
+          } : void 0
+        } : void 0
+      });
+      parts.push({
+        type: "finish",
+        finishReason,
+        usage,
+        providerMetadata
       });
+      break;
     }
-    const choice = response.choices[0];
-    if (!choice) {
-      throw new NoContentGeneratedError({
-        message: "No choice in OpenRouter completion response"
+    // Error event
+    case "error": {
+      const errorEvent = event;
+      parts.push({
+        type: "error",
+        error: new Error(
+          errorEvent.error?.message ?? "Unknown streaming error"
+        )
       });
+      break;
     }
+    // Ignored events (handled implicitly or not needed)
+    case "response.output_item.done":
+    case "response.content_part.added":
+    case "response.content_part.done":
+    case "response.refusal.delta":
+    case "response.refusal.done":
+    case "response.reasoning_text.done":
+    case "response.reasoning_summary_part.added":
+    case "response.reasoning_summary_part.done":
+    case "response.reasoning_summary_text.delta":
+    case "response.reasoning_summary_text.done":
+    case "response.image_generation_call.in_progress":
+    case "response.image_generation_call.generating":
+    case "response.image_generation_call.partial_image":
+    case "response.image_generation_call.completed":
+      break;
+  }
+  return parts;
+}
+function convertToolsToResponsesFormat(tools, warnings) {
+  if (!tools || tools.length === 0) {
+    return [];
+  }
+  return tools.map((tool) => {
+    if (tool.type !== "function") {
+      warnings.push({
+        type: "unsupported",
+        feature: `tool type '${tool.type}'`,
+        details: `Only 'function' type tools are supported. Tool '${tool.name ?? "unknown"}' has type '${tool.type}'.`
+      });
+      return null;
+    }
+    const functionTool = tool;
     return {
-      content: [
-        {
-          type: "text",
-          text: (_a15 = choice.text) != null ? _a15 : ""
-        }
-      ],
-      finishReason: mapOpenRouterFinishReason(choice.finish_reason),
-      usage: {
-        inputTokens: (_c = (_b = response.usage) == null ? void 0 : _b.prompt_tokens) != null ? _c : 0,
-        outputTokens: (_e = (_d = response.usage) == null ? void 0 : _d.completion_tokens) != null ? _e : 0,
-        totalTokens: ((_g = (_f = response.usage) == null ? void 0 : _f.prompt_tokens) != null ? _g : 0) + ((_i = (_h = response.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : 0),
-        reasoningTokens: (_l = (_k = (_j = response.usage) == null ? void 0 : _j.completion_tokens_details) == null ? void 0 : _k.reasoning_tokens) != null ? _l : 0,
-        cachedInputTokens: (_o = (_n = (_m = response.usage) == null ? void 0 : _m.prompt_tokens_details) == null ? void 0 : _n.cached_tokens) != null ? _o : 0
-      },
-      warnings: [],
-      response: {
-        headers: responseHeaders
-      }
+      type: "function",
+      name: functionTool.name,
+      description: functionTool.description ?? null,
+      parameters: functionTool.inputSchema
     };
+  }).filter((tool) => tool !== null);
+}
+function convertToolChoiceToResponsesFormat(toolChoice) {
+  if (!toolChoice) {
+    return void 0;
   }
-  async doStream(options) {
-    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: 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: createEventSourceResponseHandler(
-        OpenRouterCompletionChunkSchema
-      ),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    let finishReason = "other";
-    const usage = {
-      inputTokens: Number.NaN,
-      outputTokens: Number.NaN,
-      totalTokens: Number.NaN,
-      reasoningTokens: Number.NaN,
-      cachedInputTokens: Number.NaN
+  switch (toolChoice.type) {
+    case "auto":
+      return "auto";
+    case "none":
+      return "none";
+    case "required":
+      return "required";
+    case "tool":
+      return {
+        type: "function",
+        name: toolChoice.toolName
+      };
+    default:
+      return void 0;
+  }
+}
+function convertResponseFormatToText(responseFormat) {
+  if (!responseFormat) {
+    return void 0;
+  }
+  if (responseFormat.type === "text") {
+    return {
+      format: { type: "text" }
     };
-    const openrouterUsage = {};
+  }
+  if (responseFormat.type === "json") {
+    if (responseFormat.schema) {
+      return {
+        format: {
+          type: "json_schema",
+          name: responseFormat.name ?? "response",
+          description: responseFormat.description,
+          schema: responseFormat.schema
+        }
+      };
+    }
     return {
-      stream: response.pipeThrough(
-        new TransformStream({
-          transform(chunk, controller) {
-            var _a15, _b, _c;
-            if (!chunk.success) {
-              finishReason = "error";
-              controller.enqueue({ type: "error", error: chunk.error });
-              return;
-            }
-            const value = chunk.value;
-            if ("error" in value) {
-              finishReason = "error";
-              controller.enqueue({ type: "error", error: value.error });
-              return;
-            }
-            if (value.usage != null) {
-              usage.inputTokens = value.usage.prompt_tokens;
-              usage.outputTokens = value.usage.completion_tokens;
-              usage.totalTokens = value.usage.prompt_tokens + value.usage.completion_tokens;
-              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 upstreamInferenceCost = (_c = value.usage.cost_details) == null ? void 0 : _c.upstream_inference_cost;
-              if (upstreamInferenceCost != null) {
-                openrouterUsage.costDetails = {
-                  upstreamInferenceCost
-                };
-              }
-            }
-            const choice = value.choices[0];
-            if ((choice == null ? void 0 : choice.finish_reason) != null) {
-              finishReason = mapOpenRouterFinishReason(choice.finish_reason);
-            }
-            if ((choice == null ? void 0 : choice.text) != null) {
-              controller.enqueue({
-                type: "text-delta",
-                delta: choice.text,
-                id: generateId()
-              });
-            }
-          },
-          flush(controller) {
-            controller.enqueue({
-              type: "finish",
-              finishReason,
-              usage,
-              providerMetadata: {
-                openrouter: {
-                  usage: openrouterUsage
-                }
-              }
-            });
-          }
-        })
-      ),
-      response: {
-        headers: responseHeaders
-      }
+      format: { type: "json_object" }
     };
   }
-};
-
-// src/embedding/schemas.ts
-var import_v48 = require("zod/v4");
-var openrouterEmbeddingUsageSchema = import_v48.z.object({
-  prompt_tokens: import_v48.z.number(),
-  total_tokens: import_v48.z.number(),
-  cost: import_v48.z.number().optional()
-});
-var openrouterEmbeddingDataSchema = import_v48.z.object({
-  object: import_v48.z.literal("embedding"),
-  embedding: import_v48.z.array(import_v48.z.number()),
-  index: import_v48.z.number().optional()
-});
-var OpenRouterEmbeddingResponseSchema = import_v48.z.object({
-  id: import_v48.z.string().optional(),
-  object: import_v48.z.literal("list"),
-  data: import_v48.z.array(openrouterEmbeddingDataSchema),
-  model: import_v48.z.string(),
-  usage: openrouterEmbeddingUsageSchema.optional()
-});
+  return void 0;
+}
 
-// src/embedding/index.ts
+// src/embedding/openrouter-embedding-model.ts
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_sdk2 = require("@openrouter/sdk");
 var OpenRouterEmbeddingModel = class {
-  constructor(modelId, settings, config) {
-    this.specificationVersion = "v2";
-    this.provider = "openrouter";
-    this.maxEmbeddingsPerCall = void 0;
-    this.supportsParallelCalls = true;
+  specificationVersion = "v3";
+  provider = "openrouter";
+  modelId;
+  settings;
+  /**
+   * Maximum number of embeddings that can be generated in a single API call.
+   * Set to 2048 as a reasonable default for most embedding models.
+   */
+  maxEmbeddingsPerCall = 2048;
+  /**
+   * Whether the model supports parallel calls.
+   */
+  supportsParallelCalls = true;
+  constructor(modelId, settings) {
     this.modelId = modelId;
     this.settings = settings;
-    this.config = config;
   }
   async doEmbed(options) {
-    var _a15;
-    const { values, abortSignal, headers } = options;
-    const args = __spreadValues(__spreadValues({
+    const warnings = [];
+    const client = new import_sdk2.OpenRouter({
+      apiKey: this.settings.apiKey,
+      serverURL: this.settings.baseURL,
+      userAgent: this.settings.userAgent
+    });
+    const requestParams = {
       model: this.modelId,
-      input: values,
-      user: this.settings.user,
-      provider: this.settings.provider
-    }, this.config.extraBody), this.settings.extraBody);
-    const { value: responseValue, responseHeaders } = await postJsonToApi({
-      url: this.config.url({
-        path: "/embeddings",
-        modelId: this.modelId
-      }),
-      headers: combineHeaders(this.config.headers(), headers),
-      body: args,
-      failedResponseHandler: openrouterFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(
-        OpenRouterEmbeddingResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
+      input: options.values
+    };
+    const modelOptions = this.settings.modelOptions;
+    if (modelOptions?.user) {
+      requestParams.user = modelOptions.user;
+    }
+    if (modelOptions?.provider) {
+      requestParams.provider = modelOptions.provider;
+    }
+    const combinedHeaders = (0, import_provider_utils2.normalizeHeaders)(
+      (0, import_provider_utils2.combineHeaders)(this.settings.headers, options.headers)
+    );
+    const response = await client.embeddings.generate(requestParams, {
+      fetchOptions: {
+        signal: options.abortSignal,
+        headers: combinedHeaders
+      }
     });
-    return {
-      embeddings: responseValue.data.map((item) => item.embedding),
-      usage: responseValue.usage ? { tokens: responseValue.usage.prompt_tokens } : void 0,
-      providerMetadata: ((_a15 = responseValue.usage) == null ? void 0 : _a15.cost) ? {
-        openrouter: {
-          usage: {
-            cost: responseValue.usage.cost
-          }
-        }
-      } : void 0,
-      response: {
-        headers: responseHeaders,
-        body: responseValue
+    if (typeof response === "string") {
+      throw new Error(`Unexpected string response from embeddings API: ${response}`);
+    }
+    const responseBody = response;
+    const sortedData = [...responseBody.data].sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+    const embeddings = sortedData.map((item) => {
+      if (typeof item.embedding === "string") {
+        throw new Error("Base64 encoded embeddings are not supported");
       }
+      return item.embedding;
+    });
+    return {
+      embeddings,
+      usage: responseBody.usage ? { tokens: responseBody.usage.promptTokens } : void 0,
+      warnings
     };
   }
 };
 
-// src/facade.ts
-var OpenRouter = class {
+// src/image/openrouter-image-model.ts
+var OpenRouterImageModel = class {
+  specificationVersion = "v3";
+  provider = "openrouter";
+  modelId;
   /**
-   * Creates a new OpenRouter provider instance.
+   * Maximum number of images that can be generated in a single API call.
    */
-  constructor(options = {}) {
-    var _a15, _b;
-    this.baseURL = (_b = withoutTrailingSlash((_a15 = options.baseURL) != null ? _a15 : options.baseUrl)) != null ? _b : "https://openrouter.ai/api/v1";
-    this.apiKey = options.apiKey;
-    this.headers = options.headers;
-    this.api_keys = options.api_keys;
-  }
-  get baseConfig() {
-    return {
-      baseURL: this.baseURL,
-      headers: () => __spreadValues(__spreadValues({
-        Authorization: `Bearer ${loadApiKey({
-          apiKey: this.apiKey,
-          environmentVariableName: "OPENROUTER_API_KEY",
-          description: "OpenRouter"
-        })}`
-      }, this.headers), this.api_keys && Object.keys(this.api_keys).length > 0 && {
-        "X-Provider-API-Keys": JSON.stringify(this.api_keys)
-      })
-    };
-  }
-  chat(modelId, settings = {}) {
-    return new OpenRouterChatLanguageModel(modelId, settings, __spreadProps(__spreadValues({
-      provider: "openrouter.chat"
-    }, this.baseConfig), {
-      compatibility: "strict",
-      url: ({ path }) => `${this.baseURL}${path}`
-    }));
-  }
-  completion(modelId, settings = {}) {
-    return new OpenRouterCompletionLanguageModel(modelId, settings, __spreadProps(__spreadValues({
-      provider: "openrouter.completion"
-    }, this.baseConfig), {
-      compatibility: "strict",
-      url: ({ path }) => `${this.baseURL}${path}`
-    }));
-  }
-  textEmbeddingModel(modelId, settings = {}) {
-    return new OpenRouterEmbeddingModel(modelId, settings, __spreadProps(__spreadValues({
-      provider: "openrouter.embedding"
-    }, this.baseConfig), {
-      url: ({ path }) => `${this.baseURL}${path}`
-    }));
+  maxImagesPerCall = 1;
+  constructor(modelId, _settings) {
+    this.modelId = modelId;
   }
-  /**
-   * @deprecated Use textEmbeddingModel instead
-   */
-  embedding(modelId, settings = {}) {
-    return this.textEmbeddingModel(modelId, settings);
+  async doGenerate(_options) {
+    throw new Error(
+      "Image generation not yet supported. See: https://github.com/OpenRouterTeam/ai-sdk-provider/issues/new?title=Image+generation+support"
+    );
   }
 };
 
-// src/utils/remove-undefined.ts
-function removeUndefinedEntries2(record) {
-  return Object.fromEntries(
-    Object.entries(record).filter(([, value]) => value !== null)
+// src/openrouter-provider.ts
+function createOpenRouter(options = {}) {
+  const baseURL = (0, import_provider_utils3.withoutTrailingSlash)(
+    options.baseURL ?? options.baseUrl ?? "https://openrouter.ai/api/v1"
   );
-}
-
-// src/utils/with-user-agent-suffix.ts
-function withUserAgentSuffix(headers, ...userAgentSuffixParts) {
-  const cleanedHeaders = removeUndefinedEntries2(
-    headers != null ? headers : {}
+  const getModelSettings = (modelOptions) => {
+    const apiKey = (0, import_provider_utils3.loadApiKey)({
+      apiKey: options.apiKey,
+      environmentVariableName: "OPENROUTER_API_KEY",
+      description: "OpenRouter"
+    });
+    const providerUserAgentPart = `ai-sdk-provider/${"6.0.0-alpha.1"}`;
+    const baseUserAgent = options.headers?.["user-agent"] ?? options.headers?.["User-Agent"] ?? import_sdk3.SDK_METADATA.userAgent;
+    const userAgent = baseUserAgent.includes("ai-sdk-provider/") ? baseUserAgent : `${baseUserAgent} ${providerUserAgentPart}`;
+    const {
+      "User-Agent": _ignoredUserAgent,
+      "user-agent": _ignoredUserAgentLower,
+      ...forwardHeaders
+    } = options.headers ?? {};
+    return {
+      apiKey,
+      baseURL,
+      userAgent,
+      headers: Object.keys(forwardHeaders).length > 0 ? forwardHeaders : void 0,
+      fetch: options.fetch,
+      extraBody: options.extraBody,
+      modelOptions
+    };
+  };
+  const languageModel = (modelId, modelOptions) => {
+    return new OpenRouterChatLanguageModel(modelId, getModelSettings(modelOptions));
+  };
+  const embeddingModel = (modelId, modelOptions) => {
+    return new OpenRouterEmbeddingModel(modelId, getModelSettings(modelOptions));
+  };
+  const imageModel = (modelId, modelOptions) => {
+    return new OpenRouterImageModel(modelId, getModelSettings(modelOptions));
+  };
+  const provider = Object.assign(
+    // Make provider callable - calling it directly creates a language model
+    (modelId, modelOptions) => languageModel(modelId, modelOptions),
+    {
+      specificationVersion: "v3",
+      languageModel,
+      chat: languageModel,
+      embeddingModel,
+      textEmbeddingModel: embeddingModel,
+      imageModel,
+      image: imageModel,
+      embedding: embeddingModel
+    }
   );
-  const currentUserAgentHeader = cleanedHeaders["user-agent"] || "";
-  const newUserAgent = [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" ");
-  return __spreadProps(__spreadValues({}, cleanedHeaders), {
-    "user-agent": newUserAgent
-  });
+  return provider;
 }
 
 // src/version.ts
-var VERSION = false ? "0.0.0-test" : "1.5.4";
+var VERSION = "6.0.0-alpha.0";
 
-// src/provider.ts
-function createOpenRouter(options = {}) {
-  var _a15, _b, _c;
-  const baseURL = (_b = withoutTrailingSlash((_a15 = options.baseURL) != null ? _a15 : options.baseUrl)) != null ? _b : "https://openrouter.ai/api/v1";
-  const compatibility = (_c = options.compatibility) != null ? _c : "compatible";
-  const getHeaders = () => withUserAgentSuffix(
-    __spreadValues(__spreadValues({
-      Authorization: `Bearer ${loadApiKey({
-        apiKey: options.apiKey,
-        environmentVariableName: "OPENROUTER_API_KEY",
-        description: "OpenRouter"
-      })}`
-    }, options.headers), options.api_keys && Object.keys(options.api_keys).length > 0 && {
-      "X-Provider-API-Keys": JSON.stringify(options.api_keys)
-    }),
-    `ai-sdk/openrouter/${VERSION}`
-  );
-  const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
-    provider: "openrouter.chat",
-    url: ({ path }) => `${baseURL}${path}`,
-    headers: getHeaders,
-    compatibility,
-    fetch: options.fetch,
-    extraBody: options.extraBody
-  });
-  const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
-    provider: "openrouter.completion",
-    url: ({ path }) => `${baseURL}${path}`,
-    headers: getHeaders,
-    compatibility,
-    fetch: options.fetch,
-    extraBody: options.extraBody
-  });
-  const createEmbeddingModel = (modelId, settings = {}) => new OpenRouterEmbeddingModel(modelId, settings, {
-    provider: "openrouter.embedding",
-    url: ({ path }) => `${baseURL}${path}`,
-    headers: getHeaders,
-    fetch: options.fetch,
-    extraBody: options.extraBody
-  });
-  const createLanguageModel = (modelId, settings) => {
-    if (new.target) {
-      throw new Error(
-        "The OpenRouter model function cannot be called with the new keyword."
-      );
-    }
-    if (modelId === "openai/gpt-3.5-turbo-instruct") {
-      return createCompletionModel(
-        modelId,
-        settings
-      );
-    }
-    return createChatModel(modelId, settings);
-  };
-  const provider = (modelId, settings) => createLanguageModel(modelId, settings);
-  provider.languageModel = createLanguageModel;
-  provider.chat = createChatModel;
-  provider.completion = createCompletionModel;
-  provider.textEmbeddingModel = createEmbeddingModel;
-  provider.embedding = createEmbeddingModel;
-  return provider;
-}
-var openrouter = createOpenRouter({
-  compatibility: "strict"
-  // strict for OpenRouter API
-});
+// src/index.ts
+var openrouter = createOpenRouter();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  OpenRouter,
+  VERSION,
   createOpenRouter,
   openrouter
 });