legion-llm 0.6.17 → 0.6.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85bd29db06078f900c983a6f722cda55d6c3c5c6a72c6e4fdb8c4295c3debddb
-  data.tar.gz: 855d18648dbe9d8e02e886011c51e35dd5f7d0828a25529428fb6f865c9b5f62
+  metadata.gz: 83b1bf0eb338e47eb37627eb7004afb30b3fba91627577034554827edd797bcf
+  data.tar.gz: 54ba4b787dfb7ebbbe6ef10f363cb237075f5b37f74467c9408db723d9a36c48
 SHA512:
-  metadata.gz: 063beb13698b8645a8c365ccc1bde00d599b7653df47304d311b4c829b7de277e13e9443c5d693fe22668ee5855d3c2d33187eb8ed4af71dc0f744a59cdceaed
-  data.tar.gz: 4244f8d0af82a82c3a45cc483c9939fe492ef7350e43cdbf2f4d5b933210b6154150e038f02931f52943c5ad8918d6b6247d4c8debc29b083ea55336c5daf570
+  metadata.gz: 1a546dca02b403bc025621c1a980cf081114c383f97bd3ce3eef245a7b3314cdaacc7328cbbbfd7879cbf95dd53069e48b9af8f2401099e68966e0ee4e0b624f
+  data.tar.gz: ddb6aabeca04cdbdacfd2412ee2713dfaecc4b17911b55246ec680538874df7725eabef8768fe69c8202952d6a3f14d0a0ae27696cd64ebf2727679f7947cd61

data/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [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
 

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,29 +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
-
-        private_constant :ALWAYS_LOADED_MCP_TOOLS
-
         ASYNC_THREAD_POOL = Concurrent::FixedThreadPool.new(4, fallback_policy: :caller_runs)
 
         def initialize(request)
@@ -109,24 +86,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,15 +129,6 @@ 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

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/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

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.6.17'
+    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:)
@@ -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.18
 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