mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-20 20:37:44 +00:00
Wire the existing MCP client into the headless runner so a run can connect MCP servers and expose their tools to the agent; previously only the server/app path did this. - Add --mcp (use this computer's mcp.json; <out>/state/mcp.json when --isolated) and --mcp-config FILE (one explicit mcpServers file, no merge; implies --mcp). Off by default, so existing runs are unchanged. - Connect servers on the engine's own event loop and register their tools on the live engine, so the sync->async tool bridge targets the loop the engine runs on; close the manager on the same loop when the run ends. - A server that fails to connect is noted and skipped; the run continues. Record attach/fail in events.jsonl and summary.json. - Add load_mcp_file() for the single-file config path. - Add tests/test_headless_mcp.py: end-to-end against a real stdio MCP server and a failed-connect case.
129 lines
4.6 KiB
Python
129 lines
4.6 KiB
Python
"""`openworker run --mcp`: the headless runner attaches MCP servers as tools.
|
|
|
|
End to end with a scripted fake model (no network, no keys) and a REAL stdio MCP server —
|
|
a tiny FastMCP `echo` server spawned as a subprocess, so the whole path is exercised:
|
|
connect, list tools, register on the live engine, the model calls the tool, the grader-style
|
|
result comes back. Run in a subprocess for the same reason as test_headless_run: the runner
|
|
redirects OpenWorker's state/scratch folders before the engine is built.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
|
|
# A minimal stdio MCP server with one tool. Only depends on the `mcp` SDK, so it starts fast.
|
|
ECHO_SERVER = """\
|
|
from mcp.server.fastmcp import FastMCP
|
|
|
|
mcp = FastMCP("echo")
|
|
|
|
|
|
@mcp.tool()
|
|
def ping(text: str) -> str:
|
|
return f"pong:{text}"
|
|
|
|
|
|
if __name__ == "__main__":
|
|
mcp.run()
|
|
"""
|
|
|
|
|
|
def _env() -> dict:
|
|
env = dict(os.environ)
|
|
env["PYTHONPATH"] = str(ROOT) + os.pathsep + env.get("PYTHONPATH", "")
|
|
env.pop("ANTHROPIC_API_KEY", None)
|
|
env.pop("OPENAI_API_KEY", None)
|
|
env.pop("COWORKER_SCRATCH_BASE", None)
|
|
env["COWORKER_STATE_DIR"] = tempfile.mkdtemp(prefix="ow-run-machine-")
|
|
return env
|
|
|
|
|
|
def _write(path: Path, text: str) -> Path:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(text, encoding="utf-8")
|
|
return path
|
|
|
|
|
|
def _run(tmp_path: Path, script: list[dict], servers: dict) -> tuple[subprocess.CompletedProcess, Path]:
|
|
ws = tmp_path / "ws"
|
|
ws.mkdir(exist_ok=True)
|
|
out = tmp_path / "out"
|
|
script_path = _write(tmp_path / "script.json", json.dumps(script))
|
|
mcp_path = _write(tmp_path / "mcp.json", json.dumps({"mcpServers": servers}))
|
|
cmd = [
|
|
sys.executable, "-m", "coworker.cli", "run",
|
|
"--prompt", "Use the echo tool.",
|
|
"--workspace", str(ws), "--model", "anthropic/claude-sonnet-5",
|
|
"--approval-mode", "bypass-approvals", "--out", str(out),
|
|
"--scripted", str(script_path),
|
|
"--mcp-config", str(mcp_path),
|
|
"--isolated", "--timeout-seconds", "120",
|
|
]
|
|
proc = subprocess.run(cmd, env=_env(), capture_output=True, text=True, timeout=300)
|
|
return proc, out
|
|
|
|
|
|
def _events(out: Path) -> list[dict]:
|
|
return [
|
|
json.loads(line)
|
|
for line in (out / "events.jsonl").read_text(encoding="utf-8").splitlines()
|
|
if line.strip()
|
|
]
|
|
|
|
|
|
def _summary(out: Path) -> dict:
|
|
return json.loads((out / "summary.json").read_text(encoding="utf-8"))
|
|
|
|
|
|
def test_mcp_tool_attached_and_callable(tmp_path: Path) -> None:
|
|
"""A real stdio MCP server's tool is attached and the scripted model calls it; its
|
|
result lands in the record and the run completes."""
|
|
server = _write(tmp_path / "echo_server.py", ECHO_SERVER)
|
|
script = [
|
|
{"text": "Calling echo.", "tool_calls": [{"name": "mcp__echo__ping", "arguments": {"text": "hi"}}]},
|
|
{"text": "Got the result. Done.", "usage": {"input": 100, "output": 20}},
|
|
]
|
|
proc, out = _run(
|
|
tmp_path,
|
|
script,
|
|
{"echo": {"command": sys.executable, "args": [str(server)], "requires_approval": False}},
|
|
)
|
|
assert proc.returncode == 0, proc.stdout + proc.stderr
|
|
|
|
summary = _summary(out)
|
|
assert summary["outcome"] == "completed"
|
|
assert summary["args"]["mcp"] is True
|
|
# The attach is recorded with the server and its tool.
|
|
assert summary["mcp_servers"] == [{"server": "echo", "tools": ["mcp__echo__ping"]}]
|
|
|
|
events = _events(out)
|
|
assert any(e["type"] == "mcp_server_attached" and e["data"]["server"] == "echo" for e in events)
|
|
# The tool call ran against the real server and returned the pong.
|
|
finished = [e for e in events if e["type"] == "tool_finished" and e["data"].get("name") == "mcp__echo__ping"]
|
|
assert finished and finished[0]["data"]["status"] == "ok", events
|
|
assert "pong:hi" in (out / "messages.json").read_text(encoding="utf-8")
|
|
|
|
|
|
def test_mcp_server_failure_is_noted_and_run_continues(tmp_path: Path) -> None:
|
|
"""A server that cannot start is noted and skipped; the run still completes."""
|
|
script = [{"text": "Nothing to do. Done.", "usage": {"input": 100, "output": 20}}]
|
|
proc, out = _run(
|
|
tmp_path,
|
|
script,
|
|
{"nope": {"command": "ow-no-such-command-xyz", "args": [], "requires_approval": False}},
|
|
)
|
|
assert proc.returncode == 0, proc.stdout + proc.stderr
|
|
|
|
summary = _summary(out)
|
|
assert summary["outcome"] == "completed"
|
|
assert summary["mcp_servers"] == [] # nothing attached
|
|
events = _events(out)
|
|
assert any(e["type"] == "mcp_server_failed" and e["data"]["server"] == "nope" for e in events)
|