legion-mcp 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60a58443e45b7bb2ffc897534a7b092bf4d5c152b2206e4268a8a8c9ff6a1755
-  data.tar.gz: 178682013f6738d801d382b32e85161044c2ed48a0e8cc979a0361f542fa0f70
+  metadata.gz: 1f74d80bf3fc37b0b0130f77f38d7b1611c3efa6ab193085022d3aa1462e3ad4
+  data.tar.gz: a9ca6d64d2f3c089a787258e4ac88855d9f5d149c22eef1863bfa429157b70ed
 SHA512:
-  metadata.gz: 0b18864b7e771313db5d679018614dfd3b380fa2d55eb4f954310f90881efe04bc49c082e090db7e6b2b0b405c48a9b91d62f35ffb6a268ff64b2a9652c8f1db
-  data.tar.gz: 26b516e3471032d36cbcc580fed82da09615be5dd0777321ed3147d020afe2260dab6175ab086a4e3cfa60471160b481a2de99c9d55e328e0925bf534e2a6b36
+  metadata.gz: cd0bf2a74ac997e5ce7db2bee56a6e9d821f6244ba211c41be054700bfeb7037c557079b6616403a4f188193133d2b2087f496a0ea7be43eec96694e6feed9b9
+  data.tar.gz: af2d74fa1eeb888753a815af65e9a4527fc00d44dfdf4941abc9955f1da539606f3284413518b0b618bcd50c71894ef5f37750154cbf3f35ae224390a89b4204

data/CHANGELOG.md

@@ -1,19 +1,15 @@
 # legion-mcp Changelog
 
-## [Unreleased]
-
-### Added
-- `Legion::MCP::ToolAdapter` - wraps Tools::Base into MCP::Tool
-- `rebuild_tool_registry` method for dynamic tool registration
+## [0.7.4] - 2026-04-06
 
 ### Changed
-- Tool registry populated from `Legion::Tools::Registry` via ToolAdapter
-- `DeferredRegistry` reads canonical classification with `reset_cache!`
-- `EmbeddingIndex` uses `Tools::EmbeddingCache` for persistent caching
-- `FunctionDiscovery` delegates to `Tools::Discovery` with double-fire guard
+- `STATIC_TOOLS` renamed to `MCP_SPECIFIC_TOOLS` (6 MCP-only tools)
+- `Catalog::Registry` calls replaced with `Tools::Registry` in catalog_dispatcher
 
 ### Removed
-- Direct tool ownership (tools live in LegionIO now)
+- `CatalogBridge` module (replaced by `Tools::Registry`)
+- `dynamic_tool_list`, `dispatch_catalog_tool`, `register_catalog_listener` from server.rb
+- Stale spec files for catalog integration
 
 ## [0.7.2] - 2026-04-03
 

data/CLAUDE.md

@@ -7,7 +7,7 @@
 Standalone gem providing the Model Context Protocol (MCP) server for LegionIO. Extracted from LegionIO to enable independent versioning and reuse. Includes semantic tool matching, observation pipeline, context compilation, tiered inference (Tier 0/1/2), and tool governance.
 
 **GitHub**: https://github.com/LegionIO/legion-mcp
-**Version**: 0.6.2
+**Version**: 0.7.4
 **License**: Apache-2.0
 **Ruby**: >= 3.4
 
@@ -15,20 +15,30 @@ Standalone gem providing the Model Context Protocol (MCP) server for LegionIO. E
 
 ```
 Legion::MCP
-├── Server              # MCP::Server builder, TOOL_CLASSES registration, governance-aware build
+├── Server              # MCP::Server builder, governance-aware build; tool list sourced from Legion::Tools::Registry via DeferredRegistry
 ├── Auth                # JWT + API key authentication
 ├── ToolGovernance      # Risk-tier tool filtering + invocation audit
 ├── ContextCompiler     # Keyword + semantic tool matching, blended scoring (60% semantic + 40% keyword)
-├── EmbeddingIndex      # In-memory vector cache for semantic tool matching
+├── EmbeddingIndex      # Semantic tool matching; delegates embedding persistence to Tools::EmbeddingCache (L0-L4)
 ├── Observer            # Instrumentation pipeline: counters, ring buffer, pattern promotion
 ├── UsageFilter         # Frequency/recency/keyword scoring for dynamic tool filtering
 ├── PatternStore        # 4-layer degrading storage (L0 memory, L1 cache, L2 local SQLite)
 ├── TierRouter          # Confidence-gated tier selection (Tier 0/1/2)
 ├── ContextGuard        # Staleness, rapid-fire, anomaly detection guards
-├── Tools/              # 59 MCP::Tool subclasses (legion.* namespace)
+├── ToolAdapter         # Adapts Legion::Tools::Base subclasses to MCP SDK format (McpToolAdapter kept as alias)
+├── DeferredRegistry    # Reads deferred tools from Legion::Tools::Registry at request time
+├── Tools/              # MCP_SPECIFIC_TOOLS only (6 registered); remaining tool files exist but are not registered in Server.tool_registry — extension tools discovered via Legion::Tools::Discovery
 └── Resources/          # RunnerCatalog, ExtensionInfo
 ```
 
+### Tool Registry Migration Notes
+
+- **Before**: legion-mcp owned 57+ individual `Tools/*.rb` files registered in `TOOL_CLASSES`.
+- **After**: Tools discovered dynamically via `Legion::Tools::Discovery` from extension `runner_modules` at boot. `Legion::Tools::Registry` classifies each as `:always` or `:deferred`. `DeferredRegistry` resolves the deferred set at request time.
+- `MCP_SPECIFIC_TOOLS` (6 tools) covers MCP-only concerns not owned by any extension.
+- `CatalogBridge` removed — bridged old `Extensions::Capability` / `Catalog::Registry` which no longer exist.
+- `EmbeddingIndex` uses `Legion::Tools::EmbeddingCache` (5-tier L0–L4) instead of its own in-memory store.
+
 ## Dependencies
 
 | Gem | Required | Purpose |
@@ -65,17 +75,19 @@ All optional dependencies use `defined?()` guards:
 |------|---------|
 | `lib/legion/mcp.rb` | Entry point: `Legion::MCP.server` singleton factory |
 | `lib/legion/mcp/version.rb` | `Legion::MCP::VERSION` constant |
-| `lib/legion/mcp/server.rb` | MCP::Server builder, TOOL_CLASSES array, governance-aware build |
+| `lib/legion/mcp/server.rb` | MCP::Server builder, governance-aware build; reads tools from Tools::Registry |
 | `lib/legion/mcp/auth.rb` | JWT + API key authentication |
 | `lib/legion/mcp/tool_governance.rb` | Risk-tier tool filtering + invocation audit |
 | `lib/legion/mcp/context_compiler.rb` | Keyword + semantic tool matching (60/40 blend) |
-| `lib/legion/mcp/embedding_index.rb` | In-memory vector cache for semantic matching |
+| `lib/legion/mcp/embedding_index.rb` | Semantic tool matching; delegates persistence to Legion::Tools::EmbeddingCache |
 | `lib/legion/mcp/observer.rb` | Instrumentation: counters, ring buffer, pattern promotion |
 | `lib/legion/mcp/usage_filter.rb` | Frequency/recency/keyword scoring for dynamic tool filtering |
 | `lib/legion/mcp/pattern_store.rb` | 4-layer degrading storage (L0/L1/L2) with thread-safe access |
 | `lib/legion/mcp/tier_router.rb` | Confidence-gated tier selection, tool chain execution |
 | `lib/legion/mcp/context_guard.rb` | Staleness, rapid-fire, anomaly detection |
-| `lib/legion/mcp/tools/` | 59 MCP::Tool subclasses (legion.* namespace) |
+| `lib/legion/mcp/tool_adapter.rb` | MCP::ToolAdapter — wraps Legion::Tools::Base for MCP SDK (McpToolAdapter kept as alias) |
+| `lib/legion/mcp/deferred_registry.rb` | DeferredRegistry — reads deferred tools from Legion::Tools::Registry at request time |
+| `lib/legion/mcp/tools/` | All tool implementations; only MCP_SPECIFIC_TOOLS (6 tools) registered in Server.tool_registry — extension tools sourced via Legion::Tools::Discovery |
 | `lib/legion/mcp/tools/do_action.rb` | Natural language intent routing with Tier 0 fast path |
 | `lib/legion/mcp/tools/discover_tools.rb` | Dynamic tool discovery with context |
 | `lib/legion/mcp/tools/run_task.rb` | Execute runner function via dot notation |

data/lib/legion/mcp/catalog_dispatcher.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'logging_support'
+require_relative 'tool_adapter'
 
 module Legion
   module MCP
@@ -113,35 +114,16 @@ module Legion
       end
 
       def generate_tools_from_catalog
-        return [] unless defined?(Legion::Extensions::Catalog::Registry)
-        return [] unless Legion::Extensions::Catalog::Registry.respond_to?(:for_mcp)
+        return [] unless defined?(Legion::Tools::Registry)
+        return [] unless Legion::Tools::Registry.respond_to?(:all_tools)
 
-        Legion::Extensions::Catalog::Registry.for_mcp.filter_map do |cap|
-          raw_name = cap.respond_to?(:mcp_name) ? cap.mcp_name : "legion.catalog.#{cap.function}"
-          build_tool_class(
-            runner_class: resolve_runner_class(cap),
-            function:     cap.function,
-            tool_name:    sanitize_tool_name(raw_name),
-            description:  cap.respond_to?(:description) ? cap.description : "Auto-generated: #{cap.function}",
-            input_schema: cap.respond_to?(:input_schema) ? cap.input_schema : { properties: {} },
-            category:     cap.respond_to?(:category) ? cap.category : nil,
-            tier:         cap.respond_to?(:tier) ? cap.tier : nil
-          )
+        Legion::Tools::Registry.all_tools.filter_map do |tool_class|
+          ToolAdapter.from_legion_tool(tool_class) if defined?(ToolAdapter) && ToolAdapter.respond_to?(:from_legion_tool)
         rescue StandardError => e
           handle_exception(e, level: :debug, operation: 'legion.mcp.catalog_dispatcher.generate_tools_from_catalog')
-          log.debug("CatalogDispatcher: skipping #{cap}: #{e.message}")
           nil
         end
       end
-
-      def resolve_runner_class(cap)
-        segments = cap.extension.delete_prefix('lex-').split('-')
-        (%w[Legion Extensions] + segments.map(&:capitalize) + ['Runners', cap.runner]).join('::')
-      end
-
-      def sanitize_tool_name(name)
-        name.gsub(/[^A-Za-z0-9_.-]/, '')
-      end
     end
   end
 end

data/lib/legion/mcp/server.rb

@@ -17,82 +17,24 @@ require_relative 'tool_quality'
 require_relative 'deferred_registry'
 require_relative 'catalog_dispatcher'
 require_relative 'dynamic_injector'
-require_relative 'catalog_bridge'
 require_relative 'resources/runner_catalog'
 require_relative 'resources/extension_info'
 
 module Legion
   module MCP
-    module Server # rubocop:disable Metrics/ModuleLength
-      # All built-in tool classes loaded via tools_loader.rb
-      STATIC_TOOLS = [
-        Tools::RunTask,
-        Tools::DescribeRunner,
-        Tools::ListTasks,
-        Tools::GetTask,
-        Tools::DeleteTask,
-        Tools::GetTaskLogs,
-        Tools::ListChains,
-        Tools::CreateChain,
-        Tools::UpdateChain,
-        Tools::DeleteChain,
-        Tools::ListRelationships,
-        Tools::CreateRelationship,
-        Tools::UpdateRelationship,
-        Tools::DeleteRelationship,
-        Tools::ListExtensions,
-        Tools::GetExtension,
-        Tools::EnableExtension,
-        Tools::DisableExtension,
-        Tools::ListSchedules,
-        Tools::CreateSchedule,
-        Tools::UpdateSchedule,
-        Tools::DeleteSchedule,
-        Tools::GetStatus,
-        Tools::GetConfig,
-        Tools::ListWorkers,
-        Tools::ShowWorker,
-        Tools::WorkerLifecycle,
-        Tools::WorkerCosts,
-        Tools::TeamSummary,
-        Tools::RoutingStats,
-        Tools::RbacCheck,
-        Tools::RbacAssignments,
-        Tools::RbacGrants,
-        Tools::PromptList,
-        Tools::PromptShow,
-        Tools::PromptRun,
-        Tools::DatasetList,
-        Tools::DatasetShow,
-        Tools::ExperimentResults,
-        Tools::EvalList,
-        Tools::EvalRun,
-        Tools::EvalResults,
-        Tools::DoAction,
+    module Server
+      # MCP-specific tools not owned by any extension.
+      # All extension-owned tools are discovered via Legion::Tools::Registry.
+      MCP_SPECIFIC_TOOLS = [
         Tools::PlanAction,
         Tools::DiscoverTools,
-        Tools::AskPeer,
-        Tools::ListPeers,
-        Tools::NotifyPeer,
-        Tools::BroadcastPeers,
-        Tools::MeshStatus,
-        Tools::MindGrowthStatus,
-        Tools::MindGrowthPropose,
-        Tools::MindGrowthApprove,
-        Tools::MindGrowthBuildQueue,
-        Tools::MindGrowthCognitiveProfile,
-        Tools::MindGrowthHealth,
-        Tools::QueryKnowledge,
-        Tools::KnowledgeHealth,
-        Tools::KnowledgeContext,
-        Tools::Absorb,
         Tools::StructuralIndexTool,
         Tools::ToolAudit,
         Tools::StateDiff,
         Tools::SearchSessions
       ].freeze
 
-      @tool_registry = Concurrent::Array.new(STATIC_TOOLS)
+      @tool_registry = Concurrent::Array.new(MCP_SPECIFIC_TOOLS)
       @tool_registry_lock = Mutex.new
 
       class << self # rubocop:disable Metrics/ClassLength
@@ -100,7 +42,7 @@ module Legion
 
         def rebuild_tool_registry
           @tool_registry_lock.synchronize do
-            @tool_registry = Concurrent::Array.new(STATIC_TOOLS)
+            @tool_registry = Concurrent::Array.new(MCP_SPECIFIC_TOOLS)
 
             if defined?(Legion::Tools::Registry) && Legion::Tools::Registry.respond_to?(:all_tools)
               Legion::Tools::Registry.all_tools.each do |legion_tool_class|
@@ -148,8 +90,8 @@ module Legion
         end
 
         def build(identity: nil) # rubocop:disable Metrics/MethodLength
+          run_function_discovery
           rebuild_tool_registry
-          register_catalog_listener
 
           LoggingSupport.info(
             'server.build.start',
@@ -182,7 +124,6 @@ module Legion
 
           PatternStore.hydrate_from_l2 if defined?(PatternStore)
           ColdStart.load_community_patterns if defined?(ColdStart)
-          run_function_discovery
           populate_embedding_index
 
           Resources::RunnerCatalog.register(server)
@@ -263,48 +204,6 @@ module Legion
           end
         end
 
-        def dynamic_tool_list
-          static = tool_registry.map do |klass|
-            { name: klass.tool_name, description: klass.description,
-              input_schema: klass.input_schema, source: :builtin, klass: klass }
-          end
-
-          dynamic = if defined?(Legion::Extensions::Catalog::Registry)
-                      Legion::Extensions::Catalog::Registry.for_mcp.map(&:to_mcp_tool)
-                    else
-                      []
-                    end
-
-          static + dynamic
-        end
-
-        def dispatch_catalog_tool(tool_name, arguments)
-          return nil unless defined?(Legion::Extensions::Catalog::Registry)
-
-          cap = Legion::Extensions::Catalog::Registry.find_by_mcp_name(tool_name)
-          return nil unless cap
-
-          segments = cap.extension.delete_prefix('lex-').split('-')
-          runner_path = (%w[Legion Extensions] + segments.map(&:capitalize) + ['Runners', cap.runner]).join('::')
-          runner = Kernel.const_get(runner_path)
-          fn = cap.function.to_sym
-          result = runner.send(fn, **(arguments || {}).transform_keys(&:to_sym))
-          { status: :success, result: result, source: :catalog }
-        rescue NameError => e
-          handle_exception(e, level: :warn, operation: 'legion.mcp.server.dispatch_catalog_tool')
-          nil
-        rescue StandardError => e
-          handle_exception(e, level: :error, operation: 'legion.mcp.server.dispatch_catalog_tool')
-          { status: :error, error: e.message, source: :catalog }
-        end
-
-        def register_catalog_listener
-          return unless defined?(Legion::Extensions::Catalog::Registry)
-          return unless Legion::Extensions::Catalog::Registry.respond_to?(:on_change)
-
-          Legion::Extensions::Catalog::Registry.on_change { Legion::MCP.reset! }
-        end
-
         private
 
         def run_function_discovery

data/lib/legion/mcp/tool_adapter.rb

@@ -4,9 +4,16 @@ module Legion
   module MCP
     class ToolAdapter < ::MCP::Tool
       class << self
+        MCP_NAME_PATTERN = /[^a-zA-Z0-9_-]/
+
+        def sanitize_tool_name(name)
+          name.to_s.gsub(MCP_NAME_PATTERN, '_').slice(0, 64)
+        end
+
         def from_legion_tool(tool_class)
+          safe_name = sanitize_tool_name(tool_class.tool_name)
           Class.new(::MCP::Tool) do
-            tool_name tool_class.tool_name
+            tool_name safe_name
             description tool_class.description
             input_schema(tool_class.input_schema || { properties: {} })
 

data/lib/legion/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module MCP
-    VERSION = '0.7.3'
+    VERSION = '0.7.4'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-mcp
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Esity
@@ -122,7 +122,6 @@ files:
 - lib/legion/mcp.rb
 - lib/legion/mcp/actors/self_generate_cycle.rb
 - lib/legion/mcp/auth.rb
-- lib/legion/mcp/catalog_bridge.rb
 - lib/legion/mcp/catalog_dispatcher.rb
 - lib/legion/mcp/client.rb
 - lib/legion/mcp/client/connection.rb

data/lib/legion/mcp/catalog_bridge.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module MCP
-    module CatalogBridge
-      include Legion::Logging::Helper
-
-      def hydrate_override_confidence
-        return unless defined?(Legion::LLM::OverrideConfidence)
-        return unless Legion::LLM::OverrideConfidence.respond_to?(:hydrate_from_l2)
-
-        Legion::LLM::OverrideConfidence.hydrate_from_l2
-        Legion::LLM::OverrideConfidence.hydrate_from_apollo if Legion::LLM::OverrideConfidence.respond_to?(:hydrate_from_apollo)
-      end
-
-      def register_catalog_listener
-        return unless defined?(Legion::Extensions::Catalog::Registry)
-        return unless Legion::Extensions::Catalog::Registry.respond_to?(:on_change)
-
-        Legion::Extensions::Catalog::Registry.on_change { Legion::MCP.reset! }
-      end
-
-      def dispatch_catalog_tool(tool_name, arguments)
-        log.info('Starting legion.mcp.catalog_bridge.dispatch_catalog_tool')
-        return nil unless defined?(Legion::Extensions::Catalog::Registry)
-
-        cap = Legion::Extensions::Catalog::Registry.find_by_mcp_name(tool_name)
-        return nil unless cap
-
-        segments = cap.extension.delete_prefix('lex-').split('-')
-        runner_path = (%w[Legion Extensions] + segments.map(&:capitalize) + ['Runners', cap.runner]).join('::')
-        runner = Kernel.const_get(runner_path)
-        fn = cap.function.to_sym
-        result = runner.send(fn, **(arguments || {}).transform_keys(&:to_sym))
-        { status: :success, result: result, source: :catalog }
-      rescue NameError => e
-        handle_exception(e, level: :warn, operation: 'legion.mcp.catalog_bridge.dispatch_catalog_tool')
-        log.warn("Catalog dispatch failed: #{e.message}")
-        nil
-      rescue StandardError => e
-        handle_exception(e, level: :error, operation: 'legion.mcp.catalog_bridge.dispatch_catalog_tool')
-        { status: :error, error: e.message, source: :catalog }
-      end
-
-      def register_catalog_tools
-        log.info('Starting legion.mcp.catalog_bridge.register_catalog_tools')
-        CatalogDispatcher.generate_tools_from_catalog.each { |tc| Server.register_tool(tc) }
-      end
-
-      def dynamic_tool_list
-        static = Server.tool_registry.map do |klass|
-          { name: klass.tool_name, description: klass.description,
-            input_schema: klass.input_schema, source: :builtin, klass: klass }
-        end
-
-        dynamic = if defined?(Legion::Extensions::Catalog::Registry)
-                    Legion::Extensions::Catalog::Registry.for_mcp.map(&:to_mcp_tool)
-                  else
-                    []
-                  end
-
-        static + dynamic
-      end
-    end
-  end
-end