| |
| """Stateless Streamable HTTP MCP adapter for a CounselBench trial.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| import os |
| from http import HTTPStatus |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer |
| from typing import Any |
|
|
| from contracts import MCP_PIN |
| from world import CounselWorld |
|
|
|
|
| WORLD = CounselWorld( |
| os.environ.get("COUNSELBENCH_DOCUMENTS", "/workspace/documents"), |
| os.environ.get("COUNSELBENCH_OUTPUT", "/workspace/output"), |
| os.environ.get("COUNSELBENCH_STATE", "/workspace/state"), |
| os.environ.get("COUNSELBENCH_SPEC", "/opt/counselbench/spec.json"), |
| ) |
|
|
|
|
| def rpc_response(request: dict[str, Any]) -> dict[str, Any] | None: |
| request_id = request.get("id") |
| method = request.get("method") |
| if request_id is None and isinstance(method, str) and method.startswith("notifications/"): |
| return None |
| if request.get("jsonrpc") != "2.0" or not isinstance(method, str): |
| return { |
| "jsonrpc": "2.0", |
| "id": request_id, |
| "error": {"code": -32600, "message": "Invalid Request"}, |
| } |
| if method == "initialize": |
| return { |
| "jsonrpc": "2.0", |
| "id": request_id, |
| "result": { |
| "protocolVersion": MCP_PIN["protocol_version"], |
| "capabilities": {"tools": {"listChanged": True}}, |
| "serverInfo": { |
| "name": MCP_PIN["runtime_server_name"], |
| "version": MCP_PIN["runtime_server_version"], |
| }, |
| "instructions": ( |
| "Review the allowlisted seeded matter files and write final deliverables " |
| "only under /workspace/output." |
| ), |
| }, |
| } |
| if method == "ping": |
| return {"jsonrpc": "2.0", "id": request_id, "result": {}} |
| if method == "tools/list": |
| return { |
| "jsonrpc": "2.0", |
| "id": request_id, |
| "result": {"tools": WORLD.list_tools()}, |
| } |
| if method == "tools/call": |
| params = request.get("params") or {} |
| if not isinstance(params, dict): |
| params = {} |
| result = WORLD.call_tool(params.get("name", ""), params.get("arguments")) |
| return {"jsonrpc": "2.0", "id": request_id, "result": result} |
| return { |
| "jsonrpc": "2.0", |
| "id": request_id, |
| "error": {"code": -32601, "message": "Method not found"}, |
| } |
|
|
|
|
| class Handler(BaseHTTPRequestHandler): |
| server_version = "CounselBenchMCP/1.0" |
|
|
| def log_message(self, fmt: str, *args: Any) -> None: |
| return |
|
|
| def _json(self, status: int, value: Any) -> None: |
| payload = json.dumps(value, separators=(",", ":"), ensure_ascii=False).encode("utf-8") |
| self.send_response(status) |
| self.send_header("Content-Type", "application/json") |
| self.send_header("Content-Length", str(len(payload))) |
| self.send_header("MCP-Protocol-Version", MCP_PIN["protocol_version"]) |
| self.end_headers() |
| self.wfile.write(payload) |
|
|
| def do_GET(self) -> None: |
| if self.path == "/health": |
| self._json(HTTPStatus.OK, {"status": "ok", "task_id": WORLD.spec["task_id"]}) |
| return |
| self._json(HTTPStatus.NOT_FOUND, {"error": "not_found"}) |
|
|
| def do_POST(self) -> None: |
| length = int(self.headers.get("Content-Length", "0")) |
| body = self.rfile.read(length) |
| if self.path == "/verify": |
| try: |
| report = WORLD.verify(self.headers.get("X-Verify-Token")) |
| except PermissionError: |
| self._json(HTTPStatus.NOT_FOUND, {"error": "not_found"}) |
| return |
| self._json(HTTPStatus.OK, report) |
| return |
| if self.path != "/mcp": |
| self._json(HTTPStatus.NOT_FOUND, {"error": "not_found"}) |
| return |
| try: |
| request = json.loads(body.decode("utf-8")) |
| except (UnicodeError, json.JSONDecodeError): |
| self._json( |
| HTTPStatus.BAD_REQUEST, |
| {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "Parse error"}}, |
| ) |
| return |
| if isinstance(request, list): |
| responses = [response for item in request if (response := rpc_response(item)) is not None] |
| self._json(HTTPStatus.OK, responses) |
| return |
| response = rpc_response(request) |
| if response is None: |
| self.send_response(HTTPStatus.ACCEPTED) |
| self.send_header("Content-Length", "0") |
| self.end_headers() |
| return |
| self._json(HTTPStatus.OK, response) |
|
|
|
|
| if __name__ == "__main__": |
| host = os.environ.get("COUNSELBENCH_HOST", "0.0.0.0") |
| port = int(os.environ.get("COUNSELBENCH_PORT", "8972")) |
| ThreadingHTTPServer((host, port), Handler).serve_forever() |
|
|
