legionio 1.6.25 → 1.6.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fcd30078f57fd92474d887714ed4ba5a49ed262c50dd9bcde5301e682299d21
-  data.tar.gz: 6bee493acba0acc9199fe9c53cb3f844b64498012e7123cf9b8a4cd46bbf0bbe
+  metadata.gz: 87e232e8560f2fc19eab52867dca532552949fa8ab6f2637f505454ce7c3f435
+  data.tar.gz: d98b360b63301c86f808f2b0f2baac8c4671c871847233eb9a6d9f5ca5dd9b61
 SHA512:
-  metadata.gz: 2e96c7c7dc687503efb94dda27a1e57aad86b3f05cb6844ab12b603bc20b4c22a155755e2578ed4cca576b9bfd3b3c102b0fc2ce558d5a7ea283dc12f16e02f2
-  data.tar.gz: ef81be962e9a9228945babcab90e1222e1efa85b3a94b4ceff38d52f02048538ef4471cb03ca3d3fa2e52bb8b3bc391dce0773e57559fdd7f950940cc6ee157b
+  metadata.gz: 77bc48601a5384ac7b2b9e9185eebb73a9882b492e15e811b1377b29d672758e648a49a5385e1287e2b49724e4e7e2393ee1452b79cd700aac5171a21cf624e3
+  data.tar.gz: 7e31cd03e21c4263bb6b64dbfa0d7e7ef3aa51e0ecfa8801292084cc97ce6850c9795620dbb3fc3f235b9efd84c71a99b1ff41580f34524fcfdd8448b6f48225

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [1.6.26] - 2026-03-28
+
+### Added
+- Absorber Router registration: `builders/absorbers.rb` now registers absorbers with `Legion::API.router` for v3.0 API discovery and dispatch (component_type: `absorbers`)
+- Hook-aware LexDispatch: `POST /api/extensions/:lex/hooks/:name/:method` applies verify/route/transform lifecycle for `Hooks::Base` subclasses; auto-generated hooks pass through unchanged
+- Transport message auto-generation: `auto_generate_messages` in `extensions/transport.rb` creates `Legion::Transport::Message` subclasses from runner definitions with inputs at boot time; explicit classes always take precedence
+- `legion broker purge-topology` CLI command: detects old v2.0 AMQP exchanges (`legion.*`) that have v3.0 counterparts (`lex.*`) and optionally deletes them via RabbitMQ management API; defaults to `--dry-run`
+- `spec/api/lex_dispatch_spec.rb`: 10-example spec covering v3.0 LexDispatch routes (replaces old lex_spec.rb)
+- `spec/api/lex_dispatch_hooks_spec.rb`: 5-example spec for hook-aware dispatch (401/422/success/passthrough)
+- `spec/api/old_systems_removed_spec.rb`: 10-example spec verifying old registries are gone
+- `spec/cli/admin_command_spec.rb`: 21-example spec for topology detection logic
+- `spec/extensions/builders/absorbers_spec.rb`: 10-example spec for absorber builder + Router registration
+- `spec/extensions/transport_auto_messages_spec.rb`: 14-example spec for message auto-generation
+- `unless defined?` guards on `Routes::Gaia`, `Routes::Transport`, `Routes::Rbac` registration for library gem self-registration
+
+### Removed
+- `Routes::Lex` (`api/lex.rb`): old `/api/lex/*` wildcard dispatcher — use `/api/extensions/:lex/runners/:name/:method`
+- `Routes::Hooks` (`api/hooks.rb`): old `/api/hooks/lex/*` handler — use `/api/extensions/:lex/hooks/:name/:method`
+- `Legion::API.hook_registry`, `.register_hook`, `.find_hook`, `.find_hook_by_path`, `.registered_hooks` — hooks auto-register via builder
+- `Legion::API.route_registry`, `.register_route`, `.find_route_by_path`, `.registered_routes` — routes auto-register via builder
+
+### Changed
+- Routes builder log message now uses v3.0 path format (`/api/extensions/...` instead of `/api/lex/...`)
+
 ## [1.6.25] - 2026-03-28
 
 ### Added

data/lib/legion/api/lex_dispatch.rb

@@ -64,7 +64,7 @@ module Legion
           end
         end
 
-        def self.dispatch_request(context, request, params) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+        def self.dispatch_request(context, request, params) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
           content_type = 'application/json'
           context.content_type content_type
 
@@ -133,6 +133,10 @@ module Legion
             end
           end
 
+          # Hook-aware dispatch: when component_type is 'hooks' and the runner class
+          # is a Hooks::Base subclass, apply verify -> route -> transform -> Ingress.
+          return dispatch_hook(context, request, entry, payload, envelope) if entry[:component_type] == 'hooks' && hook_base_subclass?(entry[:runner_class])
+
           result = Legion::Ingress.run(
             payload:       payload.merge(envelope.slice(:task_id, :conversation_id, :parent_id, :master_id, :chain_id)),
             runner_class:  entry[:runner_class],
@@ -224,9 +228,68 @@ module Legion
           raise
         end
 
+        def self.hook_base_subclass?(runner_class)
+          return false unless defined?(Legion::Extensions::Hooks::Base)
+          return false if runner_class.nil?
+
+          klass = runner_class.is_a?(Class) ? runner_class : Kernel.const_get(runner_class.to_s)
+          klass < Legion::Extensions::Hooks::Base
+        rescue NameError, TypeError
+          false
+        end
+
+        def self.dispatch_hook(context, request, entry, payload, envelope)
+          hook = entry[:runner_class].new
+
+          # Re-read body for verification (request body was already read for payload parsing)
+          request.body.rewind
+          body_for_verify = request.body.read
+          request.body.rewind
+
+          unless hook.verify(request.env, body_for_verify)
+            context.halt 401, Legion::JSON.dump({
+                                                  task_id: nil, conversation_id: nil, status: 'failed',
+                                                  error: { code: 401, message: 'hook verification failed' }
+                                                })
+          end
+
+          function = hook.route(request.env, payload)
+          unless function
+            context.halt 422, Legion::JSON.dump({
+                                                  task_id: nil, conversation_id: nil, status: 'failed',
+                                                  error: { code: 422, message: 'hook could not route this event' }
+                                                })
+          end
+
+          # If the hook defines the routed function as an instance method, call it to transform
+          if hook.class.method_defined?(function) && hook.class.instance_method(function).owner != Legion::Extensions::Hooks::Base
+            transformed = hook.send(function, payload)
+            payload = transformed if transformed
+          end
+
+          runner = hook.runner_class || entry[:runner_class]
+
+          result = Legion::Ingress.run(
+            payload:       payload.merge(envelope.slice(:task_id, :conversation_id, :parent_id, :master_id, :chain_id)),
+            runner_class:  runner,
+            function:      function,
+            source:        'hook',
+            check_subtask: true,
+            generate_task: true
+          )
+
+          response_body = envelope.merge(
+            status: result[:status],
+            result: result[:result]
+          ).compact
+
+          Legion::JSON.dump(response_body)
+        end
+
         class << self
           private :register_discovery, :register_dispatch, :dispatch_request, :parse_header_integer,
-                  :build_envelope, :extension_loaded_locally?, :definition_blocks_remote?, :dispatch_async_amqp
+                  :build_envelope, :extension_loaded_locally?, :definition_blocks_remote?, :dispatch_async_amqp,
+                  :hook_base_subclass?, :dispatch_hook
         end
       end
     end

data/lib/legion/api/openapi.rb

@@ -1125,7 +1125,7 @@ module Legion
       private_class_method :lex_route_responses
 
       def self.lex_paths
-        base = {
+        {
           '/api/lex' => {
             get: {
               tags:        ['Lex'],
@@ -1156,27 +1156,6 @@ module Legion
             }
           }
         }
-
-        # Auto-routes (LEX)
-        if defined?(Legion::API) && Legion::API.respond_to?(:registered_routes)
-          Legion::API.registered_routes.each do |route|
-            path_key = "/api/lex/#{route[:route_path]}"
-            base[path_key] = {
-              post: {
-                operationId: "#{route[:lex_name]}.#{route[:runner_name]}.#{route[:function]}",
-                summary:     "Invoke #{route[:runner_name]}##{route[:function]} on lex-#{route[:lex_name]}",
-                tags:        [route[:lex_name]],
-                requestBody: {
-                  required: false,
-                  content:  { 'application/json' => { schema: { type: 'object' } } }
-                },
-                responses:   lex_route_responses
-              }
-            }
-          end
-        end
-
-        base
       end
       private_class_method :lex_paths
 

data/lib/legion/api.rb

@@ -20,8 +20,6 @@ require_relative 'api/chains'
 require_relative 'api/settings'
 require_relative 'api/events'
 require_relative 'api/transport'
-require_relative 'api/hooks'
-require_relative 'api/lex'
 require_relative 'api/workers'
 require_relative 'api/coldstart'
 require_relative 'api/gaia'
@@ -141,13 +139,11 @@ module Legion
     register Routes::Chains
     register Routes::Settings
     register Routes::Events
-    register Routes::Transport
-    register Routes::Hooks
-    register Routes::Lex
+    register Routes::Transport unless defined?(Legion::Transport::Routes)
     register Routes::Workers
     register Routes::Coldstart
-    register Routes::Gaia
-    register Routes::Rbac
+    register Routes::Gaia unless defined?(Legion::Gaia::Routes)
+    register Routes::Rbac unless defined?(Legion::Rbac::Routes)
     register Routes::Auth
     register Routes::AuthWorker
     register Routes::AuthHuman
@@ -178,65 +174,5 @@ module Legion
         @router ||= Legion::API::Router.new
       end
     end
-
-    # Hook registry (preserved from original implementation)
-    class << self
-      def hook_registry
-        @hook_registry ||= {}
-      end
-
-      def register_hook(lex_name:, hook_name:, hook_class:, default_runner: nil, route_path: nil)
-        route = route_path || "#{lex_name}/#{hook_name}"
-        key = route
-        hook_registry[key] = {
-          lex_name:       lex_name,
-          hook_name:      hook_name,
-          hook_class:     hook_class,
-          default_runner: default_runner,
-          route_path:     route
-        }
-        Legion::Logging.debug "Registered hook endpoint: /api/hooks/lex/#{route}"
-      end
-
-      def find_hook(lex_name, hook_name = nil)
-        if hook_name
-          hook_registry["#{lex_name}/#{hook_name}"]
-        else
-          hook_registry["#{lex_name}/webhook"] ||
-            hook_registry.values.find { |h| h[:lex_name] == lex_name }
-        end
-      end
-
-      def find_hook_by_path(path)
-        hook_registry[path] || hook_registry.values.find { |h| h[:route_path] == path }
-      end
-
-      def registered_hooks
-        hook_registry.values
-      end
-
-      def route_registry
-        @route_registry ||= {}
-      end
-
-      def register_route(lex_name:, runner_name:, function:, runner_class:, route_path:)
-        route_registry[route_path] = {
-          lex_name:     lex_name,
-          runner_name:  runner_name,
-          function:     function,
-          runner_class: runner_class,
-          route_path:   route_path
-        }
-        Legion::Logging.debug "Registered LEX route: POST /api/lex/#{route_path}"
-      end
-
-      def find_route_by_path(path)
-        route_registry[path]
-      end
-
-      def registered_routes
-        route_registry.values
-      end
-    end
   end
 end

data/lib/legion/cli/admin_command.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module Legion
+  module CLI
+    class AdminCommand < Thor
+      namespace :admin
+
+      desc 'purge-topology', 'Remove old v2.0 AMQP exchanges (legion.* that have lex.* counterparts)'
+      method_option :dry_run,  type: :boolean, default: true,        desc: 'List without deleting'
+      method_option :execute,  type: :boolean, default: false,       desc: 'Actually delete exchanges'
+      method_option :host,     type: :string,  default: 'localhost', desc: 'RabbitMQ management host'
+      method_option :port,     type: :numeric, default: 15_672,      desc: 'RabbitMQ management port'
+      method_option :user,     type: :string,  default: 'guest',     desc: 'RabbitMQ management user'
+      method_option :password, type: :string,  default: 'guest',     desc: 'RabbitMQ management password'
+      method_option :vhost,    type: :string,  default: '/',         desc: 'RabbitMQ vhost'
+      def purge_topology
+        exchanges  = fetch_exchanges
+        candidates = self.class.detect_old_exchanges(exchanges)
+
+        if candidates.empty?
+          say 'No old v2.0 topology exchanges found.', :green
+          return
+        end
+
+        say "Found #{candidates.size} old v2.0 exchange(s):", :yellow
+        candidates.each { |e| say "  #{e[:name]} (#{e[:type]})" }
+
+        if options[:execute] && !options[:dry_run]
+          candidates.each do |exchange|
+            delete_exchange(exchange[:name])
+            say "  Deleted: #{exchange[:name]}", :red
+          end
+          say "Purged #{candidates.size} exchange(s).", :green
+        else
+          say "\nDry run. Use --execute --no-dry-run to delete.", :cyan
+        end
+      end
+
+      def self.detect_old_exchanges(exchanges)
+        lex_names = exchanges.select { |e| e[:name].to_s.start_with?('lex.') }
+                             .to_set { |e| e[:name].to_s.sub('lex.', '') }
+
+        exchanges.select do |e|
+          next false unless e[:name].to_s.start_with?('legion.')
+
+          suffix = e[:name].to_s.sub('legion.', '')
+          lex_names.include?(suffix)
+        end
+      end
+
+      private
+
+      def management_uri(path)
+        vhost = URI.encode_www_form_component(options[:vhost])
+        URI("http://#{options[:host]}:#{options[:port]}/api#{path}?vhost=#{vhost}")
+      end
+
+      def fetch_exchanges
+        uri      = management_uri('/exchanges')
+        response = management_get(uri)
+        Legion::JSON.load(response.body).map { |e| { name: e[:name], type: e[:type] } }
+      end
+
+      def delete_exchange(name)
+        vhost        = URI.encode_www_form_component(options[:vhost])
+        encoded_name = URI.encode_www_form_component(name)
+        uri          = URI("http://#{options[:host]}:#{options[:port]}/api/exchanges/#{vhost}/#{encoded_name}")
+        management_request(uri, Net::HTTP::Delete)
+      end
+
+      def management_get(uri)
+        management_request(uri, Net::HTTP::Get)
+      end
+
+      def management_request(uri, method_class)
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          req = method_class.new(uri)
+          req.basic_auth(options[:user], options[:password])
+          http.request(req)
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/broker_command.rb

@@ -43,6 +43,40 @@ module Legion
         exit(1)
       end
 
+      desc 'purge-topology', 'Remove old v2.0 AMQP exchanges (legion.* that have lex.* counterparts)'
+      option :execute, type: :boolean, default: false, desc: 'Actually delete exchanges (default: dry-run)'
+      def purge_topology
+        require 'legion/cli/admin_command'
+        out        = formatter
+        exchanges  = management_api("/exchanges/#{vhost_encoded}").map { |e| { name: e[:name], type: e[:type] } }
+        candidates = Legion::CLI::AdminCommand.detect_old_exchanges(exchanges)
+
+        if candidates.empty?
+          out.success('No old v2.0 topology exchanges found.')
+          return
+        end
+
+        if options[:json]
+          out.json({ candidates: candidates, deleted: options[:execute] })
+          candidates.each { |e| management_delete("/exchanges/#{vhost_encoded}/#{ERB::Util.url_encode(e[:name])}") } if options[:execute]
+          return
+        end
+
+        out.header("Old v2.0 Exchanges (#{candidates.size})")
+        candidates.each { |e| out.warn("#{e[:name]} (#{e[:type]})") }
+        out.spacer
+
+        if options[:execute]
+          candidates.each { |e| management_delete("/exchanges/#{vhost_encoded}/#{ERB::Util.url_encode(e[:name])}") }
+          out.success("Purged #{candidates.size} exchange(s).")
+        else
+          out.warn('Dry-run mode — pass --execute to delete')
+        end
+      rescue Legion::CLI::Error => e
+        formatter.error(e.message)
+        exit(1)
+      end
+
       desc 'cleanup', 'Find (and optionally delete) orphaned queues with 0 consumers and 0 messages'
       option :execute, type: :boolean, default: false, desc: 'Actually delete orphaned queues (default: dry-run)'
       def cleanup

data/lib/legion/cli.rb

@@ -69,6 +69,7 @@ module Legion
     autoload :CodegenCommand, 'legion/cli/codegen_command'
     autoload :Bootstrap,      'legion/cli/bootstrap_command'
     autoload :Broker,         'legion/cli/broker_command'
+    autoload :AdminCommand,   'legion/cli/admin_command'
 
     module Groups
       autoload :Ai,       'legion/cli/groups/ai_group'

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

@@ -36,6 +36,22 @@ module Legion
             }
 
             Legion::Extensions::Absorbers::PatternMatcher.register(klass)
+
+            next unless defined?(Legion::API) && Legion::API.respond_to?(:router)
+
+            absorber_methods = klass.public_instance_methods(false).reject { |m| m.to_s.start_with?('_') }
+            absorber_methods = [:absorb] if absorber_methods.empty?
+            absorber_methods.each do |method_name|
+              Legion::API.router.register_extension_route(
+                lex_name:       lex_name,
+                amqp_prefix:    respond_to?(:amqp_prefix) ? amqp_prefix : "lex.#{lex_name}",
+                component_type: 'absorbers',
+                component_name: snake_name,
+                method_name:    method_name.to_s,
+                runner_class:   klass,
+                definition:     klass.respond_to?(:definition_for) ? klass.definition_for(method_name) : nil
+              )
+            end
           end
         rescue StandardError => e
           Legion::Logging.error("Failed to build absorbers: #{e.message}") if defined?(Legion::Logging)

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

@@ -29,7 +29,7 @@ module Legion
             methods.each do |function|
               route_path = "#{extension_name}/#{runner_name}/#{function}"
               defn = runner_module.respond_to?(:definition_for) ? runner_module.definition_for(function) : nil
-              log.info "[Routes] auto-route registered: POST /api/lex/#{route_path}"
+              log.info "[Routes] auto-route registered: POST /api/extensions/#{extension_name}/runners/#{runner_name}/#{function}"
               @routes[route_path] = {
                 lex_name:       extension_name,
                 runner_name:    runner_name,

data/lib/legion/extensions/core.rb

@@ -217,36 +217,11 @@ module Legion
       end
 
       def register_hooks
-        return if @hooks.nil? || @hooks.empty?
-        return unless defined?(Legion::API)
-
-        # Find the first runner class as default for hooks that don't specify one
-        default_runner = @runners.values.first&.dig(:runner_class)
-
-        @hooks.each_value do |hook_info|
-          Legion::API.register_hook(
-            lex_name:       extension_name,
-            hook_name:      hook_info[:hook_name],
-            hook_class:     hook_info[:hook_class],
-            default_runner: hook_info[:hook_class].new.runner_class || default_runner,
-            route_path:     hook_info[:route_path]
-          )
-        end
+        # Hook registration is handled by Routes::LexDispatch via the Router (v3.0)
       end
 
       def register_routes
-        return if @routes.nil? || @routes.empty?
-        return unless defined?(Legion::API)
-
-        @routes.each_value do |route_info|
-          Legion::API.register_route(
-            lex_name:     route_info[:lex_name],
-            runner_name:  route_info[:runner_name],
-            function:     route_info[:function],
-            runner_class: route_info[:runner_class],
-            route_path:   route_info[:route_path]
-          )
-        end
+        # Route registration is handled by Routes::LexDispatch via the Router (v3.0)
       end
 
       def auto_generate_transport

data/lib/legion/extensions/transport.rb

@@ -22,6 +22,7 @@ module Legion
         build_e_to_q(additional_e_to_q)
         auto_create_dlx_exchange
         auto_create_dlx_queue
+        auto_generate_messages
         log.info "[Transport] built exchanges=#{@exchanges.count} queues=#{@queues.count} for #{lex_name}"
       rescue StandardError => e
         log.log_exception(e, payload_summary: "[Transport] build failed for #{lex_name}", component_type: :transport)
@@ -94,6 +95,41 @@ module Legion
         dlx_queue.bind("#{special_name}.dlx", { routing_key: '#' })
       end
 
+      def auto_generate_messages
+        return unless defined?(@runners) && @runners.is_a?(Hash)
+
+        messages_mod = transport_class::Messages
+        ext_amqp = amqp_prefix
+        @runners.each_value { |info| auto_generate_runner_messages(info, messages_mod, ext_amqp) }
+      rescue StandardError => e
+        log.error("[Transport] auto-generate messages failed: #{e.message}") if respond_to?(:log)
+      end
+
+      def auto_generate_runner_messages(runner_info, messages_mod, ext_amqp)
+        runner_name   = runner_info[:runner_name]
+        runner_module = runner_info[:runner_module]
+        return if runner_module.nil?
+        return unless runner_module.respond_to?(:definition_for)
+
+        methods = runner_module.respond_to?(:instance_methods) ? runner_module.instance_methods(false) : []
+        methods.each { |method_name| auto_generate_message(runner_name, method_name, runner_module, messages_mod, ext_amqp) }
+      end
+
+      def auto_generate_message(runner_name, method_name, runner_module, messages_mod, ext_amqp)
+        defn = runner_module.definition_for(method_name)
+        return if defn.nil? || defn[:inputs].nil? || defn[:inputs].empty?
+
+        class_name = "#{runner_name.to_s.split('_').collect(&:capitalize).join}#{method_name.to_s.split('_').collect(&:capitalize).join}"
+        return if messages_mod.const_defined?(class_name, false)
+
+        routing_key = "#{ext_amqp}.runners.#{runner_name}.#{method_name}"
+        msg_class = Class.new(Legion::Transport::Message) do
+          define_method(:exchange_name) { ext_amqp }
+          define_method(:routing_key) { routing_key }
+        end
+        messages_mod.const_set(class_name, msg_class)
+      end
+
       def build_e_to_q(array)
         array.each do |binding|
           binding[:routing_key] = nil unless binding.key? :routing_key

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.25
+  version: 1.6.26
 platform: ruby
 authors:
 - Esity
@@ -468,8 +468,6 @@ files:
 - lib/legion/api/graphql/types/task_type.rb
 - lib/legion/api/graphql/types/worker_type.rb
 - lib/legion/api/helpers.rb
-- lib/legion/api/hooks.rb
-- lib/legion/api/lex.rb
 - lib/legion/api/lex_dispatch.rb
 - lib/legion/api/library_routes.rb
 - lib/legion/api/llm.rb
@@ -518,6 +516,7 @@ files:
 - lib/legion/cli/absorb_command.rb
 - lib/legion/cli/acp_command.rb
 - lib/legion/cli/admin/purge_topology.rb
+- lib/legion/cli/admin_command.rb
 - lib/legion/cli/apollo_command.rb
 - lib/legion/cli/audit_command.rb
 - lib/legion/cli/auth_command.rb

data/lib/legion/api/hooks.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  class API < Sinatra::Base
-    module Routes
-      module Hooks
-        def self.registered(app)
-          register_list(app)
-          register_lex_routes(app)
-        end
-
-        def self.register_list(app)
-          app.get '/api/hooks' do
-            hooks = Legion::API.registered_hooks.map do |h|
-              {
-                lex_name: h[:lex_name], hook_name: h[:hook_name],
-                hook_class: h[:hook_class].to_s, default_runner: h[:default_runner].to_s,
-                route_path: h[:route_path],
-                endpoint: "/api/hooks/lex/#{h[:route_path]}"
-              }
-            end
-            json_response(hooks)
-          end
-        end
-
-        def self.register_lex_routes(app)
-          handler = method(:handle_hook_request)
-
-          app.get '/api/hooks/lex/*' do
-            handler.call(self, request)
-          end
-
-          app.post '/api/hooks/lex/*' do
-            handler.call(self, request)
-          end
-        end
-
-        def self.handle_hook_request(context, request)
-          splat_path = request.path_info.sub(%r{^/api/hooks/lex/}, '')
-          Legion::Logging.debug "API: #{request.request_method} /api/hooks/lex/#{splat_path}"
-          hook_entry = Legion::API.find_hook_by_path(splat_path)
-          if hook_entry.nil?
-            Legion::Logging.warn "API #{request.request_method} #{request.path_info} returned 404: no hook registered for '#{splat_path}'"
-            context.halt 404, context.json_error('not_found', "no hook registered for '#{splat_path}'", status_code: 404)
-          end
-
-          body = request.request_method == 'POST' ? request.body.read : nil
-          hook = hook_entry[:hook_class].new
-          unless hook.verify(request.env, body || '')
-            Legion::Logging.warn "API #{request.request_method} #{request.path_info} returned 401: hook verification failed"
-            context.halt 401, context.json_error('unauthorized', 'hook verification failed', status_code: 401)
-          end
-
-          payload = build_payload(request, body)
-          function = hook.route(request.env, payload)
-          if function.nil?
-            Legion::Logging.warn "API #{request.request_method} #{request.path_info} returned 422: hook could not route this event"
-            context.halt 422, context.json_error('unhandled_event', 'hook could not route this event', status_code: 422)
-          end
-
-          runner = hook.runner_class || hook_entry[:default_runner]
-          if runner.nil?
-            Legion::Logging.error "API #{request.request_method} #{request.path_info} returned 500: no runner class configured for hook '#{splat_path}'"
-            context.halt 500, context.json_error('no_runner', 'no runner class configured for this hook', status_code: 500)
-          end
-
-          dispatch_hook(context, payload: payload, runner: runner, function: function)
-        rescue StandardError => e
-          Legion::Logging.log_exception(e, payload_summary: "API #{request.request_method} #{request.path_info}", component_type: :api)
-          context.json_error('internal_error', e.message, status_code: 500)
-        end
-
-        def self.build_payload(request, body)
-          payload = if body.nil? || body.empty?
-                      request.params.transform_keys(&:to_sym)
-                    else
-                      Legion::JSON.load(body)
-                    end
-          payload[:http_method] = request.request_method
-          payload[:headers] = request.env.select { |k, _| k.start_with?('HTTP_') || k == 'CONTENT_TYPE' }
-          payload
-        end
-
-        def self.dispatch_hook(context, payload:, runner:, function:)
-          result = Legion::Ingress.run(
-            payload: payload, runner_class: runner, function: function,
-            source: 'hook', check_subtask: true, generate_task: true
-          )
-          Legion::Logging.info "API: dispatched hook to #{runner}##{function}, task #{result[:task_id]}"
-          return render_custom_response(context, result[:response]) if result.is_a?(Hash) && result[:response]
-
-          context.json_response({ task_id: result[:task_id], status: result[:status] })
-        end
-
-        def self.render_custom_response(context, resp)
-          context.status resp[:status] || 200
-          context.content_type resp[:content_type] || 'application/json'
-          resp[:headers]&.each { |k, v| context.headers[k] = v }
-          resp[:body] || ''
-        end
-
-        class << self
-          private :register_list, :register_lex_routes,
-                  :handle_hook_request, :build_payload, :dispatch_hook, :render_custom_response
-        end
-      end
-    end
-  end
-end

data/lib/legion/api/lex.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  class API < Sinatra::Base
-    module Routes
-      module Lex
-        def self.registered(app)
-          register_list(app)
-          register_lex_routes(app)
-        end
-
-        def self.register_list(app)
-          app.get '/api/lex' do
-            routes = Legion::API.registered_routes.map do |r|
-              {
-                endpoint:     "/api/lex/#{r[:route_path]}",
-                extension:    r[:lex_name],
-                runner:       r[:runner_name],
-                function:     r[:function],
-                runner_class: r[:runner_class]
-              }
-            end
-            json_response(routes)
-          end
-        end
-
-        def self.register_lex_routes(app)
-          handler = method(:handle_lex_request)
-          app.post '/api/lex/*' do
-            handler.call(self, request)
-          end
-        end
-
-        def self.handle_lex_request(context, request)
-          splat_path = request.path_info.sub(%r{^/api/lex/}, '')
-          Legion::Logging.debug "API: POST /api/lex/#{splat_path}"
-          route_entry = Legion::API.find_route_by_path(splat_path)
-          if route_entry.nil?
-            Legion::Logging.warn "API POST /api/lex/#{splat_path} returned 404: no route registered"
-            context.halt 404, context.json_error('route_not_found',
-                                                 "no route registered for '#{splat_path}'", status_code: 404)
-          end
-
-          payload = build_payload(request)
-          result = Legion::Ingress.run(
-            payload:       payload,
-            runner_class:  route_entry[:runner_class],
-            function:      route_entry[:function],
-            source:        'lex_route',
-            generate_task: true
-          )
-          Legion::Logging.info "API: LEX route #{splat_path} dispatched to #{route_entry[:runner_class]}, task #{result[:task_id]}"
-          context.json_response({ task_id: result[:task_id], status: result[:status],
-                                   result: result[:result] }.compact)
-        rescue StandardError => e
-          Legion::Logging.log_exception(e, payload_summary: "API POST /api/lex/#{request.path_info.sub(%r{^/api/lex/}, '')}", component_type: :api)
-          context.json_error('internal_error', e.message, status_code: 500)
-        end
-
-        def self.build_payload(request)
-          body = request.body.read
-          payload = if body.nil? || body.empty?
-                      {}
-                    else
-                      Legion::JSON.load(body)
-                    end
-          payload[:http_method] = request.request_method
-          payload[:headers] = request.env.select { |k, _| k.start_with?('HTTP_') || k == 'CONTENT_TYPE' }
-          payload
-        end
-
-        class << self
-          private :register_list, :register_lex_routes, :handle_lex_request, :build_payload
-        end
-      end
-    end
-  end
-end