@reaatech/pi-bench-mcp-server 1.0.1

package/dist/index.js

@@ -0,0 +1,770 @@
+// src/mcp-server.ts
+import { readFile } from "fs/promises";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { createMockAdapter } from "@reaatech/pi-bench-adapters";
+import { createRebuffAdapter } from "@reaatech/pi-bench-adapters";
+import { createLakeraAdapter } from "@reaatech/pi-bench-adapters";
+import { createLLMGuardAdapter } from "@reaatech/pi-bench-adapters";
+import { createGarakAdapter } from "@reaatech/pi-bench-adapters";
+import { createModerationAdapter } from "@reaatech/pi-bench-adapters";
+import { getCategoryIds } from "@reaatech/pi-bench-core";
+import { DefenseScoreSchema } from "@reaatech/pi-bench-core";
+import { generateDefaultCorpus } from "@reaatech/pi-bench-corpus";
+import { createLeaderboardManager } from "@reaatech/pi-bench-leaderboard";
+import {
+  getDefaultLeaderboardPath,
+  loadLeaderboardEntries,
+  saveLeaderboardEntries
+} from "@reaatech/pi-bench-leaderboard";
+import { createLogger } from "@reaatech/pi-bench-observability";
+import { createBenchmarkEngine } from "@reaatech/pi-bench-runner";
+import { createDefenseEvaluator } from "@reaatech/pi-bench-runner";
+import { generateBenignSamples } from "@reaatech/pi-bench-runner";
+
+// src/report-data.ts
+import { calculateDefenseScore } from "@reaatech/pi-bench-scoring";
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isBenchmarkResult(value) {
+  return isObject(value) && Array.isArray(value.attackResults) && Array.isArray(value.benignResults) && typeof value.defense === "string" && typeof value.defenseVersion === "string";
+}
+function toCategoryBreakdown(categoryScores) {
+  if (!categoryScores) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(categoryScores).map(([category, score]) => [
+      category,
+      {
+        detectionRate: score.detectionRate,
+        totalAttacks: score.totalAttacks
+      }
+    ])
+  );
+}
+function normalizeReportData(results) {
+  if (!isObject(results)) {
+    throw new Error("Results must be a JSON object");
+  }
+  const score = isObject(results.score) ? results.score : void 0;
+  const overallMetrics = isObject(results.overallMetrics) ? results.overallMetrics : void 0;
+  const categoryBreakdown = isObject(results.categoryBreakdown) ? results.categoryBreakdown : void 0;
+  if (score && overallMetrics) {
+    return {
+      defense: typeof results.defense === "string" ? results.defense : score.defense,
+      version: typeof results.defenseVersion === "string" ? results.defenseVersion : score.version,
+      corpusVersion: typeof results.corpusVersion === "string" ? results.corpusVersion : isObject(results.metadata) && typeof results.metadata.corpusVersion === "string" ? results.metadata.corpusVersion : void 0,
+      generatedAt: isObject(results.metadata) && typeof results.metadata.generatedAt === "string" ? results.metadata.generatedAt : typeof results.timestamp === "string" ? results.timestamp : void 0,
+      detectionRate: typeof overallMetrics.detectionRate === "number" ? overallMetrics.detectionRate : 1 - score.attackSuccessRate,
+      falsePositiveRate: typeof overallMetrics.fpr === "number" ? overallMetrics.fpr : score.falsePositiveRate,
+      totalAttacks: typeof overallMetrics.totalAttacks === "number" ? overallMetrics.totalAttacks : score.totalSamples,
+      avgLatencyMs: typeof overallMetrics.avgLatencyMs === "number" ? overallMetrics.avgLatencyMs : score.avgLatencyMs,
+      categoryBreakdown: categoryBreakdown || toCategoryBreakdown(score.categoryScores)
+    };
+  }
+  if (isBenchmarkResult(results)) {
+    const derivedScore = calculateDefenseScore(results);
+    return {
+      defense: results.defense,
+      version: results.defenseVersion,
+      corpusVersion: results.corpusVersion,
+      generatedAt: results.timestamp,
+      detectionRate: 1 - derivedScore.attackSuccessRate,
+      falsePositiveRate: derivedScore.falsePositiveRate,
+      totalAttacks: derivedScore.totalSamples,
+      avgLatencyMs: derivedScore.avgLatencyMs,
+      categoryBreakdown: toCategoryBreakdown(derivedScore.categoryScores)
+    };
+  }
+  if (typeof results.detectionRate === "number" && typeof results.falsePositiveRate === "number" && typeof results.totalAttacks === "number" && typeof results.avgLatencyMs === "number") {
+    return {
+      defense: typeof results.defense === "string" ? results.defense : void 0,
+      version: typeof results.version === "string" ? results.version : void 0,
+      corpusVersion: typeof results.corpusVersion === "string" ? results.corpusVersion : void 0,
+      generatedAt: typeof results.timestamp === "string" ? results.timestamp : void 0,
+      detectionRate: results.detectionRate,
+      falsePositiveRate: results.falsePositiveRate,
+      totalAttacks: results.totalAttacks,
+      avgLatencyMs: results.avgLatencyMs,
+      categoryBreakdown: categoryBreakdown || {}
+    };
+  }
+  throw new Error("Results file is not a recognized benchmark or report format");
+}
+
+// src/mcp-server.ts
+var logger = createLogger();
+var DEFAULT_CONFIG = {
+  name: "prompt-injection-bench",
+  version: "1.0.0"
+};
+function validateFilePath(filePath) {
+  if (!filePath || filePath.trim().length === 0) {
+    throw new Error("File path cannot be empty");
+  }
+  const normalized = filePath.replace(/\\/g, "/");
+  if (normalized.includes("../") || normalized.includes("..\\")) {
+    throw new Error("File path cannot contain path traversal sequences");
+  }
+  if (normalized.startsWith("/")) {
+    throw new Error("Absolute file paths are not allowed");
+  }
+  if (normalized.includes("~")) {
+    throw new Error("Home directory shortcuts are not allowed");
+  }
+  if (/^\.\./.test(normalized)) {
+    throw new Error("File path cannot start with parent directory reference");
+  }
+  if (normalized.includes("//")) {
+    throw new Error("File path cannot contain double slashes");
+  }
+  if (/^\s/.test(normalized) || /\s$/.test(normalized)) {
+    throw new Error("File path cannot have leading or trailing whitespace");
+  }
+  if (/\.\./.test(normalized)) {
+    const parts = normalized.split("/");
+    for (const part of parts) {
+      if (part === ".." || part.endsWith("..")) {
+        throw new Error("File path contains parent directory references");
+      }
+    }
+  }
+  const pathSegments = normalized.split("/").filter(Boolean);
+  for (const segment of pathSegments) {
+    if (segment === ".." || segment.includes("..")) {
+      throw new Error("File path contains invalid segments");
+    }
+  }
+}
+async function loadAdapter(name) {
+  switch (name.toLowerCase()) {
+    case "mock":
+      return createMockAdapter(0.85, 0.05);
+    case "rebuff":
+      return createRebuffAdapter();
+    case "lakera":
+      return createLakeraAdapter();
+    case "llm-guard":
+      return createLLMGuardAdapter();
+    case "garak":
+      return createGarakAdapter();
+    case "moderation-openai":
+      return createModerationAdapter({ provider: "openai" });
+    case "moderation-azure":
+      return createModerationAdapter({ provider: "azure" });
+    case "moderation-anthropic":
+      return createModerationAdapter({ provider: "anthropic" });
+    case "moderation-cohere":
+      return createModerationAdapter({ provider: "cohere" });
+    default:
+      throw new Error(`Unknown defense adapter: ${name}`);
+  }
+}
+var BenchmarkMCPServer = class {
+  server;
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.server = new Server(
+      {
+        name: this.config.name,
+        version: this.config.version
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.setupToolHandlers();
+  }
+  /**
+   * Get the list of available tools (exposed for testing)
+   */
+  getToolDefinitions() {
+    return [
+      {
+        name: "run_benchmark",
+        description: "Execute a full benchmark against defenses",
+        inputSchema: {
+          type: "object",
+          properties: {
+            defense: { type: "string", description: "Defense adapter name" },
+            corpus: { type: "string", description: "Corpus version to use", default: "2026.04" },
+            categories: {
+              type: "array",
+              items: { type: "string" },
+              description: "Attack categories to include"
+            },
+            parallel: { type: "number", description: "Number of parallel executions", default: 10 },
+            timeout_ms: { type: "number", description: "Timeout per attack in ms", default: 3e4 }
+          },
+          required: ["defense"]
+        }
+      },
+      {
+        name: "compare_defenses",
+        description: "Compare multiple defense results",
+        inputSchema: {
+          type: "object",
+          properties: {
+            results: {
+              type: "array",
+              items: { type: "string" },
+              description: "Paths to result files to compare"
+            },
+            significance_level: {
+              type: "number",
+              description: "Statistical significance level",
+              default: 0.05
+            }
+          },
+          required: ["results"]
+        }
+      },
+      {
+        name: "generate_report",
+        description: "Generate HTML/JSON reports from benchmark results",
+        inputSchema: {
+          type: "object",
+          properties: {
+            results: { type: "string", description: "Path to results file" },
+            format: {
+              type: "string",
+              enum: ["json", "html", "markdown"],
+              description: "Output format",
+              default: "json"
+            },
+            include_categories: {
+              type: "boolean",
+              description: "Include category breakdown",
+              default: true
+            },
+            output: { type: "string", description: "Output file path" }
+          },
+          required: ["results"]
+        }
+      },
+      {
+        name: "submit_results",
+        description: "Submit results to the public leaderboard",
+        inputSchema: {
+          type: "object",
+          properties: {
+            results: { type: "string", description: "Path to results file" },
+            defense_name: { type: "string", description: "Name of the defense" },
+            defense_version: { type: "string", description: "Version of the defense" },
+            reproducibility_proof: {
+              type: "object",
+              properties: {
+                seed: { type: "string", description: "Seed used for the run" },
+                corpus_version: { type: "string", description: "Corpus version used" },
+                adapter_versions: {
+                  type: "object",
+                  additionalProperties: { type: "string" },
+                  description: "Versions of adapters used"
+                }
+              },
+              description: "Reproducibility proof data"
+            }
+          },
+          required: ["results", "defense_name"]
+        }
+      }
+    ];
+  }
+  /**
+   * Set up tool request handlers
+   */
+  setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: this.getToolDefinitions()
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      switch (name) {
+        case "run_benchmark":
+          return await this.handleRunBenchmark(args);
+        case "compare_defenses":
+          return await this.handleCompareDefenses(args);
+        case "generate_report":
+          return await this.handleGenerateReport(args);
+        case "submit_results":
+          return await this.handleSubmitResults(args);
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    });
+  }
+  /**
+   * Handle run_benchmark tool call
+   */
+  async handleRunBenchmark(args) {
+    const runArgs = args;
+    const defenseName = runArgs.defense;
+    const corpusVersion = runArgs.corpus || "2026.04";
+    const parallel = runArgs.parallel || 10;
+    const timeoutMs = runArgs.timeout_ms || 3e4;
+    const categories = runArgs.categories;
+    logger.info("MCP: Starting benchmark", {
+      defense: defenseName,
+      corpus: corpusVersion,
+      parallel,
+      timeoutMs
+    });
+    try {
+      const adapter = await loadAdapter(defenseName);
+      if (adapter.initialize) {
+        await adapter.initialize?.();
+      }
+      const engine = createBenchmarkEngine({ maxParallel: parallel, defaultTimeoutMs: timeoutMs });
+      engine.setAdapter(adapter);
+      const corpus = generateDefaultCorpus();
+      const attackSamples = categories ? corpus.filter((s) => categories.includes(s.category)) : corpus;
+      const benignSamples = generateBenignSamples(100);
+      const result = await engine.runBenchmark(
+        {
+          defense: defenseName,
+          corpusVersion,
+          categories: categories || getCategoryIds(),
+          parallel,
+          timeoutMs,
+          seed: Date.now().toString(36)
+        },
+        attackSamples,
+        benignSamples
+      );
+      const evaluator = createDefenseEvaluator();
+      const evaluation = evaluator.evaluate(result);
+      await adapter.cleanup?.();
+      const output = {
+        status: "success",
+        runId: result.runId,
+        defense: defenseName,
+        defenseVersion: adapter.version,
+        corpusVersion,
+        score: evaluation.score,
+        overallMetrics: evaluation.overallMetrics,
+        categoryBreakdown: evaluation.categoryBreakdown,
+        timestamp: result.timestamp
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(output, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      logger.error("MCP: Benchmark failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "error",
+                error: error instanceof Error ? error.message : "Unknown error"
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Handle compare_defenses tool call
+   */
+  async handleCompareDefenses(args) {
+    const compareArgs = args;
+    const resultFiles = compareArgs.results;
+    const significanceLevel = compareArgs.significance_level || 0.05;
+    logger.info("MCP: Comparing defenses", { files: resultFiles, significance: significanceLevel });
+    try {
+      if (resultFiles.length < 2) {
+        throw new Error("At least 2 result files are required for comparison");
+      }
+      const results = await Promise.all(
+        resultFiles.map(async (file) => {
+          validateFilePath(file);
+          const content = await readFile(file, "utf-8");
+          const parsed = JSON.parse(content);
+          const score = parsed.score || parsed;
+          const validated = DefenseScoreSchema.parse(score);
+          return { ...parsed, score: validated };
+        })
+      );
+      const evaluator = createDefenseEvaluator();
+      const comparisons = [];
+      for (let i = 0; i < results.length; i++) {
+        for (let j = i + 1; j < results.length; j++) {
+          const score1 = results[i].score;
+          const score2 = results[j].score;
+          const defense1Name = results[i].defense || results[i].defenseName || `Defense ${i + 1}`;
+          const defense2Name = results[j].defense || results[j].defenseName || `Defense ${j + 1}`;
+          const comparison = evaluator.compare(score1, score2);
+          comparisons.push({
+            defense1: defense1Name,
+            defense2: defense2Name,
+            winner: comparison.winner,
+            scoreDifference: comparison.scoreDifference,
+            asrDifference: comparison.asrDifference,
+            fprDifference: comparison.fprDifference
+          });
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "success",
+                comparisons,
+                significanceLevel,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    } catch (error) {
+      logger.error("MCP: Compare failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "error",
+                error: error instanceof Error ? error.message : "Unknown error"
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Handle generate_report tool call
+   */
+  async handleGenerateReport(args) {
+    const reportArgs = args;
+    const resultsFile = reportArgs.results;
+    const format = reportArgs.format || "json";
+    const includeCategories = reportArgs.include_categories ?? true;
+    logger.info("MCP: Generating report", { results: resultsFile, format });
+    try {
+      validateFilePath(resultsFile);
+      const content = await readFile(resultsFile, "utf-8");
+      const results = JSON.parse(content);
+      const reportData = normalizeReportData(results);
+      let report;
+      if (format === "markdown") {
+        report = generateMarkdownReport(reportData, includeCategories);
+      } else if (format === "html") {
+        report = generateHtmlReport(reportData, includeCategories);
+      } else {
+        report = JSON.stringify(reportData, null, 2);
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: report
+          }
+        ]
+      };
+    } catch (error) {
+      logger.error("MCP: Report generation failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "error",
+                error: error instanceof Error ? error.message : "Unknown error"
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Handle submit_results tool call
+   */
+  async handleSubmitResults(args) {
+    const submitArgs = args;
+    const resultsFile = submitArgs.results;
+    const defenseName = submitArgs.defense_name;
+    const defenseVersion = submitArgs.defense_version || "1.0.0";
+    const proof = submitArgs.reproducibility_proof;
+    logger.info("MCP: Submitting results", { defense: defenseName, version: defenseVersion });
+    try {
+      validateFilePath(resultsFile);
+      const content = await readFile(resultsFile, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed.score) {
+        DefenseScoreSchema.parse(parsed.score);
+      }
+      const results = parsed;
+      const proofHash = proof?.seed || `local-${Date.now().toString(36)}`;
+      const manager = createLeaderboardManager();
+      manager.replaceEntries(loadLeaderboardEntries());
+      manager.addEntry({
+        defense: defenseName,
+        version: defenseVersion,
+        overallScore: results.score?.overallScore || results.overallScore || 0,
+        submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        corpusVersion: results.corpusVersion || "2026.04",
+        categoryScores: results.score?.categoryScores ? Object.fromEntries(
+          Object.entries(results.score.categoryScores).map(([category, value]) => [
+            category,
+            value.detectionRate || 0
+          ])
+        ) : {},
+        proofHash,
+        submitter: "mcp-user"
+      });
+      saveLeaderboardEntries(manager.getAllEntries());
+      const entry = {
+        status: "success",
+        submission: {
+          defense: defenseName,
+          version: defenseVersion,
+          overallScore: results.score?.overallScore || results.overallScore || 0,
+          submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          corpusVersion: results.corpusVersion || "2026.04",
+          proofHash,
+          storagePath: getDefaultLeaderboardPath()
+        }
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(entry, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      logger.error("MCP: Submission failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "error",
+                error: error instanceof Error ? error.message : "Unknown error"
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * Start the MCP server
+   */
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.log("MCP server started");
+  }
+};
+function generateMarkdownReport(results, includeCategories) {
+  let md = "# Prompt Injection Benchmark Report\n\n";
+  md += `Generated: ${results.generatedAt || (/* @__PURE__ */ new Date()).toISOString()}
+
+`;
+  if (results.defense) {
+    md += `Defense: ${results.defense}${results.version ? ` (${results.version})` : ""}
+
+`;
+  }
+  md += "## Summary\n\n";
+  md += "| Metric | Value |\n|--------|-------|\n";
+  md += `| Detection Rate | ${(results.detectionRate * 100).toFixed(1)}% |
+`;
+  md += `| False Positive Rate | ${(results.falsePositiveRate * 100).toFixed(1)}% |
+`;
+  md += `| Total Attacks | ${results.totalAttacks || 0} |
+`;
+  md += `| Avg Latency | ${results.avgLatencyMs.toFixed(1)}ms |
+`;
+  if (includeCategories && Object.keys(results.categoryBreakdown).length > 0) {
+    md += "\n## Category Breakdown\n\n";
+    md += "| Category | Detection Rate | Attacks |\n|----------|----------------|---------|\n";
+    for (const [category, data] of Object.entries(results.categoryBreakdown)) {
+      md += `| ${category} | ${(data.detectionRate * 100).toFixed(1)}% | ${data.totalAttacks} |
+`;
+    }
+  }
+  return md;
+}
+function generateHtmlReport(results, includeCategories) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Prompt Injection Benchmark Report</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; max-width: 800px; margin: 40px auto; padding: 0 20px; }
+    h1 { color: #333; }
+    table { border-collapse: collapse; width: 100%; margin: 20px 0; }
+    th, td { border: 1px solid #ddd; padding: 12px; text-align: left; }
+    th { background: #f5f5f5; }
+    .metric { display: inline-block; margin: 10px 20px 10px 0; padding: 15px 25px; background: #f8f9fa; border-radius: 8px; }
+    .metric-value { font-size: 24px; font-weight: bold; color: #007bff; }
+    .metric-label { font-size: 12px; color: #666; text-transform: uppercase; }
+  </style>
+</head>
+<body>
+  <h1>Prompt Injection Benchmark Report</h1>
+  <p>Generated: ${results.generatedAt || (/* @__PURE__ */ new Date()).toISOString()}</p>
+  ${results.defense ? `<p>Defense: ${results.defense}${results.version ? ` (${results.version})` : ""}</p>` : ""}
+
+  <h2>Summary</h2>
+  <div class="metric">
+    <div class="metric-value">${(results.detectionRate * 100).toFixed(1)}%</div>
+    <div class="metric-label">Detection Rate</div>
+  </div>
+  <div class="metric">
+    <div class="metric-value">${(results.falsePositiveRate * 100).toFixed(1)}%</div>
+    <div class="metric-label">False Positive Rate</div>
+  </div>
+  <div class="metric">
+    <div class="metric-value">${results.totalAttacks || 0}</div>
+    <div class="metric-label">Total Attacks</div>
+  </div>
+  <div class="metric">
+    <div class="metric-value">${results.avgLatencyMs.toFixed(1)}ms</div>
+    <div class="metric-label">Avg Latency</div>
+  </div>
+  ${includeCategories && Object.keys(results.categoryBreakdown).length > 0 ? `
+  <h2>Category Breakdown</h2>
+  <table>
+    <tr><th>Category</th><th>Detection Rate</th><th>Attacks</th></tr>
+    ${Object.entries(results.categoryBreakdown).map(
+    ([category, data]) => `<tr><td>${category}</td><td>${(data.detectionRate * 100).toFixed(1)}%</td><td>${data.totalAttacks}</td></tr>`
+  ).join("")}
+  </table>
+  ` : ""}
+</body>
+</html>`;
+}
+function createMCPServer(config) {
+  return new BenchmarkMCPServer(config);
+}
+
+// src/seed-manager.ts
+import { createHash } from "crypto";
+var SeedManager = class {
+  seed;
+  config;
+  constructor(config = {}) {
+    this.config = {
+      baseSeed: Date.now(),
+      corpusVersion: "2026.04",
+      adapterVersions: {},
+      ...config
+    };
+    this.seed = this.config.baseSeed;
+  }
+  /**
+   * Get the current seed
+   */
+  getSeed() {
+    return this.seed;
+  }
+  /**
+   * Set a new seed
+   */
+  setSeed(seed) {
+    this.seed = seed;
+  }
+  /**
+   * Generate a deterministic random number
+   */
+  next() {
+    const a = 1664525;
+    const c = 1013904223;
+    const m = 2 ** 32;
+    this.seed = (a * this.seed + c) % m;
+    return this.seed / m;
+  }
+  /**
+   * Generate a deterministic random integer in range
+   */
+  nextInt(min, max) {
+    return Math.floor(this.next() * (max - min + 1)) + min;
+  }
+  /**
+   * Shuffle an array deterministically
+   */
+  shuffle(array) {
+    const shuffled = [...array];
+    for (let i = shuffled.length - 1; i > 0; i--) {
+      const j = this.nextInt(0, i);
+      const temp = shuffled[i];
+      const swapVal = shuffled[j];
+      if (temp == null || swapVal == null) continue;
+      shuffled[i] = swapVal;
+      shuffled[j] = temp;
+    }
+    return shuffled;
+  }
+  /**
+   * Create a hash from config for reproducibility proof
+   */
+  createReproducibilityHash() {
+    const data = JSON.stringify({
+      seed: this.seed,
+      corpusVersion: this.config.corpusVersion,
+      adapterVersions: this.config.adapterVersions
+    });
+    return createHash("sha256").update(data).digest("hex");
+  }
+  /**
+   * Get the full config for persistence
+   */
+  getConfig() {
+    return { ...this.config, baseSeed: this.seed };
+  }
+};
+function createSeedManager(config) {
+  return new SeedManager(config);
+}
+export {
+  BenchmarkMCPServer,
+  SeedManager,
+  createMCPServer,
+  createSeedManager,
+  normalizeReportData
+};