#!/usr/bin/env python3 """Compare the offline mock with the pinned live MCP filesystem package.""" from __future__ import annotations import argparse import json import os import select import shutil import subprocess import sys import tempfile import time from pathlib import Path from typing import Any HERE = Path(__file__).resolve().parent SOURCE_ROOT = HERE.parent RUNTIME = SOURCE_ROOT / "runtime" if not RUNTIME.exists(): # Hugging Face release layout: tests/ and world/ are siblings. RUNTIME = HERE.parent / "world" sys.path.insert(0, str(RUNTIME.parent)) sys.path.insert(0, str(RUNTIME)) from contracts import MCP_PIN, TOOLS_BY_NAME # noqa: E402 from world import CounselWorld # noqa: E402 class StdioMCP: def __init__(self, allowed_root: Path) -> None: package = f"{MCP_PIN['package']}@{MCP_PIN['version']}" self.process = subprocess.Popen( ["npx", "-y", package, str(allowed_root)], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1, ) self.next_id = 0 def close(self) -> None: self.process.terminate() try: self.process.wait(timeout=5) except subprocess.TimeoutExpired: self.process.kill() self.process.wait(timeout=5) def send(self, method: str, params: dict[str, Any] | None = None) -> dict[str, Any]: self.next_id += 1 request: dict[str, Any] = { "jsonrpc": "2.0", "id": self.next_id, "method": method, } if params is not None: request["params"] = params assert self.process.stdin is not None self.process.stdin.write(json.dumps(request, separators=(",", ":")) + "\n") self.process.stdin.flush() deadline = time.monotonic() + 60 assert self.process.stdout is not None while time.monotonic() < deadline: ready, _, _ = select.select([self.process.stdout], [], [], 1) if not ready: if self.process.poll() is not None: stderr = self.process.stderr.read() if self.process.stderr else "" raise RuntimeError(f"upstream MCP exited {self.process.returncode}: {stderr}") continue line = self.process.stdout.readline() if not line: continue response = json.loads(line) if response.get("id") == self.next_id: if response.get("error"): raise RuntimeError(json.dumps(response["error"])) return response["result"] raise TimeoutError(f"no response to {method}") def notify(self, method: str, params: dict[str, Any] | None = None) -> None: request: dict[str, Any] = {"jsonrpc": "2.0", "method": method} if params is not None: request["params"] = params assert self.process.stdin is not None self.process.stdin.write(json.dumps(request, separators=(",", ":")) + "\n") self.process.stdin.flush() def normalized_tool(tool: dict[str, Any]) -> dict[str, Any]: # The SDK may add an explicit JSON Schema dialect marker. It does not alter # accepted input/output JSON, so compare the executable schema after removing it. value = json.loads(json.dumps(tool)) for key in ("inputSchema", "outputSchema"): if isinstance(value.get(key), dict): value[key].pop("$schema", None) return value def text_result(result: dict[str, Any]) -> str: assert result.get("content") and result["content"][0].get("type") == "text" text = result["content"][0]["text"] assert result.get("structuredContent") == {"content": text} return text def normalize_info(value: str) -> dict[str, str]: parsed = dict(line.split(": ", 1) for line in value.splitlines()) return { "size": parsed["size"], "isDirectory": parsed["isDirectory"], "isFile": parsed["isFile"], "permissions_present": str(bool(parsed.get("permissions"))).lower(), "created_present": str(bool(parsed.get("created"))).lower(), "modified_present": str(bool(parsed.get("modified"))).lower(), "accessed_present": str(bool(parsed.get("accessed"))).lower(), } def run(report_path: Path | None = None) -> dict[str, Any]: if shutil.which("npx") is None: raise RuntimeError("npx is required to launch the pinned upstream MCP package") with tempfile.TemporaryDirectory(prefix="counselbench-mcp-conformance-") as temporary: root = Path(temporary) actual_root = root / "actual" mock_documents = root / "mock-documents" mock_output = root / "mock-output" mock_state = root / "mock-state" actual_root.mkdir() mock_documents.mkdir() mock_output.mkdir() fixture = "Matter CB-CONFORMANCE\nLine two with $1,250.00.\n" (actual_root / "fixture.txt").write_text(fixture, encoding="utf-8") (mock_documents / "fixture.txt").write_text(fixture, encoding="utf-8") spec_path = root / "spec.json" spec_path.write_text( json.dumps( { "task_id": "conformance", "fixed_file_timestamp": "2026-08-25T12:00:00.000Z", "verify_token_sha256": "unused", "minimum_tool_calls": 0, "required_document_paths": [], "metadata_check_paths": [], "search_patterns": [], "deliverables": [], "expected_decision": {}, "expected_register": {}, "expected_advice": "", "forbidden_claims": [], } ), encoding="utf-8", ) mock = CounselWorld(mock_documents, mock_output, mock_state, spec_path) upstream = StdioMCP(actual_root) try: initialized = upstream.send( "initialize", { "protocolVersion": MCP_PIN["protocol_version"], "capabilities": {}, "clientInfo": {"name": "counselbench-conformance", "version": "1.0.0"}, }, ) upstream.notify("notifications/initialized") actual_tools = { tool["name"]: tool for tool in upstream.send("tools/list")["tools"] } contract_checks: dict[str, bool] = {} contract_diffs: dict[str, Any] = {} for name, expected in TOOLS_BY_NAME.items(): actual = actual_tools.get(name) matches = actual is not None and normalized_tool(actual) == normalized_tool(expected) contract_checks[name] = matches if not matches: contract_diffs[name] = { "expected": normalized_tool(expected), "actual": normalized_tool(actual or {}), } behavior_checks: dict[str, bool] = {} actual_read = upstream.send( "tools/call", {"name": "read_text_file", "arguments": {"path": str(actual_root / "fixture.txt")}} ) mock_read = mock.call_tool("read_text_file", {"path": "/workspace/documents/fixture.txt"}) behavior_checks["read_text_file"] = text_result(actual_read) == text_result(mock_read) == fixture actual_write_path = actual_root / "result.txt" actual_write = upstream.send( "tools/call", {"name": "write_file", "arguments": {"path": str(actual_write_path), "content": "grounded\n"}} ) mock_write = mock.call_tool( "write_file", {"path": "/workspace/output/result.txt", "content": "grounded\n"} ) behavior_checks["write_file"] = ( text_result(actual_write) == f"Successfully wrote to {actual_write_path}" and text_result(mock_write) == "Successfully wrote to /workspace/output/result.txt" and actual_write_path.read_text(encoding="utf-8") == (mock_output / "result.txt").read_text(encoding="utf-8") ) actual_tree = upstream.send( "tools/call", {"name": "directory_tree", "arguments": {"path": str(actual_root), "excludePatterns": []}} ) mock_tree = mock.call_tool( "directory_tree", {"path": "/workspace/documents", "excludePatterns": []} ) actual_tree_value = json.loads(text_result(actual_tree)) # result.txt belongs to the upstream write root; compare the common fixture entry. behavior_checks["directory_tree"] = ( {entry["name"]: entry["type"] for entry in actual_tree_value}.get("fixture.txt") == "file" and json.loads(text_result(mock_tree)) == [{"name": "fixture.txt", "type": "file"}] ) actual_search = upstream.send( "tools/call", {"name": "search_files", "arguments": {"path": str(actual_root), "pattern": "**/*.txt", "excludePatterns": []}} ) mock_search = mock.call_tool( "search_files", {"path": "/workspace/documents", "pattern": "**/*.txt", "excludePatterns": []} ) actual_names = sorted(Path(line).name for line in text_result(actual_search).splitlines()) mock_names = sorted(Path(line).name for line in text_result(mock_search).splitlines()) behavior_checks["search_files"] = "fixture.txt" in actual_names and mock_names == ["fixture.txt"] actual_info = upstream.send( "tools/call", {"name": "get_file_info", "arguments": {"path": str(actual_root / "fixture.txt")}} ) mock_info = mock.call_tool("get_file_info", {"path": "/workspace/documents/fixture.txt"}) behavior_checks["get_file_info"] = normalize_info(text_result(actual_info)) == normalize_info(text_result(mock_info)) actual_allowed = text_result( upstream.send("tools/call", {"name": "list_allowed_directories", "arguments": {}}) ) mock_allowed = text_result(mock.call_tool("list_allowed_directories", {})) behavior_checks["list_allowed_directories"] = ( actual_allowed.startswith("Allowed directories:\n") and mock_allowed == "Allowed directories:\n/workspace/documents\n/workspace/output" ) finally: upstream.close() report = { "schema_version": "counselbench.mcp-conformance.v3", "benchmark": "CounselBench-100", "benchmark_version": "3.1.0", "upstream": MCP_PIN, "upstream_initialize": initialized, "contract_checks": contract_checks, "behavior_checks": behavior_checks, "contract_diffs": contract_diffs, "passed": all(contract_checks.values()) and all(behavior_checks.values()), } if report_path: report_path.parent.mkdir(parents=True, exist_ok=True) encoded = json.dumps(report, indent=2, sort_keys=True) + "\n" report_path.write_text(encoded, encoding="utf-8") release = report_path.parent.parent hf_reports = release / "huggingface" / "reports" if report_path.parent.name == "reports" and hf_reports.parent.is_dir(): hf_reports.mkdir(parents=True, exist_ok=True) (hf_reports / report_path.name).write_text(encoded, encoding="utf-8") print(json.dumps(report, indent=2, sort_keys=True)) return report def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser() parser.add_argument("--report", type=Path) return parser.parse_args() if __name__ == "__main__": result = run(parse_args().report) raise SystemExit(0 if result["passed"] else 1)