lex-llm 0.7.6 → 0.8.4

data/lib/legion/extensions/llm/model/info.rb

@@ -1,286 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Model
-        CAPABILITY_ALIASES = {
-          function_calling: :tools,
-          functions: :tools,
-          tool: :tools,
-          tool_use: :tools,
-          stream: :streaming,
-          stream_chat: :streaming
-        }.freeze
-
-        Info = ::Data.define(
-          :id, :name, :provider, :instance, :family,
-          :capabilities, :context_length, :parameter_count,
-          :parameter_size, :quantization, :size_bytes,
-          :modalities_input, :modalities_output, :metadata
-        ) do
-          # rubocop:disable Metrics/ParameterLists
-          def initialize(
-            id:, name: nil, provider: nil, instance: :default,
-            family: nil, capabilities: [], context_length: nil,
-            parameter_count: nil, parameter_size: nil, quantization: nil,
-            size_bytes: nil, modalities_input: [], modalities_output: [],
-            metadata: {}
-          )
-            normalized_family = family.nil? ? nil : family.to_s.downcase.strip
-
-            super(
-              id: id.to_s.strip,
-              name: (name || id).to_s.strip,
-              provider: provider.to_s.downcase.to_sym,
-              instance: (instance || :default).to_s.downcase.to_sym,
-              family: normalized_family,
-              capabilities: normalize_capabilities(capabilities),
-              context_length: to_int(context_length),
-              parameter_count: to_int(parameter_count),
-              parameter_size: parameter_size&.to_s&.strip,
-              quantization: quantization&.to_s&.strip,
-              size_bytes: to_int(size_bytes),
-              modalities_input: normalize_symbols(modalities_input),
-              modalities_output: normalize_symbols(modalities_output),
-              metadata: metadata.is_a?(Hash) ? metadata : {}
-            )
-          end
-          # rubocop:enable Metrics/ParameterLists
-
-          # ── Capability predicates ─────────────────────────────────────
-
-          def completion? = capabilities.include?(:completion)
-          def embedding?  = capabilities.include?(:embedding)
-          def vision?     = capabilities.include?(:vision)
-          def tools?      = capabilities.include?(:tools)
-          def thinking?   = capabilities.include?(:thinking)
-
-          # Returns true if the model supports prompt caching (Anthropic Claude 4.x, 3.5 Sonnet+).
-          # Checks the explicit `prompt_caching` capability flag in the capabilities array.
-          def supports_prompt_caching?
-            capabilities.include?(:prompt_caching)
-          end
-
-          def supports?(capability)
-            capabilities.include?(capability.to_s.downcase.to_sym)
-          end
-
-          # ── Backward-compatible accessors ─────────────────────────────
-          # These bridge the legacy Model::Info class API used by Models,
-          # OpenAICompatible, and provider gems. They read from metadata
-          # where the old fields were stored.
-
-          def context_window
-            context_length || metadata[:context_window]
-          end
-
-          def max_output_tokens
-            metadata[:max_output_tokens]
-          end
-
-          def max_tokens
-            max_output_tokens
-          end
-
-          def created_at
-            metadata[:created_at]
-          end
-
-          def knowledge_cutoff
-            metadata[:knowledge_cutoff]
-          end
-
-          def modalities
-            Modalities.new(input: modalities_input.map(&:to_s), output: modalities_output.map(&:to_s))
-          end
-
-          def pricing
-            Pricing.new(metadata[:pricing] || {})
-          end
-
-          def display_name
-            name
-          end
-
-          def label
-            "#{provider} - #{display_name}"
-          end
-
-          def input_price_per_million
-            pricing.text_tokens.input
-          end
-
-          def output_price_per_million
-            pricing.text_tokens.output
-          end
-
-          def supports_vision?
-            vision? || modalities_input.include?(:image)
-          end
-
-          def supports_video?
-            modalities_input.include?(:video)
-          end
-
-          def supports_functions?
-            tools? || capabilities.include?(:function_calling)
-          end
-
-          # Legacy capability predicates (string-based)
-          %w[function_calling structured_output batch reasoning citations streaming prompt_caching].each do |cap|
-            define_method "#{cap}?" do
-              supports?(cap)
-            end
-          end
-
-          def type
-            output = modalities_output.map(&:to_s)
-            return 'embedding' if output.include?('embeddings') || embedding?
-            return 'moderation' if output.include?('moderation')
-            return 'image' if output.include?('image')
-            return 'audio' if output.include?('audio')
-            return 'video' if output.include?('video')
-
-            'chat'
-          end
-
-          # Factory for assumed-to-exist models without full metadata.
-          def self.default(model_id, provider)
-            new(
-              id: model_id,
-              name: model_id.tr('-', ' ').capitalize,
-              provider: provider,
-              capabilities: %w[function_calling streaming vision structured_output],
-              modalities_input: %w[text image],
-              modalities_output: %w[text],
-              metadata: { warning: 'Assuming model exists, capabilities may not be accurate' }
-            )
-          end
-
-          # Factory that accepts both legacy and new-style hashes and maps
-          # them to the new struct fields. Handles round-tripping through to_h.
-          def self.from_hash(data)
-            data = data.transform_keys(&:to_sym) if data.is_a?(Hash)
-
-            input_mods, output_mods = extract_modalities(data)
-
-            new(
-              id: data[:id],
-              name: data[:name],
-              provider: data[:provider],
-              instance: data[:instance],
-              family: data[:family],
-              capabilities: data[:capabilities] || [],
-              context_length: data[:context_length] || data[:context_window],
-              parameter_count: data[:parameter_count],
-              parameter_size: data[:parameter_size],
-              quantization: data[:quantization],
-              size_bytes: data[:size_bytes],
-              modalities_input: input_mods,
-              modalities_output: output_mods,
-              metadata: build_metadata(data)
-            )
-          end
-
-          private
-
-          def normalize_capabilities(value)
-            raw = Array(value).compact.filter_map do |cap|
-              next unless cap.respond_to?(:to_s)
-
-              sym = cap.to_s.downcase.strip.tr('-', '_').to_sym
-              sym unless sym.to_s.empty?
-            end
-
-            (raw + Legion::Extensions::Llm::Capabilities.normalize(raw)).uniq.freeze
-          end
-
-          def normalize_symbols(value)
-            Array(value).compact.each_with_object([]) do |item, normalized|
-              symbol = item.to_s.downcase.strip.to_sym
-              next if symbol.to_s.empty?
-
-              normalized << symbol
-              alias_symbol = CAPABILITY_ALIASES[symbol]
-              normalized << alias_symbol if alias_symbol
-            end.uniq
-          end
-
-          def to_int(value)
-            return nil if value.nil?
-
-            value.to_i
-          end
-
-          # Class-level helpers for from_hash normalization
-          class << self
-            private
-
-            def extract_modalities(data)
-              # New-style keys take priority (round-trip from to_h)
-              return [Array(data[:modalities_input]), Array(data[:modalities_output])] if data.key?(:modalities_input) || data.key?(:modalities_output)
-
-              # Legacy: modalities is a hash or Modalities object
-              modalities_data = data[:modalities]
-              input_mods = if modalities_data.respond_to?(:input)
-                             modalities_data.input
-                           elsif modalities_data.is_a?(Hash)
-                             Array(modalities_data[:input])
-                           else
-                             []
-                           end
-              output_mods = if modalities_data.respond_to?(:output)
-                              modalities_data.output
-                            elsif modalities_data.is_a?(Hash)
-                              Array(modalities_data[:output])
-                            else
-                              []
-                            end
-              [input_mods, output_mods]
-            end
-
-            def build_metadata(data)
-              extra = {}
-              extra[:created_at] = normalize_created_at(data[:created_at]) if data.key?(:created_at)
-              if data.key?(:knowledge_cutoff)
-                extra[:knowledge_cutoff] =
-                  normalize_knowledge_cutoff(data[:knowledge_cutoff])
-              end
-              extra[:max_output_tokens] = data[:max_output_tokens] if data.key?(:max_output_tokens)
-              extra[:pricing] = normalize_pricing(data[:pricing]) if data.key?(:pricing)
-
-              base = data[:metadata] || {}
-              base.merge(extra).compact
-            end
-
-            def normalize_created_at(value)
-              return nil if value.nil?
-              return value if value.is_a?(Time)
-
-              Utils.to_time(value)&.utc
-            rescue StandardError
-              nil
-            end
-
-            def normalize_knowledge_cutoff(value)
-              return nil if value.nil?
-              return value if value.is_a?(Date)
-
-              Utils.to_date(value)
-            rescue StandardError
-              nil
-            end
-
-            def normalize_pricing(value)
-              return nil if value.nil?
-              return value.to_h if value.respond_to?(:to_h)
-
-              value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/model/modalities.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Model
-        # 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
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/model/pricing.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Model
-        # A collection that manages and provides access to different categories of pricing information
-        class Pricing
-          def initialize(data)
-            @data = {}
-
-            %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)
-            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
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/model/pricing_category.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Model
-        # Represents pricing tiers for different usage categories (standard and batch)
-        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
-
-          def input
-            standard&.input_per_million
-          end
-
-          def output
-            standard&.output_per_million
-          end
-
-          def cached_input
-            standard&.cached_input_per_million
-          end
-
-          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
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/model/pricing_tier.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Model
-        # A dynamic class for storing non-zero pricing values with flexible attribute access
-        class PricingTier
-          def initialize(data = {})
-            @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]
-            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
-    end
-  end
-end

data/lib/legion/extensions/llm/model.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      # Model-related classes for working with LLM models
-      module Model
-      end
-    end
-  end
-end