ruby_llm 1.14.1 → 1.16.0

data/lib/ruby_llm/model/info.rb

@@ -5,7 +5,7 @@ module RubyLLM
     # Information about an AI model's capabilities, pricing, and metadata.
     class Info
       attr_reader :id, :name, :provider, :family, :created_at, :context_window, :max_output_tokens, :knowledge_cutoff,
-                  :modalities, :capabilities, :pricing, :metadata
+                  :modalities, :capabilities, :pricing, :metadata, :reasoning_options
 
       # Create a default model with assumed capabilities
       def self.default(model_id, provider)
@@ -31,7 +31,9 @@ module RubyLLM
         @modalities = Modalities.new(data[:modalities] || {})
         @capabilities = data[:capabilities] || []
         @pricing = Pricing.new(data[:pricing] || {})
-        @metadata = data[:metadata] || {}
+        @metadata = data[:metadata]&.dup || {}
+        @reasoning_options = normalize_reasoning_options(reasoning_options_from(data))
+        store_reasoning_options_metadata
       end
 
       def supports?(capability)
@@ -61,6 +63,14 @@ module RubyLLM
         modalities.input.include?('image')
       end
 
+      def reasoning_option(type)
+        reasoning_options.find { |option| option[:type] == type.to_s }
+      end
+
+      def reasoning_option_values(type)
+        Array(reasoning_option(type)&.fetch(:values, nil))
+      end
+
       def supports_video?
         modalities.input.include?('video')
       end
@@ -77,6 +87,23 @@ module RubyLLM
         pricing.text_tokens.output
       end
 
+      def cache_read_input_price_per_million
+        pricing.text_tokens.cache_read_input
+      end
+
+      def cache_write_input_price_per_million
+        pricing.text_tokens.cache_write_input
+      end
+
+      alias cached_input_price_per_million cache_read_input_price_per_million
+      alias cache_creation_input_price_per_million cache_write_input_price_per_million
+
+      def cost_for(tokens)
+        tokens = tokens.tokens if tokens.respond_to?(:tokens)
+
+        Cost.new(tokens:, model: self)
+      end
+
       def provider_class
         RubyLLM::Provider.resolve provider
       end
@@ -108,6 +135,30 @@ module RubyLLM
           metadata: metadata
         }
       end
+
+      private
+
+      def reasoning_options_from(data)
+        data[:reasoning_options] || metadata[:reasoning_options] || metadata['reasoning_options']
+      end
+
+      def store_reasoning_options_metadata
+        return unless reasoning_options.any?
+
+        metadata.delete('reasoning_options')
+        metadata[:reasoning_options] = reasoning_options
+      end
+
+      def normalize_reasoning_options(options)
+        Array(options).filter_map do |option|
+          next unless option.is_a?(Hash)
+
+          normalized = option.to_h.transform_keys(&:to_sym)
+          normalized[:type] = normalized[:type].to_s if normalized[:type]
+          normalized[:values] = Array(normalized[:values]).map(&:to_s) if normalized.key?(:values)
+          normalized
+        end
+      end
     end
   end
 end

data/lib/ruby_llm/model/pricing.rb

@@ -4,24 +4,30 @@ module RubyLLM
   module Model
     # A collection that manages and provides access to different categories of pricing information
     class Pricing
+      CATEGORIES = %i[text_tokens images audio_tokens embeddings].freeze
+
       def initialize(data)
         @data = {}
 
-        %i[text_tokens images audio_tokens embeddings].each do |category|
+        CATEGORIES.each do |category|
           @data[category] = PricingCategory.new(data[category]) if data[category] && !empty_pricing?(data[category])
         end
       end
 
-      def method_missing(method, *args)
-        if respond_to_missing?(method)
-          @data[method.to_sym] || PricingCategory.new
-        else
-          super
-        end
+      def text_tokens
+        category(:text_tokens)
+      end
+
+      def images
+        category(:images)
       end
 
-      def respond_to_missing?(method, include_private = false)
-        %i[text_tokens images audio_tokens embeddings].include?(method.to_sym) || super
+      def audio_tokens
+        category(:audio_tokens)
+      end
+
+      def embeddings
+        category(:embeddings)
       end
 
       def to_h
@@ -30,6 +36,10 @@ module RubyLLM
 
       private
 
+      def category(name)
+        @data[name] || PricingCategory.new
+      end
+
       def empty_pricing?(data)
         return true unless data
 

data/lib/ruby_llm/model/pricing_category.rb

@@ -19,10 +19,21 @@ module RubyLLM
         standard&.output_per_million
       end
 
-      def cached_input
-        standard&.cached_input_per_million
+      def cache_read_input
+        standard&.cache_read_input_per_million || standard&.cached_input_per_million
       end
 
+      def cache_write_input
+        standard&.cache_write_input_per_million || standard&.cache_creation_input_per_million
+      end
+
+      def reasoning_output
+        standard&.reasoning_output_per_million
+      end
+
+      alias cached_input cache_read_input
+      alias cache_creation_input cache_write_input
+
       def [](key)
         key == :batch ? batch : standard
       end

data/lib/ruby_llm/model/pricing_tier.rb

@@ -2,8 +2,18 @@
 
 module RubyLLM
   module Model
-    # A dynamic class for storing non-zero pricing values with flexible attribute access
+    # Stores non-zero pricing values for a single pricing tier.
     class PricingTier
+      ATTRIBUTES = %i[
+        input_per_million
+        output_per_million
+        cache_read_input_per_million
+        cache_write_input_per_million
+        cached_input_per_million
+        cache_creation_input_per_million
+        reasoning_output_per_million
+      ].freeze
+
       def initialize(data = {})
         @values = {}
 
@@ -12,17 +22,18 @@ module RubyLLM
         end
       end
 
-      def method_missing(method, *args)
-        if method.to_s.end_with?('=')
-          key = method.to_s.chomp('=').to_sym
-          @values[key] = args.first if args.first && args.first != 0.0
-        elsif @values.key?(method)
-          @values[method]
+      ATTRIBUTES.each do |attribute|
+        define_method(attribute) do
+          @values[attribute]
+        end
+
+        define_method("#{attribute}=") do |value|
+          @values[attribute] = value if value && value != 0.0
         end
       end
 
-      def respond_to_missing?(method, include_private = false)
-        method.to_s.end_with?('=') || @values.key?(method.to_sym) || super
+      def [](key)
+        @values[key.to_sym]
       end
 
       def to_h

data/lib/ruby_llm/model_registry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Sources for model registry data.
+  module ModelRegistry
+    # Reads model registry data from the configured JSON file.
+    class JsonSource
+      def initialize(file = nil)
+        @file = file
+      end
+
+      def read
+        Models.read_from_json(@file || RubyLLM.config.model_registry_file)
+      end
+    end
+
+    # Reads model registry data from the configured Active Record model class.
+    class ActiveRecordSource
+      def read
+        model_class = resolve_model_class
+        return [] unless model_class.respond_to?(:table_exists?) && model_class.table_exists?
+
+        model_class.all.map(&:to_llm)
+      rescue StandardError => e
+        RubyLLM.logger.debug { "Failed to load models from database: #{e.message}, falling back to JSON" }
+        []
+      end
+
+      private
+
+      def resolve_model_class
+        model_class = RubyLLM.config.model_registry_class
+        return model_class unless model_class.is_a?(String)
+
+        model_class.split('::').inject(Object) { |scope, name| scope.const_get(name) }
+      end
+    end
+  end
+end