lex-llm 0.7.3 → 0.8.0

data/lib/legion/extensions/llm/routing/model_offering.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Routing
-        # DEPRECATED (Phase 4 removal): kept unchanged for released consumers.
-        # New providers publish Inventory::OfferingDraft; the new registry accepts
-        # no default generated offering_id from this class.
-        # Describes one concrete model made available by one provider instance.
-        class ModelOffering
-          CAPABILITY_ALIASES = {
-            function_calling: :tools,
-            functions: :tools,
-            tool: :tools,
-            tool_use: :tools,
-            stream: :streaming,
-            stream_chat: :streaming
-          }.freeze
-
-          attr_reader :offering_id, :provider_family, :model_family, :provider_instance, :instance_id, :transport,
-                      :tier, :model, :canonical_model_alias, :routing_metadata, :usage_type, :capabilities,
-                      :capability_sources, :limits, :credentials, :health, :cost, :policy_tags, :metadata
-
-          def initialize(data)
-            @metadata = normalize_hash(fetch_value(data, :metadata))
-            @provider_family = normalize_symbol(fetch_value(data, :provider_family, fetch_value(data, :provider)))
-            @model_family = normalize_symbol(fetch_value(data, :model_family, @metadata[:model_family]))
-            @provider_instance = normalize_symbol(fetch_value(data, :provider_instance,
-                                                              fetch_value(data, :instance_id, @provider_family)))
-            @instance_id = @provider_instance
-            @transport = normalize_symbol(fetch_value(data, :transport, :http))
-            @tier = normalize_symbol(fetch_value(data, :tier, default_tier))
-            @model = fetch_value(data, :model).to_s
-            @canonical_model_alias = normalize_model_alias(fetch_value(data, :canonical_model_alias,
-                                                                       metadata_canonical_model_alias))
-            @routing_metadata = normalize_hash(fetch_value(data, :routing_metadata))
-            @usage_type = normalize_usage_type(fetch_value(data, :usage_type,
-                                                           fetch_value(data, :type) ||
-                                                           fetch_value(data, :kind) ||
-                                                           infer_usage_type(data)))
-            @capabilities = normalize_capabilities(fetch_value(data, :capabilities))
-            @capability_sources = normalize_capability_sources(fetch_value(data, :capability_sources))
-            @limits = normalize_hash(fetch_value(data, :limits))
-            @credentials = fetch_value(data, :credentials)
-            @health = normalize_hash(fetch_value(data, :health))
-            @cost = normalize_hash(fetch_value(data, :cost))
-            @policy_tags = normalize_array(fetch_value(data, :policy_tags)).map(&:to_sym)
-            @offering_id = normalize_offering_id(fetch_value(data, :offering_id, default_offering_id))
-          end
-
-          def enabled?
-            !metadata.key?(:enabled) || metadata[:enabled] != false
-          end
-
-          def embedding?
-            usage_type == :embedding
-          end
-
-          def inference?
-            %i[chat inference completion].include?(usage_type)
-          end
-
-          def context_window
-            integer_limit(:context_window) || integer_limit(:max_input_tokens)
-          end
-
-          def max_output_tokens
-            integer_limit(:max_output_tokens)
-          end
-
-          def supports?(capability)
-            normalize_capabilities([capability]).any? { |candidate| capabilities.include?(candidate) }
-          end
-
-          def eligible_for?(usage_type: nil, required_capabilities: [], min_context_window: nil, policy_tags: [])
-            return false unless enabled?
-            return false unless usage_type_matches?(usage_type)
-            return false unless capabilities_match?(required_capabilities)
-            return false unless context_window_matches?(min_context_window)
-            return false unless policy_tags_match?(policy_tags)
-
-            true
-          end
-
-          def lane_key(prefix: 'llm.fleet', include_context: true, include_fingerprint: false)
-            LaneKey.for(self, prefix:, include_context:, include_fingerprint:)
-          end
-
-          def eligibility_fingerprint
-            LaneKey.eligibility_fingerprint(self)
-          end
-
-          def model_alias?(alias_name)
-            normalized = normalize_model_alias(alias_name)
-            [canonical_model_alias, model].compact.any? { |candidate| normalize_model_alias(candidate) == normalized }
-          end
-
-          def to_h
-            {
-              offering_id: offering_id,
-              provider_family: provider_family,
-              model_family: model_family,
-              provider_instance: provider_instance,
-              instance_id: instance_id,
-              transport: transport,
-              tier: tier,
-              model: model,
-              canonical_model_alias: canonical_model_alias,
-              routing_metadata: routing_metadata,
-              usage_type: usage_type,
-              capabilities: capabilities,
-              capability_sources: capability_sources,
-              limits: limits,
-              credentials: credentials,
-              health: health,
-              cost: cost,
-              policy_tags: policy_tags,
-              metadata: metadata
-            }
-          end
-
-          private
-
-          def default_tier
-            case @transport
-            when :local
-              :local
-            when :rabbitmq
-              :fleet
-            else
-              :private
-            end
-          end
-
-          def infer_usage_type(data)
-            capabilities = normalize_capabilities(fetch_value(data, :capabilities))
-            return :embedding if capabilities.include?(:embedding) || capabilities.include?(:embed)
-
-            :inference
-          end
-
-          def normalize_usage_type(value)
-            case value.to_sym
-            when :embed, :embeddings
-              :embedding
-            when :completion, :text, :chat
-              :inference
-            else
-              value.to_sym
-            end
-          end
-
-          def normalize_symbol(value)
-            return nil if value.nil?
-
-            value.to_sym
-          end
-
-          def normalize_array(value)
-            Array(value).compact.map(&:to_sym)
-          end
-
-          def normalize_capabilities(value)
-            Legion::Extensions::Llm::Capabilities.normalize(value)
-          end
-
-          def normalize_capability_sources(value)
-            normalize_hash(value).to_h do |capability, source_data|
-              normalized_source = normalize_hash(source_data)
-              [
-                Legion::Extensions::Llm::Capabilities.canonical(capability),
-                { value: normalized_source[:value], source: normalized_source[:source]&.to_sym }.compact
-              ]
-            end
-          end
-
-          def normalize_hash(value)
-            (value || {}).to_h.transform_keys(&:to_sym)
-          end
-
-          def fetch_value(hash, key, default = nil)
-            return default unless hash.respond_to?(:key?)
-
-            string_key = key.to_s
-            return hash[string_key] if hash.key?(string_key)
-
-            hash.key?(key) ? hash[key] : default
-          end
-
-          def usage_type_matches?(expected)
-            expected.nil? || normalize_usage_type(expected) == usage_type
-          end
-
-          def capabilities_match?(required)
-            normalize_capabilities(required).all? { |capability| capabilities.include?(capability) }
-          end
-
-          def context_window_matches?(minimum)
-            minimum.nil? || (!!context_window && context_window >= minimum.to_i)
-          end
-
-          def policy_tags_match?(required)
-            Array(required).all? { |tag| policy_tags.include?(tag.to_sym) }
-          end
-
-          def integer_limit(key)
-            value = limits[key]
-            return nil if value.nil?
-
-            Integer(value)
-          rescue ArgumentError, TypeError
-            nil
-          end
-
-          def metadata_canonical_model_alias
-            metadata[:canonical_model_alias] || metadata[:alias] ||
-              Legion::Extensions::Llm::Aliases.canonical_model_alias(@model, @provider_family)
-          end
-
-          def normalize_model_alias(value)
-            Legion::Extensions::Llm::Aliases.normalize_model_alias(value)
-          end
-
-          def normalize_offering_id(value)
-            value.to_s.strip
-          end
-
-          def default_offering_id
-            [
-              provider_family,
-              provider_instance,
-              usage_type,
-              canonical_model_alias || model
-            ].compact.map { |part| LaneKey.model_slug(part) }.join(':')
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/routing/offering_registry.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Routing
-        # DEPRECATED (Phase 4 removal): the old mutable registry, kept only for
-        # old callers. It is never returned by Inventory::Registry.snapshot.
-        # In-memory index of provider-neutral model offerings.
-        class OfferingRegistry
-          include Enumerable
-
-          def initialize(offerings = [])
-            @offerings = []
-            Array(offerings).each { |offering| register(offering) }
-          end
-
-          def register(offering)
-            normalized = normalize_offering(offering)
-            @offerings.reject! { |existing| existing.offering_id == normalized.offering_id }
-            @offerings << normalized
-            normalized
-          end
-
-          def each(&)
-            @offerings.each(&)
-          end
-
-          def all
-            @offerings.dup
-          end
-          alias list all
-
-          def find(offering_id)
-            @offerings.find { |offering| offering.offering_id == offering_id.to_s }
-          end
-
-          def find_by_model_alias(alias_name)
-            @offerings.find { |offering| offering.model_alias?(alias_name) }
-          end
-
-          def filter(**criteria)
-            @offerings.select do |offering|
-              matches_symbol?(offering.provider_family, criteria[:provider_family]) &&
-                matches_symbol?(offering.model_family, criteria[:model_family]) &&
-                matches_symbol?(offering.provider_instance, criteria[:provider_instance]) &&
-                matches_capability?(offering, criteria[:capability]) &&
-                matches_model_alias?(offering, criteria[:model_alias]) &&
-                matches_model?(offering, criteria[:model]) &&
-                matches_usage_type?(offering, criteria[:usage_type])
-            end
-          end
-
-          def by_provider_family(provider_family)
-            filter(provider_family:)
-          end
-
-          def by_model_family(model_family)
-            filter(model_family:)
-          end
-
-          def by_provider_instance(provider_instance)
-            filter(provider_instance:)
-          end
-
-          def by_capability(capability)
-            filter(capability:)
-          end
-
-          private
-
-          def normalize_offering(offering)
-            return offering if offering.is_a?(ModelOffering)
-
-            ModelOffering.new(offering)
-          end
-
-          def matches_symbol?(actual, expected)
-            expected.nil? || actual == expected.to_sym
-          end
-
-          def matches_capability?(offering, capability)
-            capability.nil? || offering.supports?(capability)
-          end
-
-          def matches_model_alias?(offering, model_alias)
-            model_alias.nil? || offering.model_alias?(model_alias)
-          end
-
-          def matches_model?(offering, model)
-            model.nil? || offering.model == model.to_s
-          end
-
-          def matches_usage_type?(offering, usage_type)
-            usage_type.nil? || offering.usage_type == usage_type.to_sym
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/routing/registry_event.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Routing
-        # Serializable provider-neutral envelope for future llm.registry publishing.
-        class RegistryEvent
-          EVENT_TYPES = %i[
-            offering_available
-            offering_unavailable
-            offering_degraded
-            offering_heartbeat
-          ].freeze
-          SENSITIVE_KEYS = %i[
-            access_key
-            api_key
-            authorization
-            bearer
-            client_secret
-            credential
-            credentials
-            endpoint
-            endpoint_url
-            password
-            path
-            private_key
-            prompt
-            reply_to
-            secret
-            secrets
-            token
-            url
-          ].freeze
-
-          attr_reader :event_id, :event_type, :occurred_at, :offering, :runtime, :capacity, :health, :lane, :metadata
-
-          class << self
-            def available(offering, **attributes)
-              new(event_type: :offering_available, offering:, **attributes)
-            end
-
-            def unavailable(offering, **attributes)
-              new(event_type: :offering_unavailable, offering:, **attributes)
-            end
-
-            def degraded(offering, **attributes)
-              new(event_type: :offering_degraded, offering:, **attributes)
-            end
-
-            def heartbeat(offering, **attributes)
-              new(event_type: :offering_heartbeat, offering:, **attributes)
-            end
-          end
-
-          def initialize(event_type:, offering:, **attributes)
-            @event_id = normalize_event_id(attributes.fetch(:event_id, SecureRandom.uuid))
-            @event_type = normalize_event_type(event_type)
-            @occurred_at = normalize_time(attributes.fetch(:occurred_at, Time.now.utc))
-            @offering = normalize_offering(offering)
-            @runtime = sanitize_optional_hash(attributes[:runtime], :runtime)
-            @capacity = sanitize_optional_hash(attributes[:capacity], :capacity)
-            @health = sanitize_optional_hash(attributes[:health], :health)
-            @lane = sanitize_optional_value(attributes[:lane], :lane)
-            @metadata = sanitize_optional_hash(attributes[:metadata], :metadata)
-          end
-
-          def to_h
-            {
-              event_id: event_id,
-              event_type: event_type,
-              occurred_at: occurred_at.utc.iso8601(6),
-              offering: sanitized_offering_hash,
-              runtime: runtime,
-              capacity: capacity,
-              health: health,
-              lane: lane,
-              metadata: metadata
-            }.compact
-          end
-
-          private
-
-          def normalize_event_id(value)
-            normalized = value.to_s.strip
-            raise ArgumentError, 'event_id is required' if normalized.empty?
-
-            normalized
-          end
-
-          def normalize_event_type(value)
-            normalized = value.to_sym
-            raise ArgumentError, "unsupported registry event type: #{value}" unless EVENT_TYPES.include?(normalized)
-
-            normalized
-          end
-
-          def normalize_time(value)
-            return value.utc if value.respond_to?(:utc)
-
-            Time.parse(value.to_s).utc
-          end
-
-          def normalize_offering(value)
-            return value if value.is_a?(ModelOffering)
-
-            ModelOffering.new(value)
-          end
-
-          def sanitized_offering_hash
-            sanitize_hash(offering.to_h, on_sensitive: :drop)
-          end
-
-          def sanitize_optional_hash(value, label)
-            return nil if value.nil?
-
-            sanitize_hash(value.to_h, label:)
-          end
-
-          def sanitize_optional_value(value, label)
-            return nil if value.nil?
-            return sanitize_hash(value.to_h, label:) if value.respond_to?(:to_h)
-            return value unless value.is_a?(Array)
-
-            sanitize_array(value, label:, path: [])
-          end
-
-          def sanitize_hash(hash, label: nil, path: [], on_sensitive: :raise)
-            hash.each_with_object({}) do |(key, value), sanitized|
-              normalized_key = key.to_sym
-              key_path = path + [normalized_key]
-              if sensitive_key?(normalized_key)
-                raise_sensitive_key!(label, key_path) if on_sensitive == :raise
-
-                next
-              end
-
-              sanitized[normalized_key] = sanitize_value(value, label:, path: key_path, on_sensitive:)
-            end
-          end
-
-          def sanitize_array(array, label:, path:, on_sensitive: :raise)
-            array.map { |value| sanitize_value(value, label:, path:, on_sensitive:) }
-          end
-
-          def sanitize_value(value, label:, path:, on_sensitive:)
-            return sanitize_hash(value, label:, path:, on_sensitive:) if value.is_a?(Hash)
-            return sanitize_array(value, label:, path:, on_sensitive:) if value.is_a?(Array)
-
-            value
-          end
-
-          def sensitive_key?(key)
-            normalized = key.to_s.downcase.gsub(/[^a-z0-9]+/, '_').to_sym
-            SENSITIVE_KEYS.include?(normalized) ||
-              normalized.to_s.end_with?('_key', '_secret', '_token', '_password')
-          end
-
-          def raise_sensitive_key!(label, path)
-            prefix = label ? "#{label} contains" : 'registry event contains'
-            raise ArgumentError, "#{prefix} sensitive key: #{path.join('.')}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      # Represents provider thinking output.
-      class Thinking
-        attr_reader :text, :signature
-
-        def initialize(text: nil, signature: nil)
-          @text = text
-          @signature = signature
-        end
-
-        def self.build(text: nil, signature: nil)
-          text = nil if text.is_a?(String) && text.empty?
-          signature = nil if signature.is_a?(String) && signature.empty?
-
-          return nil if text.nil? && signature.nil?
-
-          new(text: text, signature: signature)
-        end
-
-        def pretty_print(printer)
-          printer.object_group(self) do
-            printer.breakable
-            printer.text 'text='
-            printer.pp text
-            printer.comma_breakable
-            printer.text 'signature='
-            printer.pp(signature ? '[REDACTED]' : nil)
-          end
-        end
-      end
-
-      class Thinking
-        # Normalized config for thinking across providers.
-        class Config
-          attr_reader :effort, :budget
-
-          def initialize(effort: nil, budget: nil)
-            @effort = effort.is_a?(Symbol) ? effort.to_s : effort
-            @budget = budget
-          end
-
-          def enabled?
-            !effort.nil? || !budget.nil?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      # Represents token usage for a response.
-      class Tokens
-        attr_reader :input, :output, :cached, :cache_creation, :thinking
-
-        # rubocop:disable Metrics/ParameterLists
-        def initialize(input: nil, output: nil, cached: nil, cache_creation: nil, thinking: nil, reasoning: nil)
-          @input = input
-          @output = output
-          @cached = cached
-          @cache_creation = cache_creation
-          @thinking = thinking || reasoning
-        end
-        # rubocop:enable Metrics/ParameterLists
-
-        # rubocop:disable Metrics/ParameterLists
-        def self.build(input: nil, output: nil, cached: nil, cache_creation: nil, thinking: nil, reasoning: nil)
-          return nil if [input, output, cached, cache_creation, thinking, reasoning].all?(&:nil?)
-
-          new(
-            input: input,
-            output: output,
-            cached: cached,
-            cache_creation: cache_creation,
-            thinking: thinking,
-            reasoning: reasoning
-          )
-        end
-        # rubocop:enable Metrics/ParameterLists
-
-        def to_h
-          {
-            input_tokens: input,
-            output_tokens: output,
-            cached_tokens: cached,
-            cache_creation_tokens: cache_creation,
-            thinking_tokens: thinking
-          }.compact
-        end
-
-        def reasoning
-          thinking
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      # Represents a function call from an AI model to a Tool.
-      class ToolCall
-        attr_reader :id, :name, :arguments, :index
-        attr_accessor :thought_signature
-
-        # index carries the provider's authoritative wire position
-        # (delta.tool_calls[N].index) so the StreamAccumulator can correlate
-        # interleaved argument fragments to the right parallel call by index
-        # rather than by recency. nil for non-streaming/single-call paths.
-        def initialize(id:, name:, arguments: {}, thought_signature: nil, index: nil)
-          @id = id
-          @name = name
-          @arguments = arguments
-          @thought_signature = thought_signature
-          @index = index
-        end
-
-        def to_h
-          {
-            id: @id,
-            name: @name,
-            arguments: @arguments,
-            thought_signature: @thought_signature
-          }.compact
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      # Represents a transcription of audio content.
-      class Transcription
-        attr_reader :text, :model, :language, :duration, :segments, :input_tokens, :output_tokens
-
-        def initialize(text:, model:, **attributes)
-          @text = text
-          @model = model
-          @language = attributes[:language]
-          @duration = attributes[:duration]
-          @segments = attributes[:segments]
-          @input_tokens = attributes[:input_tokens]
-          @output_tokens = attributes[:output_tokens]
-        end
-
-        def self.transcribe(audio_file, **kwargs)
-          model = kwargs.delete(:model)
-          language = kwargs.delete(:language)
-          provider = kwargs.delete(:provider)
-          assume_model_exists = kwargs.delete(:assume_model_exists) { false }
-          context = kwargs.delete(:context)
-          options = kwargs
-
-          config = context&.config || Legion::Extensions::Llm.config
-          model ||= config.default_transcription_model
-          model, provider_instance = Models.resolve(model, provider: provider, assume_exists: assume_model_exists,
-                                                           config: config)
-          model_id = model.id
-
-          provider_instance.transcribe(audio_file, model: model_id, language:, **options)
-        end
-      end
-    end
-  end
-end