ruby_llm 1.2.0 → 1.3.0rc1

data/lib/ruby_llm/model_info.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'time'
-
 module RubyLLM
   # Information about an AI model's capabilities, pricing, and metadata.
   # Used by the Models registry to help developers choose the right model
@@ -13,44 +11,227 @@ module RubyLLM
   #   model.supports_functions?       # => true
   #   model.input_price_per_million   # => 30.0
   class ModelInfo
-    attr_reader :id, :created_at, :display_name, :provider, :metadata,
-                :context_window, :max_tokens, :supports_vision, :supports_functions,
-                :supports_json_mode, :input_price_per_million, :output_price_per_million, :type, :family
+    attr_reader :id, :name, :provider, :family, :created_at, :context_window, :max_output_tokens, :knowledge_cutoff,
+                :modalities, :capabilities, :pricing, :metadata
 
-    def initialize(data) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+    def initialize(data)
       @id = data[:id]
-      @created_at = data[:created_at].is_a?(String) ? Time.parse(data[:created_at]) : data[:created_at]
-      @display_name = data[:display_name]
+      @name = data[:name]
       @provider = data[:provider]
-      @context_window = data[:context_window]
-      @max_tokens = data[:max_tokens]
-      @type = data[:type]
       @family = data[:family]
-      @supports_vision = data[:supports_vision]
-      @supports_functions = data[:supports_functions]
-      @supports_json_mode = data[:supports_json_mode]
-      @input_price_per_million = data[:input_price_per_million]
-      @output_price_per_million = data[:output_price_per_million]
+      @created_at = data[:created_at]
+      @context_window = data[:context_window]
+      @max_output_tokens = data[:max_output_tokens]
+      @knowledge_cutoff = data[:knowledge_cutoff]
+      @modalities = Modalities.new(data[:modalities] || {})
+      @capabilities = data[:capabilities] || []
+      @pricing = PricingCollection.new(data[:pricing] || {})
       @metadata = data[:metadata] || {}
     end
 
-    def to_h # rubocop:disable Metrics/MethodLength
+    # Capability methods
+    def supports?(capability)
+      capabilities.include?(capability.to_s)
+    end
+
+    %w[function_calling structured_output batch reasoning citations streaming].each do |cap|
+      define_method "#{cap}?" do
+        supports?(cap)
+      end
+    end
+
+    # Backward compatibility methods
+    def display_name
+      name
+    end
+
+    def max_tokens
+      max_output_tokens
+    end
+
+    def supports_vision?
+      modalities.input.include?('image')
+    end
+
+    def supports_functions?
+      function_calling?
+    end
+
+    def input_price_per_million
+      pricing.text_tokens.input
+    end
+
+    def output_price_per_million
+      pricing.text_tokens.output
+    end
+
+    def type # rubocop:disable Metrics/PerceivedComplexity
+      if modalities.output.include?('embeddings') && !modalities.output.include?('text')
+        'embedding'
+      elsif modalities.output.include?('image') && !modalities.output.include?('text')
+        'image'
+      elsif modalities.output.include?('audio') && !modalities.output.include?('text')
+        'audio'
+      elsif modalities.output.include?('moderation')
+        'moderation'
+      else
+        'chat'
+      end
+    end
+
+    def to_h
       {
         id: id,
-        created_at: created_at&.iso8601,
-        display_name: display_name,
+        name: name,
         provider: provider,
-        context_window: context_window,
-        max_tokens: max_tokens,
-        type: type,
         family: family,
-        supports_vision: supports_vision,
-        supports_functions: supports_functions,
-        supports_json_mode: supports_json_mode,
-        input_price_per_million: input_price_per_million,
-        output_price_per_million: output_price_per_million,
+        created_at: created_at,
+        context_window: context_window,
+        max_output_tokens: max_output_tokens,
+        knowledge_cutoff: knowledge_cutoff,
+        modalities: modalities.to_h,
+        capabilities: capabilities,
+        pricing: pricing.to_h,
         metadata: metadata
       }
     end
   end
+
+  # Holds and manages input and output modalities for a language model
+  class Modalities
+    attr_reader :input, :output
+
+    def initialize(data)
+      @input = Array(data[:input]).map(&:to_s)
+      @output = Array(data[:output]).map(&:to_s)
+    end
+
+    def to_h
+      {
+        input: input,
+        output: output
+      }
+    end
+  end
+
+  # A collection that manages and provides access to different categories of pricing information
+  # (text tokens, images, audio tokens, embeddings)
+  class PricingCollection
+    def initialize(data)
+      @data = {}
+
+      # Initialize pricing categories
+      %i[text_tokens images audio_tokens embeddings].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
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      %i[text_tokens images audio_tokens embeddings].include?(method.to_sym) || super
+    end
+
+    def to_h
+      @data.transform_values(&:to_h)
+    end
+
+    private
+
+    def empty_pricing?(data)
+      # Check if all pricing values in this category are zero or nil
+      return true unless data
+
+      %i[standard batch].each do |tier|
+        next unless data[tier]
+
+        data[tier].each_value do |value|
+          return false if value && value != 0.0
+        end
+      end
+
+      true
+    end
+  end
+
+  # Represents pricing tiers for different usage categories (standard and batch), managing access to their respective
+  # rates
+  class PricingCategory
+    attr_reader :standard, :batch
+
+    def initialize(data = {})
+      @standard = PricingTier.new(data[:standard] || {}) unless empty_tier?(data[:standard])
+      @batch = PricingTier.new(data[:batch] || {}) unless empty_tier?(data[:batch])
+    end
+
+    # Shorthand methods that default to standard tier
+    def input
+      standard&.input_per_million
+    end
+
+    def output
+      standard&.output_per_million
+    end
+
+    def cached_input
+      standard&.cached_input_per_million
+    end
+
+    # Get value for a specific tier
+    def [](key)
+      key == :batch ? batch : standard
+    end
+
+    def to_h
+      result = {}
+      result[:standard] = standard.to_h if standard
+      result[:batch] = batch.to_h if batch
+      result
+    end
+
+    private
+
+    def empty_tier?(tier_data)
+      return true unless tier_data
+
+      tier_data.values.all? { |v| v.nil? || v == 0.0 }
+    end
+  end
+
+  # A dynamic class for storing non-zero pricing values with flexible attribute access
+  class PricingTier
+    def initialize(data = {})
+      @values = {}
+
+      # Only store non-zero values
+      data.each do |key, value|
+        @values[key.to_sym] = value if value && value != 0.0
+      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]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      method.to_s.end_with?('=') || @values.key?(method.to_sym) || super
+    end
+
+    def to_h
+      @values
+    end
+  end
 end