@absolutejs/ai 0.0.49 → 0.0.50

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,
@@ -456,7 +457,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 +465,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,13 +494,13 @@ 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
@@ -510,12 +525,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 +591,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) => {
@@ -632,6 +651,35 @@ var processDelta = function* (delta, pendingToolCalls) {
   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 +698,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) {
   const trimmed = line.trim();
   if (!trimmed || !trimmed.startsWith("data: ")) {
     return;
@@ -664,7 +724,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;
@@ -677,6 +736,10 @@ var processSSELine = function* (line, pendingToolCalls, currentUsage) {
   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;
@@ -688,18 +751,30 @@ var processSSELine = function* (line, pendingToolCalls, currentUsage) {
   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) => {
+  const allChunks = Array.from(processSSELine(line, pendingToolCalls));
   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) {
   for (const line of lines) {
-    yield* collectYieldableChunks(line, pendingToolCalls, usageRef);
+    yield* collectYieldableChunks(line, pendingToolCalls, usageRef, metadataRef);
   }
 };
 var processStreamValue = (value, decoder, state) => {
@@ -712,51 +787,66 @@ 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);
   }
 };
-var parseSSEStream = async function* (body, signal) {
+var parseSSEStream = async function* (body, initialMetadata, signal) {
   const reader = body.getReader();
   const decoder = new TextDecoder;
   const state = {
     buffer: "",
+    metadataRef: { current: initialMetadata },
     pendingToolCalls: new Map,
     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
+    }
+  }, 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 +856,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 +921,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 +929,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) => {
@@ -903,7 +1010,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 +1062,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,
@@ -1193,24 +1300,28 @@ var parseSSEStream2 = async function* (body, signal) {
     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);
 };
@@ -1224,15 +1335,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 +1375,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
@@ -1571,6 +1724,9 @@ var mapContentBlock2 = (block) => {
       type: "tool_use"
     };
   }
+  if (block.type === "audio" || block.type === "video") {
+    throw new Error(`Anthropic does not support ${block.type} content blocks`);
+  }
   return { text: block.content, type: "text" };
 };
 var mapMessage = (msg) => ({
@@ -2228,6 +2384,429 @@ 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 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"
+      });
+    },
+    generateVideo: (body) => {
+      assertAllowedModel(body.model, allowedModels);
+      return request("/videos", {
+        body,
+        method: "POST"
+      });
+    },
+    getBatch: (id) => request(`/batches/${encodeURIComponent(id)}`),
+    getCredits: () => request("/credits"),
+    getCurrentKey: () => request("/key"),
+    getGeneration: (id) => request("/generation", {
+      query: { id }
+    }),
+    getModelEndpoints: (model) => {
+      assertAllowedModel(model, allowedModels);
+      return request(`/models/${encodeModelPath(model)}/endpoints`);
+    },
+    getVideo: (id) => request(`/videos/${encodeURIComponent(id)}`),
+    listImageModels: async () => filterModelList(await request("/images/models")),
+    listModels,
+    listPresets: (offset = 0, limit = 100) => request("/presets", { query: { limit, offset } }),
+    listProviders: () => request("/providers"),
+    listRerankModels: async () => filterModelList(await request("/rerank/models")),
+    listVideoModels: async () => filterModelList(await request("/videos/models")),
+    request,
+    requestRaw,
+    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"
+      });
+    }
+  };
+};
+
+// 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" && 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.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) => {
+  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;
+  }
+  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.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.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);
+};
+
 // src/plugins/aiChat.ts
 import { Elysia } from "elysia";
 
@@ -2644,6 +3223,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 +3310,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,
@@ -3111,6 +3692,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 +3705,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 +4195,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 +4208,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 +4232,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 +4427,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,
@@ -6223,9 +6826,12 @@ export {
   parseChoiceSpec,
   parseChartSpec,
   parseAIMessage,
+  openrouterResponses,
+  openrouter,
   openaiResponses,
   openaiCompatible,
   openai,
+  openRouterModelMatchesRule,
   ollama,
   moonshot,
   mistralai,
@@ -6245,6 +6851,7 @@ export {
   createUiCards,
   createSyncConversationStore,
   createProviderProxyResponse,
+  createOpenRouterClient,
   createOAuth2ClientCredentialsTokenSource,
   createMemoryStore,
   createConversationManager,
@@ -6282,5 +6889,5 @@ export {
   BUILTIN_UI_CARDS
 };
 
-//# debugId=8DDC9883DEF6AEEE64756E2164756E21
+//# debugId=A06FECA819C53C2464756E2164756E21
 //# sourceMappingURL=index.js.map