legionio 1.9.2 → 1.9.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dee00872a482d84ca7cffed624add4a568595383b31d93ffe1983d5bfb89d91
-  data.tar.gz: 0e8eaba327808c586a3cdf6d9e8da177831ac0ce9f5fb1919de115f48b63346f
+  metadata.gz: 1ddd3ea28ab0a066f4e3bc7d7fa6f7016ac1b395eec931a76ece7bc3722f04f8
+  data.tar.gz: 4c97638f1e52579b2351023fa21c36974412ab60c126fe8825c72f2d22466516
 SHA512:
-  metadata.gz: 7b7124a1ed4fa62aaa5da4e55391961973435b324cc17142245c52af7b32d43d6f7c161341f12d27aca47310dc9e6289a3d1a4d781561b001baa724c03ddc8ba
-  data.tar.gz: 952d0045d985d1f14ac76e15e015fa8bd279ed92ae123cd43e7f5139ed7efbee9a3cba93856ce2f6c8603e74f9549495e415fcd8459a27d3b35cb169eebec617
+  metadata.gz: 5641aa16fb0c352632286285433596060ac046c1300c9083f0bf851afea6bca5e9626f41984cdd2b5586346a7515dbf6e11ea288555f5a57c543adca5fd1f52c
+  data.tar.gz: d3e33ed0f6fb0bb5da8688705ef13bfe95841b74faa4e06103d462fccf9771714f1d9efc28f0017cc10f1ad0310560f66c0468d3912d7d23ab8c34359e2abec0

data/.gitignore

@@ -1,6 +1,7 @@
 /.bundle/
 /.yardoc
 Gemfile.lock
+*.gem
 /_yardoc/
 /coverage/
 /doc/

data/CHANGELOG.md

@@ -2,6 +2,111 @@
 
 ## [Unreleased]
 
+## [1.9.18] - 2026-04-29
+
+### Fixed
+- API-submitted LLM tools now build native `Legion::LLM::Types::ToolDefinition` objects instead of attempting to require RubyLLM at runtime.
+- Provider route coverage now locks LegionIO's `/api/llm/providers` compatibility response ahead of later colliding LLM library route registrations.
+
+## [1.9.17] - 2026-04-29
+
+### Fixed
+- LegionIO now requires `legion-llm >= 0.8.47` and only uses a local sibling `legion-llm` checkout when it satisfies that release floor, preventing stale local worktrees from breaking Bundler resolution.
+- Native LLM provider health API responses now preserve model, type, health, and instance fields when inventory offerings are loaded from string-keyed data.
+
+## [1.9.16] - 2026-04-28
+
+### Fixed
+- LegionIO now requires `legion-llm >= 0.8.44` so packaged installs include the unified identity migration for LLM caller metadata and Broker token audit context.
+
+## [1.9.15] - 2026-04-28
+
+### Fixed
+- The static extension catalog now classifies `lex-llm-gateway` as legacy compatibility, and setup pack tests explicitly prevent it from returning to default LLM or agentic installs.
+- README LLM documentation now calls out `lex-llm-gateway` as legacy-only compatibility glue that is not installed by default.
+
+## [1.9.14] - 2026-04-28
+
+### Fixed
+- LegionIO now requires `legion-tty >= 0.5.4` so packaged installs include the Legion-native LLM probe instead of the legacy direct RubyLLM probe.
+
+## [1.9.13] - 2026-04-28
+
+### Fixed
+- LegionIO now requires `legion-llm >= 0.8.43` so packaged installs get the optional RubyLLM compatibility layer and native dispatch fallback defaults.
+
+## [1.9.12] - 2026-04-28
+
+### Fixed
+- LegionIO now requires `legion-llm >= 0.8.42` so packaged installs resolve the validated LLM routing uplift release.
+
+## [1.9.11] - 2026-04-28
+
+### Fixed
+- LLM chat API routing now prefers native `Legion::LLM.chat` even when legacy `lex-llm-gateway` compatibility code is loaded.
+
+## [1.9.10] - 2026-04-28
+
+### Fixed
+- LLM provider health endpoints and CLI health checks now use the native `legion-llm` provider inventory before falling back to legacy `lex-llm-gateway` provider stats.
+
+## [1.9.9] - 2026-04-28
+
+### Fixed
+- Registry governance and security scanning now accept nested `lex-*` extension gem names such as `lex-llm-openai` and `lex-llm-azure-foundry`.
+
+## [1.9.8] - 2026-04-28
+
+### Fixed
+- The `agentic` setup pack now installs the Legion-native `lex-llm-*` provider stack without also installing retired legacy LLM provider gems.
+- Role profiles now treat `lex-llm-*` gems as the active AI extension set and exclude legacy LLM providers from default `core`, `dev`, and `cognitive` profile loading.
+- LegionIO now requires `legion-llm >= 0.8.41` so packaged installs get the router dependency cleanup that removes retired legacy provider runtime dependencies.
+
+## [1.9.7] - 2026-04-28
+
+### Fixed
+- Extension discovery now maps `lex-llm-azure-foundry` to `Legion::Extensions::Llm::AzureFoundry` and `legion/extensions/llm/azure_foundry`.
+- LegionIO now requires `legion-llm >= 0.8.40` so packaged installs include the native provider bridge needed by the Legion-native LLM stack.
+- README LLM provider documentation now describes the `lex-llm-*` provider stack instead of the retired legacy provider list.
+
+## [1.9.6] - 2026-04-28
+
+### Fixed
+- LLM API gateway checks now use the `Legion::Extensions::Llm::Gateway` namespace loaded by Legion extension autoloading.
+- LLM inference and skill invocation routes now call the current `Legion::LLM::Inference` request/executor API instead of the retired pipeline constants.
+- `legionio llm ping` now routes through `Legion::LLM.ask_direct` instead of bypassing Legion routing with a raw RubyLLM call.
+- API client tool construction now degrades cleanly when the RubyLLM tool base is unavailable.
+
+## [1.9.5] - 2026-04-28
+
+### Added
+- Extension catalog, setup packs, and local development wiring now include the Legion-native `lex-llm` provider stack, including Bedrock, Azure Foundry, and Vertex hosted provider extensions.
+
+### Fixed
+- Local development Gemfile wiring now includes guarded `lex-llm-ledger` resolution so the local bundle matches the LLM setup pack.
+- Local development Gemfile wiring now points `lex-llm-gateway` at the workspace extension path actually used by LegionIO checkouts.
+- Default setup packs no longer install legacy `lex-llm-gateway`; the extension catalog now labels it as compatibility glue rather than active LLM routing.
+- `require 'legion/extensions'` now loads its logging dependency directly instead of relying on `require 'legion'` order.
+
+## [1.9.4] - 2026-04-27
+
+### Added
+- Extension boot now runs a dedicated LLM load phase so `lex-llm` loads before any `lex-llm-*` extension gems.
+- `/api/health` now reports `uptime_seconds` and `uptime` for dashboard and monitor consumers. Fixes #168
+- `/api/extensions` now returns a flat loaded-extension summary for dashboard consumers. Fixes #169
+
+### Fixed
+- `legionio doctor` no longer reports extension-loader config keys as missing `lex-*` gems. Fixes #157
+- `/api/metering` now returns dashboard headline totals instead of the routing breakdown shape. Fixes #170
+- Extension autobuild now runs per-extension data migrations when migration files are present, even when an extension does not opt into general data models. Fixes #171
+- `/api/webhooks` now loads its `Legion::Webhooks` runtime dependency before route handlers execute. Fixes #172
+- `/api/tenants` now passes positional response data and uses `json_error` for missing tenants. Fixes #173
+
+## [1.9.3] - 2026-04-27
+
+### Fixed
+- Extension catalog persistence now skips no-op startup updates when the stored state already matches, reducing local SQLite write churn. Fixes #176
+
 ## [1.9.2] - 2026-04-27
 
 ### Fixed

data/Gemfile

@@ -4,16 +4,51 @@ source 'https://rubygems.org'
 
 gemspec
 
+def local_gem_version(path, version_file)
+  version_path = File.expand_path(File.join(path, version_file), __dir__)
+  return unless File.file?(version_path)
+
+  version_source = File.read(version_path)
+  version_source[/VERSION\s*=\s*['"]([^'"]+)['"]/, 1]
+end
+
+def local_gem_satisfies?(path, version_file, requirement)
+  version = local_gem_version(path, version_file)
+  version && Gem::Requirement.new(requirement).satisfied_by?(Gem::Version.new(version))
+end
+
+def local_gem_path(name, default_path, version_file, requirement)
+  env_name = "#{name.upcase.tr('-', '_')}_PATH"
+  env_path = ENV.fetch(env_name, nil)
+  return env_path if env_path && File.exist?(File.expand_path(env_path, __dir__))
+
+  return unless File.exist?(File.expand_path(default_path, __dir__))
+  return unless local_gem_satisfies?(default_path, version_file, requirement)
+
+  default_path
+end
+
 gem 'legion-data', path: '../legion-data' if File.exist?(File.expand_path('../legion-data', __dir__))
 gem 'legion-gaia', path: '../legion-gaia' if File.exist?(File.expand_path('../legion-gaia', __dir__))
-gem 'legion-llm', path: '../legion-llm' if File.exist?(File.expand_path('../legion-llm', __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-llm-gateway', path: '../extensions-core/lex-llm-gateway' if File.exist?(File.expand_path('../extensions-core/lex-llm-gateway', __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 'pg'

data/README.md

@@ -18,7 +18,7 @@ Schedule tasks, chain services into dependency graphs, run them concurrently via
 [![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.4-red.svg)](https://www.ruby-lang.org/)
 [![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 
-**Ruby >= 3.4** | **v1.8.12** | **Apache-2.0** | [@Esity](https://github.com/Esity)
+**Ruby >= 3.4** | **v1.9.18** | **Apache-2.0** | [@Esity](https://github.com/Esity)
 
 ---
 
@@ -411,9 +411,9 @@ Access Vault secrets inline: `<%= Legion::Crypt.read('pushover/token') %>`
 
 Browse: [LegionIO GitHub](https://github.com/LegionIO) | [legionio topic](https://github.com/topics/legionio?l=ruby)
 
-### Core (16 operational extensions)
+### Core (14 operational extensions)
 
-`lex-node` `lex-tasker` `lex-conditioner` `lex-transformer` `lex-synapse` `lex-scheduler` `lex-health` `lex-log` `lex-ping` `lex-exec` `lex-lex` `lex-codegen` `lex-metering` `lex-telemetry` `lex-audit` `task_pruner`
+`lex-node` `lex-tasker` `lex-conditioner` `lex-transformer` `lex-scheduler` `lex-health` `lex-log` `lex-ping` `lex-exec` `lex-lex` `lex-codegen` `lex-metering` `lex-telemetry` `lex-task_pruner`
 
 ### Agentic (242 cognitive extensions)
 
@@ -429,11 +429,13 @@ Brain-modeled cognitive architecture. 20 core orchestration extensions plus 222
 
 Coordinated by [legion-gaia](https://github.com/LegionIO/legion-gaia), the cognitive coordination layer with tick-cycle scheduling, channel abstraction, and weighted routing across cognitive modules.
 
-### AI / LLM (7 provider extensions)
+### AI / LLM
 
-`lex-azure-ai` `lex-bedrock` `lex-claude` `lex-foundry` `lex-gemini` `lex-openai` `lex-xai`
+`legion-llm` `lex-llm` `lex-llm-anthropic` `lex-llm-azure-foundry` `lex-llm-bedrock` `lex-llm-gemini` `lex-llm-ledger` `lex-llm-mlx` `lex-llm-ollama` `lex-llm-openai` `lex-llm-vertex` `lex-llm-vllm`
 
-Powered by [legion-llm](https://github.com/LegionIO/legion-llm) with three-tier routing (local Ollama, fleet GPU servers, cloud APIs), intent-based dispatch, health tracking, and automatic model discovery.
+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.
 
 ### Service Integrations (8 common + 15 additional)
 
@@ -465,7 +467,7 @@ Control which extensions load at startup via `settings/legion.json`:
 | `core` | 14 core operational extensions only |
 | `cognitive` | core + all agentic extensions |
 | `service` | core + service + other integrations |
-| `dev` | core + AI + essential agentic (~20 extensions) |
+| `dev` | core + native LLM providers + essential agentic (~20 extensions) |
 | `custom` | only what's listed in `role.extensions` |
 
 Faster boot and lower memory footprint for dedicated worker roles.

data/legionio.gemspec

@@ -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.5.8'
-  spec.add_dependency 'legion-tty', '>= 0.4.35'
+  spec.add_dependency 'legion-llm', '>= 0.8.47'
+  spec.add_dependency 'legion-tty', '>= 0.5.4'
   spec.add_dependency 'lex-node'
 end

data/lib/legion/api/extensions.rb

@@ -5,6 +5,7 @@ module Legion
     module Routes
       module Extensions
         def self.registered(app)
+          register_loaded_summary_route(app)
           register_available_route(app)
           register_extension_routes(app)
           register_runner_routes(app)
@@ -12,6 +13,22 @@ module Legion
           register_invoke_route(app)
         end
 
+        def self.register_loaded_summary_route(app)
+          app.get '/api/extensions' do
+            items = Legion::Extensions.loaded_extension_modules.map do |mod|
+              version = mod.const_get(:VERSION, false).to_s if mod.const_defined?(:VERSION, false)
+              name = if mod.respond_to?(:lex_name)
+                       mod.lex_name
+                     else
+                       mod.name.to_s.split('::').last.to_s.downcase
+                     end
+              { name: name, module: mod.name, version: version }.compact
+            end
+
+            json_response(items)
+          end
+        end
+
         def self.register_available_route(app)
           app.get '/api/extension_catalog/available' do
             entries = Legion::Extensions::Catalog::Available.all
@@ -188,7 +205,7 @@ module Legion
               started_at: entry[:started_at]&.iso8601 }
           end
 
-          private :register_available_route, :register_extension_routes,
+          private :register_loaded_summary_route, :register_available_route, :register_extension_routes,
                   :register_runner_routes, :register_function_routes, :register_invoke_route
         end
       end

data/lib/legion/api/llm.rb

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
 require 'securerandom'
-require 'open3'
-require 'resolv'
-require 'ipaddr'
-require 'uri'
 
 module Legion
   class API < Sinatra::Base
@@ -29,89 +25,86 @@ module Legion
             end
 
             define_method(:gateway_available?) do
-              defined?(Legion::Extensions::LLM::Gateway::Runners::Inference)
+              defined?(Legion::Extensions::Llm::Gateway::Runners::Inference)
             end
 
-            define_method(:build_client_tool_class) do |tname, tdesc, tschema|
-              klass = Class.new(RubyLLM::Tool) do
-                description tdesc
-                define_method(:name) { tname }
-                tool_ref = tname
-                define_method(:execute) do |**kwargs|
-                  case tool_ref
-                  when 'sh'
-                    cmd = kwargs[:command] || kwargs[:cmd] || kwargs.values.first.to_s
-                    output, status = ::Open3.capture2e(cmd, chdir: Dir.pwd)
-                    "exit=#{status.exitstatus}\n#{output}"
-                  when 'file_read'
-                    path = kwargs[:path] || kwargs[:file_path] || kwargs.values.first.to_s
-                    ::File.exist?(path) ? ::File.read(path, encoding: 'utf-8') : "File not found: #{path}"
-                  when 'file_write'
-                    path = kwargs[:path] || kwargs[:file_path]
-                    content = kwargs[:content] || kwargs[:contents]
-                    ::File.write(path, content)
-                    "Written #{content.to_s.bytesize} bytes to #{path}"
-                  when 'file_edit'
-                    path = kwargs[:path] || kwargs[:file_path]
-                    old_text = kwargs[:old_text] || kwargs[:search]
-                    new_text = kwargs[:new_text] || kwargs[:replace]
-                    content = ::File.read(path, encoding: 'utf-8')
-                    content.sub!(old_text, new_text)
-                    ::File.write(path, content)
-                    "Edited #{path}"
-                  when 'list_directory'
-                    path = kwargs[:path] || kwargs[:dir] || Dir.pwd
-                    Dir.entries(path).reject { |e| e.start_with?('.') }.sort.join("\n")
-                  when 'grep'
-                    pattern = kwargs[:pattern] || kwargs[:query] || kwargs.values.first.to_s
-                    path = kwargs[:path] || Dir.pwd
-                    output, = ::Open3.capture2e('grep', '-rn', '--include=*.rb', pattern, path)
-                    output.lines.first(50).join
-                  when 'glob'
-                    pattern = kwargs[:pattern] || kwargs.values.first.to_s
-                    Dir.glob(pattern).first(100).join("\n")
-                  when 'web_fetch'
-                    url = kwargs[:url] || kwargs.values.first.to_s
-                    raw_length = (kwargs[:maxLength] || kwargs[:max_length])&.to_i
-                    max_length = raw_length&.positive? ? raw_length : nil
-                    parsed = begin
-                      URI.parse(url)
-                    rescue StandardError
-                      nil
-                    end
-                    raise 'Invalid or non-HTTP URL' unless parsed.is_a?(URI::HTTP)
-
-                    addr = begin
-                      ::Resolv.getaddress(parsed.host)
-                    rescue StandardError
-                      nil
-                    end
-                    if addr
-                      ip = ::IPAddr.new(addr)
-                      raise 'SSRF: private/loopback targets are not permitted' if
-                        ip.loopback? || ip.private? || ip.link_local?
-                    end
-                    require 'legion/cli/chat/web_fetch'
-                    content = Legion::CLI::Chat::WebFetch.fetch(url)
-                    max_length ? content[0, max_length] : content
-                  when 'web_search'
-                    query = kwargs[:query] || kwargs.values.first.to_s
-                    raw_results = (kwargs[:max_results] || kwargs[:maxResults]).to_i
-                    max_results = raw_results.positive? ? [raw_results, 50].min : 5
-                    require 'legion/cli/chat/web_search'
-                    results = Legion::CLI::Chat::WebSearch.search(query, max_results: max_results,
-                                                                         auto_fetch:  false)
-                    results[:results].map { |r| "### #{r[:title]}\n#{r[:url]}\n#{r[:snippet]}" }.join("\n\n")
-                  else
-                    "Tool #{tool_ref} is not executable server-side. Use a legion_ prefixed tool instead."
-                  end
-                rescue StandardError => e
-                  Legion::Logging.log_exception(e, payload_summary: "client tool #{tool_ref} failed", component_type: :api)
-                  "Tool error: #{e.message}"
+            define_method(:native_provider_stats_available?) do
+              defined?(Legion::LLM::Inventory) && Legion::LLM::Inventory.respond_to?(:providers)
+            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
+                []
+              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,
+                closed:    circuits.count('closed'),
+                open:      circuits.count('open'),
+                half_open: circuits.count('half_open')
+              }
+            end
+
+            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
-              klass.params(tschema) if tschema.is_a?(Hash) && tschema[:properties]
-              klass
+            end
+
+            define_method(:offering_value) do |offering, key|
+              next unless offering.respond_to?(:[])
+
+              offering[key] || offering[key.to_s]
+            end
+
+            define_method(:build_client_tool_class) do |tname, tdesc, tschema|
+              require 'legion/llm/types/tool_definition' unless defined?(Legion::LLM::Types::ToolDefinition)
+
+              Legion::LLM::Types::ToolDefinition.build(
+                name:        tname,
+                description: tdesc,
+                parameters:  tschema || {},
+                source:      { type: :client, executable: true }
+              )
             rescue StandardError => e
               Legion::Logging.log_exception(e, payload_summary: "build_client_tool_class failed for #{tname}", component_type: :api)
               nil
@@ -168,12 +161,12 @@ module Legion
             model      = body[:model]
             provider   = body[:provider]
 
-            # Route through full Legion pipeline when gateway is available
-            if gateway_available?
+            # 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',
+                runner_class: 'Legion::Extensions::Llm::Gateway::Runners::Inference',
                 function:     'chat',
                 source:       'api'
               )
@@ -307,8 +300,8 @@ module Legion
             streaming = body[:stream] == true && env['HTTP_ACCEPT']&.include?('text/event-stream')
 
             # Executor handles all registry tool injection — API only passes client-defined tools
-            require 'legion/llm/pipeline/request' unless defined?(Legion::LLM::Pipeline::Request)
-            require 'legion/llm/pipeline/executor' unless defined?(Legion::LLM::Pipeline::Executor)
+            require 'legion/llm/inference' unless defined?(Legion::LLM::Inference::Request) &&
+                                                  defined?(Legion::LLM::Inference::Executor)
 
             principal  = defined?(Legion::Identity::Request) && env['legion.principal']
             caller_ctx = if principal
@@ -318,7 +311,7 @@ module Legion
                          end
 
             caller_metadata = body[:metadata].is_a?(Hash) ? body[:metadata] : {}
-            req = Legion::LLM::Pipeline::Request.build(
+            req = Legion::LLM::Inference::Request.build(
               messages:        messages,
               system:          body[:system],
               routing:         { provider: provider, model: model },
@@ -329,7 +322,7 @@ module Legion
               stream:          streaming,
               cache:           { strategy: :default, cacheable: true }
             )
-            executor = Legion::LLM::Pipeline::Executor.new(req)
+            executor = Legion::LLM::Inference::Executor.new(req)
 
             if streaming
               content_type 'text/event-stream'
@@ -476,26 +469,17 @@ module Legion
         def self.register_providers(app)
           app.get '/api/llm/providers' do
             require_llm!
-            unless gateway_available? && defined?(Legion::Extensions::LLM::Gateway::Runners::ProviderStats)
-              halt 503, json_error('gateway_unavailable', 'LLM gateway is not loaded', status_code: 503)
-            end
 
-            stats = Legion::Extensions::LLM::Gateway::Runners::ProviderStats
             json_response({
-                            providers: stats.health_report,
-                            summary:   stats.circuit_summary
+                            providers: provider_health_report,
+                            summary:   provider_circuit_summary
                           })
           end
 
           app.get '/api/llm/providers/:name' do
             require_llm!
-            unless gateway_available? && defined?(Legion::Extensions::LLM::Gateway::Runners::ProviderStats)
-              halt 503, json_error('gateway_unavailable', 'LLM gateway is not loaded', status_code: 503)
-            end
 
-            stats = Legion::Extensions::LLM::Gateway::Runners::ProviderStats
-            detail = stats.provider_detail(provider: params[:name])
-            json_response(detail)
+            json_response(provider_detail(params[:name]))
           end
         end
 

data/lib/legion/api/metering.rb

@@ -5,6 +5,13 @@ module Legion
     module Routes
       module Metering
         def self.registered(app)
+          register_helpers(app)
+          register_summary_route(app)
+          register_rollup_route(app)
+          register_by_model_route(app)
+        end
+
+        def self.register_helpers(app)
           app.helpers do
             define_method(:require_metering!) do
               return if defined?(Legion::Extensions::Metering::Runners::Metering)
@@ -17,18 +24,29 @@ module Legion
                 Legion::Data.connected? && Legion::Data.connection.table_exists?(:metering_records)
             end
           end
+        end
 
+        def self.register_summary_route(app)
           app.get '/api/metering' do
             require_metering!
-            return json_response({ records: [], total: 0, note: 'metering_records table not available' }) unless metering_table?
+            unless metering_table?
+              return json_response({ total_cost_usd: 0.0, total_tokens: 0, total_requests: 0,
+                                     note: 'metering_records table not available' })
+            end
 
-            result = Legion::Extensions::Metering::Runners::Metering.routing_stats
-            json_response(result)
+            ds = Legion::Data.connection[:metering_records]
+            json_response({
+                            total_cost_usd: (ds.sum(:cost_usd) || 0).to_f,
+                            total_tokens:   (ds.sum(:total_tokens) || 0).to_i,
+                            total_requests: ds.count
+                          })
           rescue StandardError => e
             Legion::Logging.log_exception(e, payload_summary: 'GET /api/metering', component_type: :api)
-            json_response({ records: [], total: 0, error: e.message })
+            json_response({ total_cost_usd: 0.0, total_tokens: 0, total_requests: 0, error: e.message })
           end
+        end
 
+        def self.register_rollup_route(app)
           app.get '/api/metering/rollup' do
             require_metering!
             return json_response({ rollup: [], period: 'hourly', note: 'metering_records table not available' }) unless metering_table?
@@ -41,7 +59,9 @@ module Legion
             Legion::Logging.log_exception(e, payload_summary: 'GET /api/metering/rollup', component_type: :api)
             json_response({ rollup: [], period: 'hourly', error: e.message })
           end
+        end
 
+        def self.register_by_model_route(app)
           app.get '/api/metering/by_model' do
             require_metering!
             return json_response({ models: [], note: 'metering_records table not available' }) unless metering_table?
@@ -60,6 +80,8 @@ module Legion
             json_response({ models: [], error: e.message })
           end
         end
+
+        private_class_method :register_helpers, :register_summary_route, :register_rollup_route, :register_by_model_route
       end
     end
   end

data/lib/legion/api/skills.rb

@@ -64,13 +64,16 @@ module Legion
             conv_id = body[:conversation_id] || "conv_#{SecureRandom.hex(8)}"
             begin
               Legion::LLM::ConversationStore.set_skill_state(conv_id, skill_key: skill_name, resume_at: 0)
-              req = Legion::LLM::Pipeline::Request.build(
+              require 'legion/llm/inference' unless defined?(Legion::LLM::Inference::Request) &&
+                                                    defined?(Legion::LLM::Inference::Executor)
+
+              req = Legion::LLM::Inference::Request.build(
                 messages:        [{ role: :user, content: body[:initial_message] || 'start skill' }],
                 conversation_id: conv_id,
                 metadata:        (body[:metadata].is_a?(Hash) ? body[:metadata] : {}).merge(skill_invoke: true),
                 stream:          false
               )
-              result = Legion::LLM::Pipeline::Executor.new(req).call
+              result = Legion::LLM::Inference::Executor.new(req).call
               json_response({ conversation_id: conv_id, content: result.message[:content],
                               skill_name: skill_name })
             rescue StandardError => e

data/lib/legion/api/tenants.rb

@@ -9,7 +9,7 @@ module Legion
         def self.registered(app)
           app.get '/api/tenants' do
             tenants = Legion::Tenants.list
-            json_response(data: tenants)
+            json_response(tenants)
           end
 
           app.post '/api/tenants' do
@@ -24,13 +24,13 @@ module Legion
 
           app.get '/api/tenants/:tenant_id' do
             tenant = Legion::Tenants.find(params[:tenant_id])
-            halt 404, json_response(error: 'not_found') unless tenant
-            json_response(data: tenant)
+            halt 404, json_error('not_found', 'Tenant not found', status_code: 404) unless tenant
+            json_response(tenant)
           end
 
           app.post '/api/tenants/:tenant_id/suspend' do
             result = Legion::Tenants.suspend(tenant_id: params[:tenant_id])
-            json_response(data: result)
+            json_response(result)
           end
 
           app.get '/api/tenants/:tenant_id/quota/:resource' do
@@ -38,7 +38,7 @@ module Legion
               tenant_id: params[:tenant_id],
               resource:  params[:resource].to_sym
             )
-            json_response(data: result)
+            json_response(result)
           end
         end
       end

data/lib/legion/api/webhooks.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../webhooks'
+
 module Legion
   class API < Sinatra::Base
     module Routes

data/lib/legion/api.rb

@@ -67,6 +67,8 @@ require_relative 'api/graphql' if defined?(GraphQL)
 
 module Legion
   class API < Sinatra::Base
+    START_TIME = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
     helpers Legion::API::Helpers
     helpers Legion::API::Validators
 
@@ -105,7 +107,8 @@ module Legion
 
     # Health and readiness
     get '/api/health' do
-      json_response({ status: 'ok', version: Legion::VERSION })
+      uptime_seconds = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - START_TIME).to_i
+      json_response({ status: 'ok', version: Legion::VERSION, uptime_seconds: uptime_seconds, uptime: uptime_seconds })
     end
 
     get '/api/ready' do

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

@@ -19,7 +19,7 @@ module Legion
           param :provider, type: 'string', desc: 'Specific provider to check (optional)', required: false
 
           def execute(provider: nil)
-            return 'LLM gateway not available.' unless gateway_stats_available?
+            return 'LLM provider inventory not available.' unless provider_stats_available?
 
             if provider
               format_detail(provider.strip)
@@ -34,11 +34,11 @@ module Legion
           private
 
           def format_report
-            report = stats_module.health_report
+            report = provider_health_report
             return "Router not available: #{report[:error]}" if report.is_a?(Hash) && report[:error]
             return 'No providers configured.' if report.empty?
 
-            summary = stats_module.circuit_summary
+            summary = provider_circuit_summary(report)
             lines = ["Provider Health Report:\n"]
             lines << format_circuit_summary(summary) if summary.is_a?(Hash) && !summary[:error]
             lines << ''
@@ -47,8 +47,9 @@ module Legion
           end
 
           def format_detail(provider)
-            entry = stats_module.provider_detail(provider: provider.to_sym)
+            entry = provider_detail(provider)
             return "Router not available: #{entry[:error]}" if entry[:error]
+            return "Provider not found: #{provider}" if entry.empty?
 
             lines = ["Provider: #{entry[:provider]}\n"]
             lines << "  Circuit:    #{entry[:circuit]}"
@@ -65,17 +66,83 @@ module Legion
 
           def format_entry(entry)
             icon = entry[:healthy] ? '+' : '!'
-            format('  [%<icon>s] %<name>-15s circuit=%<circuit>s adj=%<adj>d',
+            suffix = +''
+            suffix << " offerings=#{entry[:offerings]}" if entry.key?(:offerings)
+            suffix << " models=#{entry[:models].length}" if entry[:models].respond_to?(:length)
+            format('  [%<icon>s] %<name>-15s circuit=%<circuit>s adj=%<adj>d%<suffix>s',
                    icon: icon, name: entry[:provider],
-                   circuit: entry[:circuit], adj: entry[:adjustment])
+                   circuit: entry[:circuit], adj: entry[:adjustment], suffix: suffix)
+          end
+
+          def provider_stats_available?
+            native_provider_stats_available? || gateway_stats_available?
+          end
+
+          def native_provider_stats_available?
+            defined?(Legion::LLM::Inventory) && Legion::LLM::Inventory.respond_to?(:providers)
+          end
+
+          def provider_health_report
+            return native_provider_health_report if native_provider_stats_available?
+
+            stats_module.health_report
+          end
+
+          def native_provider_health_report
+            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
+
+          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,
+              closed:    circuits.count('closed'),
+              open:      circuits.count('open'),
+              half_open: circuits.count('half_open')
+            }
+          end
+
+          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
+
+          def offering_value(offering, key)
+            return unless offering.respond_to?(:[])
+
+            offering[key] || offering[key.to_s]
           end
 
           def gateway_stats_available?
-            defined?(Legion::Extensions::LLM::Gateway::Runners::ProviderStats)
+            defined?(Legion::Extensions::Llm::Gateway::Runners::ProviderStats)
           end
 
           def stats_module
-            Legion::Extensions::LLM::Gateway::Runners::ProviderStats
+            Legion::Extensions::Llm::Gateway::Runners::ProviderStats
           end
         end
       end

data/lib/legion/cli/doctor/extensions_check.rb

@@ -4,6 +4,11 @@ module Legion
   module CLI
     class Doctor
       class ExtensionsCheck
+        LOADER_CONFIG_KEYS = %w[
+          agentic ai auto_install blocked categories core gaia identity
+          parallel_pool_size reserved_prefixes reserved_words
+        ].freeze
+
         def name
           'Extensions'
         end
@@ -38,7 +43,11 @@ module Legion
           exts = Legion::Settings[:extensions]
           return [] unless exts.is_a?(Hash) || exts.is_a?(Array)
 
-          exts.is_a?(Array) ? exts.map(&:to_s) : exts.keys.map(&:to_s)
+          if exts.is_a?(Array)
+            exts.map(&:to_s)
+          else
+            exts.keys.map(&:to_s).reject { |key| LOADER_CONFIG_KEYS.include?(key) }
+          end
         rescue StandardError => e
           Legion::Logging.warn("ExtensionsCheck#configured_extensions failed: #{e.message}") if defined?(Legion::Logging)
           []

data/lib/legion/cli/llm_command.rb

@@ -234,10 +234,15 @@ module Legion
           out.header("  Pinging #{name} (#{model})...") unless options[:json]
           t0 = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
 
-          response = RubyLLM.chat(model: model, provider: name).ask('Respond with only the word: pong')
+          response = Legion::LLM.ask_direct(
+            message:  'Respond with only the word: pong',
+            model:    model,
+            provider: name,
+            caller:   { source: 'cli', command: 'llm ping' }
+          )
           elapsed = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - t0) * 1000).round
 
-          content = response.content.to_s.strip
+          content = response_content(response)
           success = content.downcase.include?('pong')
 
           if success
@@ -255,6 +260,16 @@ module Legion
           { provider: name, status: 'error', message: e.message, model: model, latency_ms: elapsed }
         end
 
+        def response_content(response)
+          if response.respond_to?(:content)
+            response.content.to_s.strip
+          elsif response.is_a?(Hash)
+            (response[:content] || response['content'] || response[:response] || response['response']).to_s.strip
+          else
+            response.to_s.strip
+          end
+        end
+
         def show_status(out, data)
           out.header('LLM Status')
           out.detail({

data/lib/legion/cli/setup_command.rb

@@ -37,20 +37,27 @@ module Legion
             lex-agentic-imagination lex-agentic-inference lex-agentic-integration
             lex-agentic-language lex-agentic-learning lex-agentic-memory
             lex-agentic-self lex-agentic-social lex-apollo lex-audit lex-autofix
-            lex-azure-ai lex-bedrock lex-claude lex-codegen lex-coldstart
+            lex-codegen lex-coldstart
             lex-conditioner lex-cost-scanner lex-dataset lex-detect
-            lex-eval lex-exec lex-extinction lex-factory lex-finops lex-foundry
-            lex-gemini lex-governance lex-kerberos lex-knowledge lex-llm-gateway
+            lex-eval lex-exec lex-extinction lex-factory lex-finops
+            lex-governance lex-kerberos lex-knowledge lex-llm
+            lex-llm-anthropic lex-llm-azure-foundry lex-llm-bedrock
+            lex-llm-gemini lex-llm-ledger lex-llm-mlx
+            lex-llm-ollama lex-llm-openai lex-llm-vertex lex-llm-vllm
             lex-metering lex-mesh lex-microsoft_teams lex-mind-growth lex-node
-            lex-onboard lex-openai lex-pilot-infra-monitor
+            lex-onboard lex-pilot-infra-monitor
             lex-pilot-knowledge-assist lex-privatecore lex-prompt lex-react
             lex-swarm lex-swarm-github lex-synapse lex-telemetry lex-tick
-            lex-transformer lex-xai
+            lex-transformer
           ]
         },
         llm:      {
           description: 'LLM routing and provider integration (no cognitive stack)',
-          gems:        %w[legion-llm]
+          gems:        %w[
+            legion-llm lex-llm lex-llm-anthropic lex-llm-azure-foundry
+            lex-llm-bedrock lex-llm-gemini lex-llm-ledger lex-llm-mlx
+            lex-llm-ollama lex-llm-openai lex-llm-vertex lex-llm-vllm
+          ]
         },
         channels: {
           description: 'Channel adapters for chat platforms',

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

@@ -14,7 +14,7 @@ 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: 'core',     description: 'LLM gateway and routing' },
+          { 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' },
@@ -36,6 +36,16 @@ module Legion
           { name: 'lex-ollama',       category: 'ai',       description: 'Ollama local LLM provider integration' },
           { name: 'lex-openai',       category: 'ai',       description: 'OpenAI provider integration' },
           { name: 'lex-xai',          category: 'ai',       description: 'xAI Grok provider integration' },
+          { name: 'lex-llm',          category: 'ai',       description: 'Common LLM provider base and routing metadata' },
+          { name: 'lex-llm-anthropic', category: 'ai',      description: 'Anthropic LLM provider integration' },
+          { name: 'lex-llm-azure-foundry', category: 'ai',  description: 'Azure AI Foundry hosted LLM provider integration' },
+          { name: 'lex-llm-bedrock',  category: 'ai',       description: 'AWS Bedrock hosted LLM provider integration' },
+          { name: 'lex-llm-gemini',   category: 'ai',       description: 'Google Gemini LLM provider integration' },
+          { name: 'lex-llm-mlx',      category: 'ai',       description: 'Apple MLX local LLM provider integration' },
+          { name: 'lex-llm-ollama',   category: 'ai',       description: 'Ollama LLM provider integration' },
+          { name: 'lex-llm-openai',   category: 'ai',       description: 'OpenAI LLM provider integration' },
+          { name: 'lex-llm-vertex',   category: 'ai',       description: 'Google Vertex AI hosted LLM provider integration' },
+          { name: 'lex-llm-vllm',     category: 'ai',       description: 'vLLM OpenAI-compatible provider integration' },
           # agentic
           { name: 'lex-agentic-affect',       category: 'agentic', description: 'Affective state modeling' },
           { name: 'lex-agentic-attention',    category: 'agentic', description: 'Attentional focus and salience' },

data/lib/legion/extensions/catalog.rb

@@ -85,6 +85,8 @@ module Legion
             pending.each do |lex_name, new_state|
               existing = model.where(lex_name: lex_name).first
               if existing
+                next if existing.respond_to?(:state) && existing.state == new_state.to_s
+
                 existing.update(state: new_state.to_s, updated_at: now)
               else
                 model.insert(lex_name: lex_name, state: new_state.to_s, created_at: now, updated_at: now)

data/lib/legion/extensions/core.rb

@@ -72,7 +72,7 @@ module Legion
         @messages = {}
         build_settings
         build_transport
-        if Legion::Settings[:data][:connected] && data_required?
+        if Legion::Settings[:data][:connected] && (data_required? || data_migrations_available?)
           Legion::Logging.debug "[Core] building data for #{name}" if defined?(Legion::Logging)
           build_data
         end
@@ -91,6 +91,13 @@ module Legion
         false
       end
 
+      def data_migrations_available?
+        Dir[File.join(extension_path.to_s, 'data', 'migrations', '*.rb')].any?
+      rescue StandardError => e
+        log.debug "[Core] data migration discovery failed for #{name}: #{e.message}" if defined?(log)
+        false
+      end
+
       def transport_required?
         true
       end

data/lib/legion/extensions/helpers/segments.rb

@@ -6,8 +6,13 @@ module Legion
       module Segments
         module_function
 
+        COMPOUND_SUFFIXES = {
+          %w[llm azure foundry] => %w[llm azure_foundry]
+        }.freeze
+
         def derive_segments(gem_name)
-          gem_name.delete_prefix('lex-').split('-')
+          segments = gem_name.delete_prefix('lex-').split('-')
+          COMPOUND_SUFFIXES.fetch(segments, segments)
         end
 
         def derive_namespace(gem_name)

data/lib/legion/extensions.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'legion/logging'
 require 'legion/extensions/core'
 require 'legion/extensions/catalog'
 require 'legion/extensions/handle_registry'
@@ -29,11 +30,19 @@ module Legion
         find_extensions
 
         phases = group_by_phase
+        llm_base_entries, llm_extension_entries = extract_llm_extension_entries!(phases)
+        llm_phases_loaded = false
         phases.each do |phase_num, entries|
+          unless llm_phases_loaded || before_llm_extension_phase?(phase_num)
+            load_llm_extension_phases(llm_base_entries, llm_extension_entries)
+            llm_phases_loaded = true
+          end
+
           @pending_actors = Concurrent::Array.new
           load_phase_extensions(phase_num, entries)
           hook_phase_actors(phase_num)
         end
+        load_llm_extension_phases(llm_base_entries, llm_extension_entries) unless llm_phases_loaded
 
         transition_loaded_extensions(:running)
         Catalog.flush_persisted_transitions
@@ -350,6 +359,55 @@ module Legion
         end.sort_by(&:first)
       end
 
+      def load_llm_extension_phases(base_entries, extension_entries)
+        run_extension_phase(:llm_base, base_entries)
+
+        Legion::Logging.warn 'lex-llm-* extensions discovered without lex-llm; provider loading may fail' if base_entries.empty? && extension_entries.any?
+
+        run_extension_phase(:llm_extensions, extension_entries.sort_by { |entry| entry[:gem_name] })
+      end
+
+      def before_llm_extension_phase?(phase_num)
+        phase_num.is_a?(Numeric) && phase_num < 1
+      end
+
+      def run_extension_phase(phase_num, entries)
+        return if entries.empty?
+
+        @pending_actors = Concurrent::Array.new
+        load_phase_extensions(phase_num, entries)
+        hook_phase_actors(phase_num)
+      end
+
+      def extract_llm_extension_entries!(phases)
+        base_entries = []
+        extension_entries = []
+
+        phases.each do |(_, entries)|
+          entries.delete_if do |entry|
+            next false unless llm_extension_entry?(entry)
+
+            if llm_base_extension_entry?(entry)
+              base_entries << entry
+            else
+              extension_entries << entry
+            end
+            true
+          end
+        end
+        phases.reject! { |_, entries| entries.empty? }
+
+        [base_entries, extension_entries]
+      end
+
+      def llm_extension_entry?(entry)
+        llm_base_extension_entry?(entry) || entry[:gem_name].start_with?('lex-llm-')
+      end
+
+      def llm_base_extension_entry?(entry)
+        entry[:gem_name] == 'lex-llm'
+      end
+
       def group_pending_actors
         groups = { once: [], poll: [], every: [], loop: [], subscription: [] }
         @pending_actors.each do |actor|
@@ -677,12 +735,32 @@ module Legion
       end
 
       def core_extension_names
-        %w[codegen conditioner exec health lex llm-gateway log metering node ping scheduler tasker task_pruner telemetry
+        %w[codegen conditioner exec health lex log metering node ping scheduler tasker task_pruner telemetry
            transformer].freeze
       end
 
       def ai_extension_names
-        %w[claude gemini openai].freeze
+        native_llm_extension_names
+      end
+
+      def native_llm_extension_names
+        %w[
+          llm
+          llm-anthropic
+          llm-azure-foundry
+          llm-bedrock
+          llm-gemini
+          llm-ledger
+          llm-mlx
+          llm-ollama
+          llm-openai
+          llm-vertex
+          llm-vllm
+        ].freeze
+      end
+
+      def legacy_ai_extension_names
+        %w[azure-ai bedrock claude foundry gemini llm-gateway ollama openai xai].freeze
       end
 
       def service_extension_names
@@ -700,7 +778,10 @@ module Legion
       end
 
       def agentic_extension_names
-        known_gem_names = (core_extension_names + service_extension_names + other_extension_names + ai_extension_names).map { |n| "lex-#{n}" }
+        known_gem_names = (
+          core_extension_names + service_extension_names + other_extension_names +
+            ai_extension_names + legacy_ai_extension_names
+        ).map { |n| "lex-#{n}" }
         Array(@extensions).reject { |entry| known_gem_names.include?(entry[:gem_name]) }.map { |entry| entry[:gem_name] }
       end
 

data/lib/legion/registry/governance.rb

@@ -7,7 +7,7 @@ module Legion
         require_airb_approval:      false,
         auto_approve_risk_tiers:    %w[low],
         review_required_risk_tiers: %w[medium high critical],
-        naming_convention:          'lex-[a-z][a-z0-9_]*',
+        naming_convention:          'lex-[a-z][a-z0-9_]*(?:-[a-z][a-z0-9_]*)*',
         deprecation_notice_days:    30
       }.freeze
 

data/lib/legion/registry/security_scanner.rb

@@ -39,10 +39,11 @@ module Legion
       def naming_convention(name:, **_)
         return { check: :naming_convention, status: :skip, details: 'no name' } unless name
 
-        if name.match?(/\Alex-[a-z][a-z0-9_]*\z/)
+        if name.match?(/\Alex-[a-z][a-z0-9_]*(?:-[a-z][a-z0-9_]*)*\z/)
           { check: :naming_convention, status: :pass, details: name }
         else
-          { check: :naming_convention, status: :fail, details: "#{name} does not match lex-[a-z][a-z0-9_]*" }
+          { check: :naming_convention, status: :fail,
+            details: "#{name} does not match lex-[a-z][a-z0-9_]*(?:-[a-z][a-z0-9_]*)*" }
         end
       end
 

data/lib/legion/service.rb

@@ -451,6 +451,7 @@ module Legion
       log.info 'Setting up Legion::LLM'
       require 'legion/llm'
       Legion::Settings.merge_settings('llm', Legion::LLM::Settings.default)
+      preload_llm_providers
       Legion::LLM.start
       log.info 'Legion::LLM started'
     rescue LoadError => e
@@ -460,6 +461,40 @@ module Legion
       handle_exception(e, level: :warn, operation: 'service.setup_llm')
     end
 
+    def preload_llm_providers
+      require 'legion/extensions/llm'
+      gems = llm_provider_gems
+      gems.each do |gem_name, require_path|
+        require require_path
+        log.debug "[service] loaded #{gem_name}"
+      rescue LoadError => e
+        log.warn "[service] #{gem_name} failed to load: #{e.message}"
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: "service.preload_llm_provider.#{gem_name}")
+      end
+      registered = defined?(Legion::LLM::Call::Registry) ? Legion::LLM::Call::Registry.all_instances : []
+      log.info "[service] llm providers preloaded gems=#{gems.size} instances=#{registered.size}"
+    rescue LoadError => e
+      handle_exception(e, level: :warn, operation: 'service.preload_llm_providers', availability: 'lex-llm not installed')
+    rescue StandardError => e
+      handle_exception(e, level: :warn, operation: 'service.preload_llm_providers')
+    end
+
+    def llm_provider_gems
+      specs = if defined?(Bundler)
+                Bundler.load.specs.map { |s| s.respond_to?(:name) ? s.name : s[:name].to_s }
+              else
+                Gem::Specification.latest_specs.map(&:name)
+              end
+      specs.filter_map do |name|
+        next unless name.start_with?('lex-llm-') && name != 'lex-llm-ledger'
+
+        provider_name = name.delete_prefix('lex-llm-').tr('-', '_')
+        require_path = "legion/extensions/llm/#{provider_name}"
+        [name, require_path]
+      end
+    end
+
     def setup_gaia
       log.info 'Setting up Legion::Gaia'
       require 'legion/gaia'

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.9.18
 platform: ruby
 authors:
 - Esity
@@ -351,28 +351,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.8
+        version: 0.8.47
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.8
+        version: 0.8.47
 - !ruby/object:Gem::Dependency
   name: legion-tty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.35
+        version: 0.5.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.35
+        version: 0.5.4
 - !ruby/object:Gem::Dependency
   name: lex-node
   requirement: !ruby/object:Gem::Requirement