open_router_enhanced 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 925d55d16a222d6a954c449307c480ab85bf3092138b172cd8a2561f40aeeba4
-  data.tar.gz: 7f427cb96bdd2a98c355096db04babb861a8bb2a13ab3f7f940c5397a9d4f651
+  metadata.gz: 1f08650282b1232abfa779330c8f8ec9aad7bf6a984fd31e1a74ce1f3cad6962
+  data.tar.gz: e41ce6204abde21a34dd6c2976801666b8f4b9339cf81c845861f3837c15097c
 SHA512:
-  metadata.gz: c4cea4727bfa5df23b123e695cd95fe6106f6a57a5184e8b3af9f7c043e3198702ea433fc7d553220c3def45d1adc899b4e53ff4b7fa3ff4b005cf76a580c681
-  data.tar.gz: 9544496653c0716f7c704d10f7376e21e20bc4f98fe784114822640ffc957142e3fed056bcdc6d135e333010e2489910c44f7a445aa50ac3dc18eb9fe52bb4ee
+  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)
@@ -11,7 +11,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (8.1.1)
+    activesupport (8.1.3)
       base64
       bigdecimal
       concurrent-ruby (~> 1.0, >= 1.3.1)
@@ -24,11 +24,11 @@ GEM
       securerandom (>= 0.3)
       tzinfo (~> 2.0, >= 2.0.5)
       uri (>= 0.13.1)
-    addressable (2.8.8)
+    addressable (2.9.0)
       public_suffix (>= 2.0.2, < 8.0)
     ast (2.4.3)
     base64 (0.3.0)
-    bigdecimal (4.0.1)
+    bigdecimal (4.1.1)
     coderay (1.1.3)
     concurrent-ruby (1.3.6)
     connection_pool (3.0.2)
@@ -38,42 +38,47 @@ GEM
     diff-lcs (1.6.2)
     dotenv (3.2.0)
     drb (2.2.3)
-    faraday (2.14.0)
+    faraday (2.14.1)
       faraday-net_http (>= 2.0, < 3.5)
       json
       logger
-    faraday-multipart (1.1.1)
+    faraday-multipart (1.2.0)
       multipart-post (~> 2.0)
     faraday-net_http (3.4.2)
       net-http (~> 0.5)
     hashdiff (1.2.1)
     i18n (1.14.8)
       concurrent-ruby (~> 1.0)
-    json (2.18.0)
+    io-console (0.8.2)
+    json (2.19.3)
     json-schema (4.3.1)
       addressable (>= 2.8)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     logger (1.7.0)
     method_source (1.1.0)
-    minitest (6.0.0)
+    minitest (6.0.4)
+      drb (~> 2.0)
       prism (~> 1.5)
     multipart-post (2.4.1)
     net-http (0.9.1)
       uri (>= 0.11.1)
-    parallel (1.27.0)
-    parser (3.3.10.0)
+    parallel (2.0.1)
+    parser (3.3.11.1)
       ast (~> 2.4.1)
       racc
-    prism (1.7.0)
-    pry (0.15.2)
+    prism (1.9.0)
+    pry (0.16.0)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    public_suffix (7.0.0)
+      reline (>= 0.6.0)
+    public_suffix (7.0.5)
     racc (1.8.1)
     rainbow (3.1.1)
-    rake (13.3.1)
-    regexp_parser (2.11.3)
+    rake (13.4.2)
+    regexp_parser (2.12.0)
+    reline (0.6.3)
+      io-console (~> 0.5)
     rexml (3.4.4)
     rspec (3.13.2)
       rspec-core (~> 3.13.0)
@@ -84,24 +89,24 @@ GEM
     rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.7)
+    rspec-mocks (3.13.8)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-support (3.13.6)
-    rubocop (1.82.1)
+    rspec-support (3.13.7)
+    rubocop (1.86.1)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
-      parallel (~> 1.10)
+      parallel (>= 1.10)
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.48.0, < 2.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.48.0)
+    rubocop-ast (1.49.1)
       parser (>= 3.3.7.2)
-      prism (~> 1.4)
+      prism (~> 1.7)
     ruby-progressbar (1.13.0)
     securerandom (0.4.1)
     tzinfo (2.0.6)
@@ -111,7 +116,7 @@ GEM
     unicode-emoji (4.2.0)
     uri (1.1.1)
     vcr (6.4.0)
-    webmock (3.26.1)
+    webmock (3.26.2)
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.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/client.rb

@@ -12,15 +12,19 @@ module OpenRouter
   class Client
     include OpenRouter::HTTP
 
-    attr_reader :callbacks, :usage_tracker
+    attr_reader :callbacks, :usage_tracker, :configuration
 
     # Initializes the client with optional configurations.
     def initialize(access_token: nil, request_timeout: nil, uri_base: nil, extra_headers: {}, track_usage: true)
-      OpenRouter.configuration.access_token = access_token if access_token
-      OpenRouter.configuration.request_timeout = request_timeout if request_timeout
-      OpenRouter.configuration.uri_base = uri_base if uri_base
-      OpenRouter.configuration.extra_headers = extra_headers if extra_headers.any?
-      yield(OpenRouter.configuration) if block_given?
+      # Build a per-instance configuration to avoid mutating the global singleton,
+      # which would cause credential leakage across Client instances in concurrent use.
+      @configuration = OpenRouter.configuration.dup
+      @configuration.extra_headers = OpenRouter.configuration.extra_headers.dup
+      @configuration.access_token = access_token if access_token
+      @configuration.request_timeout = request_timeout if request_timeout
+      @configuration.uri_base = uri_base if uri_base
+      @configuration.extra_headers = @configuration.extra_headers.merge(extra_headers) if extra_headers.any?
+      yield(@configuration) if block_given?
 
       # Instance-level tracking of capability warnings to avoid memory leaks
       @capability_warnings_shown = Set.new
@@ -40,10 +44,6 @@ module OpenRouter
       @usage_tracker = UsageTracker.new if @track_usage
     end
 
-    def configuration
-      OpenRouter.configuration
-    end
-
     # Register a callback for a specific event
     #
     # @param event [Symbol] The event to register for (:before_request, :after_response, :on_tool_call, :on_error, :on_stream_chunk, :on_healing)
@@ -185,7 +185,7 @@ module OpenRouter
 
       parameters = { model: opts.model, input: input }
       parameters[:reasoning] = opts.reasoning if opts.reasoning
-      parameters[:tools] = serialize_tools_for_responses(opts.tools) if opts.has_tools?
+      parameters[:tools] = serialize_tools_for_responses(opts.tools) if opts.tools?
       parameters[:tool_choice] = opts.tool_choice if opts.tool_choice
       # Prefer max_completion_tokens over max_tokens (consistent with complete() method)
       parameters[:max_output_tokens] = opts.max_completion_tokens || opts.max_tokens if opts.max_completion_tokens || opts.max_tokens
@@ -503,7 +503,7 @@ module OpenRouter
     # @param parameters [Hash] Request parameters hash
     # @param opts [CompletionOptions] Options object
     def configure_tool_calling!(parameters, opts)
-      return unless opts.has_tools?
+      return unless opts.tools?
 
       warn_if_unsupported(opts.model, :function_calling, "tool calling")
       parameters[:tools] = serialize_tools(opts.tools)
@@ -516,7 +516,7 @@ module OpenRouter
     # @param opts [CompletionOptions] Options object
     # @return [Boolean] Whether forced extraction mode is being used
     def configure_structured_outputs!(parameters, opts)
-      return false unless opts.has_response_format?
+      return false unless opts.response_format?
 
       force_extraction = determine_forced_extraction_mode(opts.model, opts.force_structured_output)
 

data/lib/open_router/completion_options.rb

@@ -244,14 +244,14 @@ module OpenRouter
     # Check if this options object has any tools defined
     #
     # @return [Boolean]
-    def has_tools?
+    def tools?
       tools.is_a?(Array) && !tools.empty?
     end
 
     # Check if response format is configured
     #
     # @return [Boolean]
-    def has_response_format?
+    def response_format?
       !response_format.nil?
     end
 

data/lib/open_router/http.rb

@@ -78,30 +78,30 @@ module OpenRouter
 
     def conn(multipart: false)
       Faraday.new do |f|
-        f.options[:timeout] = OpenRouter.configuration.request_timeout
+        f.options[:timeout] = configuration.request_timeout
         f.request(:multipart) if multipart
         # NOTE: Removed MiddlewareErrors reference - was undefined and @log_errors was never set
         f.response :raise_error
         f.response :json if OpenRouter::HAS_JSON_MW
 
-        OpenRouter.configuration.faraday_config&.call(f)
+        configuration.faraday_config&.call(f)
       end
     end
 
     def uri(path:)
-      base = OpenRouter.configuration.uri_base.sub(%r{/\z}, "")
-      ver = OpenRouter.configuration.api_version.to_s.sub(%r{^/}, "").sub(%r{/\z}, "")
+      base = configuration.uri_base.sub(%r{/\z}, "")
+      ver = configuration.api_version.to_s.sub(%r{^/}, "").sub(%r{/\z}, "")
       p = path.to_s.sub(%r{^/}, "")
-      "#{base}/#{ver}/#{p}"
+      [base, ver, p].reject(&:empty?).join("/")
     end
 
     def headers
       {
-        "Authorization" => "Bearer #{OpenRouter.configuration.access_token}",
+        "Authorization" => "Bearer #{configuration.access_token}",
         "Content-Type" => "application/json",
         "X-Title" => "OpenRouter Ruby Client",
         "HTTP-Referer" => "https://github.com/OlympiaAI/open_router"
-      }.merge(OpenRouter.configuration.extra_headers)
+      }.merge(configuration.extra_headers)
     end
 
     def multipart_parameters(parameters)

data/lib/open_router/json_healer.rb

@@ -22,6 +22,11 @@ module OpenRouter
 
     # Enhanced heal method that supports different healing contexts
     def heal(raw_text, schema, context: :generic)
+      # Guard against re-entrant healing triggered by on_healing callbacks
+      raise StructuredOutputError, "Recursive healing detected — cannot heal from within a healing callback" if (Thread.current[:openrouter_heal_depth] || 0).positive?
+
+      Thread.current[:openrouter_heal_depth] = 1
+
       candidate_json = extract_json_candidate(raw_text)
       raise StructuredOutputError, "No JSON-like content found in the response." if candidate_json.nil?
 
@@ -53,6 +58,8 @@ module OpenRouter
         # Escalate to LLM-based healing with proper context
         candidate_json = fix_with_healer_model(candidate_json, schema, e.message, e.class, original_content, context)
       end
+    ensure
+      Thread.current[:openrouter_heal_depth] = 0
     end
 
     private

data/lib/open_router/model_registry.rb

@@ -15,6 +15,8 @@ module OpenRouter
     CACHE_METADATA_FILE = File.join(CACHE_DIR, "cache_metadata.json")
     MAX_CACHE_SIZE_MB = 50 # Maximum cache size in megabytes
 
+    REGISTRY_MUTEX = Mutex.new
+
     class << self
       # Fetch models from OpenRouter API using Faraday for consistent SSL handling
       def fetch_models_from_api
@@ -83,9 +85,11 @@ module OpenRouter
 
       # Clear local cache (both files and memory)
       def clear_cache!
-        FileUtils.rm_rf(CACHE_DIR) if Dir.exist?(CACHE_DIR)
-        @processed_models = nil
-        @all_models = nil
+        REGISTRY_MUTEX.synchronize do
+          FileUtils.rm_rf(CACHE_DIR) if Dir.exist?(CACHE_DIR)
+          @processed_models = nil
+          @all_models = nil
+        end
       end
 
       # Refresh models data from API
@@ -135,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
             },
@@ -246,7 +250,11 @@ module OpenRouter
 
       # Get all registered models (fetch from API if needed)
       def all_models
-        @all_models ||= fetch_and_cache_models
+        return @all_models if @all_models # fast path without lock
+
+        REGISTRY_MUTEX.synchronize do
+          @all_models ||= fetch_and_cache_models
+        end
       end
 
       # Calculate estimated cost for a request
@@ -254,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
@@ -271,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
 
@@ -326,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
@@ -355,9 +381,9 @@ module OpenRouter
         total_size = Dir.glob(File.join(CACHE_DIR, "**/*"))
                         .select { |f| File.file?(f) }
                         .sum do |f|
-                          File.size(f)
-                        rescue StandardError
-                          0
+          File.size(f)
+        rescue StandardError
+          0
         end
         total_size / (1024.0 * 1024.0)
       end

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.0"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: open_router_enhanced
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Eric Stiens
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-28 00:00:00.000000000 Z
+date: 2026-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport