legionio 1.6.21 → 1.6.24

data/lib/legion/api.rb

@@ -47,6 +47,10 @@ require_relative 'api/costs'
 require_relative 'api/traces'
 require_relative 'api/stats'
 require_relative 'api/codegen'
+require_relative 'api/router'
+require_relative 'api/library_routes'
+require_relative 'api/sync_dispatch'
+require_relative 'api/lex_dispatch'
 require_relative 'api/graphql' if defined?(GraphQL)
 
 module Legion
@@ -72,6 +76,21 @@ module Legion
       Legion::API::OpenAPI.to_json
     end
 
+    # Root discovery — lists all tiers
+    get '/api/discovery' do
+      content_type :json
+      Legion::JSON.dump({
+                          infrastructure: [
+                            { path: '/api/health', method: 'GET' },
+                            { path: '/api/ready', method: 'GET' },
+                            { path: '/api/openapi.json', method: 'GET' },
+                            { path: '/api/discovery', method: 'GET' }
+                          ],
+                          libraries:      Legion::API.router.library_names,
+                          extensions:     Legion::API.router.extension_names
+                        })
+    end
+
     # Health and readiness
     get '/api/health' do
       json_response({ status: 'ok', version: Legion::VERSION })
@@ -87,8 +106,14 @@ module Legion
       content_type :json
       Legion::Logging.warn "API #{request.request_method} #{request.path_info} returned 404: no route matches"
       Legion::JSON.dump({
-                          error: { code: 'not_found', message: "no route matches #{request.request_method} #{request.path_info}" },
-                          meta:  { timestamp: Time.now.utc.iso8601, node: Legion::Settings[:client][:name] }
+                          task_id:         nil,
+                          conversation_id: nil,
+                          status:          'failed',
+                          error:           {
+                            code:    404,
+                            message: "no route matches #{request.request_method} #{request.path_info}"
+                          },
+                          meta:            { timestamp: Time.now.utc.iso8601, node: Legion::Settings[:client][:name] }
                         })
     end
 
@@ -97,12 +122,16 @@ module Legion
       err = env['sinatra.error']
       Legion::Logging.log_exception(err, payload_summary: "API #{request.request_method} #{request.path_info} returned 500", component_type: :api)
       Legion::JSON.dump({
-                          error: { code: 'internal_error', message: err.message },
-                          meta:  { timestamp: Time.now.utc.iso8601, node: Legion::Settings[:client][:name] }
+                          task_id:         nil,
+                          conversation_id: nil,
+                          status:          'failed',
+                          error:           { code: 500, message: err.message },
+                          meta:            { timestamp: Time.now.utc.iso8601, node: Legion::Settings[:client][:name] }
                         })
     end
 
     # Mount route modules
+    register Routes::LexDispatch
     register Routes::Tasks
     register Routes::Extensions
     register Routes::Nodes
@@ -126,14 +155,14 @@ module Legion
     register Routes::Capacity
     register Routes::Audit
     register Routes::Metrics
-    register Routes::Llm
+    register Routes::Llm unless defined?(Legion::LLM::Routes)
     register Routes::ExtensionCatalog
     register Routes::OrgChart
     register Routes::Governance
     register Routes::Acp
     register Routes::Prompts
     register Routes::Marketplace
-    register Routes::Apollo
+    register Routes::Apollo unless defined?(Legion::Apollo::Routes)
     register Routes::Costs
     register Routes::Traces
     register Routes::Stats
@@ -143,6 +172,13 @@ module Legion
     use Legion::API::Middleware::RequestLogger
     use Legion::Rbac::Middleware if defined?(Legion::Rbac::Middleware)
 
+    # Tier-aware router (three-tier namespace)
+    class << self
+      def router
+        @router ||= Legion::API::Router.new
+      end
+    end
+
     # Hook registry (preserved from original implementation)
     class << self
       def hook_registry

data/lib/legion/cli/admin/purge_topology.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'erb'
+
+module Legion
+  module CLI
+    module Admin
+      class PurgeTopology < Thor
+        namespace 'admin:purge_topology'
+
+        def self.exit_on_failure?
+          true
+        end
+
+        class_option :json,      type: :boolean, default: false,       desc: 'Output as JSON'
+        class_option :no_color,  type: :boolean, default: false,       desc: 'Disable color output'
+        class_option :host,      type: :string,  default: 'localhost', desc: 'RabbitMQ management host'
+        class_option :port,      type: :numeric, default: 15_672,      desc: 'RabbitMQ management port'
+        class_option :user,      type: :string,  default: 'guest',     desc: 'RabbitMQ management username'
+        class_option :password,  type: :string,  default: 'guest',     desc: 'RabbitMQ management password'
+        class_option :vhost,     type: :string,  default: '/',         desc: 'RabbitMQ vhost'
+        class_option :execute,   type: :boolean, default: false,       desc: 'Actually delete (default: dry-run)'
+
+        desc 'purge', 'Enumerate and optionally delete legacy v2.0 topology (legion.{lex} exchanges/queues)'
+        def purge
+          out = formatter
+          out.header('Legion AMQP Topology Migration: v2.0 → v3.0')
+          out.spacer
+
+          legacy = find_legacy_topology
+          if legacy[:exchanges].empty? && legacy[:queues].empty?
+            out.success('No legacy topology found. Already on v3.0 or never had v2.0 topology.')
+            return
+          end
+
+          if options[:json]
+            perform_deletion(legacy) if options[:execute]
+            out.json({ legacy: legacy, deleted: options[:execute] })
+            return
+          end
+
+          report_legacy(out, legacy)
+
+          if options[:execute]
+            perform_deletion(legacy)
+            out.success("Deleted #{legacy[:exchanges].size} exchange(s) and #{legacy[:queues].size} queue(s)")
+          else
+            out.warn('Dry-run mode — pass --execute to delete legacy topology')
+          end
+        rescue Legion::CLI::Error => e
+          formatter.error(e.message)
+          exit(1)
+        end
+
+        no_commands do # rubocop:disable Metrics/BlockLength
+          def formatter
+            @formatter ||= Output::Formatter.new(
+              json:  options[:json],
+              color: !options[:no_color]
+            )
+          end
+
+          private
+
+          def vhost_encoded
+            ERB::Util.url_encode(options[:vhost])
+          end
+
+          def management_api(path)
+            uri = URI("http://#{options[:host]}:#{options[:port]}/api#{path}")
+            req = Net::HTTP::Get.new(uri)
+            req.basic_auth(options[:user], options[:password])
+            response = Net::HTTP.start(uri.host, uri.port, open_timeout: 5, read_timeout: 10) do |http|
+              http.request(req)
+            end
+            raise Legion::CLI::Error, "Management API #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+            ::JSON.parse(response.body, symbolize_names: true)
+          rescue Errno::ECONNREFUSED
+            raise Legion::CLI::Error, "Cannot connect to RabbitMQ management API at #{options[:host]}:#{options[:port]}"
+          rescue Net::OpenTimeout, Net::ReadTimeout
+            raise Legion::CLI::Error, 'Timed out connecting to RabbitMQ management API'
+          end
+
+          def management_delete(path)
+            uri = URI("http://#{options[:host]}:#{options[:port]}/api#{path}")
+            req = Net::HTTP::Delete.new(uri)
+            req.basic_auth(options[:user], options[:password])
+            response = Net::HTTP.start(uri.host, uri.port, open_timeout: 5, read_timeout: 10) do |http|
+              http.request(req)
+            end
+            raise Legion::CLI::Error, "Management API #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+            response
+          rescue Errno::ECONNREFUSED
+            raise Legion::CLI::Error, "Cannot connect to RabbitMQ management API at #{options[:host]}:#{options[:port]}"
+          rescue Net::OpenTimeout, Net::ReadTimeout
+            raise Legion::CLI::Error, 'Timed out connecting to RabbitMQ management API'
+          end
+
+          # Find exchanges and queues matching legacy v2.0 pattern: legion.{lex_name}.*
+          # but NOT matching v3.0 pattern (lex.{lex_name}.*) or infrastructure (task, node, etc.)
+          def find_legacy_topology
+            all_exchanges = management_api("/exchanges/#{vhost_encoded}")
+            all_queues    = management_api("/queues/#{vhost_encoded}")
+
+            legacy_exchanges = all_exchanges
+                               .map { |e| e[:name].to_s }
+                               .select do |name|
+              name.match?(/\Alegion\.[a-z]/) && !name.start_with?('legion.task', 'legion.node', 'legion.crypt', 'legion.extensions',
+                                                                  'legion.logging')
+            end
+
+            legacy_queues = all_queues
+                            .map { |q| q[:name].to_s }
+                            .select { |name| name.match?(/\Alegion\.[a-z]/) && !name.match?(/\Alegion\.(task|node|crypt|extensions|logging)/) }
+
+            { exchanges: legacy_exchanges, queues: legacy_queues }
+          end
+
+          def report_legacy(out, legacy)
+            unless legacy[:exchanges].empty?
+              out.detail_header("Legacy Exchanges (#{legacy[:exchanges].size})")
+              legacy[:exchanges].each { |name| out.detail({ name: name }) }
+              out.spacer
+            end
+
+            unless legacy[:queues].empty? # rubocop:disable Style/GuardClause
+              out.detail_header("Legacy Queues (#{legacy[:queues].size})")
+              legacy[:queues].each { |name| out.detail({ name: name }) }
+              out.spacer
+            end
+          end
+
+          def perform_deletion(legacy)
+            legacy[:queues].each do |name|
+              management_delete("/queues/#{vhost_encoded}/#{ERB::Util.url_encode(name)}")
+            end
+            legacy[:exchanges].each do |name|
+              management_delete("/exchanges/#{vhost_encoded}/#{ERB::Util.url_encode(name)}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/chat/daemon_chat.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'legion/cli/chat_command'
+
+begin
+  require 'legion/llm/daemon_client'
+rescue LoadError
+  # legion-llm not yet loaded; DaemonClient must be defined before DaemonChat#ask is called.
+end
+
+module Legion
+  module CLI
+    class Chat
+      # Daemon-backed chat adapter. Matches the interface that Session expects
+      # from a chat object (ask, with_tools, with_instructions, on_tool_call,
+      # on_tool_result, model, add_message, reset_messages!, with_model).
+      #
+      # All LLM inference is routed through the running daemon via
+      # POST /api/llm/inference. Tool execution runs locally on the client
+      # machine — the daemon returns tool_call requests and the client
+      # executes them and loops.
+      class DaemonChat
+        # Minimal response-like object returned from ask.
+        # Responds to the same interface Session#send_message reads.
+        Response = Struct.new(:content, :input_tokens, :output_tokens, :model)
+
+        # Minimal model object responding to .id (used by Session#model_id).
+        ModelInfo = Struct.new(:id) do
+          def to_s
+            id.to_s
+          end
+        end
+
+        attr_reader :model
+
+        def initialize(model: nil, provider: nil)
+          @model    = ModelInfo.new(id: model)
+          @provider = provider
+          @messages = []
+          @tools    = []
+          @instructions = nil
+          @on_tool_call   = nil
+          @on_tool_result = nil
+        end
+
+        # Sets the system prompt. Returns self for chaining.
+        def with_instructions(prompt)
+          @instructions = prompt
+          self
+        end
+
+        # Registers tool classes for local execution and schema forwarding.
+        # Returns self for chaining.
+        def with_tools(*tools)
+          @tools = tools.flatten
+          self
+        end
+
+        # Switches the active model. Returns self for chaining.
+        def with_model(model_id)
+          @model = ModelInfo.new(id: model_id)
+          self
+        end
+
+        # Stores a tool_call callback invoked before each local tool execution.
+        def on_tool_call(&block)
+          @on_tool_call = block
+        end
+
+        # Stores a tool_result callback invoked after each local tool execution.
+        def on_tool_result(&block)
+          @on_tool_result = block
+        end
+
+        # Appends a message to the conversation history directly (used by
+        # slash commands /fetch, /search, /agent, etc. that inject context).
+        def add_message(role:, content:)
+          @messages << { role: role.to_s, content: content }
+        end
+
+        # Clears all conversation history (used by /clear slash command).
+        def reset_messages!
+          @messages = []
+        end
+
+        # Sends a message through the daemon inference loop.
+        # Executes any tool_calls locally and loops until the LLM stops.
+        # Yields response-like chunks for streaming display (Phase 1: single chunk).
+        # Returns a Response object compatible with Session#send_message.
+        def ask(message, &on_chunk)
+          @messages << { role: 'user', content: message }
+
+          loop do
+            result = call_daemon_inference
+
+            raise CLI::Error, "Daemon inference error: #{result[:error]}" if result[:status] == :error
+            raise CLI::Error, 'Daemon is unavailable' if result[:status] == :unavailable
+
+            data = extract_data(result)
+
+            if data[:tool_calls]&.any?
+              execute_tool_calls(data[:tool_calls], data[:content])
+            else
+              on_chunk&.call(Response.new(content: data[:content]))
+              @messages << { role: 'assistant', content: data[:content] }
+              return build_response(data)
+            end
+          end
+        end
+
+        private
+
+        def call_daemon_inference
+          Legion::LLM::DaemonClient.inference(
+            messages: build_messages,
+            tools:    build_tool_schemas,
+            model:    @model.id,
+            provider: @provider
+          )
+        end
+
+        def extract_data(result)
+          # DaemonClient.inference returns { status:, data: { content:, tool_calls:, ... } }
+          data = result[:data] || result[:body] || {}
+          data.is_a?(Hash) ? data : {}
+        end
+
+        def build_messages
+          msgs = []
+          msgs << { role: 'system', content: @instructions } if @instructions
+          msgs + @messages
+        end
+
+        def build_tool_schemas
+          @tools.map do |tool|
+            {
+              name:        tool_name(tool),
+              description: tool_description(tool),
+              parameters:  tool_parameters(tool)
+            }
+          end
+        end
+
+        def tool_name(tool)
+          if tool.respond_to?(:tool_name)
+            tool.tool_name
+          else
+            tool.name.to_s.split('::').last.gsub(/([A-Z])/) do
+              "_#{::Regexp.last_match(1).downcase}"
+            end.delete_prefix('_')
+          end
+        end
+
+        def tool_description(tool)
+          tool.respond_to?(:description) ? tool.description : ''
+        end
+
+        def tool_parameters(tool)
+          tool.respond_to?(:parameters) ? tool.parameters : {}
+        end
+
+        def execute_tool_calls(tool_calls, assistant_content)
+          # Record the assistant turn with tool_calls before appending results.
+          @messages << { role: 'assistant', content: assistant_content, tool_calls: tool_calls }
+
+          tool_calls.each do |tc|
+            tc = tc.transform_keys(&:to_sym) if tc.respond_to?(:transform_keys)
+            tc_obj = build_tool_call_object(tc)
+
+            @on_tool_call&.call(tc_obj)
+
+            result_text = run_tool(tc)
+
+            result_obj = build_tool_result_object(result_text)
+            @on_tool_result&.call(result_obj)
+
+            @messages << {
+              role:         'tool',
+              tool_call_id: tc[:id] || tc[:tool_call_id],
+              content:      result_text.to_s
+            }
+          end
+        end
+
+        def build_tool_call_object(tool_call)
+          Struct.new(:name, :arguments, :id).new(
+            name:      tool_call[:name].to_s,
+            arguments: (tool_call[:arguments] || tool_call[:input] || {}).transform_keys(&:to_sym),
+            id:        tool_call[:id] || tool_call[:tool_call_id]
+          )
+        end
+
+        def build_tool_result_object(text)
+          Struct.new(:content).new(content: text.to_s)
+        end
+
+        def run_tool(tool_call)
+          name      = tool_call[:name].to_s
+          arguments = (tool_call[:arguments] || tool_call[:input] || {}).transform_keys(&:to_sym)
+
+          tool_class = @tools.find { |t| tool_name(t) == name }
+          return "Unknown tool: #{name}" unless tool_class
+
+          tool_class.call(**arguments)
+        rescue StandardError => e
+          "Tool error (#{name}): #{e.message}"
+        end
+
+        def build_response(data)
+          Response.new(
+            content:       data[:content],
+            input_tokens:  data[:input_tokens],
+            output_tokens: data[:output_tokens],
+            model:         ModelInfo.new(id: data[:model] || @model.id)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/chat_command.rb

@@ -176,7 +176,14 @@ module Legion
         def setup_connection
           Connection.config_dir = options[:config_dir] if options[:config_dir]
           Connection.log_level = options[:verbose] ? 'debug' : 'error'
-          Connection.ensure_llm
+          Connection.ensure_settings
+
+          require 'legion/llm/daemon_client'
+          return if Legion::LLM::DaemonClient.available?
+
+          raise CLI::Error,
+                "LegionIO daemon is not running. Start it with: legionio start\n  " \
+                'All LLM requests must route through the daemon.'
         end
 
         def setup_notification_bridge
@@ -237,13 +244,13 @@ module Legion
         end
 
         def create_chat
-          opts = {}
-          opts[:model]    = options[:model] || chat_setting(:model)
-          opts[:provider] = (options[:provider] || chat_setting(:provider))&.to_sym
-          opts.compact!
-
+          require 'legion/cli/chat/daemon_chat'
           require 'legion/cli/chat/tool_registry'
-          chat = Legion::LLM.chat(**opts, caller: { source: 'cli', command: 'chat' })
+
+          chat = Chat::DaemonChat.new(
+            model:    options[:model] || chat_setting(:model),
+            provider: (options[:provider] || chat_setting(:provider))&.to_sym
+          )
           chat.with_tools(*Chat::ToolRegistry.all_tools)
           chat
         end

data/lib/legion/cli/generate_command.rb

@@ -427,9 +427,9 @@ module Legion
                 end
               end
 
-              describe '#handle' do
+              describe '#absorb' do
                 it 'returns success' do
-                  result = described_class.new.handle(url: 'https://#{test_url}')
+                  result = described_class.new.absorb(url: 'https://#{test_url}')
                   expect(result[:success]).to be true
                 end
               end

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

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require_relative '../definitions'
+
 module Legion
   module Extensions
     module Absorbers
       class Base
+        extend Legion::Extensions::Definitions
+
         attr_accessor :job_id, :runners
 
         class << self
@@ -21,10 +25,13 @@ module Legion
           end
         end
 
-        def handle(url: nil, content: nil, metadata: {}, context: {})
-          raise NotImplementedError, "#{self.class.name} must implement #handle"
+        def absorb(url: nil, content: nil, metadata: {}, context: {})
+          raise NotImplementedError, "#{self.class.name} must implement #absorb"
         end
 
+        # @deprecated Use #absorb instead
+        alias handle absorb
+
         def absorb_to_knowledge(content:, tags: [], scope: :global, **opts)
           return fallback_absorb(:chunker, content, tags, scope, opts) unless chunker_available?
           return fallback_absorb(:apollo, content, tags, scope, opts) unless apollo_available?

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

@@ -19,7 +19,7 @@ module Legion
 
           absorber = absorber_class.new
           absorber.job_id = job_id
-          result = absorber.handle(url: input, content: context[:content],
+          result = absorber.absorb(url: input, content: context[:content],
                                    metadata: context[:metadata] || {}, context: context)
           publish_event("absorb.complete.#{job_id}", job_id: job_id, absorber: absorber_class.name,
                                                      result: result)

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

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
+require_relative 'dsl'
+
 module Legion
   module Extensions
     module Actors
       module Base
+        extend Legion::Extensions::Actors::Dsl
         include Legion::Extensions::Helpers::Lex
 
+        define_dsl_accessor :use_runner, default: true
+        define_dsl_accessor :check_subtask, default: true
+        define_dsl_accessor :generate_task, default: false
+        define_dsl_accessor :enabled, default: true
+        define_dsl_accessor :remote_invocable, default: true
+
         def runner
           Legion::Runner.run(runner_class: runner_class, function: function, check_subtask: check_subtask?, generate_task: generate_task?)
         rescue StandardError => e
@@ -29,8 +38,17 @@ module Legion
           nil
         end
 
+        def self.included(base)
+          base.extend(Legion::Extensions::Actors::Dsl) unless base.singleton_class.include?(Legion::Extensions::Actors::Dsl)
+          base.define_dsl_accessor(:use_runner, default: true) unless base.respond_to?(:use_runner)
+          base.define_dsl_accessor(:check_subtask, default: true) unless base.respond_to?(:check_subtask)
+          base.define_dsl_accessor(:generate_task, default: false) unless base.respond_to?(:generate_task)
+          base.define_dsl_accessor(:enabled, default: true) unless base.respond_to?(:enabled)
+          base.define_dsl_accessor(:remote_invocable, default: true) unless base.respond_to?(:remote_invocable)
+        end
+
         def use_runner?
-          true
+          self.class.respond_to?(:use_runner) ? self.class.use_runner : true
         end
 
         def args
@@ -38,19 +56,19 @@ module Legion
         end
 
         def check_subtask?
-          true
+          self.class.respond_to?(:check_subtask) ? self.class.check_subtask : true
         end
 
         def generate_task?
-          false
+          self.class.respond_to?(:generate_task) ? self.class.generate_task : false
         end
 
         def enabled?
-          true
+          self.class.respond_to?(:enabled) ? self.class.enabled : true
         end
 
         def remote_invocable?
-          true
+          self.class.respond_to?(:remote_invocable) ? self.class.remote_invocable : true
         end
       end
     end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Actors
+      module Dsl
+        def define_dsl_accessor(name, default:)
+          define_singleton_method(name) do |val = :_unset|
+            if val == :_unset
+              if instance_variable_defined?(:"@#{name}")
+                instance_variable_get(:"@#{name}")
+              elsif superclass.respond_to?(name)
+                superclass.public_send(name)
+              else
+                default
+              end
+            else
+              instance_variable_set(:"@#{name}", val)
+            end
+          end
+
+          define_method(name) do
+            self.class.public_send(name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,14 +2,20 @@
 
 require_relative 'base'
 require_relative 'fingerprint'
+require_relative 'dsl'
 
 module Legion
   module Extensions
     module Actors
       class Every
+        extend Legion::Extensions::Actors::Dsl
         include Legion::Extensions::Actors::Base
         include Legion::Extensions::Actors::Fingerprint
 
+        define_dsl_accessor :time, default: 1
+        define_dsl_accessor :timeout, default: 5
+        define_dsl_accessor :run_now, default: false
+
         def initialize(**_opts)
           @timer = Concurrent::TimerTask.new(execution_interval: time, run_now: run_now?) do
             log.debug "[Every] tick: #{self.class}" if defined?(log)
@@ -25,16 +31,8 @@ module Legion
           log.log_exception(e, component_type: :actor)
         end
 
-        def time
-          1
-        end
-
-        def timeout
-          5
-        end
-
         def run_now?
-          false
+          run_now
         end
 
         def action(**_opts)