Skip to content

The open-source agent harness - the runtime layer that turns an LLM into a working agent.

fix: Abort timed-out MCP connects so they don’t leak sockets (#766)

Bhavesh Patel01ee9345b338
diff --git a/.changeset/abort-mcp-connect-timeout.md b/.changeset/abort-mcp-connect-timeout.md
new file mode 100644
index 000000000..26c3ccebd
--- /dev/null
+++ b/.changeset/abort-mcp-connect-timeout.md
@@ -0,0 +1,5 @@
+---
+"@truefoundry/trueforge-core": patch
+---
+
+Abort timed-out remote MCP `client.connect()` so the handshake does not leak sockets.
diff --git a/packages/trueforge-core/src/core/mcp/remoteMcpClient.ts b/packages/trueforge-core/src/core/mcp/remoteMcpClient.ts
index 019ef9bce..c4d4612f5 100644
--- a/packages/trueforge-core/src/core/mcp/remoteMcpClient.ts
+++ b/packages/trueforge-core/src/core/mcp/remoteMcpClient.ts
@@ -172,16 +172,23 @@ export async function connectRemoteMcp(params: {
for (const transportType of candidates) {
const transport = createTransport(transportType, url, params.headers, params.sessionId);
const client = new McpClientWithTimeout(params.requestTimeoutMs);
+ // withTimeout races client.connect() and does not abort it, so timed-out connects can leak
+ // sockets until GC. Abort this controller on timeout so the handshake is cancelled.
+ // AbortSignal.timeout cannot be cleared, and the SDK keeps the signal on initialize, so it
+ // would still fire connectTimeoutMs later and cancel the live client.
+ const timeout = new AbortController();
+ const connectOptions = { signal: AbortSignal.any([params.signal, timeout.signal]) };
try {
stampTraceHeaders(params.headers);
await withTimeout(
// Concrete transports use sessionId: string|undefined; Transport uses an optional
// property — exactOptionalPropertyTypes rejects assignability without this cast.
- client.connect(transport as Parameters<Client['connect']>[0], requestOptions),
+ client.connect(transport as Parameters<Client['connect']>[0], connectOptions),
params.connectTimeoutMs,
transportType,
);
} catch (error) {
+ timeout.abort();
await client.close().catch(() => {
/* no-op */
});
diff --git a/packages/trueforge-core/tests/core/mcp/connectRemoteMcp.test.ts b/packages/trueforge-core/tests/core/mcp/connectRemoteMcp.test.ts
index 4a74c4d7e..ae9340241 100644
--- a/packages/trueforge-core/tests/core/mcp/connectRemoteMcp.test.ts
+++ b/packages/trueforge-core/tests/core/mcp/connectRemoteMcp.test.ts
@@ -3,7 +3,11 @@ import { connectRemoteMcp } from '../../../src/core/mcp/remoteMcpClient';
// Records every transport type client.connect() was attempted with, in order.
const mockConnectAttempts: string[] = [];
+const mockConnectSignals: Array<AbortSignal | undefined> = [];
const mockRequestTimeouts: number[] = [];
+let mockCloseCalls = 0;
+// When set, connect hangs until the AbortSignal passed to it is aborted.
+let hangUntilAbort = false;
// Per-test hook: throw to fail a given transport, return to succeed.
let mockConnectImpl: (type: string) => void = () => {
/* no-op */
@@ -18,13 +22,28 @@ jest.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
Client: class {
onclose?: () => void;
onerror?: (e: Error) => void;
- connect(transport: MockTransport): Promise<void> {
+ connect(transport: MockTransport, options?: { signal?: AbortSignal }): Promise<void> {
const type = transport.__type;
mockConnectAttempts.push(type);
+ mockConnectSignals.push(options?.signal);
mockConnectImpl(type);
+ const signal = options?.signal;
+ if (hangUntilAbort && signal) {
+ return new Promise((_, reject) => {
+ const onAbort = (): void => {
+ reject(signal.reason instanceof Error ? signal.reason : new Error('aborted'));
+ };
+ if (signal.aborted) {
+ onAbort();
+ return;
+ }
+ signal.addEventListener('abort', onAbort, { once: true });
+ });
+ }
return Promise.resolve();
}
close(): Promise<void> {
+ mockCloseCalls += 1;
return Promise.resolve();
}
request(_req: unknown, _schema: unknown, options?: { timeout?: number }): Promise<{ tools: [] }> {
@@ -69,7 +88,10 @@ const baseParams = () => ({
describe('connectRemoteMcp transport selection', () => {
beforeEach(() => {
mockConnectAttempts.length = 0;
+ mockConnectSignals.length = 0;
mockRequestTimeouts.length = 0;
+ mockCloseCalls = 0;
+ hangUntilAbort = false;
mockConnectImpl = () => {
/* no-op */
};
@@ -137,4 +159,25 @@ describe('connectRemoteMcp transport selection', () => {
// Session-expiry short-circuits: no fallback to sse with a stale session.
expect(mockConnectAttempts).toEqual(['streamable-http']);
});
+
+ it('aborts a hung connect when connectTimeoutMs elapses without aborting the caller signal', async () => {
+ hangUntilAbort = true;
+ const caller = new AbortController();
+
+ await expect(
+ connectRemoteMcp({ ...baseParams(), signal: caller.signal, connectTimeoutMs: 20 }),
+ ).rejects.toMatchObject({ constructor: McpConnectionError });
+
+ expect(mockConnectAttempts.length).toBeGreaterThan(0);
+ expect(mockConnectSignals.every(signal => signal?.aborted === true)).toBe(true);
+ expect(caller.signal.aborted).toBe(false);
+ expect(mockCloseCalls).toBe(mockConnectAttempts.length);
+ });
+
+ it('does not abort the connect signal after a successful handshake', async () => {
+ await connectRemoteMcp({ ...baseParams(), knownTransportType: 'sse', connectTimeoutMs: 20 });
+ await new Promise(resolve => setTimeout(resolve, 40));
+ expect(mockConnectSignals).toHaveLength(1);
+ expect(mockConnectSignals[0]?.aborted).toBe(false);
+ });
});