@standardagents/openrouter 0.24.4 → 0.24.6

package/dist/index.d.ts

@@ -173,11 +173,32 @@ declare class OpenRouterProvider implements LLMProviderInterface {
     private static modelsCache;
     private static modelsCacheTime;
     private static readonly CACHE_TTL;
+    /** In-flight catalog download shared by concurrent callers. */
+    private static modelsFetchPromise;
+    /** Timestamp of the last failed catalog fetch, for negative caching. */
+    private static modelsFetchFailedAt;
+    private static readonly FAILURE_RETRY_MS;
     /**
      * Get capabilities for a specific model.
      * Fetches from OpenRouter's models API which provides rich metadata.
      */
     getModelCapabilities(modelId: string): Promise<ModelCapabilities | null>;
+    /**
+     * How long a streaming finish chunk may wait on the catalog pricing lookup.
+     * The lookup is started when the stream starts, so by finish time it is
+     * almost always resolved; the bound guarantees a slow catalog download can
+     * never stall the finish chunk into the runtime's stream watchdog.
+     */
+    private static readonly USAGE_PRICING_FINISH_WAIT_MS;
+    private static settleUsagePricing;
+    /** Bounded-wait pricing attachment shared by the non-streaming paths. */
+    private attachUsagePricing;
+    /**
+     * Exact unit prices for a model from OpenRouter's live catalog (cached),
+     * attached to response usage so request logs can record specific prices.
+     * Best-effort: any failure just leaves pricing off the usage payload.
+     */
+    private getUsagePricing;
     private fetchModelsWithCache;
     private mapOpenRouterCapabilities;
     /**

package/dist/index.js

@@ -1944,6 +1944,25 @@ function getModelIconDataUri(modelId) {
 }
 
 // src/OpenRouterProvider.ts
+function usagePricingFromCatalogPricing(pricing) {
+  if (!pricing) return void 0;
+  const perMillion = (value) => {
+    if (value === void 0) return void 0;
+    const parsed = Number.parseFloat(value);
+    if (!Number.isFinite(parsed)) return void 0;
+    return Number((parsed * 1e6).toFixed(12));
+  };
+  const inputPerMillion = perMillion(pricing.prompt);
+  const outputPerMillion = perMillion(pricing.completion);
+  if (inputPerMillion === void 0 || outputPerMillion === void 0) {
+    return void 0;
+  }
+  return {
+    inputPerMillion,
+    cachedInputPerMillion: perMillion(pricing.input_cache_read),
+    outputPerMillion
+  };
+}
 var OpenRouterProvider = class _OpenRouterProvider {
   name = "openrouter";
   specificationVersion = "1";
@@ -2075,6 +2094,11 @@ var OpenRouterProvider = class _OpenRouterProvider {
   static modelsCacheTime = 0;
   static CACHE_TTL = 5 * 60 * 1e3;
   // 5 minutes
+  /** In-flight catalog download shared by concurrent callers. */
+  static modelsFetchPromise = null;
+  /** Timestamp of the last failed catalog fetch, for negative caching. */
+  static modelsFetchFailedAt = 0;
+  static FAILURE_RETRY_MS = 60 * 1e3;
   /**
    * Get capabilities for a specific model.
    * Fetches from OpenRouter's models API which provides rich metadata.
@@ -2092,19 +2116,73 @@ var OpenRouterProvider = class _OpenRouterProvider {
       return null;
     }
   }
+  /**
+   * How long a streaming finish chunk may wait on the catalog pricing lookup.
+   * The lookup is started when the stream starts, so by finish time it is
+   * almost always resolved; the bound guarantees a slow catalog download can
+   * never stall the finish chunk into the runtime's stream watchdog.
+   */
+  static USAGE_PRICING_FINISH_WAIT_MS = 2500;
+  static async settleUsagePricing(pricingPromise) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(void 0), _OpenRouterProvider.USAGE_PRICING_FINISH_WAIT_MS);
+    });
+    try {
+      return await Promise.race([pricingPromise, timeout]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  }
+  /** Bounded-wait pricing attachment shared by the non-streaming paths. */
+  async attachUsagePricing(result, pricingPromise) {
+    const pricing = await _OpenRouterProvider.settleUsagePricing(pricingPromise);
+    if (pricing) result.usage.pricing = pricing;
+    return result;
+  }
+  /**
+   * Exact unit prices for a model from OpenRouter's live catalog (cached),
+   * attached to response usage so request logs can record specific prices.
+   * Best-effort: any failure just leaves pricing off the usage payload.
+   */
+  async getUsagePricing(modelId) {
+    if (!modelId) return void 0;
+    try {
+      const models = await this.fetchModelsWithCache();
+      const model = models.find((m) => m.id === modelId);
+      return usagePricingFromCatalogPricing(model?.pricing);
+    } catch {
+      return void 0;
+    }
+  }
   async fetchModelsWithCache() {
     const now = Date.now();
     if (_OpenRouterProvider.modelsCache && now - _OpenRouterProvider.modelsCacheTime < _OpenRouterProvider.CACHE_TTL) {
       return _OpenRouterProvider.modelsCache;
     }
-    const response = await fetch("https://openrouter.ai/api/v1/models");
-    if (!response.ok) {
-      throw new Error(`OpenRouter API error: ${response.status}`);
+    if (now - _OpenRouterProvider.modelsFetchFailedAt < _OpenRouterProvider.FAILURE_RETRY_MS) {
+      throw new Error("OpenRouter models fetch recently failed");
     }
-    const data = await response.json();
-    _OpenRouterProvider.modelsCache = data.data || [];
-    _OpenRouterProvider.modelsCacheTime = now;
-    return _OpenRouterProvider.modelsCache;
+    if (!_OpenRouterProvider.modelsFetchPromise) {
+      _OpenRouterProvider.modelsFetchPromise = (async () => {
+        try {
+          const response = await fetch("https://openrouter.ai/api/v1/models");
+          if (!response.ok) {
+            throw new Error(`OpenRouter API error: ${response.status}`);
+          }
+          const data = await response.json();
+          _OpenRouterProvider.modelsCache = data.data || [];
+          _OpenRouterProvider.modelsCacheTime = Date.now();
+          return _OpenRouterProvider.modelsCache;
+        } catch (error) {
+          _OpenRouterProvider.modelsFetchFailedAt = Date.now();
+          throw error;
+        } finally {
+          _OpenRouterProvider.modelsFetchPromise = null;
+        }
+      })();
+    }
+    return _OpenRouterProvider.modelsFetchPromise;
   }
   mapOpenRouterCapabilities(model) {
     const capabilities = {
@@ -2189,6 +2267,7 @@ var OpenRouterProvider = class _OpenRouterProvider {
       if (this.config.providers && this.config.providers.length > 0) {
         params.provider = { only: this.config.providers };
       }
+      const pricingPromise = this.getUsagePricing(params.model);
       const response = await fetch(`${baseUrl}/chat/completions`, {
         method: "POST",
         headers: {
@@ -2210,7 +2289,7 @@ var OpenRouterProvider = class _OpenRouterProvider {
         throw new ProviderError(errorMessage, "invalid_request", response.status);
       }
       const data = await response.json();
-      return transformChatResponse(data);
+      return this.attachUsagePricing(transformChatResponse(data), pricingPromise);
     } catch (error) {
       throw this.toProviderError(error);
     }
@@ -2224,6 +2303,7 @@ var OpenRouterProvider = class _OpenRouterProvider {
     try {
       const params = buildCreateParams(request);
       this.applyConfiguredProvidersToResponses(params);
+      const pricingPromise = this.getUsagePricing(params.model);
       if (this.hasOpenRouterServerTools(params)) {
         const response2 = await fetch(`${baseUrl}/responses`, {
           method: "POST",
@@ -2241,14 +2321,14 @@ var OpenRouterProvider = class _OpenRouterProvider {
           await this.throwOpenRouterFetchError(response2);
         }
         const data = await response2.json();
-        return transformResponse(data);
+        return this.attachUsagePricing(transformResponse(data), pricingPromise);
       }
       const client = await this.getClient();
       const response = await client.beta.responses.send({
         ...this.toSdkResponsesRequest(params),
         stream: false
       });
-      return transformResponse(response);
+      return this.attachUsagePricing(transformResponse(response), pricingPromise);
     } catch (error) {
       throw this.toProviderError(error);
     }
@@ -2272,6 +2352,7 @@ var OpenRouterProvider = class _OpenRouterProvider {
       if (this.config.providers && this.config.providers.length > 0) {
         params.provider = { only: this.config.providers };
       }
+      const pricingPromise = this.getUsagePricing(params.model);
       const response = await fetch(`${baseUrl}/chat/completions`, {
         method: "POST",
         headers: {
@@ -2311,6 +2392,10 @@ var OpenRouterProvider = class _OpenRouterProvider {
               }
             }
             if (finishChunk) {
+              if (finishChunk.type === "finish") {
+                const pricing = await _OpenRouterProvider.settleUsagePricing(pricingPromise);
+                if (pricing) finishChunk.usage.pricing = pricing;
+              }
               const finishWithMeta = {
                 ...finishChunk,
                 _asyncMetadata: responseId ? {
@@ -2341,6 +2426,7 @@ var OpenRouterProvider = class _OpenRouterProvider {
     try {
       const params = buildCreateParams(request);
       this.applyConfiguredProvidersToResponses(params);
+      const pricingPromise = this.getUsagePricing(params.model);
       const response = await fetch(`${baseUrl}/responses`, {
         method: "POST",
         headers: {
@@ -2379,6 +2465,10 @@ var OpenRouterProvider = class _OpenRouterProvider {
               }
             }
             if (finishChunk) {
+              if (finishChunk.type === "finish") {
+                const pricing = await _OpenRouterProvider.settleUsagePricing(pricingPromise);
+                if (pricing) finishChunk.usage.pricing = pricing;
+              }
               const finishWithMeta = {
                 ...finishChunk,
                 // Include what's needed to fetch metadata later