@absolutejs/ai 0.0.50 → 0.0.52

package/dist/ai/providers/openrouter.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;
@@ -923,7 +969,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,
@@ -1059,11 +1110,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") {
@@ -1120,6 +1192,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"
   };
 };
@@ -1138,9 +1211,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 : "",
@@ -1156,6 +1241,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 };
@@ -1163,12 +1272,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 : "";
@@ -1189,6 +1312,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;
@@ -1199,11 +1325,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) {
@@ -1212,7 +1337,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 = "";
@@ -1250,17 +1375,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();
   }
@@ -1288,7 +1415,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) {
@@ -1324,8 +1451,585 @@ var openaiResponses = (config2) => {
   }, providerName);
 };
 
+// src/ai/providers/anthropic.ts
+var h2IfHttps3 = (url) => url.startsWith("https://") ? { protocol: "http2" } : {};
+var DEFAULT_BASE_URL3 = "https://api.anthropic.com";
+var API_VERSION = "2023-06-01";
+var DEFAULT_MAX_TOKENS = 32000;
+var EVENT_PREFIX_LENGTH2 = 7;
+var DATA_PREFIX_LENGTH2 = 6;
+var EMPTY_CHUNKS = [];
+var isRecord3 = (val) => typeof val === "object" && val !== null;
+var mapContentBlock = (block) => {
+  if (block.type === "thinking") {
+    return {
+      signature: block.signature,
+      thinking: block.thinking,
+      type: "thinking"
+    };
+  }
+  if (block.type === "image") {
+    return {
+      source: block.source,
+      type: "image"
+    };
+  }
+  if (block.type === "document") {
+    return {
+      source: block.source,
+      type: "document"
+    };
+  }
+  if (block.type === "tool_result") {
+    return {
+      content: block.content,
+      tool_use_id: block.tool_use_id,
+      type: "tool_result"
+    };
+  }
+  if (block.type === "tool_use") {
+    if (block.providerData)
+      return { ...block.providerData };
+    return {
+      id: block.id,
+      input: block.input,
+      name: block.name,
+      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) => ({
+  content: typeof msg.content === "string" ? msg.content : msg.content.map(mapContentBlock),
+  role: msg.role === "system" ? "user" : msg.role
+});
+var mapToolDefinition2 = (tool) => ({
+  description: tool.description,
+  input_schema: tool.input_schema,
+  name: tool.name
+});
+var cacheLastContentBlock = (msg) => {
+  const cacheControl = { type: "ephemeral" };
+  if (typeof msg.content === "string") {
+    return {
+      content: [
+        { cache_control: cacheControl, text: msg.content, type: "text" }
+      ],
+      role: msg.role
+    };
+  }
+  if (msg.content.length === 0)
+    return msg;
+  const blocks = [...msg.content];
+  blocks[blocks.length - 1] = {
+    ...blocks[blocks.length - 1],
+    cache_control: cacheControl
+  };
+  return { content: blocks, role: msg.role };
+};
+var buildRequestBody3 = (params, configuredMax, configCaching) => {
+  const caching = params.promptCaching ?? configCaching;
+  const cacheSystem = params.cacheSystemPrompt ?? caching;
+  const messages = params.messages.filter((msg) => msg.role !== "system").map(mapMessage);
+  if (caching && messages.length > 1) {
+    const last = messages[messages.length - 1];
+    if (last) {
+      messages[messages.length - 1] = cacheLastContentBlock(last);
+    }
+  }
+  const max = typeof params.maxTokens === "number" ? params.maxTokens : configuredMax;
+  const body = {
+    max_tokens: max,
+    messages,
+    model: params.model,
+    stream: true
+  };
+  if (params.systemPrompt) {
+    body.system = cacheSystem ? [
+      {
+        cache_control: { type: "ephemeral" },
+        text: params.systemPrompt,
+        type: "text"
+      }
+    ] : params.systemPrompt;
+  }
+  if (params.tools && params.tools.length > 0) {
+    const tools = params.tools.map(mapToolDefinition2);
+    if (caching) {
+      tools[tools.length - 1] = {
+        ...tools[tools.length - 1],
+        cache_control: { type: "ephemeral" }
+      };
+    }
+    body.tools = tools;
+    if (params.toolChoice === "auto" || params.toolChoice === "none") {
+      body.tool_choice = { type: params.toolChoice };
+    } else if (params.toolChoice === "required") {
+      body.tool_choice = { type: "any" };
+    } else if (params.toolChoice && typeof params.toolChoice === "object") {
+      body.tool_choice = { name: params.toolChoice.name, type: "tool" };
+    }
+  }
+  if (params.stopSequences && params.stopSequences.length > 0) {
+    body.stop_sequences = params.stopSequences;
+  }
+  const mode = params.reasoning ? anthropicReasoningMode(params.model) : "none";
+  const thinkingActive = mode !== "none";
+  if (!thinkingActive && anthropicSupportsSampling(params.model)) {
+    if (typeof params.temperature === "number") {
+      body.temperature = params.temperature;
+    }
+    if (typeof params.topP === "number")
+      body.top_p = params.topP;
+  }
+  if (mode === "effort" || mode === "adaptive") {
+    body.thinking = { type: "adaptive" };
+    if (mode === "effort" && params.reasoning) {
+      const effort = anthropicEffortValue(params.model, params.reasoning);
+      if (effort)
+        body.output_config = { effort };
+    }
+  } else if (mode === "legacy" && params.reasoning) {
+    const budget = resolveBudgetTokens(params.reasoning);
+    if (budget) {
+      body.thinking = { budget_tokens: budget, type: "enabled" };
+      body.max_tokens = Math.max(max, budget + max);
+    }
+  }
+  return body;
+};
+var classifyLine = (line) => {
+  if (line.startsWith("event: ")) {
+    return {
+      field: "event",
+      value: line.slice(EVENT_PREFIX_LENGTH2)
+    };
+  }
+  if (line.startsWith("data: ")) {
+    return {
+      field: "data",
+      value: line.slice(DATA_PREFIX_LENGTH2)
+    };
+  }
+  return;
+};
+var applyClassified = (acc, classified) => {
+  if (!classified) {
+    return acc;
+  }
+  if (classified.field === "event") {
+    return { eventData: acc.eventData, eventType: classified.value };
+  }
+  return { eventData: classified.value, eventType: acc.eventType };
+};
+var parseEventLines = (event) => event.split(`
+`).reduce((acc, line) => applyClassified(acc, classifyLine(line)), {
+  eventData: "",
+  eventType: ""
+});
+var safeParse = (text) => {
+  try {
+    const result = JSON.parse(text);
+    return result;
+  } catch {
+    return;
+  }
+};
+var tryParseJson = (text) => {
+  const result = safeParse(text);
+  if (isRecord3(result)) {
+    return result;
+  }
+  return;
+};
+var getRecord = (obj, key) => {
+  const val = obj[key];
+  if (isRecord3(val)) {
+    return val;
+  }
+  return;
+};
+var getString = (obj, key) => {
+  const val = obj[key];
+  if (typeof val === "string") {
+    return val;
+  }
+  return "";
+};
+var getNumber = (obj, key) => {
+  const val = obj[key];
+  if (typeof val === "number") {
+    return val;
+  }
+  return 0;
+};
+var handleContentBlockStart = (parsed, state) => {
+  const block = getRecord(parsed, "content_block");
+  if (block && block.type === "tool_use") {
+    state.currentToolId = getString(block, "id");
+    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) => {
+  const delta = getRecord(parsed, "delta");
+  if (!delta) {
+    return;
+  }
+  if (delta.type === "thinking_delta") {
+    return {
+      content: getString(delta, "thinking"),
+      type: "thinking"
+    };
+  }
+  if (delta.type === "text_delta") {
+    return {
+      content: getString(delta, "text"),
+      type: "text"
+    };
+  }
+  if (delta.type === "input_json_delta") {
+    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");
+  }
+  return;
+};
+var handleContentBlockStop = (state) => {
+  if (state.isThinkingBlock && state.thinkingSignature) {
+    state.isThinkingBlock = false;
+    const signature = state.thinkingSignature;
+    state.thinkingSignature = "";
+    return {
+      content: "",
+      signature,
+      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;
+  }
+  const input = tryParseJson(state.toolInputJson) ?? state.toolInputJson;
+  const chunk = {
+    id: state.currentToolId,
+    input,
+    name: state.currentToolName,
+    type: "tool_use"
+  };
+  state.currentToolId = "";
+  state.currentToolName = "";
+  state.toolInputJson = "";
+  return chunk;
+};
+var extractUsage3 = (usageRecord, existingUsage) => {
+  if (!usageRecord) {
+    return existingUsage;
+  }
+  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,
+    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) => {
+  const deltaUsage = getRecord(parsed, "usage");
+  state.usage = extractUsage3(deltaUsage, state.usage);
+  const delta = getRecord(parsed, "delta");
+  const stopReason = delta ? getString(delta, "stop_reason") : "";
+  if (stopReason)
+    state.stopReason = stopReason;
+};
+var handleMessageStart = (parsed, state) => {
+  const message = getRecord(parsed, "message");
+  if (!message) {
+    return;
+  }
+  const startUsage = getRecord(message, "usage");
+  state.usage = extractUsage3(startUsage, state.usage);
+  mergeMetadata(message, state);
+};
+var handleError = (parsed, state) => {
+  const error = getRecord(parsed, "error");
+  const errorMessage = error ? getString(error, "message") : "";
+  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",
+    metadata: error,
+    provider: state.providerName,
+    retryable,
+    type: errorType || null
+  });
+};
+var processEvent = (eventType, parsed, state) => {
+  switch (eventType) {
+    case "content_block_start": {
+      handleContentBlockStart(parsed, state);
+      return;
+    }
+    case "content_block_delta": {
+      return handleContentBlockDelta(parsed, state);
+    }
+    case "content_block_stop": {
+      return handleContentBlockStop(state);
+    }
+    case "message_delta": {
+      handleMessageDelta(parsed, state);
+      mergeMetadata(parsed, state);
+      return;
+    }
+    case "message_start": {
+      handleMessageStart(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, state);
+      return;
+    }
+    default: {
+      return;
+    }
+  }
+};
+var processSingleEvent = (event, state) => {
+  if (!event.trim()) {
+    return;
+  }
+  const { eventData, eventType } = parseEventLines(event);
+  if (!eventData) {
+    return;
+  }
+  const parsed = tryParseJson(eventData);
+  if (!parsed) {
+    return;
+  }
+  return processEvent(eventType, parsed, state);
+};
+var collectChunk = (event, state) => {
+  const chunk = processSingleEvent(event, state);
+  return chunk ? [chunk] : [];
+};
+var processBufferedEvents = (eventsText, state) => {
+  const events = eventsText.split(`
+
+`);
+  state.buffer = events.pop() ?? "";
+  return events.flatMap((event) => collectChunk(event, state));
+};
+var readNextChunks = async (reader, decoder, state, signal) => {
+  if (signal?.aborted) {
+    return { chunks: EMPTY_CHUNKS, done: true };
+  }
+  const { done, value } = await reader.read();
+  if (done) {
+    return { chunks: EMPTY_CHUNKS, done: true };
+  }
+  const rawText = state.buffer + decoder.decode(value, { stream: true });
+  const chunks = processBufferedEvents(rawText, state);
+  return { chunks, done: false };
+};
+var findDoneChunk = (chunks) => chunks.findIndex((c) => c.type === "done");
+var sseStreamLoop = async (reader, decoder, state, signal) => {
+  const result = await readNextChunks(reader, decoder, state, signal);
+  if (result.done) {
+    return { chunks: result.chunks, finished: true };
+  }
+  const doneIdx = findDoneChunk(result.chunks);
+  if (doneIdx >= 0) {
+    return { chunks: result.chunks.slice(0, doneIdx + 1), finished: true };
+  }
+  return { chunks: result.chunks, finished: false };
+};
+async function* streamChunks(reader, decoder, state, signal) {
+  let finished = false;
+  while (!finished) {
+    const result = await sseStreamLoop(reader, decoder, state, signal);
+    ({ finished } = result);
+    yield* result.chunks;
+  }
+}
+async function* parseSSEStream3(body, providerName, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  const state = {
+    buffer: "",
+    currentToolId: "",
+    currentToolName: "",
+    isThinkingBlock: false,
+    stopReason: "",
+    thinkingSignature: "",
+    toolInputJson: "",
+    usage: undefined,
+    providerName,
+    providerBlockInputJson: ""
+  };
+  try {
+    yield* streamChunks(reader, decoder, state, signal);
+  } finally {
+    reader.releaseLock();
+  }
+}
+var fetchAndStream = async function* (baseUrl, config2, params, configuredMax, promptCaching, providerName) {
+  const builtBody = buildRequestBody3(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, {
+    ...h2IfHttps3(target),
+    body: JSON.stringify(body),
+    headers: requestHeaders,
+    method: "POST",
+    signal: params.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw ProviderError.fromResponse(providerName, response.status, errorText);
+  }
+  if (!response.body) {
+    throw new ProviderError({
+      message: `${providerName} Messages API returned no response body`,
+      provider: providerName,
+      retryable: true
+    });
+  }
+  yield* parseSSEStream3(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_URL3;
+  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, providerName)
+  }, providerName);
+};
+
 // src/ai/providers/openrouterClient.ts
-var DEFAULT_BASE_URL3 = "https://openrouter.ai/api/v1";
+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_URL4 = "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);
@@ -1339,6 +2043,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) => {
@@ -1351,13 +2071,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_URL4).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_URL3).replace(/\/$/, "");
+  const baseUrl = (config2.baseUrl ?? DEFAULT_BASE_URL4).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);
@@ -1371,13 +2220,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)
@@ -1396,10 +2248,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", {
@@ -1414,6 +2301,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", {
@@ -1421,25 +2319,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: (window = "7d") => request("/classifications/task", {
+      query: { window }
+    }),
     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", {
@@ -1471,12 +2434,57 @@ 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 });
+        });
+      }
     }
   };
 };
 
 // src/ai/providers/openrouter.ts
-var DEFAULT_BASE_URL4 = "https://openrouter.ai/api";
+var DEFAULT_BASE_URL5 = "https://openrouter.ai/api";
 var MAX_APP_CATEGORIES = 2;
 var withoutLatestPrefix2 = (model) => model.startsWith("~") ? model.slice(1) : model;
 var modelForOpenAICapabilities = (model) => {
@@ -1607,7 +2615,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);
@@ -1638,6 +2646,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));
@@ -1656,17 +2665,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;
@@ -1686,12 +2719,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)
@@ -1721,7 +2764,7 @@ var openrouter = (config2) => {
   const { allowedModels, allowedPresets } = snapshotPolicy(config2);
   const provider = openai({
     apiKey: config2.apiKey,
-    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL4,
+    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL5,
     fetch: config2.fetch,
     headers: (params) => resolveAttributionHeaders(config2, params),
     modelForCapabilities: modelForOpenAICapabilities,
@@ -1736,7 +2779,7 @@ var openrouterResponses = (config2) => {
   const { allowedModels, allowedPresets } = snapshotPolicy(config2);
   const provider = openaiResponses({
     apiKey: config2.apiKey,
-    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL4,
+    baseUrl: config2.baseUrl ?? DEFAULT_BASE_URL5,
     fetch: config2.fetch,
     headers: (params) => resolveAttributionHeaders(config2, params),
     modelForCapabilities: modelForOpenAICapabilities,
@@ -1746,12 +2789,35 @@ 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_URL5,
+    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);
+};
 export {
+  verifyOpenRouterWebhookSignature,
   openrouterResponses,
+  openrouterMessages,
   openrouter,
   openRouterModelMatchesRule,
-  createOpenRouterClient
+  generateOpenRouterPKCE,
+  exchangeOpenRouterAuthCode,
+  estimateOpenRouterModelCost,
+  estimateOpenRouterCost,
+  createOpenRouterKeyLinks,
+  createOpenRouterClient,
+  createOpenRouterAuthorizationUrl
 };
 
-//# debugId=BFDE217D89D0CFF064756E2164756E21
+//# debugId=FABF06EDFC815F9A64756E2164756E21
 //# sourceMappingURL=openrouter.js.map