legion-llm 0.6.16 → 0.6.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fe6246015e9967dec5bbe428ab2cb5869b4a359c4a5b40c0a8206d0fe7b516d
-  data.tar.gz: f803de963b1887d064506187c3d7c8fa00b437613f5456bcbf87adae1d53a3a4
+  metadata.gz: 83b1bf0eb338e47eb37627eb7004afb30b3fba91627577034554827edd797bcf
+  data.tar.gz: 54ba4b787dfb7ebbbe6ef10f363cb237075f5b37f74467c9408db723d9a36c48
 SHA512:
-  metadata.gz: e7f65ec573b55b840b7b07b9a9c83c7aa189696b162936e63ad65ddf508be3240eb056fc70d3bbbad532eb2f3db841c4facd3efb1df30e9bf816b4f37d8a33e0
-  data.tar.gz: 6a823d728ab547b3ccab050d7a01e9825cb3764446eecb2f32b71ce1c7ff73f7da7f167e9198b9a45f4941b7ed8113c3aac3f1ca95c0a76b46a5b502dd713147
+  metadata.gz: 1a546dca02b403bc025621c1a980cf081114c383f97bd3ce3eef245a7b3314cdaacc7328cbbbfd7879cbf95dd53069e48b9af8f2401099e68966e0ee4e0b624f
+  data.tar.gz: ddb6aabeca04cdbdacfd2412ee2713dfaecc4b17911b55246ec680538874df7725eabef8768fe69c8202952d6a3f14d0a0ae27696cd64ebf2727679f7947cd61

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## [Unreleased]
 
+### Fixed
+- fix Process namespace collision by using ::Process::CLOCK_MONOTONIC prefix inside Legion namespace
+
+### Added
+- `Legion::LLM::Pipeline::ToolAdapter` - wraps Tools::Base for RubyLLM sessions
+
+### Changed
+- Renamed `McpToolAdapter` to `ToolAdapter` (backwards compat alias kept)
+- Pipeline step `McpDiscovery` renamed to `ToolDiscovery`
+- Executor reads from `Legion::Tools::Registry`
+- `chat_single` wraps registry tools with ToolAdapter
+- Routes: executor handles all tool injection, routes only pass client tools
+
+### Removed
+- MCP server dependency for tool injection in routes
+
 ## [0.6.16] - 2026-04-03
 
 ### Fixed

data/CLAUDE.md

@@ -8,7 +8,7 @@
 Core LegionIO gem providing LLM capabilities to all extensions. Wraps ruby_llm to provide a consistent interface for chat, embeddings, tool use, and agents across multiple providers (Bedrock, Anthropic, OpenAI, Gemini, Ollama). Includes a dynamic weighted routing engine that dispatches requests across local, fleet, and cloud tiers based on caller intent, priority rules, time schedules, cost multipliers, and real-time provider health.
 
 **GitHub**: https://github.com/LegionIO/legion-llm
-**Version**: 0.5.15
+**Version**: 0.6.18
 **License**: Apache-2.0
 
 ## Architecture
@@ -61,8 +61,12 @@ Legion::LLM (lib/legion/llm.rb)
 │   ├── Timeline     # Ordered event recording with participant tracking
 │   ├── Executor     # 18-step pipeline skeleton with profile-aware execution
 │   ├── Steps/
-│   │   └── Metering # Metering event builder (absorbed from lex-llm-gateway)
+│   │   ├── Metering       # Metering event builder (absorbed from lex-llm-gateway)
+│   │   └── ToolDiscovery  # Step 9 — formerly McpDiscovery; renamed to ToolDiscovery (McpDiscovery kept as backwards alias)
 │   └── Executor#call_stream # Streaming variant: pre-provider steps, yield chunks, post-provider steps
+│
+│   Note: Legion::LLM::ToolRegistry was removed. Tool registration now lives in Legion::Tools::Registry (LegionIO gem).
+│         McpToolAdapter renamed to ToolAdapter; McpToolAdapter kept as a backwards-compatible alias.
 ├── CostEstimator    # Model cost estimation with fuzzy pricing (absorbed from lex-llm-gateway)
 ├── Fleet            # Fleet RPC dispatch (absorbed from lex-llm-gateway)
 │   ├── Dispatcher   # Fleet dispatch with timeout and availability checks

data/lib/legion/llm/pipeline/executor.rb

@@ -18,7 +18,7 @@ module Legion
                     :audit, :warnings, :discovered_tools, :confidence_score,
                     :escalation_chain
 
-        include Steps::McpDiscovery
+        include Steps::ToolDiscovery
         include Steps::ToolCalls
         include Steps::KnowledgeCapture
         include Steps::ConfidenceScoring
@@ -28,14 +28,14 @@ module Legion
 
         STEPS = %i[
           tracing_init idempotency conversation_uuid context_load
-          rbac classification billing gaia_advisory tier_assignment rag_context mcp_discovery
+          rbac classification billing gaia_advisory tier_assignment rag_context tool_discovery
           routing request_normalization token_budget provider_call response_normalization
           debate confidence_scoring tool_calls context_store post_response knowledge_capture response_return
         ].freeze
 
         PRE_PROVIDER_STEPS = %i[
           tracing_init idempotency conversation_uuid context_load
-          rbac classification billing gaia_advisory tier_assignment rag_context mcp_discovery
+          rbac classification billing gaia_advisory tier_assignment rag_context tool_discovery
           routing request_normalization token_budget
         ].freeze
 
@@ -45,27 +45,6 @@ module Legion
 
         ASYNC_SAFE_STEPS = %i[post_response knowledge_capture response_return].freeze
 
-        ALWAYS_LOADED_MCP_TOOLS = %w[
-          legion_do
-          legion_get_status
-          legion_run_task
-          legion_describe_runner
-          legion_list_extensions
-          legion_get_extension
-          legion_list_tasks
-          legion_get_task
-          legion_get_task_logs
-          legion_query_knowledge
-          legion_knowledge_health
-          legion_knowledge_context
-          legion_list_workers
-          legion_show_worker
-          legion_mesh_status
-          legion_list_peers
-          legion_tools
-          legion_search_sessions
-        ].freeze
-
         ASYNC_THREAD_POOL = Concurrent::FixedThreadPool.new(4, fallback_policy: :caller_runs)
 
         def initialize(request)
@@ -104,27 +83,42 @@ module Legion
 
         private
 
-        def inject_discovered_tools(session)
-          server = mcp_server
-          return unless server.respond_to?(:tool_registry)
+        def inject_registry_tools(session)
+          return unless defined?(::Legion::Tools::Registry)
 
-          requested = requested_deferred_tool_names
           injected_names = []
 
-          server.tool_registry.each do |mcp_tool_class|
-            adapter = McpToolAdapter.new(mcp_tool_class)
-            next unless ALWAYS_LOADED_MCP_TOOLS.include?(adapter.name) || requested.include?(adapter.name)
-
+          # Always-loaded tools — inject all unconditionally
+          ::Legion::Tools::Registry.tools.each do |tool_class|
+            adapter = ToolAdapter.new(tool_class)
             session.with_tool(adapter)
             injected_names << adapter.name
           rescue StandardError => e
-            @warnings << "Failed to inject tool: #{e.message}"
-            handle_exception(e, level: :warn, operation: 'llm.pipeline.inject_tool')
+            @warnings << "Failed to inject always tool: #{e.message}"
+            handle_exception(e, level: :warn, operation: 'llm.pipeline.inject_always_tool')
+          end
+
+          # Requested deferred tools — inject only if explicitly requested
+          deferred = ::Legion::Tools::Registry.respond_to?(:deferred_tools) ? ::Legion::Tools::Registry.deferred_tools : []
+          requested = requested_deferred_tool_names
+          if requested.any?
+            deferred.each do |tool_class|
+              adapter = ToolAdapter.new(tool_class)
+              next unless requested.include?(adapter.name)
+
+              session.with_tool(adapter)
+              injected_names << adapter.name
+            rescue StandardError => e
+              @warnings << "Failed to inject deferred tool: #{e.message}"
+              handle_exception(e, level: :warn, operation: 'llm.pipeline.inject_deferred_tool')
+            end
           end
 
           log.info(
-            "[llm][mcp] inject request_id=#{@request.id} " \
-            "always_loaded=#{ALWAYS_LOADED_MCP_TOOLS.size} requested_deferred=#{requested.size} " \
+            "[llm][tools] inject request_id=#{@request.id} " \
+            "always=#{::Legion::Tools::Registry.tools.size} " \
+            "deferred_available=#{deferred.size} " \
+            "requested_deferred=#{requested.size} " \
             "injected=#{injected_names.size} names=#{injected_names.first(25).join(',')}"
           )
         rescue StandardError => e
@@ -132,6 +126,9 @@ module Legion
           handle_exception(e, level: :warn, operation: 'llm.pipeline.inject_tools')
         end
 
+        # Backwards compatibility alias
+        alias inject_discovered_tools inject_registry_tools
+
         def execute_steps
           executed = 0
           skipped = 0
@@ -678,8 +675,7 @@ module Legion
             session.with_tool(tool)
           end
 
-          ToolRegistry.tools.each { |tool| session.with_tool(tool) } if defined?(ToolRegistry)
-          inject_discovered_tools(session)
+          inject_registry_tools(session)
         end
 
         def apply_ruby_llm_instructions(session)
@@ -864,23 +860,6 @@ module Legion
           )
         end
 
-        def mcp_server
-          return ::Legion::MCP.server if defined?(::Legion::MCP) && ::Legion::MCP.respond_to?(:server)
-
-          require 'legion/mcp'
-          return unless defined?(::Legion::MCP) && ::Legion::MCP.respond_to?(:server)
-
-          ::Legion::MCP.server
-        rescue LoadError => e
-          @warnings << "MCP unavailable: #{e.message}"
-          handle_exception(e, level: :debug, operation: 'llm.pipeline.mcp_server.require')
-          nil
-        rescue StandardError => e
-          @warnings << "MCP server load error: #{e.message}"
-          handle_exception(e, level: :warn, operation: 'llm.pipeline.mcp_server')
-          nil
-        end
-
         def requested_deferred_tool_names
           metadata = @request.metadata || {}
           requested = metadata[:requested_tools] || metadata['requested_tools'] || []

data/lib/legion/llm/pipeline/mcp_tool_adapter.rb

@@ -1,69 +1,5 @@
 # frozen_string_literal: true
 
-require 'ruby_llm'
-require 'legion/logging/helper'
-
-module Legion
-  module LLM
-    module Pipeline
-      class McpToolAdapter < RubyLLM::Tool
-        include Legion::Logging::Helper
-
-        def initialize(mcp_tool_class)
-          @mcp_tool_class = mcp_tool_class
-          raw_name = mcp_tool_class.respond_to?(:tool_name) ? mcp_tool_class.tool_name : mcp_tool_class.name.to_s
-          @tool_name = raw_name.tr('.', '_')
-          @tool_desc = mcp_tool_class.respond_to?(:description) ? mcp_tool_class.description.to_s : ''
-          @tool_schema = mcp_tool_class.respond_to?(:input_schema) ? mcp_tool_class.input_schema : nil
-          super()
-        end
-
-        def name
-          @tool_name
-        end
-
-        def description
-          @tool_desc
-        end
-
-        def params_schema
-          return @params_schema if defined?(@params_schema)
-
-          @params_schema = (RubyLLM::Utils.deep_stringify_keys(@tool_schema) if @tool_schema.is_a?(Hash))
-        end
-
-        def execute(**args)
-          log.info("[llm][tools] adapter.execute name=#{@tool_name} arguments=#{summarize_payload(args)}")
-          result = @mcp_tool_class.call(**args)
-          content = extract_content(result)
-          log.info("[llm][tools] adapter.result name=#{@tool_name} output=#{summarize_payload(content)}")
-          content
-        rescue StandardError => e
-          handle_exception(e, level: :warn, operation: 'llm.pipeline.mcp_tool_adapter.execute', tool_name: @tool_name)
-          "Tool error: #{e.message}"
-        end
-
-        private
-
-        def extract_content(result)
-          # MCP::Tool::Response — has .content array of {type: 'text', text: '...'}
-          if result.respond_to?(:content) && result.content.is_a?(Array)
-            result.content.filter_map { |c| c[:text] || c['text'] || c.to_s }.join("\n")
-          elsif result.is_a?(Hash) && result[:content].is_a?(Array)
-            result[:content].filter_map { |c| c[:text] || c['text'] }.join("\n")
-          elsif result.is_a?(Hash)
-            Legion::JSON.dump(result)
-          elsif result.is_a?(String)
-            result
-          else
-            result.to_s
-          end
-        end
-
-        def summarize_payload(payload)
-          payload.to_s[0, 200].inspect
-        end
-      end
-    end
-  end
-end
+# Backwards-compatibility shim — the implementation moved to tool_adapter.rb.
+# Callers that require this path directly will still find McpToolAdapter via the alias.
+require_relative 'tool_adapter'

data/lib/legion/llm/pipeline/profile.rb

@@ -6,18 +6,18 @@ module Legion
       module Profile
         GAIA_SKIP = %i[
           idempotency conversation_uuid context_load rbac classification
-          billing gaia_advisory mcp_discovery context_store post_response
+          billing gaia_advisory tool_discovery context_store post_response
         ].freeze
 
         SYSTEM_SKIP = %i[
           idempotency conversation_uuid context_load rbac classification
-          billing gaia_advisory rag_context mcp_discovery context_store
+          billing gaia_advisory rag_context tool_discovery context_store
           post_response
         ].freeze
 
         QUICK_REPLY_SKIP = %i[
           idempotency conversation_uuid context_load classification
-          gaia_advisory rag_context mcp_discovery confidence_scoring
+          gaia_advisory rag_context tool_discovery confidence_scoring
           tool_calls context_store post_response knowledge_capture
         ].freeze
 

data/lib/legion/llm/pipeline/steps/tool_discovery.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'legion/logging/helper'
+
+module Legion
+  module LLM
+    module Pipeline
+      module Steps
+        module ToolDiscovery
+          include Legion::Logging::Helper
+
+          def step_tool_discovery
+            @discovered_tools ||= []
+            start_time = Time.now
+
+            discover_registry_tools
+            discover_client_tools
+
+            total = @discovered_tools.size
+            if total.positive?
+              sources = @discovered_tools.filter_map { |t| t.dig(:source, :server) || t.dig(:source, :type) }.uniq
+              @enrichments['tool:discovery'] = {
+                content:   "#{total} tools from #{sources.length} sources",
+                data:      { tool_count: total, sources: sources },
+                timestamp: Time.now
+              }
+            end
+
+            record_tool_discovery_timeline(total, start_time)
+          rescue StandardError => e
+            @warnings << "Tool discovery error: #{e.message}"
+            handle_exception(e, level: :warn, operation: 'llm.pipeline.steps.tool_discovery')
+            record_tool_discovery_timeline(0)
+          end
+
+          # Backwards compatibility alias — step name used in STEPS array is tool_discovery
+          alias step_mcp_discovery step_tool_discovery
+
+          private
+
+          def discover_registry_tools
+            return unless defined?(::Legion::Tools::Registry)
+
+            ::Legion::Tools::Registry.tools.each do |tool_class|
+              name = tool_class.respond_to?(:tool_name) ? tool_class.tool_name : tool_class.name
+              desc = tool_class.respond_to?(:description) ? tool_class.description : ''
+              schema = tool_class.respond_to?(:input_schema) ? tool_class.input_schema : {}
+              @discovered_tools << {
+                name:        name,
+                description: desc,
+                parameters:  schema,
+                source:      { type: :registry, server: 'legion' }
+              }
+            end
+
+            log.info(
+              "[llm][tools] discover request_id=#{@request.id} " \
+              "registry_tools=#{::Legion::Tools::Registry.tools.size}"
+            )
+          rescue StandardError => e
+            @warnings << "Registry tool discovery error: #{e.message}"
+            handle_exception(e, level: :warn, operation: 'llm.pipeline.steps.tool_discovery.registry')
+          end
+
+          def discover_client_tools
+            return unless defined?(::Legion::MCP::Client::Pool)
+
+            ::Legion::MCP::Client::Pool.all_tools.each do |tool|
+              @discovered_tools << {
+                name:        tool[:name],
+                description: tool[:description],
+                parameters:  tool[:input_schema],
+                source:      tool[:source]
+              }
+            end
+          rescue StandardError => e
+            @warnings << "Client tool discovery error: #{e.message}"
+            handle_exception(e, level: :warn, operation: 'llm.pipeline.steps.tool_discovery.client')
+          end
+
+          def record_tool_discovery_timeline(count, start_time = nil)
+            duration = start_time ? ((Time.now - start_time) * 1000).to_i : 0
+            @timeline.record(
+              category: :enrichment, key: 'tool:discovery',
+              direction: :inbound, detail: "#{count} tools discovered",
+              from: 'tool_registry', to: 'pipeline',
+              duration_ms: duration
+            )
+          end
+        end
+
+        # Backwards compatibility alias
+        McpDiscovery = ToolDiscovery
+      end
+    end
+  end
+end

data/lib/legion/llm/pipeline/steps.rb

@@ -17,7 +17,7 @@ require_relative 'steps/billing'
 require_relative 'steps/gaia_advisory'
 require_relative 'steps/tier_assigner'
 require_relative 'steps/post_response'
-require_relative 'steps/mcp_discovery'
+require_relative 'steps/tool_discovery'
 require_relative 'steps/tool_calls'
 require_relative 'steps/rag_context'
 require_relative 'steps/rag_guard'

data/lib/legion/llm/pipeline/tool_adapter.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'ruby_llm'
+require 'legion/logging/helper'
+
+module Legion
+  module LLM
+    module Pipeline
+      class ToolAdapter < RubyLLM::Tool
+        include Legion::Logging::Helper
+
+        MAX_TOOL_NAME_LENGTH = 64
+
+        def initialize(tool_class)
+          @tool_class = tool_class
+          raw_name = tool_class.respond_to?(:tool_name) ? tool_class.tool_name : tool_class.name.to_s
+          @tool_name = sanitize_tool_name(raw_name)
+          @tool_desc = tool_class.respond_to?(:description) ? tool_class.description.to_s : ''
+          @tool_schema = tool_class.respond_to?(:input_schema) ? tool_class.input_schema : nil
+          super()
+        end
+
+        def name
+          @tool_name
+        end
+
+        def description
+          @tool_desc
+        end
+
+        def params_schema
+          return @params_schema if defined?(@params_schema)
+
+          @params_schema = (RubyLLM::Utils.deep_stringify_keys(@tool_schema) if @tool_schema.is_a?(Hash))
+        end
+
+        def execute(**args)
+          log.info("[llm][tools] adapter.execute name=#{@tool_name} arguments=#{summarize_payload(args)}")
+          result = @tool_class.call(**args)
+          content = extract_content(result)
+          log.info("[llm][tools] adapter.result name=#{@tool_name} output=#{summarize_payload(content)}")
+          content
+        rescue StandardError => e
+          handle_exception(e, level: :warn, operation: 'llm.pipeline.tool_adapter.execute', tool_name: @tool_name)
+          "Tool error: #{e.message}"
+        end
+
+        private
+
+        def extract_content(result)
+          # MCP::Tool::Response — has .content array of {type: 'text', text: '...'}
+          if result.respond_to?(:content) && result.content.is_a?(Array)
+            result.content.filter_map { |c| c[:text] || c['text'] || c.to_s }.join("\n")
+          elsif result.is_a?(Hash) && result[:content].is_a?(Array)
+            result[:content].filter_map { |c| c[:text] || c['text'] }.join("\n")
+          elsif result.is_a?(Hash)
+            Legion::JSON.dump(result)
+          elsif result.is_a?(String)
+            result
+          else
+            result.to_s
+          end
+        end
+
+        def summarize_payload(payload)
+          payload.to_s[0, 200].inspect
+        end
+
+        # Bedrock constraints: [a-zA-Z0-9_-]+ and max 64 chars.
+        # Falls back to a stable name derived from the class object_id if sanitization yields
+        # an empty string (e.g. all chars stripped), ensuring the result always satisfies the
+        # at-least-one-character requirement.
+        def sanitize_tool_name(raw)
+          name = raw.tr('.', '_')
+          name = name.gsub(/[^a-zA-Z0-9_-]/, '') # strip ?, !, etc.
+          name = name[0, MAX_TOOL_NAME_LENGTH] if name.length > MAX_TOOL_NAME_LENGTH
+          name.empty? ? "tool_#{@tool_class.object_id}" : name
+        end
+      end
+
+      # Backwards compatibility alias
+      McpToolAdapter = ToolAdapter
+    end
+  end
+end

data/lib/legion/llm/pipeline.rb

@@ -11,7 +11,7 @@ require_relative 'pipeline/gaia_caller'
 require_relative 'pipeline/tool_dispatcher'
 require_relative 'pipeline/enrichment_injector'
 require_relative 'pipeline/steps'
-require_relative 'pipeline/mcp_tool_adapter'
+require_relative 'pipeline/tool_adapter'
 require_relative 'pipeline/executor'
 
 module Legion

data/lib/legion/llm/routes.rb

@@ -12,17 +12,6 @@ require 'open3'
 require 'time'
 require 'legion/logging/helper'
 
-begin
-  require 'legion/cli/chat/tools/search_traces'
-  if defined?(Legion::LLM::ToolRegistry) && defined?(Legion::CLI::Chat::Tools::SearchTraces)
-    Legion::LLM::ToolRegistry.register(Legion::CLI::Chat::Tools::SearchTraces)
-  end
-rescue LoadError => e
-  if defined?(Legion::Logging) && Legion::Logging.respond_to?(:log_exception)
-    Legion::Logging.log_exception(e, payload_summary: 'SearchTraces not available for API', component_type: :api)
-  end
-end
-
 module Legion
   module LLM
     module Routes
@@ -214,34 +203,6 @@ module Legion
           end
           # rubocop:enable Metrics/BlockLength
 
-          define_method(:cached_mcp_tools) do
-            @@llm_cached_mcp_tools ||= begin # rubocop:disable Style/ClassVars
-              all = []
-              if defined?(Legion::MCP) && Legion::MCP.respond_to?(:server)
-                Legion::MCP.server
-                if defined?(Legion::MCP::Server) && Legion::MCP::Server.respond_to?(:tool_registry)
-                  require 'legion/llm/pipeline/mcp_tool_adapter' unless defined?(Legion::LLM::Pipeline::McpToolAdapter)
-                  Legion::MCP::Server.tool_registry.each do |tc|
-                    all << Legion::LLM::Pipeline::McpToolAdapter.new(tc)
-                  rescue StandardError
-                    nil
-                  end
-                end
-              end
-              always_names = %w[legion_do legion_get_status legion_run_task legion_describe_runner
-                                legion_list_extensions legion_get_extension legion_list_tasks
-                                legion_get_task legion_get_task_logs legion_query_knowledge
-                                legion_knowledge_health legion_knowledge_context legion_list_workers
-                                legion_show_worker legion_mesh_status legion_list_peers
-                                legion_tools legion_search_sessions]
-              {
-                always:   all.select { |t| always_names.include?(t.name) }.freeze,
-                deferred: all.reject { |t| always_names.include?(t.name) }.freeze,
-                all:      all.freeze
-              }.freeze
-            end
-          end
-
           define_method(:extract_tool_calls) do |pipeline_response|
             tools_data = pipeline_response.tools
             return [] unless tools_data.is_a?(Array) && !tools_data.empty?
@@ -505,16 +466,7 @@ module Legion
             build_client_tool_class(ts[:name].to_s, ts[:description].to_s, ts[:parameters] || ts[:input_schema])
           end
 
-          # Inject daemon MCP tools alongside client tools
-          all_tools = tool_declarations.dup
-          begin
-            mcp_tools = cached_mcp_tools
-            mcp_to_inject = Array(requested_tools).empty? ? mcp_tools[:always] : mcp_tools[:all]
-            all_tools.concat(mcp_to_inject) if mcp_to_inject&.any?
-            log.unknown "[llm][api] inference tools client=#{tool_declarations.size} mcp=#{mcp_to_inject&.size || 0} total=#{all_tools.size}"
-          rescue StandardError => e
-            handle_exception(e, level: :warn, operation: 'llm.routes.mcp_tool_injection', request_id: request_id)
-          end
+          log.unknown "[llm][api] inference tools client=#{tool_declarations.size}"
 
           streaming = body[:stream] == true && request.preferred_type.to_s.include?('text/event-stream')
           normalized_caller = caller_context.respond_to?(:transform_keys) ? caller_context.transform_keys(&:to_sym) : {}
@@ -541,7 +493,7 @@ module Legion
             messages:        messages,
             system:          body[:system],
             routing:         { provider: provider, model: model },
-            tools:           all_tools,
+            tools:           tool_declarations,
             caller:          effective_caller,
             conversation_id: conversation_id,
             metadata:        { requested_tools: requested_tools },

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.6.16'
+    VERSION = '0.6.18'
   end
 end

data/lib/legion/llm.rb

@@ -32,7 +32,6 @@ require_relative 'llm/scheduling'
 require_relative 'llm/off_peak'
 require_relative 'llm/cost_tracker'
 require_relative 'llm/token_tracker'
-require_relative 'llm/tool_registry'
 require_relative 'llm/override_confidence'
 require_relative 'llm/routes'
 
@@ -108,7 +107,7 @@ module Legion
       # for automatic metering and fleet dispatch
       def chat(model: nil, provider: nil, intent: nil, tier: nil, escalate: nil,
                max_escalations: nil, quality_check: nil, message: nil, **kwargs, &)
-        started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        started_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
         log_inference_request(
           request_type:       :chat,
           requested_model:    model,
@@ -154,7 +153,7 @@ module Legion
       # Send a single message — daemon-first, falls through to direct on unavailability.
       def ask(message:, model: nil, provider: nil, intent: nil, tier: nil,
               context: {}, identity: nil, &)
-        started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        started_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
         log_inference_request(
           request_type:       :ask,
           requested_model:    model,
@@ -367,7 +366,7 @@ module Legion
       end
 
       def elapsed_ms_since(started_at)
-        ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round
+        ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - started_at) * 1000).round
       end
 
       def inference_input_payload(message:, messages:)
@@ -644,7 +643,7 @@ module Legion
 
       def chat_single(model:, provider:, intent:, tier:, message: nil, **kwargs, &block)
         explicit_tools = kwargs.delete(:tools)
-        tools = explicit_tools || ToolRegistry.tools
+        tools = explicit_tools || adapted_registry_tools
         tools = nil if tools.empty?
 
         if (intent || tier) && Router.routing_enabled?
@@ -687,6 +686,24 @@ module Legion
         response
       end
 
+      def adapted_registry_tools
+        tool_classes = if defined?(::Legion::Tools::Registry)
+                         ::Legion::Tools::Registry.tools
+                       else
+                         return []
+                       end
+
+        tool_classes.map do |tool_class|
+          Pipeline::ToolAdapter.new(tool_class)
+        rescue StandardError => e
+          handle_exception(e, level: :warn, operation: 'llm.adapted_registry_tools', tool_class: tool_class.to_s)
+          nil
+        end.compact
+      rescue StandardError => e
+        handle_exception(e, level: :warn, operation: 'llm.adapted_registry_tools')
+        []
+      end
+
       def try_defer(intent:, urgency:, model:, provider:, message:, **)
         return nil unless Scheduling.enabled? && Scheduling.should_defer?(intent: intent || :normal, urgency: urgency)
         return nil unless defined?(Batch) && Batch.enabled?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.6.16
+  version: 0.6.18
 platform: ruby
 authors:
 - Esity
@@ -287,7 +287,9 @@ files:
 - lib/legion/llm/pipeline/steps/tier_assigner.rb
 - lib/legion/llm/pipeline/steps/token_budget.rb
 - lib/legion/llm/pipeline/steps/tool_calls.rb
+- lib/legion/llm/pipeline/steps/tool_discovery.rb
 - lib/legion/llm/pipeline/timeline.rb
+- lib/legion/llm/pipeline/tool_adapter.rb
 - lib/legion/llm/pipeline/tool_dispatcher.rb
 - lib/legion/llm/pipeline/tracing.rb
 - lib/legion/llm/provider_registry.rb
@@ -306,7 +308,6 @@ files:
 - lib/legion/llm/shadow_eval.rb
 - lib/legion/llm/structured_output.rb
 - lib/legion/llm/token_tracker.rb
-- lib/legion/llm/tool_registry.rb
 - lib/legion/llm/transport/exchanges/audit.rb
 - lib/legion/llm/transport/exchanges/escalation.rb
 - lib/legion/llm/transport/messages/audit_event.rb

data/lib/legion/llm/tool_registry.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/logging/helper'
-
-module Legion
-  module LLM
-    module ToolRegistry
-      extend Legion::Logging::Helper
-
-      @tools = []
-      @mutex = Mutex.new
-
-      class << self
-        def register(tool_class)
-          registered = @mutex.synchronize do
-            next false if @tools.include?(tool_class)
-
-            @tools << tool_class
-            true
-          end
-          if registered
-            log.info("[llm][tools] registered class=#{tool_class}")
-          else
-            log.debug("[llm][tools] already_registered class=#{tool_class}")
-          end
-        end
-
-        def tools
-          @mutex.synchronize { @tools.dup }
-        end
-
-        def clear
-          count = @mutex.synchronize { @tools.size }
-          @mutex.synchronize { @tools.clear }
-          log.info("[llm][tools] registry_cleared count=#{count}")
-        end
-      end
-    end
-  end
-end