Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🪔 feat: Expose Bounded Attached Bash Timeouts (#15776)
Danny Avila9f311b810dd6
diff --git a/api/server/services/ToolService.js b/api/server/services/ToolService.jsindex 34b762e997..35253aa595 100644--- a/api/server/services/ToolService.js+++ b/api/server/services/ToolService.js@@ -47,6 +47,7 @@ const {isFatalAgentInitializationError,codeExecutionAuthHeaders,createAttachedWorkspaceBashTool,+ resolveAttachedWorkspaceCommandTimeoutMax,createGitIdentityProgrammaticBashTool,resolveCodeExecutionContext,resolveCodeExecutionWorkspaceContext,@@ -2234,6 +2235,9 @@ async function loadToolsForExecution({baseUrl: codeExecutionContext.baseUrl,workspaceId: codeExecutionContext.codeWorkspace.workspaceId,gitIdentity: agent?.git_identity,+ maxTimeoutMs: resolveAttachedWorkspaceCommandTimeoutMax(+ codeExecutionContext.codeEnvironmentConfigSchema,+ ),}): createBashExecutionTool({authHeaders,diff --git a/api/server/services/__tests__/ToolService.spec.js b/api/server/services/__tests__/ToolService.spec.jsindex 5235a65441..21d5540790 100644--- a/api/server/services/__tests__/ToolService.spec.js+++ b/api/server/services/__tests__/ToolService.spec.js@@ -2750,6 +2750,7 @@ describe('ToolService - Action Capability Gating', () => {environmentType: 'attached',environmentId: 'personal-machine',bridgeWorkerId: 'worker-abc',+ codeEnvironmentConfigSchema: { limits: { maxCommandTimeoutMs: 120000 } },});const toolRegistry = new Map([[AgentConstants.BASH_TOOL, { name: AgentConstants.BASH_TOOL }],@@ -2775,6 +2776,7 @@ describe('ToolService - Action Capability Gating', () => {baseUrl: 'http://attached-code.test/v1',workspaceId: 'project-a',gitIdentity: { name: 'LibreChat Agent', email: '[email protected]' },+ maxTimeoutMs: 120000,});expect(mockResolveCodeExecutionWorkspaceContext).toHaveBeenCalledWith(expect.objectContaining({ requestedSelections: req.body.codeWorkspaces }),diff --git a/librechat.example.yaml b/librechat.example.yamlindex b502457ac0..d91e8e2176 100644--- a/librechat.example.yaml+++ b/librechat.example.yaml@@ -630,6 +630,10 @@ endpoints:# owner: deployment# # Optionally expose only these bounded preferences to environment owners.# configSchema:+ # limits:+ # # Maximum Bash execution budget the model may request per call.+ # # Omit to preserve the historical 30-second limit. Hard cap: 300000.+ # maxCommandTimeoutMs: 120000# permissions:# fileWrite:# allowed: [allow, ask, deny]diff --git a/packages/api/src/agents/__tests__/initialize.test.ts b/packages/api/src/agents/__tests__/initialize.test.tsindex 1feffdf41b..1ca43f52aa 100644--- a/packages/api/src/agents/__tests__/initialize.test.ts+++ b/packages/api/src/agents/__tests__/initialize.test.ts@@ -2520,6 +2520,9 @@ describe('initializeAgent — execute_code capability expansion', () => {baseURL: 'https://code.example.com/v1',owner: 'deployment',workerId: 'worker-a',+ configSchema: {+ limits: { maxCommandTimeoutMs: 120_000 },+ },},],},@@ -2543,10 +2546,13 @@ describe('initializeAgent — execute_code capability expansion', () => {environmentId: 'personal-vm',environmentType: 'attached',bridgeWorkerId: 'worker-a',+ codeEnvironmentConfigSchema: {+ limits: { maxCommandTimeoutMs: 120_000 },+ },codeWorkspace: {environmentId: 'personal-vm',workspaceId: 'project-a',- operations: ['read_file', 'list_files'],+ operations: ['read_file', 'list_files', 'execute_command'],},};if (protectedEdit) codeExecutionContext.codeWorkspace!.operations.push('edit_file');@@ -2576,9 +2582,15 @@ describe('initializeAgent — execute_code capability expansion', () => {expect(result.codeExecutionContext).toBe(codeExecutionContext);expect(result.toolDefinitions?.map(({ name }) => name).sort()).toEqual([+ 'bash_tool','list_workspace_files','read_file',]);+ const bashTool = result.toolDefinitions?.find(({ name }) => name === 'bash_tool');+ expect(+ (bashTool?.parameters as { properties?: { timeoutMs?: { maximum?: number } } })?.properties+ ?.timeoutMs?.maximum,+ ).toBe(120_000);},);diff --git a/packages/api/src/agents/initialize.ts b/packages/api/src/agents/initialize.tsindex 5254a6b88f..5b2dd0f0ac 100644--- a/packages/api/src/agents/initialize.ts+++ b/packages/api/src/agents/initialize.ts@@ -103,6 +103,7 @@ import {import { extractAgentContent, extractSkillContent } from '../protection/adapters/submissions';import { createConfiguredContentInspector, inspectContent } from '../protection/runtime';import { assertAgentAttachmentLimits, isModelBoundAttachmentFile } from './attachments';+import { resolveAttachedWorkspaceCommandTimeoutMax } from '~/code/command';import { assertModelBoundContent } from '../middleware/modelBoundContent';import { registerMemoryTools, memoryToolUsageGuard } from './memory';import { applyIntentLabels, sanitizeIntentLabels } from './intent';@@ -1670,6 +1671,12 @@ export async function initializeAgent(trustedCodeExecutionContext.environmentType === 'attached'? new Set(trustedCodeExecutionContext.codeWorkspace?.operations ?? []): undefined;+ const attachedWorkspaceCommandTimeoutMaxMs =+ trustedCodeExecutionContext.environmentType === 'attached'+ ? resolveAttachedWorkspaceCommandTimeoutMax(+ trustedCodeExecutionContext.codeEnvironmentConfigSchema,+ )+ : undefined;if (attachedWorkspaceOperations &&!attachedWorkspaceOperations.has('preview_edit') &&@@ -1805,6 +1812,7 @@ export async function initializeAgent(statefulSessions: effectiveStatefulSessions,workspaceTools: attachedWorkspaceTools,workspaceOperations: attachedWorkspaceOperations,+ workspaceCommandTimeoutMaxMs: attachedWorkspaceCommandTimeoutMaxMs,});toolDefinitions = codeExecResult.toolDefinitions;recordCapabilityToolNames(AgentCapabilities.execute_code, codeExecResult.toolNames);@@ -1855,6 +1863,7 @@ export async function initializeAgent(enableToolOutputReferences: effectiveCodeEnvAvailable,workspaceTools: attachedWorkspaceTools,workspaceOperations: attachedWorkspaceOperations,+ workspaceCommandTimeoutMaxMs: attachedWorkspaceCommandTimeoutMaxMs,});toolDefinitions = skillReadResult.toolDefinitions;recordCapabilityToolNames(AgentCapabilities.skills, skillReadResult.toolNames);diff --git a/packages/api/src/agents/skills.ts b/packages/api/src/agents/skills.tsindex 970d836e01..9c7367f609 100644--- a/packages/api/src/agents/skills.ts+++ b/packages/api/src/agents/skills.ts@@ -434,6 +434,8 @@ export interface InjectSkillCatalogParams {workspaceTools?: boolean;/** Live operation ceiling for the selected attached workspace. */workspaceOperations?: ReadonlySet<CodeWorkspaceOperation>;+ /** Deployment ceiling advertised on attached Bash tool definitions. */+ workspaceCommandTimeoutMaxMs?: number;/** Current user ID — used to determine skill ownership for active-state resolution. */userId?: string;/** Per-user skill overrides: `{ [skillId]: boolean }`. Missing entries use the default. */@@ -662,6 +664,7 @@ export async function injectSkillCatalog(statefulSessions,workspaceTools,workspaceOperations,+ workspaceCommandTimeoutMaxMs,userId,skillStates,defaultActiveOnShare = false,@@ -821,6 +824,7 @@ export async function injectSkillCatalog(statefulSessions: statefulSessions === true,workspaceTools: workspaceTools === true,workspaceOperations,+ workspaceCommandTimeoutMaxMs,});workingDefs = codeExecResult.toolDefinitions;diff --git a/packages/api/src/agents/tools.spec.ts b/packages/api/src/agents/tools.spec.tsindex 8afd0a524a..a49d61aaac 100644--- a/packages/api/src/agents/tools.spec.ts+++ b/packages/api/src/agents/tools.spec.ts@@ -520,6 +520,7 @@ describe('registerCodeExecutionTools', () => {command: { type: 'string' },args: { type: 'array' },cwd: { type: 'string', maxLength: 4096 },+ timeoutMs: { type: 'integer', minimum: 1, maximum: 30000 },},required: ['command'],});@@ -550,6 +551,25 @@ describe('registerCodeExecutionTools', () => {expect(filePathDescription(listWorkspaceFiles)).toContain('canonical relative');});+ it('advertises the configured attached-command timeout ceiling', () => {+ const result = registerCodeExecutionTools({+ toolRegistry: makeRegistry(),+ toolDefinitions: [],+ includeBash: true,+ workspaceTools: true,+ workspaceOperations: new Set(['execute_command'] as const),+ workspaceCommandTimeoutMaxMs: 120_000,+ });++ expect(+ result.toolDefinitions.find((definition) => definition.name === 'bash_tool'),+ ).toMatchObject({+ parameters: {+ properties: { timeoutMs: { minimum: 1, maximum: 120_000 } },+ },+ });+ });+it('registers only operations advertised by the selected workspace', () => {const result = registerCodeExecutionTools({toolRegistry: makeRegistry(),diff --git a/packages/api/src/agents/tools.ts b/packages/api/src/agents/tools.tsindex ce8af5002f..5b23429b5a 100644--- a/packages/api/src/agents/tools.ts+++ b/packages/api/src/agents/tools.ts@@ -15,7 +15,7 @@ import type { AgentToolOptions, CodeWorkspaceOperation, GraphEdge } from 'librecimport type { LCTool, LCToolRegistry } from '@librechat/agents';import type { ReachableAgent } from './traversal';import {- ATTACHED_WORKSPACE_BASH_SCHEMA,+ buildAttachedWorkspaceBashSchema,buildAttachedWorkspaceBashDescription,} from '~/code/command';import { toolkitExpansion } from '~/tools/toolkits/mapping';@@ -379,6 +379,8 @@ export interface RegisterCodeExecutionToolsParams {workspaceTools?: boolean;/** Live operation ceiling for the selected workspace. Omitted for managed runtimes. */workspaceOperations?: ReadonlySet<CodeWorkspaceOperation>;+ /** Deployment ceiling advertised on attached Bash tool definitions. */+ workspaceCommandTimeoutMaxMs?: number;/*** When `true`, the registered `bash_tool` description includes the* LLM-facing `{{tool<idx>turn<turn>}}` reference syntax guide so the@@ -888,6 +890,7 @@ function createBashToolDef(enableToolOutputReferences: boolean,statefulSessions = false,workspaceTools = false,+ workspaceCommandTimeoutMaxMs?: number,): LCTool {/* Passed as a variable (not an inline literal) so the extra* `statefulSessions` key stays assignable against pinned SDK versions@@ -900,7 +903,7 @@ function createBashToolDef(? buildAttachedWorkspaceBashDescription(enableToolOutputReferences): buildBashExecutionToolDescription(descriptionOpts),parameters: (workspaceTools- ? ATTACHED_WORKSPACE_BASH_SCHEMA+ ? buildAttachedWorkspaceBashSchema(workspaceCommandTimeoutMaxMs): BashExecutionToolDefinition.schema) as unknown as LCTool['parameters'],}) as LCTool;}@@ -912,6 +915,7 @@ function buildBashToolDef(opts: {enableToolOutputReferences: boolean;statefulSessions?: boolean;workspaceTools?: boolean;+ workspaceCommandTimeoutMaxMs?: number;}): LCTool {/* Stateful defs are built on demand: the stateless pair covers the* default path, and per-run construction is negligible next to init. */@@ -920,6 +924,7 @@ function buildBashToolDef(opts: {opts.enableToolOutputReferences,opts.statefulSessions === true,opts.workspaceTools === true,+ opts.workspaceCommandTimeoutMaxMs,);}return opts.enableToolOutputReferences@@ -951,6 +956,7 @@ export function registerCodeExecutionTools(includeSkillFileInstructions = true,workspaceTools = false,workspaceOperations,+ workspaceCommandTimeoutMaxMs,enableToolOutputReferences = false,statefulSessions = false,} = params;@@ -965,7 +971,12 @@ export function registerCodeExecutionTools(}if (includeBash && supportsWorkspaceOperation('execute_command')) {candidates.push(- buildBashToolDef({ enableToolOutputReferences, statefulSessions, workspaceTools }),+ buildBashToolDef({+ enableToolOutputReferences,+ statefulSessions,+ workspaceTools,+ workspaceCommandTimeoutMaxMs,+ }),);}if (workspaceTools && supportsWorkspaceOperation('search_text')) {diff --git a/packages/api/src/code/command.spec.ts b/packages/api/src/code/command.spec.tsindex db57adaa40..fcf5420116 100644--- a/packages/api/src/code/command.spec.ts+++ b/packages/api/src/code/command.spec.ts@@ -4,8 +4,10 @@ import type { AddressInfo } from 'node:net';import type { CodeBridgeFetch } from './bridge';import {ATTACHED_WORKSPACE_BASH_SCHEMA,+ buildAttachedWorkspaceBashSchema,createAttachedWorkspaceBashTool,createGitIdentityProgrammaticBashTool,+ resolveAttachedWorkspaceCommandTimeoutMax,} from './command';describe('programmatic Bash Git identity', () => {@@ -98,10 +100,92 @@ describe('createAttachedWorkspaceBashTool', () => {workspaceId: 'project-a',command: 'pwd',cwd: 'packages/api',+ timeoutMs: 30_000,maxOutputBytes: 256 * 1024,});});+ test('forwards a bounded per-call execution timeout', async () => {+ const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());+ const bashTool = createAttachedWorkspaceBashTool({+ baseUrl: 'https://code.example.com/v1',+ authHeaders: () => ({}),+ workspaceId: 'project-a',+ maxTimeoutMs: 300_000,+ fetchImpl,+ });++ await bashTool.invoke({ command: 'npm test', timeoutMs: 300_000 });++ const request = JSON.parse(String((fetchImpl as jest.Mock).mock.calls[0][1]?.body));+ expect(request).toMatchObject({ command: 'npm test', timeoutMs: 300_000 });+ });++ test('preserves the historical 30-second ceiling unless an administrator raises it', async () => {+ const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());+ const bashTool = createAttachedWorkspaceBashTool({+ baseUrl: 'https://code.example.com/v1',+ authHeaders: () => ({}),+ workspaceId: 'project-a',+ fetchImpl,+ });++ await expect(+ bashTool.func({ command: 'npm test', timeoutMs: 30_001 }, undefined, {}),+ ).rejects.toThrow('deployment limit of 30000 milliseconds');+ expect(fetchImpl).not.toHaveBeenCalled();+ });++ test('resolves and advertises an administrator-configured timeout ceiling', () => {+ const maxTimeoutMs = resolveAttachedWorkspaceCommandTimeoutMax({+ limits: { maxCommandTimeoutMs: 120_000 },+ });+ const schema = buildAttachedWorkspaceBashSchema(maxTimeoutMs);++ expect(maxTimeoutMs).toBe(120_000);+ expect(schema).toMatchObject({+ properties: { timeoutMs: { type: 'integer', minimum: 1, maximum: 120_000 } },+ });+ expect(resolveAttachedWorkspaceCommandTimeoutMax()).toBe(30_000);+ });++ test('lowers the omitted timeout when the deployment ceiling is below 30 seconds', async () => {+ const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());+ const bashTool = createAttachedWorkspaceBashTool({+ baseUrl: 'https://code.example.com/v1',+ authHeaders: () => ({}),+ workspaceId: 'project-a',+ maxTimeoutMs: 5_000,+ fetchImpl,+ });++ await bashTool.invoke({ command: 'npm test' });++ const request = JSON.parse(String((fetchImpl as jest.Mock).mock.calls[0][1]?.body));+ expect(request).toMatchObject({ timeoutMs: 5_000 });+ expect(buildAttachedWorkspaceBashSchema(5_000)).toMatchObject({+ properties: {+ timeoutMs: expect.objectContaining({+ maximum: 5_000,+ description: expect.stringContaining('Defaults to 5000'),+ }),+ },+ });+ });++ test.each([0, 300_001, 1.5])('rejects an invalid execution timeout of %p', async (timeoutMs) => {+ const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());+ const bashTool = createAttachedWorkspaceBashTool({+ baseUrl: 'https://code.example.com/v1',+ authHeaders: () => ({}),+ workspaceId: 'project-a',+ fetchImpl,+ });++ await expect(bashTool.invoke({ command: 'npm test', timeoutMs })).rejects.toThrow();+ expect(fetchImpl).not.toHaveBeenCalled();+ });+test('validates and invokes commands through the LangChain tool runtime', async () => {const fetchImpl: CodeBridgeFetch = jest.fn(async () => commandResponse());const bashTool = createAttachedWorkspaceBashTool({diff --git a/packages/api/src/code/command.ts b/packages/api/src/code/command.tsindex ecb16e3e1e..20b3122e11 100644--- a/packages/api/src/code/command.ts+++ b/packages/api/src/code/command.ts@@ -4,12 +4,16 @@ import {BashToolOutputReferencesGuide,createBashProgrammaticToolCallingTool,} from '@librechat/agents';+import type { AgentGitIdentity, CodeEnvironmentUserConfigSchema } from 'librechat-data-provider';import type { DynamicStructuredTool } from '@librechat/agents/langchain/tools';-import type { AgentGitIdentity } from 'librechat-data-provider';import type { LCTool } from '@librechat/agents';import type { WorkspaceExecuteCommandResult } from './workspace';import type { CodeBridgeFetch } from './bridge';-import { executeWorkspaceTool } from './workspace';+import {+ executeWorkspaceTool,+ WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS,+ WORKSPACE_COMMAND_MAX_TIMEOUT_MS,+} from './workspace';const DEFAULT_OUTPUT_BYTES = 256 * 1024;@@ -48,20 +52,64 @@ const attachedWorkingDirectorySchema: BoundedWorkingDirectorySchema = {'Optional working directory relative to the selected workspace root, such as "packages/api". Absolute paths and parent traversal are rejected.',};+/** Numeric bounds are valid JSON Schema, but the SDK's schema type omits them. */+interface BoundedTimeoutSchema {+ type: 'integer';+ minimum: number;+ maximum: number;+ description: string;+}++function buildAttachedTimeoutSchema(maxTimeoutMs: number): BoundedTimeoutSchema {+ const defaultTimeoutMs = Math.min(WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS, maxTimeoutMs);+ return {+ type: 'integer',+ minimum: 1,+ maximum: maxTimeoutMs,+ description: `Optional execution timeout in milliseconds, from 1 through ${maxTimeoutMs}. Defaults to ${defaultTimeoutMs}. Waiting for an available worker does not consume this execution budget.`,+ };+}++function normalizeAttachedWorkspaceCommandTimeoutMax(maxTimeoutMs: number): number {+ if (!Number.isSafeInteger(maxTimeoutMs) || maxTimeoutMs < 1) {+ return WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS;+ }+ return Math.min(WORKSPACE_COMMAND_MAX_TIMEOUT_MS, maxTimeoutMs);+}++export function resolveAttachedWorkspaceCommandTimeoutMax(+ configSchema?: CodeEnvironmentUserConfigSchema,+): number {+ const configured = configSchema?.limits?.maxCommandTimeoutMs;+ return configured == null+ ? WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS+ : normalizeAttachedWorkspaceCommandTimeoutMax(configured);+}++export function buildAttachedWorkspaceBashSchema(+ maxTimeoutMs: number = WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS,+): NonNullable<LCTool['parameters']> {+ const effectiveMaxTimeoutMs = normalizeAttachedWorkspaceCommandTimeoutMax(maxTimeoutMs);+ return {+ type: 'object',+ properties: {+ ...bashSchema.properties,+ command: attachedCommandSchema,+ cwd: attachedWorkingDirectorySchema,+ timeoutMs: buildAttachedTimeoutSchema(effectiveMaxTimeoutMs),+ },+ required: ['command'],+ };+}+/*** This definition is shared with agent metadata. LangChain's JSON Schema* dereferencer annotates schemas during validation, so each tool receives an* isolated mutable clone instead of mutating this shared definition.*/-export const ATTACHED_WORKSPACE_BASH_SCHEMA: NonNullable<LCTool['parameters']> = Object.freeze({- type: 'object',- properties: {- ...bashSchema.properties,- command: attachedCommandSchema,- cwd: attachedWorkingDirectorySchema,- },- required: ['command'],-});+export const ATTACHED_WORKSPACE_BASH_SCHEMA: NonNullable<LCTool['parameters']> = Object.freeze(+ buildAttachedWorkspaceBashSchema(),+);export function buildAttachedWorkspaceBashDescription(enableToolOutputReferences: boolean): string {return enableToolOutputReferences@@ -130,23 +178,40 @@ export function createAttachedWorkspaceBashTool({authHeaders,workspaceId,gitIdentity,+ maxTimeoutMs = WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS,fetchImpl,}: {baseUrl: string;authHeaders: () => Promise<Record<string, string>> | Record<string, string>;workspaceId: string;gitIdentity?: AgentGitIdentity | null;+ /** Deployment ceiling already intersected with the protocol hard cap. */+ maxTimeoutMs?: number;fetchImpl?: CodeBridgeFetch;}): DynamicStructuredTool {+ const effectiveMaxTimeoutMs = normalizeAttachedWorkspaceCommandTimeoutMax(maxTimeoutMs);return tool(async (- rawInput: { command: string; args?: string[]; cwd?: string; intent?: string },+ rawInput: {+ command: string;+ args?: string[];+ cwd?: string;+ timeoutMs?: number;+ intent?: string;+ },config,): Promise<[string, Record<string, never>]> => {+ if (rawInput.timeoutMs != null && rawInput.timeoutMs > effectiveMaxTimeoutMs) {+ throw new Error(+ `Command timeout exceeds the deployment limit of ${effectiveMaxTimeoutMs} milliseconds.`,+ );+ }const command = commandWithGitIdentity(commandWithArguments(rawInput.command, rawInput.args),gitIdentity,);+ const timeoutMs =+ rawInput.timeoutMs ?? Math.min(WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS, effectiveMaxTimeoutMs);const result = await executeWorkspaceTool({baseURL: baseUrl,authHeaders: await authHeaders(),@@ -156,6 +221,7 @@ export function createAttachedWorkspaceBashTool({workspaceId,command,...(rawInput.cwd ? { cwd: rawInput.cwd } : {}),+ timeoutMs,maxOutputBytes: DEFAULT_OUTPUT_BYTES,},signal: config?.signal,@@ -169,7 +235,7 @@ export function createAttachedWorkspaceBashTool({{name: BashExecutionToolDefinition.name,description: ATTACHED_WORKSPACE_BASH_DESCRIPTION,- schema: structuredClone(ATTACHED_WORKSPACE_BASH_SCHEMA),+ schema: structuredClone(buildAttachedWorkspaceBashSchema(effectiveMaxTimeoutMs)),responseFormat: 'content_and_artifact',},) as unknown as DynamicStructuredTool;diff --git a/packages/api/src/code/config.spec.ts b/packages/api/src/code/config.spec.tsindex 784c33ad39..b3f3a31042 100644--- a/packages/api/src/code/config.spec.ts+++ b/packages/api/src/code/config.spec.ts@@ -134,6 +134,9 @@ describe('mergeAccessibleCodeEnvironments', () => {permissions: {commandExecution: { allowed: ['ask', 'deny'], default: 'ask' },},+ limits: {+ maxCommandTimeoutMs: 120_000,+ },},},],@@ -172,6 +175,9 @@ describe('mergeAccessibleCodeEnvironments', () => {permissions: {commandExecution: { allowed: ['ask', 'deny'], default: 'ask' },},+ limits: {+ maxCommandTimeoutMs: 120_000,+ },},settings: { permissions: { commandExecution: 'deny' } },});diff --git a/packages/api/src/code/workspace.ts b/packages/api/src/code/workspace.tsindex cedc624b66..900dd6d211 100644--- a/packages/api/src/code/workspace.ts+++ b/packages/api/src/code/workspace.ts@@ -11,8 +11,9 @@ const MAX_LIST_RESULTS = 500;export const WORKSPACE_WRITE_MAX_BYTES: number = 1024 * 1024;export const WORKSPACE_EDIT_MAX_COUNT: number = 100;const MAX_COMMAND_BYTES = 32 * 1024;-const DEFAULT_COMMAND_TIMEOUT_MS = 30_000;-const MAX_COMMAND_TIMEOUT_MS = 5 * 60_000;+/** Keep aligned with data-provider's deployment schema defaults and hard cap. */+export const WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS: number = 30_000;+export const WORKSPACE_COMMAND_MAX_TIMEOUT_MS: number = 5 * 60_000;const DEFAULT_COMMAND_OUTPUT_BYTES = 256 * 1024;const MAX_COMMAND_OUTPUT_BYTES = 1024 * 1024;const MAX_COMMAND_SIGNAL_LENGTH = 32;@@ -467,7 +468,8 @@ function isValidRequest(request: WorkspaceToolRequest): boolean {request.command.trim().length > 0 &&!request.command.includes('\0') &&(request.cwd == null || isSafePath(request.cwd)) &&- (request.timeoutMs == null || isPositiveInteger(request.timeoutMs, MAX_COMMAND_TIMEOUT_MS)) &&+ (request.timeoutMs == null ||+ isPositiveInteger(request.timeoutMs, WORKSPACE_COMMAND_MAX_TIMEOUT_MS)) &&(request.maxOutputBytes == null ||isPositiveInteger(request.maxOutputBytes, MAX_COMMAND_OUTPUT_BYTES)));@@ -658,7 +660,8 @@ function isValidResult(function getWorkspaceToolTimeoutMs(request: WorkspaceToolRequest): number {const executionBudgetMs =request.operation === 'execute_command'- ? (request.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS) + WORKSPACE_COMMAND_SETTLEMENT_GRACE_MS+ ? (request.timeoutMs ?? WORKSPACE_COMMAND_DEFAULT_TIMEOUT_MS) ++ WORKSPACE_COMMAND_SETTLEMENT_GRACE_MS: WORKSPACE_TOOL_TIMEOUT_MS;return WORKSPACE_QUEUE_TIMEOUT_MS + executionBudgetMs + WORKSPACE_COMMAND_TRANSPORT_GRACE_MS;}diff --git a/packages/data-provider/src/config.spec.ts b/packages/data-provider/src/config.spec.tsindex 5d3b1ae098..72dafeb6c3 100644--- a/packages/data-provider/src/config.spec.ts+++ b/packages/data-provider/src/config.spec.ts@@ -237,6 +237,7 @@ describe('attached code environment user config schema', () => {fileWrite: { allowed: ['allow', 'ask', 'deny'], default: 'ask' },commandExecution: { allowed: ['ask', 'deny'], default: 'ask' },},+ limits: { maxCommandTimeoutMs: 120000 },},},],@@ -251,6 +252,30 @@ describe('attached code environment user config schema', () => {expect(result.success).toBe(true);});+ it('rejects an attached command timeout above the protocol hard cap', () => {+ const result = configSchema.safeParse({+ version: '1.0',+ endpoints: {+ agents: {+ statefulCodeSessions: {+ allowedEnvironments: ['user'],+ environments: [+ {+ id: 'personal-vm',+ name: 'Personal VM',+ type: 'attached',+ baseURL: 'https://code.example.com/v1',+ configSchema: { limits: { maxCommandTimeoutMs: 300001 } },+ },+ ],+ },+ },+ },+ });++ expect(result.success).toBe(false);+ });+it('rejects a permission default the administrator did not expose', () => {const result = configSchema.safeParse({version: '1.0',diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex d4f1c84fbe..acfa2561e4 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -1116,6 +1116,11 @@ const codeEnvironmentPermissionFieldSchema = z}});+/** Existing attached commands used a fixed 30-second execution budget. */+export const CODE_ENVIRONMENT_COMMAND_TIMEOUT_DEFAULT_MS = 30_000;+/** Protocol-level ceiling; deployments may only lower this value. */+export const CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS = 5 * 60_000;+/*** Typed user-tunable surface for one attached code environment. Omitted fields* remain fixed at LibreChat's safe baseline. Isolation, networking, mounts,@@ -1130,6 +1135,19 @@ export const codeEnvironmentUserConfigSchema = z}).strict().optional(),+ limits: z+ .object({+ /** Maximum timeout a Bash invocation may request. Omission preserves+ * the historical 30-second command budget. */+ maxCommandTimeoutMs: z+ .number()+ .int()+ .min(1)+ .max(CODE_ENVIRONMENT_COMMAND_TIMEOUT_HARD_MAX_MS)+ .optional(),+ })+ .strict()+ .optional(),}).strict();