The open-source agent harness - the runtime layer that turns an LLM into a working agent.
fix: cap remote MCP HTTP bodies to prevent OOM (#769)
Bhavesh Patelc83145ae55eb
diff --git a/.changeset/mcp-max-response-bytes.md b/.changeset/mcp-max-response-bytes.mdnew file mode 100644index 000000000..0dc05aab9--- /dev/null+++ b/.changeset/mcp-max-response-bytes.md@@ -0,0 +1,6 @@+---+"@truefoundry/trueforge-core": patch+"@truefoundry/trueforge": patch+---++Abort remote MCP HTTP response bodies over 50MB (`MCP_TOOL_CALL_MAX_RESPONSE_BYTES`) so oversized tool results cannot OOM the process.diff --git a/packages/trueforge-core/src/agent-session/TurnResourceResolver.ts b/packages/trueforge-core/src/agent-session/TurnResourceResolver.tsindex 8e6edaa78..9bcfed4a3 100644--- a/packages/trueforge-core/src/agent-session/TurnResourceResolver.ts+++ b/packages/trueforge-core/src/agent-session/TurnResourceResolver.ts@@ -76,6 +76,7 @@ export class TurnResourceResolver<mcp: (name: string) => Promise<{ url: string; headers?: RemoteMcpHeaders }>;mcpRequestTimeoutMs: number;mcpConnectTimeoutMs: number;+ mcpMaxResponseBytes?: number | undefined;/** One sandbox type per runtime. Omit = no sandbox support. */sandboxProvider?: TurnSandboxFactory | undefined;/**@@ -191,6 +192,9 @@ export class TurnResourceResolver<sessionId: previousTurn?.snapshot.mcp_servers?.[entry.name]?.session_id,requestTimeoutMs: this.deps.mcpRequestTimeoutMs,connectTimeoutMs: this.deps.mcpConnectTimeoutMs,+ ...(this.deps.mcpMaxResponseBytes !== undefined+ ? { maxResponseBytes: this.deps.mcpMaxResponseBytes }+ : {}),logger: this.deps.logger,tracing,signal,diff --git a/packages/trueforge-core/src/core/index.ts b/packages/trueforge-core/src/core/index.tsindex 7b150ba91..76538942f 100644--- a/packages/trueforge-core/src/core/index.ts+++ b/packages/trueforge-core/src/core/index.ts@@ -76,6 +76,7 @@ export type { ToolDefinition } from './mcp/LocalToolMCP';// live in the harness-internal `remoteMcpClient` module.export { RemoteMCP } from './mcp/RemoteMCP';export type { RemoteMcpHeaders, ResolveHeadersResult } from './mcp/RemoteMCP';+export { DEFAULT_MAX_MCP_RESPONSE_BYTES } from './mcp/remoteMcpClient';export type { RemoteMcpConnection, RemoteMcpTransportType } from './mcp/remoteMcpClient';export type { ToolSelectorConfig } from './mcp/ToolSelectorPolicy';export {diff --git a/packages/trueforge-core/src/core/mcp/RemoteMCP.ts b/packages/trueforge-core/src/core/mcp/RemoteMCP.tsindex ef4a7c312..c9a82bdc8 100644--- a/packages/trueforge-core/src/core/mcp/RemoteMCP.ts+++ b/packages/trueforge-core/src/core/mcp/RemoteMCP.ts@@ -17,6 +17,7 @@ import {import { paginateWithCursorGuard } from './pagination';import {connectRemoteMcp,+ DEFAULT_MAX_MCP_RESPONSE_BYTES,isSessionExpiredError,type RemoteMcpConnection,type RemoteMcpTransportType,@@ -57,6 +58,7 @@ export class RemoteMCP implements ToolSource {private readonly tracing: AgentTracing;private readonly requestTimeoutMs: number;private readonly connectTimeoutMs: number;+ private readonly maxResponseBytes: number;// Redacted display url for trace spans (derived from url; unused when tracing is a no-op).private readonly traceUrl: string;@@ -80,6 +82,7 @@ export class RemoteMCP implements ToolSource {transportType?: RemoteMcpTransportType | undefined;requestTimeoutMs: number;connectTimeoutMs: number;+ maxResponseBytes?: number | undefined;signal: AbortSignal;}) {this.name = params.name;@@ -92,6 +95,7 @@ export class RemoteMCP implements ToolSource {this.resolvedTransportType = params.transportType;this.requestTimeoutMs = params.requestTimeoutMs;this.connectTimeoutMs = params.connectTimeoutMs;+ this.maxResponseBytes = params.maxResponseBytes ?? DEFAULT_MAX_MCP_RESPONSE_BYTES;this.logger = params.logger;this.tracing = params.tracing ?? NOOP_AGENT_TRACING;this.traceUrl = redactUrlForTrace(params.url);@@ -252,6 +256,7 @@ export class RemoteMCP implements ToolSource {knownTransportType: this.resolvedTransportType,requestTimeoutMs: this.requestTimeoutMs,connectTimeoutMs: this.connectTimeoutMs,+ maxResponseBytes: this.maxResponseBytes,signal: this.signal,onClose: () => {this.isConnected = false;diff --git a/packages/trueforge-core/src/core/mcp/remoteMcpClient.ts b/packages/trueforge-core/src/core/mcp/remoteMcpClient.tsindex c4d4612f5..9298fb441 100644--- a/packages/trueforge-core/src/core/mcp/remoteMcpClient.ts+++ b/packages/trueforge-core/src/core/mcp/remoteMcpClient.ts@@ -31,6 +31,8 @@ type McpTransport = StreamableHTTPClientTransport | SSEClientTransport;const CLIENT_INFO = { name: 'tfy-agent-mcp-client', version: '1.0.0' } as const;const TRANSPORT_PROBE_ORDER: RemoteMcpTransportType[] = ['streamable-http', 'sse'];+export const DEFAULT_MAX_MCP_RESPONSE_BYTES = 50 * 1024 * 1024;+// MCP SSE/streamable-HTTP keeps a long-lived response open that is often idle between tool calls.// Node fetch (undici) defaults bodyTimeout to 300s of silence, then kills the stream with// `Body Timeout Error` — we reconnect and the ~5m cycle repeats in logs. 30m matches the@@ -40,6 +42,35 @@ const mcpHttpAgent = new Agent({ bodyTimeout: MCP_BODY_TIMEOUT_MS });const mcpFetch: FetchLike = (url, init) =>undiciFetch(typeof url === 'string' ? url : url.href, { ...(init as object), dispatcher: mcpHttpAgent });+/** GET SSE is long-lived and uncapped; every other body aborts at `maxBytes`. */+export function withMaxResponseBytes(fetchFn: FetchLike, maxBytes: number): FetchLike {+ return async (url, init) => {+ const response = await fetchFn(url, init);+ const isGetSse =+ (init?.method ?? 'GET').toUpperCase() === 'GET' &&+ (response.headers.get('content-type') ?? '').toLowerCase().includes('text/event-stream');+ if (isGetSse || !response.body) {+ return response;+ }+ let seen = 0;+ return new Response(+ response.body.pipeThrough(+ new TransformStream<Uint8Array, Uint8Array>({+ transform(chunk, controller) {+ seen += chunk.byteLength;+ if (seen > maxBytes) {+ controller.error(new Error(`MCP response exceeded max ${String(maxBytes)} bytes`));+ return;+ }+ controller.enqueue(chunk);+ },+ }),+ ),+ { status: response.status, statusText: response.statusText, headers: response.headers },+ );+ };+}+class McpClientWithTimeout extends Client {constructor(private readonly requestTimeoutMs: number) {super(CLIENT_INFO, { capabilities: {} });@@ -57,18 +88,19 @@ function createTransport(type: RemoteMcpTransportType,url: URL,headers: Record<string, string>,+ fetchFn: FetchLike,sessionId?: string,): McpTransport {const requestInit = { headers };if (type === 'streamable-http') {return new StreamableHTTPClientTransport(url, {requestInit,- fetch: mcpFetch,+ fetch: fetchFn,...(sessionId !== undefined ? { sessionId } : {}),});}// eslint-disable-next-line @typescript-eslint/no-deprecated -- dual-transport probe; see TRANSPORT_PROBE_ORDER- return new SSEClientTransport(url, { requestInit, fetch: mcpFetch });+ return new SSEClientTransport(url, { requestInit, fetch: fetchFn });}export function isSessionExpiredError(error: unknown): boolean {@@ -158,19 +190,21 @@ export async function connectRemoteMcp(params: {knownTransportType?: RemoteMcpTransportType | undefined;requestTimeoutMs: number;connectTimeoutMs: number;+ maxResponseBytes?: number | undefined;signal: AbortSignal;onClose?: (() => void) | undefined;onError?: ((error: Error) => void) | undefined;}): Promise<RemoteMcpConnection> {const url = new URL(params.url);const requestOptions = { signal: params.signal };+ const fetchFn = withMaxResponseBytes(mcpFetch, params.maxResponseBytes ?? DEFAULT_MAX_MCP_RESPONSE_BYTES);const candidates = params.knownTransportType? [params.knownTransportType, ...TRANSPORT_PROBE_ORDER.filter(t => t !== params.knownTransportType)]: TRANSPORT_PROBE_ORDER;const failures: { transport: RemoteMcpTransportType; error: string }[] = [];for (const transportType of candidates) {- const transport = createTransport(transportType, url, params.headers, params.sessionId);+ const transport = createTransport(transportType, url, params.headers, fetchFn, 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.diff --git a/packages/trueforge-core/tests/core/mcp/mcpResponseSizeLimit.test.ts b/packages/trueforge-core/tests/core/mcp/mcpResponseSizeLimit.test.tsnew file mode 100644index 000000000..77b328aa4--- /dev/null+++ b/packages/trueforge-core/tests/core/mcp/mcpResponseSizeLimit.test.ts@@ -0,0 +1,36 @@+import { withMaxResponseBytes } from '../../../src/core/mcp/remoteMcpClient';++function streamOf(bytes: Uint8Array): ReadableStream<Uint8Array> {+ return new ReadableStream({+ start(controller) {+ controller.enqueue(bytes);+ controller.close();+ },+ });+}++describe('withMaxResponseBytes', () => {+ it('aborts when the body exceeds max', async () => {+ const fetchFn = withMaxResponseBytes(async () => new Response(streamOf(new Uint8Array(80))), 50);+ const response = await fetchFn('https://mcp.example.com', { method: 'POST' });++ await expect(response.arrayBuffer()).rejects.toThrow(/exceeded max 50 bytes/);+ });++ it('passes through a body at or under the max', async () => {+ const fetchFn = withMaxResponseBytes(async () => new Response(streamOf(new Uint8Array(50))), 50);+ const response = await fetchFn('https://mcp.example.com', { method: 'POST' });++ expect((await response.arrayBuffer()).byteLength).toBe(50);+ });++ it('does not cap GET text/event-stream bodies', async () => {+ const fetchFn = withMaxResponseBytes(+ async () => new Response(streamOf(new Uint8Array(80)), { headers: { 'content-type': 'text/event-stream' } }),+ 50,+ );+ const response = await fetchFn('https://mcp.example.com', { method: 'GET' });++ expect((await response.arrayBuffer()).byteLength).toBe(80);+ });+});diff --git a/packages/trueforge/.env.example b/packages/trueforge/.env.exampleindex bd905fcf2..582176c3c 100644--- a/packages/trueforge/.env.example+++ b/packages/trueforge/.env.example@@ -110,6 +110,8 @@ TRUEFORGE_API_KEY=placeholder-value-please-generate-your-own# MCP_REQUEST_TIMEOUT_MS=240000## Max ms for an MCP transport connection. Default 30000.# MCP_CONNECT_TIMEOUT_MS=30000+## Max bytes for one remote MCP tool-call HTTP response body (JSON / POST SSE). Default 50 MB.+# MCP_TOOL_CALL_MAX_RESPONSE_BYTES=52428800## ---------------------------------------------------------------------------## Sandbox process knobs.diff --git a/packages/trueforge/src/apis/mcpServers.ts b/packages/trueforge/src/apis/mcpServers.tsindex d2a612746..5b8960620 100644--- a/packages/trueforge/src/apis/mcpServers.ts+++ b/packages/trueforge/src/apis/mcpServers.ts@@ -418,6 +418,7 @@ export function createMcpServersRouter<TTransaction>(deps: McpServersRouterDeps<headers: connection.headers,requestTimeoutMs: configuration.MCP_REQUEST_TIMEOUT_MS,connectTimeoutMs: configuration.MCP_CONNECT_TIMEOUT_MS,+ maxResponseBytes: configuration.MCP_TOOL_CALL_MAX_RESPONSE_BYTES,logger: deps.logger,signal: c.req.raw.signal,});diff --git a/packages/trueforge/src/apis/turns.ts b/packages/trueforge/src/apis/turns.tsindex a5068b69b..99f9456ee 100644--- a/packages/trueforge/src/apis/turns.ts+++ b/packages/trueforge/src/apis/turns.ts@@ -218,6 +218,7 @@ function createTurnResolver(deps: {},mcpRequestTimeoutMs: configuration.MCP_REQUEST_TIMEOUT_MS,mcpConnectTimeoutMs: configuration.MCP_CONNECT_TIMEOUT_MS,+ mcpMaxResponseBytes: configuration.MCP_TOOL_CALL_MAX_RESPONSE_BYTES,sandboxProvider: async ({ spec, existingSandboxId, tracing }) => {const provider = await resolveSandboxProvider({tenant_id,diff --git a/packages/trueforge/src/config.ts b/packages/trueforge/src/config.tsindex 18782286c..fcda35539 100644--- a/packages/trueforge/src/config.ts+++ b/packages/trueforge/src/config.ts@@ -562,6 +562,8 @@ export interface SharedServerConfiguration {MCP_REQUEST_TIMEOUT_MS: number;/** Max milliseconds for an MCP transport connection. Env: `MCP_CONNECT_TIMEOUT_MS`. Default 30 seconds. */MCP_CONNECT_TIMEOUT_MS: number;+ /** Max bytes for one remote MCP tool-call HTTP response body (not GET SSE). Env: `MCP_TOOL_CALL_MAX_RESPONSE_BYTES`. Default 50 MB. */+ MCP_TOOL_CALL_MAX_RESPONSE_BYTES: number;/*** Client name used for Dynamic Client Registration (DCR) of MCP servers.* This is the client name shown on authorization-server consent screens.@@ -849,6 +851,11 @@ const shared: SharedServerConfiguration = {raw: getEnv('MCP_CONNECT_TIMEOUT_MS'),defaultValue: 30 * 1000,}),+ MCP_TOOL_CALL_MAX_RESPONSE_BYTES: parsePositiveInt({+ envKey: 'MCP_TOOL_CALL_MAX_RESPONSE_BYTES',+ raw: getEnv('MCP_TOOL_CALL_MAX_RESPONSE_BYTES'),+ defaultValue: 50 * 1024 * 1024,+ }),MCP_DCR_OAUTH_CLIENT_NAME:getEnv('MCP_DCR_OAUTH_CLIENT_NAME', { defaultValue: 'truefoundry-harness' }) ?? 'truefoundry-harness',SANDBOX_FILE_MAX_BYTES_FOR_DOWNLOAD: parsePositiveInt({