drydock-cli 3.0.53__tar.gz → 3.0.55__tar.gz

{drydock_cli-3.0.53/drydock_cli.egg-info → drydock_cli-3.0.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.53
+Version: 3.0.55
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.53 → drydock_cli-3.0.55}/drydock/cli.py

@@ -268,6 +268,33 @@ def _first_run_setup(cfg: dict, cfg_path, cfgmod) -> tuple[dict, str]:
     return cfg, f"⚓ Using {model} at {url}"
 
 
+def _connect_mcp(config: dict) -> None:
+    """Start configured MCP servers and register their tools into the registry.
+    Quiet + crash-proof: any failure is logged to config['mcp_log'], never
+    raised. No-op when no mcp.json exists."""
+    import atexit
+
+    from drydock import mcp
+    from drydock.tool_registry import ToolDef, register
+
+    log: list[str] = []
+    try:
+        schemas = mcp.connect_all(config.get("cwd") or os.getcwd(), log=log.append)
+    except Exception as e:  # noqa: BLE001 — never block startup on MCP
+        config["mcp_log"] = [f"MCP init error: {e}"]
+        return
+    for sch in schemas:
+        _, server, tool = sch["name"].split("__", 2)
+        register(ToolDef(
+            name=sch["name"], schema=sch,
+            func=(lambda params, cfg, s=server, t=tool: mcp.call(s, t, params)),
+            read_only=False,
+        ))
+    config["mcp_log"] = log
+    if mcp.connected():
+        atexit.register(mcp.shutdown)
+
+
 def main():
     parser = argparse.ArgumentParser(description="DryDock — local coding agent")
     parser.add_argument(
@@ -349,6 +376,11 @@ def main():
     # call load_project_instructions directly (see run_interactive/run_oneshot).
     config["project_instructions"] = load_project_instructions()
 
+    # Connect any configured MCP servers and register their tools so the model
+    # can call them like native tools. Failures are skipped (never block start);
+    # status is stashed for /mcp. Servers are torn down at exit.
+    _connect_mcp(config)
+
     if args.prompt:
         run_oneshot(args.prompt, config)
     elif args.cli:

drydock_cli-3.0.55/drydock/mcp.py

@@ -0,0 +1,213 @@
+"""MCP (Model Context Protocol) client — connect to MCP servers, expose their
+tools to the agent.
+
+Clean-room, stdlib only (no `mcp` SDK dependency): a minimal JSON-RPC 2.0 client
+over the stdio transport (newline-delimited JSON), which is what local MCP
+servers use. We do the initialize handshake, list the server's tools, and call
+them on demand; results come back as text the model reads like any tool output.
+
+Config (standard mcpServers shape, like Claude Desktop):
+    ~/.drydock/mcp.json   and/or   <cwd>/.drydock/mcp.json
+    {
+      "mcpServers": {
+        "files": {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/data"]},
+        "weather": {"command": "python", "args": ["weather_server.py"], "env": {"KEY": "..."}}
+      }
+    }
+
+Tools are registered as ``mcp__<server>__<tool>``. Everything degrades cleanly:
+a server that fails to start or times out is skipped with a logged note, never
+crashing drydock.
+
+All logic original to Drydock.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import threading
+from pathlib import Path
+
+_PROTOCOL_VERSION = "2024-11-05"
+# Live servers for this process, by name. The tool funcs look servers up here.
+_SERVERS: dict[str, "MCPServer"] = {}
+
+
+class MCPError(RuntimeError):
+    pass
+
+
+class MCPServer:
+    """One stdio MCP server subprocess + a synchronous JSON-RPC channel."""
+
+    def __init__(self, name: str, command: str, args: list[str], env: dict | None = None):
+        self.name = name
+        self.command = command
+        self.args = args or []
+        self.env = env or {}
+        self.proc: subprocess.Popen | None = None
+        self.tools: list[dict] = []
+        self._id = 0
+        self._lock = threading.Lock()
+
+    # ── transport ──────────────────────────────────────────────────────────
+    def _send(self, msg: dict) -> None:
+        assert self.proc and self.proc.stdin
+        self.proc.stdin.write(json.dumps(msg) + "\n")
+        self.proc.stdin.flush()
+
+    def _read_result(self, want_id: int, timeout: float = 20.0) -> dict:
+        """Read newline-delimited JSON until the response with want_id arrives.
+        Notifications / other-id messages are skipped. (Requests are serialized
+        under _lock, so responses effectively arrive in order.)"""
+        assert self.proc and self.proc.stdout
+        import time
+        deadline = time.monotonic() + timeout
+        while True:
+            if time.monotonic() > deadline:
+                raise MCPError(f"{self.name}: timed out waiting for response {want_id}")
+            line = self.proc.stdout.readline()
+            if line == "":
+                raise MCPError(f"{self.name}: server closed the connection")
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                msg = json.loads(line)
+            except ValueError:
+                continue  # stray non-JSON (some servers log to stdout — ignore)
+            if msg.get("id") == want_id:
+                if "error" in msg:
+                    raise MCPError(f"{self.name}: {msg['error'].get('message', msg['error'])}")
+                return msg.get("result", {})
+
+    def _request(self, method: str, params: dict | None = None, timeout: float = 20.0) -> dict:
+        with self._lock:
+            self._id += 1
+            rid = self._id
+            self._send({"jsonrpc": "2.0", "id": rid, "method": method, "params": params or {}})
+            return self._read_result(rid, timeout=timeout)
+
+    def _notify(self, method: str, params: dict | None = None) -> None:
+        with self._lock:
+            self._send({"jsonrpc": "2.0", "method": method, "params": params or {}})
+
+    # ── lifecycle ──────────────────────────────────────────────────────────
+    def start(self, timeout: float = 20.0) -> None:
+        env = {**os.environ, **self.env}
+        self.proc = subprocess.Popen(
+            [self.command, *self.args],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+            text=True, env=env, bufsize=1,
+        )
+        self._request("initialize", {
+            "protocolVersion": _PROTOCOL_VERSION,
+            "capabilities": {},
+            "clientInfo": {"name": "drydock", "version": "1"},
+        }, timeout=timeout)
+        self._notify("notifications/initialized")
+        result = self._request("tools/list", {}, timeout=timeout)
+        self.tools = result.get("tools", []) or []
+
+    def call(self, tool: str, arguments: dict, timeout: float = 60.0) -> str:
+        result = self._request("tools/call", {"name": tool, "arguments": arguments or {}},
+                               timeout=timeout)
+        return _content_to_text(result)
+
+    def stop(self) -> None:
+        if self.proc:
+            try:
+                self.proc.terminate()
+            except Exception:  # noqa: BLE001
+                pass
+            self.proc = None
+
+
+def _content_to_text(result: dict) -> str:
+    """Flatten an MCP tools/call result (content blocks) to text."""
+    if not isinstance(result, dict):
+        return str(result)
+    blocks = result.get("content")
+    if isinstance(blocks, list):
+        parts = []
+        for b in blocks:
+            if isinstance(b, dict):
+                if b.get("type") == "text":
+                    parts.append(b.get("text", ""))
+                else:
+                    parts.append(json.dumps(b))
+        text = "\n".join(p for p in parts if p)
+    else:
+        text = json.dumps(result)
+    if result.get("isError"):
+        text = f"[tool reported an error]\n{text}"
+    return text or "(empty result)"
+
+
+# ── config + connection ────────────────────────────────────────────────────
+
+def config_paths(cwd: str) -> list[Path]:
+    return [Path.home() / ".drydock" / "mcp.json", Path(cwd) / ".drydock" / "mcp.json"]
+
+
+def load_config(cwd: str) -> dict:
+    """Merge mcpServers from user + project config (project overrides by name)."""
+    servers: dict[str, dict] = {}
+    for p in config_paths(cwd):
+        if not p.is_file():
+            continue
+        try:
+            data = json.loads(p.read_text("utf-8"))
+        except (OSError, ValueError):
+            continue
+        for name, spec in (data.get("mcpServers") or {}).items():
+            if isinstance(spec, dict) and spec.get("command"):
+                servers[name] = spec
+    return servers
+
+
+def connect_all(cwd: str, *, log=None) -> list[dict]:
+    """Start every configured MCP server and return drydock tool schemas for
+    their tools (namespaced mcp__<server>__<tool>). Failures are skipped."""
+    _say = log or (lambda *_: None)
+    schemas: list[dict] = []
+    for name, spec in load_config(cwd).items():
+        if name in _SERVERS:
+            continue
+        srv = MCPServer(name, spec["command"], spec.get("args") or [], spec.get("env") or {})
+        try:
+            srv.start()
+        except (MCPError, OSError, Exception) as e:  # noqa: BLE001 — never crash startup
+            _say(f"MCP server '{name}' failed to start: {e}")
+            srv.stop()
+            continue
+        _SERVERS[name] = srv
+        for t in srv.tools:
+            schemas.append({
+                "name": f"mcp__{name}__{t['name']}",
+                "description": (t.get("description") or f"{name} tool {t['name']}")[:1024],
+                "input_schema": t.get("inputSchema") or {"type": "object", "properties": {}},
+            })
+        _say(f"MCP server '{name}': {len(srv.tools)} tool(s)")
+    return schemas
+
+
+def call(server: str, tool: str, arguments: dict) -> str:
+    srv = _SERVERS.get(server)
+    if srv is None:
+        return f"MCP server '{server}' is not connected."
+    try:
+        return srv.call(tool, arguments)
+    except MCPError as e:
+        return f"MCP call failed: {e}"
+
+
+def connected() -> dict[str, "MCPServer"]:
+    return dict(_SERVERS)
+
+
+def shutdown() -> None:
+    for srv in _SERVERS.values():
+        srv.stop()
+    _SERVERS.clear()

{drydock_cli-3.0.53 → drydock_cli-3.0.55}/drydock/tools/__init__.py

@@ -161,6 +161,34 @@ SCHEMAS = [
             "required": ["prompt"],
         },
     },
+    {
+        "name": "Dispatch",
+        "description": (
+            "Run SEVERAL read-only investigation sub-agents at once (in "
+            "parallel), each in its own fresh context with Read/Glob/Grep/Bash. "
+            "Use it to answer multiple INDEPENDENT questions concurrently, e.g. "
+            "'where is auth handled?', 'how does the DB layer work?', 'what tests "
+            "exist?'. Returns each agent's summary. They cannot write or recurse."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "tasks": {
+                    "type": "array",
+                    "description": "Up to 6 independent investigation tasks.",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "prompt": {"type": "string", "description": "The self-contained task."},
+                            "label": {"type": "string", "description": "Optional short label."},
+                        },
+                        "required": ["prompt"],
+                    },
+                },
+            },
+            "required": ["tasks"],
+        },
+    },
     {
         "name": "GitStatus",
         "description": (
@@ -787,15 +815,10 @@ _SUBAGENT_SYSTEM = (
 )
 
 
-def tool_task(params: dict, config: dict) -> str:
-    """Spawn a read-only sub-agent with a FRESH context for a focused
-    exploration task, returning only its final summary. Keeps big searches out
-    of the main agent's context. Cannot recurse (no `task` tool) and cannot
-    write (no Write/Edit), so it can never corrupt the parent's work."""
-    prompt = (params.get("prompt") or params.get("description") or "").strip()
-    if not prompt:
-        return "Error: `task` needs a `prompt` describing what to investigate."
-    # Lazy import to avoid a tools <-> agent import cycle.
+def _run_subagent(prompt: str, config: dict) -> str:
+    """Run one read-only sub-agent to completion and return its final summary.
+    Shared by `task` (one) and `Dispatch` (many in parallel). Hard-capped; never
+    raises (a sub-agent must not crash the parent turn)."""
     from drydock.agent import run as agent_run, AgentState, TurnDone
 
     sub_state = AgentState()
@@ -806,6 +829,9 @@ def tool_task(params: dict, config: dict) -> str:
     sub_config["max_tool_calls"] = 20
     sub_config.pop("_todo", None)      # the sub-agent keeps no checklist of its own
     sub_config.pop("_plan_autocontinue", None)
+    # Own abort holder so parallel sub-agents don't clobber each other's (or the
+    # parent's) in-flight client/proc handles in the shared dict.
+    sub_config["_abort"] = {}
     steps = 0
     try:
         for ev in agent_run(prompt, sub_state, sub_config, _SUBAGENT_SYSTEM):
@@ -819,6 +845,54 @@ def tool_task(params: dict, config: dict) -> str:
     return f"[sub-agent finished {steps} step(s) with no summary]"
 
 
+def tool_task(params: dict, config: dict) -> str:
+    """Spawn a read-only sub-agent with a FRESH context for a focused
+    exploration task, returning only its final summary. Keeps big searches out
+    of the main agent's context. Cannot recurse (no `task` tool) and cannot
+    write (no Write/Edit), so it can never corrupt the parent's work."""
+    prompt = (params.get("prompt") or params.get("description") or "").strip()
+    if not prompt:
+        return "Error: `task` needs a `prompt` describing what to investigate."
+    return _run_subagent(prompt, config)
+
+
+def tool_dispatch(params: dict, config: dict) -> str:
+    """Run SEVERAL read-only sub-agents concurrently and return all summaries.
+    Each gets its own fresh context + Read/Glob/Grep/Bash (no recursion, no
+    writes). Use it to investigate independent questions at once."""
+    import concurrent.futures
+
+    raw = params.get("tasks") or params.get("agents") or []
+    if isinstance(raw, dict):
+        raw = [raw]
+    norm: list[dict] = []
+    for t in raw:
+        if isinstance(t, str) and t.strip():
+            norm.append({"prompt": t.strip(), "label": ""})
+        elif isinstance(t, dict):
+            p = (t.get("prompt") or t.get("description") or "").strip()
+            if p:
+                norm.append({"prompt": p, "label": (t.get("label") or t.get("description") or "").strip()})
+    if not norm:
+        return "Error: `Dispatch` needs a `tasks` list, each item a prompt (string) or {prompt, label}."
+    norm = norm[:6]  # cap fan-out
+
+    results: list[str] = [""] * len(norm)
+    with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(norm))) as ex:
+        futs = {ex.submit(_run_subagent, t["prompt"], config): i for i, t in enumerate(norm)}
+        for fut in concurrent.futures.as_completed(futs):
+            i = futs[fut]
+            try:
+                results[i] = fut.result()
+            except Exception as e:  # noqa: BLE001
+                results[i] = f"[agent error: {e}]"
+    parts = [f"Dispatched {len(norm)} sub-agent(s) in parallel:"]
+    for i, t in enumerate(norm):
+        label = t["label"] or f"agent {i + 1}"
+        parts.append(f"\n=== {label} ===\n{results[i]}")
+    return "\n".join(parts)
+
+
 def _git_cwd(config: dict) -> str:
     return config.get("cwd") or os.getcwd()
 
@@ -940,6 +1014,7 @@ _TOOLS = [
     ("Grep", tool_grep, True),
     ("todo", tool_todo, False),
     ("task", tool_task, True),
+    ("Dispatch", tool_dispatch, True),
     ("Knowledge", tool_knowledge, True),
     ("WebSearch", tool_websearch, True),
     ("WebFetch", tool_webfetch, True),
@@ -955,7 +1030,8 @@ def register_all():
         func = {
             "Read": tool_read, "Write": tool_write, "Edit": tool_edit,
             "Bash": tool_bash, "Glob": tool_glob, "Grep": tool_grep,
-            "todo": tool_todo, "task": tool_task, "Knowledge": tool_knowledge,
+            "todo": tool_todo, "task": tool_task, "Dispatch": tool_dispatch,
+            "Knowledge": tool_knowledge,
             "WebSearch": tool_websearch, "WebFetch": tool_webfetch,
             "GitStatus": tool_gitstatus, "GitDiff": tool_gitdiff,
             "GitLog": tool_gitlog, "GitCommit": tool_gitcommit,
@@ -963,8 +1039,8 @@ def register_all():
         # Read-only w.r.t. the parent's files (GitStatus/Diff/Log inspect only;
         # GitCommit writes a local, reversible commit).
         read_only = name in (
-            "Read", "Glob", "Grep", "task", "Knowledge", "WebSearch", "WebFetch",
-            "GitStatus", "GitDiff", "GitLog",
+            "Read", "Glob", "Grep", "task", "Dispatch", "Knowledge",
+            "WebSearch", "WebFetch", "GitStatus", "GitDiff", "GitLog",
         )
         register(ToolDef(name=name, schema=schema, func=func, read_only=read_only))
 

{drydock_cli-3.0.53 → drydock_cli-3.0.55}/drydock/tui/app.py

@@ -494,10 +494,13 @@ class DrydockApp(App):
                 "                   /graphrag build <path> · /graphrag status · /graphrag clear\n"
                 "  /skills          list your reusable /<name> skills\n"
                 "  /loop            /loop <count> <prompt> — repeat a prompt (Esc stops)\n"
+                "  /mcp             list connected MCP servers and their tools\n"
                 "  /clear           reset the conversation\n"
                 "  /quit            exit\n"
                 "Type a task and press Enter. ↑/↓ recall history · Esc stops · Ctrl+O expands tools."
             )
+        elif cmd == "/mcp":
+            self._cmd_mcp()
         elif cmd == "/loop":
             self._cmd_loop(arg)
         elif cmd == "/skills":
@@ -507,6 +510,27 @@ class DrydockApp(App):
         else:
             self._mount(ErrorMessage(f"unknown command: {cmd} (try /help)"))
 
+    def _cmd_mcp(self) -> None:
+        """List connected MCP servers and the tools they expose."""
+        from drydock import mcp
+
+        servers = mcp.connected()
+        lines: list[str] = []
+        if not servers:
+            lines.append(
+                "No MCP servers connected. Configure them in ~/.drydock/mcp.json "
+                "(or <project>/.drydock/mcp.json) under \"mcpServers\", then restart."
+            )
+        else:
+            lines.append(f"MCP servers ({len(servers)} connected):")
+            for name, srv in servers.items():
+                tools = ", ".join(t["name"] for t in srv.tools) or "(no tools)"
+                lines.append(f"  • {name}: {tools}")
+            lines.append("Call them as mcp__<server>__<tool> (the model does this automatically).")
+        for msg in self.config.get("mcp_log") or []:
+            lines.append(f"  · {msg}")
+        self._info("\n".join(lines))
+
     def _cmd_loop(self, arg: str) -> None:
         """/loop <count> <prompt> — run <prompt> up to <count> times (1–50),
         re-submitting after each turn finishes. Esc (or /stop) ends the loop."""

{drydock_cli-3.0.53 → drydock_cli-3.0.55}/drydock/tui/widgets.py

@@ -153,7 +153,7 @@ class PromptHistory:
 # completes the prefix.
 SLASH_COMMANDS = [
     "/help", "/model", "/cwd", "/undo", "/back", "/stop", "/status",
-    "/compact", "/graphrag", "/skills", "/loop", "/clear", "/quit",
+    "/compact", "/graphrag", "/skills", "/loop", "/mcp", "/clear", "/quit",
 ]
 
 

{drydock_cli-3.0.53 → drydock_cli-3.0.55/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.53
+Version: 3.0.55
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.53 → drydock_cli-3.0.55}/drydock_cli.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ drydock/gittools.py
 drydock/graphrag.py
 drydock/guards.py
 drydock/loop_detect.py
+drydock/mcp.py
 drydock/providers.py
 drydock/skills.py
 drydock/tool_registry.py
@@ -43,6 +44,7 @@ tests/test_config.py
 tests/test_config_migration.py
 tests/test_context_limit_config.py
 tests/test_detect.py
+tests/test_dispatch.py
 tests/test_empty_response.py
 tests/test_failure_loop.py
 tests/test_first_run_setup.py
@@ -52,6 +54,7 @@ tests/test_guards_and_tools.py
 tests/test_hallucinated_tools.py
 tests/test_leaked_tool_call.py
 tests/test_loop_detect.py
+tests/test_mcp.py
 tests/test_oneshot_unreachable.py
 tests/test_plan_autocontinue.py
 tests/test_providers_unreachable.py

{drydock_cli-3.0.53 → drydock_cli-3.0.55}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.53"
+version = "3.0.55"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.55/tests/test_dispatch.py

@@ -0,0 +1,62 @@
+"""Multi-agent: the Dispatch tool fans out several read-only sub-agents in
+parallel and returns all summaries. The sub-agent runner is mocked so tests are
+deterministic and don't need the LLM."""
+from __future__ import annotations
+
+import time
+
+import drydock.tools as T
+
+
+def test_dispatch_runs_each_task_and_labels(monkeypatch):
+    monkeypatch.setattr(T, "_run_subagent", lambda p, c: f"R:{p}")
+    out = T.tool_dispatch({"tasks": [
+        {"prompt": "find auth", "label": "auth"},
+        {"prompt": "find db"},
+    ]}, {})
+    assert "=== auth ===" in out and "R:find auth" in out
+    assert "=== agent 2 ===" in out and "R:find db" in out
+
+
+def test_dispatch_accepts_string_tasks(monkeypatch):
+    monkeypatch.setattr(T, "_run_subagent", lambda p, c: f"R:{p}")
+    out = T.tool_dispatch({"tasks": ["a", "b", "c"]}, {})
+    assert out.count("R:") == 3
+
+
+def test_dispatch_needs_tasks():
+    assert "needs a `tasks`" in T.tool_dispatch({"tasks": []}, {})
+    assert "needs a `tasks`" in T.tool_dispatch({}, {})
+
+
+def test_dispatch_caps_fanout(monkeypatch):
+    monkeypatch.setattr(T, "_run_subagent", lambda p, c: "x")
+    out = T.tool_dispatch({"tasks": [f"t{i}" for i in range(20)]}, {})
+    assert "Dispatched 6 sub-agent" in out  # capped at 6
+
+
+def test_dispatch_isolates_subagent_errors(monkeypatch):
+    def runner(p, c):
+        if "boom" in p:
+            raise RuntimeError("kaboom")
+        return f"R:{p}"
+    monkeypatch.setattr(T, "_run_subagent", runner)
+    out = T.tool_dispatch({"tasks": ["ok", "boom"]}, {})
+    assert "R:ok" in out and "agent error" in out  # one fails, the other survives
+
+
+def test_dispatch_runs_concurrently(monkeypatch):
+    # 4 tasks that each sleep 0.2s should finish in well under 0.8s (serial time)
+    def slow(p, c):
+        time.sleep(0.2)
+        return "done"
+    monkeypatch.setattr(T, "_run_subagent", slow)
+    t0 = time.monotonic()
+    T.tool_dispatch({"tasks": ["a", "b", "c", "d"]}, {})
+    assert time.monotonic() - t0 < 0.6  # parallel, not 0.8s serial
+
+
+def test_task_still_works_via_shared_runner(monkeypatch):
+    monkeypatch.setattr(T, "_run_subagent", lambda p, c: f"summary:{p}")
+    assert T.tool_task({"prompt": "explore X"}, {}) == "summary:explore X"
+    assert "needs a `prompt`" in T.tool_task({}, {})

drydock_cli-3.0.55/tests/test_mcp.py

@@ -0,0 +1,57 @@
+"""MCP client: connect to a stdio MCP server, list + call its tools. Uses a real
+(mock) server subprocess so the JSON-RPC handshake is exercised end to end."""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from drydock import mcp
+
+_SERVER = str(Path(__file__).parent / "fixtures" / "mock_mcp_server.py")
+
+
+def _write_cfg(cwd: Path):
+    d = cwd / ".drydock"
+    d.mkdir(parents=True, exist_ok=True)
+    (d / "mcp.json").write_text(json.dumps({
+        "mcpServers": {"mock": {"command": sys.executable, "args": [_SERVER]}}
+    }))
+
+
+def teardown_function(_):
+    mcp.shutdown()
+
+
+def test_connect_lists_tools(tmp_path):
+    _write_cfg(tmp_path)
+    schemas = mcp.connect_all(str(tmp_path))
+    names = [s["name"] for s in schemas]
+    assert "mcp__mock__echo" in names
+    assert mcp.connected()["mock"].tools[0]["name"] == "echo"
+
+
+def test_call_tool_round_trips(tmp_path):
+    _write_cfg(tmp_path)
+    mcp.connect_all(str(tmp_path))
+    out = mcp.call("mock", "echo", {"text": "hello mcp"})
+    assert out == "echo: hello mcp"
+
+
+def test_call_unknown_server_is_graceful(tmp_path):
+    assert "not connected" in mcp.call("nope", "echo", {"text": "x"})
+
+
+def test_missing_config_is_noop(tmp_path):
+    assert mcp.connect_all(str(tmp_path)) == []
+
+
+def test_bad_server_is_skipped(tmp_path):
+    d = tmp_path / ".drydock"; d.mkdir(parents=True)
+    (d / "mcp.json").write_text(json.dumps({
+        "mcpServers": {"broken": {"command": "this_command_does_not_exist_xyz", "args": []}}
+    }))
+    logs = []
+    schemas = mcp.connect_all(str(tmp_path), log=logs.append)
+    assert schemas == []
+    assert any("failed to start" in m for m in logs)