legionio 1.9.18 → 1.9.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ddd3ea28ab0a066f4e3bc7d7fa6f7016ac1b395eec931a76ece7bc3722f04f8
-  data.tar.gz: 4c97638f1e52579b2351023fa21c36974412ab60c126fe8825c72f2d22466516
+  metadata.gz: e6be612db3e6de32b7c4baf82b6a38aac19a0a0bb53d198f736ae4d2d638829d
+  data.tar.gz: bf294cc20dbb5701b7bd4f5fd474dbc27d6eae37d2c084cf7b06ec2cbb99f2dc
 SHA512:
-  metadata.gz: 5641aa16fb0c352632286285433596060ac046c1300c9083f0bf851afea6bca5e9626f41984cdd2b5586346a7515dbf6e11ea288555f5a57c543adca5fd1f52c
-  data.tar.gz: d3e33ed0f6fb0bb5da8688705ef13bfe95841b74faa4e06103d462fccf9771714f1d9efc28f0017cc10f1ad0310560f66c0468d3912d7d23ab8c34359e2abec0
+  metadata.gz: 3968a2056a7f9c5c2bdbaeff4934165c0a0abd47bde56202f91befeac65c3bd5e38e321de7df3056f2fb71ff66016a89fc2b1803288b598da8fbdaedcc628e77
+  data.tar.gz: cc371efeb8f0ad2b32bccfe8140a3ebba0310bded8718c5736c9338fbf088f407d27f58a27d05ad2f6d371b5be45d3d5d50dfddbb4a5d4edb9888a44430a5d9d

data/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 ## [Unreleased]
 
+## [1.9.23] - 2026-05-07
+
+### Fixed
+- Fixed encrypted subscription handling to accept both string-keyed and symbol-keyed IV headers before decrypting `encrypted/cs` AMQP payloads.
+
+## [1.9.22] - 2026-05-06
+
+### Changed
+- Hot-reloading a `lex-llm-*` provider extension now asks `Legion::LLM::Call::Providers` to rediscover loaded provider modules, keeping LLM provider instances aligned after extension updates.
+- Bumped the packaged `legion-llm` dependency floor to `>= 0.9.1` for LLM-owned provider registration and reload-safe registry rebuilds.
+
+## [1.9.21] - 2026-05-06
+
+### Changed
+- LegionIO now mounts `Legion::LLM::Routes` through the library route selector when `legion-llm` is available, leaving LLM API ownership with `legion-llm` instead of registering partial fallback routes first.
+- LLM provider health API and CLI output now require native `Legion::LLM::Inventory` data and return a clear unavailable response when inventory is not loaded.
+- Bumped packaged dependency floors to `legion-llm >= 0.9.0` and `legion-data >= 1.8.0` for the coordinated LLM route/schema sweep.
+
+### Fixed
+- Lite and local mode startup now write development mode through the public `Legion::Settings.set_prop` API.
+
+### Removed
+- Removed active `lex-llm-gateway` fallback paths from LLM chat, provider health, extension catalog, role filtering, and README documentation.
+
+## [1.9.20] - 2026-05-06
+
+### Fixed
+- Nested LEX extensions now merge default settings into their nested `extensions` path (for example `lex-foo-bar` -> `extensions.foo.bar`) while underscored flat extensions continue to use the flat key (for example `lex-foo_bar` -> `extensions.foo_bar`).
+- Extension load-time settings checks now use the discovered settings path for nested extensions, keeping `enabled`, `min_version`, `workers`, and `remote_invocable` overrides aligned with where defaults are merged.
+
+## [1.9.19] - 2026-05-05
+
+### Added
+- `UnrecoverableMessageError` for messages that should be dead-lettered immediately (e.g., missing IV header on encrypted messages) instead of retried.
+- Subscription actors now extract `message_id` and `correlation_id` from AMQP metadata into the message hash for downstream tracing.
+- Runner builder auto-includes `Helpers::Lex` into runner modules when available, ensuring all runners have LEX metadata helpers.
+
+### Fixed
+- Encrypted messages (`encrypted/cs`) with a missing `iv` header now raise `UnrecoverableMessageError` and are dead-lettered rather than crashing with a nil argument to `Crypt.decrypt`.
+
 ## [1.9.18] - 2026-04-29
 
 ### Fixed

data/Gemfile

@@ -28,28 +28,32 @@ def local_gem_path(name, default_path, version_file, requirement)
   default_path
 end
 
+gem 'legion-apollo', path: '../legion-apollo' if File.exist?(File.expand_path('../legion-apollo', __dir__))
 gem 'legion-data', path: '../legion-data' if File.exist?(File.expand_path('../legion-data', __dir__))
+gem 'legion-logging', path: '../legion-logging' if File.exist?(File.expand_path('../legion-logging', __dir__))
+gem 'legion-settings', path: '../legion-settings' if File.exist?(File.expand_path('../legion-settings', __dir__))
+if (legion_tty_path = local_gem_path('legion-tty', '../legion-tty', 'lib/legion/tty/version.rb', '>= 0.5.4'))
+  gem 'legion-tty', path: legion_tty_path
+end
+
 gem 'legion-gaia', path: '../legion-gaia' if File.exist?(File.expand_path('../legion-gaia', __dir__))
 if (legion_llm_path = local_gem_path('legion-llm', '../legion-llm', 'lib/legion/llm/version.rb', '>= 0.8.47'))
   gem 'legion-llm', path: legion_llm_path
 end
-if (legion_tty_path = local_gem_path('legion-tty', '../legion-tty', 'lib/legion/tty/version.rb', '>= 0.5.4'))
-  gem 'legion-tty', path: legion_tty_path
-end
-gem 'legion-logging', path: '../legion-logging' if File.exist?(File.expand_path('../legion-logging', __dir__))
 gem 'legion-mcp', path: '../legion-mcp' if File.exist?(File.expand_path('../legion-mcp', __dir__))
-gem 'legion-settings', path: '../legion-settings' if File.exist?(File.expand_path('../legion-settings', __dir__))
 
-gem 'legion-apollo', path: '../legion-apollo' if File.exist?(File.expand_path('../legion-apollo', __dir__))
-gem 'lex-agentic-memory', path: '../extensions-agentic/lex-agentic-memory' if File.exist?(File.expand_path('../extensions-agentic/lex-agentic-memory', __dir__))
+gem 'lex-kerberos'
+
+gem 'lex-apollo', path: '../extensions/lex-apollo' if File.exist?(File.expand_path('../extensions/lex-apollo', __dir__))
 gem 'lex-llm', path: '../extensions-ai/lex-llm' if File.exist?(File.expand_path('../extensions-ai/lex-llm', __dir__))
 gem 'lex-llm-ledger', path: '../extensions-ai/lex-llm-ledger' if File.exist?(File.expand_path('../extensions-ai/lex-llm-ledger', __dir__))
+
 %w[anthropic azure-foundry bedrock gemini mlx ollama openai vertex vllm].each do |provider|
   provider_path = "../extensions-ai/lex-llm-#{provider}"
   gem "lex-llm-#{provider}", path: provider_path if File.exist?(File.expand_path(provider_path, __dir__))
 end
-gem 'lex-llm-gateway', path: '../extensions/lex-llm-gateway' if File.exist?(File.expand_path('../extensions/lex-llm-gateway', __dir__))
-gem 'lex-microsoft_teams', path: '../extensions/lex-microsoft_teams' if File.exist?(File.expand_path('../extensions/lex-microsoft_teams', __dir__))
+
+# gem 'lex-microsoft_teams', path: '../extensions/lex-microsoft_teams' if File.exist?(File.expand_path('../extensions/lex-microsoft_teams', __dir__))
 
 gem 'pg'
 

data/README.md

@@ -435,7 +435,7 @@ Coordinated by [legion-gaia](https://github.com/LegionIO/legion-gaia), the cogni
 
 Powered by [legion-llm](https://github.com/LegionIO/legion-llm) with provider-neutral model offerings, local and fleet routing, hosted cloud providers, health tracking, metering, and automatic model discovery.
 
-`lex-llm-gateway` remains available only as legacy compatibility glue for older deployments. New `legion setup llm` and `legion setup agentic` installs use the native `legion-llm` / `lex-llm-*` stack and do not install the gateway by default.
+LLM API routes are mounted from `legion-llm` when available; LegionIO only hosts those route modules and does not provide a provider gateway fallback.
 
 ### Service Integrations (8 common + 15 additional)
 

data/legionio.gemspec

@@ -54,7 +54,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'legion-cache', '>= 1.3.22'
   spec.add_dependency 'legion-crypt', '>= 1.5.1'
-  spec.add_dependency 'legion-data', '>= 1.6.19'
+  spec.add_dependency 'legion-data', '>= 1.8.0'
   spec.add_dependency 'legion-json', '>= 1.2.1'
   spec.add_dependency 'legion-logging', '>= 1.5.0'
   spec.add_dependency 'legion-settings', '>= 1.3.25'
@@ -62,7 +62,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'legion-apollo', '>= 0.4.0'
   spec.add_dependency 'legion-gaia', '>= 0.9.26'
-  spec.add_dependency 'legion-llm', '>= 0.8.47'
+  spec.add_dependency 'legion-llm', '>= 0.9.1'
   spec.add_dependency 'legion-tty', '>= 0.5.4'
   spec.add_dependency 'lex-node'
 end

data/lib/legion/api/llm.rb

@@ -24,49 +24,52 @@ module Legion
                 Legion::Cache.connected?
             end
 
-            define_method(:gateway_available?) do
-              defined?(Legion::Extensions::Llm::Gateway::Runners::Inference)
-            end
-
             define_method(:native_provider_stats_available?) do
               defined?(Legion::LLM::Inventory) && Legion::LLM::Inventory.respond_to?(:providers)
             end
 
+            define_method(:require_llm_chat!) do
+              return if defined?(Legion::LLM) && Legion::LLM.respond_to?(:chat)
+
+              halt 503, json_error('llm_chat_unavailable',
+                                   'Legion::LLM.chat is not available',
+                                   status_code: 503)
+            end
+
+            define_method(:require_provider_inventory!) do
+              return if native_provider_stats_available?
+
+              halt 503, json_error('providers_unavailable',
+                                   'LLM provider inventory is not loaded',
+                                   status_code: 503)
+            end
+
             define_method(:provider_health_report) do
-              if native_provider_stats_available?
-                groups = Legion::LLM::Inventory.providers
-                return [] unless groups.respond_to?(:map)
-
-                groups.map do |provider, offerings|
-                  provider_offerings = Array(offerings)
-                  health = provider_offerings.map { |offering| offering_value(offering, :health) }
-                                             .find { |entry| entry.is_a?(Hash) } || {}
-                  circuit = health[:circuit_state] || health['circuit_state'] || 'unknown'
-                  {
-                    provider:   provider.to_s,
-                    circuit:    circuit,
-                    adjustment: health[:adjustment] || health['adjustment'] || 0,
-                    healthy:    circuit.to_s != 'open',
-                    offerings:  provider_offerings.size,
-                    models:     provider_offerings.map { |offering| offering_value(offering, :model) }.compact.uniq,
-                    types:      provider_offerings.map { |offering| offering_value(offering, :type) }.compact.uniq,
-                    instances:  provider_offerings.map do |offering|
-                      offering_value(offering, :provider_instance) || offering_value(offering, :instance_id)
-                    end.compact.uniq
-                  }
-                end
-              elsif defined?(Legion::Extensions::Llm::Gateway::Runners::ProviderStats)
-                Legion::Extensions::Llm::Gateway::Runners::ProviderStats.health_report
-              else
-                []
+              groups = Legion::LLM::Inventory.providers
+              return [] unless groups.respond_to?(:map)
+
+              groups.map do |provider, offerings|
+                provider_offerings = Array(offerings)
+                health = provider_offerings.map { |offering| offering_value(offering, :health) }
+                                           .find { |entry| entry.is_a?(Hash) } || {}
+                circuit = health[:circuit_state] || health['circuit_state'] || 'unknown'
+                {
+                  provider:   provider.to_s,
+                  circuit:    circuit,
+                  adjustment: health[:adjustment] || health['adjustment'] || 0,
+                  healthy:    circuit.to_s != 'open',
+                  offerings:  provider_offerings.size,
+                  models:     provider_offerings.map { |offering| offering_value(offering, :model) }.compact.uniq,
+                  types:      provider_offerings.map { |offering| offering_value(offering, :type) }.compact.uniq,
+                  instances:  provider_offerings.map do |offering|
+                    offering_value(offering, :provider_instance) || offering_value(offering, :instance_id)
+                  end.compact.uniq
+                }
               end
             end
 
             define_method(:provider_circuit_summary) do
               report = provider_health_report
-              return Legion::Extensions::Llm::Gateway::Runners::ProviderStats.circuit_summary if
-                report.empty? && defined?(Legion::Extensions::Llm::Gateway::Runners::ProviderStats)
-
               circuits = report.map { |entry| entry[:circuit].to_s }
               {
                 total:     report.size,
@@ -78,16 +81,10 @@ module Legion
 
             define_method(:provider_detail) do |provider|
               provider_name = provider.to_s
-              if native_provider_stats_available?
-                entry = provider_health_report.find { |candidate| candidate[:provider] == provider_name }
-                halt 404, json_error('provider_not_found', "Provider '#{provider_name}' not found", status_code: 404) unless entry
-
-                entry
-              elsif defined?(Legion::Extensions::Llm::Gateway::Runners::ProviderStats)
-                Legion::Extensions::Llm::Gateway::Runners::ProviderStats.provider_detail(provider: provider_name.to_sym)
-              else
-                halt 503, json_error('providers_unavailable', 'LLM provider inventory is not loaded', status_code: 503)
-              end
+              entry = provider_health_report.find { |candidate| candidate[:provider] == provider_name }
+              halt 404, json_error('provider_not_found', "Provider '#{provider_name}' not found", status_code: 404) unless entry
+
+              entry
             end
 
             define_method(:offering_value) do |offering, key|
@@ -157,55 +154,14 @@ module Legion
               end
             end
 
+            require_llm_chat!
+
             request_id = body[:request_id] || SecureRandom.uuid
             model      = body[:model]
             provider   = body[:provider]
 
-            # Compatibility fallback for legacy gateway installs. Native legion-llm handles routing first.
-            if !Legion::LLM.respond_to?(:chat) && gateway_available?
-              ingress_result = Legion::Ingress.run(
-                payload:      { message: message, model: model, provider: provider,
-                                request_id: request_id },
-                runner_class: 'Legion::Extensions::Llm::Gateway::Runners::Inference',
-                function:     'chat',
-                source:       'api'
-              )
-
-              unless ingress_result[:success]
-                Legion::Logging.error "[api/llm/chat] ingress failed: #{ingress_result}"
-                return json_response({ error: ingress_result[:error] || ingress_result[:status] },
-                                     status_code: 502)
-              end
-
-              result = ingress_result[:result]
-
-              if result.nil?
-                Legion::Logging.warn "[api/llm/chat] runner returned nil (status=#{ingress_result[:status]})"
-                return json_response({ error: { code:    'empty_result',
-                                                message: 'Gateway runner returned no result' } },
-                                     status_code: 502)
-              end
-
-              response_content = if result.respond_to?(:content)
-                                   result.content
-                                 elsif result.is_a?(Hash) && result[:error]
-                                   return json_response({ error: result[:error] }, status_code: 502)
-                                 elsif result.is_a?(Hash)
-                                   result[:response] || result[:content] || result.to_s
-                                 else
-                                   result.to_s
-                                 end
-
-              meta = { routed_via: 'gateway' }
-              meta[:model] = result.model.to_s if result.respond_to?(:model)
-              meta[:tokens_in] = result.input_tokens if result.respond_to?(:input_tokens)
-              meta[:tokens_out] = result.output_tokens if result.respond_to?(:output_tokens)
-
-              return json_response({ response: response_content, meta: meta }, status_code: 201)
-            end
-
             # Fallback: direct LLM call (no metering, no task tracking)
-            if cache_available? && env['HTTP_X_LEGION_SYNC'] != 'true'
+            if cache_available? && env['HTTP_X_LEGION_SYNC'] != 'true' && Legion::LLM.respond_to?(:chat_direct)
               llm = Legion::LLM
               rc  = Legion::LLM::ResponseCache
               rc.init_request(request_id)
@@ -469,6 +425,7 @@ module Legion
         def self.register_providers(app)
           app.get '/api/llm/providers' do
             require_llm!
+            require_provider_inventory!
 
             json_response({
                             providers: provider_health_report,
@@ -478,6 +435,7 @@ module Legion
 
           app.get '/api/llm/providers/:name' do
             require_llm!
+            require_provider_inventory!
 
             json_response(provider_detail(params[:name]))
           end

data/lib/legion/cli/chat/tools/provider_health.rb

@@ -75,7 +75,7 @@ module Legion
           end
 
           def provider_stats_available?
-            native_provider_stats_available? || gateway_stats_available?
+            native_provider_stats_available?
           end
 
           def native_provider_stats_available?
@@ -83,9 +83,7 @@ module Legion
           end
 
           def provider_health_report
-            return native_provider_health_report if native_provider_stats_available?
-
-            stats_module.health_report
+            native_provider_health_report
           end
 
           def native_provider_health_report
@@ -113,8 +111,6 @@ module Legion
           end
 
           def provider_circuit_summary(report)
-            return stats_module.circuit_summary unless native_provider_stats_available?
-
             circuits = report.map { |entry| entry[:circuit].to_s }
             {
               total:     report.size,
@@ -126,8 +122,6 @@ module Legion
 
           def provider_detail(provider)
             provider_name = provider.to_s
-            return stats_module.provider_detail(provider: provider_name.to_sym) unless native_provider_stats_available?
-
             provider_health_report.find { |entry| entry[:provider] == provider_name } || {}
           end
 
@@ -136,14 +130,6 @@ module Legion
 
             offering[key] || offering[key.to_s]
           end
-
-          def gateway_stats_available?
-            defined?(Legion::Extensions::Llm::Gateway::Runners::ProviderStats)
-          end
-
-          def stats_module
-            Legion::Extensions::Llm::Gateway::Runners::ProviderStats
-          end
         end
       end
     end

data/lib/legion/extensions/actors/subscription.rb

@@ -9,6 +9,8 @@ require 'securerandom'
 module Legion
   module Extensions
     module Actors
+      class UnrecoverableMessageError < StandardError; end
+
       class Subscription
         extend Legion::Extensions::Actors::Dsl
         include Concurrent::Async
@@ -62,7 +64,7 @@ module Legion
           true
         end
 
-        def prepare
+        def prepare # rubocop:disable Metrics/AbcSize
           @queue = queue.new
           @queue.channel.prefetch(prefetch) if defined? prefetch
           consumer_tag = "#{Legion::Settings[:client][:name]}_#{lex_name}_#{runner_name}_#{SecureRandom.uuid}"
@@ -90,6 +92,10 @@ module Legion
             @queue.acknowledge(delivery_info.delivery_tag) if manual_ack
 
             cancel if Legion::Settings[:client][:shutting_down]
+          rescue UnrecoverableMessageError => e
+            handle_exception(e, lex: lex_name, fn: fn, routing_key: delivery_info.routing_key)
+            log.warn "[Subscription] dead-lettering unrecoverable message for #{lex_name}/#{fn}: #{e.message}"
+            @queue.reject(delivery_info.delivery_tag, requeue: false) if manual_ack
           rescue StandardError => e
             handle_exception(e, lex: lex_name, fn: fn, routing_key: delivery_info.routing_key)
             reject_or_retry(delivery_info, metadata, payload) if manual_ack
@@ -112,9 +118,13 @@ module Legion
           true
         end
 
-        def process_message(message, metadata, delivery_info)
+        def process_message(message, metadata, delivery_info) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
           payload = if metadata.content_encoding && metadata.content_encoding == 'encrypted/cs'
-                      Legion::Crypt.decrypt(message, metadata.headers['iv'])
+                      headers = metadata.headers || {}
+                      iv = headers['iv'] || headers[:iv]
+                      raise UnrecoverableMessageError, "encrypted/cs message missing iv header (#{lex_name}/#{runner_name})" if iv.nil?
+
+                      Legion::Crypt.decrypt(message, iv)
                     elsif metadata.content_encoding && metadata.content_encoding == 'encrypted/pk'
                       Legion::Crypt.decrypt_from_keypair(metadata.headers[:public_key], message)
                     else
@@ -131,6 +141,9 @@ module Legion
             message[:routing_key] = delivery_info[:routing_key]
           end
 
+          message[:message_id] ||= metadata.message_id if metadata.respond_to?(:message_id) && metadata.message_id
+          message[:correlation_id] ||= metadata.correlation_id if metadata.respond_to?(:correlation_id) && metadata.correlation_id
+
           message[:timestamp] = (message[:timestamp_in_ms] / 1000).round if message.key?(:timestamp_in_ms) && !message.key?(:timestamp)
           message[:datetime] = Time.at(message[:timestamp].to_i).to_datetime.to_s if message.key?(:timestamp)
           message
@@ -152,11 +165,14 @@ module Legion
           on_cancellation = block { cancel }
 
           @consumer = @queue.subscribe(manual_ack: manual_ack, block: false, consumer_tag: consumer_tag, on_cancellation: on_cancellation) do |*rmq_message|
-            payload = rmq_message.pop
-            metadata = rmq_message.last
-            delivery_info = rmq_message.first
-
+            delivery_info = nil
+            metadata = nil
+            payload = nil
             fn = nil
+
+            delivery_info = rmq_message.first
+            metadata = rmq_message.last
+            payload = rmq_message.pop
             message = process_message(payload, metadata, delivery_info)
             fn = find_function(message)
             log.debug "[Subscription] message received: #{lex_name}/#{fn}" if defined?(log)
@@ -182,10 +198,14 @@ module Legion
             @queue.acknowledge(delivery_info.delivery_tag) if manual_ack
 
             cancel if Legion::Settings[:client][:shutting_down]
+          rescue UnrecoverableMessageError => e
+            handle_exception(e, lex: lex_name, fn: fn)
+            log.warn "[Subscription] dead-lettering unrecoverable message for #{lex_name}/#{fn}: #{e.message}"
+            @queue.reject(delivery_info.delivery_tag, requeue: false) if manual_ack && delivery_info
           rescue StandardError => e
             handle_exception(e)
             log.warn "[Subscription] retry-or-dlq for #{lex_name}/#{fn}"
-            reject_or_retry(delivery_info, metadata, payload) if manual_ack
+            reject_or_retry(delivery_info, metadata, payload) if manual_ack && delivery_info
           end
           log.info "[Subscription] subscribed: #{lex_name}/#{runner_name} (consumer registered)" if defined?(log)
         end

data/lib/legion/extensions/builders/actors.rb

@@ -29,6 +29,7 @@ module Legion
             @actors[actor_name.to_sym] = {
               extension:      lex_class.to_s.downcase,
               extension_name: extension_name,
+              settings_path:  settings_path,
               actor_name:     actor_name,
               actor_class:    Kernel.const_get(actor_class),
               type:           'literal'
@@ -50,6 +51,7 @@ module Legion
             @actors[runner.to_sym] = {
               extension:      attr[:extension],
               extension_name: attr[:extension_name],
+              settings_path:  attr[:settings_path],
               actor_name:     attr[:runner_name],
               actor_class:    Kernel.const_get(actor_class),
               type:           'meta'

data/lib/legion/extensions/builders/hooks.rb

@@ -34,6 +34,7 @@ module Legion
             @hooks[hook_name.to_sym] = {
               extension:      lex_class.to_s.downcase,
               extension_name: extension_name,
+              settings_path:  settings_path,
               hook_name:      hook_name,
               hook_class:     hook_class,
               route_path:     route_path

data/lib/legion/extensions/builders/runners.rb

@@ -24,6 +24,7 @@ module Legion
             runner_class = "#{lex_class}::Runners::#{runner_name.split('_').collect(&:capitalize).join}"
             loaded_runner = Kernel.const_get(runner_class)
             loaded_runner.extend(Legion::Extensions::Definitions) unless loaded_runner.respond_to?(:definition)
+            ensure_lex_helpers(loaded_runner, runner_class)
             Legion::Logging.debug "[Runners] registered: #{runner_class}" if defined?(Legion::Logging)
             @runners[runner_name.to_sym] = build_runner_entry(runner_name, runner_class, loaded_runner, file)
             populate_runner_methods(runner_name, loaded_runner)
@@ -34,6 +35,7 @@ module Legion
           entry = {
             extension:       lex_class.to_s.downcase,
             extension_name:  extension_name,
+            settings_path:   settings_path,
             extension_class: lex_class,
             runner_name:     runner_name,
             runner_class:    runner_class,
@@ -75,6 +77,19 @@ module Legion
         def runner_files
           @runner_files ||= find_files('runners')
         end
+
+        private
+
+        def ensure_lex_helpers(runner_module, runner_class)
+          return unless Legion::Extensions.const_defined?(:Helpers, false) &&
+                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+
+          lex_mod = Legion::Extensions::Helpers::Lex
+          return if runner_module.ancestors.include?(lex_mod)
+
+          runner_module.include(lex_mod)
+          Legion::Logging.info "[Runners] auto-included Helpers::Lex into #{runner_class}" if defined?(Legion::Logging)
+        end
       end
     end
   end

data/lib/legion/extensions/catalog/available.rb

@@ -14,7 +14,6 @@ module Legion
           { name: 'lex-exec',         category: 'core',     description: 'Shell command execution' },
           { name: 'lex-health',       category: 'core',     description: 'Health monitoring and metrics' },
           { name: 'lex-lex',          category: 'core',     description: 'Extension management' },
-          { name: 'lex-llm-gateway',  category: 'legacy',   description: 'Legacy LLM gateway compatibility' },
           { name: 'lex-llm-ledger',   category: 'core',     description: 'LLM cost and usage ledger' },
           { name: 'lex-log',          category: 'core',     description: 'Log shipping and aggregation' },
           { name: 'lex-metering',     category: 'core',     description: 'Resource metering and accounting' },

data/lib/legion/extensions/core.rb

@@ -219,27 +219,9 @@ module Legion
       end
 
       def build_settings
-        defaults = deep_dup_settings_value(Legion::Settings[:default_extension_settings] || {})
-
-        if Legion::Settings[:extensions].key?(lex_name.to_sym)
-          defaults.each do |key, value|
-            Legion::Settings[:extensions][lex_name.to_sym][key.to_sym] = if Legion::Settings[:extensions][lex_name.to_sym].key?(key.to_sym)
-                                                                           deep_dup_settings_value(value).merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
-                                                                         else
-                                                                           deep_dup_settings_value(value)
-                                                                         end
-          end
-        else
-          Legion::Settings[:extensions][lex_name.to_sym] = defaults
-        end
-
-        default_settings.each do |key, value|
-          Legion::Settings[:extensions][lex_name.to_sym][key.to_sym] = if Legion::Settings[:extensions][lex_name.to_sym].key?(key.to_sym)
-                                                                         deep_dup_settings_value(value).merge(Legion::Settings[:extensions][lex_name.to_sym][key.to_sym])
-                                                                       else
-                                                                         deep_dup_settings_value(value)
-                                                                       end
-        end
+        target = extension_settings_target
+        merge_extension_defaults!(target, Legion::Settings[:default_extension_settings] || {})
+        merge_extension_defaults!(target, default_settings)
       end
 
       def default_settings
@@ -284,6 +266,29 @@ module Legion
       rescue TypeError
         value
       end
+
+      def extension_settings_target
+        settings_path.reduce(Legion::Settings[:extensions]) do |current, key|
+          current[key] = {} unless current[key].is_a?(Hash)
+          current[key]
+        end
+      end
+
+      def merge_extension_defaults!(target, defaults)
+        defaults.each do |key, value|
+          key = key.to_sym
+          target[key] = if target.key?(key)
+                          merge_extension_default_value(deep_dup_settings_value(value), target[key])
+                        else
+                          deep_dup_settings_value(value)
+                        end
+        end
+      end
+
+      def merge_extension_default_value(default_value, current_value)
+        merge_extension_defaults!(current_value, default_value) if default_value.is_a?(Hash) && current_value.is_a?(Hash)
+        current_value
+      end
     end
   end
 end

data/lib/legion/extensions.rb

@@ -143,12 +143,9 @@ module Legion
       def load_phase_extensions(phase_num, entries)
         eligible = entries.filter_map do |entry|
           gem_name = entry[:gem_name]
-          ext_name = entry[:require_path].split('/').last
+          ext_settings = extension_settings_for_entry(entry)
 
-          if Legion::Settings[:extensions].key?(ext_name.to_sym) &&
-             Legion::Settings[:extensions][ext_name.to_sym].is_a?(Hash) &&
-             Legion::Settings[:extensions][ext_name.to_sym].key?(:enabled) &&
-             !Legion::Settings[:extensions][ext_name.to_sym][:enabled]
+          if ext_settings.is_a?(Hash) && ext_settings.key?(:enabled) && !ext_settings[:enabled]
             Legion::Logging.info "Skipping #{gem_name} because it's disabled"
             next
           end
@@ -239,7 +236,7 @@ module Legion
         extension.extend Legion::Extensions::Core unless extension.singleton_class.include?(Legion::Extensions::Core)
 
         ext_name = entry[:segments].join('_')
-        ext_settings = Legion::Settings[:extensions][ext_name.to_sym]
+        ext_settings = extension_settings_for_entry(entry)
         min_version = ext_settings[:min_version] if ext_settings.is_a?(Hash)
         if min_version.is_a?(String)
           begin
@@ -427,8 +424,9 @@ module Legion
       end
 
       def hook_actor(extension:, extension_name:, actor_class:, size: 1, **opts)
-        size = if Legion::Settings[:extensions].key?(extension_name.to_sym) && Legion::Settings[:extensions][extension_name.to_sym].key?(:workers)
-                 Legion::Settings[:extensions][extension_name.to_sym][:workers]
+        ext_settings = extension_settings_for_actor(extension_name, opts[:settings_path])
+        size = if ext_settings.is_a?(Hash) && ext_settings.key?(:workers)
+                 ext_settings[:workers]
                elsif size.is_a? Integer
                  size
                else
@@ -595,7 +593,7 @@ module Legion
 
       def resolve_subscription_worker_count(actor_hash)
         ext_name = actor_hash[:extension_name]
-        ext_settings = Legion::Settings.dig(:extensions, ext_name.to_sym)
+        ext_settings = extension_settings_for_actor(ext_name, actor_hash[:settings_path])
         if ext_settings.is_a?(Hash) && ext_settings.key?(:workers)
           ext_settings[:workers]
         elsif actor_hash[:size].is_a?(Integer)
@@ -606,8 +604,7 @@ module Legion
       end
 
       def resolve_remote_invocable(extension_name, opts = {})
-        ext_key = extension_name.to_sym
-        ext_settings = Legion::Settings.dig(:extensions, ext_key)
+        ext_settings = extension_settings_for_actor(extension_name, opts[:settings_path])
         runner_name = opts[:actor_name]&.to_sym
 
         # 1. Per-runner settings override
@@ -760,7 +757,7 @@ module Legion
       end
 
       def legacy_ai_extension_names
-        %w[azure-ai bedrock claude foundry gemini llm-gateway ollama openai xai].freeze
+        %w[azure-ai bedrock claude foundry gemini ollama openai xai].freeze
       end
 
       def service_extension_names
@@ -914,6 +911,7 @@ module Legion
         entry = @extensions&.find { |candidate| candidate[:gem_name] == gem_name }
         raise "#{gem_name} failed to reload" if entry && !load_extension(entry)
 
+        refresh_llm_provider_registry(gem_name)
         update_extension_handle(gem_name, state: :running, reload_state: :idle, last_error: nil,
                                           latest_installed_version: latest_installed_version(gem_name))
         true
@@ -926,6 +924,13 @@ module Legion
         @extension_handle_registry ||= HandleRegistry.new
       end
 
+      def refresh_llm_provider_registry(gem_name)
+        return unless gem_name.start_with?('lex-llm-') && gem_name != 'lex-llm-ledger'
+        return unless defined?(Legion::LLM::Call::Providers)
+
+        Legion::LLM::Call::Providers.rediscover_all_providers
+      end
+
       def transition_loaded_extensions(state)
         @loaded_extensions&.each do |name|
           Catalog.transition(name, state)
@@ -955,6 +960,21 @@ module Legion
         nil
       end
 
+      def extension_settings_for_entry(entry)
+        extension_settings_for_path(entry[:settings_path])
+      end
+
+      def extension_settings_for_actor(extension_name, settings_path)
+        extension_settings_for_path(settings_path) || Legion::Settings.dig(:extensions, extension_name.to_sym)
+      end
+
+      def extension_settings_for_path(settings_path)
+        path = Array(settings_path).map(&:to_sym)
+        return nil if path.empty?
+
+        Legion::Settings.dig(:extensions, *path)
+      end
+
       def reset_runner_cache
         return unless defined?(Legion::Ingress) && Legion::Ingress.respond_to?(:reset_runner_cache!)
 
@@ -1119,7 +1139,16 @@ module Legion
         end
 
         { gem_name: gem_name, category: category, tier: tier,
-          segments: segments, const_path: const_path, require_path: require_path }
+          segments: segments, const_path: const_path, require_path: require_path,
+          settings_path: settings_path_for_entry(segments, nesting) }
+      end
+
+      def settings_path_for_entry(segments, nesting)
+        if nesting
+          segments.map(&:to_sym)
+        else
+          [segments.join('_').to_sym]
+        end
       end
 
       def probe_nesting(gem_name, segments)

data/lib/legion/service.rb

@@ -209,7 +209,7 @@ module Legion
     def setup_local_mode
       if lite_mode?
         log.info 'Starting in lite mode (zero infrastructure)'
-        Legion::Settings[:dev] = true
+        Legion::Settings.set_prop(:dev, true)
         require 'legion/transport/local'
         require 'legion/crypt/mock_vault' if defined?(Legion::Crypt)
         return
@@ -218,7 +218,7 @@ module Legion
       return unless local_mode?
 
       log.info 'Starting in local development mode'
-      Legion::Settings[:dev] = true
+      Legion::Settings.set_prop(:dev, true)
 
       require 'legion/transport/local'
       require 'legion/crypt/mock_vault'

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.9.18'
+  VERSION = '1.9.23'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.9.18
+  version: 1.9.23
 platform: ruby
 authors:
 - Esity
@@ -253,14 +253,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.19
+        version: 1.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.6.19
+        version: 1.8.0
 - !ruby/object:Gem::Dependency
   name: legion-json
   requirement: !ruby/object:Gem::Requirement
@@ -351,14 +351,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.47
+        version: 0.9.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.47
+        version: 0.9.1
 - !ruby/object:Gem::Dependency
   name: legion-tty
   requirement: !ruby/object:Gem::Requirement