legion-mcp 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc7341c88afa89639cebd05ccffc1dfb00792062373fe295743f525c9c0380c9
-  data.tar.gz: d2b832be2e2942286489edad666215e13f8de19b888a32551bdedef4e70b1f7f
+  metadata.gz: 423fca2b66220aa4bfd5dce33490a6fb92826da7e999a21be9afed00610fd435
+  data.tar.gz: 7e9a664b742ee174140f2463c008bd99475736afe074c056cf298d9742a7ec5d
 SHA512:
-  metadata.gz: 89874ef7825b398392ed7966573379a9c9edc55500cb874bb79897b3b1f65631ff1c594c90420948468d00d9cbe9e8a83838d482d491d7260cea76450b977358
-  data.tar.gz: 58b8e23f9a5a37a87f2d50150cdc8872deaa654524c1ce92a507ac7b157aa9b687a6b99a591d3841f94e37a567dc7f30a4922ca55e5e1646072cf84331947354
+  metadata.gz: d610777e7f105a5b72e4a58fb0a06cd129361639837638b49888de9b6feeb3697a5147184d5d415ba95315d2bafcf3011b9a6c5d7515b8ceec3155a8173477a9
+  data.tar.gz: 6c74faf7a062f61e8b9e10d79b6236dc9b361d6b5ff657bfe651bfa731f6a633a8c8acaf0a68f907b49cd333c4328d77e919d45a114c8e8b7a40323bbfeb9dac

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # legion-mcp Changelog
 
+## [0.4.2] - 2026-03-22
+
+### Added
+- `legion.ask_peer` — synchronous RPC query to a specific mesh peer via `lex-mesh` `request_task`
+- `legion.list_peers` — list all registered mesh agents, with optional capability filter via `find_agents`
+- `legion.notify_peer` — fire-and-forget unicast notification to a specific mesh agent via `send_message`
+- `legion.broadcast_peers` — broadcast to all agents or multicast to a capability group via `send_message`
+- `legion.mesh_status` — retrieve current mesh network state via `mesh_status`
+- All 5 tools registered in `TOOL_CLASSES`; total tool count raised from 45 to 50
+- Specs for all 5 new tools (25 examples)
+- Updated `server_spec.rb` tool count assertion from 45 to 50
+
+## [0.4.1] - 2026-03-19
+
+### Added
+- `legion.prompt_list` — list all stored prompt templates via lex-prompt Client
+- `legion.prompt_show` — fetch a prompt by name, version, or tag via lex-prompt Client
+- `legion.prompt_run` — render a prompt template with ERB variable substitution via lex-prompt Client
+- `legion.dataset_list` — list all stored datasets via lex-dataset Client
+- `legion.dataset_show` — fetch a dataset with all rows, optionally version-pinned, via lex-dataset Client
+- `legion.experiment_results` — retrieve per-row results and summary for a named experiment from lex-dataset
+- `legion.eval_list` — list available evaluator templates via lex-eval Client
+- `legion.eval_run` — run a single input/output pair through a named evaluator via lex-eval Client
+- `legion.eval_results` — retrieve stored experiment results via lex-dataset experiment store
+- All 9 tools registered in `TOOL_CLASSES`; total tool count raised from 36 to 45
+- Specs for all 9 new tools
+
 ## [0.4.0] - 2026-03-20
 
 ### Added

data/CODEOWNERS

@@ -0,0 +1,39 @@
+# Default owner — all files
+* @Esity
+
+# Core library code
+# lib/ @Esity @future-ai-team
+
+# MCP tools (35 tool subclasses)
+# lib/legion/mcp/tools/ @Esity @future-ai-team
+
+# MCP resources
+# lib/legion/mcp/resources/ @Esity @future-ai-team
+
+# Tiered Behavioral Intelligence (TBI) — pattern store, tier router, context guard
+# lib/legion/mcp/pattern_store.rb @Esity @future-ai-team
+# lib/legion/mcp/tier_router.rb @Esity @future-ai-team
+# lib/legion/mcp/context_guard.rb @Esity @future-ai-team
+
+# Semantic matching and embeddings
+# lib/legion/mcp/context_compiler.rb @Esity @future-ai-team
+# lib/legion/mcp/embedding_index.rb @Esity @future-ai-team
+
+# Observer pipeline and usage filter
+# lib/legion/mcp/observer.rb @Esity @future-ai-team
+# lib/legion/mcp/usage_filter.rb @Esity @future-ai-team
+
+# Tool governance
+# lib/legion/mcp/tool_governance.rb @Esity @future-security-team
+
+# Authentication
+# lib/legion/mcp/auth.rb @Esity @future-security-team
+
+# Specs
+# spec/ @Esity @future-contributors
+
+# Documentation
+# *.md @Esity @future-docs-team
+
+# CI/CD
+# .github/ @Esity

data/lib/legion/mcp/server.rb

@@ -35,12 +35,26 @@ require_relative 'tools/routing_stats'
 require_relative 'tools/rbac_check'
 require_relative 'tools/rbac_assignments'
 require_relative 'tools/rbac_grants'
+require_relative 'tools/prompt_list'
+require_relative 'tools/prompt_show'
+require_relative 'tools/prompt_run'
+require_relative 'tools/dataset_list'
+require_relative 'tools/dataset_show'
+require_relative 'tools/experiment_results'
+require_relative 'tools/eval_list'
+require_relative 'tools/eval_run'
+require_relative 'tools/eval_results'
 require_relative 'context_compiler'
 require_relative 'embedding_index'
 require_relative 'cold_start'
 require_relative 'tools/do_action'
 require_relative 'tools/plan_action'
 require_relative 'tools/discover_tools'
+require_relative 'tools/ask_peer'
+require_relative 'tools/list_peers'
+require_relative 'tools/notify_peer'
+require_relative 'tools/broadcast_peers'
+require_relative 'tools/mesh_status'
 require_relative 'resources/runner_catalog'
 require_relative 'resources/extension_info'
 
@@ -81,9 +95,23 @@ module Legion
         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,
         Tools::PlanAction,
-        Tools::DiscoverTools
+        Tools::DiscoverTools,
+        Tools::AskPeer,
+        Tools::ListPeers,
+        Tools::NotifyPeer,
+        Tools::BroadcastPeers,
+        Tools::MeshStatus
       ].freeze
 
       class << self

data/lib/legion/mcp/tools/ask_peer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class AskPeer < ::MCP::Tool
+        tool_name 'legion.ask_peer'
+        description 'Send a synchronous query to a specific mesh peer and return the result.'
+
+        input_schema(
+          properties: {
+            to:      { type: 'string', description: 'Agent ID or capability name to route to' },
+            query:   { type: 'string', description: 'The question or request to send to the peer' },
+            timeout: { type: 'integer', description: 'Seconds to wait for response (default 30)' }
+          },
+          required:   %w[to query]
+        )
+
+        class << self
+          def call(to:, query:, timeout: 30)
+            return error_response('lex-mesh is not available') unless mesh_available?
+
+            result = mesh_client.request_task(
+              from:    'legion.mcp',
+              to:      to,
+              task:    'query',
+              payload: { query: query },
+              timeout: timeout
+            )
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to query peer: #{e.message}")
+          end
+
+          private
+
+          def mesh_available?
+            defined?(Legion::Extensions::Mesh::Client)
+          end
+
+          def mesh_client
+            @mesh_client ||= Legion::Extensions::Mesh::Client.new
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/broadcast_peers.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class BroadcastPeers < ::MCP::Tool
+        tool_name 'legion.broadcast_peers'
+        description 'Broadcast a message to all mesh agents, or multicast to agents with a specific capability.'
+
+        input_schema(
+          properties: {
+            message:    { type: 'string', description: 'Message content to broadcast' },
+            capability: { type: 'string', description: 'If provided, multicast only to agents with this capability' }
+          },
+          required:   %w[message]
+        )
+
+        class << self
+          def call(message:, capability: nil)
+            return error_response('lex-mesh is not available') unless mesh_available?
+
+            pattern = capability ? :multicast : :broadcast
+            result  = mesh_client.send_message(
+              from:    'legion.mcp',
+              to:      capability || :all,
+              pattern: pattern,
+              payload: { message: message }
+            )
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to broadcast: #{e.message}")
+          end
+
+          private
+
+          def mesh_available?
+            defined?(Legion::Extensions::Mesh::Client)
+          end
+
+          def mesh_client
+            @mesh_client ||= Legion::Extensions::Mesh::Client.new
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/dataset_list.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class DatasetList < ::MCP::Tool
+        tool_name 'legion.dataset_list'
+        description 'List all stored datasets with their latest version and row counts.'
+
+        input_schema(properties: {})
+
+        class << self
+          def call
+            return error_response('lex-dataset is not loaded') unless extension_loaded?('dataset')
+
+            require 'legion/extensions/dataset/client'
+            client = Legion::Extensions::Dataset::Client.new(db: db)
+            result = client.list_datasets
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to list datasets: #{e.message}")
+          end
+
+          private
+
+          def extension_loaded?(name)
+            require "legion/extensions/#{name}"
+            true
+          rescue LoadError
+            false
+          end
+
+          def db
+            Legion::Data.db
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/dataset_show.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class DatasetShow < ::MCP::Tool
+        tool_name 'legion.dataset_show'
+        description 'Retrieve a dataset by name including all rows, optionally pinned to a specific version.'
+
+        input_schema(
+          properties: {
+            name:    { type: 'string', description: 'Name of the dataset' },
+            version: { type: 'integer', description: 'Specific version to fetch (default: latest)' }
+          },
+          required:   ['name']
+        )
+
+        class << self
+          def call(name:, version: nil)
+            return error_response('lex-dataset is not loaded') unless extension_loaded?('dataset')
+
+            require 'legion/extensions/dataset/client'
+            client = Legion::Extensions::Dataset::Client.new(db: db)
+            result = client.get_dataset(name: name, version: version)
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to fetch dataset: #{e.message}")
+          end
+
+          private
+
+          def extension_loaded?(name)
+            require "legion/extensions/#{name}"
+            true
+          rescue LoadError
+            false
+          end
+
+          def db
+            Legion::Data.db
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/eval_list.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class EvalList < ::MCP::Tool
+        tool_name 'legion.eval_list'
+        description 'List all available evaluator templates (LLM-as-judge and code-based).'
+
+        input_schema(properties: {})
+
+        class << self
+          def call
+            return error_response('lex-eval is not loaded') unless extension_loaded?('eval')
+
+            require 'legion/extensions/eval/client'
+            client = Legion::Extensions::Eval::Client.new(db: db)
+            result = client.list_evaluators
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to list evaluators: #{e.message}")
+          end
+
+          private
+
+          def extension_loaded?(name)
+            require "legion/extensions/#{name}"
+            true
+          rescue LoadError
+            false
+          end
+
+          def db
+            Legion::Data.db
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/eval_results.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class EvalResults < ::MCP::Tool
+        tool_name 'legion.eval_results'
+        description 'Retrieve stored results for a named experiment from the dataset experiment store.'
+
+        input_schema(
+          properties: {
+            experiment_name: { type: 'string', description: 'Name of the experiment to retrieve results for' }
+          },
+          required:   ['experiment_name']
+        )
+
+        class << self
+          def call(experiment_name:)
+            return error_response('lex-dataset is not loaded') unless extension_loaded?('dataset')
+
+            require 'legion/extensions/dataset/client'
+            client = Legion::Extensions::Dataset::Client.new(db: db)
+            result = fetch_experiment(client, experiment_name)
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to fetch eval results: #{e.message}")
+          end
+
+          private
+
+          def fetch_experiment(client, name)
+            db_handle = client.instance_variable_get(:@db)
+            return { error: 'database_unavailable' } unless db_handle
+
+            exp = db_handle[:experiments].where(name: name).first
+            return { error: 'not_found' } unless exp
+
+            rows = db_handle[:experiment_results]
+                   .where(experiment_id: exp[:id])
+                   .order(:row_index)
+                   .all
+                   .map { |r| { row_index: r[:row_index], passed: r[:passed], latency_ms: r[:latency_ms] } }
+
+            summary = begin
+              ::JSON.parse(exp[:summary], symbolize_names: true)
+            rescue StandardError
+              {}
+            end
+
+            { experiment_id: exp[:id], name: exp[:name], status: exp[:status],
+              created_at: exp[:created_at], completed_at: exp[:completed_at],
+              summary: summary, rows: rows }
+          end
+
+          def extension_loaded?(name)
+            require "legion/extensions/#{name}"
+            true
+          rescue LoadError
+            false
+          end
+
+          def db
+            Legion::Data.db
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/eval_run.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class EvalRun < ::MCP::Tool
+        tool_name 'legion.eval_run'
+        description 'Run an evaluator against a single input/output pair and return pass/fail with score.'
+
+        input_schema(
+          properties: {
+            evaluator_name: { type: 'string', description: 'Name of the evaluator template to use' },
+            input:          { type: 'string', description: 'The original input/prompt given to the model' },
+            output:         { type: 'string', description: 'The model output to evaluate' },
+            expected:       { type: 'string', description: 'Optional expected/reference output for comparison' }
+          },
+          required:   %w[evaluator_name input output]
+        )
+
+        class << self
+          def call(evaluator_name:, input:, output:, expected: nil)
+            return error_response('lex-eval is not loaded') unless extension_loaded?('eval')
+
+            require 'legion/extensions/eval/client'
+            client = Legion::Extensions::Eval::Client.new(db: db)
+            inputs = [{ input: input, output: output, expected: expected }.compact]
+            result = client.run_evaluation(evaluator_name: evaluator_name, inputs: inputs)
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to run evaluation: #{e.message}")
+          end
+
+          private
+
+          def extension_loaded?(name)
+            require "legion/extensions/#{name}"
+            true
+          rescue LoadError
+            false
+          end
+
+          def db
+            Legion::Data.db
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/experiment_results.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class ExperimentResults < ::MCP::Tool
+        tool_name 'legion.experiment_results'
+        description 'Retrieve stored results for a named experiment, including per-row pass/fail and summary stats.'
+
+        input_schema(
+          properties: {
+            name: { type: 'string', description: 'Name of the experiment to retrieve results for' }
+          },
+          required:   ['name']
+        )
+
+        class << self
+          def call(name:)
+            return error_response('lex-dataset is not loaded') unless extension_loaded?('dataset')
+
+            require 'legion/extensions/dataset/client'
+            client = Legion::Extensions::Dataset::Client.new(db: db)
+            result = fetch_experiment(client, name)
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to fetch experiment results: #{e.message}")
+          end
+
+          private
+
+          def fetch_experiment(client, name)
+            db_handle = client.instance_variable_get(:@db)
+            return { error: 'database_unavailable' } unless db_handle
+
+            exp = db_handle[:experiments].where(name: name).first
+            return { error: 'not_found' } unless exp
+
+            rows = db_handle[:experiment_results]
+                   .where(experiment_id: exp[:id])
+                   .order(:row_index)
+                   .all
+                   .map { |r| { row_index: r[:row_index], passed: r[:passed], latency_ms: r[:latency_ms] } }
+
+            summary = begin
+              ::JSON.parse(exp[:summary], symbolize_names: true)
+            rescue StandardError
+              {}
+            end
+
+            { experiment_id: exp[:id], name: exp[:name], status: exp[:status],
+              created_at: exp[:created_at], completed_at: exp[:completed_at],
+              summary: summary, rows: rows }
+          end
+
+          def extension_loaded?(name)
+            require "legion/extensions/#{name}"
+            true
+          rescue LoadError
+            false
+          end
+
+          def db
+            Legion::Data.db
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/list_peers.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class ListPeers < ::MCP::Tool
+        tool_name 'legion.list_peers'
+        description 'List all registered mesh agents, optionally filtered by capability.'
+
+        input_schema(
+          properties: {
+            capability: { type: 'string', description: 'Filter agents by capability' }
+          }
+        )
+
+        class << self
+          def call(capability: nil)
+            return error_response('lex-mesh is not available') unless mesh_available?
+
+            result = mesh_client.find_agents(capability: capability)
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to list peers: #{e.message}")
+          end
+
+          private
+
+          def mesh_available?
+            defined?(Legion::Extensions::Mesh::Client)
+          end
+
+          def mesh_client
+            @mesh_client ||= Legion::Extensions::Mesh::Client.new
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/mesh_status.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class MeshStatus < ::MCP::Tool
+        tool_name 'legion.mesh_status'
+        description 'Get current mesh network status including registered agents and topology.'
+
+        input_schema(properties: {})
+
+        class << self
+          def call
+            return error_response('lex-mesh is not available') unless mesh_available?
+
+            result = mesh_client.mesh_status
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to get mesh status: #{e.message}")
+          end
+
+          private
+
+          def mesh_available?
+            defined?(Legion::Extensions::Mesh::Client)
+          end
+
+          def mesh_client
+            @mesh_client ||= Legion::Extensions::Mesh::Client.new
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/notify_peer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class NotifyPeer < ::MCP::Tool
+        tool_name 'legion.notify_peer'
+        description 'Send a fire-and-forget async notification to a specific mesh agent.'
+
+        input_schema(
+          properties: {
+            to:      { type: 'string', description: 'Target agent ID' },
+            message: { type: 'string', description: 'Notification content to send' }
+          },
+          required:   %w[to message]
+        )
+
+        class << self
+          def call(to:, message:)
+            return error_response('lex-mesh is not available') unless mesh_available?
+
+            result = mesh_client.send_message(
+              from:    'legion.mcp',
+              to:      to,
+              pattern: :unicast,
+              payload: { message: message }
+            )
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to notify peer: #{e.message}")
+          end
+
+          private
+
+          def mesh_available?
+            defined?(Legion::Extensions::Mesh::Client)
+          end
+
+          def mesh_client
+            @mesh_client ||= Legion::Extensions::Mesh::Client.new
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/prompt_list.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class PromptList < ::MCP::Tool
+        tool_name 'legion.prompt_list'
+        description 'List all stored LLM prompt templates with their latest version and metadata.'
+
+        input_schema(properties: {})
+
+        class << self
+          def call
+            return error_response('lex-prompt is not loaded') unless extension_loaded?('prompt')
+
+            require 'legion/extensions/prompt/client'
+            client = Legion::Extensions::Prompt::Client.new(db: db)
+            result = client.list_prompts
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to list prompts: #{e.message}")
+          end
+
+          private
+
+          def extension_loaded?(name)
+            require "legion/extensions/#{name}"
+            true
+          rescue LoadError
+            false
+          end
+
+          def db
+            Legion::Data.db
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/prompt_run.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class PromptRun < ::MCP::Tool
+        tool_name 'legion.prompt_run'
+        description 'Render a prompt template with variable substitution and return the final text.'
+
+        input_schema(
+          properties: {
+            name:      { type: 'string', description: 'Name of the prompt template to render' },
+            variables: {
+              type:                 'object',
+              description:          'Key/value pairs to substitute into the ERB template',
+              additionalProperties: true
+            },
+            version:   { type: 'integer', description: 'Specific version to render (default: latest)' }
+          },
+          required:   ['name']
+        )
+
+        class << self
+          def call(name:, variables: {}, version: nil)
+            return error_response('lex-prompt is not loaded') unless extension_loaded?('prompt')
+
+            require 'legion/extensions/prompt/client'
+            client = Legion::Extensions::Prompt::Client.new(db: db)
+            result = client.render_prompt(name: name, variables: variables, version: version)
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to render prompt: #{e.message}")
+          end
+
+          private
+
+          def extension_loaded?(name)
+            require "legion/extensions/#{name}"
+            true
+          rescue LoadError
+            false
+          end
+
+          def db
+            Legion::Data.db
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/tools/prompt_show.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module MCP
+    module Tools
+      class PromptShow < ::MCP::Tool
+        tool_name 'legion.prompt_show'
+        description 'Retrieve a prompt template by name, optionally pinned to a specific version or tag.'
+
+        input_schema(
+          properties: {
+            name:    { type: 'string', description: 'Name of the prompt template' },
+            version: { type: 'integer', description: 'Specific version number to fetch (default: latest)' },
+            tag:     { type: 'string', description: 'Named tag to resolve (e.g. "stable", "production")' }
+          },
+          required:   ['name']
+        )
+
+        class << self
+          def call(name:, version: nil, tag: nil)
+            return error_response('lex-prompt is not loaded') unless extension_loaded?('prompt')
+
+            require 'legion/extensions/prompt/client'
+            client = Legion::Extensions::Prompt::Client.new(db: db)
+            result = client.get_prompt(name: name, version: version, tag: tag)
+            text_response(result)
+          rescue StandardError => e
+            error_response("Failed to fetch prompt: #{e.message}")
+          end
+
+          private
+
+          def extension_loaded?(name)
+            require "legion/extensions/#{name}"
+            true
+          rescue LoadError
+            false
+          end
+
+          def db
+            Legion::Data.db
+          end
+
+          def text_response(data)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump(data) }])
+          end
+
+          def error_response(msg)
+            ::MCP::Tool::Response.new([{ type: 'text', text: Legion::JSON.dump({ error: msg }) }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module MCP
-    VERSION = '0.4.0'
+    VERSION = '0.4.2'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-mcp
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Esity
@@ -110,6 +110,7 @@ files:
 - ".rubocop.yml"
 - CHANGELOG.md
 - CLAUDE.md
+- CODEOWNERS
 - Gemfile
 - LICENSE
 - README.md
@@ -134,9 +135,13 @@ files:
 - lib/legion/mcp/server.rb
 - lib/legion/mcp/tier_router.rb
 - lib/legion/mcp/tool_governance.rb
+- lib/legion/mcp/tools/ask_peer.rb
+- lib/legion/mcp/tools/broadcast_peers.rb
 - lib/legion/mcp/tools/create_chain.rb
 - lib/legion/mcp/tools/create_relationship.rb
 - lib/legion/mcp/tools/create_schedule.rb
+- lib/legion/mcp/tools/dataset_list.rb
+- lib/legion/mcp/tools/dataset_show.rb
 - lib/legion/mcp/tools/delete_chain.rb
 - lib/legion/mcp/tools/delete_relationship.rb
 - lib/legion/mcp/tools/delete_schedule.rb
@@ -146,6 +151,10 @@ files:
 - lib/legion/mcp/tools/discover_tools.rb
 - lib/legion/mcp/tools/do_action.rb
 - lib/legion/mcp/tools/enable_extension.rb
+- lib/legion/mcp/tools/eval_list.rb
+- lib/legion/mcp/tools/eval_results.rb
+- lib/legion/mcp/tools/eval_run.rb
+- lib/legion/mcp/tools/experiment_results.rb
 - lib/legion/mcp/tools/get_config.rb
 - lib/legion/mcp/tools/get_extension.rb
 - lib/legion/mcp/tools/get_status.rb
@@ -153,11 +162,17 @@ files:
 - lib/legion/mcp/tools/get_task_logs.rb
 - lib/legion/mcp/tools/list_chains.rb
 - lib/legion/mcp/tools/list_extensions.rb
+- lib/legion/mcp/tools/list_peers.rb
 - lib/legion/mcp/tools/list_relationships.rb
 - lib/legion/mcp/tools/list_schedules.rb
 - lib/legion/mcp/tools/list_tasks.rb
 - lib/legion/mcp/tools/list_workers.rb
+- lib/legion/mcp/tools/mesh_status.rb
+- lib/legion/mcp/tools/notify_peer.rb
 - lib/legion/mcp/tools/plan_action.rb
+- lib/legion/mcp/tools/prompt_list.rb
+- lib/legion/mcp/tools/prompt_run.rb
+- lib/legion/mcp/tools/prompt_show.rb
 - lib/legion/mcp/tools/rbac_assignments.rb
 - lib/legion/mcp/tools/rbac_check.rb
 - lib/legion/mcp/tools/rbac_grants.rb