legion-llm 0.6.16 → 0.6.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fe6246015e9967dec5bbe428ab2cb5869b4a359c4a5b40c0a8206d0fe7b516d
-  data.tar.gz: f803de963b1887d064506187c3d7c8fa00b437613f5456bcbf87adae1d53a3a4
+  metadata.gz: 85bd29db06078f900c983a6f722cda55d6c3c5c6a72c6e4fdb8c4295c3debddb
+  data.tar.gz: 855d18648dbe9d8e02e886011c51e35dd5f7d0828a25529428fb6f865c9b5f62
 SHA512:
-  metadata.gz: e7f65ec573b55b840b7b07b9a9c83c7aa189696b162936e63ad65ddf508be3240eb056fc70d3bbbad532eb2f3db841c4facd3efb1df30e9bf816b4f37d8a33e0
-  data.tar.gz: 6a823d728ab547b3ccab050d7a01e9825cb3764446eecb2f32b71ce1c7ff73f7da7f167e9198b9a45f4941b7ed8113c3aac3f1ca95c0a76b46a5b502dd713147
+  metadata.gz: 063beb13698b8645a8c365ccc1bde00d599b7653df47304d311b4c829b7de277e13e9443c5d693fe22668ee5855d3c2d33187eb8ed4af71dc0f744a59cdceaed
+  data.tar.gz: 4244f8d0af82a82c3a45cc483c9939fe492ef7350e43cdbf2f4d5b933210b6154150e038f02931f52943c5ad8918d6b6247d4c8debc29b083ea55336c5daf570

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+### 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/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
 
@@ -66,6 +66,8 @@ module Legion
           legion_search_sessions
         ].freeze
 
+        private_constant :ALWAYS_LOADED_MCP_TOOLS
+
         ASYNC_THREAD_POOL = Concurrent::FixedThreadPool.new(4, fallback_policy: :caller_runs)
 
         def initialize(request)
@@ -104,16 +106,16 @@ 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
+          always_loaded = always_loaded_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)
+          ::Legion::Tools::Registry.tools.each do |tool_class|
+            adapter = ToolAdapter.new(tool_class)
+            next unless always_loaded.include?(adapter.name) || requested.include?(adapter.name)
 
             session.with_tool(adapter)
             injected_names << adapter.name
@@ -123,8 +125,8 @@ module Legion
           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_loaded=#{always_loaded.size} requested_deferred=#{requested.size} " \
             "injected=#{injected_names.size} names=#{injected_names.first(25).join(',')}"
           )
         rescue StandardError => e
@@ -132,6 +134,18 @@ module Legion
           handle_exception(e, level: :warn, operation: 'llm.pipeline.inject_tools')
         end
 
+        # Backwards compatibility alias
+        alias inject_discovered_tools inject_registry_tools
+
+        def always_loaded_tool_names
+          return ALWAYS_LOADED_MCP_TOOLS unless defined?(::Legion::Tools::Registry)
+
+          names = ::Legion::Tools::Registry.always_loaded_names.map { |name| name.to_s.tr('.', '_') }
+          names.any? ? names : ALWAYS_LOADED_MCP_TOOLS
+        rescue StandardError
+          ALWAYS_LOADED_MCP_TOOLS
+        end
+
         def execute_steps
           executed = 0
           skipped = 0
@@ -678,8 +692,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 +877,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/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,72 @@
+# 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
+
+        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 = raw_name.tr('.', '_')
+          @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
+      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

@@ -214,34 +214,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 +477,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 +504,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.17'
   end
 end

data/lib/legion/llm.rb

@@ -644,7 +644,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 +687,26 @@ module Legion
         response
       end
 
+      def adapted_registry_tools
+        tool_classes = if defined?(::Legion::Tools::Registry)
+                         ::Legion::Tools::Registry.tools
+                       elsif defined?(::Legion::LLM::ToolRegistry)
+                         ::Legion::LLM::ToolRegistry.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.17
 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