ask-llm-providers 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48397005f7c0a96ae277cc4542f716c389000bb958ef060e474efa763f3cb2e7
-  data.tar.gz: ad14c0674e82ff5ee6572ee16c2c2c2731222b846ac1ea10e3ed51b59eb453cd
+  metadata.gz: 47102c012ea2700606f18c21510b875399a323d5a52ee91eca0b55c176b59468
+  data.tar.gz: 9e1e42e298a7e4d4ec40c3d9a3a631fbb9605e48816a439621ac4b4129cd0abe
 SHA512:
-  metadata.gz: 05db1db4749217a513b85be42e0b7492466d657ea1c90f50b5fe3bacec83745555d95440c77ffe6df90a356584b99f4f3619645a99d1eb8bf73103aed4c39e94
-  data.tar.gz: adbb4b2e782d488a87aae1b7c1ba9478dfc9e083c013f701f78984a28fe49c081f42f254197ed071c03a6f31820ecc10de35ef101d97d26e806a5b21d9765074
+  metadata.gz: effa863afea39f4dc924a1df6d88dce2ebb8639f6d607230df47233a54ef4e124cd998d0efe1a7e63ef5c2bcb6e7dadc7814804f5b9bb35bd82e0ee3c661de00
+  data.tar.gz: 7081eb62a0db815a56cfdaa04212cf4cc96fbd88fd17c4b8f5109535186d30bfa7a2e20d642cfe8617162eb2313a0229f18ad7e4d968cb29e9b8bfec590352e9

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [0.8.1] — 2026-07-17
+
+### Added
+
+- **Rich error categories in HTTP mapper** — `Ask::LLM::HTTP.map_error` now sets `category`, `rate_limit_type`, and `retry_after` on `RateLimitError` instances. Rate limit type is detected from error message keywords (token, budget, concurrent, requests). `retry_after` is extracted from response headers.
+
+## [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

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

data/lib/ask/llm/http.rb

@@ -14,7 +14,13 @@ module Ask
       end
 
       # Map an HTTP exception or error response to the appropriate Ask::Error.
-      def self.map_error(status, body, provider:)
+      #
+      # @param status [Integer] HTTP status code
+      # @param body [Hash, String, nil] response body
+      # @param provider [String] provider name for error messages
+      # @param headers [Hash, nil] response headers (for retry-after etc.)
+      # @return [Ask::Error]
+      def self.map_error(status, body, provider:, headers: nil)
         body = JSON.parse(body) rescue body if body.is_a?(String)
         message = extract_error_message(body, status) || "HTTP #{status} from #{provider}"
 
@@ -25,12 +31,25 @@ module Ask
         end
 
         case status
-        when 400 then Ask::ProviderError.new(message, status_code: status, response_body: body&.to_json)
-        when 401, 403 then Ask::Unauthorized.new("#{provider}: #{message}")
-        when 429 then Ask::RateLimitError.new("#{provider}: #{message}")
-        when 500 then Ask::ServerError.new("#{provider}: #{message}")
-        when 503 then Ask::ServiceUnavailable.new("#{provider}: #{message}")
-        else Ask::ProviderError.new("#{provider}: #{message}", status_code: status, response_body: body&.to_json)
+        when 400
+          Ask::ProviderError.new(message, status_code: status, response_body: body&.to_json)
+        when 401, 403
+          Ask::Unauthorized.new("#{provider}: #{message}")
+        when 429
+          retry_after = extract_retry_after(headers)
+          rate_limit_type = detect_rate_limit_type(body)
+          Ask::RateLimitError.new(
+            "#{provider}: #{message}",
+            category: Ask::RateLimitCategory::VENDOR,
+            rate_limit_type: rate_limit_type,
+            retry_after: retry_after
+          )
+        when 500
+          Ask::ServerError.new("#{provider}: #{message}")
+        when 503
+          Ask::ServiceUnavailable.new("#{provider}: #{message}")
+        else
+          Ask::ProviderError.new("#{provider}: #{message}", status_code: status, response_body: body&.to_json)
         end
       end
 
@@ -48,6 +67,37 @@ module Ask
           body.to_s
         end
       end
+
+      # Extract retry_after from response headers.
+      # Providers send Retry-After as seconds (integer) or HTTP-date.
+      # @param headers [Hash, nil]
+      # @return [Integer, nil]
+      def self.extract_retry_after(headers)
+        return nil unless headers.is_a?(Hash)
+
+        raw = headers["retry-after"] || headers["Retry-After"] || headers["retry_after"]
+        return nil unless raw
+
+        int = Integer(raw) rescue nil
+        return int if int
+
+        Time.parse(raw) - Time.now rescue nil
+      end
+
+      # Detect rate limit type from error body.
+      # @param body [Hash, nil]
+      # @return [Symbol, nil]
+      def self.detect_rate_limit_type(body)
+        return nil unless body.respond_to?(:dig)
+
+        msg = body.dig("error", "message") || body.dig("error", "code") || ""
+        msg_lower = msg.to_s.downcase
+
+        return Ask::RateLimitType::BUDGET if msg_lower.include?("budget") || msg_lower.include?("quota")
+        return Ask::RateLimitType::TOKENS if msg_lower.include?("token") || msg_lower.include?("tpm")
+        return Ask::RateLimitType::CONCURRENT if msg_lower.include?("concurrent") || msg_lower.include?("parallel")
+        Ask::RateLimitType::REQUESTS
+      end
     end
   end
 end

data/lib/ask/llm/models/anthropic.json

@@ -1,4 +1,371 @@
 [
+  {
+    "id": "claude-3-haiku",
+    "name": "Anthropic: Claude 3 Haiku",
+    "provider": "anthropic",
+    "context_window": 200000,
+    "max_output_tokens": 4096,
+    "capabilities": [
+      "vision"
+    ],
+    "modalities": {
+      "input": [
+        "text",
+        "image"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 0.25,
+          "output_per_million": 1.25,
+          "cache_read_input_per_million": 0.03,
+          "cache_write_input_per_million": 0.3
+        }
+      }
+    },
+    "architecture": "text+image->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-haiku-4.5",
+    "name": "Anthropic: Claude Haiku 4.5",
+    "provider": "anthropic",
+    "context_window": 200000,
+    "max_output_tokens": 64000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 1.0,
+          "output_per_million": 5.0,
+          "cache_read_input_per_million": 0.1,
+          "cache_write_input_per_million": 1.25
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-opus-4",
+    "name": "Anthropic: Claude Opus 4",
+    "provider": "anthropic",
+    "context_window": 200000,
+    "max_output_tokens": 32000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 15.0,
+          "output_per_million": 75.0,
+          "cache_read_input_per_million": 1.5,
+          "cache_write_input_per_million": 18.75
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-opus-4.1",
+    "name": "Anthropic: Claude Opus 4.1",
+    "provider": "anthropic",
+    "context_window": 200000,
+    "max_output_tokens": 32000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 15.0,
+          "output_per_million": 75.0,
+          "cache_read_input_per_million": 1.5,
+          "cache_write_input_per_million": 18.75
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-opus-4.5",
+    "name": "Anthropic: Claude Opus 4.5",
+    "provider": "anthropic",
+    "context_window": 200000,
+    "max_output_tokens": 64000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 5.0,
+          "output_per_million": 25.0,
+          "cache_read_input_per_million": 0.5,
+          "cache_write_input_per_million": 6.25
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-opus-4.6",
+    "name": "Anthropic: Claude Opus 4.6",
+    "provider": "anthropic",
+    "context_window": 1000000,
+    "max_output_tokens": 128000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 5.0,
+          "output_per_million": 25.0,
+          "cache_read_input_per_million": 0.5,
+          "cache_write_input_per_million": 6.25
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-opus-4.7",
+    "name": "Anthropic: Claude Opus 4.7",
+    "provider": "anthropic",
+    "context_window": 1000000,
+    "max_output_tokens": 128000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 5.0,
+          "output_per_million": 25.0,
+          "cache_read_input_per_million": 0.5,
+          "cache_write_input_per_million": 6.25
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-opus-4.7-fast",
+    "name": "Anthropic: Claude Opus 4.7 (Fast)",
+    "provider": "anthropic",
+    "context_window": 1000000,
+    "max_output_tokens": 128000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 30.0,
+          "output_per_million": 150.0,
+          "cache_read_input_per_million": 3.0,
+          "cache_write_input_per_million": 37.5
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-opus-4.8",
+    "name": "Anthropic: Claude Opus 4.8",
+    "provider": "anthropic",
+    "context_window": 1000000,
+    "max_output_tokens": 128000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 5.0,
+          "output_per_million": 25.0,
+          "cache_read_input_per_million": 0.5,
+          "cache_write_input_per_million": 6.25
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-opus-4.8-fast",
+    "name": "Anthropic: Claude Opus 4.8 (Fast)",
+    "provider": "anthropic",
+    "context_window": 1000000,
+    "max_output_tokens": 128000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 10.0,
+          "output_per_million": 50.0,
+          "cache_read_input_per_million": 1.0,
+          "cache_write_input_per_million": 12.5
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-sonnet-4",
+    "name": "Anthropic: Claude Sonnet 4",
+    "provider": "anthropic",
+    "context_window": 1000000,
+    "max_output_tokens": 64000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 3.0,
+          "output_per_million": 15.0,
+          "cache_read_input_per_million": 0.3,
+          "cache_write_input_per_million": 3.75
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-sonnet-4.5",
+    "name": "Anthropic: Claude Sonnet 4.5",
+    "provider": "anthropic",
+    "context_window": 1000000,
+    "max_output_tokens": 64000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 3.0,
+          "output_per_million": 15.0,
+          "cache_read_input_per_million": 0.3,
+          "cache_write_input_per_million": 3.75
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
+  {
+    "id": "claude-sonnet-4.6",
+    "name": "Anthropic: Claude Sonnet 4.6",
+    "provider": "anthropic",
+    "context_window": 1000000,
+    "max_output_tokens": 128000,
+    "capabilities": [],
+    "modalities": {
+      "input": [
+        "text"
+      ],
+      "output": [
+        "text"
+      ]
+    },
+    "pricing": {
+      "text_tokens": {
+        "standard": {
+          "input_per_million": 3.0,
+          "output_per_million": 15.0,
+          "cache_read_input_per_million": 0.3,
+          "cache_write_input_per_million": 3.75
+        }
+      }
+    },
+    "architecture": "text+image+file->text",
+    "source": "openrouter"
+  },
   {
     "id": "claude-fable-5",
     "name": "Claude Fable 5",