lex-llm 0.7.6 → 0.8.4

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

@@ -13,7 +13,7 @@ module Legion
           include Legion::Logging::Helper
 
           def basic(&)
-            logger = faraday_logger
+            logger = faraday_logger_for(Legion::Extensions::Llm.config, log)
             Faraday.new do |f|
               f.response :logger,
                          logger,
@@ -25,22 +25,20 @@ module Legion
               yield f if block_given?
             end
           end
+        end
 
-          private
-
-          def faraday_logger
-            config = Legion::Extensions::Llm.config
-            return config.logger if config.respond_to?(:logger) && config.logger
+        # One Faraday logger resolution (10 U9): the configured logger when
+        # present, else the caller's fallback log.
+        def self.faraday_logger_for(config_source, fallback_log)
+          return config_source.logger if config_source.respond_to?(:logger) && config_source.logger
 
-            log
-          end
+          fallback_log
         end
 
         def initialize(provider, config)
           @provider = provider
           @config = config
 
-          ensure_configured!
           @connection ||= Faraday.new(provider.api_base) do |faraday|
             faraday.ssl.verify = false
             setup_timeout(faraday)
@@ -83,7 +81,7 @@ module Legion
         end
 
         def setup_logging(faraday)
-          logger = faraday_logger
+          logger = self.class.faraday_logger_for(config, log)
           # Enable request body logging when the logger is at DEBUG level,
           # or when explicitly enabled via fleet request_payload setting.
           request_payload = Legion::Extensions::Llm.default_settings.dig(:fleet, :request, :logger, :request_payload)
@@ -100,12 +98,6 @@ module Legion
           end
         end
 
-        def faraday_logger
-          return config.logger if config.respond_to?(:logger) && config.logger
-
-          log
-        end
-
         def debug_logger?(logger)
           return logger.debug? if logger.respond_to?(:debug?)
           return logger.level.to_i <= Logger::DEBUG if logger.respond_to?(:level)
@@ -164,20 +156,6 @@ module Legion
             Legion::Extensions::Llm::OverloadedError
           ]
         end
-
-        def ensure_configured!
-          return if @provider.configured?
-
-          missing = @provider.configuration_requirements.reject { |req| @config.send(req) }
-          config_block = <<~RUBY
-            Legion::Extensions::Llm.configure do |config|
-              #{missing.map { |key| "config.#{key} = ENV['#{key.to_s.upcase}']" }.join("\n  ")}
-            end
-          RUBY
-
-          raise ConfigurationError,
-                "#{@provider.name} provider is not configured. Add this to your initialization:\n\n#{config_block}"
-        end
       end
     end
   end

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

@@ -58,8 +58,12 @@ module Legion
           env_hash[key.to_sym] || env_hash[key.to_s]
         end
 
+        # The codex auth file is an optional source: absent means "no codex
+        # credential" (probe semantics); present-but-unreadable raises from
+        # read_json (O11 fail-closed).
         def codex_token
           return nil unless credential_source_probing_enabled?
+          return nil unless File.exist?(CODEX_AUTH)
 
           data = read_json(CODEX_AUTH)
           mode = data[:auth_mode] || data['auth_mode']
@@ -74,6 +78,7 @@ module Legion
 
         def codex_openai_key
           return nil unless credential_source_probing_enabled?
+          return nil unless File.exist?(CODEX_AUTH)
 
           data = read_json(CODEX_AUTH)
           val = data[:OPENAI_API_KEY] || data['OPENAI_API_KEY']
@@ -198,19 +203,12 @@ module Legion
           credential_fingerprint(val)
         end
 
-        # Returns true when the URL points to localhost / 127.0.0.1 / ::1.
+        # Returns true when the URL points to localhost / 127.0.0.1 / ::1
+        # (the one shared host-locality detector — Utils.localhost_url?).
         def localhost?(url)
           return false if url.nil?
 
-          uri = URI.parse(url.to_s)
-          host = uri.host
-          return false if host.nil?
-
-          normalized = host.delete_prefix('[').delete_suffix(']')
-          %w[localhost 127.0.0.1 ::1].include?(normalized)
-        rescue URI::InvalidURIError => e
-          handle_exception(e, level: :warn, handled: true, operation: 'llm.credential_sources.localhost')
-          false
+          Utils.localhost_url?(url)
         end
 
         module_function :env, :credential_source_probing_enabled?,
@@ -224,69 +222,54 @@ module Legion
         # --- private helpers -----------------------------------------------
 
         # Merge user-level (~/.claude/settings.json) and project-level
-        # (.claude/settings.json) Claude configs.  Project overrides user.
+        # (.claude/settings.json) Claude configs.  Both files are optional
+        # sources: absent means "no config from that level".  Project overrides
+        # user.
         def merge_claude_configs
-          user = read_json(CLAUDE_SETTINGS)
-          project = read_json(CLAUDE_PROJECT)
-          deep_merge(user, project)
+          user = File.exist?(CLAUDE_SETTINGS) ? read_json(CLAUDE_SETTINGS) : {}
+          project = File.exist?(CLAUDE_PROJECT) ? read_json(CLAUDE_PROJECT) : {}
+          Utils.deep_merge(user, project)
         end
 
-        # Read and parse a JSON file.  Returns an empty hash on any error.
+        # Read and parse a JSON file.  O11 fail-closed: a missing, empty, or
+        # unreadable/unparseable credential file raises — it is a
+        # configuration error, never a fabricated empty credential.
         def read_json(path)
-          return {} unless File.exist?(path)
+          raise ConfigurationError, "credential file is missing: #{path}" unless File.exist?(path)
 
           raw = File.read(path)
-          return {} if raw.strip.empty?
+          raise ConfigurationError, "credential file is empty: #{path}" if raw.strip.empty?
 
-          if defined?(::Legion::JSON)
-            ::Legion::JSON.parse(raw, symbolize_names: true)
-          else
-            ::JSON.parse(raw, symbolize_names: true)
-          end
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: 'llm.credential_sources.read_json',
-                              path:)
-          {}
+          # L1: Legion::JSON only (house rule) — the bare ::JSON fallback is
+          # deleted; Legion::JSON is a hard dependency of this gem.
+          ::Legion::JSON.parse(raw, symbolize_names: true)
         end
 
         # JWT expiry check.  Decodes the base64 payload segment and checks
-        # that exp > now.  Returns true on any parse error (benefit of the
-        # doubt).
+        # that exp > now.  O11 fail-closed: unreadable or invalid token data
+        # is INVALID (the old benefit-of-the-doubt true is deleted). A
+        # parseable token with no exp claim has nothing to violate.
         def token_valid?(token)
-          return true if token.nil?
-
           require 'base64'
-          require 'json'
 
           parts = token.to_s.split('.')
-          return true unless parts.length >= 2
+          return false if parts.length < 2
 
-          payload = ::JSON.parse(Base64.urlsafe_decode64(parts[1]))
+          # L1: Legion::JSON only (string keys — the JWT payload is read by
+          # string key).
+          payload = ::Legion::JSON.parse(Base64.urlsafe_decode64(parts[1]), symbolize_names: false)
           exp = payload['exp']
           return true if exp.nil?
 
           exp.to_i > Time.now.to_i
         rescue StandardError => e
           handle_exception(e, level: :warn, handled: true, operation: 'llm.credential_sources.token_valid')
-          true
-        end
-
-        # Simple recursive hash merge (project values override user values).
-        def deep_merge(base, override)
-          base.merge(override) do |_key, old_val, new_val|
-            if old_val.is_a?(Hash) && new_val.is_a?(Hash)
-              deep_merge(old_val, new_val)
-            else
-              new_val
-            end
-          end
+          false
         end
 
-        module_function :merge_claude_configs, :read_json,
-                        :token_valid?, :deep_merge
+        module_function :merge_claude_configs, :read_json, :token_valid?
 
-        private_class_method :merge_claude_configs, :read_json,
-                             :token_valid?, :deep_merge
+        private_class_method :merge_claude_configs, :read_json, :token_valid?
       end
     end
   end

data/lib/legion/extensions/llm/discovery/actor.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+begin
+  require 'legion/extensions/actors/every'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
+# The base actor inherits the LegionIO time-based Every actor, which only
+# exists inside the daemon. In a standalone lex-llm load (specs, gem require)
+# Every is absent — define nothing rather than crash. Provider actor files
+# carry the same guard.
+#
+# Like the pipeline, this base lives in `discovery/`, NOT the scanned
+# `actors/` dir: a file there would be claimed by the builder as a live
+# per-extension actor (and auto-wrapped in a meta actor). A provider's live
+# actor is its own `<Provider>::Actor::Discovery` (scanned), which subclasses
+# this base with an EMPTY body.
+return unless defined?(Legion::Extensions::Actors::Every)
+
+module Legion
+  module Extensions
+    module Llm
+      module Discovery
+        # Base periodic discovery actor for EVERY lex-llm-* provider. This is
+        # the interface: a provider subclasses it with an EMPTY body and gets
+        # discovery for free —
+        #
+        #   module Vllm
+        #     module Actor
+        #       class Discovery < Legion::Extensions::Llm::Discovery::Actor; end
+        #     end
+        #   end
+        #
+        # It fires on the configured discovery interval and dispatches each tick
+        # to the provider's `Runners::Discovery` module (resolved by convention
+        # from this actor's own namespace), which mixes in Discovery::Pipeline
+        # and owns the provider-specific fetch/health/evidence/callable. Every
+        # generic decision lives in the pipeline; a provider overrides a single
+        # method only when its runner lives somewhere non-conventional or its
+        # teardown differs.
+        #
+        # Dispatch contract (Every -> Actors::Base#manual): `use_runner? = false`
+        # calls the runner MODULE's `refresh` directly (no Legion::Runner task —
+        # the state and the Registry are process-local, so it must run on the
+        # owning node); `run_now? = true` fires once on boot then every `time`
+        # seconds.
+        class Actor < Legion::Extensions::Actors::Every
+          include Legion::Extensions::Helpers::Lex
+
+          def run_now?        = true
+          def use_runner?     = false
+          def runner_function = 'refresh'
+
+          # The provider's discovery runner module, resolved by convention from
+          # this actor's namespace: <ProviderModule>::Runners::Discovery. A
+          # provider whose runner lives elsewhere overrides this one method.
+          def runner_class
+            "#{provider_namespace}::Runners::Discovery"
+          end
+
+          # Honor the registered discovery interval. A nil TimerTask interval
+          # fires once and then stops, so resolve to the registered default
+          # (300s) whenever the setting is missing or non-positive.
+          def time
+            interval = settings.dig(:instances, :default, :discovery_interval)&.to_i ||
+                       settings.dig(:discovery, :interval_seconds)&.to_i
+            interval&.positive? ? interval : 300
+          end
+
+          def shutdown
+            Kernel.const_get(runner_class).remove_all_instances
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: "#{provider_slug}.actor.discovery.shutdown")
+          end
+
+          private
+
+          # "Legion::Extensions::Llm::Vllm::Actor::Discovery" ->
+          # "Legion::Extensions::Llm::Vllm" (drop the trailing Actor::<Name>).
+          def provider_namespace
+            self.class.name.split('::')[0..-3].join('::')
+          end
+
+          def provider_slug
+            provider_namespace.split('::').last.to_s.downcase
+          end
+        end
+      end
+    end
+  end
+end