@oh-my-pi/pi-coding-agent 16.2.11 → 16.2.13

package/src/lsp/client.ts

@@ -180,22 +180,91 @@ const CLIENT_CAPABILITIES = {
 // LSP Message Protocol
 // =============================================================================
 
+function abortReason(signal: AbortSignal): Error {
+	return signal.reason instanceof Error ? signal.reason : new ToolAbortError();
+}
+
+class LspFlushAbortError extends Error {
+	constructor(readonly reason: Error) {
+		super(reason.message);
+		this.name = "LspFlushAbortError";
+	}
+}
+
 async function writeMessage(
 	sink: Bun.FileSink,
 	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
+	signal?: AbortSignal,
 ): Promise<void> {
+	if (signal?.aborted) {
+		throw abortReason(signal);
+	}
 	const content = JSON.stringify(message);
 	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n${content}`);
-	await sink.flush();
+	const flush = Promise.resolve(sink.flush());
+	if (!signal) {
+		await flush;
+		return;
+	}
+	// The sink's flush blocks on the OS-level pipe drain: if the server is
+	// alive but stopped reading stdin, `await sink.flush()` never resolves.
+	// Race the flush against the caller's signal so a wedged server surfaces
+	// as the tool's normal timeout/cancel instead of a permanent hang.
+	const { promise, resolve, reject } = Promise.withResolvers<void>();
+	const onAbort = () => {
+		signal.removeEventListener("abort", onAbort);
+		// The underlying flush stays pending in the background; suppress its
+		// eventual settlement so we do not surface an unhandled rejection.
+		flush.catch(() => {});
+		reject(new LspFlushAbortError(abortReason(signal)));
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	flush.then(
+		() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		},
+		(err: unknown) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(err);
+		},
+	);
+	await promise;
+}
+
+/**
+ * Kill a client whose write queue is stuck (aborted flush left the sink's
+ * flush promise pending, so subsequent writes queue behind a wedge forever).
+ * Remove it from `clients` immediately so concurrent `getOrCreateClient`
+ * callers do not grab the corpse before `proc.exited` cleans up.
+ */
+function teardownWedgedClient(client: LspClient): void {
+	if (clients.get(client.name) === client) clients.delete(client.name);
+	try {
+		client.proc.kill();
+	} catch {
+		// process already gone or unkillable — the exit handler will finish cleanup.
+	}
 }
 
 function queueWriteMessage(
 	client: LspClient,
 	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
+	signal?: AbortSignal,
 ): Promise<void> {
-	const write = client.writeQueue.catch(() => {}).then(() => writeMessage(client.proc.stdin, message));
-	client.writeQueue = write.catch(() => {});
-	return write;
+	const write = client.writeQueue.catch(() => {}).then(() => writeMessage(client.proc.stdin, message, signal));
+	const result = write.catch((err: unknown) => {
+		if (err instanceof LspFlushAbortError) {
+			// Only an abort that raced this write's in-flight flush leaves
+			// the sink pending. Pre-write aborts and queued caller timeouts
+			// must not kill a healthy shared client.
+			teardownWedgedClient(client);
+			throw err.reason;
+		}
+		throw err;
+	});
+	client.writeQueue = result.catch(() => {});
+	return result;
 }
 
 // =============================================================================
@@ -530,9 +599,18 @@ const EXIT_TIMEOUT_MS = 1_000;
  * Get or create an LSP client for the given server configuration and working directory.
  * @param config - Server configuration
  * @param cwd - Working directory
- * @param initTimeoutMs - Optional timeout for the initialize request (defaults to 30s)
+ * @param initTimeoutMs - Optional hard deadline for the initialize handshake (warmup / other
+ *   short-lived callers). When set it takes precedence over `signal` inside `sendRequest`.
+ * @param signal - Optional caller abort signal. Threaded into the initialize `sendRequest`
+ *   and the `initialized` notification so a wedged server surfaces the caller's
+ *   timeout/cancel instead of falling back to the internal 30s default.
  */
-export async function getOrCreateClient(config: ServerConfig, cwd: string, initTimeoutMs?: number): Promise<LspClient> {
+export async function getOrCreateClient(
+	config: ServerConfig,
+	cwd: string,
+	initTimeoutMs?: number,
+	signal?: AbortSignal,
+): Promise<LspClient> {
 	const key = `${config.command}:${cwd}`;
 
 	// Check if client already exists
@@ -649,7 +727,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 					initializationOptions: config.initOptions ?? {},
 					workspaceFolders: currentWorkspaceFolders(client),
 				},
-				undefined, // signal
+				signal,
 				initTimeoutMs,
 			)) as { capabilities?: unknown };
 
@@ -660,7 +738,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			client.serverCapabilities = initResult.capabilities as LspClient["serverCapabilities"];
 
 			// Send initialized notification
-			await sendNotification(client, "initialized", {});
+			await sendNotification(client, "initialized", {}, signal);
 
 			client.status = "ready";
 			// Publish only after init succeeds: pre-init clients are reachable
@@ -676,10 +754,10 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			proc.kill();
 			const message = err instanceof Error ? err.message : String(err);
 			// Negative-cache deterministic failures. Timeouts under a
-			// caller-shortened deadline (warmup/writethrough) are not cached —
-			// the server may simply be slow and a later call with the full
-			// deadline can still succeed.
-			if (!(initTimeoutMs !== undefined && message.includes("timed out"))) {
+			// caller-shortened deadline (warmup/writethrough) and caller-signal
+			// aborts are transient — the server may simply be slow or the user may
+			// have cancelled, so a later call with a fresh deadline should retry.
+			if (!signal?.aborted && !(initTimeoutMs !== undefined && message.includes("timed out"))) {
 				initFailures.set(key, { at: Date.now(), message });
 			}
 			throw err;
@@ -732,14 +810,19 @@ export async function ensureFileOpen(client: LspClient, filePath: string, signal
 		const languageId = detectLanguageId(filePath);
 		throwIfAborted(signal);
 
-		await sendNotification(client, "textDocument/didOpen", {
-			textDocument: {
-				uri,
-				languageId,
-				version: 1,
-				text: content,
+		await sendNotification(
+			client,
+			"textDocument/didOpen",
+			{
+				textDocument: {
+					uri,
+					languageId,
+					version: 1,
+					text: content,
+				},
 			},
-		});
+			signal,
+		);
 
 		client.openFiles.set(uri, { version: 1, languageId });
 		client.lastActivity = Date.now();
@@ -800,14 +883,19 @@ export async function syncContent(
 			// Open file with provided content instead of reading from disk
 			const languageId = detectLanguageId(filePath);
 			throwIfAborted(signal);
-			await sendNotification(client, "textDocument/didOpen", {
-				textDocument: {
-					uri,
-					languageId,
-					version: 1,
-					text: content,
+			await sendNotification(
+				client,
+				"textDocument/didOpen",
+				{
+					textDocument: {
+						uri,
+						languageId,
+						version: 1,
+						text: content,
+					},
 				},
-			});
+				signal,
+			);
 			client.openFiles.set(uri, { version: 1, languageId });
 			client.lastActivity = Date.now();
 			return;
@@ -815,10 +903,15 @@ export async function syncContent(
 
 		const version = ++info.version;
 		throwIfAborted(signal);
-		await sendNotification(client, "textDocument/didChange", {
-			textDocument: { uri, version },
-			contentChanges: [{ text: content }],
-		});
+		await sendNotification(
+			client,
+			"textDocument/didChange",
+			{
+				textDocument: { uri, version },
+				contentChanges: [{ text: content }],
+			},
+			signal,
+		);
 		client.lastActivity = Date.now();
 	})();
 
@@ -840,9 +933,14 @@ export async function notifySaved(client: LspClient, filePath: string, signal?:
 	if (!info) return; // File not open, nothing to notify
 
 	throwIfAborted(signal);
-	await sendNotification(client, "textDocument/didSave", {
-		textDocument: { uri },
-	});
+	await sendNotification(
+		client,
+		"textDocument/didSave",
+		{
+			textDocument: { uri },
+		},
+		signal,
+	);
 	client.lastActivity = Date.now();
 }
 
@@ -884,16 +982,26 @@ export async function refreshFile(client: LspClient, filePath: string, signal?:
 		const version = ++info.version;
 		throwIfAborted(signal);
 
-		await sendNotification(client, "textDocument/didChange", {
-			textDocument: { uri, version },
-			contentChanges: [{ text: content }],
-		});
+		await sendNotification(
+			client,
+			"textDocument/didChange",
+			{
+				textDocument: { uri, version },
+				contentChanges: [{ text: content }],
+			},
+			signal,
+		);
 		throwIfAborted(signal);
 
-		await sendNotification(client, "textDocument/didSave", {
-			textDocument: { uri },
-			text: content,
-		});
+		await sendNotification(
+			client,
+			"textDocument/didSave",
+			{
+				textDocument: { uri },
+				text: content,
+			},
+			signal,
+		);
 
 		client.lastActivity = Date.now();
 	})();
@@ -1044,8 +1152,10 @@ export async function sendRequest(
 		method,
 	});
 
-	// Write request
-	queueWriteMessage(client, request).catch(err => {
+	// Write request. `queueWriteMessage(..., signal)` bounds the sink flush
+	// so a wedged server does not stall the write queue past the signal's
+	// deadline; the write-queue teardown kills the client on abort.
+	queueWriteMessage(client, request, signal).catch(err => {
 		if (timeout) clearTimeout(timeout);
 		client.pendingRequests.delete(id);
 		cleanup();
@@ -1056,8 +1166,15 @@ export async function sendRequest(
 
 /**
  * Send an LSP notification (no response expected).
+ * `signal` bounds the underlying `sink.flush()` — without it a server that
+ * stops draining stdin blocks every future write on the client's write queue.
  */
-export async function sendNotification(client: LspClient, method: string, params: unknown): Promise<void> {
+export async function sendNotification(
+	client: LspClient,
+	method: string,
+	params: unknown,
+	signal?: AbortSignal,
+): Promise<void> {
 	const notification: LspJsonRpcNotification = {
 		jsonrpc: "2.0",
 		method,
@@ -1065,7 +1182,7 @@ export async function sendNotification(client: LspClient, method: string, params
 	};
 
 	client.lastActivity = Date.now();
-	await queueWriteMessage(client, notification);
+	await queueWriteMessage(client, notification, signal);
 }
 
 /**

package/src/lsp/index.ts

@@ -216,7 +216,7 @@ async function syncFileContent(
 			if (serverConfig.createClient) {
 				return;
 			}
-			const client = await getOrCreateClient(serverConfig, cwd);
+			const client = await getOrCreateClient(serverConfig, cwd, undefined, signal);
 			throwIfAborted(signal);
 			await syncContent(client, absolutePath, content, signal);
 		}),
@@ -244,7 +244,7 @@ async function notifyFileSaved(
 			if (serverConfig.createClient) {
 				return;
 			}
-			const client = await getOrCreateClient(serverConfig, cwd);
+			const client = await getOrCreateClient(serverConfig, cwd, undefined, signal);
 			await notifySaved(client, absolutePath, signal);
 		}),
 	);
@@ -469,7 +469,7 @@ async function reloadServer(client: LspClient, serverName: string, signal?: Abor
 	// as a request hangs until the tool deadline on servers that route it to
 	// the notification handler and never respond.
 	try {
-		await sendNotification(client, "workspace/didChangeConfiguration", { settings: {} });
+		await sendNotification(client, "workspace/didChangeConfiguration", { settings: {} }, signal);
 		return `Reloaded ${serverName}`;
 	} catch {
 		client.proc.kill();
@@ -643,12 +643,13 @@ async function captureDiagnosticVersions(
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
 	initTimeoutMs?: number,
+	signal?: AbortSignal,
 ): Promise<ServerVersionMap> {
 	const versions = new Map<string, number>();
 	await Promise.allSettled(
 		servers.map(async ([serverName, serverConfig]) => {
 			if (serverConfig.createClient) return;
-			const client = await getOrCreateClient(serverConfig, cwd, initTimeoutMs);
+			const client = await getOrCreateClient(serverConfig, cwd, initTimeoutMs, signal);
 			versions.set(serverName, client.diagnosticsVersion);
 		}),
 	);
@@ -659,12 +660,13 @@ async function captureOpenFileVersions(
 	absolutePath: string,
 	cwd: string,
 	servers: Array<[string, ServerConfig]>,
+	signal?: AbortSignal,
 ): Promise<ServerVersionMap> {
 	const uri = fileToUri(absolutePath);
 	const versions = new Map<string, number>();
 	await Promise.allSettled(
 		servers.map(async ([serverName, serverConfig]) => {
-			const client = await getOrCreateClient(serverConfig, cwd);
+			const client = await getOrCreateClient(serverConfig, cwd, undefined, signal);
 			const version = client.openFiles.get(uri)?.version;
 			if (version !== undefined) {
 				versions.set(serverName, version);
@@ -711,7 +713,7 @@ async function getDiagnosticsForFile(
 			}
 
 			// Default: use LSP
-			const client = await getOrCreateClient(serverConfig, cwd);
+			const client = await getOrCreateClient(serverConfig, cwd, undefined, signal);
 			throwIfAborted(signal);
 			if (isProjectAwareLspServer(serverConfig)) {
 				await waitForProjectLoaded(client, signal);
@@ -812,7 +814,7 @@ async function formatContent(
 			}
 
 			// Default: use LSP
-			const client = await getOrCreateClient(serverConfig, cwd);
+			const client = await getOrCreateClient(serverConfig, cwd, undefined, signal);
 			throwIfAborted(signal);
 
 			const caps = client.serverCapabilities;
@@ -1118,7 +1120,7 @@ async function runLspWritethrough(
 	// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
 	// Bound client creation by the writethrough budget: a hung/broken server
 	// must not add its full init wait (30s default) to every edit.
-	const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers, 5_000) : undefined;
+	const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers, 5_000, signal) : undefined;
 	let expectedDocumentVersions: ServerVersionMap | undefined;
 
 	let formatter: FileFormatResult | undefined;
@@ -1163,7 +1165,7 @@ async function runLspWritethrough(
 			}
 
 			if (enableDiagnostics) {
-				expectedDocumentVersions = await captureOpenFileVersions(dst, cwd, lspServers);
+				expectedDocumentVersions = await captureOpenFileVersions(dst, cwd, lspServers, operationSignal);
 			}
 
 			// 5. Notify saved to LSP servers
@@ -1460,7 +1462,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 							allDiagnostics.push(...diagnostics);
 							continue;
 						}
-						const client = await getOrCreateClient(serverConfig, this.session.cwd);
+						const client = await getOrCreateClient(serverConfig, this.session.cwd, undefined, signal);
 						if (isProjectAwareLspServer(serverConfig)) {
 							await waitForProjectLoaded(client, signal);
 							throwIfAborted(signal);
@@ -1634,7 +1636,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			for (const [serverName, serverConfig] of servers) {
 				throwIfAborted(signal);
 				try {
-					const client = await getOrCreateClient(serverConfig, this.session.cwd);
+					const client = await getOrCreateClient(serverConfig, this.session.cwd, undefined, signal);
 					if (isProjectAwareLspServer(serverConfig)) {
 						await waitForProjectLoaded(client, signal);
 					}
@@ -1781,16 +1783,14 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 			for (const [serverName, serverConfig] of servers) {
 				try {
-					const client = await getOrCreateClient(serverConfig, this.session.cwd);
+					const client = await getOrCreateClient(serverConfig, this.session.cwd, undefined, signal);
 					for (const { oldUri } of pairs) {
 						if (client.openFiles.has(oldUri)) {
-							await sendNotification(client, "textDocument/didClose", {
-								textDocument: { uri: oldUri },
-							});
+							await sendNotification(client, "textDocument/didClose", { textDocument: { uri: oldUri } }, signal);
 							client.openFiles.delete(oldUri);
 						}
 					}
-					await sendNotification(client, "workspace/didRenameFiles", lspParams);
+					await sendNotification(client, "workspace/didRenameFiles", lspParams, signal);
 				} catch (err) {
 					if (err instanceof ToolAbortError || signal?.aborted) {
 						throw err;
@@ -1844,7 +1844,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			for (const [serverName, serverConfig] of serverList) {
 				throwIfAborted(signal);
 				try {
-					const client = await getOrCreateClient(serverConfig, this.session.cwd);
+					const client = await getOrCreateClient(serverConfig, this.session.cwd, undefined, signal);
 					respondingServers.add(serverName);
 					const caps = client.serverCapabilities ?? {};
 					sections.push(`${serverName}:`);
@@ -1930,7 +1930,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			}
 
 			try {
-				const client = await getOrCreateClient(chosenConfig, this.session.cwd);
+				const client = await getOrCreateClient(chosenConfig, this.session.cwd, undefined, signal);
 				if (resolvedTarget) {
 					await ensureFileOpen(client, resolvedTarget, signal);
 				}
@@ -2001,7 +2001,12 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			for (const [workspaceServerName, workspaceServerConfig] of servers) {
 				throwIfAborted(signal);
 				try {
-					const workspaceClient = await getOrCreateClient(workspaceServerConfig, this.session.cwd);
+					const workspaceClient = await getOrCreateClient(
+						workspaceServerConfig,
+						this.session.cwd,
+						undefined,
+						signal,
+					);
 					const workspaceResult = (await sendRequest(
 						workspaceClient,
 						"workspace/symbol",
@@ -2072,7 +2077,12 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			for (const [workspaceServerName, workspaceServerConfig] of servers) {
 				throwIfAborted(signal);
 				try {
-					const workspaceClient = await getOrCreateClient(workspaceServerConfig, this.session.cwd);
+					const workspaceClient = await getOrCreateClient(
+						workspaceServerConfig,
+						this.session.cwd,
+						undefined,
+						signal,
+					);
 					outputs.push(await reloadServer(workspaceClient, workspaceServerName, signal));
 				} catch (err) {
 					if (err instanceof ToolAbortError || signal?.aborted) {
@@ -2099,7 +2109,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 		const [serverName, serverConfig] = serverInfo;
 
 		try {
-			const client = await getOrCreateClient(serverConfig, this.session.cwd);
+			const client = await getOrCreateClient(serverConfig, this.session.cwd, undefined, signal);
 			const targetFile = resolvedFile;
 			const isRustAnalyzerServer =
 				serverName === "rust-analyzer" ||

package/src/main.ts

@@ -850,7 +850,6 @@ async function buildSessionOptions(
 				{
 					settings: activeSettings,
 					matchPreferences: modelMatchPreferences,
-					modelRegistry,
 				},
 			);
 			const rememberedResolvedModel = rememberedSpec.model;

package/src/mcp/transports/http.ts

@@ -238,8 +238,6 @@ export class HttpTransport implements MCPTransport {
 				signal: operation.signal,
 			});
 
-			operation.clear();
-
 			// Check for session ID in response
 			const newSessionId = response.headers.get("Mcp-Session-Id");
 			if (newSessionId) {
@@ -276,11 +274,12 @@ export class HttpTransport implements MCPTransport {
 
 			return result.result as T;
 		} catch (error) {
-			operation.clear();
 			if (operation.isTimeoutAbort(error)) {
 				throw new Error(`Request timeout after ${timeout}ms`);
 			}
 			throw error;
+		} finally {
+			operation.clear();
 		}
 	}
 
@@ -373,7 +372,7 @@ export class HttpTransport implements MCPTransport {
 			headers["Mcp-Session-Id"] = this.#sessionId;
 		}
 		const timeout = resolveMCPTimeoutMs(this.config.timeout);
-		let operation = createMCPTimeout(timeout);
+		const operation = createMCPTimeout(timeout);
 		try {
 			const resp = await fetch(this.config.url, {
 				method: "POST",
@@ -381,7 +380,6 @@ export class HttpTransport implements MCPTransport {
 				body: JSON.stringify(body),
 				signal: operation.signal,
 			});
-			operation.clear();
 			// Retry once on auth failure if onAuthError is wired
 			if (this.onAuthError && (resp.status === 401 || resp.status === 403)) {
 				await resp.body?.cancel();
@@ -390,22 +388,27 @@ export class HttpTransport implements MCPTransport {
 					this.config.headers ??= {};
 					Object.assign(this.config.headers, newHeaders);
 					Object.assign(headers, newHeaders);
-					operation = createMCPTimeout(timeout);
-					const retry = await fetch(this.config.url, {
-						method: "POST",
-						headers,
-						body: JSON.stringify(body),
-						signal: operation.signal,
-					});
 					operation.clear();
-					await retry.body?.cancel();
+					const retryOperation = createMCPTimeout(timeout);
+					try {
+						const retry = await fetch(this.config.url, {
+							method: "POST",
+							headers,
+							body: JSON.stringify(body),
+							signal: retryOperation.signal,
+						});
+						await retry.body?.cancel();
+					} finally {
+						retryOperation.clear();
+					}
 					return;
 				}
 			}
 			await resp.body?.cancel();
 		} catch {
-			operation.clear();
 			// Best-effort response delivery — server may have disconnected
+		} finally {
+			operation.clear();
 		}
 	}
 
@@ -441,8 +444,6 @@ export class HttpTransport implements MCPTransport {
 				signal: operation.signal,
 			});
 
-			operation.clear();
-
 			// 202 Accepted is success for notifications
 			if (!response.ok && response.status !== 202) {
 				const text = await response.text();
@@ -465,11 +466,12 @@ export class HttpTransport implements MCPTransport {
 				await response.body?.cancel();
 			}
 		} catch (error) {
-			operation.clear();
 			if (operation.isTimeoutAbort(error)) {
 				throw new Error(`Notify timeout after ${timeout}ms`);
 			}
 			throw error;
+		} finally {
+			operation.clear();
 		}
 	}
 

package/src/mcp/transports/stdio.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "bun:test";
 
-import { resolveStdioSpawnCommand } from "./stdio";
+import { resolveStdioSpawnCommand, StdioTransport } from "./stdio";
 
 describe("resolveStdioSpawnCommand", () => {
 	it("hides Windows executable MCP servers when the host has no console", async () => {
@@ -43,3 +43,53 @@ describe("resolveStdioSpawnCommand", () => {
 		});
 	});
 });
+
+// Regression for #3945: request() awaited stdin.write/flush, so a child that
+// stops draining stdin would park the async fn past the timeout timer and past
+// `return promise`, orphaning the deferred rejection and hanging the caller
+// forever. `sleep` is POSIX-only, so the check is scoped to non-Windows hosts.
+describe.skipIf(process.platform === "win32")("StdioTransport request write stall", () => {
+	it("rejects with the timeout error when the child never drains stdin", async () => {
+		const timeoutMs = 400;
+		const orphaned: Error[] = [];
+		const captureOrphan = (reason: unknown) => {
+			if (reason instanceof Error) orphaned.push(reason);
+		};
+		process.on("unhandledRejection", captureOrphan);
+
+		// `sleep 60` accepts a stdin pipe but never reads it; a 1 MB payload
+		// overruns the OS pipe buffer plus any FileSink JS-side buffering, so
+		// Bun's write() returns a Promise that only settles if the child reads.
+		const transport = new StdioTransport({
+			command: "sleep",
+			args: ["60"],
+			timeout: timeoutMs,
+		});
+
+		try {
+			await transport.connect();
+
+			const bigParam = "x".repeat(1024 * 1024);
+			const started = performance.now();
+			const outcome = await transport.request("tools/call", { name: "noop", arguments: { blob: bigParam } }).then(
+				() => ({ kind: "resolved" as const }),
+				(error: unknown) => ({ kind: "rejected" as const, error }),
+			);
+			const elapsedMs = performance.now() - started;
+
+			expect(outcome.kind).toBe("rejected");
+			if (outcome.kind !== "rejected") return;
+			if (!(outcome.error instanceof Error)) {
+				throw new Error(`expected Error rejection, got ${String(outcome.error)}`);
+			}
+			expect(outcome.error.message).toContain(`Request timeout after ${timeoutMs}ms`);
+			// Generous ceiling: bare rejection latency plus room for slow CI. The
+			// pre-fix behavior was an unbounded hang, not a slightly-late reject.
+			expect(elapsedMs).toBeLessThan(timeoutMs + 1500);
+			expect(orphaned).toEqual([]);
+		} finally {
+			process.off("unhandledRejection", captureOrphan);
+			await transport.close();
+		}
+	}, 8000);
+});