legion-llm 0.6.17 → 0.6.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85bd29db06078f900c983a6f722cda55d6c3c5c6a72c6e4fdb8c4295c3debddb
-  data.tar.gz: 855d18648dbe9d8e02e886011c51e35dd5f7d0828a25529428fb6f865c9b5f62
+  metadata.gz: 45d07a2c60a8663ba1b62165b3b489d49a2aac37ee1e1ec6abff7bd5f4357d6c
+  data.tar.gz: 9ee8246c75fee6d7e690b55f4e2a91b030f6b142c91dd79acb7bf66edf4d9d05
 SHA512:
-  metadata.gz: 063beb13698b8645a8c365ccc1bde00d599b7653df47304d311b4c829b7de277e13e9443c5d693fe22668ee5855d3c2d33187eb8ed4af71dc0f744a59cdceaed
-  data.tar.gz: 4244f8d0af82a82c3a45cc483c9939fe492ef7350e43cdbf2f4d5b933210b6154150e038f02931f52943c5ad8918d6b6247d4c8debc29b083ea55336c5daf570
+  metadata.gz: 92b102167bb6f346fab490787baedda2f2fa6fb528713c6b055b269f747c490d56fed5d21027616bc2c6d1f7cf4069ce14bb9b7607f7a6ad07c2c69b05ce0814
+  data.tar.gz: f1fded39722bf678936df28f3bbf3ec095265bdabc28f70eaf67e64fae5519b7c58842a8432e4b4bfdc0476c9275473f75a9c83bf0c77d6f5cc2afe1fa700aeb

data/CHANGELOG.md

@@ -1,9 +1,22 @@
 # Legion LLM Changelog
 
-## [Unreleased]
+## [0.6.20] - 2026-04-06
+
+### Added
+- Per-step pipeline timing diagnostics: `[pipeline][timing]` log line with duration per step
+- Pre-pipeline timing in inference route: `gaia_ingest`, `pre_pipeline_setup`, `executor_call` durations
+- `MAX_RUBY_LLM_TOOL_ROUNDS` (25) — caps RubyLLM's unbounded tool-use loop to prevent infinite cycling
+- `install_tool_loop_guard` applied to both streaming and non-streaming provider paths
+
+### 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
+- `Profile.derive` returns `:human` for `type: :human` and `type: :user` callers (Wire Format Phase 3)
+- `Profile.derive` returns `:service` for `type: :service` callers (Wire Format Phase 3)
+- `HUMAN_SKIP` constant (empty — humans get full pipeline)
+- `SERVICE_SKIP` constant — services skip conversational steps (context, tools, knowledge)
 
 ### Changed
 - Renamed `McpToolAdapter` to `ToolAdapter` (backwards compat alias kept)

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

@@ -45,28 +45,7 @@ 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
-
-        private_constant :ALWAYS_LOADED_MCP_TOOLS
+        MAX_RUBY_LLM_TOOL_ROUNDS = 25
 
         ASYNC_THREAD_POOL = Concurrent::FixedThreadPool.new(4, fallback_policy: :caller_runs)
 
@@ -109,24 +88,39 @@ module Legion
         def inject_registry_tools(session)
           return unless defined?(::Legion::Tools::Registry)
 
-          requested = requested_deferred_tool_names
-          always_loaded = always_loaded_tool_names
           injected_names = []
 
+          # Always-loaded tools — inject all unconditionally
           ::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
           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][tools] inject request_id=#{@request.id} " \
-            "always_loaded=#{always_loaded.size} requested_deferred=#{requested.size} " \
+            "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
@@ -137,27 +131,25 @@ module Legion
         # 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
+          pipeline_start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+          step_timings = []
           STEPS.each do |step|
             if Profile.skip?(@profile, step)
               skipped += 1
               next
             end
 
+            t0 = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             execute_step(step) { send(:"step_#{step}") }
+            elapsed_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - t0) * 1000).round
+            step_timings << "#{step}=#{elapsed_ms}ms"
             executed += 1
           end
+          total_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - pipeline_start) * 1000).round
+          log.warn("[pipeline][timing] profile=#{@profile} total=#{total_ms}ms executed=#{executed} skipped=#{skipped} #{step_timings.join(' ')}")
           annotate_top_level_span(steps_executed: executed, steps_skipped: skipped)
         end
 
@@ -481,6 +473,7 @@ module Legion
 
         def execute_provider_request_ruby_llm
           session, message_content = build_ruby_llm_session
+          install_tool_loop_guard(session)
           @raw_response = message_content ? session.ask(message_content) : session
         end
 
@@ -662,6 +655,7 @@ module Legion
           )
 
           session, message_content = build_ruby_llm_session
+          install_tool_loop_guard(session)
           @raw_response = message_content ? session.ask(message_content, &) : session
 
           @timestamps[:provider_end] = Time.now
@@ -695,6 +689,19 @@ module Legion
           inject_registry_tools(session)
         end
 
+        def install_tool_loop_guard(session)
+          return unless session.respond_to?(:on)
+
+          tool_round = 0
+          session.on(:tool_call) do |_tool_call|
+            tool_round += 1
+            if tool_round > MAX_RUBY_LLM_TOOL_ROUNDS
+              log.warn("[pipeline] tool loop cap hit: #{tool_round} rounds, halting")
+              raise Legion::LLM::PipelineError, "tool loop exceeded #{MAX_RUBY_LLM_TOOL_ROUNDS} rounds"
+            end
+          end
+        end
+
         def apply_ruby_llm_instructions(session)
           injected_system = EnrichmentInjector.inject(
             system:      @request.system,

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

@@ -21,6 +21,14 @@ module Legion
           tool_calls context_store post_response knowledge_capture
         ].freeze
 
+        HUMAN_SKIP = %i[].freeze
+
+        SERVICE_SKIP = %i[
+          conversation_uuid context_load gaia_advisory
+          rag_context tool_discovery confidence_scoring
+          tool_calls context_store knowledge_capture
+        ].freeze
+
         module_function
 
         def derive(caller_hash)
@@ -31,7 +39,9 @@ module Legion
           identity = requested_by[:identity].to_s
 
           return :quick_reply if type == :quick_reply
-          return :external unless type == :system
+          return :human       if %i[human user].include?(type)
+          return :service     if type == :service
+          return :external    unless type == :system
 
           identity.start_with?('gaia:') ? :gaia : :system
         end
@@ -41,6 +51,8 @@ module Legion
           when :gaia        then GAIA_SKIP.include?(step)
           when :system      then SYSTEM_SKIP.include?(step)
           when :quick_reply then QUICK_REPLY_SKIP.include?(step)
+          when :human       then HUMAN_SKIP.include?(step)
+          when :service     then SERVICE_SKIP.include?(step)
           else false
           end
         end

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

@@ -9,10 +9,12 @@ module Legion
       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 = raw_name.tr('.', '_')
+          @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()
@@ -63,6 +65,17 @@ module Legion
         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

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
@@ -457,8 +446,11 @@ module Legion
           last_user = messages.select { |m| (m[:role] || m['role']).to_s == 'user' }.last
           prompt    = (last_user || {})[:content] || (last_user || {})['content'] || ''
 
+          route_t0 = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
           if defined?(Legion::Gaia) && Legion::Gaia.respond_to?(:started?) && Legion::Gaia.started? && prompt.to_s.length.positive?
             begin
+              gaia_t0 = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
               frame = Legion::Gaia::InputFrame.new(
                 content:      prompt,
                 channel_id:   :api,
@@ -467,6 +459,8 @@ module Legion
                 metadata:     { source_type: :human_direct, salience: 0.9 }
               )
               Legion::Gaia.ingest(frame)
+              gaia_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - gaia_t0) * 1000).round
+              log.warn("[inference][timing] gaia_ingest=#{gaia_ms}ms request_id=#{request_id}")
             rescue StandardError => e
               handle_exception(e, level: :warn, operation: 'llm.routes.gaia_ingest', request_id: request_id)
             end
@@ -512,6 +506,9 @@ module Legion
             cache:           { strategy: :default, cacheable: true }
           )
 
+          setup_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - route_t0) * 1000).round
+          log.warn("[inference][timing] pre_pipeline_setup=#{setup_ms}ms request_id=#{request_id}")
+
           executor = Legion::LLM::Pipeline::Executor.new(pipeline_request)
 
           if streaming
@@ -572,7 +569,10 @@ module Legion
             end
             # rubocop:enable Metrics/BlockLength
           else
+            exec_t0 = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             pipeline_response = executor.call
+            exec_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - exec_t0) * 1000).round
+            log.warn("[inference][timing] executor_call=#{exec_ms}ms request_id=#{request_id}")
             raw_msg = pipeline_response.message
             content = raw_msg.is_a?(Hash) ? (raw_msg[:content] || raw_msg['content']) : raw_msg.to_s
             routing = pipeline_response.routing || {}

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.6.17'
+    VERSION = '0.6.20'
   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:)
@@ -690,8 +689,6 @@ module Legion
       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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.6.17
+  version: 0.6.20
 platform: ruby
 authors:
 - Esity
@@ -308,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