@absolutejs/ai 0.0.49 → 0.0.51

package/dist/ai/index.js

@@ -6,7 +6,8 @@ var PROVIDER_STATUS_PAGES = {
   anthropic: "https://status.claude.com",
   gemini: "https://status.cloud.google.com",
   google: "https://status.cloud.google.com",
-  openai: "https://status.openai.com"
+  openai: "https://status.openai.com",
+  openrouter: "https://status.openrouter.ai"
 };
 var RETRYABLE_STATUSES = new Set([
   408,
@@ -42,6 +43,7 @@ class ProviderError extends Error {
   status;
   type;
   retryable;
+  metadata;
   statusPageUrl;
   constructor(init) {
     super(init.message, init.cause === undefined ? undefined : { cause: init.cause });
@@ -50,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) {
@@ -222,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;
     }
   };
@@ -456,7 +460,7 @@ var mapContentBlockToOpenAI = (block) => {
   if (block.type === "image") {
     return {
       image_url: {
-        url: `data:${block.source.media_type};base64,${block.source.data}`
+        url: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`
       },
       type: "image_url"
     };
@@ -464,12 +468,26 @@ var mapContentBlockToOpenAI = (block) => {
   if (block.type === "document") {
     return {
       file: {
-        file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+        file_data: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`,
         filename: block.name ?? "document.pdf"
       },
       type: "file"
     };
   }
+  if (block.type === "audio") {
+    return {
+      input_audio: { data: block.source.data, format: block.source.format },
+      type: "input_audio"
+    };
+  }
+  if (block.type === "video") {
+    return {
+      type: "video_url",
+      video_url: {
+        url: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`
+      }
+    };
+  }
   if (block.type === "text") {
     return { text: block.content, type: "text" };
   }
@@ -479,17 +497,20 @@ var mapOpenAIContent = (msg) => {
   if (typeof msg.content === "string") {
     return msg.content;
   }
-  const hasMedia = msg.content.some((block) => block.type === "image" || block.type === "document");
+  const hasMedia = msg.content.some((block) => block.type === "image" || block.type === "document" || block.type === "audio" || block.type === "video");
   if (!hasMedia) {
     return null;
   }
   return msg.content.map(mapContentBlockToOpenAI).filter((mapped) => mapped !== null);
 };
-var buildRequestBody = (params) => {
+var buildRequestBody = (params, capabilityModel = params.model) => {
   const messages = convertToolResultMessages(params.messages.map((msg) => ({
     content: mapOpenAIContent(msg),
     role: msg.role
   })), params);
+  if (params.systemPrompt) {
+    messages.unshift({ content: params.systemPrompt, role: "system" });
+  }
   const body = {
     messages,
     model: params.model,
@@ -510,12 +531,12 @@ var buildRequestBody = (params) => {
       body.parallel_tool_calls = params.parallelToolCalls;
     }
   }
-  if (isOpenAIReasoningModel(params.model)) {
+  if (isOpenAIReasoningModel(capabilityModel)) {
     if (typeof params.maxTokens === "number") {
       body.max_completion_tokens = params.maxTokens;
     }
     if (params.reasoning) {
-      const effort = openaiEffortValue(params.model, params.reasoning);
+      const effort = openaiEffortValue(capabilityModel, params.reasoning);
       if (effort)
         body.reasoning_effort = effort;
     }
@@ -576,8 +597,12 @@ var extractUsage = (parsedUsage) => {
   const cached = parsedUsage.cached_tokens ?? 0;
   return {
     cacheReadInputTokens: cached,
+    cacheWriteInputTokens: parsedUsage.cache_write_tokens || undefined,
+    costCredits: parsedUsage.cost,
     inputTokens: Math.max(0, prompt - cached),
-    outputTokens: parsedUsage.completion_tokens ?? 0
+    outputTokens: parsedUsage.completion_tokens ?? 0,
+    reasoningTokens: parsedUsage.reasoning_tokens || undefined,
+    upstreamInferenceCostCredits: parsedUsage.upstream_inference_cost || undefined
   };
 };
 var resolveToolCallIndex = (toolCall) => {
@@ -629,9 +654,50 @@ 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);
   }
+  if (Array.isArray(delta.annotations)) {
+    for (const annotation of delta.annotations) {
+      if (!isRecord(annotation) || annotation.type !== "url_citation")
+        continue;
+      const citation = isRecord(annotation.url_citation) ? annotation.url_citation : annotation;
+      if (typeof citation.url !== "string")
+        continue;
+      yield {
+        content: typeof citation.content === "string" ? citation.content : undefined,
+        endIndex: typeof citation.end_index === "number" ? citation.end_index : undefined,
+        startIndex: typeof citation.start_index === "number" ? citation.start_index : undefined,
+        title: typeof citation.title === "string" ? citation.title : undefined,
+        type: "citation",
+        url: citation.url
+      };
+    }
+  }
+};
+var narrowResponseMetadata = (parsed) => {
+  const providerMetadata = isRecord(parsed.openrouter_metadata) ? parsed.openrouter_metadata : undefined;
+  const generationId = typeof parsed.id === "string" ? parsed.id : undefined;
+  const model = typeof parsed.model === "string" ? parsed.model : undefined;
+  const serviceTier = typeof parsed.service_tier === "string" ? parsed.service_tier : undefined;
+  const selected = providerMetadata && isRecord(providerMetadata.endpoints) ? providerMetadata.endpoints.available : undefined;
+  const selectedEndpoint = Array.isArray(selected) ? selected.find((entry) => isRecord(entry) && entry.selected === true) : undefined;
+  const provider = isRecord(selectedEndpoint) && typeof selectedEndpoint.provider === "string" ? selectedEndpoint.provider : undefined;
+  if (!providerMetadata && !generationId && !model && !serviceTier)
+    return;
+  return { generationId, model, provider, providerMetadata, serviceTier };
 };
 var processChoice = function* (choice, pendingToolCalls) {
   const delta = isRecord(choice.delta) ? choice.delta : null;
@@ -650,13 +716,25 @@ var narrowUsageRecord = (parsed) => {
   const promptTokens = typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0;
   const completionTokens = typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0;
   const cachedTokens = isRecord(usage.prompt_tokens_details) && typeof usage.prompt_tokens_details.cached_tokens === "number" ? usage.prompt_tokens_details.cached_tokens : 0;
-  return extractUsage({
+  const cacheWriteTokens = isRecord(usage.prompt_tokens_details) && typeof usage.prompt_tokens_details.cache_write_tokens === "number" ? usage.prompt_tokens_details.cache_write_tokens : 0;
+  const reasoningTokens = isRecord(usage.completion_tokens_details) && typeof usage.completion_tokens_details.reasoning_tokens === "number" ? usage.completion_tokens_details.reasoning_tokens : 0;
+  const cost = typeof usage.cost === "number" ? usage.cost : undefined;
+  const upstreamInferenceCost = isRecord(usage.cost_details) && typeof usage.cost_details.upstream_inference_cost === "number" ? usage.cost_details.upstream_inference_cost : undefined;
+  const normalized = extractUsage({
+    cache_write_tokens: cacheWriteTokens,
     cached_tokens: cachedTokens,
     completion_tokens: completionTokens,
-    prompt_tokens: promptTokens
+    cost,
+    prompt_tokens: promptTokens,
+    reasoning_tokens: reasoningTokens,
+    upstream_inference_cost: upstreamInferenceCost
   });
+  if (isRecord(usage.server_tool_use)) {
+    normalized.serverToolUse = Object.fromEntries(Object.entries(usage.server_tool_use).filter((entry) => typeof entry[1] === "number"));
+  }
+  return normalized;
 };
-var processSSELine = function* (line, pendingToolCalls, currentUsage) {
+var processSSELine = function* (line, pendingToolCalls, providerName) {
   const trimmed = line.trim();
   if (!trimmed || !trimmed.startsWith("data: ")) {
     return;
@@ -664,7 +742,6 @@ var processSSELine = function* (line, pendingToolCalls, currentUsage) {
   const data = trimmed.slice(SSE_DATA_PREFIX_LENGTH);
   if (data === DONE_SENTINEL) {
     yield* flushPendingToolCalls(pendingToolCalls);
-    yield { type: "done", usage: currentUsage };
     return;
   }
   let parsed;
@@ -673,10 +750,28 @@ var processSSELine = function* (line, pendingToolCalls, currentUsage) {
   } 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 };
   }
+  const metadata = narrowResponseMetadata(parsed);
+  if (metadata) {
+    yield { metadata, type: "response_metadata" };
+  }
   const { choices } = parsed;
   if (!isRecordArray(choices)) {
     return;
@@ -685,21 +780,46 @@ var processSSELine = function* (line, pendingToolCalls, currentUsage) {
   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) => {
-  const allChunks = Array.from(processSSELine(line, pendingToolCalls, usageRef.current));
+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) {
     usageRef.current = lastUsage.usage;
   }
-  return allChunks.filter((chunk) => !isUsageUpdate(chunk));
+  const metadataChunks = allChunks.filter((chunk) => chunk.type === "response_metadata");
+  const lastMetadata = metadataChunks.at(NOT_FOUND);
+  if (lastMetadata && "metadata" in lastMetadata) {
+    metadataRef.current = {
+      ...metadataRef.current,
+      ...lastMetadata.metadata,
+      providerMetadata: {
+        ...metadataRef.current?.providerMetadata,
+        ...lastMetadata.metadata.providerMetadata
+      }
+    };
+  }
+  return allChunks.filter((chunk) => !isUsageUpdate(chunk) && chunk.type !== "response_metadata");
 };
-var processSSELines = function* (lines, pendingToolCalls, usageRef) {
+var processSSELines = function* (lines, pendingToolCalls, usageRef, metadataRef, providerName) {
   for (const line of lines) {
-    yield* collectYieldableChunks(line, pendingToolCalls, usageRef);
+    yield* collectYieldableChunks(line, pendingToolCalls, usageRef, metadataRef, providerName);
   }
 };
 var processStreamValue = (value, decoder, state) => {
@@ -712,51 +832,67 @@ 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);
+    yield* processSSELines(lines, state.pendingToolCalls, state.usageRef, state.metadataRef, state.providerName);
   }
 };
-var parseSSEStream = async function* (body, 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 {
     yield* drainReader(reader, decoder, state, signal);
-    yield { type: "done", usage: state.usageRef.current };
+    yield {
+      metadata: state.metadataRef.current,
+      type: "done",
+      usage: state.usageRef.current
+    };
   } finally {
     reader.releaseLock();
   }
 };
-var fetchOpenAIStream = async function* (baseUrl, apiKey, body, signal) {
+var fetchOpenAIStream = async function* (baseUrl, apiKey, body, fetchImpl, headers, providerName, signal) {
   const target = `${baseUrl}/v1/chat/completions`;
-  const response = await fetch(target, {
+  const requestHeaders = new Headers(headers);
+  requestHeaders.set("Authorization", `Bearer ${apiKey}`);
+  requestHeaders.set("Content-Type", "application/json");
+  const response = await fetchImpl(target, {
     ...h2IfHttps(target),
     body: JSON.stringify(body),
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
+    headers: requestHeaders,
     method: "POST",
     signal
   });
   if (!response.ok) {
     const errorText = await response.text();
-    throw ProviderError.fromResponse("openai", response.status, errorText);
+    throw ProviderError.fromResponse(providerName, response.status, errorText);
   }
   if (!response.body) {
     throw new ProviderError({
-      message: "OpenAI API returned no response body",
-      provider: "openai",
+      message: `${providerName} API returned no response body`,
+      provider: providerName,
       retryable: true
     });
   }
-  yield* parseSSEStream(response.body, signal);
+  yield* parseSSEStream(response.body, {
+    generationId: response.headers.get("X-Generation-Id") ?? undefined,
+    providerMetadata: {
+      cacheAge: response.headers.get("X-OpenRouter-Cache-Age") ?? undefined,
+      cacheSourceId: response.headers.get("X-OpenRouter-Cache-Source-Id") ?? undefined,
+      cacheStatus: response.headers.get("X-OpenRouter-Cache-Status") ?? undefined,
+      cacheTtl: response.headers.get("X-OpenRouter-Cache-TTL") ?? undefined
+    }
+  }, providerName, signal);
 };
 var openai = (config2) => {
   const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL;
+  const fetchImpl = config2.fetch ?? globalThis.fetch;
+  const providerName = config2.providerName ?? "openai";
   if (!config2.apiKey && !config2.tokenSource) {
     throw new Error("openai() requires either apiKey or tokenSource");
   }
@@ -766,15 +902,20 @@ var openai = (config2) => {
     }
     return config2.apiKey;
   };
+  const resolveHeaders = async (params) => typeof config2.headers === "function" ? await config2.headers(params) : config2.headers ?? {};
   return instrumentAIProvider({
     stream: (params) => {
-      const body = buildRequestBody(params);
+      const openaiBody = buildRequestBody(params, config2.modelForCapabilities?.(params.model) ?? params.model);
+      const body = config2.transformRequestBody ? config2.transformRequestBody(openaiBody, params) : openaiBody;
       return async function* () {
-        const apiKey = await resolveKey();
-        yield* fetchOpenAIStream(baseUrl, apiKey, body, params.signal);
+        const [apiKey, headers] = await Promise.all([
+          resolveKey(),
+          resolveHeaders(params)
+        ]);
+        yield* fetchOpenAIStream(baseUrl, apiKey, body, fetchImpl, headers, providerName, params.signal);
       }();
     }
-  }, "openai");
+  }, providerName);
 };
 
 // src/ai/providers/openaiCompatible.ts
@@ -826,7 +967,7 @@ var mapBlockToResponsesFormat = (block) => {
   if (block.type === "image") {
     return {
       image_url: {
-        url: `data:${block.source.media_type};base64,${block.source.data}`
+        url: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`
       },
       type: "input_image"
     };
@@ -834,12 +975,24 @@ var mapBlockToResponsesFormat = (block) => {
   if (block.type === "document") {
     return {
       file: {
-        file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+        file_data: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`,
         filename: block.name ?? "document.pdf"
       },
       type: "input_file"
     };
   }
+  if (block.type === "audio") {
+    return {
+      input_audio: { data: block.source.data, format: block.source.format },
+      type: "input_audio"
+    };
+  }
+  if (block.type === "video") {
+    return {
+      type: "input_video",
+      video_url: block.source.type === "url" ? block.source.url : `data:${block.source.media_type};base64,${block.source.data}`
+    };
+  }
   return null;
 };
 var mapContentToResponsesFormat = (content) => {
@@ -851,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,
@@ -903,7 +1061,7 @@ var buildTools = (tools, isImageModel) => {
   }
   return result.length > 0 ? result : undefined;
 };
-var buildRequestBody2 = (params, isImageModel) => {
+var buildRequestBody2 = (params, isImageModel, capabilityModel = params.model) => {
   const body = {
     input: buildInput(params.messages),
     model: params.model,
@@ -955,8 +1113,8 @@ var buildRequestBody2 = (params, isImageModel) => {
       };
     }
   }
-  if (params.reasoning && isOpenAIReasoningModel(params.model)) {
-    const effort = openaiEffortValue(params.model, params.reasoning);
+  if (params.reasoning && isOpenAIReasoningModel(capabilityModel)) {
+    const effort = openaiEffortValue(capabilityModel, params.reasoning);
     if (effort) {
       body.reasoning = {
         effort,
@@ -987,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") {
@@ -1048,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"
   };
 };
@@ -1066,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 : "",
@@ -1084,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 };
@@ -1091,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 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) {
+var processSSEEvent = function* (eventType, parsed, pendingCalls, providerName) {
   switch (eventType) {
     case "response.reasoning_summary_text.delta": {
       const delta = typeof parsed.delta === "string" ? parsed.delta : "";
@@ -1117,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;
@@ -1127,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) {
@@ -1140,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 = "";
@@ -1178,41 +1410,47 @@ 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();
   }
 };
-var fetchResponsesStream = async function* (baseUrl, apiKey, body, signal) {
+var fetchResponsesStream = async function* (baseUrl, apiKey, body, fetchImpl, headers, providerName, signal) {
   const target = `${baseUrl}/v1/responses`;
-  const response = await fetch(target, {
+  const requestHeaders = new Headers(headers);
+  requestHeaders.set("Authorization", `Bearer ${apiKey}`);
+  requestHeaders.set("Content-Type", "application/json");
+  const response = await fetchImpl(target, {
     ...h2IfHttps2(target),
     body: JSON.stringify(body),
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
+    headers: requestHeaders,
     method: "POST",
     signal
   });
   if (!response.ok) {
     const errorText = await response.text();
-    throw new Error(`OpenAI Responses API error ${response.status}: ${errorText}`);
+    throw ProviderError.fromResponse(providerName, response.status, errorText);
   }
   if (!response.body) {
-    throw new Error("OpenAI Responses API returned no response body");
+    throw new ProviderError({
+      message: `${providerName} Responses API returned no response body`,
+      provider: providerName,
+      retryable: true
+    });
   }
-  yield* parseSSEStream2(response.body, signal);
+  yield* parseSSEStream2(response.body, providerName, signal);
 };
 var resolveImageModels = (imageModels) => {
   if (!imageModels) {
@@ -1224,15 +1462,28 @@ var resolveImageModels = (imageModels) => {
   return new Set(imageModels);
 };
 var openaiResponses = (config2) => {
+  if (!config2.apiKey && !config2.tokenSource)
+    throw new Error("openaiResponses() requires either apiKey or tokenSource");
   const baseUrl = config2.baseUrl ?? DEFAULT_BASE_URL2;
+  const fetchImpl = config2.fetch ?? globalThis.fetch;
   const imageModels = resolveImageModels(config2.imageModels);
+  const providerName = config2.providerName ?? "openai-responses";
+  const resolveKey = async () => config2.tokenSource ? await Promise.resolve(config2.tokenSource()) : config2.apiKey;
+  const resolveHeaders = async (params) => typeof config2.headers === "function" ? await config2.headers(params) : config2.headers ?? {};
   return instrumentAIProvider({
     stream: (params) => {
       const isImageModel = imageModels.has(params.model);
-      const body = buildRequestBody2(params, isImageModel);
-      return fetchResponsesStream(baseUrl, config2.apiKey, body, params.signal);
+      const builtBody = buildRequestBody2(params, isImageModel, config2.modelForCapabilities?.(params.model) ?? params.model);
+      const body = config2.transformRequestBody ? config2.transformRequestBody(builtBody, params) : builtBody;
+      return async function* () {
+        const [apiKey, headers] = await Promise.all([
+          resolveKey(),
+          resolveHeaders(params)
+        ]);
+        yield* fetchResponsesStream(baseUrl, apiKey, body, fetchImpl, headers, providerName, params.signal);
+      }();
     }
-  }, "openai-responses");
+  }, providerName);
 };
 
 // src/ai/providers/gemini.ts
@@ -1251,14 +1502,43 @@ var mapContentBlock = (block) => {
     case "text":
       return { text: block.content };
     case "image":
-      return {
+      return block.source.type === "url" ? {
+        fileData: {
+          fileUri: block.source.url,
+          mimeType: block.source.media_type
+        }
+      } : {
         inlineData: {
           data: block.source.data,
           mimeType: block.source.media_type
         }
       };
     case "document":
+      return block.source.type === "url" ? {
+        fileData: {
+          fileUri: block.source.url,
+          mimeType: block.source.media_type
+        }
+      } : {
+        inlineData: {
+          data: block.source.data,
+          mimeType: block.source.media_type
+        }
+      };
+    case "audio":
       return {
+        inlineData: {
+          data: block.source.data,
+          mimeType: `audio/${block.source.format}`
+        }
+      };
+    case "video":
+      return block.source.type === "url" ? {
+        fileData: {
+          fileUri: block.source.url,
+          mimeType: block.source.media_type
+        }
+      } : {
         inlineData: {
           data: block.source.data,
           mimeType: block.source.media_type
@@ -1564,6 +1844,8 @@ var mapContentBlock2 = (block) => {
     };
   }
   if (block.type === "tool_use") {
+    if (block.providerData)
+      return { ...block.providerData };
     return {
       id: block.id,
       input: block.input,
@@ -1571,6 +1853,12 @@ var mapContentBlock2 = (block) => {
       type: "tool_use"
     };
   }
+  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) => ({
@@ -1744,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) => {
@@ -1769,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");
@@ -1787,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;
   }
@@ -1806,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) => {
@@ -1828,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
   });
@@ -1855,6 +2195,7 @@ var processEvent = (eventType, parsed, state) => {
     }
     case "message_delta": {
       handleMessageDelta(parsed, state);
+      mergeMetadata(parsed, state);
       return;
     }
     case "message_start": {
@@ -1862,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: {
@@ -1934,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 = {
@@ -1945,7 +2288,9 @@ async function* parseSSEStream4(body, signal) {
     stopReason: "",
     thinkingSignature: "",
     toolInputJson: "",
-    usage: undefined
+    usage: undefined,
+    providerName,
+    providerBlockInputJson: ""
   };
   try {
     yield* streamChunks(reader, decoder, state, signal);
@@ -1953,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
@@ -2228,6 +2583,612 @@ var ollama = (config2 = {}) => {
   }, "ollama");
 };
 
+// src/ai/providers/openrouterClient.ts
+var DEFAULT_BASE_URL6 = "https://openrouter.ai/api/v1";
+var withoutLatestPrefix = (model) => model.startsWith("~") ? model.slice(1) : model;
+var openRouterModelMatchesRule = (model, rule) => {
+  const normalizedModel = withoutLatestPrefix(model);
+  const normalizedRule = withoutLatestPrefix(rule);
+  return normalizedRule.endsWith("/*") ? normalizedModel.startsWith(normalizedRule.slice(0, -1)) : normalizedModel === normalizedRule;
+};
+var assertAllowedModel = (model, allowedModels) => {
+  if (!allowedModels)
+    return;
+  if (allowedModels.some((rule) => openRouterModelMatchesRule(model, rule)))
+    return;
+  throw new Error(`OpenRouter model "${model}" is not allowed`);
+};
+var normalizePath = (path) => path.startsWith("/") ? path : `/${path}`;
+var encodeModelPath = (model) => model.split("/").map(encodeURIComponent).join("/");
+var withQuery = (url, query) => {
+  if (!query)
+    return url;
+  const result = new URL(url);
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined)
+      result.searchParams.set(key, String(value));
+  }
+  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 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 fetchImpl = config2.fetch ?? globalThis.fetch;
+  const allowedModels = config2.allowedModels ? [...config2.allowedModels] : undefined;
+  const requestRaw = async (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);
+    new Headers(options.headers).forEach((value, key) => headers.set(key, value));
+    headers.set("Authorization", `Bearer ${token}`);
+    let body;
+    if (options.body instanceof FormData || options.body instanceof Blob) {
+      body = options.body;
+    } else if (options.body !== undefined) {
+      headers.set("Content-Type", "application/json");
+      body = JSON.stringify(options.body);
+    }
+    const { query, ...requestInit } = options;
+    const response = await fetchImpl(withQuery(`${baseUrl}${normalizePath(path)}`, options.query), { ...requestInit, body, headers });
+    if (!response.ok) {
+      throw ProviderError.fromResponse("openrouter", response.status, await response.text());
+    }
+    return response;
+  };
+  const request = async (path, options = {}) => (await requestRaw(path, options)).json();
+  const listModels = async (query) => {
+    const result = await request("/models", { query });
+    if (!allowedModels)
+      return result;
+    return {
+      ...result,
+      data: result.data.filter((model) => allowedModels.some((rule) => openRouterModelMatchesRule(model.id, rule)))
+    };
+  };
+  const filterModelList = (result) => {
+    if (!allowedModels)
+      return result;
+    return {
+      ...result,
+      data: result.data.filter((model) => allowedModels.some((rule) => openRouterModelMatchesRule(model.id, rule)))
+    };
+  };
+  return {
+    cancelBatch: (id) => request(`/batches/${encodeURIComponent(id)}/cancel`, {
+      method: "POST"
+    }),
+    createBatch: (body) => request("/batches", { body, method: "POST" }),
+    createEmbedding: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return request("/embeddings", {
+        body,
+        method: "POST"
+      });
+    },
+    generateImage: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return request("/images", {
+        body,
+        method: "POST"
+      });
+    },
+    deleteFile: (id, workspaceId) => request(`/files/${encodeURIComponent(id)}`, { method: "DELETE", query: { workspace_id: workspaceId } }),
+    downloadFile: (id, workspaceId) => 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", {
+        body,
+        method: "POST"
+      });
+    },
+    getBatch: (id) => request(`/batches/${encodeURIComponent(id)}`),
+    getCredits: () => request("/credits"),
+    getCurrentKey: () => request("/key"),
+    getFile: (id, workspaceId) => request(`/files/${encodeURIComponent(id)}`, {
+      query: { workspace_id: workspaceId }
+    }),
+    getGeneration: (id) => request("/generation", {
+      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`);
+    },
+    getVideo: (id) => request(`/videos/${encodeURIComponent(id)}`),
+    listImageModels: async () => filterModelList(await request("/images/models")),
+    listFiles: (query) => request("/files", { query }),
+    listModels,
+    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")),
+    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", {
+        body,
+        method: "POST"
+      });
+    },
+    rerank: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return request("/rerank", {
+        body,
+        method: "POST"
+      });
+    },
+    speak: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return requestRaw("/audio/speech", { body, method: "POST" });
+    },
+    transcribe: (body) => {
+      if (body instanceof FormData) {
+        const model = body.get("model");
+        if (typeof model !== "string")
+          throw new Error("OpenRouter transcription FormData requires model");
+        assertAllowedModel(model, allowedModels);
+      } else {
+        assertAllowedModel(body.model, allowedModels);
+      }
+      return request("/audio/transcriptions", {
+        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 }
+      });
+    }
+  };
+};
+
+// src/ai/providers/openrouter.ts
+var DEFAULT_BASE_URL7 = "https://openrouter.ai/api";
+var MAX_APP_CATEGORIES = 2;
+var withoutLatestPrefix2 = (model) => model.startsWith("~") ? model.slice(1) : model;
+var modelForOpenAICapabilities = (model) => {
+  const normalized = withoutLatestPrefix2(model);
+  return normalized.startsWith("openai/") ? normalized.slice("openai/".length) : normalized;
+};
+var modelMatchesRule = (model, rule) => {
+  const normalizedModel = withoutLatestPrefix2(model);
+  const normalizedRule = withoutLatestPrefix2(rule);
+  if (normalizedRule.endsWith("/*")) {
+    return normalizedModel.startsWith(normalizedRule.slice(0, -1));
+  }
+  return normalizedModel === normalizedRule;
+};
+var providerMatchesRule = (provider, rule) => provider === rule || provider.startsWith(`${rule}/`);
+var assertNonEmptyPolicy = (label, value) => {
+  if (value && value.length === 0) {
+    throw new Error(`openrouter() ${label} must not be empty`);
+  }
+};
+var assertRoutingPolicy = (config2) => {
+  assertNonEmptyPolicy("allowedProviders", config2.allowedProviders);
+  assertNonEmptyPolicy("routing.only", config2.routing?.only);
+  assertNonEmptyPolicy("allowedPresets", config2.allowedPresets);
+  if (config2.appCategories && config2.appCategories.length > MAX_APP_CATEGORIES) {
+    throw new Error("openrouter() appCategories supports at most 2 entries");
+  }
+  if (!config2.allowedProviders)
+    return;
+  const selected = [
+    ...config2.routing?.only ?? [],
+    ...config2.routing?.order ?? []
+  ];
+  const denied = selected.find((provider) => !config2.allowedProviders.some((rule) => providerMatchesRule(provider, rule)));
+  if (denied) {
+    throw new Error(`openrouter() provider "${denied}" is outside allowedProviders`);
+  }
+};
+var assertRequestRoutingPolicy = (routing, allowedProviders) => {
+  assertRoutingPolicy({
+    allowedProviders,
+    apiKey: "policy-validation",
+    routing
+  });
+};
+var mapRouting = (routing, allowedProviders) => {
+  const only = routing?.only ?? allowedProviders;
+  const wire = {};
+  if (typeof routing?.allowFallbacks === "boolean")
+    wire.allow_fallbacks = routing.allowFallbacks;
+  if (routing?.dataCollection)
+    wire.data_collection = routing.dataCollection;
+  if (typeof routing?.enforceDistillableText === "boolean")
+    wire.enforce_distillable_text = routing.enforceDistillableText;
+  if (routing?.ignore)
+    wire.ignore = [...routing.ignore];
+  if (routing?.maxPrice)
+    wire.max_price = { ...routing.maxPrice };
+  if (only)
+    wire.only = [...only];
+  if (routing?.order)
+    wire.order = [...routing.order];
+  if (routing?.preferredMaxLatency !== undefined)
+    wire.preferred_max_latency = routing.preferredMaxLatency;
+  if (routing?.preferredMinThroughput !== undefined)
+    wire.preferred_min_throughput = routing.preferredMinThroughput;
+  if (routing?.quantizations)
+    wire.quantizations = [...routing.quantizations];
+  if (typeof routing?.requireParameters === "boolean")
+    wire.require_parameters = routing.requireParameters;
+  if (routing?.sort)
+    wire.sort = routing.sort;
+  if (typeof routing?.zdr === "boolean")
+    wire.zdr = routing.zdr;
+  return wire;
+};
+var requestOptionsFor = (params, defaults) => {
+  const supplied = params.providerOptions?.openrouter;
+  if (supplied !== undefined && (typeof supplied !== "object" || !supplied)) {
+    throw new Error("providerOptions.openrouter must be an object");
+  }
+  return {
+    ...defaults,
+    ...supplied
+  };
+};
+var resolveAttributionHeaders = async (config2, params) => {
+  const supplied = typeof config2.headers === "function" ? await config2.headers() : config2.headers ?? {};
+  const headers = new Headers(supplied);
+  if (config2.appUrl)
+    headers.set("HTTP-Referer", config2.appUrl);
+  if (config2.appName)
+    headers.set("X-OpenRouter-Title", config2.appName);
+  if (config2.appCategories?.length) {
+    headers.set("X-OpenRouter-Categories", config2.appCategories.join(","));
+  }
+  const options = requestOptionsFor(params, config2.requestOptions);
+  if (options.routerMetadata ?? true)
+    headers.set("X-OpenRouter-Metadata", "enabled");
+  if (options.sessionId)
+    headers.set("X-Session-Id", options.sessionId);
+  if (options.responseCache) {
+    headers.set("X-OpenRouter-Cache", options.responseCache.enabled ? "true" : "false");
+    if (options.responseCache.ttlSeconds !== undefined)
+      headers.set("X-OpenRouter-Cache-TTL", String(options.responseCache.ttlSeconds));
+    if (options.responseCache.clear)
+      headers.set("X-OpenRouter-Cache-Clear", "true");
+  }
+  return headers;
+};
+var SECURITY_SENSITIVE_EXTRA_BODY_FIELDS = new Set([
+  "messages",
+  "model",
+  "models",
+  "plugins",
+  "preset",
+  "provider",
+  "stream",
+  "tools"
+]);
+var assertAllowedPreset = (preset, allowedPresets) => {
+  if (!preset)
+    return;
+  if (allowedPresets?.includes(preset))
+    return;
+  throw new Error(`OpenRouter preset "${preset}" is not allowed`);
+};
+var assertIndirectModels = (value, allowedModels, key = "") => {
+  if (key === "model" && typeof value === "string")
+    assertAllowedModel2(value, allowedModels);
+  if ((key === "models" || key === "analysis_models") && Array.isArray(value)) {
+    for (const model of value) {
+      if (typeof model === "string")
+        assertAllowedModel2(model, allowedModels);
+    }
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      assertIndirectModels(item, allowedModels);
+  } else if (value && typeof value === "object") {
+    for (const [childKey, child] of Object.entries(value))
+      assertIndirectModels(child, allowedModels, childKey);
+  }
+};
+var assertRequestOptions = (options, allowedModels, allowedPresets, allowedProviders) => {
+  assertAllowedPreset(options.preset, allowedPresets);
+  assertRequestRoutingPolicy(options.routing, allowedProviders);
+  if (options.sessionId && options.sessionId.length > 256)
+    throw new Error("OpenRouter sessionId must be at most 256 characters");
+  const ttl = options.responseCache?.ttlSeconds;
+  if (ttl !== undefined && (!Number.isInteger(ttl) || ttl < 1 || ttl > 86400))
+    throw new Error("OpenRouter response-cache TTL must be 1-86400 seconds");
+  if (options.responseCache?.clear && !options.responseCache.enabled)
+    throw new Error("OpenRouter cache clear requires response caching enabled");
+  if (options.fallbackModels) {
+    if (options.fallbackModels.length === 0)
+      throw new Error("OpenRouter fallbackModels must not be empty");
+    for (const model of options.fallbackModels)
+      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));
+    if (unsafe)
+      throw new Error(`OpenRouter extraBody cannot override "${unsafe}"`);
+  }
+};
+var assertAllowedModel2 = (model, allowedModels) => {
+  if (!allowedModels)
+    return;
+  if (allowedModels.some((rule) => modelMatchesRule(model, rule)))
+    return;
+  throw new Error(`OpenRouter model "${model}" is not allowed`);
+};
+var snapshotPolicy = (config2) => ({
+  allowedModels: config2.allowedModels ? [...config2.allowedModels] : undefined,
+  allowedPresets: config2.allowedPresets ? [...config2.allowedPresets] : undefined
+});
+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 (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;
+  if (options.fallbackModels)
+    transformed.models = [...options.fallbackModels];
+  if (options.includeReasoning !== undefined)
+    transformed.include_reasoning = options.includeReasoning;
+  if (options.maxToolCalls !== undefined)
+    transformed.max_tool_calls = options.maxToolCalls;
+  if (options.plugins)
+    transformed.plugins = [...options.plugins];
+  if (options.preset)
+    transformed.preset = options.preset;
+  if (options.serverTools) {
+    transformed.tools = [
+      ...Array.isArray(transformed.tools) ? transformed.tools : [],
+      ...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)
+    transformed.user = options.user;
+  if (options.verbosity)
+    transformed.verbosity = options.verbosity;
+  return transformed;
+};
+var withOpenRouterPolicy = (provider, allowedModels, allowedPresets) => ({
+  stream: (params) => {
+    if (params.model.startsWith("@preset/")) {
+      assertAllowedPreset(params.model.slice("@preset/".length), allowedPresets);
+    } else {
+      const presetSeparator = params.model.indexOf("@preset/");
+      if (presetSeparator >= 0) {
+        assertAllowedModel2(params.model.slice(0, presetSeparator), allowedModels);
+        assertAllowedPreset(params.model.slice(presetSeparator + "@preset/".length), allowedPresets);
+      } else {
+        assertAllowedModel2(params.model, allowedModels);
+      }
+    }
+    return provider.stream(params);
+  }
+});
+var openrouter = (config2) => {
+  assertRoutingPolicy(config2);
+  const { allowedModels, allowedPresets } = snapshotPolicy(config2);
+  const provider = openai({
+    apiKey: config2.apiKey,
+    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL7,
+    fetch: config2.fetch,
+    headers: (params) => resolveAttributionHeaders(config2, params),
+    modelForCapabilities: modelForOpenAICapabilities,
+    providerName: "openrouter",
+    tokenSource: config2.tokenSource,
+    transformRequestBody: (body, params) => transformOpenRouterRequest(config2, allowedModels, allowedPresets, body, params)
+  });
+  return withOpenRouterPolicy(provider, allowedModels, allowedPresets);
+};
+var openrouterResponses = (config2) => {
+  assertRoutingPolicy(config2);
+  const { allowedModels, allowedPresets } = snapshotPolicy(config2);
+  const provider = openaiResponses({
+    apiKey: config2.apiKey,
+    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL7,
+    fetch: config2.fetch,
+    headers: (params) => resolveAttributionHeaders(config2, params),
+    modelForCapabilities: modelForOpenAICapabilities,
+    providerName: "openrouter",
+    tokenSource: config2.tokenSource,
+    transformRequestBody: (body, params) => transformOpenRouterRequest(config2, allowedModels, allowedPresets, body, params)
+  });
+  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";
 
@@ -2403,6 +3364,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":
@@ -2502,6 +3465,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,
@@ -2595,6 +3567,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);
@@ -2602,6 +3583,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;
@@ -2644,6 +3626,7 @@ var processToolTurn = async (socket, options, state, messageId, conversationId,
     messages: state.currentMessages,
     model: options.model,
     promptCaching: options.promptCaching,
+    providerOptions: options.providerOptions,
     reasoning: options.reasoning,
     signal,
     systemPrompt: options.systemPrompt,
@@ -2730,6 +3713,7 @@ var processStream = async (socket, options, messages, messageId, conversationId,
     messages,
     model: options.model,
     promptCaching: options.promptCaching,
+    providerOptions: options.providerOptions,
     reasoning: options.reasoning,
     signal,
     systemPrompt: options.systemPrompt,
@@ -2787,6 +3771,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({
@@ -2798,6 +3791,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;
@@ -2898,6 +3892,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 ? {
@@ -2967,6 +3965,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({
@@ -2978,6 +3985,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"
   });
 };
@@ -2992,6 +4000,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;
@@ -3111,6 +4122,7 @@ var streamTurns = async function* (options, renderers, messages, signal, startTi
         messages: turnState.currentMessages,
         model: options.model,
         promptCaching: options.promptCaching,
+        providerOptions: options.providerOptions,
         reasoning: options.reasoning,
         signal,
         systemPrompt: options.systemPrompt,
@@ -3123,6 +4135,13 @@ var streamTurns = async function* (options, renderers, messages, signal, startTi
       aggregateUsage.outputTokens += chunkState.usage?.outputTokens ?? 0;
       aggregateUsage.cacheReadInputTokens = (aggregateUsage.cacheReadInputTokens ?? 0) + (chunkState.usage?.cacheReadInputTokens ?? 0);
       aggregateUsage.cacheWriteInputTokens = (aggregateUsage.cacheWriteInputTokens ?? 0) + (chunkState.usage?.cacheWriteInputTokens ?? 0);
+      aggregateUsage.costCredits = (aggregateUsage.costCredits ?? 0) + (chunkState.usage?.costCredits ?? 0);
+      aggregateUsage.reasoningTokens = (aggregateUsage.reasoningTokens ?? 0) + (chunkState.usage?.reasoningTokens ?? 0);
+      for (const [key, value] of Object.entries(chunkState.usage?.serverToolUse ?? {})) {
+        aggregateUsage.serverToolUse ??= {};
+        aggregateUsage.serverToolUse[key] = (aggregateUsage.serverToolUse[key] ?? 0) + value;
+      }
+      aggregateUsage.upstreamInferenceCostCredits = (aggregateUsage.upstreamInferenceCostCredits ?? 0) + (chunkState.usage?.upstreamInferenceCostCredits ?? 0);
       const runningTotalTokens = aggregateUsage.inputTokens + aggregateUsage.outputTokens;
       if (chunkState.stopReason === "max_tokens") {
         finishReason = "max_tokens";
@@ -3606,6 +4625,7 @@ var generateAI = async (options) => {
     messages: options.messages,
     model: options.model,
     promptCaching: options.promptCaching,
+    providerOptions: options.providerOptions,
     reasoning: options.reasoning,
     responseFormat: options.responseFormat,
     signal: options.signal,
@@ -3618,17 +4638,22 @@ var generateAI = async (options) => {
   });
   let text = "";
   const toolCalls = [];
+  const citations = [];
   let usage;
+  let metadata;
   for await (const chunk of stream) {
     if (chunk.type === "text") {
       text += chunk.content;
     } else if (chunk.type === "tool_use") {
       toolCalls.push({ id: chunk.id, input: chunk.input, name: chunk.name });
+    } else if (chunk.type === "citation") {
+      citations.push(chunk);
     } else if (chunk.type === "done") {
       usage = chunk.usage;
+      metadata = chunk.metadata;
     }
   }
-  return { text, toolCalls, usage };
+  return { citations, metadata, text, toolCalls, usage };
 };
 var DEFAULT_TOOL_MAX_TURNS = 6;
 var mergeUsage = (left, right) => {
@@ -3637,11 +4662,18 @@ var mergeUsage = (left, right) => {
   if (!right)
     return left;
   const add = (a, b) => a === undefined && b === undefined ? undefined : (a ?? 0) + (b ?? 0);
+  const serverToolUse = { ...left.serverToolUse };
+  for (const [key, value] of Object.entries(right.serverToolUse ?? {}))
+    serverToolUse[key] = (serverToolUse[key] ?? 0) + value;
   return {
     cacheReadInputTokens: add(left.cacheReadInputTokens, right.cacheReadInputTokens),
     cacheWriteInputTokens: add(left.cacheWriteInputTokens, right.cacheWriteInputTokens),
+    costCredits: add(left.costCredits, right.costCredits),
     inputTokens: (left.inputTokens ?? 0) + (right.inputTokens ?? 0),
-    outputTokens: (left.outputTokens ?? 0) + (right.outputTokens ?? 0)
+    outputTokens: (left.outputTokens ?? 0) + (right.outputTokens ?? 0),
+    reasoningTokens: add(left.reasoningTokens, right.reasoningTokens),
+    serverToolUse: Object.keys(serverToolUse).length > 0 ? serverToolUse : undefined,
+    upstreamInferenceCostCredits: add(left.upstreamInferenceCostCredits, right.upstreamInferenceCostCredits)
   };
 };
 var toProviderTools = (tools) => Object.entries(tools).map(([name, definition]) => ({
@@ -3825,6 +4857,7 @@ var streamAIWithTools = async function* (options) {
       messages,
       model: base.model,
       promptCaching: base.promptCaching,
+      providerOptions: base.providerOptions,
       reasoning: base.reasoning,
       signal: base.signal,
       stopSequences: base.stopSequences,
@@ -3853,6 +4886,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 });
@@ -3860,8 +4901,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;
@@ -5406,6 +6455,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,
@@ -5808,6 +6867,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) {
@@ -5878,6 +6951,9 @@ var applyAction = (state, action) => {
     case "image":
       handleImage(state, action);
       break;
+    case "audio":
+      handleAudio(state, action);
+      break;
     case "complete":
       handleComplete(state, action);
       break;
@@ -6197,6 +7273,7 @@ var startProviderStatusMonitor = (options) => {
 export {
   xai,
   withResilience,
+  verifyOpenRouterWebhookSignature,
   tableCard,
   streamAIWithTools,
   streamAIToSSE,
@@ -6223,9 +7300,13 @@ export {
   parseChoiceSpec,
   parseChartSpec,
   parseAIMessage,
+  openrouterResponses,
+  openrouterMessages,
+  openrouter,
   openaiResponses,
   openaiCompatible,
   openai,
+  openRouterModelMatchesRule,
   ollama,
   moonshot,
   mistralai,
@@ -6245,6 +7326,7 @@ export {
   createUiCards,
   createSyncConversationStore,
   createProviderProxyResponse,
+  createOpenRouterClient,
   createOAuth2ClientCredentialsTokenSource,
   createMemoryStore,
   createConversationManager,
@@ -6282,5 +7364,5 @@ export {
   BUILTIN_UI_CARDS
 };
 
-//# debugId=8DDC9883DEF6AEEE64756E2164756E21
+//# debugId=3B5ACA11D1118B9564756E2164756E21
 //# sourceMappingURL=index.js.map