legion-mcp 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc7341c88afa89639cebd05ccffc1dfb00792062373fe295743f525c9c0380c9
-  data.tar.gz: d2b832be2e2942286489edad666215e13f8de19b888a32551bdedef4e70b1f7f
+  metadata.gz: 37f03ddf4778cc238c0e69b039b9cd6c55acc2ada6207ef32c777c844d60d5e1
+  data.tar.gz: ffe2b6b6da0930d795ca3965b86f5edabdf8f6b698232b110bd3ae6187ce0c20
 SHA512:
-  metadata.gz: 89874ef7825b398392ed7966573379a9c9edc55500cb874bb79897b3b1f65631ff1c594c90420948468d00d9cbe9e8a83838d482d491d7260cea76450b977358
-  data.tar.gz: 58b8e23f9a5a37a87f2d50150cdc8872deaa654524c1ce92a507ac7b157aa9b687a6b99a591d3841f94e37a567dc7f30a4922ca55e5e1646072cf84331947354
+  metadata.gz: a4c148c867a384494dd92847f6ec4f25b6010d73ce3f076e6d01c0f5ae47c8a7c6d8cfa909da58f067334612f7b7420e87e388c0910fad2edf604ea45a670206
+  data.tar.gz: eb8d5f6536df790298e4613a92f61f8a4e136d16d83ede2a99c92a9507ddfd8f7301fe52a12678f891b0227e1568660b77db008b09bd9e1a98f55644e64a56b2

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # legion-mcp Changelog
 
+## [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/lib/legion/mcp/server.rb

@@ -35,6 +35,15 @@ 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'
@@ -81,6 +90,15 @@ 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

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/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.1'
   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.1
 platform: ruby
 authors:
 - Esity
@@ -137,6 +137,8 @@ files:
 - 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 +148,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
@@ -158,6 +164,9 @@ files:
 - lib/legion/mcp/tools/list_tasks.rb
 - lib/legion/mcp/tools/list_workers.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