open_router_enhanced 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d443d948a07c5b55d6366e135354b2faa07a8edc38cb2791237a6a4a92bd229a
-  data.tar.gz: 37a93b36720b58bf1ee1c4809aa4d54e4d29e06ba27a63c9285a78fa7074eb66
+  metadata.gz: 1f08650282b1232abfa779330c8f8ec9aad7bf6a984fd31e1a74ce1f3cad6962
+  data.tar.gz: e41ce6204abde21a34dd6c2976801666b8f4b9339cf81c845861f3837c15097c
 SHA512:
-  metadata.gz: 78fb6b74df5a7cb901ecac23fe503c667035e4794d6e7d9b97d4ad703e1f0a40347bd3274b86ba13c35501c8afc0b3c29ec5cb7b632eb93013af5a5328403285
-  data.tar.gz: 51d704a3035cf8211ac0d9533931d0b1a9bc9ebe49d21f192dd49b7dbb423eadcbf5adcc7b99d3212002947f2646337122e99660a589fa54be22ab3a356555eb
+  metadata.gz: 1d15f1e25db721734f0f9d2e43d01f6546af170096e65253c1c8438c3362484d6bad28f36669e2b8c34856ca297bb07dc1ffb18c7dc4442e2fe8c93ad79474b1
+  data.tar.gz: 2db9c96b66dcb0eae4b03f463db956192b38ef7444c879f7fe72a767e31c378d1ed702ee38a4c3b76e187945e6d942ac5dcbf7e7733fe8621315bee729e74940

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    open_router_enhanced (2.0.0)
+    open_router_enhanced (2.0.1)
       activesupport (>= 6.0, < 9.0)
       dotenv (>= 2.0, < 4.0)
       faraday (>= 1.0, < 3.0)

data/Rakefile

@@ -30,6 +30,17 @@ task ci: %i[spec_all rubocop]
 
 # Model exploration tasks
 namespace :models do
+  desc "Fetch fresh model data from OpenRouter API and update local cache"
+  task :update do
+    require_relative "lib/open_router"
+
+    print "Fetching models from OpenRouter API..."
+    OpenRouter::ModelRegistry.refresh!
+    count = OpenRouter::ModelRegistry.all_models.size
+    puts " done. #{count} models cached."
+  end
+
+
   desc "Display summary of available models"
   task :summary do
     require_relative "lib/open_router"
@@ -59,18 +70,18 @@ namespace :models do
     end
 
     # Cost analysis
-    input_costs = models.values.map { |spec| spec[:cost_per_1k_tokens][:input] }.compact.sort
-    output_costs = models.values.map { |spec| spec[:cost_per_1k_tokens][:output] }.compact.sort
+    input_costs = models.values.map { |spec| spec[:cost_per_token][:input] }.compact.sort
+    output_costs = models.values.map { |spec| spec[:cost_per_token][:output] }.compact.sort
 
-    puts "\n💰 Cost Analysis (per 1k tokens):"
+    puts "\n💰 Cost Analysis (per million tokens):"
     puts "  Input tokens:"
-    puts "    Min:    $#{format("%.6f", input_costs.min)}"
-    puts "    Max:    $#{format("%.6f", input_costs.max)}"
-    puts "    Median: $#{format("%.6f", input_costs[input_costs.size / 2])}"
+    puts "    Min:    $#{format("%.4f", input_costs.min * 1_000_000)}"
+    puts "    Max:    $#{format("%.4f", input_costs.max * 1_000_000)}"
+    puts "    Median: $#{format("%.4f", input_costs[input_costs.size / 2] * 1_000_000)}"
     puts "  Output tokens:"
-    puts "    Min:    $#{format("%.6f", output_costs.min)}"
-    puts "    Max:    $#{format("%.6f", output_costs.max)}"
-    puts "    Median: $#{format("%.6f", output_costs[output_costs.size / 2])}"
+    puts "    Min:    $#{format("%.4f", output_costs.min * 1_000_000)}"
+    puts "    Max:    $#{format("%.4f", output_costs.max * 1_000_000)}"
+    puts "    Median: $#{format("%.4f", output_costs[output_costs.size / 2] * 1_000_000)}"
 
     # Context length analysis
     context_lengths = models.values.map { |spec| spec[:context_length] }.compact.sort
@@ -269,8 +280,8 @@ namespace :models do
   def self.display_model_info(model_id, specs, index)
     puts "#{(index + 1).to_s.rjust(3)}. #{model_id}"
     puts "     Name: #{specs[:name]}" if specs[:name]
-    puts "     Cost: $#{format("%.6f", specs[:cost_per_1k_tokens][:input])}/1k input, " \
-         "$#{format("%.6f", specs[:cost_per_1k_tokens][:output])}/1k output"
+    cpm = OpenRouter::ModelRegistry.cost_per_million(model_id)
+    puts "     Cost: $#{format("%.4f", cpm[:input])}/M input, $#{format("%.4f", cpm[:output])}/M output"
     puts "     Context: #{format_number_with_commas(specs[:context_length])} tokens"
     puts "     Capabilities: #{specs[:capabilities].join(", ")}"
     puts "     Tier: #{specs[:performance_tier]}"
@@ -318,17 +329,17 @@ namespace :models do
   def self.sort_by_strategy(candidates, strategy)
     case strategy
     when :cost
-      candidates.sort_by { |_, specs| specs[:cost_per_1k_tokens][:input] }
+      candidates.sort_by { |_, specs| specs[:cost_per_token][:input] }
     when :performance
       candidates.sort_by do |_, specs|
-        [specs[:performance_tier] == :premium ? 0 : 1, specs[:cost_per_1k_tokens][:input]]
+        [specs[:performance_tier] == :premium ? 0 : 1, specs[:cost_per_token][:input]]
       end
     when :latest
       candidates.sort_by { |_, specs| -(specs[:created_at] || 0).to_i }
     when :context
       candidates.sort_by { |_, specs| -(specs[:context_length] || 0).to_i }
     else
-      candidates.sort_by { |_, specs| specs[:cost_per_1k_tokens][:input] }
+      candidates.sort_by { |_, specs| specs[:cost_per_token][:input] }
     end
   end
 end

data/lib/open_router/model_registry.rb

@@ -139,7 +139,7 @@ module OpenRouter
 
           models[model_id] = {
             name: model_data["name"],
-            cost_per_1k_tokens: {
+            cost_per_token: {
               input: model_data.dig("pricing", "prompt").to_f,
               output: model_data.dig("pricing", "completion").to_f
             },
@@ -262,12 +262,30 @@ module OpenRouter
         model_info = get_model_info(model)
         return 0 unless model_info
 
-        input_cost = (input_tokens / 1000.0) * model_info[:cost_per_1k_tokens][:input]
-        output_cost = (output_tokens / 1000.0) * model_info[:cost_per_1k_tokens][:output]
+        input_cost = input_tokens * model_info[:cost_per_token][:input]
+        output_cost = output_tokens * model_info[:cost_per_token][:output]
 
         input_cost + output_cost
       end
 
+      # Cost per 1,000 tokens — { input: Float, output: Float } or nil
+      def cost_per_thousand(model)
+        info = get_model_info(model)
+        return nil unless info
+
+        { input: info[:cost_per_token][:input] * 1_000,
+          output: info[:cost_per_token][:output] * 1_000 }
+      end
+
+      # Cost per 1,000,000 tokens — { input: Float, output: Float } or nil
+      def cost_per_million(model)
+        info = get_model_info(model)
+        return nil unless info
+
+        { input: info[:cost_per_token][:input] * 1_000_000,
+          output: info[:cost_per_token][:output] * 1_000_000 }
+      end
+
       private
 
       # Check if model specs meet the given requirements
@@ -279,11 +297,11 @@ module OpenRouter
         end
 
         # Check cost requirements
-        if requirements[:max_input_cost] && (specs[:cost_per_1k_tokens][:input] > requirements[:max_input_cost])
+        if requirements[:max_input_cost] && (specs[:cost_per_token][:input] > requirements[:max_input_cost])
           return false
         end
 
-        if requirements[:max_output_cost] && (specs[:cost_per_1k_tokens][:output] > requirements[:max_output_cost])
+        if requirements[:max_output_cost] && (specs[:cost_per_token][:output] > requirements[:max_output_cost])
           return false
         end
 
@@ -334,7 +352,7 @@ module OpenRouter
       def calculate_model_cost(specs, _requirements)
         # Simple cost calculation for sorting - could be made more sophisticated
         # For now, just use input token cost as the primary metric
-        specs[:cost_per_1k_tokens][:input]
+        specs[:cost_per_token][:input]
       end
 
       # Set up cleanup hook to manage cache size

data/lib/open_router/model_selector.rb

@@ -343,7 +343,7 @@ module OpenRouter
       all_candidates = filter_by_providers(ModelRegistry.all_models)
       return nil if all_candidates.empty?
 
-      all_candidates.min_by { |_, specs| specs[:cost_per_1k_tokens][:input] }&.first
+      all_candidates.min_by { |_, specs| specs[:cost_per_token][:input] }&.first
     end
 
     # Get detailed information about the current selection criteria
@@ -426,18 +426,18 @@ module OpenRouter
     def apply_strategy_sorting(candidates)
       case @strategy
       when :cost
-        candidates.min_by { |_, specs| specs[:cost_per_1k_tokens][:input] }
+        candidates.min_by { |_, specs| specs[:cost_per_token][:input] }
       when :performance
         # Prefer premium tier, then by cost within tier
         candidates.min_by do |_, specs|
-          [specs[:performance_tier] == :premium ? 0 : 1, specs[:cost_per_1k_tokens][:input]]
+          [specs[:performance_tier] == :premium ? 0 : 1, specs[:cost_per_token][:input]]
         end
       when :latest
         candidates.max_by { |_, specs| (specs[:created_at] || 0).to_i }
       when :context
         candidates.max_by { |_, specs| (specs[:context_length] || 0).to_i }
       else
-        candidates.min_by { |_, specs| specs[:cost_per_1k_tokens][:input] }
+        candidates.min_by { |_, specs| specs[:cost_per_token][:input] }
       end
     end
 
@@ -445,17 +445,17 @@ module OpenRouter
     def apply_strategy_sorting_all(candidates)
       case @strategy
       when :cost
-        candidates.sort_by { |_, specs| specs[:cost_per_1k_tokens][:input] }
+        candidates.sort_by { |_, specs| specs[:cost_per_token][:input] }
       when :performance
         candidates.sort_by do |_, specs|
-          [specs[:performance_tier] == :premium ? 0 : 1, specs[:cost_per_1k_tokens][:input]]
+          [specs[:performance_tier] == :premium ? 0 : 1, specs[:cost_per_token][:input]]
         end
       when :latest
         candidates.sort_by { |_, specs| -(specs[:created_at] || 0).to_i }
       when :context
         candidates.sort_by { |_, specs| -(specs[:context_length] || 0).to_i }
       else
-        candidates.sort_by { |_, specs| specs[:cost_per_1k_tokens][:input] }
+        candidates.sort_by { |_, specs| specs[:cost_per_token][:input] }
       end
     end
   end

data/lib/open_router/response.rb

@@ -110,7 +110,12 @@ module OpenRouter
           end
         end
 
-        @structured_output ||= result
+        # Use a flag rather than ||= so nil results don't trigger re-parsing on every call
+        unless @structured_output_computed
+          @structured_output = result
+          @structured_output_computed = true
+        end
+        @structured_output
       when :gentle
         # New gentle mode: best-effort parsing, no healing, no validation
         content_to_parse = @forced_extraction ? extract_json_from_text(content) : content

data/lib/open_router/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenRouter
-  VERSION = "2.0.1"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: open_router_enhanced
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Eric Stiens