The open-source agent harness - the runtime layer that turns an LLM into a working agent.
Align MCP and Code Mode timeouts (#25)
Bhavesh Patele053094cd6bb
diff --git a/packages/harness/src/agent-session/TurnResourceResolver.ts b/packages/harness/src/agent-session/TurnResourceResolver.tsindex 81f7c01d5..730798236 100644--- a/packages/harness/src/agent-session/TurnResourceResolver.ts+++ b/packages/harness/src/agent-session/TurnResourceResolver.ts@@ -67,6 +67,8 @@ export class TurnResourceResolver<* turn. Throw for unknown names. `headers` supports the async resolver form.*/mcp: (name: string) => Promise<{ url: string; headers?: RemoteMcpHeaders }>;+ mcpRequestTimeoutMs: number;+ mcpConnectTimeoutMs: number;/** One sandbox type per runtime. Omit = no sandbox support. */sandboxProvider?: TurnSandboxFactory | undefined;/** Forwarded to RemoteMCP / AgentThread (required by their constructors). */@@ -159,6 +161,8 @@ export class TurnResourceResolver<url,headers: headers ?? {},sessionId: previousTurn?.snapshot.mcp_servers?.[entry.name]?.session_id,+ requestTimeoutMs: this.deps.mcpRequestTimeoutMs,+ connectTimeoutMs: this.deps.mcpConnectTimeoutMs,logger: this.deps.logger,tracing,signal,diff --git a/packages/harness/src/core/mcp/RemoteMCP.ts b/packages/harness/src/core/mcp/RemoteMCP.tsindex e8555eaa0..5a5d8c296 100644--- a/packages/harness/src/core/mcp/RemoteMCP.ts+++ b/packages/harness/src/core/mcp/RemoteMCP.ts@@ -54,7 +54,8 @@ export class RemoteMCP implements ToolSource {private readonly signal: AbortSignal;private readonly logger: Logger;private readonly tracing: AgentTracing;- private readonly connectTimeoutMs?: number | undefined;+ private readonly requestTimeoutMs: number;+ private readonly connectTimeoutMs: number;// Redacted display url for trace spans (derived from url; unused when tracing is a no-op).private readonly traceUrl: string;@@ -76,7 +77,8 @@ export class RemoteMCP implements ToolSource {tracing?: AgentTracing | undefined;sessionId?: string | undefined;transportType?: RemoteMcpTransportType | undefined;- connectTimeoutMs?: number | undefined;+ requestTimeoutMs: number;+ connectTimeoutMs: number;signal: AbortSignal;}) {this.name = params.name;@@ -87,6 +89,7 @@ export class RemoteMCP implements ToolSource {this.signal = params.signal;this.sessionId = params.sessionId;this.resolvedTransportType = params.transportType;+ this.requestTimeoutMs = params.requestTimeoutMs;this.connectTimeoutMs = params.connectTimeoutMs;this.logger = params.logger;this.tracing = params.tracing ?? NOOP_AGENT_TRACING;@@ -236,6 +239,7 @@ export class RemoteMCP implements ToolSource {sessionId: this.sessionId ?? undefined,// Hint from a prior connectknownTransportType: this.resolvedTransportType,+ requestTimeoutMs: this.requestTimeoutMs,connectTimeoutMs: this.connectTimeoutMs,signal: this.signal,onClose: () => {diff --git a/packages/harness/src/core/mcp/remoteMcpClient.ts b/packages/harness/src/core/mcp/remoteMcpClient.tsindex ec43d3260..b146f11b0 100644--- a/packages/harness/src/core/mcp/remoteMcpClient.ts+++ b/packages/harness/src/core/mcp/remoteMcpClient.ts@@ -29,11 +29,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 REQUEST_TIMEOUT_MS = 1_800_000;-export const CONNECT_TIMEOUT_MS = 30_000;-class McpClientWithTimeout extends Client {- constructor() {+ constructor(private readonly requestTimeoutMs: number) {super(CLIENT_INFO, { capabilities: {} });}@@ -41,7 +38,7 @@ class McpClientWithTimeout extends Client {// eslint-disable-next-line @typescript-eslint/no-explicit-any -- MCP SDK request typingoverride request(req: any, schema: any, options?: any): Promise<any> {// eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- MCP SDK request typing- return super.request(req, schema, { ...options, timeout: REQUEST_TIMEOUT_MS });+ return super.request(req, schema, { ...options, timeout: this.requestTimeoutMs });}}@@ -134,7 +131,8 @@ export async function connectRemoteMcp(params: {headers: Record<string, string>;sessionId?: string | undefined;knownTransportType?: RemoteMcpTransportType | undefined;- connectTimeoutMs?: number | undefined;+ requestTimeoutMs: number;+ connectTimeoutMs: number;signal: AbortSignal;onClose?: (() => void) | undefined;onError?: ((error: Error) => void) | undefined;@@ -148,14 +146,14 @@ export async function connectRemoteMcp(params: {for (const transportType of candidates) {const transport = createTransport(transportType, url, params.headers, params.sessionId);- const client = new McpClientWithTimeout();+ const client = new McpClientWithTimeout(params.requestTimeoutMs);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),- params.connectTimeoutMs ?? CONNECT_TIMEOUT_MS,+ params.connectTimeoutMs,transportType,);} catch (error) {diff --git a/packages/harness/src/core/sandbox/Sandbox.ts b/packages/harness/src/core/sandbox/Sandbox.tsindex e55ead96e..58b6a2941 100644--- a/packages/harness/src/core/sandbox/Sandbox.ts+++ b/packages/harness/src/core/sandbox/Sandbox.ts@@ -31,6 +31,10 @@ export interface SandboxInfo {// Downloader/setup scripts can run longer than a normal exec.export const SKILL_DOWNLOAD_TIMEOUT_SECONDS = 180;+// Keeps the sandbox-side NATS wait longer than the host's own MCP deadline, so the host+// surfaces the real MCP error instead of the bridge client giving up first.+const NATS_REQUEST_TIMEOUT_BUFFER_SECONDS = 30;+// Write a script (base64-encoded, never interpolated raw) to a path and run it. Skill mounters reuse it.export function buildWriteAndRunScriptCommand(params: { scriptPath: string; scriptContent: string }): string {const b64 = Buffer.from(params.scriptContent, 'utf-8').toString('base64');@@ -86,6 +90,9 @@ export interface SandboxOptions {* instead. Must be `true` — approvals are always enabled (the kill switch is gone).*/blockDestructiveToolsInCodeMode: true;+ /** Used to derive the Code Mode NATS wait as request + connect. */+ mcpRequestTimeoutMs: number;+ mcpConnectTimeoutMs: number;execExtraEnv?: Readonly<Record<string, string>> | undefined;tracing: AgentTracing;logger: Logger;@@ -136,6 +143,7 @@ function injectMCPClientEnv(params: {mcpServers: Record<string, SandboxMcpServerConfig>;execExtraEnv?: Readonly<Record<string, string>> | undefined;natsBridgeSubjectPrefix?: string | undefined;+ natsRequestTimeoutSeconds: number;}): Record<string, string> {return {...(params.execExtraEnv ?? {}),@@ -147,6 +155,7 @@ function injectMCPClientEnv(params: {...(params.natsBridgeSubjectPrefix && {TFY_NATS_URL: `ws://localhost:${String(DEFAULT_SANDBOX_NATS_WS_PORT)}`,TFY_NATS_SUBJECT_PREFIX: params.natsBridgeSubjectPrefix,+ TFY_NATS_REQUEST_TIMEOUT_SECONDS: String(params.natsRequestTimeoutSeconds),// W3C trace context captured per-exec so each NATS request carries the originating// Sandbox: exec span as parent. Without this, MCP spans dispatched via the bridge// inherit whatever ALS context the NATS callback runs under (stale, shared across execs).@@ -197,6 +206,7 @@ export class Sandbox extends LocalToolMCP {private sandboxInitPromise?: Promise<void> | undefined;private codeExecToolSets: readonly IToolSet[] = [];private readonly fileDownloadEnabled: boolean;+ private readonly natsRequestTimeoutSeconds: number;private readonly execExtraEnv?: Readonly<Record<string, string>> | undefined;private readonly skillMounter?: ISkillMounter | undefined;private cachedSkillsSection?: string | undefined;@@ -222,6 +232,8 @@ export class Sandbox extends LocalToolMCP {this.tenantName = options.execExtraEnv?.['TFY_TENANT_NAME'] ?? '';this.skillMounter = options.skillMounter;this.fileDownloadEnabled = options.fileDownloadEnabled ?? false;+ const mcpBoundTimeoutMs = options.mcpRequestTimeoutMs + options.mcpConnectTimeoutMs;+ this.natsRequestTimeoutSeconds = Math.ceil(mcpBoundTimeoutMs / 1000) + NATS_REQUEST_TIMEOUT_BUFFER_SECONDS;this.execExtraEnv = options.execExtraEnv;// Scripts are internal to Sandbox: the upload paths, env contract, and prompt// text are all hardcoded here, so injecting different content was never a@@ -472,6 +484,7 @@ export class Sandbox extends LocalToolMCP {mcpServers: this.buildMcpServersEnvelope(),execExtraEnv: this.execExtraEnv,natsBridgeSubjectPrefix: bridge?.subjectPrefix,+ natsRequestTimeoutSeconds: this.natsRequestTimeoutSeconds,});const gitAuthEnv =this.resolvedGitCredentialsContent !== nulldiff --git a/packages/harness/src/core/sandbox/scripts/mcp_client.py b/packages/harness/src/core/sandbox/scripts/mcp_client.pyindex b0df23e6f..3a7c01334 100644--- a/packages/harness/src/core/sandbox/scripts/mcp_client.py+++ b/packages/harness/src/core/sandbox/scripts/mcp_client.py@@ -21,7 +21,6 @@ from mcp.types import CallToolResult, TextContent, Toollogger = logging.getLogger(__name__)-_NATS_REQUEST_TIMEOUT_SECONDS = 60_NATS_REQUEST_MAX_ATTEMPTS = 3_NATS_RETRY_BACKOFF_MS = 250@@ -143,6 +142,7 @@ async def _nats_request(subject: str, payload: dict[str, Any]) -> Any:from nats.errors import NoRespondersErrordata = json.dumps(payload).encode()+ request_timeout = float(os.environ["TFY_NATS_REQUEST_TIMEOUT_SECONDS"])# Phase 1: establish a connection, retrying only connect failures.nc = None@@ -170,7 +170,7 @@ async def _nats_request(subject: str, payload: dict[str, Any]) -> Any:msg = await nc.request(subject,data,- timeout=_NATS_REQUEST_TIMEOUT_SECONDS,+ timeout=request_timeout,headers=_nats_trace_headers or None,)except NoRespondersError as e:diff --git a/packages/harness/tests/agent-session/testHelpers.ts b/packages/harness/tests/agent-session/testHelpers.tsindex 047d9d297..9c85ed734 100644--- a/packages/harness/tests/agent-session/testHelpers.ts+++ b/packages/harness/tests/agent-session/testHelpers.ts@@ -91,6 +91,8 @@ export function makeTestResolver<TTurnCustom extends object = Record<string, nevmcp: name => {return Promise.reject(new Error(`unexpected mcp lookup: ${name}`));},+ mcpRequestTimeoutMs: 60_000,+ mcpConnectTimeoutMs: 5_000,logger: makeSilentLogger(),...(options?.sandbox? {diff --git a/packages/harness/tests/agent-session/turnStream.test.ts b/packages/harness/tests/agent-session/turnStream.test.tsindex cd11ccd85..454830a1c 100644--- a/packages/harness/tests/agent-session/turnStream.test.ts+++ b/packages/harness/tests/agent-session/turnStream.test.ts@@ -389,6 +389,8 @@ describe('TurnHandle.stream()', () => {const resolver = new TurnResourceResolver({llm: () => makeMockILLM({ create: jest.fn().mockImplementation(() => emptyLlmStream()) }),mcp: () => Promise.resolve({ url: 'http://localhost' }),+ mcpRequestTimeoutMs: 60_000,+ mcpConnectTimeoutMs: 5_000,sandboxProvider: () => Promise.resolve(sandbox),logger,});@@ -427,6 +429,8 @@ describe('TurnResourceResolver caches', () => {headers: {},logger,tracing: this.createTracing(),+ requestTimeoutMs: 60_000,+ connectTimeoutMs: 5_000,signal: new AbortController().signal,});};@@ -439,6 +443,8 @@ describe('TurnResourceResolver caches', () => {})({llm: () => makeMockILLM(),mcp: () => Promise.resolve({ url: 'http://example.invalid' }),+ mcpRequestTimeoutMs: 60_000,+ mcpConnectTimeoutMs: 5_000,logger,});await resolver.resolveTwice();@@ -453,6 +459,8 @@ describe('TurnResourceResolver caches', () => {const resolver = new TurnResourceResolver({llm: () => makeMockILLM({ create: jest.fn().mockImplementation(() => emptyLlmStream()) }),mcp: () => Promise.resolve({ url: 'http://localhost' }),+ mcpRequestTimeoutMs: 60_000,+ mcpConnectTimeoutMs: 5_000,sandboxProvider: () => {sandboxCreates += 1;return Promise.resolve(sandbox);diff --git a/packages/harness/tests/core/harnessMocks.ts b/packages/harness/tests/core/harnessMocks.tsindex 6d307915e..3dd447692 100644--- a/packages/harness/tests/core/harnessMocks.ts+++ b/packages/harness/tests/core/harnessMocks.ts@@ -69,6 +69,8 @@ export function makeStubPublicSandbox(tenantName = 'test-tenant'): Sandbox {return new Sandbox({provider,blockDestructiveToolsInCodeMode: true,+ mcpRequestTimeoutMs: 60_000,+ mcpConnectTimeoutMs: 5_000,execExtraEnv: { TFY_TENANT_NAME: tenantName },logger: makeSilentLogger(),tracing: NOOP_AGENT_TRACING,diff --git a/packages/harness/tests/core/mcp/connectRemoteMcp.test.ts b/packages/harness/tests/core/mcp/connectRemoteMcp.test.tsindex 1379c5805..4a74c4d7e 100644--- a/packages/harness/tests/core/mcp/connectRemoteMcp.test.ts+++ b/packages/harness/tests/core/mcp/connectRemoteMcp.test.ts@@ -3,6 +3,7 @@ import { connectRemoteMcp } from '../../../src/core/mcp/remoteMcpClient';// Records every transport type client.connect() was attempted with, in order.const mockConnectAttempts: string[] = [];+const mockRequestTimeouts: number[] = [];// Per-test hook: throw to fail a given transport, return to succeed.let mockConnectImpl: (type: string) => void = () => {/* no-op */@@ -26,9 +27,13 @@ jest.mock('@modelcontextprotocol/sdk/client/index.js', () => ({close(): Promise<void> {return Promise.resolve();}- listTools(): Promise<{ tools: [] }> {+ request(_req: unknown, _schema: unknown, options?: { timeout?: number }): Promise<{ tools: [] }> {+ if (options?.timeout !== undefined) mockRequestTimeouts.push(options.timeout);return Promise.resolve({ tools: [] });}+ listTools(_params?: unknown, options?: { timeout?: number }): Promise<{ tools: [] }> {+ return this.request({}, {}, options);+ }callTool(): Promise<{ content: [] }> {return Promise.resolve({ content: [] });}@@ -56,12 +61,15 @@ jest.mock('@modelcontextprotocol/sdk/client/sse.js', () => ({const baseParams = () => ({url: 'https://mcp.example.com/mcp',headers: {},+ requestTimeoutMs: 60_000,+ connectTimeoutMs: 5_000,signal: new AbortController().signal,});describe('connectRemoteMcp transport selection', () => {beforeEach(() => {mockConnectAttempts.length = 0;+ mockRequestTimeouts.length = 0;mockConnectImpl = () => {/* no-op */};@@ -87,6 +95,14 @@ describe('connectRemoteMcp transport selection', () => {expect(mockConnectAttempts).toEqual(['sse']);});+ it('uses the configured request timeout', async () => {+ const conn = await connectRemoteMcp({ ...baseParams(), requestTimeoutMs: 1234 });++ await conn.listTools();++ expect(mockRequestTimeouts).toEqual([1234]);+ });+it('probes in order when there is no hint', async () => {mockConnectImpl = type => {if (type === 'streamable-http') throw new Error('no streamable-http');diff --git a/packages/harness/tests/core/mcp/remoteMcpServer.test.ts b/packages/harness/tests/core/mcp/remoteMcpServer.test.tsindex 5625b7326..c41b81c24 100644--- a/packages/harness/tests/core/mcp/remoteMcpServer.test.ts+++ b/packages/harness/tests/core/mcp/remoteMcpServer.test.ts@@ -108,6 +108,8 @@ function makeServer(params: {tracing: NOOP_AGENT_TRACING,sessionId: params.sessionId,transportType: params.transportType,+ requestTimeoutMs: 60_000,+ connectTimeoutMs: 5_000,signal: new AbortController().signal,});return new ToolSet({diff --git a/packages/harness/tests/core/sandbox/sandboxBridgeTimeout.test.ts b/packages/harness/tests/core/sandbox/sandboxBridgeTimeout.test.tsnew file mode 100644index 000000000..2bf30ba86--- /dev/null+++ b/packages/harness/tests/core/sandbox/sandboxBridgeTimeout.test.ts@@ -0,0 +1,92 @@+jest.mock('../../../src/core/sandbox/SandboxNatsBridge', () => {+ const actual = jest.requireActual('../../../src/core/sandbox/SandboxNatsBridge');+ return {+ ...actual,+ SandboxNatsBridge: { connect: jest.fn() },+ };+});++import type { ExecResult, SandboxExecParams, SandboxProvider } from '../../../src/core/sandbox/provider/Provider';+import { Sandbox, SANDBOX_EXEC_TOOL_NAME } from '../../../src/core/sandbox/Sandbox';+import { SandboxNatsBridge } from '../../../src/core/sandbox/SandboxNatsBridge';+import { NOOP_AGENT_TRACING } from '../../../src/core/tracing/NoopAgentTracing';+import { makeMockIMCPServer, makeSilentLogger } from '../harnessMocks';++const mockBridgeConnect = SandboxNatsBridge.connect as jest.Mock;+const AGENT_COMMAND = 'echo hello';++function makeSandbox(options: { mcpRequestTimeoutMs: number; mcpConnectTimeoutMs: number }): {+ sandbox: Sandbox;+ execCalls: SandboxExecParams[];+} {+ const execCalls: SandboxExecParams[] = [];+ const provider: SandboxProvider = {+ createSandbox: () => Promise.resolve({ sandboxId: 'test-tenant.sandbox-1' }),+ exec: (params): Promise<ExecResult> => {+ execCalls.push(params);+ return Promise.resolve({ success: true, response: { exitCode: 0, result: '' } });+ },+ getAdditionalInstructions: () => undefined,+ getToolResultDumpDir: () => '/tmp/tool-results',+ getGitCredentialsPath: () => '/tmp/.git-credentials',+ downloadFile: jest.fn(),+ uploadFile: jest.fn(),+ getNatsBridgeUrl: () => Promise.resolve('ws://localhost:4444'),+ };+ return {+ sandbox: new Sandbox({+ provider,+ blockDestructiveToolsInCodeMode: true,+ ...options,+ execExtraEnv: { TFY_TENANT_NAME: 'test-tenant' },+ logger: makeSilentLogger(),+ tracing: NOOP_AGENT_TRACING,+ }),+ execCalls,+ };+}++async function execAgentCommand(sandbox: Sandbox, execCalls: SandboxExecParams[]): Promise<SandboxExecParams> {+ await sandbox.callTool({+ name: SANDBOX_EXEC_TOOL_NAME,+ arguments: { intent: 'Run command', command: AGENT_COMMAND },+ });+ const call = execCalls.find(item => item.command === AGENT_COMMAND);+ if (!call) throw new Error('Expected agent command');+ return call;+}++describe('Code Mode timeouts', () => {+ beforeEach(() => {+ mockBridgeConnect.mockReset();+ mockBridgeConnect.mockResolvedValue({+ subjectPrefix: 'sandbox.bridge.test',+ whenClosed: () => new Promise<void>(() => {}),+ close: () => Promise.resolve(),+ });+ });++ it('derives the NATS wait from MCP request + connect plus a buffer', async () => {+ const { sandbox, execCalls } = makeSandbox({+ mcpRequestTimeoutMs: 90_000,+ mcpConnectTimeoutMs: 30_000,+ });+ sandbox.configureCodeMode([makeMockIMCPServer({ name: 'github', preload: true })]);++ const call = await execAgentCommand(sandbox, execCalls);++ expect(call.env?.['TFY_NATS_REQUEST_TIMEOUT_SECONDS']).toBe('150');+ });++ it('leaves the exec timeout to the provider default', async () => {+ const { sandbox, execCalls } = makeSandbox({+ mcpRequestTimeoutMs: 90_000,+ mcpConnectTimeoutMs: 30_000,+ });++ const call = await execAgentCommand(sandbox, execCalls);++ expect(call.env?.['TFY_NATS_REQUEST_TIMEOUT_SECONDS']).toBeUndefined();+ expect(call.timeoutSeconds).toBeUndefined();+ });+});diff --git a/packages/server/src/apis/mcpServers.ts b/packages/server/src/apis/mcpServers.tsindex 192601592..1835f3392 100644--- a/packages/server/src/apis/mcpServers.ts+++ b/packages/server/src/apis/mcpServers.ts@@ -174,6 +174,8 @@ export function createMcpServersRouter(deps: McpServersRouterDeps) {name,url: connection.url,headers: connection.headers,+ requestTimeoutMs: configuration.MCP_REQUEST_TIMEOUT_MS,+ connectTimeoutMs: configuration.MCP_CONNECT_TIMEOUT_MS,logger: deps.logger,signal: c.req.raw.signal,});diff --git a/packages/server/src/apis/turns.ts b/packages/server/src/apis/turns.tsindex f2abdce92..f9c780702 100644--- a/packages/server/src/apis/turns.ts+++ b/packages/server/src/apis/turns.ts@@ -111,6 +111,8 @@ function createTurnResolver(deps: {tokenStore,clientName: configuration.OAUTH_CLIENT_NAME,}),+ mcpRequestTimeoutMs: configuration.MCP_REQUEST_TIMEOUT_MS,+ mcpConnectTimeoutMs: configuration.MCP_CONNECT_TIMEOUT_MS,sandboxProvider: async ({ spec, existingSandboxId, tracing }) => {const provider = await resolveSandboxProvider({tenant_id: TENANT_ID,diff --git a/packages/server/src/config.ts b/packages/server/src/config.tsindex fc8fe767d..74dd79525 100644--- a/packages/server/src/config.ts+++ b/packages/server/src/config.ts@@ -161,6 +161,10 @@ export interface ServerConfiguration {* Env: `FRONTEND_DIR`, defaults to `../frontend/dist` relative to the working directory.*/FRONTEND_DIR: string;+ /** Max milliseconds for one MCP request. Env: `MCP_REQUEST_TIMEOUT_MS`. Default 4 minutes. */+ 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;/*** Public base URL of this server used as the origin of the MCP OAuth callback* (`{PUBLIC_BASE_URL}/api/v1/mcp-servers/oauth/callback`). Not trimmed.@@ -268,6 +272,17 @@ const singleBinary = parseBoolean({defaultValue: true,});+const mcpRequestTimeoutMs = parsePositiveInt({+ envKey: 'MCP_REQUEST_TIMEOUT_MS',+ raw: getEnv('MCP_REQUEST_TIMEOUT_MS'),+ defaultValue: 4 * 60 * 1000,+});+const mcpConnectTimeoutMs = parsePositiveInt({+ envKey: 'MCP_CONNECT_TIMEOUT_MS',+ raw: getEnv('MCP_CONNECT_TIMEOUT_MS'),+ defaultValue: 30 * 1000,+});+const configuration: ServerConfiguration = {PORT: parsePort(getEnv('PORT')),EXECUTOR_ID: resolveExecutorId(singleBinary),@@ -288,6 +303,8 @@ const configuration: ServerConfiguration = {return override === undefined || override === '' ? undefined : path.resolve(override);})(),FRONTEND_DIR: path.resolve(getEnv('FRONTEND_DIR', { defaultValue: DEFAULT_FRONTEND_DIR }) ?? DEFAULT_FRONTEND_DIR),+ MCP_REQUEST_TIMEOUT_MS: mcpRequestTimeoutMs,+ MCP_CONNECT_TIMEOUT_MS: mcpConnectTimeoutMs,PUBLIC_BASE_URL: requireNonEmptyEnv('PUBLIC_BASE_URL'),OAUTH_CLIENT_NAME: getEnv('OAUTH_CLIENT_NAME', { defaultValue: 'truefoundry-harness' }) ?? 'truefoundry-harness',SANDBOX_FILE_MAX_BYTES_FOR_DOWNLOAD: parsePositiveInt({diff --git a/packages/server/src/runtime/sessionResources.ts b/packages/server/src/runtime/sessionResources.tsindex 01f22d83e..cc3972e77 100644--- a/packages/server/src/runtime/sessionResources.ts+++ b/packages/server/src/runtime/sessionResources.ts@@ -237,6 +237,8 @@ export function buildTurnSandbox(input: {existingSandboxId: input.existingSandboxId,fileDownloadEnabled: input.fileDownloadEnabled,blockDestructiveToolsInCodeMode: true,+ mcpRequestTimeoutMs: configuration.MCP_REQUEST_TIMEOUT_MS,+ mcpConnectTimeoutMs: configuration.MCP_CONNECT_TIMEOUT_MS,// Sandbox reads its tenant from TFY_TENANT_NAME for the ownership check// against provider-created sandbox ids (`<tenant>.<uuid>`).execExtraEnv: { TFY_TENANT_NAME: input.tenantName },