ask-llm-providers 0.6.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 915a6861e0cbc8cdddcc9f1b9f936d9f95896943f1307f199dfe604b8f4d527c
-  data.tar.gz: 9f667d8f56d4e1265314c4dfdeaebbefbab7dae0a74724dc31ac79074decf3ef
+  metadata.gz: 3cd9e34fd4befbdd393f4b4496b0d0e5dde254dc2ef10c3d86bb7043f81406de
+  data.tar.gz: 6de8ecfb85b0aa79f5623a0968ea8a787dc8c64ebce9da6d5d49122ef82e037c
 SHA512:
-  metadata.gz: 528d7105a625887f249e0fe7a0f0dad3469e47f73cfad59d02d85613cdecb287d9277c007cc50b1fc574053fc44ac27b6fa198cf3221ec0de8881dca2be65b33
-  data.tar.gz: b6d3e1dc25804a7808e7cfa45ec2ff7f9542ca43fad5336a7131c7dd18930264badcf9575f0ee993781f7ced64cd9dfa496a8e14851b4f73e60fa0db4f1c780f
+  metadata.gz: 10878f289f4fc79c814e839554adf05f7931e5a4eaa100cc5b584a20ee0bc16fece12c65472af23872abb30885e4e1cbdfc05310baffce4cd4f1dc4be60a622d
+  data.tar.gz: c2fbe34457dcd128b2601baf756257d6147761505150b700d988d130e580017b9e6839ad9b5ba0ea6f91ec398ec1e09ae2bf3c363c2b6508a2d44a9c16368235

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## [0.8.0] — 2026-07-17
+
+### Added
+
+- **OpenRouter model source** (`Ask::LLM::Sources::OpenRouter`) — fetches model data from OpenRouter API and fills gaps that models.dev doesn't cover. Adds models for providers like Groq, Together, Fireworks, Cerebras, Meta, Moonshot, Nvidia NIM that aren't in models.dev. Merges with existing models.dev data — models.dev takes priority for overlapping models.
+- **`CostCalculator.per_million`** — returns per-million token rates for quick display: `{ input: 2.5, output: 10.0, cache_read: 1.25 }`.
+- **Audio token costing** — `calculate` and `breakdown` now accept `audio_input_tokens` and `audio_output_tokens` parameters. Costs are computed from `audio_tokens` pricing data.
+- **Tiered pricing** — both `calculate` and `breakdown` accept a `tier:` parameter (`:standard` or `:batch`) that selects the appropriate rate tier.
+- **`rake models:update`** — now fetches both models.dev and OpenRouter in sequence.
+
+### Changed
+
+- **Model coverage: 62 → 406 models** across 12 providers, with 397 (98%) having full pricing data.
+- **OpenRouter source added** — providers without models.dev coverage (meta, moonshot, nvidia_nim) now have bundled models.
+- **`build_model_info`** — pricing hashes are deep-symbolized. `Date.parse` failures handled gracefully via `safe_parse_date`.
+
+## [0.7.0] — 2026-07-17
+
+### Added
+
+- **`Ask::LLM::Sources::ModelsDev`** — fetches model data from `models.dev` API and writes enriched per-provider JSON files with pricing, capabilities, and modalities. Run `rake models:update` before each release to keep bundled model data current.
+- **`Ask::LLM::CostCalculator`** — calculates LLM API costs from model pricing data. Supports input, output, cache read/write, and reasoning tokens.
+
+### Changed
+
+- **Model coverage expanded** — from 62 to 289 models across 10 providers, with 284 (98%) having full pricing data. Generated from models.dev API instead of hand-written.
+- **`build_model_info` now deep-symbolizes pricing keys** — pricing hashes loaded from JSON now use symbol keys (`:text_tokens`, `:standard`, `:input_per_million`) matching the format produced by `ModelsDevParser` in ask-core.
+- **`build_model_info` handles date parsing safely** — `Date.parse` failures no longer silently destroy the entire model entry via a broad `rescue Date::Error`. Invalid dates are gracefully set to `nil` via `safe_parse_date`.
+
+### Fixed
+
+- **Pricing data loss bug** — `rescue Date::Error` in `build_model_info` was catching exceptions from the entire method body, including date parsing and pricing construction. When any model had an unparseable date, its ModelInfo was created with only `id` and `provider`, silently discarding pricing, capabilities, modalities, and all other fields.
+- **Pricing key inconsistency** — pricing loaded from JSON had string keys while pricing from `ModelsDevParser` (ask-core) had symbol keys. Both formats now consistently use symbol keys.
+
 ## [0.6.1] — 2026-07-17
 
 ### Added

data/lib/ask/llm/catalog.rb

@@ -35,6 +35,8 @@ module Ask
           true
         end
 
+
+
         # Like load! but also fetches model lists from configured providers'
         # list_models() APIs. Unknown models are added with minimal metadata.
         def refresh!
@@ -112,9 +114,12 @@ module Ask
       # Register all accumulated entries into Ask::ModelCatalog.
       # Also registers alias entries so models can be found by alias name.
       def register_all
+        catalog = Ask::ModelCatalog.instance
+        catalog.instance_variable_set(:@models, [])
+
         @entries.each do |entry|
           info = build_model_info(entry)
-          Ask::ModelCatalog.instance.register(info)
+          catalog.register(info)
         end
 
         register_alias_entries
@@ -142,6 +147,13 @@ module Ask
         hash.transform_keys { |k| k.respond_to?(:to_sym) ? k.to_sym : k }
       end
 
+      def deep_symbolize_keys(hash)
+        hash.each_with_object({}) { |(k, v), h|
+          hk = k.respond_to?(:to_sym) ? k.to_sym : k
+          h[hk] = v.is_a?(Hash) ? deep_symbolize_keys(v) : v
+        }
+      end
+
       def add_entry(entry)
         key = entry_key(entry)
         return if @model_keys.include?(key)
@@ -170,8 +182,16 @@ module Ask
 
       def build_model_info(entry)
         e = entry.transform_keys(&:to_sym)
-        modalities = e[:modalities]
-        modalities = symbolize_keys(modalities) if modalities
+
+        modalities = symbolize_keys(e[:modalities]) if e[:modalities]
+
+        pricing = {}
+        if e[:pricing] && e[:pricing].any?
+          deep_symbolize_keys(e[:pricing]).each { |k, v| pricing[k] = v }
+        end
+
+        knowledge_cutoff = safe_parse_date(e[:knowledge_cutoff])
+        created_at = safe_parse_date(e[:created_at])
 
         Ask::ModelInfo.new(
           id: e[:id],
@@ -182,13 +202,19 @@ module Ask
           context_window: e[:context_window],
           max_output_tokens: e[:max_output_tokens],
           modalities: modalities || { input: %w[text], output: %w[text] },
-          pricing: e[:pricing] || {},
-          knowledge_cutoff: e[:knowledge_cutoff] ? Date.parse(e[:knowledge_cutoff].to_s) : nil,
-          created_at: e[:created_at] ? Date.parse(e[:created_at].to_s) : nil,
+          pricing: pricing,
+          knowledge_cutoff: knowledge_cutoff,
+          created_at: created_at,
           metadata: (e[:metadata] || {}).merge(source: e[:metadata]&.dig("source") || "bundled")
         )
-      rescue Date::Error
-        Ask::ModelInfo.new(id: e[:id], provider: e[:provider])
+      end
+
+      def safe_parse_date(value)
+        return nil if value.nil?
+        return value if value.is_a?(Date)
+        Date.parse(value.to_s)
+      rescue ArgumentError
+        nil
       end
     end
   end

data/lib/ask/llm/cost_calculator.rb

@@ -3,79 +3,107 @@
 module Ask
   module LLM
     # Calculate LLM API costs from model pricing data.
-    #
-    # Works with any object responding to +#pricing+ that returns a hash
-    # in the standard ask-rb pricing format:
-    #
-    #   {
-    #     text_tokens: {
-    #       standard: {
-    #         input_per_million: 2.5,
-    #         output_per_million: 10.0,
-    #         cache_read_input_per_million: 1.25,
-    #         cache_write_input_per_million: 5.0,
-    #         reasoning_output_per_million: 15.0
-    #       }
-    #     },
-    #     audio_tokens: { standard: { input_per_million: 100.0, output_per_million: 200.0 } }
-    #   }
-    #
     module CostCalculator
       MILLION = 1_000_000
 
       class << self
-        # Calculate the total cost in USD for a model invocation.
+        # Calculate total cost in USD for a model invocation.
         #
-        # @param model [Ask::ModelInfo, #pricing] the model
+        # @param model [Ask::ModelInfo, #pricing] the model or a pricing hash
         # @param input_tokens [Integer]
         # @param output_tokens [Integer]
         # @param cache_read_tokens [Integer]
         # @param cache_write_tokens [Integer]
-        # @param reasoning_tokens [Integer] tokens billed at reasoning rate
+        # @param reasoning_tokens [Integer]
+        # @param audio_input_tokens [Integer]
+        # @param audio_output_tokens [Integer]
+        # @param tier [Symbol] pricing tier (:standard or :batch)
         # @return [Float, nil] cost in USD, or nil if no pricing data
         def calculate(model, input_tokens: 0, output_tokens: 0,
                       cache_read_tokens: 0, cache_write_tokens: 0,
-                      reasoning_tokens: 0)
-          pricing = model.respond_to?(:pricing) ? model.pricing : model
-          rates = pricing.dig(:text_tokens, :standard) or return nil
+                      reasoning_tokens: 0,
+                      audio_input_tokens: 0, audio_output_tokens: 0,
+                      tier: :standard)
+          pricing = extract_pricing(model)
+          return nil unless pricing
+
+          rates = pricing.dig(:text_tokens, tier) or return nil
 
           sum = cost(input_tokens, rates[:input_per_million])
           sum += cost(output_tokens, rates[:output_per_million])
+          sum += cost(cache_read_tokens, rates[:cache_read_input_per_million])
+          sum += cost(cache_write_tokens, rates[:cache_write_input_per_million])
 
-          if cache_read_tokens > 0
-            sum += cost(cache_read_tokens, rates[:cache_read_input_per_million])
-          end
-          if cache_write_tokens > 0
-            sum += cost(cache_write_tokens, rates[:cache_write_input_per_million])
-          end
           if reasoning_tokens > 0
             rate = rates[:reasoning_output_per_million] || rates[:output_per_million]
             sum += cost(reasoning_tokens, rate)
           end
 
+          if audio_input_tokens > 0 || audio_output_tokens > 0
+            audio = pricing.dig(:audio_tokens, tier)
+            sum += cost(audio_input_tokens, audio[:input_per_million]) if audio
+            sum += cost(audio_output_tokens, audio[:output_per_million]) if audio
+          end
+
           sum
         end
 
-        # Cost breakdown with individual components.
+        # Per-million rates for quick display.
+        #
+        # @param model [Ask::ModelInfo, #pricing]
+        # @param tier [Symbol] (:standard or :batch)
+        # @return [Hash, nil]
+        def per_million(model, tier: :standard)
+          pricing = extract_pricing(model)
+          return nil unless pricing
+
+          rates = pricing.dig(:text_tokens, tier) or return nil
+
+          {
+            input: rates[:input_per_million],
+            output: rates[:output_per_million],
+            cache_read: rates[:cache_read_input_per_million],
+            cache_write: rates[:cache_write_input_per_million],
+            reasoning: rates[:reasoning_output_per_million]
+          }.compact
+        end
+
+        # Per-component cost breakdown.
         #
         # @return [Hash, nil]
         def breakdown(model, input_tokens: 0, output_tokens: 0,
                       cache_read_tokens: 0, cache_write_tokens: 0,
-                      reasoning_tokens: 0)
-          pricing = model.respond_to?(:pricing) ? model.pricing : model
-          rates = pricing.dig(:text_tokens, :standard) or return nil
+                      reasoning_tokens: 0,
+                      audio_input_tokens: 0, audio_output_tokens: 0,
+                      tier: :standard)
+          pricing = extract_pricing(model)
+          return nil unless pricing
 
-          {
+          rates = pricing.dig(:text_tokens, tier) or return nil
+
+          result = {
             input: cost(input_tokens, rates[:input_per_million]),
             output: cost(output_tokens, rates[:output_per_million]),
-            cache_read: cache_read_tokens > 0 ? cost(cache_read_tokens, rates[:cache_read_input_per_million]) : 0,
-            cache_write: cache_write_tokens > 0 ? cost(cache_write_tokens, rates[:cache_write_input_per_million]) : 0,
-            reasoning: reasoning_tokens > 0 ? cost(reasoning_tokens, rates[:reasoning_output_per_million] || rates[:output_per_million]) : 0
+            cache_read: cost(cache_read_tokens, rates[:cache_read_input_per_million]),
+            cache_write: cost(cache_write_tokens, rates[:cache_write_input_per_million]),
+            reasoning: cost(reasoning_tokens, rates[:reasoning_output_per_million] || rates[:output_per_million])
           }.compact
+
+          if audio_input_tokens > 0 || audio_output_tokens > 0
+            audio = pricing.dig(:audio_tokens, tier)
+            result[:audio_input] = cost(audio_input_tokens, audio[:input_per_million]) if audio
+            result[:audio_output] = cost(audio_output_tokens, audio[:output_per_million]) if audio
+          end
+
+          result
         end
 
         private
 
+        def extract_pricing(model)
+          model.respond_to?(:pricing) ? model.pricing : model
+        end
+
         def cost(tokens, rate)
           return 0.0 unless rate && tokens > 0
           (tokens * rate) / MILLION.to_f