@absolutejs/ai 0.0.50 → 0.0.52

package/dist/ai/index.js

@@ -43,6 +43,7 @@ class ProviderError extends Error {
   status;
   type;
   retryable;
+  metadata;
   statusPageUrl;
   constructor(init) {
     super(init.message, init.cause === undefined ? undefined : { cause: init.cause });
@@ -51,6 +52,7 @@ class ProviderError extends Error {
     this.status = init.status ?? null;
     this.type = init.type ?? null;
     this.retryable = init.retryable;
+    this.metadata = init.metadata;
     this.statusPageUrl = providerStatusPage(init.provider);
   }
   static fromResponse(provider, status, body, type) {
@@ -223,7 +225,8 @@ var withResilience = (provider, providerName = "unknown") => {
         yield* attempt(params, attemptNo + 1);
         return;
       }
-      noteFailure(providerName, providerError);
+      if (providerError.retryable)
+        noteFailure(providerName, providerError);
       throw providerError;
     }
   };
@@ -505,6 +508,9 @@ var buildRequestBody = (params, capabilityModel = params.model) => {
     content: mapOpenAIContent(msg),
     role: msg.role
   })), params);
+  if (params.systemPrompt) {
+    messages.unshift({ content: params.systemPrompt, role: "system" });
+  }
   const body = {
     messages,
     model: params.model,
@@ -648,6 +654,18 @@ var processDelta = function* (delta, pendingToolCalls) {
   if (typeof delta.content === "string") {
     yield { content: delta.content, type: "text" };
   }
+  if (isRecord(delta.audio)) {
+    const audio = delta.audio;
+    if (typeof audio.data === "string" || typeof audio.transcript === "string") {
+      yield {
+        audioId: typeof audio.id === "string" ? audio.id : undefined,
+        data: typeof audio.data === "string" ? audio.data : "",
+        format: typeof audio.format === "string" ? audio.format : "pcm16",
+        transcript: typeof audio.transcript === "string" ? audio.transcript : undefined,
+        type: "audio"
+      };
+    }
+  }
   if (isRecordArray(delta.tool_calls)) {
     processToolCallDeltas(delta.tool_calls, pendingToolCalls);
   }
@@ -716,7 +734,7 @@ var narrowUsageRecord = (parsed) => {
   }
   return normalized;
 };
-var processSSELine = function* (line, pendingToolCalls) {
+var processSSELine = function* (line, pendingToolCalls, providerName) {
   const trimmed = line.trim();
   if (!trimmed || !trimmed.startsWith("data: ")) {
     return;
@@ -732,6 +750,20 @@ var processSSELine = function* (line, pendingToolCalls) {
   } catch {
     return;
   }
+  if (isRecord(parsed.error)) {
+    const error = parsed.error;
+    const metadata2 = isRecord(error.metadata) ? error.metadata : undefined;
+    const status = typeof error.code === "number" ? error.code : null;
+    const type = metadata2 && typeof metadata2.error_type === "string" ? metadata2.error_type : typeof error.error_type === "string" ? error.error_type : null;
+    throw new ProviderError({
+      message: typeof error.message === "string" ? error.message : "OpenRouter stream failed",
+      metadata: metadata2,
+      provider: providerName,
+      retryable: status === 408 || status === 409 || status === 425 || status === 429 || status !== null && status >= 500,
+      status,
+      type
+    });
+  }
   const usageUpdate = narrowUsageRecord(parsed);
   if (usageUpdate) {
     yield { type: "usage_update", usage: usageUpdate };
@@ -748,11 +780,24 @@ var processSSELine = function* (line, pendingToolCalls) {
   if (!firstChoice) {
     return;
   }
+  if (isRecord(firstChoice.error)) {
+    const error = firstChoice.error;
+    const metadata2 = isRecord(error.metadata) ? error.metadata : undefined;
+    const status = typeof error.code === "number" ? error.code : null;
+    throw new ProviderError({
+      message: typeof error.message === "string" ? error.message : "OpenRouter stream failed",
+      metadata: metadata2,
+      provider: providerName,
+      retryable: status === 429 || status !== null && status >= 500,
+      status,
+      type: metadata2 && typeof metadata2.error_type === "string" ? metadata2.error_type : null
+    });
+  }
   yield* processChoice(firstChoice, pendingToolCalls);
 };
 var isUsageUpdate = (chunk) => chunk.type === "usage_update";
-var collectYieldableChunks = (line, pendingToolCalls, usageRef, metadataRef) => {
-  const allChunks = Array.from(processSSELine(line, pendingToolCalls));
+var collectYieldableChunks = (line, pendingToolCalls, usageRef, metadataRef, providerName) => {
+  const allChunks = Array.from(processSSELine(line, pendingToolCalls, providerName));
   const usageChunks = allChunks.filter(isUsageUpdate);
   const lastUsage = usageChunks.at(NOT_FOUND);
   if (lastUsage) {
@@ -772,9 +817,9 @@ var collectYieldableChunks = (line, pendingToolCalls, usageRef, metadataRef) =>
   }
   return allChunks.filter((chunk) => !isUsageUpdate(chunk) && chunk.type !== "response_metadata");
 };
-var processSSELines = function* (lines, pendingToolCalls, usageRef, metadataRef) {
+var processSSELines = function* (lines, pendingToolCalls, usageRef, metadataRef, providerName) {
   for (const line of lines) {
-    yield* collectYieldableChunks(line, pendingToolCalls, usageRef, metadataRef);
+    yield* collectYieldableChunks(line, pendingToolCalls, usageRef, metadataRef, providerName);
   }
 };
 var processStreamValue = (value, decoder, state) => {
@@ -787,16 +832,17 @@ var processStreamValue = (value, decoder, state) => {
 var drainReader = async function* (reader, decoder, state, signal) {
   for (let result = await reader.read();!result.done && !signal?.aborted; result = await reader.read()) {
     const lines = processStreamValue(result.value, decoder, state);
-    yield* processSSELines(lines, state.pendingToolCalls, state.usageRef, state.metadataRef);
+    yield* processSSELines(lines, state.pendingToolCalls, state.usageRef, state.metadataRef, state.providerName);
   }
 };
-var parseSSEStream = async function* (body, initialMetadata, signal) {
+var parseSSEStream = async function* (body, initialMetadata, providerName = "openai", signal) {
   const reader = body.getReader();
   const decoder = new TextDecoder;
   const state = {
     buffer: "",
     metadataRef: { current: initialMetadata },
     pendingToolCalls: new Map,
+    providerName,
     usageRef: { current: undefined }
   };
   try {
@@ -841,7 +887,7 @@ var fetchOpenAIStream = async function* (baseUrl, apiKey, body, fetchImpl, heade
       cacheStatus: response.headers.get("X-OpenRouter-Cache-Status") ?? undefined,
       cacheTtl: response.headers.get("X-OpenRouter-Cache-TTL") ?? undefined
     }
-  }, signal);
+  }, providerName, signal);
 };
 var openai = (config2) => {
   const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL;
@@ -958,7 +1004,12 @@ var mapContentToResponsesFormat = (content) => {
 };
 var hasToolBlocks = (content) => content.some((block) => block.type === "tool_use" || block.type === "tool_result");
 var convertToolBlock = (block) => {
+  if (block.type === "provider_data" && block.provider === "openrouter") {
+    return { ...block.data };
+  }
   if (block.type === "tool_use") {
+    if (block.providerData)
+      return { ...block.providerData };
     return {
       arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input),
       call_id: block.id,
@@ -1094,11 +1145,32 @@ var extractUsage2 = (response) => {
   const { usage } = response;
   const input = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
   const cached = isRecord2(usage.input_tokens_details) && typeof usage.input_tokens_details.cached_tokens === "number" ? usage.input_tokens_details.cached_tokens : 0;
-  return {
+  const outputDetails = isRecord2(usage.output_tokens_details) ? usage.output_tokens_details : undefined;
+  const inputDetails = isRecord2(usage.input_tokens_details) ? usage.input_tokens_details : undefined;
+  const costDetails = isRecord2(usage.cost_details) ? usage.cost_details : undefined;
+  const normalized = {
     cacheReadInputTokens: cached,
+    cacheWriteInputTokens: inputDetails && typeof inputDetails.cache_write_tokens === "number" ? inputDetails.cache_write_tokens : undefined,
+    costCredits: typeof usage.cost === "number" ? usage.cost : undefined,
     inputTokens: Math.max(0, input - cached),
-    outputTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0
+    outputTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0,
+    reasoningTokens: outputDetails && typeof outputDetails.reasoning_tokens === "number" ? outputDetails.reasoning_tokens : undefined,
+    upstreamInferenceCostCredits: costDetails && typeof costDetails.upstream_inference_cost === "number" ? costDetails.upstream_inference_cost : undefined
   };
+  if (isRecord2(usage.server_tool_use)) {
+    normalized.serverToolUse = Object.fromEntries(Object.entries(usage.server_tool_use).filter((entry) => typeof entry[1] === "number"));
+  }
+  return normalized;
+};
+var extractResponseMetadata = (response) => {
+  const providerMetadata = isRecord2(response.openrouter_metadata) ? response.openrouter_metadata : undefined;
+  const generationId = typeof response.id === "string" ? response.id : undefined;
+  const model = typeof response.model === "string" ? response.model : undefined;
+  const provider = typeof response.provider === "string" ? response.provider : undefined;
+  const serviceTier = typeof response.service_tier === "string" ? response.service_tier : undefined;
+  if (!providerMetadata && !generationId && !model && !provider && !serviceTier)
+    return;
+  return { generationId, model, provider, providerMetadata, serviceTier };
 };
 var extractMimeFormat = (mimeType) => {
   if (typeof mimeType !== "string") {
@@ -1155,6 +1227,7 @@ var processFunctionCallArgumentsDone = function* (parsed, pendingCalls) {
     id: callId || pending?.callId || itemId,
     input: parseToolInput2(args),
     name,
+    providerData: pending?.providerData ? { ...pending.providerData, arguments: args } : undefined,
     type: "tool_use"
   };
 };
@@ -1173,9 +1246,21 @@ var processOutputItemAdded = (parsed, pendingCalls) => {
   pendingCalls.set(itemId, {
     arguments: "",
     callId,
-    name
+    name,
+    providerData: { ...item }
   });
 };
+var processOutputItemDone = function* (parsed) {
+  if (!isRecord2(parsed.item) || typeof parsed.item.type !== "string")
+    return;
+  if (!parsed.item.type.startsWith("openrouter:"))
+    return;
+  yield {
+    data: { ...parsed.item },
+    provider: "openrouter",
+    type: "provider_event"
+  };
+};
 var isCompletedImageGeneration = (item) => item.type === "image_generation_call" && item.status === "completed" && typeof item.result === "string" && item.result !== "";
 var buildImageChunk = (item) => ({
   data: typeof item.result === "string" ? item.result : "",
@@ -1191,6 +1276,30 @@ var extractImageFromOutput = function* (output) {
     yield buildImageChunk(item);
   }
 };
+var extractCitationsFromOutput = function* (output) {
+  for (const item of output) {
+    if (!isRecordArray2(item.content))
+      continue;
+    for (const content of item.content) {
+      if (!Array.isArray(content.annotations))
+        continue;
+      for (const annotation of content.annotations) {
+        if (!isRecord2(annotation) || annotation.type !== "url_citation")
+          continue;
+        if (typeof annotation.url !== "string")
+          continue;
+        yield {
+          content: typeof annotation.content === "string" ? annotation.content : undefined,
+          endIndex: typeof annotation.end_index === "number" ? annotation.end_index : undefined,
+          startIndex: typeof annotation.start_index === "number" ? annotation.start_index : undefined,
+          title: typeof annotation.title === "string" ? annotation.title : undefined,
+          type: "citation",
+          url: annotation.url
+        };
+      }
+    }
+  }
+};
 var processCompleted = function* (parsed) {
   if (!isRecord2(parsed.response)) {
     yield { type: "done", usage: undefined };
@@ -1198,12 +1307,26 @@ var processCompleted = function* (parsed) {
   }
   const { response } = parsed;
   const usage = extractUsage2(response);
+  const metadata = extractResponseMetadata(response);
   if (isRecordArray2(response.output)) {
+    yield* extractCitationsFromOutput(response.output);
     yield* extractImageFromOutput(response.output);
   }
-  yield { type: "done", usage };
+  yield { metadata, type: "done", usage };
 };
-var processSSEEvent = function* (eventType, parsed, pendingCalls) {
+var responseFailure = (eventType, parsed, providerName) => {
+  const response = isRecord2(parsed.response) ? parsed.response : parsed;
+  const error = isRecord2(response.error) ? response.error : undefined;
+  const type = typeof response.error_type === "string" ? response.error_type : error && typeof error.code === "string" ? error.code : eventType;
+  return new ProviderError({
+    message: error && typeof error.message === "string" ? error.message : `OpenRouter Responses API: ${eventType}`,
+    metadata: response,
+    provider: providerName,
+    retryable: type === "rate_limit_exceeded" || type === "provider_overloaded" || type === "provider_unavailable" || type === "server",
+    type
+  });
+};
+var processSSEEvent = function* (eventType, parsed, pendingCalls, providerName) {
   switch (eventType) {
     case "response.reasoning_summary_text.delta": {
       const delta = typeof parsed.delta === "string" ? parsed.delta : "";
@@ -1224,6 +1347,9 @@ var processSSEEvent = function* (eventType, parsed, pendingCalls) {
     case "response.output_item.added":
       processOutputItemAdded(parsed, pendingCalls);
       break;
+    case "response.output_item.done":
+      yield* processOutputItemDone(parsed);
+      break;
     case "response.function_call_arguments.delta":
       processFunctionCallArgumentsDelta(parsed, pendingCalls);
       break;
@@ -1234,11 +1360,10 @@ var processSSEEvent = function* (eventType, parsed, pendingCalls) {
       yield* processCompleted(parsed);
       break;
     case "response.failed":
-    case "response.incomplete": {
-      const respObj = isRecord2(parsed.response) ? parsed.response : parsed;
-      const errMsg = isRecord2(respObj.error) && typeof respObj.error.message === "string" ? respObj.error.message : `OpenAI Responses API: ${eventType}`;
-      throw new Error(errMsg);
-    }
+    case "response.incomplete":
+    case "response.error":
+    case "error":
+      throw responseFailure(eventType, parsed, providerName);
   }
 };
 var flushSSEBuffer = function* (state) {
@@ -1247,7 +1372,7 @@ var flushSSEBuffer = function* (state) {
   }
   const parsed = parseJSON(state.buffer);
   if (parsed) {
-    yield* processSSEEvent(state.currentEvent, parsed, state.pendingCalls);
+    yield* processSSEEvent(state.currentEvent, parsed, state.pendingCalls, state.providerName);
   }
   state.currentEvent = "";
   state.buffer = "";
@@ -1285,17 +1410,19 @@ var drainReader2 = async function* (reader, decoder, state, signal) {
     yield* processSSELines2([textBuffer, ""], state);
   }
 };
-var parseSSEStream2 = async function* (body, signal) {
+var parseSSEStream2 = async function* (body, providerName, signal) {
   const reader = body.getReader();
   const decoder = new TextDecoder;
   const state = {
     buffer: "",
     currentEvent: "",
     pendingCalls: new Map,
-    usage: undefined
+    usage: undefined,
+    providerName
   };
   try {
     yield* drainReader2(reader, decoder, state, signal);
+    yield* flushSSEBuffer(state);
   } finally {
     reader.releaseLock();
   }
@@ -1323,7 +1450,7 @@ var fetchResponsesStream = async function* (baseUrl, apiKey, body, fetchImpl, he
       retryable: true
     });
   }
-  yield* parseSSEStream2(response.body, signal);
+  yield* parseSSEStream2(response.body, providerName, signal);
 };
 var resolveImageModels = (imageModels) => {
   if (!imageModels) {
@@ -1717,6 +1844,8 @@ var mapContentBlock2 = (block) => {
     };
   }
   if (block.type === "tool_use") {
+    if (block.providerData)
+      return { ...block.providerData };
     return {
       id: block.id,
       input: block.input,
@@ -1727,6 +1856,9 @@ var mapContentBlock2 = (block) => {
   if (block.type === "audio" || block.type === "video") {
     throw new Error(`Anthropic does not support ${block.type} content blocks`);
   }
+  if (block.type === "provider_data") {
+    return { ...block.data };
+  }
   return { text: block.content, type: "text" };
 };
 var mapMessage = (msg) => ({
@@ -1900,11 +2032,15 @@ var handleContentBlockStart = (parsed, state) => {
     state.currentToolName = getString(block, "name");
     state.toolInputJson = "";
     state.isThinkingBlock = false;
+    state.currentProviderBlock = undefined;
   } else if (block && block.type === "thinking") {
     state.isThinkingBlock = true;
     state.thinkingSignature = "";
+    state.currentProviderBlock = undefined;
   } else {
     state.isThinkingBlock = false;
+    state.currentProviderBlock = block && block.type !== "text" ? { ...block } : undefined;
+    state.providerBlockInputJson = "";
   }
 };
 var handleContentBlockDelta = (parsed, state) => {
@@ -1925,7 +2061,11 @@ var handleContentBlockDelta = (parsed, state) => {
     };
   }
   if (delta.type === "input_json_delta") {
-    state.toolInputJson += getString(delta, "partial_json");
+    if (state.currentProviderBlock) {
+      state.providerBlockInputJson += getString(delta, "partial_json");
+    } else {
+      state.toolInputJson += getString(delta, "partial_json");
+    }
   }
   if (delta.type === "signature_delta") {
     state.thinkingSignature += getString(delta, "signature");
@@ -1943,6 +2083,19 @@ var handleContentBlockStop = (state) => {
       type: "thinking"
     };
   }
+  if (state.currentProviderBlock) {
+    const data = { ...state.currentProviderBlock };
+    if (state.providerBlockInputJson) {
+      data.input = tryParseJson(state.providerBlockInputJson) ?? state.providerBlockInputJson;
+    }
+    state.currentProviderBlock = undefined;
+    state.providerBlockInputJson = "";
+    return {
+      data,
+      provider: state.providerName,
+      type: "provider_event"
+    };
+  }
   if (!state.currentToolId) {
     return;
   }
@@ -1962,11 +2115,39 @@ var extractUsage4 = (usageRecord, existingUsage) => {
   if (!usageRecord) {
     return existingUsage;
   }
-  return {
+  const normalized = {
     cacheReadInputTokens: getNumber(usageRecord, "cache_read_input_tokens") || existingUsage?.cacheReadInputTokens || 0,
     cacheWriteInputTokens: getNumber(usageRecord, "cache_creation_input_tokens") || existingUsage?.cacheWriteInputTokens || 0,
     inputTokens: getNumber(usageRecord, "input_tokens") || existingUsage?.inputTokens || 0,
-    outputTokens: getNumber(usageRecord, "output_tokens") || existingUsage?.outputTokens || 0
+    outputTokens: getNumber(usageRecord, "output_tokens") || existingUsage?.outputTokens || 0,
+    costCredits: getNumber(usageRecord, "cost") || existingUsage?.costCredits,
+    reasoningTokens: getNumber(usageRecord, "reasoning_tokens") || existingUsage?.reasoningTokens,
+    upstreamInferenceCostCredits: getNumber(getRecord(usageRecord, "cost_details") ?? {}, "upstream_inference_cost") || existingUsage?.upstreamInferenceCostCredits
+  };
+  const serverToolUse = getRecord(usageRecord, "server_tool_use");
+  if (serverToolUse) {
+    normalized.serverToolUse = Object.fromEntries(Object.entries(serverToolUse).filter((entry) => typeof entry[1] === "number"));
+  }
+  return normalized;
+};
+var mergeMetadata = (source, state) => {
+  const providerMetadata = getRecord(source, "openrouter_metadata");
+  const generationId = getString(source, "id") || undefined;
+  const model = getString(source, "model") || undefined;
+  const provider = getString(source, "provider") || undefined;
+  const serviceTier = getString(source, "service_tier") || undefined;
+  if (!providerMetadata && !generationId && !model && !provider && !serviceTier)
+    return;
+  state.metadata = {
+    ...state.metadata,
+    generationId: generationId ?? state.metadata?.generationId,
+    model: model ?? state.metadata?.model,
+    provider: provider ?? state.metadata?.provider,
+    providerMetadata: {
+      ...state.metadata?.providerMetadata,
+      ...providerMetadata
+    },
+    serviceTier: serviceTier ?? state.metadata?.serviceTier
   };
 };
 var handleMessageDelta = (parsed, state) => {
@@ -1984,15 +2165,18 @@ var handleMessageStart = (parsed, state) => {
   }
   const startUsage = getRecord(message, "usage");
   state.usage = extractUsage4(startUsage, state.usage);
+  mergeMetadata(message, state);
 };
-var handleError = (parsed) => {
+var handleError = (parsed, state) => {
   const error = getRecord(parsed, "error");
   const errorMessage = error ? getString(error, "message") : "";
-  const errorType = error ? getString(error, "type") : "";
-  const retryable = errorType === "overloaded_error" || errorType === "rate_limit_error" || errorType === "api_error";
+  const nativeErrorType = error ? getString(error, "type") : "";
+  const errorType = error ? getString(error, "error_type") || nativeErrorType : "";
+  const retryable = errorType === "provider_overloaded" || errorType === "rate_limit_exceeded" || errorType === "provider_unavailable" || errorType === "server" || nativeErrorType === "overloaded_error" || nativeErrorType === "rate_limit_error" || nativeErrorType === "api_error";
   throw new ProviderError({
     message: errorMessage || "Anthropic API error",
-    provider: "anthropic",
+    metadata: error,
+    provider: state.providerName,
     retryable,
     type: errorType || null
   });
@@ -2011,6 +2195,7 @@ var processEvent = (eventType, parsed, state) => {
     }
     case "message_delta": {
       handleMessageDelta(parsed, state);
+      mergeMetadata(parsed, state);
       return;
     }
     case "message_start": {
@@ -2018,14 +2203,16 @@ var processEvent = (eventType, parsed, state) => {
       return;
     }
     case "message_stop": {
+      mergeMetadata(parsed, state);
       return {
         stopReason: state.stopReason,
+        metadata: state.metadata,
         type: "done",
         usage: state.usage
       };
     }
     case "error": {
-      handleError(parsed);
+      handleError(parsed, state);
       return;
     }
     default: {
@@ -2090,7 +2277,7 @@ async function* streamChunks(reader, decoder, state, signal) {
     yield* result.chunks;
   }
 }
-async function* parseSSEStream4(body, signal) {
+async function* parseSSEStream4(body, providerName, signal) {
   const reader = body.getReader();
   const decoder = new TextDecoder;
   const state = {
@@ -2101,7 +2288,9 @@ async function* parseSSEStream4(body, signal) {
     stopReason: "",
     thinkingSignature: "",
     toolInputJson: "",
-    usage: undefined
+    usage: undefined,
+    providerName,
+    providerBlockInputJson: ""
   };
   try {
     yield* streamChunks(reader, decoder, state, signal);
@@ -2109,41 +2298,51 @@ async function* parseSSEStream4(body, signal) {
     reader.releaseLock();
   }
 }
-var fetchAndStream = async function* (baseUrl, config2, params, configuredMax, promptCaching) {
-  const body = buildRequestBody4(params, configuredMax, promptCaching);
+var fetchAndStream = async function* (baseUrl, config2, params, configuredMax, promptCaching, providerName) {
+  const builtBody = buildRequestBody4(params, configuredMax, promptCaching);
+  const body = config2.transformRequestBody ? config2.transformRequestBody(builtBody, params) : builtBody;
   const target = `${baseUrl}/v1/messages`;
   const fetchImpl = config2.fetch ?? fetch;
+  const token = config2.tokenSource ? await Promise.resolve(config2.tokenSource()) : config2.apiKey;
+  const suppliedHeaders = typeof config2.headers === "function" ? await config2.headers(params) : config2.headers ?? {};
+  const requestHeaders = new Headers(suppliedHeaders);
+  requestHeaders.set("Content-Type", "application/json");
+  if (config2.authStyle === "bearer") {
+    requestHeaders.set("Authorization", `Bearer ${token}`);
+  } else {
+    requestHeaders.set("anthropic-version", API_VERSION);
+    requestHeaders.set("x-api-key", token);
+  }
   const response = await fetchImpl(target, {
     ...h2IfHttps4(target),
     body: JSON.stringify(body),
-    headers: {
-      "anthropic-version": API_VERSION,
-      "Content-Type": "application/json",
-      "x-api-key": config2.apiKey
-    },
+    headers: requestHeaders,
     method: "POST",
     signal: params.signal
   });
   if (!response.ok) {
     const errorText = await response.text();
-    throw ProviderError.fromResponse("anthropic", response.status, errorText);
+    throw ProviderError.fromResponse(providerName, response.status, errorText);
   }
   if (!response.body) {
     throw new ProviderError({
-      message: "Anthropic API returned no response body",
-      provider: "anthropic",
+      message: `${providerName} Messages API returned no response body`,
+      provider: providerName,
       retryable: true
     });
   }
-  yield* parseSSEStream4(response.body, params.signal);
+  yield* parseSSEStream4(response.body, providerName, params.signal);
 };
 var anthropic = (config2) => {
+  if (!config2.apiKey && !config2.tokenSource)
+    throw new Error("anthropic() requires either apiKey or tokenSource");
   const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL4;
   const configuredMax = config2.maxTokens ?? DEFAULT_MAX_TOKENS;
   const promptCaching = config2.promptCaching ?? true;
+  const providerName = config2.providerName ?? "anthropic";
   return instrumentAIProvider({
-    stream: (params) => fetchAndStream(baseUrl, config2, params, configuredMax, promptCaching)
-  }, "anthropic");
+    stream: (params) => fetchAndStream(baseUrl, config2, params, configuredMax, promptCaching, providerName)
+  }, providerName);
 };
 
 // src/ai/providers/ollama.ts
@@ -2385,7 +2584,46 @@ var ollama = (config2 = {}) => {
 };
 
 // src/ai/providers/openrouterClient.ts
+var OPENROUTER_PRICING_KEYS = [
+  "prompt",
+  "completion",
+  "request",
+  "image",
+  "web_search",
+  "internal_reasoning",
+  "input_cache_read",
+  "input_cache_write"
+];
+var estimateOpenRouterCost = (pricing, units) => {
+  const components = {};
+  let total = 0;
+  for (const key of OPENROUTER_PRICING_KEYS) {
+    const quantity = units[key];
+    if (quantity === undefined)
+      continue;
+    if (!Number.isFinite(quantity) || quantity < 0)
+      throw new Error(`OpenRouter ${key} units must be non-negative`);
+    const rawPrice = pricing[key];
+    if (rawPrice === undefined)
+      continue;
+    const price = Number(rawPrice);
+    if (!Number.isFinite(price) || price < 0)
+      throw new Error(`OpenRouter ${key} price must be non-negative`);
+    components[key] = price * quantity;
+    total += components[key];
+  }
+  return { components, total };
+};
+var estimateOpenRouterModelCost = (model, units) => estimateOpenRouterCost(model.pricing ?? {}, units);
 var DEFAULT_BASE_URL6 = "https://openrouter.ai/api/v1";
+var DEFAULT_BATCH_BASE_URL = "https://openrouter.ai/api/beta";
+var DEFAULT_SITE_URL = "https://openrouter.ai";
+var TERMINAL_BATCH_STATUSES = new Set([
+  "completed",
+  "failed",
+  "expired",
+  "cancelled"
+]);
 var withoutLatestPrefix = (model) => model.startsWith("~") ? model.slice(1) : model;
 var openRouterModelMatchesRule = (model, rule) => {
   const normalizedModel = withoutLatestPrefix(model);
@@ -2399,6 +2637,22 @@ var assertAllowedModel = (model, allowedModels) => {
     return;
   throw new Error(`OpenRouter model "${model}" is not allowed`);
 };
+var assertAllowedModelsInValue = (value, allowedModels, key = "") => {
+  if (key === "model" && typeof value === "string")
+    assertAllowedModel(value, allowedModels);
+  if ((key === "models" || key === "analysis_models" || key === "allowed_models") && Array.isArray(value)) {
+    for (const model of value)
+      if (typeof model === "string")
+        assertAllowedModel(model, allowedModels);
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      assertAllowedModelsInValue(item, allowedModels);
+  } else if (value && typeof value === "object") {
+    for (const [childKey, child] of Object.entries(value))
+      assertAllowedModelsInValue(child, allowedModels, childKey);
+  }
+};
 var normalizePath = (path) => path.startsWith("/") ? path : `/${path}`;
 var encodeModelPath = (model) => model.split("/").map(encodeURIComponent).join("/");
 var withQuery = (url, query) => {
@@ -2411,13 +2665,142 @@ var withQuery = (url, query) => {
   }
   return result.toString();
 };
+var parseImageSSE = async function* (response) {
+  if (!response.body)
+    throw new Error("OpenRouter image stream has no body");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    for (;; ) {
+      const result = await reader.read();
+      buffer += decoder.decode(result.value, { stream: !result.done });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: "))
+          continue;
+        const data = line.slice(6);
+        if (data === "[DONE]")
+          return;
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed && typeof parsed === "object" && "type" in parsed)
+            yield parsed;
+        } catch {}
+      }
+      if (result.done)
+        break;
+    }
+    if (buffer.startsWith("data: ")) {
+      const parsed = JSON.parse(buffer.slice(6));
+      if (parsed && typeof parsed === "object" && "type" in parsed)
+        yield parsed;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+};
+var toBytes = (value) => typeof value === "string" ? new TextEncoder().encode(value) : value;
+var toBase64Url = (bytes) => {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+};
+var generateOpenRouterPKCE = async () => {
+  const random = crypto.getRandomValues(new Uint8Array(32));
+  const codeVerifier = toBase64Url(random);
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(codeVerifier));
+  return {
+    codeChallenge: toBase64Url(new Uint8Array(digest)),
+    codeChallengeMethod: "S256",
+    codeVerifier
+  };
+};
+var createOpenRouterAuthorizationUrl = (options = {}) => {
+  const url = new URL("/auth", options.baseUrl ?? DEFAULT_SITE_URL);
+  if (options.callbackUrl)
+    url.searchParams.set("callback_url", options.callbackUrl);
+  if (options.codeChallenge)
+    url.searchParams.set("code_challenge", options.codeChallenge);
+  if (options.codeChallengeMethod)
+    url.searchParams.set("code_challenge_method", options.codeChallengeMethod);
+  if (options.keyLabel)
+    url.searchParams.set("key_label", options.keyLabel);
+  return url.toString();
+};
+var exchangeOpenRouterAuthCode = async (body, options = {}) => {
+  const response = await (options.fetch ?? globalThis.fetch)(`${(options.baseUrl ?? DEFAULT_BASE_URL6).replace(/\/$/, "")}/auth/keys`, {
+    body: JSON.stringify(body),
+    headers: { "Content-Type": "application/json" },
+    method: "POST"
+  });
+  if (!response.ok)
+    throw ProviderError.fromResponse("openrouter", response.status, await response.text());
+  return response.json();
+};
+var createOpenRouterKeyLinks = async (key, siteUrl = DEFAULT_SITE_URL) => {
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(key)));
+  const hash = Array.from(digest, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  const root = siteUrl.replace(/\/$/, "");
+  return {
+    hash,
+    logsUrl: `${root}/logs?api_key_hash=${hash}`,
+    settingsUrl: `${root}/keys/${hash}`
+  };
+};
+var hexToBytes = (hex) => {
+  if (!/^[0-9a-f]+$/iu.test(hex) || hex.length % 2 !== 0)
+    return;
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let index = 0;index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+};
+var constantTimeEqual = (left, right) => {
+  if (left.length !== right.length)
+    return false;
+  let mismatch = 0;
+  for (let index = 0;index < left.length; index += 1)
+    mismatch |= (left[index] ?? 0) ^ (right[index] ?? 0);
+  return mismatch === 0;
+};
+var verifyOpenRouterWebhookSignature = async (options) => {
+  const fields = new Map(options.header.split(",").map((part) => {
+    const [key2, ...rest] = part.trim().split("=");
+    return [key2, rest.join("=")];
+  }));
+  const timestamp = fields.get("t");
+  const supplied = fields.get("v1");
+  if (!timestamp || !supplied)
+    return false;
+  const timestampNumber = Number(timestamp);
+  const now = options.nowSeconds ?? Math.floor(Date.now() / 1000);
+  const tolerance = options.toleranceSeconds ?? 300;
+  if (!Number.isFinite(timestampNumber) || Math.abs(now - timestampNumber) > tolerance)
+    return false;
+  const key = await crypto.subtle.importKey("raw", Uint8Array.from(toBytes(options.secret)).buffer, { hash: "SHA-256", name: "HMAC" }, false, ["sign"]);
+  const prefix = new TextEncoder().encode(`${timestamp},`);
+  const body = toBytes(options.body);
+  const payload = new Uint8Array(prefix.length + body.length);
+  payload.set(prefix);
+  payload.set(body, prefix.length);
+  const expected = new Uint8Array(await crypto.subtle.sign("HMAC", key, payload.buffer));
+  const suppliedBytes = hexToBytes(supplied);
+  return suppliedBytes ? constantTimeEqual(expected, suppliedBytes) : false;
+};
 var createOpenRouterClient = (config2) => {
   if (!config2.apiKey && !config2.tokenSource)
     throw new Error("createOpenRouterClient() requires either apiKey or tokenSource");
   const baseUrl = (config2.baseUrl ?? DEFAULT_BASE_URL6).replace(/\/$/, "");
+  const batchBaseUrl = (config2.batchBaseUrl ?? (config2.baseUrl ? new URL("../beta", `${baseUrl}/`).toString() : DEFAULT_BATCH_BASE_URL)).replace(/\/$/, "");
   const fetchImpl = config2.fetch ?? globalThis.fetch;
   const allowedModels = config2.allowedModels ? [...config2.allowedModels] : undefined;
-  const requestRaw = async (path, options = {}) => {
+  const defaultWorkspaceId = config2.workspaceId;
+  const requestRawAt = async (rootUrl, path, options = {}) => {
     const token = config2.tokenSource ? await Promise.resolve(config2.tokenSource()) : config2.apiKey;
     const suppliedHeaders = typeof config2.headers === "function" ? await config2.headers() : config2.headers ?? {};
     const headers = new Headers(suppliedHeaders);
@@ -2431,13 +2814,16 @@ var createOpenRouterClient = (config2) => {
       body = JSON.stringify(options.body);
     }
     const { query, ...requestInit } = options;
-    const response = await fetchImpl(withQuery(`${baseUrl}${normalizePath(path)}`, options.query), { ...requestInit, body, headers });
+    const response = await fetchImpl(withQuery(`${rootUrl}${normalizePath(path)}`, options.query), { ...requestInit, body, headers });
     if (!response.ok) {
       throw ProviderError.fromResponse("openrouter", response.status, await response.text());
     }
     return response;
   };
+  const requestRaw = (path, options = {}) => requestRawAt(baseUrl, path, options);
   const request = async (path, options = {}) => (await requestRaw(path, options)).json();
+  const requestBatch = async (path, options = {}) => (await requestRawAt(batchBaseUrl, path, options)).json();
+  const getBatch = (id) => requestBatch(`/batches/${encodeURIComponent(id)}`);
   const listModels = async (query) => {
     const result = await request("/models", { query });
     if (!allowedModels)
@@ -2456,10 +2842,45 @@ var createOpenRouterClient = (config2) => {
     };
   };
   return {
-    cancelBatch: (id) => request(`/batches/${encodeURIComponent(id)}/cancel`, {
+    addWorkspaceMembers: (id, userIds) => request(`/workspaces/${encodeURIComponent(id)}/members/add`, { body: { user_ids: [...userIds] }, method: "POST" }),
+    createAuthCode: (body) => request("/auth/keys/code", {
+      body: {
+        ...body,
+        workspace_id: body.workspace_id ?? defaultWorkspaceId
+      },
       method: "POST"
     }),
-    createBatch: (body) => request("/batches", { body, method: "POST" }),
+    createPresetFromChatCompletions: (slug, body) => {
+      assertAllowedModelsInValue(body, allowedModels);
+      return request(`/presets/${encodeURIComponent(slug)}/chat/completions`, { body, method: "POST" });
+    },
+    createPresetFromMessages: (slug, body) => {
+      assertAllowedModelsInValue(body, allowedModels);
+      return request(`/presets/${encodeURIComponent(slug)}/messages`, { body, method: "POST" });
+    },
+    createPresetFromResponses: (slug, body) => {
+      assertAllowedModelsInValue(body, allowedModels);
+      return request(`/presets/${encodeURIComponent(slug)}/responses`, { body, method: "POST" });
+    },
+    createWorkspace: (body) => {
+      assertAllowedModelsInValue(body, allowedModels);
+      return request("/workspaces", {
+        body,
+        method: "POST"
+      });
+    },
+    createBatch: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return requestBatch("/batches", {
+        body: {
+          endpoint: body.endpoint,
+          model: body.model,
+          requests: body.requests,
+          ...body.completion_window ? { completion_window: body.completion_window } : {}
+        },
+        method: "POST"
+      });
+    },
     createEmbedding: (body) => {
       assertAllowedModel(body.model, allowedModels);
       return request("/embeddings", {
@@ -2474,6 +2895,17 @@ var createOpenRouterClient = (config2) => {
         method: "POST"
       });
     },
+    deleteFile: (id, workspaceId = defaultWorkspaceId) => request(`/files/${encodeURIComponent(id)}`, { method: "DELETE", query: { workspace_id: workspaceId } }),
+    deleteWorkspace: (id) => request(`/workspaces/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    }),
+    deleteWorkspaceBudget: (id, interval) => request(`/workspaces/${encodeURIComponent(id)}/budgets/${interval}`, { method: "DELETE" }),
+    downloadFile: (id, workspaceId = defaultWorkspaceId) => requestRaw(`/files/${encodeURIComponent(id)}/content`, {
+      query: { workspace_id: workspaceId }
+    }),
+    downloadVideo: (id, index = 0) => requestRaw(`/videos/${encodeURIComponent(id)}/content`, {
+      query: { index }
+    }),
     generateVideo: (body) => {
       assertAllowedModel(body.model, allowedModels);
       return request("/videos", {
@@ -2481,25 +2913,90 @@ var createOpenRouterClient = (config2) => {
         method: "POST"
       });
     },
-    getBatch: (id) => request(`/batches/${encodeURIComponent(id)}`),
+    getBatch,
+    getActivity: (query) => request("/activity", {
+      query: {
+        ...query,
+        workspace_id: query?.workspace_id ?? defaultWorkspaceId
+      }
+    }),
+    getAnalyticsMeta: () => request("/analytics/meta"),
     getCredits: () => request("/credits"),
     getCurrentKey: () => request("/key"),
+    getFile: (id, workspaceId = defaultWorkspaceId) => request(`/files/${encodeURIComponent(id)}`, {
+      query: { workspace_id: workspaceId }
+    }),
     getGeneration: (id) => request("/generation", {
       query: { id }
     }),
+    getGenerationContent: (id) => request("/generation/content", {
+      query: { id }
+    }),
     getModelEndpoints: (model) => {
       assertAllowedModel(model, allowedModels);
       return request(`/models/${encodeModelPath(model)}/endpoints`);
     },
+    getModel: (model) => {
+      assertAllowedModel(model, allowedModels);
+      return request(`/model/${encodeModelPath(model)}`);
+    },
+    getImageModelEndpoints: (model) => {
+      assertAllowedModel(model, allowedModels);
+      return request(`/images/models/${encodeModelPath(model)}/endpoints`);
+    },
+    getPreset: (slug) => request(`/presets/${encodeURIComponent(slug)}`),
+    getPresetVersion: (slug, version) => request(`/presets/${encodeURIComponent(slug)}/versions/${encodeURIComponent(String(version))}`),
+    getTaskClassifications: (window2 = "7d") => request("/classifications/task", {
+      query: { window: window2 }
+    }),
     getVideo: (id) => request(`/videos/${encodeURIComponent(id)}`),
+    getWorkspace: (id) => request(`/workspaces/${encodeURIComponent(id)}`),
     listImageModels: async () => filterModelList(await request("/images/models")),
+    listFiles: (query) => request("/files", {
+      query: {
+        ...query,
+        workspace_id: query?.workspace_id ?? defaultWorkspaceId
+      }
+    }),
     listModels,
-    listPresets: (offset = 0, limit = 100) => request("/presets", { query: { limit, offset } }),
+    listUserModels: async () => filterModelList(await request("/models/user")),
+    listZdrEndpoints: async () => {
+      const result = await request("/endpoints/zdr");
+      if (!allowedModels)
+        return result;
+      return {
+        ...result,
+        data: result.data.filter((endpoint) => allowedModels.some((rule) => openRouterModelMatchesRule(endpoint.model_id, rule)))
+      };
+    },
+    countModels: (outputModalities) => request("/models/count", {
+      query: { output_modalities: outputModalities }
+    }),
+    listPresets: (offset = 0, limit = 100) => request("/presets", {
+      query: { limit, offset }
+    }),
+    listPresetVersions: (slug, offset = 0, limit = 100) => request(`/presets/${encodeURIComponent(slug)}/versions`, { query: { limit, offset } }),
     listProviders: () => request("/providers"),
     listRerankModels: async () => filterModelList(await request("/rerank/models")),
     listVideoModels: async () => filterModelList(await request("/videos/models")),
+    listWorkspaceBudgets: (id) => request(`/workspaces/${encodeURIComponent(id)}/budgets`),
+    listWorkspaces: (offset = 0, limit = 100) => request("/workspaces", { query: { limit, offset } }),
+    queryAnalytics: (body) => request("/analytics/query", {
+      body,
+      method: "POST"
+    }),
+    removeWorkspaceMembers: (id, userIds) => request(`/workspaces/${encodeURIComponent(id)}/members/remove`, { body: { user_ids: [...userIds] }, method: "POST" }),
     request,
     requestRaw,
+    streamImage: async function* (body, options = {}) {
+      assertAllowedModel(body.model, allowedModels);
+      const response = await requestRaw("/images", {
+        ...options,
+        body: { ...body, stream: true },
+        method: "POST"
+      });
+      yield* parseImageSSE(response);
+    },
     respond: (body) => {
       assertAllowedModel(body.model, allowedModels);
       return body.stream ? requestRaw("/responses", { body, method: "POST" }) : request("/responses", {
@@ -2531,6 +3028,51 @@ var createOpenRouterClient = (config2) => {
         body,
         method: "POST"
       });
+    },
+    uploadFile: (file, options = {}) => {
+      const body = new FormData;
+      if (options.filename)
+        body.append("file", file, options.filename);
+      else
+        body.append("file", file);
+      return request("/files", {
+        body,
+        method: "POST",
+        query: { workspace_id: options.workspaceId ?? defaultWorkspaceId }
+      });
+    },
+    updateWorkspace: (id, body) => {
+      assertAllowedModelsInValue(body, allowedModels);
+      return request(`/workspaces/${encodeURIComponent(id)}`, { body, method: "PATCH" });
+    },
+    upsertWorkspaceBudget: (id, interval, limitUsd) => request(`/workspaces/${encodeURIComponent(id)}/budgets/${interval}`, { body: { limit_usd: limitUsd }, method: "PUT" }),
+    waitForBatch: async (id, options = {}) => {
+      const intervalMs = options.intervalMs ?? 1000;
+      const timeoutMs = options.timeoutMs;
+      if (!Number.isFinite(intervalMs) || intervalMs < 0)
+        throw new Error("OpenRouter batch intervalMs must be non-negative");
+      if (timeoutMs !== undefined && (!Number.isFinite(timeoutMs) || timeoutMs < 0))
+        throw new Error("OpenRouter batch timeoutMs must be non-negative");
+      const startedAt = Date.now();
+      for (;; ) {
+        options.signal?.throwIfAborted();
+        const batch = await getBatch(id);
+        if (TERMINAL_BATCH_STATUSES.has(batch.status))
+          return batch;
+        if (timeoutMs !== undefined && Date.now() - startedAt + intervalMs > timeoutMs)
+          throw new Error(`Timed out waiting for OpenRouter batch "${id}"`);
+        await new Promise((resolve, reject) => {
+          const onAbort = () => {
+            clearTimeout(timeout);
+            reject(options.signal?.reason);
+          };
+          const timeout = setTimeout(() => {
+            options.signal?.removeEventListener("abort", onAbort);
+            resolve();
+          }, intervalMs);
+          options.signal?.addEventListener("abort", onAbort, { once: true });
+        });
+      }
     }
   };
 };
@@ -2667,7 +3209,7 @@ var assertAllowedPreset = (preset, allowedPresets) => {
 var assertIndirectModels = (value, allowedModels, key = "") => {
   if (key === "model" && typeof value === "string")
     assertAllowedModel2(value, allowedModels);
-  if (key === "models" && Array.isArray(value)) {
+  if ((key === "models" || key === "analysis_models" || key === "allowed_models") && Array.isArray(value)) {
     for (const model of value) {
       if (typeof model === "string")
         assertAllowedModel2(model, allowedModels);
@@ -2698,6 +3240,7 @@ var assertRequestOptions = (options, allowedModels, allowedPresets, allowedProvi
       assertAllowedModel2(model, allowedModels);
   }
   assertIndirectModels(options.serverTools, allowedModels);
+  assertIndirectModels(options.messagesTools, allowedModels);
   assertIndirectModels(options.plugins, allowedModels);
   if (options.extraBody) {
     const unsafe = Object.keys(options.extraBody).find((key) => SECURITY_SENSITIVE_EXTRA_BODY_FIELDS.has(key));
@@ -2716,17 +3259,41 @@ var snapshotPolicy = (config2) => ({
   allowedModels: config2.allowedModels ? [...config2.allowedModels] : undefined,
   allowedPresets: config2.allowedPresets ? [...config2.allowedPresets] : undefined
 });
-var transformOpenRouterRequest = (config2, allowedModels, allowedPresets, body, params) => {
+var transformOpenRouterRequest = (config2, allowedModels, allowedPresets, body, params, skin = "openai") => {
   const options = requestOptionsFor(params, config2.requestOptions);
   assertRequestOptions(options, allowedModels, allowedPresets, config2.allowedProviders);
   const transformed = { ...body, ...options.extraBody };
-  if (params.reasoning?.budgetTokens !== undefined) {
-    transformed.reasoning = { max_tokens: params.reasoning.budgetTokens };
-    delete transformed.reasoning_effort;
-  } else if (params.reasoning?.effort) {
-    transformed.reasoning = { effort: params.reasoning.effort };
-    delete transformed.reasoning_effort;
-  }
+  if (options.audioOutput) {
+    transformed.audio = options.audioOutput;
+    transformed.modalities = ["text", "audio"];
+  }
+  if (skin === "openai") {
+    const requestedReasoning = {};
+    if (params.reasoning?.budgetTokens !== undefined) {
+      requestedReasoning.max_tokens = params.reasoning.budgetTokens;
+      delete transformed.reasoning_effort;
+    } else if (params.reasoning?.effort) {
+      requestedReasoning.effort = params.reasoning.effort;
+      delete transformed.reasoning_effort;
+    }
+    if (options.reasoning) {
+      Object.assign(requestedReasoning, options.reasoning);
+      if (options.reasoning.maxTokens !== undefined) {
+        requestedReasoning.max_tokens = options.reasoning.maxTokens;
+        delete requestedReasoning.maxTokens;
+      }
+    }
+    if (Object.keys(requestedReasoning).length > 0)
+      transformed.reasoning = requestedReasoning;
+  }
+  const automaticCacheControl = params.promptCaching === true || params.cacheSystemPrompt === true ? { type: "ephemeral" } : undefined;
+  const cacheControl = options.cacheControl ?? automaticCacheControl;
+  if (cacheControl)
+    transformed.cache_control = cacheControl;
+  if (options.promptCacheKey)
+    transformed.prompt_cache_key = options.promptCacheKey;
+  if (options.promptCacheOptions)
+    transformed.prompt_cache_options = options.promptCacheOptions;
   const routing = mapRouting({ ...config2.routing, ...options.routing }, config2.allowedProviders);
   if (Object.keys(routing).length > 0)
     transformed.provider = routing;
@@ -2746,12 +3313,22 @@ var transformOpenRouterRequest = (config2, allowedModels, allowedPresets, body,
       ...options.serverTools
     ];
   }
+  if (options.messagesTools) {
+    if (skin !== "messages")
+      throw new Error("OpenRouter messagesTools requires openrouterMessages()");
+    transformed.tools = [
+      ...Array.isArray(transformed.tools) ? transformed.tools : [],
+      ...options.messagesTools
+    ];
+  }
   if (options.serviceTier)
     transformed.service_tier = options.serviceTier;
   if (options.sessionId)
     transformed.session_id = options.sessionId;
   if (options.stopServerToolsWhen)
     transformed.stop_server_tools_when = options.stopServerToolsWhen;
+  if (options.trace)
+    transformed.trace = options.trace;
   if (options.transforms)
     transformed.transforms = [...options.transforms];
   if (options.user)
@@ -2806,6 +3383,21 @@ var openrouterResponses = (config2) => {
   });
   return withOpenRouterPolicy(provider, allowedModels, allowedPresets);
 };
+var openrouterMessages = (config2) => {
+  assertRoutingPolicy(config2);
+  const { allowedModels, allowedPresets } = snapshotPolicy(config2);
+  const provider = anthropic({
+    apiKey: config2.apiKey,
+    authStyle: "bearer",
+    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL7,
+    fetch: config2.fetch,
+    headers: (params) => resolveAttributionHeaders(config2, params),
+    providerName: "openrouter",
+    tokenSource: config2.tokenSource,
+    transformRequestBody: (body, params) => transformOpenRouterRequest(config2, allowedModels, allowedPresets, body, params, "messages")
+  });
+  return withOpenRouterPolicy(provider, allowedModels, allowedPresets);
+};
 
 // src/plugins/aiChat.ts
 import { Elysia } from "elysia";
@@ -2982,6 +3574,8 @@ var isValidAIServerMessage = (data) => {
       return "name" in data && "status" in data && "messageId" in data && "conversationId" in data;
     case "image":
       return "data" in data && typeof data.data === "string" && "format" in data && typeof data.format === "string" && "isPartial" in data && typeof data.isPartial === "boolean" && "messageId" in data && "conversationId" in data;
+    case "audio":
+      return "data" in data && typeof data.data === "string" && "format" in data && typeof data.format === "string" && "messageId" in data && "conversationId" in data;
     case "complete":
       return "messageId" in data && "conversationId" in data;
     case "turn_queued":
@@ -3081,6 +3675,15 @@ var sendImageMessage = async (socket, chunk, messageId, conversationId) => sendM
   revisedPrompt: chunk.revisedPrompt,
   type: "image"
 });
+var sendAudioMessage = async (socket, chunk, messageId, conversationId) => sendMessage(socket, {
+  audioId: chunk.audioId,
+  conversationId,
+  data: chunk.data,
+  format: chunk.format,
+  messageId,
+  transcript: chunk.transcript,
+  type: "audio"
+});
 var sendToolRunning = async (socket, toolName, toolInput, messageId, conversationId) => sendMessage(socket, {
   conversationId,
   input: toolInput,
@@ -3174,6 +3777,15 @@ var processToolChunk = (chunk, state, options, socket, messageId, conversationId
         revisedPrompt: chunk.revisedPrompt
       });
       break;
+    case "audio":
+      sendAudioMessage(socket, chunk, messageId, conversationId);
+      options.onAudio?.({
+        audioId: chunk.audioId,
+        data: chunk.data,
+        format: chunk.format,
+        transcript: chunk.transcript
+      });
+      break;
     case "tool_use":
       flushThinking(state);
       handleToolChunkToolUse(chunk, state);
@@ -3181,6 +3793,7 @@ var processToolChunk = (chunk, state, options, socket, messageId, conversationId
         id: chunk.id,
         input: typeof chunk.input === "object" && chunk.input !== null ? chunk.input : {},
         name: chunk.name,
+        providerData: chunk.providerData,
         type: "tool_use"
       });
       hitAnotherTool = true;
@@ -3368,6 +3981,15 @@ var consumeStreamChunk = async (chunk, options, socket, state, messageId, conver
         revisedPrompt: chunk.revisedPrompt
       });
       break;
+    case "audio":
+      await sendAudioMessage(socket, chunk, messageId, conversationId);
+      options.onAudio?.({
+        audioId: chunk.audioId,
+        data: chunk.data,
+        format: chunk.format,
+        transcript: chunk.transcript
+      });
+      break;
     case "tool_use":
       flushStreamThinking(state);
       state.pendingToolCalls.push({
@@ -3379,6 +4001,7 @@ var consumeStreamChunk = async (chunk, options, socket, state, messageId, conver
         id: chunk.id,
         input: typeof chunk.input === "object" && chunk.input !== null ? chunk.input : {},
         name: chunk.name,
+        providerData: chunk.providerData,
         type: "tool_use"
       });
       break;
@@ -3479,6 +4102,10 @@ var serializeToolCall2 = (name, input) => `${name}:${JSON.stringify(input)}`;
 var contentEvent = (options, renderers, delta, full) => options.structuredEvents ? { data: JSON.stringify({ delta, full }), event: "content" } : { data: renderers.chunk(delta, full), event: "content" };
 var thinkingEvent = (options, renderers, text) => options.structuredEvents ? { data: JSON.stringify({ text }), event: "thinking" } : { data: renderers.thinking(text), event: "thinking" };
 var imageEvent = (options, renderers, data, format, revisedPrompt) => options.structuredEvents ? { data: JSON.stringify({ data, format, revisedPrompt }), event: "images" } : { data: renderers.image(data, format, revisedPrompt), event: "images" };
+var audioEvent = (data, format, transcript, audioId) => ({
+  data: JSON.stringify({ audioId, data, format, transcript }),
+  event: "audio"
+});
 var completeEvent = (options, renderers, fullResponse, usage, durationMs) => {
   options.onComplete?.(fullResponse, usage);
   return options.structuredEvents ? {
@@ -3548,6 +4175,15 @@ var processImageChunk = function* (chunk, renderers, options) {
     revisedPrompt: chunk.revisedPrompt
   });
 };
+var processAudioChunk = function* (chunk, options) {
+  yield audioEvent(chunk.data, chunk.format, chunk.transcript, chunk.audioId);
+  options.onAudio?.({
+    audioId: chunk.audioId,
+    data: chunk.data,
+    format: chunk.format,
+    transcript: chunk.transcript
+  });
+};
 var processToolUseChunk = (chunk, chunkState) => {
   maybeFlushThinking(chunkState);
   chunkState.pendingToolCalls.push({
@@ -3559,6 +4195,7 @@ var processToolUseChunk = (chunk, chunkState) => {
     id: chunk.id,
     input: typeof chunk.input === "object" && chunk.input !== null ? chunk.input : {},
     name: chunk.name,
+    providerData: chunk.providerData,
     type: "tool_use"
   });
 };
@@ -3573,6 +4210,9 @@ var processChunk2 = function* (chunk, chunkState, renderers, options, fullRespon
     case "image":
       yield* processImageChunk(chunk, renderers, options);
       break;
+    case "audio":
+      yield* processAudioChunk(chunk, options);
+      break;
     case "tool_use":
       processToolUseChunk(chunk, chunkState);
       break;
@@ -4456,6 +5096,14 @@ var streamAIWithTools = async function* (options) {
         fullText += chunk.content;
         pushText(blocks, chunk.content);
         yield { content: chunk.content, type: "text" };
+      } else if (chunk.type === "audio") {
+        yield {
+          audioId: chunk.audioId,
+          data: chunk.data,
+          format: chunk.format,
+          transcript: chunk.transcript,
+          type: "audio"
+        };
       } else if (chunk.type === "tool_use") {
         thinking = flushThinking3(blocks, thinking);
         pending.push({ id: chunk.id, input: chunk.input, name: chunk.name });
@@ -4463,8 +5111,16 @@ var streamAIWithTools = async function* (options) {
           id: chunk.id,
           input: chunk.input && typeof chunk.input === "object" ? chunk.input : {},
           name: chunk.name,
+          providerData: chunk.providerData,
           type: "tool_use"
         });
+      } else if (chunk.type === "provider_event") {
+        thinking = flushThinking3(blocks, thinking);
+        blocks.push({
+          data: chunk.data,
+          provider: chunk.provider,
+          type: "provider_data"
+        });
       } else if (chunk.type === "done") {
         thinking = flushThinking3(blocks, thinking);
         turnUsage = chunk.usage;
@@ -6009,6 +6665,16 @@ var serverMessageToAction = (message) => {
         revisedPrompt: message.revisedPrompt,
         type: "image"
       };
+    case "audio":
+      return {
+        audioId: message.audioId,
+        conversationId: message.conversationId,
+        data: message.data,
+        format: message.format,
+        messageId: message.messageId,
+        transcript: message.transcript,
+        type: "audio"
+      };
     case "complete":
       return {
         conversationId: message.conversationId,
@@ -6411,6 +7077,20 @@ var handleImage = (state, action) => {
   });
   conversation.messages = [...conversation.messages];
 };
+var handleAudio = (state, action) => {
+  const conversation = getOrCreate(state, action.conversationId);
+  const message = getOrCreateAssistantMessage(conversation, action.messageId, action.conversationId);
+  message.audio = [
+    ...message.audio ?? [],
+    {
+      audioId: action.audioId,
+      data: action.data,
+      format: action.format,
+      transcript: action.transcript
+    }
+  ];
+  conversation.messages = [...conversation.messages];
+};
 var handleComplete = (state, action) => {
   const conversation = state.conversations.get(action.conversationId);
   if (conversation) {
@@ -6481,6 +7161,9 @@ var applyAction = (state, action) => {
     case "image":
       handleImage(state, action);
       break;
+    case "audio":
+      handleAudio(state, action);
+      break;
     case "complete":
       handleComplete(state, action);
       break;
@@ -6800,6 +7483,7 @@ var startProviderStatusMonitor = (options) => {
 export {
   xai,
   withResilience,
+  verifyOpenRouterWebhookSignature,
   tableCard,
   streamAIWithTools,
   streamAIToSSE,
@@ -6827,6 +7511,7 @@ export {
   parseChartSpec,
   parseAIMessage,
   openrouterResponses,
+  openrouterMessages,
   openrouter,
   openaiResponses,
   openaiCompatible,
@@ -6838,6 +7523,7 @@ export {
   meta,
   google,
   getProviderHealth,
+  generateOpenRouterPKCE,
   generateObjectAI,
   generateId,
   generateAIWithTools,
@@ -6845,13 +7531,18 @@ export {
   gemini,
   formCard,
   fetchProviderApiStatus,
+  exchangeOpenRouterAuthCode,
+  estimateOpenRouterModelCost,
+  estimateOpenRouterCost,
   diffCard,
   deepseek,
   credentialCard,
   createUiCards,
   createSyncConversationStore,
   createProviderProxyResponse,
+  createOpenRouterKeyLinks,
   createOpenRouterClient,
+  createOpenRouterAuthorizationUrl,
   createOAuth2ClientCredentialsTokenSource,
   createMemoryStore,
   createConversationManager,
@@ -6889,5 +7580,5 @@ export {
   BUILTIN_UI_CARDS
 };
 
-//# debugId=A06FECA819C53C2464756E2164756E21
+//# debugId=25187F8D2370EC5064756E2164756E21
 //# sourceMappingURL=index.js.map