lex-llm 0.7.6 → 0.8.4

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      # Identify potentially harmful content in text.
-      # https://platform.openai.com/docs/guides/moderation
-      class Moderation
-        attr_reader :id, :model, :results
-
-        def initialize(id:, model:, results:)
-          @id = id
-          @model = model
-          @results = results
-        end
-
-        def self.moderate(input,
-                          model: nil,
-                          provider: nil,
-                          assume_model_exists: false,
-                          context: nil)
-          config = context&.config || Legion::Extensions::Llm.config
-          model ||= config.default_moderation_model
-          model, provider_instance = Models.resolve(model, provider: provider, assume_exists: assume_model_exists,
-                                                           config: config)
-          model_id = model.id
-
-          provider_instance.moderate(input, model: model_id)
-        end
-
-        # Convenience method to get content from moderation result
-        def content
-          results
-        end
-
-        # Check if any content was flagged
-        def flagged?
-          results.any? { |result| result['flagged'] }
-        end
-
-        # Get all flagged categories across all results
-        def flagged_categories
-          results.flat_map do |result|
-            result['categories']&.select { |_category, flagged| flagged }&.keys || []
-          end.uniq
-        end
-
-        # Get category scores for the first result (most common case)
-        def category_scores
-          results.first&.dig('category_scores') || {}
-        end
-
-        # Get categories for the first result (most common case)
-        def categories
-          results.first&.dig('categories') || {}
-        end
-      end
-    end
-  end
-end

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

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      # Builds sanitized lex-llm registry envelopes for provider state.
-      # Parameterized by `provider_family` so each lex-llm-* gem can reuse this
-      # class without defining its own copy.
-      class RegistryEventBuilder
-        include Legion::Logging::Helper
-
-        attr_reader :provider_family
-
-        def initialize(provider_family:)
-          @provider_family = provider_family.to_s.downcase.to_sym
-        end
-
-        def readiness(readiness)
-          registry_event_class.public_send(
-            readiness[:ready] ? :available : :unavailable,
-            provider_offering(readiness),
-            runtime: runtime_metadata,
-            health: readiness_health(readiness),
-            metadata: readiness_metadata(readiness)
-          )
-        end
-
-        def model_available(model, readiness:)
-          registry_event_class.available(
-            model_offering(model),
-            runtime: runtime_metadata,
-            health: model_health(readiness),
-            metadata: model_metadata(model)
-          )
-        end
-
-        private
-
-        def provider_offering(readiness)
-          {
-            provider_family: provider_family,
-            provider_instance: provider_instance,
-            transport: :http,
-            model: 'provider-readiness',
-            usage_type: :inference,
-            capabilities: [],
-            health: readiness_health(readiness),
-            metadata: { lex: extension_sym, provider_readiness: true }
-          }
-        end
-
-        def model_offering(model)
-          {
-            provider_family: provider_family,
-            provider_instance: provider_instance,
-            transport: :http,
-            model: model.id,
-            usage_type: usage_type_for(model),
-            capabilities: Array(model.capabilities).map(&:to_sym),
-            limits: model_limits(model),
-            metadata: { lex: extension_sym, model_name: model.name }.compact
-          }
-        end
-
-        def readiness_health(readiness)
-          source = readiness[:health]
-          health = {
-            ready: readiness[:ready] == true,
-            status: readiness[:ready] ? :available : :unavailable,
-            checked: !source.is_a?(Hash) || source[:checked] != false
-          }
-          add_readiness_error(health, source)
-        end
-
-        def add_readiness_error(health, source)
-          error = source.is_a?(Hash) ? source : {}
-          error_class = error[:error] || error['error']
-          error_message = error[:message] || error['message']
-          health[:error_class] = error_class if error_class
-          health[:error] = error_message if error_message
-          health
-        end
-
-        def model_health(readiness)
-          ready = readiness.fetch(:ready, true) == true
-          { ready:, status: ready ? :available : :degraded }
-        end
-
-        def readiness_metadata(readiness)
-          {
-            extension: extension_sym,
-            provider: provider_family,
-            configured: readiness[:configured] == true,
-            live: readiness[:live] == true
-          }
-        end
-
-        def model_metadata(model)
-          { extension: extension_sym, provider: provider_family, model_type: model_type_for(model) }
-        end
-
-        def runtime_metadata
-          { node: provider_instance }
-        end
-
-        def model_limits(model)
-          limits = {}
-          limits[:context_window] = model.context_window if model.respond_to?(:context_window)
-          limits[:max_output_tokens] = model.max_output_tokens if model.respond_to?(:max_output_tokens)
-          limits.compact
-        end
-
-        def usage_type_for(model)
-          model_type_for(model) == 'embedding' ? :embedding : :inference
-        end
-
-        def model_type_for(model)
-          model.respond_to?(:type) ? model.type : 'chat'
-        end
-
-        def extension_sym
-          :"llm_#{provider_family}"
-        end
-
-        def provider_instance
-          configured_node = (::Legion::Settings.dig(:node, :canonical_name) if defined?(::Legion::Settings))
-          value = configured_node.to_s.strip
-          value.empty? ? provider_family : value.to_sym
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true,
-                              operation: "#{provider_family}.registry.provider_instance")
-          provider_family
-        end
-
-        def registry_event_class
-          ::Legion::Extensions::Llm::Routing::RegistryEvent
-        end
-      end
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'concurrent'
-
-module Legion
-  module Extensions
-    module Llm
-      # Best-effort publisher for LLM provider availability events.
-      # Parameterized by `provider_family` so each lex-llm-* gem can reuse this
-      # class without defining its own copy.
-      class RegistryPublisher
-        include Legion::Logging::Helper
-
-        ASYNC_THREAD_POOL = Concurrent::FixedThreadPool.new(1, fallback_policy: :caller_runs)
-
-        attr_reader :provider_family
-
-        def initialize(provider_family:, builder: nil)
-          @provider_family = provider_family.to_s.downcase.to_sym
-          @builder = builder || RegistryEventBuilder.new(provider_family: @provider_family)
-        end
-
-        def app_id
-          "lex-llm-#{provider_family}"
-        end
-
-        def publish_readiness_async(readiness)
-          log.debug { "publishing readiness event to llm.registry for #{provider_family}" }
-          schedule { publish_event(@builder.readiness(readiness)) }
-        end
-
-        def publish_models_async(models, readiness:)
-          log.debug { "publishing #{Array(models).size} model event(s) to llm.registry for #{provider_family}" }
-          schedule do
-            Array(models).each do |model|
-              publish_event(@builder.model_available(model, readiness:))
-            end
-          end
-        end
-
-        private
-
-        def schedule(&)
-          return false unless publishing_available?
-
-          ASYNC_THREAD_POOL.post do
-            yield
-          rescue StandardError => e
-            handle_exception(e, level: :warn, handled: true,
-                                operation: "#{provider_family}.registry.schedule_thread")
-          end
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true,
-                              operation: "#{provider_family}.registry.schedule")
-          false
-        end
-
-        def publish_event(event)
-          return false unless publishing_available?
-
-          message_class.new(event:, provider_family: provider_family, app_id: app_id).publish(spool: false)
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true,
-                              operation: "#{provider_family}.registry.publish_event")
-          false
-        end
-
-        def publishing_available?
-          return false unless registry_event_available?
-          return false unless transport_message_available?
-          return true unless defined?(::Legion::Transport::Connection)
-          return true unless ::Legion::Transport::Connection.respond_to?(:session_open?)
-
-          ::Legion::Transport::Connection.session_open?
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true,
-                              operation: "#{provider_family}.registry.publishing_available?")
-          false
-        end
-
-        def registry_event_available?
-          defined?(::Legion::Extensions::Llm::Routing::RegistryEvent)
-        end
-
-        def transport_message_available?
-          return true if message_class_defined?
-          return false unless defined?(::Legion::Transport::Message) && defined?(::Legion::Transport::Exchange)
-
-          require 'legion/extensions/llm/transport/messages/registry_event'
-          message_class_defined?
-        rescue LoadError => e
-          handle_exception(e, level: :warn, handled: true,
-                              operation: "#{provider_family}.registry.transport_load")
-          false
-        end
-
-        def message_class_defined?
-          defined?(::Legion::Extensions::Llm::Transport::Messages::RegistryEvent)
-        end
-
-        def message_class
-          ::Legion::Extensions::Llm::Transport::Messages::RegistryEvent
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/responses/chat_response.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Responses
-        # Normalized non-streaming chat provider response.
-        class ChatResponse
-          attr_reader :content, :thinking, :metadata, :model, :tool_calls, :tokens, :raw, :internal_metadata
-
-          def initialize(content:, thinking: nil, metadata: {}, model: nil, tool_calls: nil, tokens: nil, raw: nil) # rubocop:disable Metrics/ParameterLists
-            extraction = ThinkingExtractor.extract(content, metadata: metadata)
-
-            @content = extraction.content
-            @thinking = thinking || extraction.thinking
-            @metadata = extraction.metadata
-            @internal_metadata = metadata.to_h
-            @model = model
-            @tool_calls = tool_calls
-            @tokens = tokens
-            @raw = raw
-
-            freeze
-          end
-
-          def to_h
-            {
-              content: content,
-              metadata: metadata,
-              model: model,
-              tool_calls: tool_calls,
-              tokens: tokens
-            }.compact
-          end
-
-          def to_internal_h
-            to_h.merge(thinking: thinking, metadata: internal_metadata, raw: raw).compact
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/responses/embedding_response.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Responses
-        # Normalized embedding provider response.
-        class EmbeddingResponse
-          attr_reader :vectors, :model, :tokens, :metadata, :raw
-
-          def initialize(vectors:, model:, tokens: nil, metadata: {}, raw: nil)
-            @vectors = vectors
-            @model = model
-            @tokens = tokens
-            @metadata = ThinkingExtractor.extract(nil, metadata: metadata).metadata
-            @internal_metadata = metadata.to_h
-            @raw = raw
-
-            freeze
-          end
-
-          def to_h
-            {
-              vectors: vectors,
-              model: model,
-              tokens: tokens,
-              metadata: metadata
-            }.compact
-          end
-
-          def to_internal_h
-            to_h.merge(metadata: @internal_metadata, raw: raw).compact
-          end
-        end
-      end
-    end
-  end
-end

data/lib/legion/extensions/llm/responses/stream_chunk.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Responses
-        # Normalized streaming provider response chunk.
-        class StreamChunk
-          attr_reader :content, :thinking, :metadata, :model, :tool_calls, :tokens, :raw, :internal_metadata
-
-          def initialize(content: nil, thinking: nil, metadata: {}, model: nil, tool_calls: nil, tokens: nil, raw: nil) # rubocop:disable Metrics/ParameterLists
-            extraction = ThinkingExtractor.extract(content, metadata: metadata)
-
-            @content = extraction.content
-            @thinking = thinking || extraction.thinking
-            @metadata = extraction.metadata
-            @internal_metadata = metadata.to_h
-            @model = model
-            @tool_calls = tool_calls
-            @tokens = tokens
-            @raw = raw
-
-            freeze
-          end
-
-          def to_h
-            {
-              content: content,
-              metadata: metadata,
-              model: model,
-              tool_calls: tool_calls,
-              tokens: tokens
-            }.compact
-          end
-
-          def to_internal_h
-            to_h.merge(thinking: thinking, metadata: internal_metadata, raw: raw).compact
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Routing
-        # DEPRECATED (Phase 4 removal): retained only for protocol-v2 fleet
-        # compatibility. The new canonical execution identity comes solely from
-        # Inventory::Identity (off:v1:/lane:v1:); do not reinterpret an old
-        # five-part lane as a new lane:v1: identity.
-        # Builds stable fleet lane keys from provider-neutral model offerings.
-        module LaneKey
-          module_function
-
-          def for(offering, prefix: 'llm.fleet', include_context: true, include_fingerprint: false)
-            parts = [prefix, lane_kind(offering), model_slug(lane_model(offering))]
-            parts << "ctx#{offering.context_window}" if include_context && offering.inference? && offering.context_window
-            parts.push('elig', eligibility_fingerprint(offering)) if include_fingerprint
-            parts.join('.')
-          end
-
-          def lane_model(offering)
-            return offering.canonical_model_alias if offering.respond_to?(:canonical_model_alias) &&
-                                                     offering.canonical_model_alias.to_s != ''
-
-            offering.model
-          end
-
-          def lane_kind(offering)
-            offering.embedding? ? 'embed' : 'inference'
-          end
-
-          def model_slug(model)
-            model.to_s.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/\A-+|-+\z/, '')
-          end
-
-          def eligibility_fingerprint(offering)
-            canonical = {
-              usage_type: offering.usage_type,
-              capabilities: offering.capabilities.sort,
-              context_window: offering.context_window,
-              max_output_tokens: offering.max_output_tokens,
-              policy_tags: offering.policy_tags.sort,
-              metadata: fingerprint_metadata(offering.metadata)
-            }
-            Digest::SHA1.hexdigest(Legion::JSON.generate(canonical))[0, 10]
-          end
-
-          def fingerprint_metadata(metadata)
-            metadata.fetch(:eligibility, {})
-                    .to_h
-                    .transform_keys(&:to_sym)
-                    .reject { |key, _| sensitive_fingerprint_key?(key) }
-                    .sort
-                    .to_h
-          end
-
-          def sensitive_fingerprint_key?(key)
-            %i[credential credentials endpoint endpoint_url identity path prompt reply_to secret secrets token
-               url].include?(key)
-          end
-        end
-      end
-    end
-  end
-end