lex-llm 0.1.2 → 0.1.3

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Model
+        # 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
+
+          # Create a default model with assumed capabilities
+          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], output: %w[text] },
+              metadata: { warning: 'Assuming model exists, capabilities may not be accurate' }
+            )
+          end
+
+          def initialize(data)
+            @id = data[:id]
+            @name = data[:name]
+            @provider = data[:provider]
+            @family = data[:family]
+            @created_at = Utils.to_time(data[:created_at])&.utc
+            @context_window = data[:context_window]
+            @max_output_tokens = data[:max_output_tokens]
+            @knowledge_cutoff = Utils.to_date(data[:knowledge_cutoff])
+            @modalities = Modalities.new(data[:modalities] || {})
+            @capabilities = data[:capabilities] || []
+            @pricing = Pricing.new(data[:pricing] || {})
+            @metadata = data[:metadata] || {}
+          end
+
+          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
+
+          def display_name
+            name
+          end
+
+          def label
+            provider_name = provider_class&.name || provider
+            "#{provider_name} - #{display_name}"
+          end
+
+          def max_tokens
+            max_output_tokens
+          end
+
+          def supports_vision?
+            modalities.input.include?('image')
+          end
+
+          def supports_video?
+            modalities.input.include?('video')
+          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 provider_class
+            Legion::Extensions::Llm::Provider.resolve provider
+          end
+
+          def type
+            output = modalities.output
+            return 'embedding' if output.include?('embeddings')
+            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
+
+          def to_h
+            {
+              id: id,
+              name: name,
+              provider: provider,
+              family: family,
+              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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,52 @@
+# 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

@@ -0,0 +1,50 @@
+# 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

@@ -0,0 +1,37 @@
+# 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

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