legionio 1.7.31 → 1.7.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 962639f3a96de99418ba1cb7feb2ba06b488776df2c2c3a1ec7dfd0d353e6759
-  data.tar.gz: 87f2e206fab455fac86e36efdc497ff67d4614bb0699be00eb146c764ef43797
+  metadata.gz: 839e777ef392bc9f9a005418901f90837a78e10dc16f4425788332f8098a449c
+  data.tar.gz: 81c74483a04d1e5ae46789b0648153df04e954b94415168063fb5831a67d83c5
 SHA512:
-  metadata.gz: ef4a6788ec894fe2107c834c470fc469d866d36e445618bee17d6149738e2b31ce49c708619f0aaff12d140e799a92562e5383e9515f6d88e1ce15bbaeb9834c
-  data.tar.gz: 3a8a85d88ba670d683c196de7e60c32f37650e3ce420869a5e7b781f0741dcadce758f6c42b6cdb71b61c32ca68ac23d05d1571b00f2b974423da8779d975b82
+  metadata.gz: 3828b5dc1f52bd1e1a1f6f1c63d5fe2fe148f019be8e24fdf58cc1c0c69c4788d99f64a119398d9d8209042e21ba47f48a24a9b8692227b5851113825dc7d3c1
+  data.tar.gz: 3e05508d0d71bbed405d18219f79e7e4745ab28be2e16755747822bc1ec0dae2b441b3810b6dd0c1ec42cef58ccfacea065e2b33588f1bc20d225c5e473f4415

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Legion Changelog
 
+## [1.7.33] - 2026-04-09
+
+### Added
+- Phase 8 prerequisites: `Broker.lease_for(name)` returns raw Lease, `Broker.renewer_for(name)` returns LeaseRenewer
+- `LeaseRenewer` now exposes `attr_reader :provider` for structured credential access
+- Non-renewing registration path: static API key providers (expires_at: nil, renewable: false) stored in `Concurrent::AtomicReference` without background LeaseRenewer thread
+- `Broker.refresh_credential(name)` for manual refresh of static credentials
+- `Broker.providers` and `Broker.leases` include both dynamic and static registrations
+- `register_provider_with_broker` in service.rb — winning auth provider auto-registered with Broker after identity resolution
+
+### Changed (Copilot review #126)
+- Renamed extension catalog routes from `/api/extensions` to `/api/extension_catalog` to eliminate route conflict with LexDispatch's `GET /api/extensions/:lex_name/:component_type/:component_name/:method_name` wildcard
+- Updated `GET /api/extension_catalog/available` (was `/api/extensions/available`)
+- Updated OpenAPI spec paths and `list_extensions` chat tool to match new route prefix
+- Froze individual entry hashes in `Catalog::Available::EXTENSIONS` via `.each(&:freeze).freeze`; `all`, `by_category`, and `find` now return dup copies to prevent caller mutation
+- Added explicit `require 'legion/api/helpers'` and `require 'legion/api/extensions'` to `spec/legion/api/extensions_spec.rb` for deterministic spec loading
+- Added `loader.settings[:data]`, `[:transport]`, and `[:extensions]` initialization to extensions spec `before(:all)` for isolation
+
+## [1.7.32] - 2026-04-09
+
+### Changed
+- Rewrote `/api/extensions` routes to use in-memory state from `Catalog` instead of database queries — no `require_data!` dependency
+- All extension routes now use `:name` (string identifier like `lex-node`) instead of numeric `:id` params
+- Added `GET /api/extensions/available` route backed by `Catalog::Available.all` (static ecosystem list, filterable by `?category=`)
+- Added `Legion::Extensions::Catalog::Available` module with 120+ known LEX gems organized by category
+- Extension helper methods (`find_extension_module`, `find_runner_info`, `runner_summaries`, `halt_not_found`) moved into `Legion::API::Helpers` for reuse across all API tests
+
 ## [1.7.31] - 2026-04-08
 
 ### Added

data/lib/legion/api/extensions.rb

@@ -5,87 +5,157 @@ module Legion
     module Routes
       module Extensions
         def self.registered(app)
+          register_available_route(app)
           register_extension_routes(app)
           register_runner_routes(app)
           register_function_routes(app)
+          register_invoke_route(app)
+        end
+
+        def self.register_available_route(app)
+          app.get '/api/extension_catalog/available' do
+            entries = Legion::Extensions::Catalog::Available.all
+            entries = entries.select { |e| e[:category] == params[:category] } if params[:category]
+            json_response(entries)
+          end
         end
 
         def self.register_extension_routes(app)
-          app.get '/api/extensions' do
-            require_data!
-            dataset = Legion::Data::Model::Extension.order(:id)
-            dataset = dataset.where(active: true) if params[:active] == 'true'
-            json_collection(dataset)
+          app.get '/api/extension_catalog' do
+            entries = Legion::Extensions::Catalog.all.map do |name, entry|
+              { name: name, state: entry[:state].to_s,
+                registered_at: entry[:registered_at]&.iso8601,
+                started_at: entry[:started_at]&.iso8601 }
+            end
+            entries = entries.select { |e| e[:state] == params[:state] } if params[:state]
+            json_response(entries)
           end
 
-          app.get '/api/extensions/:id' do
-            require_data!
-            ext = find_or_halt(Legion::Data::Model::Extension, params[:id])
-            json_response(ext.values)
+          app.get '/api/extension_catalog/:name' do
+            name = params[:name]
+            entry = Legion::Extensions::Catalog.entry(name)
+            halt_not_found("extension '#{name}' not found") unless entry
+
+            ext_mod = find_extension_module(name)
+            version = ext_mod&.const_defined?(:VERSION) ? ext_mod::VERSION : nil
+
+            runners = ext_mod ? runner_summaries(ext_mod) : []
+
+            json_response({
+              name:          name,
+              state:         entry[:state].to_s,
+              version:       version,
+              registered_at: entry[:registered_at]&.iso8601,
+              started_at:    entry[:started_at]&.iso8601,
+              runners:       runners
+            }.compact)
           end
         end
 
         def self.register_runner_routes(app)
-          app.get '/api/extensions/:id/runners' do
-            require_data!
-            find_or_halt(Legion::Data::Model::Extension, params[:id])
-            runners = Legion::Data::Model::Runner.where(extension_id: params[:id].to_i).order(:id)
-            json_collection(runners)
+          app.get '/api/extension_catalog/:name/runners' do
+            name = params[:name]
+            halt_not_found("extension '#{name}' not found") unless Legion::Extensions::Catalog.entry(name)
+
+            ext_mod = find_extension_module(name)
+            halt_not_found("extension '#{name}' not loaded") unless ext_mod
+
+            json_response(runner_summaries(ext_mod))
           end
 
-          app.get '/api/extensions/:id/runners/:runner_id' do
-            require_data!
-            find_or_halt(Legion::Data::Model::Extension, params[:id])
-            runner = find_or_halt(Legion::Data::Model::Runner, params[:runner_id])
-            json_response(runner.values)
+          app.get '/api/extension_catalog/:name/runners/:runner_name' do
+            name = params[:name]
+            halt_not_found("extension '#{name}' not found") unless Legion::Extensions::Catalog.entry(name)
+
+            ext_mod = find_extension_module(name)
+            halt_not_found("extension '#{name}' not loaded") unless ext_mod
+
+            info = find_runner_info(ext_mod, params[:runner_name])
+            halt_not_found("runner '#{params[:runner_name]}' not found") unless info
+
+            runner_mod = info[:runner_module]
+            functions = runner_mod.instance_methods(false).map(&:to_s)
+
+            json_response({
+                            name:         info[:runner_name],
+                            runner_class: info[:runner_class],
+                            functions:    functions
+                          })
           end
         end
 
-        def self.register_function_routes(app) # rubocop:disable Metrics/AbcSize
-          app.get '/api/extensions/:id/runners/:runner_id/functions' do
-            require_data!
-            find_or_halt(Legion::Data::Model::Extension, params[:id])
-            find_or_halt(Legion::Data::Model::Runner, params[:runner_id])
-            functions = Legion::Data::Model::Function.where(runner_id: params[:runner_id].to_i).order(:id)
-            json_collection(functions)
+        def self.register_function_routes(app)
+          app.get '/api/extension_catalog/:name/runners/:runner_name/functions' do
+            name = params[:name]
+            halt_not_found("extension '#{name}' not found") unless Legion::Extensions::Catalog.entry(name)
+
+            ext_mod = find_extension_module(name)
+            halt_not_found("extension '#{name}' not loaded") unless ext_mod
+
+            info = find_runner_info(ext_mod, params[:runner_name])
+            halt_not_found("runner '#{params[:runner_name]}' not found") unless info
+
+            functions = info[:runner_module].instance_methods(false).map do |m|
+              args = info.dig(:class_methods, m, :args)
+              { name: m.to_s, args: args }
+            end
+            json_response(functions)
           end
 
-          app.get '/api/extensions/:id/runners/:runner_id/functions/:function_id' do
-            require_data!
-            find_or_halt(Legion::Data::Model::Extension, params[:id])
-            find_or_halt(Legion::Data::Model::Runner, params[:runner_id])
-            func = find_or_halt(Legion::Data::Model::Function, params[:function_id])
-            json_response(func.values)
+          app.get '/api/extension_catalog/:name/runners/:runner_name/functions/:function_name' do
+            name = params[:name]
+            halt_not_found("extension '#{name}' not found") unless Legion::Extensions::Catalog.entry(name)
+
+            ext_mod = find_extension_module(name)
+            halt_not_found("extension '#{name}' not loaded") unless ext_mod
+
+            info = find_runner_info(ext_mod, params[:runner_name])
+            halt_not_found("runner '#{params[:runner_name]}' not found") unless info
+
+            func_sym = params[:function_name].to_sym
+            halt_not_found("function '#{params[:function_name]}' not found") unless info[:runner_module].method_defined?(func_sym, false)
+
+            args = info.dig(:class_methods, func_sym, :args)
+            json_response({ name: params[:function_name], runner: params[:runner_name], args: args })
           end
+        end
+
+        def self.register_invoke_route(app)
+          app.post '/api/extension_catalog/:name/runners/:runner_name/functions/:function_name/invoke' do
+            name = params[:name]
+            halt_not_found("extension '#{name}' not found") unless Legion::Extensions::Catalog.entry(name)
+
+            ext_mod = find_extension_module(name)
+            halt_not_found("extension '#{name}' not loaded") unless ext_mod
+
+            info = find_runner_info(ext_mod, params[:runner_name])
+            halt_not_found("runner '#{params[:runner_name]}' not found") unless info
+
+            func_sym = params[:function_name].to_sym
+            halt_not_found("function '#{params[:function_name]}' not found") unless info[:runner_module].method_defined?(func_sym, false)
 
-          app.post '/api/extensions/:id/runners/:runner_id/functions/:function_id/invoke' do
-            require_data!
-            path = "/api/extensions/#{params[:id]}/runners/#{params[:runner_id]}/functions/#{params[:function_id]}/invoke"
-            Legion::Logging.debug "API: POST #{path} params=#{params.keys}"
-            find_or_halt(Legion::Data::Model::Extension, params[:id])
-            runner = find_or_halt(Legion::Data::Model::Runner, params[:runner_id])
-            func = find_or_halt(Legion::Data::Model::Function, params[:function_id])
             body = parse_request_body
 
             result = Legion::Ingress.run(
-              payload: body, runner_class: runner.values[:namespace],
-              function: func.values[:name].to_sym, source: 'api',
+              payload:       body,
+              runner_class:  info[:runner_class],
+              function:      func_sym,
+              source:        'api',
               check_subtask: body.fetch(:check_subtask, true),
               generate_task: body.fetch(:generate_task, true)
             )
-            Legion::Logging.info "API: invoked function #{func.values[:name]} via runner #{runner.values[:namespace]}, task #{result[:task_id]}"
             json_response(result, status_code: 201)
           rescue NameError => e
-            Legion::Logging.warn "API POST /api/extensions invoke returned 422: #{e.message}"
             json_error('invalid_runner', e.message, status_code: 422)
           rescue StandardError => e
-            Legion::Logging.error "API POST /api/extensions invoke: #{e.class} — #{e.message}"
+            Legion::Logging.error "API POST /api/extension_catalog invoke: #{e.class} - #{e.message}" if defined?(Legion::Logging)
             json_error('execution_error', e.message, status_code: 500)
           end
         end
 
         class << self
-          private :register_extension_routes, :register_runner_routes, :register_function_routes
+          private :register_available_route, :register_extension_routes,
+                  :register_runner_routes, :register_function_routes, :register_invoke_route
         end
       end
     end

data/lib/legion/api/helpers.rb

@@ -101,6 +101,39 @@ module Legion
         halt 400, json_error('invalid_json', 'request body is not valid JSON', status_code: 400)
       end
 
+      def find_extension_module(lex_name)
+        short = lex_name.delete_prefix('lex-')
+        short_no_sep = short.tr('-', '_').delete('_')
+        Legion::Extensions.loaded_extension_modules.find do |mod|
+          parts = mod.name&.split('::')
+          mod_short = parts&.last&.downcase
+          mod_short == short.tr('-', '_') ||
+            mod_short == short.delete('-') ||
+            mod_short == short_no_sep
+        end
+      end
+
+      def find_runner_info(ext_mod, runner_name)
+        return nil unless ext_mod.respond_to?(:runners)
+
+        ext_mod.runners.values.find do |r|
+          r[:runner_name].to_s.downcase == runner_name.downcase
+        end
+      end
+
+      def runner_summaries(ext_mod)
+        return [] unless ext_mod.respond_to?(:runners)
+
+        ext_mod.runners.values.map do |r|
+          functions = r[:runner_module]&.instance_methods(false)&.map(&:to_s) || []
+          { name: r[:runner_name], runner_class: r[:runner_class], functions: functions }
+        end
+      end
+
+      def halt_not_found(message)
+        halt 404, json_error('not_found', message, status_code: 404)
+      end
+
       def find_or_halt(model_class, id)
         record = model_class[id.to_i]
         halt 404, json_error('not_found', "#{model_class.name.split('::').last} #{id} not found", status_code: 404) if record.nil?

data/lib/legion/api/openapi.rb

@@ -177,22 +177,23 @@ module Legion
             }
           },
           schemas:         {
-            Meta:               META_SCHEMA,
-            MetaCollection:     META_COLLECTION_SCHEMA,
-            ErrorResponse:      ERROR_SCHEMA,
-            DeletedResponse:    deleted_response_schema,
-            TaskObject:         task_object_schema,
-            TaskInput:          task_input_schema,
-            ExtensionObject:    extension_object_schema,
-            RunnerObject:       runner_object_schema,
-            FunctionObject:     function_object_schema,
-            NodeObject:         node_object_schema,
-            ScheduleObject:     schedule_object_schema,
-            ScheduleInput:      schedule_input_schema,
-            RelationshipObject: stub_object_schema('Relationship'),
-            ChainObject:        stub_object_schema('Chain'),
-            WorkerObject:       worker_object_schema,
-            WorkerInput:        worker_input_schema
+            Meta:                     META_SCHEMA,
+            MetaCollection:           META_COLLECTION_SCHEMA,
+            ErrorResponse:            ERROR_SCHEMA,
+            DeletedResponse:          deleted_response_schema,
+            TaskObject:               task_object_schema,
+            TaskInput:                task_input_schema,
+            ExtensionObject:          extension_object_schema,
+            RunnerObject:             runner_object_schema,
+            FunctionObject:           function_object_schema,
+            AvailableExtensionObject: available_extension_object_schema,
+            NodeObject:               node_object_schema,
+            ScheduleObject:           schedule_object_schema,
+            ScheduleInput:            schedule_input_schema,
+            RelationshipObject:       stub_object_schema('Relationship'),
+            ChainObject:              stub_object_schema('Chain'),
+            WorkerObject:             worker_object_schema,
+            WorkerInput:              worker_input_schema
           }
         }
       end
@@ -240,11 +241,12 @@ module Legion
         {
           type:       'object',
           properties: {
-            id:        { type: 'integer' },
-            name:      { type: 'string' },
-            namespace: { type: 'string' },
-            active:    { type: 'boolean' },
-            version:   { type: 'string', nullable: true }
+            name:          { type: 'string' },
+            state:         { type: 'string' },
+            version:       { type: 'string', nullable: true },
+            registered_at: { type: 'string', format: 'date-time', nullable: true },
+            started_at:    { type: 'string', format: 'date-time', nullable: true },
+            runners:       { type: 'array', items: { '$ref' => '#/components/schemas/RunnerObject' } }
           }
         }
       end
@@ -254,10 +256,9 @@ module Legion
         {
           type:       'object',
           properties: {
-            id:           { type: 'integer' },
-            extension_id: { type: 'integer' },
             name:         { type: 'string' },
-            namespace:    { type: 'string' }
+            runner_class: { type: 'string' },
+            functions:    { type: 'array', items: { type: 'string' } }
           }
         }
       end
@@ -267,14 +268,26 @@ module Legion
         {
           type:       'object',
           properties: {
-            id:        { type: 'integer' },
-            runner_id: { type: 'integer' },
-            name:      { type: 'string' }
+            name:   { type: 'string' },
+            runner: { type: 'string' },
+            args:   { type: 'object', nullable: true }
           }
         }
       end
       private_class_method :function_object_schema
 
+      def self.available_extension_object_schema
+        {
+          type:       'object',
+          properties: {
+            name:        { type: 'string' },
+            category:    { type: 'string' },
+            description: { type: 'string' }
+          }
+        }
+      end
+      private_class_method :available_extension_object_schema
+
       def self.node_object_schema
         {
           type:       'object',
@@ -370,6 +383,17 @@ module Legion
 
       # --- route path builders ---
 
+      def self.wrap_array(schema_ref)
+        {
+          type:       'object',
+          properties: {
+            data: { type: 'array', items: { '$ref' => "#/components/schemas/#{schema_ref}" } },
+            meta: { '$ref' => '#/components/schemas/Meta' }
+          }
+        }
+      end
+      private_class_method :wrap_array
+
       def self.wrap_data(schema_ref)
         {
           type:       'object',
@@ -520,28 +544,42 @@ module Legion
 
       def self.extension_paths
         {
-          '/api/extensions'                                                         => {
+          '/api/extension_catalog'                                                               => {
             get: {
               tags:        ['Extensions'],
-              summary:     'List extensions',
+              summary:     'List loaded extensions',
               operationId: 'listExtensions',
-              parameters:  PAGINATION_PARAMS + [
-                { name: 'active', in: 'query', description: 'Filter to active extensions only', required: false,
-                  schema: { type: 'boolean' } }
+              parameters:  [
+                { name: 'state', in: 'query', description: 'Filter by extension state (e.g. running)', required: false,
+                  schema: { type: 'string' } }
               ],
               responses:   {
-                '200' => ok_response('Extension list', wrap_collection('ExtensionObject')),
-                '401' => UNAUTH_RESPONSE,
-                '503' => { description: 'legion-data not connected' }
+                '200' => ok_response('Extension list', wrap_array('ExtensionObject')),
+                '401' => UNAUTH_RESPONSE
               }
             }
           },
-          '/api/extensions/{id}'                                                    => {
+          '/api/extension_catalog/available'                                                     => {
             get: {
               tags:        ['Extensions'],
-              summary:     'Get extension by ID',
+              summary:     'List all available extensions in the ecosystem registry',
+              operationId: 'listAvailableExtensions',
+              parameters:  [
+                { name: 'category', in: 'query', description: 'Filter by category (core, ai, agentic, identity, service, other)',
+                  required: false, schema: { type: 'string' } }
+              ],
+              responses:   {
+                '200' => ok_response('Available extension list', wrap_array('AvailableExtensionObject')),
+                '401' => UNAUTH_RESPONSE
+              }
+            }
+          },
+          '/api/extension_catalog/{name}'                                                        => {
+            get: {
+              tags:        ['Extensions'],
+              summary:     'Get extension by name',
               operationId: 'getExtension',
-              parameters:  [{ name: 'id', in: 'path', required: true, schema: { type: 'integer' } }],
+              parameters:  [{ name: 'name', in: 'path', required: true, schema: { type: 'string' } }],
               responses:   {
                 '200' => ok_response('Extension detail', wrap_data('ExtensionObject')),
                 '401' => UNAUTH_RESPONSE,
@@ -549,27 +587,27 @@ module Legion
               }
             }
           },
-          '/api/extensions/{id}/runners'                                            => {
+          '/api/extension_catalog/{name}/runners'                                                => {
             get: {
               tags:        ['Extensions'],
               summary:     'List runners for extension',
               operationId: 'listExtensionRunners',
-              parameters:  [{ name: 'id', in: 'path', required: true, schema: { type: 'integer' } }] + PAGINATION_PARAMS,
+              parameters:  [{ name: 'name', in: 'path', required: true, schema: { type: 'string' } }],
               responses:   {
-                '200' => ok_response('Runner list', wrap_collection('RunnerObject')),
+                '200' => ok_response('Runner list', wrap_array('RunnerObject')),
                 '401' => UNAUTH_RESPONSE,
                 '404' => NOT_FOUND_RESPONSE
               }
             }
           },
-          '/api/extensions/{id}/runners/{runner_id}'                                => {
+          '/api/extension_catalog/{name}/runners/{runner_name}'                                  => {
             get: {
               tags:        ['Extensions'],
-              summary:     'Get runner by ID',
+              summary:     'Get runner by name',
               operationId: 'getExtensionRunner',
               parameters:  [
-                { name: 'id', in: 'path', required: true, schema: { type: 'integer' } },
-                { name: 'runner_id', in: 'path', required: true, schema: { type: 'integer' } }
+                { name: 'name', in: 'path', required: true, schema: { type: 'string' } },
+                { name: 'runner_name', in: 'path', required: true, schema: { type: 'string' } }
               ],
               responses:   {
                 '200' => ok_response('Runner detail', wrap_data('RunnerObject')),
@@ -578,31 +616,31 @@ module Legion
               }
             }
           },
-          '/api/extensions/{id}/runners/{runner_id}/functions'                      => {
+          '/api/extension_catalog/{name}/runners/{runner_name}/functions'                        => {
             get: {
               tags:        ['Extensions'],
               summary:     'List functions for runner',
               operationId: 'listRunnerFunctions',
               parameters:  [
-                { name: 'id', in: 'path', required: true, schema: { type: 'integer' } },
-                { name: 'runner_id', in: 'path', required: true, schema: { type: 'integer' } }
-              ] + PAGINATION_PARAMS,
+                { name: 'name', in: 'path', required: true, schema: { type: 'string' } },
+                { name: 'runner_name', in: 'path', required: true, schema: { type: 'string' } }
+              ],
               responses:   {
-                '200' => ok_response('Function list', wrap_collection('FunctionObject')),
+                '200' => ok_response('Function list', wrap_array('FunctionObject')),
                 '401' => UNAUTH_RESPONSE,
                 '404' => NOT_FOUND_RESPONSE
               }
             }
           },
-          '/api/extensions/{id}/runners/{runner_id}/functions/{function_id}'        => {
+          '/api/extension_catalog/{name}/runners/{runner_name}/functions/{function_name}'        => {
             get: {
               tags:        ['Extensions'],
-              summary:     'Get function by ID',
+              summary:     'Get function by name',
               operationId: 'getRunnerFunction',
               parameters:  [
-                { name: 'id', in: 'path', required: true, schema: { type: 'integer' } },
-                { name: 'runner_id', in: 'path', required: true, schema: { type: 'integer' } },
-                { name: 'function_id', in: 'path', required: true, schema: { type: 'integer' } }
+                { name: 'name', in: 'path', required: true, schema: { type: 'string' } },
+                { name: 'runner_name', in: 'path', required: true, schema: { type: 'string' } },
+                { name: 'function_name', in: 'path', required: true, schema: { type: 'string' } }
               ],
               responses:   {
                 '200' => ok_response('Function detail', wrap_data('FunctionObject')),
@@ -611,15 +649,15 @@ module Legion
               }
             }
           },
-          '/api/extensions/{id}/runners/{runner_id}/functions/{function_id}/invoke' => {
+          '/api/extension_catalog/{name}/runners/{runner_name}/functions/{function_name}/invoke' => {
             post: {
               tags:        ['Extensions'],
               summary:     'Invoke a function directly',
               operationId: 'invokeFunction',
               parameters:  [
-                { name: 'id', in: 'path', required: true, schema: { type: 'integer' } },
-                { name: 'runner_id', in: 'path', required: true, schema: { type: 'integer' } },
-                { name: 'function_id', in: 'path', required: true, schema: { type: 'integer' } }
+                { name: 'name', in: 'path', required: true, schema: { type: 'string' } },
+                { name: 'runner_name', in: 'path', required: true, schema: { type: 'string' } },
+                { name: 'function_name', in: 'path', required: true, schema: { type: 'string' } }
               ],
               requestBody: {
                 required: false,

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

@@ -18,19 +18,19 @@ module Legion
           description 'List loaded Legion extensions and their runners/functions. ' \
                       'Use this to discover what capabilities are available, what extensions are active, ' \
                       'and what tasks can be triggered through the framework.'
-          param :extension_id, type: 'integer',
-                               desc: 'Show runners for a specific extension ID (optional)', required: false
-          param :active_only, type: 'string',
-                              desc: 'Set to "true" to show only active extensions (default: all)', required: false
+          param :extension_name, type: 'string',
+                                 desc: 'Show runners for a specific extension by name (e.g. lex-node)', required: false
+          param :state, type: 'string',
+                        desc: 'Filter by state (e.g. "running"). Default: all', required: false
 
           DEFAULT_PORT = 4567
           DEFAULT_HOST = '127.0.0.1'
 
-          def execute(extension_id: nil, active_only: nil)
-            if extension_id
-              fetch_extension_detail(extension_id)
+          def execute(extension_name: nil, state: nil)
+            if extension_name
+              fetch_extension_detail(extension_name)
             else
-              fetch_extension_list(active_only)
+              fetch_extension_list(state)
             end
           rescue Errno::ECONNREFUSED
             'Legion daemon not running (cannot query extensions API).'
@@ -41,9 +41,9 @@ module Legion
 
           private
 
-          def fetch_extension_list(active_only)
-            path = '/api/extensions'
-            path += '?active=true' if active_only == 'true'
+          def fetch_extension_list(state)
+            path = '/api/extension_catalog'
+            path += "?state=#{state}" if state
             data = api_get(path)
             return "API error: #{data[:error]}" if data[:error]
 
@@ -54,37 +54,35 @@ module Legion
             format_list(extensions)
           end
 
-          def fetch_extension_detail(ext_id)
-            ext_data = api_get("/api/extensions/#{ext_id}")
-            runners_data = api_get("/api/extensions/#{ext_id}/runners")
-
+          def fetch_extension_detail(name)
+            ext_data = api_get("/api/extension_catalog/#{name}")
             return "API error: #{ext_data[:error]}" if ext_data[:error]
 
+            runners_data = api_get("/api/extension_catalog/#{name}/runners")
             runners = runners_data[:data] || runners_data[:items] || runners_data
             runners = [runners] if runners.is_a?(Hash)
             runners = [] unless runners.is_a?(Array)
 
-            format_detail(ext_data, runners)
+            format_detail(ext_data[:data] || ext_data, runners)
           end
 
           def format_list(extensions)
             lines = ["Loaded Extensions (#{extensions.size}):\n"]
             extensions.each do |ext|
-              status = ext[:active] ? 'active' : 'inactive'
-              lines << "  #{ext[:id]}. #{ext[:name]} (#{status})"
+              lines << "  #{ext[:name]} (#{ext[:state]})"
             end
             lines.join("\n")
           end
 
           def format_detail(ext, runners)
-            lines = ["Extension: #{ext[:name]} (id: #{ext[:id]})\n"]
-            lines << "  Status: #{ext[:active] ? 'active' : 'inactive'}"
-            lines << "  Namespace: #{ext[:namespace]}" if ext[:namespace]
+            lines = ["Extension: #{ext[:name]}\n"]
+            lines << "  State: #{ext[:state]}"
+            lines << "  Version: #{ext[:version]}" if ext[:version]
 
             if runners.any?
               lines << "\n  Runners (#{runners.size}):"
               runners.each do |r|
-                lines << "    #{r[:id]}. #{r[:name] || r[:namespace]}"
+                lines << "    #{r[:name]} (#{r[:runner_class]})"
               end
             else
               lines << "\n  No runners registered."

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Catalog
+      module Available
+        EXTENSIONS = [
+          # core
+          { name: 'lex-acp', category: 'core', description: 'Agent communication protocol' },
+          { name: 'lex-audit',        category: 'core',     description: 'Audit logging and trail' },
+          { name: 'lex-codegen',      category: 'core',     description: 'Code generation pipeline' },
+          { name: 'lex-conditioner',  category: 'core',     description: 'Task chain conditioning' },
+          { name: 'lex-detect',       category: 'core',     description: 'Environment detection and recommendations' },
+          { 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-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' },
+          { name: 'lex-node',         category: 'core',     description: 'Node identity and registration' },
+          { name: 'lex-ping',         category: 'core',     description: 'Connectivity checks' },
+          { name: 'lex-react',        category: 'core',     description: 'Event-driven reaction engine' },
+          { name: 'lex-scheduler',    category: 'core',     description: 'Cron and interval scheduling' },
+          { name: 'lex-synapse',      category: 'core',     description: 'Agent-to-agent relationships' },
+          { name: 'lex-tasker',       category: 'core',     description: 'Task management and lifecycle' },
+          { name: 'lex-telemetry',    category: 'core',     description: 'OpenTelemetry tracing integration' },
+          { name: 'lex-transformer',  category: 'core',     description: 'Task chain transformation' },
+          { name: 'lex-webhook',      category: 'core',     description: 'Inbound webhook receiver' },
+          # ai
+          { name: 'lex-azure-ai',     category: 'ai',       description: 'Azure OpenAI provider integration' },
+          { name: 'lex-bedrock',      category: 'ai',       description: 'AWS Bedrock LLM provider integration' },
+          { name: 'lex-claude',       category: 'ai',       description: 'Anthropic Claude provider integration' },
+          { name: 'lex-foundry',      category: 'ai',       description: 'Azure AI Foundry provider integration' },
+          { name: 'lex-gemini',       category: 'ai',       description: 'Google Gemini provider integration' },
+          { 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' },
+          # agentic
+          { name: 'lex-agentic-affect',       category: 'agentic', description: 'Affective state modeling' },
+          { name: 'lex-agentic-attention',    category: 'agentic', description: 'Attentional focus and salience' },
+          { name: 'lex-agentic-defense',      category: 'agentic', description: 'Defensive behavior and threat response' },
+          { name: 'lex-agentic-executive',    category: 'agentic', description: 'Executive function and planning' },
+          { name: 'lex-agentic-homeostasis',  category: 'agentic', description: 'Internal state regulation' },
+          { name: 'lex-agentic-imagination',  category: 'agentic', description: 'Generative imagination and hypothesis' },
+          { name: 'lex-agentic-inference',    category: 'agentic', description: 'Probabilistic inference engine' },
+          { name: 'lex-agentic-integration',  category: 'agentic', description: 'Cross-domain knowledge integration' },
+          { name: 'lex-agentic-language',     category: 'agentic', description: 'Natural language understanding' },
+          { name: 'lex-agentic-learning',     category: 'agentic', description: 'Online learning and adaptation' },
+          { name: 'lex-agentic-memory',       category: 'agentic', description: 'Long-term memory and recall' },
+          { name: 'lex-agentic-self',         category: 'agentic', description: 'Self-model and identity' },
+          { name: 'lex-agentic-social',       category: 'agentic', description: 'Social cognition and theory of mind' },
+          { name: 'lex-adapter',              category: 'agentic', description: 'Protocol and format adaptation' },
+          { name: 'lex-apollo',               category: 'agentic', description: 'Shared knowledge store client' },
+          { name: 'lex-autofix',              category: 'agentic', description: 'Autonomous code fix pipeline' },
+          { name: 'lex-coldstart',            category: 'agentic', description: 'Bootstrap knowledge ingestion' },
+          { name: 'lex-cost-scanner',         category: 'agentic', description: 'Cloud cost scanning and analysis' },
+          { name: 'lex-dataset',              category: 'agentic', description: 'Dataset management and versioning' },
+          { name: 'lex-eval',                 category: 'agentic', description: 'LLM evaluation framework' },
+          { name: 'lex-extinction',           category: 'agentic', description: 'Worker lifecycle termination' },
+          { name: 'lex-factory',              category: 'agentic', description: 'Spec-to-code generation pipeline' },
+          { name: 'lex-finops',               category: 'agentic', description: 'FinOps cost optimization' },
+          { name: 'lex-governance',           category: 'agentic', description: 'Policy and compliance governance' },
+          { name: 'lex-knowledge',            category: 'agentic', description: 'Corpus ingestion and knowledge query' },
+          { name: 'lex-mesh',                 category: 'agentic', description: 'Agent mesh and preference exchange' },
+          { name: 'lex-mind-growth',          category: 'agentic', description: 'Autonomous cognitive expansion' },
+          { name: 'lex-onboard',              category: 'agentic', description: 'New agent onboarding workflow' },
+          { name: 'lex-pilot-infra-monitor',  category: 'agentic', description: 'Infrastructure monitoring pilot' },
+          { name: 'lex-pilot-knowledge-assist', category: 'agentic', description: 'Knowledge assist pilot worker' },
+          { name: 'lex-privatecore',          category: 'agentic', description: 'Private execution enclave' },
+          { name: 'lex-prompt',               category: 'agentic', description: 'Prompt management and versioning' },
+          { name: 'lex-swarm',                category: 'agentic', description: 'Multi-agent swarm orchestration' },
+          { name: 'lex-swarm-github',         category: 'agentic', description: 'GitHub code review swarm' },
+          { name: 'lex-tick',                 category: 'agentic', description: 'Gaia tick cycle driver' },
+          # identity
+          { name: 'lex-identity-approle',    category: 'identity', description: 'Vault AppRole identity provider' },
+          { name: 'lex-identity-aws',        category: 'identity', description: 'AWS IAM identity provider' },
+          { name: 'lex-identity-entra',      category: 'identity', description: 'Microsoft Entra identity provider' },
+          { name: 'lex-identity-github',     category: 'identity', description: 'GitHub App identity provider' },
+          { name: 'lex-identity-kerberos',   category: 'identity', description: 'Kerberos identity provider' },
+          { name: 'lex-identity-kubernetes', category: 'identity', description: 'Kubernetes service account identity provider' },
+          { name: 'lex-identity-ldap',       category: 'identity', description: 'LDAP identity provider' },
+          { name: 'lex-identity-system',     category: 'identity', description: 'System identity provider' },
+          # service integrations
+          { name: 'lex-consul',          category: 'service', description: 'HashiCorp Consul service mesh integration' },
+          { name: 'lex-github',          category: 'service', description: 'GitHub API integration' },
+          { name: 'lex-http',            category: 'service', description: 'Generic HTTP client runner' },
+          { name: 'lex-kerberos',        category: 'service', description: 'Kerberos authentication integration' },
+          { name: 'lex-microsoft_teams', category: 'service', description: 'Microsoft Teams messaging integration' },
+          { name: 'lex-nomad',           category: 'service', description: 'HashiCorp Nomad job integration' },
+          { name: 'lex-redis',           category: 'service', description: 'Redis integration' },
+          { name: 'lex-s3',              category: 'service', description: 'AWS S3 object storage integration' },
+          { name: 'lex-tfe',             category: 'service', description: 'Terraform Enterprise integration' },
+          { name: 'lex-uais',            category: 'service', description: 'UHG AI Services integration' },
+          { name: 'lex-vault',           category: 'service', description: 'HashiCorp Vault secrets integration' },
+          # other integrations
+          { name: 'lex-aha',                  category: 'other', description: 'Aha! roadmap integration' },
+          { name: 'lex-chef',                 category: 'other', description: 'Chef infrastructure automation' },
+          { name: 'lex-cloudflare',           category: 'other', description: 'Cloudflare DNS and CDN integration' },
+          { name: 'lex-discord',              category: 'other', description: 'Discord messaging integration' },
+          { name: 'lex-dns',                  category: 'other', description: 'DNS query and management' },
+          { name: 'lex-docker',               category: 'other', description: 'Docker container integration' },
+          { name: 'lex-dynatrace',            category: 'other', description: 'Dynatrace APM integration' },
+          { name: 'lex-elastic_app_search',   category: 'other', description: 'Elastic App Search integration' },
+          { name: 'lex-elasticsearch',        category: 'other', description: 'Elasticsearch integration' },
+          { name: 'lex-gitlab',               category: 'other', description: 'GitLab integration' },
+          { name: 'lex-google-calendar',      category: 'other', description: 'Google Calendar integration' },
+          { name: 'lex-grafana',              category: 'other', description: 'Grafana dashboard integration' },
+          { name: 'lex-home-assistant',       category: 'other', description: 'Home Assistant smart home integration' },
+          { name: 'lex-influxdb',             category: 'other', description: 'InfluxDB time series integration' },
+          { name: 'lex-infoblox',             category: 'other', description: 'Infoblox IPAM/DNS integration' },
+          { name: 'lex-jenkins',              category: 'other', description: 'Jenkins CI/CD integration' },
+          { name: 'lex-jfrog',                category: 'other', description: 'JFrog Artifactory integration' },
+          { name: 'lex-jira',                 category: 'other', description: 'Jira issue tracking integration' },
+          { name: 'lex-kafka',                category: 'other', description: 'Apache Kafka messaging integration' },
+          { name: 'lex-kubernetes',           category: 'other', description: 'Kubernetes cluster integration' },
+          { name: 'lex-lambda',               category: 'other', description: 'AWS Lambda function integration' },
+          { name: 'lex-memcached',            category: 'other', description: 'Memcached cache integration' },
+          { name: 'lex-mongodb',              category: 'other', description: 'MongoDB integration' },
+          { name: 'lex-mqtt',                 category: 'other', description: 'MQTT IoT messaging integration' },
+          { name: 'lex-openweathermap',       category: 'other', description: 'OpenWeatherMap weather integration' },
+          { name: 'lex-pagerduty',            category: 'other', description: 'PagerDuty alerting integration' },
+          { name: 'lex-pihole',               category: 'other', description: 'Pi-hole DNS filtering integration' },
+          { name: 'lex-postgres',             category: 'other', description: 'PostgreSQL database integration' },
+          { name: 'lex-prometheus',           category: 'other', description: 'Prometheus metrics integration' },
+          { name: 'lex-pushbullet',           category: 'other', description: 'Pushbullet notification integration' },
+          { name: 'lex-pushover',             category: 'other', description: 'Pushover notification integration' },
+          { name: 'lex-sftp',                 category: 'other', description: 'SFTP file transfer integration' },
+          { name: 'lex-slack',                category: 'other', description: 'Slack messaging integration' },
+          { name: 'lex-sleepiq',              category: 'other', description: 'SleepIQ bed sensor integration' },
+          { name: 'lex-smtp',                 category: 'other', description: 'SMTP email integration' },
+          { name: 'lex-sonos',                category: 'other', description: 'Sonos audio integration' },
+          { name: 'lex-sqs',                  category: 'other', description: 'AWS SQS queue integration' },
+          { name: 'lex-ssh',                  category: 'other', description: 'SSH remote execution integration' },
+          { name: 'lex-telegram',             category: 'other', description: 'Telegram messaging integration' },
+          { name: 'lex-todoist',              category: 'other', description: 'Todoist task management integration' },
+          { name: 'lex-twilio',               category: 'other', description: 'Twilio SMS/voice integration' },
+          { name: 'lex-wled',                 category: 'other', description: 'WLED LED controller integration' }
+        ].each(&:freeze).freeze
+
+        class << self
+          def all
+            EXTENSIONS.map(&:dup)
+          end
+
+          def by_category(category)
+            EXTENSIONS.select { |e| e[:category] == category }.map(&:dup)
+          end
+
+          def find(name)
+            entry = EXTENSIONS.find { |e| e[:name] == name }
+            entry&.dup
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/catalog.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'catalog/registry'
+require_relative 'catalog/available'
 
 module Legion
   module Extensions

data/lib/legion/identity/broker.rb

@@ -9,18 +9,25 @@ module Legion
 
       class << self
         def token_for(provider_name)
-          renewer = renewers[provider_name.to_sym]
-          return nil unless renewer
-
-          lease = renewer.current_lease
+          lease = lease_for(provider_name)
           lease&.valid? ? lease.token : nil
         end
 
-        def credentials_for(provider_name, service: nil)
-          renewer = renewers[provider_name.to_sym]
-          return nil unless renewer
+        def lease_for(provider_name)
+          name = provider_name.to_sym
+          renewer = renewers[name]
+          return renewer.current_lease if renewer
 
-          lease = renewer.current_lease
+          static_ref = static_leases[name]
+          static_ref&.get
+        end
+
+        def renewer_for(provider_name)
+          renewers[provider_name.to_sym]
+        end
+
+        def credentials_for(provider_name, service: nil)
+          lease = lease_for(provider_name)
           return nil unless lease&.valid?
 
           { token: lease.token, provider: provider_name.to_sym, service: service, lease: lease }
@@ -28,12 +35,37 @@ module Legion
 
         def register_provider(provider_name, provider:, lease:)
           name = provider_name.to_sym
+
           renewers[name]&.stop!
-          renewers[name] = LeaseRenewer.new(
-            provider_name: name,
-            provider:      provider,
-            lease:         lease
-          )
+          if lease&.expires_at.nil? && !lease&.renewable
+            # Static credential — store without a background renewal thread
+            renewers.delete(name)
+            static_leases[name] = Concurrent::AtomicReference.new(lease)
+            providers_map[name] = provider
+          else
+            # Dynamic credential — create LeaseRenewer
+            static_leases.delete(name)
+            renewers[name] = LeaseRenewer.new(
+              provider_name: name,
+              provider:      provider,
+              lease:         lease
+            )
+          end
+        end
+
+        def refresh_credential(provider_name)
+          name = provider_name.to_sym
+          ref  = static_leases[name]
+          return false unless ref
+
+          provider = providers_map[name]
+          return false unless provider.respond_to?(:provide_token)
+
+          new_lease = provider.provide_token
+          return false unless new_lease&.valid?
+
+          ref.set(new_lease)
+          true
         end
 
         def authenticated?
@@ -77,11 +109,13 @@ module Legion
         end
 
         def providers
-          renewers.keys
+          (renewers.keys + static_leases.keys).uniq
         end
 
         def leases
-          renewers.transform_values { |r| r.current_lease&.to_h }
+          dynamic = renewers.transform_values { |r| r.current_lease&.to_h }
+          static  = static_leases.transform_values { |ref| ref.get&.to_h }
+          dynamic.merge(static)
         end
 
         def shutdown
@@ -91,6 +125,8 @@ module Legion
             nil
           end
           renewers.clear
+          static_leases.clear
+          providers_map.clear
         end
 
         def reset!
@@ -105,6 +141,14 @@ module Legion
           @renewers ||= Concurrent::Hash.new
         end
 
+        def static_leases
+          @static_leases ||= Concurrent::Hash.new
+        end
+
+        def providers_map
+          @providers_map ||= Concurrent::Hash.new
+        end
+
         def fetch_groups
           process_groups = Identity::Process.identity_hash[:groups]
           return process_groups if process_groups && !process_groups.empty?

data/lib/legion/identity/lease_renewer.rb

@@ -5,7 +5,7 @@ require 'concurrent'
 module Legion
   module Identity
     class LeaseRenewer
-      attr_reader :provider_name
+      attr_reader :provider_name, :provider
 
       BACKOFF_SLEEP  = 5
       MIN_SLEEP      = 1

data/lib/legion/service.rb

@@ -1107,6 +1107,11 @@ module Legion
         identity = future.value
         Legion::Identity::Process.bind!(provider, identity)
         log.info "[Identity] resolved via #{provider.class.name}: #{identity[:canonical_name]}"
+
+        # Phase 8: Register winning auth provider with Broker so extensions can
+        # call Broker.token_for(:provider_name) without managing tokens themselves.
+        register_provider_with_broker(provider)
+
         true
       else
         false
@@ -1119,6 +1124,19 @@ module Legion
       pool&.kill unless pool&.wait_for_termination(2)
     end
 
+    def register_provider_with_broker(provider)
+      return unless provider.respond_to?(:provide_token) && defined?(Legion::Identity::Broker)
+
+      lease = provider.provide_token
+      return unless lease
+
+      provider_name = provider.respond_to?(:provider_name) ? provider.provider_name : provider.class.name.to_sym
+      Legion::Identity::Broker.register_provider(provider_name, provider: provider, lease: lease)
+      log.info "[Identity] registered provider #{provider_name} with Broker"
+    rescue StandardError => e
+      handle_exception(e, level: :warn, operation: 'service.register_provider_with_broker')
+    end
+
     def find_identity_providers
       return [] unless defined?(Legion::Extensions)
 

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.7.31
+  version: 1.7.33
 platform: ruby
 authors:
 - Esity
@@ -818,6 +818,7 @@ files:
 - lib/legion/extensions/builders/runners.rb
 - lib/legion/extensions/capability.rb
 - lib/legion/extensions/catalog.rb
+- lib/legion/extensions/catalog/available.rb
 - lib/legion/extensions/catalog/registry.rb
 - lib/legion/extensions/core.rb
 - lib/legion/extensions/data.rb