ask-llm-providers 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82485a61da8048017c554844b7b31218778eca6c20a95a237331b62c2eb31da4
-  data.tar.gz: 66818f024528ecf1dde358b5a6e0882687b2e75c023d9c02659fa9c97116babb
+  metadata.gz: 48397005f7c0a96ae277cc4542f716c389000bb958ef060e474efa763f3cb2e7
+  data.tar.gz: ad14c0674e82ff5ee6572ee16c2c2c2731222b846ac1ea10e3ed51b59eb453cd
 SHA512:
-  metadata.gz: ac4f1392b495866a46232a8d3b7b5ae00adf4db9e14cc05c774e3478a15f31f8d79313eebf110749d3972ea6f5b02ec33d90a536ec4dade0a8498c58b265ca45
-  data.tar.gz: 423dadd52ef3653cf8552b7fde1f9a551c793f0c9c1650af139ada68f415d22e90f9d76a1e6788fd2633f074af09439dbf8304168e3f017f7161a46627330327
+  metadata.gz: 05db1db4749217a513b85be42e0b7492466d657ea1c90f50b5fe3bacec83745555d95440c77ffe6df90a356584b99f4f3619645a99d1eb8bf73103aed4c39e94
+  data.tar.gz: adbb4b2e782d488a87aae1b7c1ba9478dfc9e083c013f701f78984a28fe49c081f42f254197ed071c03a6f31820ecc10de35ef101d97d26e806a5b21d9765074

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## [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
+
+- **`Ask::LLM::CostCalculator`** — calculate LLM API costs from model pricing data. Supports input, output, cache read/write, and reasoning tokens. Returns cost in USD or nil if no pricing data available. Works with any object responding to `#pricing` (Ask::ModelInfo, raw hash, etc.).
+- **`CostCalculator.breakdown`** — returns a component-by-component cost breakdown hash.
+
 ## [0.6.0] — 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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+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.
+        #
+        # @param model [Ask::ModelInfo, #pricing] the model
+        # @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
+        # @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
+
+          sum = cost(input_tokens, rates[:input_per_million])
+          sum += cost(output_tokens, rates[:output_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
+
+          sum
+        end
+
+        # Cost breakdown with individual components.
+        #
+        # @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
+
+          {
+            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
+          }.compact
+        end
+
+        private
+
+        def cost(tokens, rate)
+          return 0.0 unless rate && tokens > 0
+          (tokens * rate) / MILLION.to_f
+        end
+      end
+    end
+  end
+end