Skip to content

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.md
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.example
index 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.ts
index 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.ts
index 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.ts
index 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({