MCP Clients: What Each One Supports and How to Confirm What a Client Declares

#!/usr/bin/env python3
"""Probe MCP server: record what a connecting client says about itself and which list methods it calls.

Usage: client_probe_server.py [--era modern|legacy] [--port 8240]
Point a client at http://127.0.0.1:8240/mcp. Every POST prints one JSON line:
  method, protocol (the MCP-Protocol-Version header, or the version the client offers in `initialize`),
  version (the protocolVersion in the `_meta` of a modern request), client (name and version),
  capabilities (what the client declares: roots, sampling, elicitation, ...).
`--era modern` answers `server/discover` (revision 2026-07-28; a client names itself in the `_meta` of every
request) and refuses `initialize`. `--era legacy` refuses `server/discover` and answers `initialize` (a client names
itself once, in the handshake). The server offers empty tool, resource and prompt lists, so a client that wants
any of the three has a reason to ask. Standard library only.
"""
import argparse
import json
import sys
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

PREFIX = "io.modelcontextprotocol/"
MODERN = "2026-07-28"
LEGACY = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"]
CAPABILITIES = {"tools": {}, "resources": {}, "prompts": {}}
LISTS = {"tools/list": "tools", "resources/list": "resources", "prompts/list": "prompts"}


def make_handler(era, log):
    class Handler(BaseHTTPRequestHandler):
        def log_message(self, *args):  # keep stdout for the records
            pass

        def reply(self, status, body=None):
            data = json.dumps(body).encode() if body is not None else b""
            self.send_response(status)
            if body is not None:
                self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", str(len(data)))
            self.end_headers()
            self.wfile.write(data)

        def do_GET(self):  # no server-initiated stream: the spec allows 405
            self.reply(405)

        do_DELETE = do_GET

        def do_POST(self):
            try:
                msg = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0))))
                method, params = msg["method"], msg.get("params") or {}
            except (ValueError, KeyError, TypeError):
                return self.reply(400, {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "bad request"}})
            meta = params.get("_meta") or {}
            entry = {"method": method, "protocol": self.headers.get("MCP-Protocol-Version") or params.get("protocolVersion"),
                     "version": meta.get(PREFIX + "protocolVersion"),
                     "client": meta.get(PREFIX + "clientInfo") or params.get("clientInfo"),
                     "capabilities": meta.get(PREFIX + "clientCapabilities", params.get("capabilities"))}
            log({k: v for k, v in entry.items() if v is not None})
            if "id" not in msg:  # a notification gets no body
                return self.reply(202)
            result, error = None, None
            if method == "server/discover" and era == "modern":
                result = {"resultType": "complete", "supportedVersions": [MODERN], "capabilities": CAPABILITIES,
                          "ttlMs": 0, "cacheScope": "private"}
            elif method == "initialize" and era == "legacy":
                offered = params.get("protocolVersion")
                result = {"protocolVersion": offered if offered in LEGACY else LEGACY[0], "capabilities": CAPABILITIES,
                          "serverInfo": {"name": "client-probe", "version": "1"}}
            elif method in LISTS:
                result = {LISTS[method]: []}
                if era == "modern":
                    result.update(resultType="complete", ttlMs=0, cacheScope="private")
            else:
                error = {"code": -32601, "message": "Method not found: %s" % method}
            body = {"jsonrpc": "2.0", "id": msg["id"]}
            body.update({"error": error} if error else {"result": result})
            self.reply(200, body)

    return Handler


def summarize(record):
    """One readable line per record: method, protocol, client, and the capability names it declares."""
    parts = ["%-26s" % record["method"], "protocol=%s" % record.get("protocol")]
    client = record.get("client")
    if client:
        parts.append("client=%s/%s" % (client.get("name"), client.get("version")))
    if "capabilities" in record:
        parts.append("declares=%s" % (sorted(record["capabilities"]) or "nothing"))
    return "  " + " ".join(parts).rstrip()


def serve(era, port, log):
    return ThreadingHTTPServer(("127.0.0.1", port), make_handler(era, log))


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--era", choices=["modern", "legacy"], default="modern")
    ap.add_argument("--port", type=int, default=8240)
    args = ap.parse_args()
    server = serve(args.era, args.port, lambda e: print(json.dumps(e, sort_keys=True), flush=True))
    print("probe (%s era) on http://127.0.0.1:%d/mcp" % (args.era, args.port), file=sys.stderr, flush=True)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Connect the official Python SDK client (mcp==2.3.0) to the probe server in four configurations and print what
the probe recorded. The list calls are issued by this script; a real client issues its own, and that is what you read.

Usage: probe_runs.py      Exit code 0 = every run recorded what its configuration implies, 1 = it did not.
"""
import asyncio
import sys
import threading

from mcp import types
from mcp.client import Client

import client_probe_server as probe

PORT = 8241


async def no_sampling(context, params):
    return types.ErrorData(code=-32601, message="not used in this run")


async def no_roots(context):
    return types.ErrorData(code=-32601, message="not used in this run")


async def no_elicitation(context, params):
    return types.ErrorData(code=-32601, message="not used in this run")


def run(era, callbacks):
    records = []
    server = probe.serve(era, PORT, records.append)
    thread = threading.Thread(target=server.serve_forever, daemon=True)
    thread.start()
    kwargs = {"sampling_callback": no_sampling, "list_roots_callback": no_roots,
              "elicitation_callback": no_elicitation} if callbacks else {}

    async def drive():
        async with Client("http://127.0.0.1:%d/mcp" % PORT, **kwargs) as client:
            await client.list_tools()
            await client.list_resources()
            await client.list_prompts()

    try:
        asyncio.run(drive())
    finally:
        server.shutdown()
        server.server_close()
        thread.join()
    return records


def main():
    failed = 0
    for era in ("modern", "legacy"):
        for callbacks in (False, True):
            records = run(era, callbacks)
            print("run: era=%s callbacks=%s" % (era, "sampling,roots,elicitation" if callbacks else "none"))
            for record in records:
                print(probe.summarize(record))
            methods = [r["method"] for r in records]
            declared = [r for r in records if "capabilities" in r]
            wanted = ["elicitation", "roots", "sampling"] if callbacks else []
            ok = (methods[:1] == ["server/discover"]  # the SDK always probes first
                  and ("initialize" in methods) == (era == "legacy")  # only a legacy server gets the handshake
                  and [m for m in methods if m.endswith("/list")] == ["tools/list", "resources/list", "prompts/list"]
                  and bool(declared) and all(sorted(r["capabilities"]) == wanted for r in declared))
            print("  check: %s" % ("as configured" if ok else "NOT as configured"))
            failed += 0 if ok else 1
    return 1 if failed else 0


if __name__ == "__main__":
    sys.exit(main())

run: era=modern callbacks=none
  server/discover            protocol=2026-07-28 client=mcp/0.1.0 declares=nothing
  tools/list                 protocol=2026-07-28 client=mcp/0.1.0 declares=nothing
  resources/list             protocol=2026-07-28 client=mcp/0.1.0 declares=nothing
  prompts/list               protocol=2026-07-28 client=mcp/0.1.0 declares=nothing
  check: as configured
run: era=modern callbacks=sampling,roots,elicitation
  server/discover            protocol=2026-07-28 client=mcp/0.1.0 declares=['elicitation', 'roots', 'sampling']
  tools/list                 protocol=2026-07-28 client=mcp/0.1.0 declares=['elicitation', 'roots', 'sampling']
  resources/list             protocol=2026-07-28 client=mcp/0.1.0 declares=['elicitation', 'roots', 'sampling']
  prompts/list               protocol=2026-07-28 client=mcp/0.1.0 declares=['elicitation', 'roots', 'sampling']
  check: as configured
run: era=legacy callbacks=none
  server/discover            protocol=2026-07-28 client=mcp/0.1.0 declares=nothing
  initialize                 protocol=2025-11-25 client=mcp/0.1.0 declares=nothing
  notifications/initialized  protocol=2025-11-25
  tools/list                 protocol=2025-11-25
  resources/list             protocol=2025-11-25
  prompts/list               protocol=2025-11-25
  check: as configured
run: era=legacy callbacks=sampling,roots,elicitation
  server/discover            protocol=2026-07-28 client=mcp/0.1.0 declares=['elicitation', 'roots', 'sampling']
  initialize                 protocol=2025-11-25 client=mcp/0.1.0 declares=['elicitation', 'roots', 'sampling']
  notifications/initialized  protocol=2025-11-25
  tools/list                 protocol=2025-11-25
  resources/list             protocol=2025-11-25
  prompts/list               protocol=2025-11-25
  check: as configured

#!/usr/bin/env python3
"""Connect the real Claude Code CLI to the probe server and print what it declares.

`claude mcp list` health-checks every configured server, so adding the probe and running it once records the
client's own handshake. HOME, XDG_CONFIG_HOME and CLAUDE_CONFIG_DIR point at a throw-away directory, so your own
Claude Code configuration and servers are neither read nor changed. Needs the `claude` CLI on PATH; exit code 3
when it is missing.
Usage: claude_code_probe.py [--save FILE]   (--save writes the full records of both runs as JSON)
"""
import argparse
import json
import os
import shutil
import subprocess
import sys
import tempfile
import threading
from pathlib import Path

import client_probe_server as probe

PORT = 8243
URL = "http://127.0.0.1:%d/mcp" % PORT


def run_era(era, env, cwd):
    records = []
    server = probe.serve(era, PORT, records.append)
    thread = threading.Thread(target=server.serve_forever, daemon=True)
    thread.start()
    try:
        subprocess.run(["claude", "mcp", "add", "--transport", "http", "-s", "local", "probe", URL],
                       cwd=cwd, env=env, check=True, capture_output=True, text=True, timeout=120)
        listed = subprocess.run(["claude", "mcp", "list"], cwd=cwd, env=env, capture_output=True, text=True, timeout=120)
        status = [line for line in listed.stdout.splitlines() if line.startswith("probe:")]
        subprocess.run(["claude", "mcp", "remove", "probe", "-s", "local"], cwd=cwd, env=env, capture_output=True, text=True, timeout=120)
    finally:
        server.shutdown()
        server.server_close()
        thread.join()
    return records, status[0].split(" - ")[-1] if status else "no status line"


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--save")
    args = ap.parse_args()
    if not shutil.which("claude"):
        print("claude CLI not found on PATH", file=sys.stderr)
        return 3
    version = subprocess.run(["claude", "--version"], capture_output=True, text=True, timeout=60).stdout.strip()
    print("claude --version: %s" % version)
    saved = {"version": version}
    with tempfile.TemporaryDirectory() as home, tempfile.TemporaryDirectory() as cwd:
        env = dict(os.environ, HOME=home, XDG_CONFIG_HOME=os.path.join(home, ".config"),
                   CLAUDE_CONFIG_DIR=os.path.join(home, ".claude"))
        for era in ("legacy", "modern"):
            records, status = run_era(era, env, cwd)
            saved[era] = records
            print("run: probe era=%s, claude mcp list says: %s" % (era, status))
            for record in records:
                print(probe.summarize(record))
            first = next((r for r in records if "capabilities" in r), None)
            if first:
                print("  declared in full: %s" % json.dumps(first["capabilities"], sort_keys=True))
    if args.save:
        Path(args.save).write_text(json.dumps(saved, indent=1, sort_keys=True) + "\n", encoding="utf-8")
    return 0


if __name__ == "__main__":
    sys.exit(main())

claude --version: 2.1.292 (Claude Code)
run: probe era=legacy, claude mcp list says: ✔ Connected
  server/discover            protocol=2026-07-28 client=claude-code/2.1.292 declares=['elicitation', 'roots']
  initialize                 protocol=2025-11-25 client=claude-code/2.1.292 declares=['elicitation', 'roots']
  notifications/initialized  protocol=2025-11-25
  tools/list                 protocol=2025-11-25
  declared in full: {"elicitation": {"form": {}, "url": {}}, "roots": {"listChanged": true}}
run: probe era=modern, claude mcp list says: ✔ Connected
  server/discover            protocol=2026-07-28 client=claude-code/2.1.292 declares=['elicitation', 'roots']
  tools/list                 protocol=2026-07-28 client=claude-code/2.1.292 declares=['elicitation', 'roots']
  declared in full: {"elicitation": {"form": {}, "url": {}}, "roots": {"listChanged": true}}