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: Seal Code Environment Choices Per Conversation (#15868)
Danny Avila1163045cef65
diff --git a/.env.example b/.env.exampleindex 1a6a27ee35..42b88f61bc 100644--- a/.env.example+++ b/.env.example@@ -729,6 +729,10 @@ TTS_API_KEY=#==================================================## LIBRECHAT_CODE_API_KEY=++# Advertise the immutable per-conversation code-environment decision protocol.+# Enable only after every LibreChat API replica runs a version that supports protocol v1.+# CODE_ENVIRONMENT_DECISION_VERSION=1# LIBRECHAT_CODE_BASEURL=# Current self-hosted Code Interpreter deployments use per-user LibreChat JWTs outside local mode.# Configure the matching public verifier on Code Interpreter; see:diff --git a/CONTEXT.md b/CONTEXT.mdindex 1fa1202774..061c21700b 100644--- a/CONTEXT.md+++ b/CONTEXT.md@@ -3,6 +3,7 @@- **Scheduled run admission**: The claimed-occurrence phase that rehydrates the owner, validates current schedule policy and agent reachability, resolves files and MCP readiness, and only then competes for durable generation capacity. It owns cancellation and lease revalidation until a generation slot is reserved; a slow or failed readiness check never occupies generation capacity.- **Attached code environment**: A principal- or deployment-authorized stateful workspace owned by an outbound `librechat-code` worker on a user-chosen machine or VM. LibreChat selects it and enforces approval policy, Code API authenticates and dispatches to it, and the worker's local sandbox and capability flags remain the final execution ceiling. The environment interface is runtime-neutral: native SRT, WSL2, Docker/NsJail, and future adapters expose the same workspace operations without leaking host paths or runtime configuration into agent tools.+- **Conversation code-environment decision**: The immutable choice established by a conversation's first accepted submission between validated attached workspaces and continuing without an attached environment. Agent defaults and recent workspace preferences may suggest a draft choice, but only the persisted conversation decision authorizes attached workspace tool registration; later turns, retries, resumes, and alternate ingresses cannot upgrade or replace it.- **Agent run envelope**: the versioned, JSON-safe request contract created after ingress authentication and protocol validation but before agent, provider, tool, or MCP initialization. It carries only the validated protocol payload and the minimum trusted principal identifiers. The execution host rehydrates all runtime state from those identifiers.- **Agent execution context**: runtime-only, transport-free state rehydrated beside an Agent run envelope. It contains the authenticated user, application configuration, normalized request metadata, and resolved conversation facts needed by initialization, but never Express request/response objects or serialized credentials.- **Agent execution host**: the protocol-neutral module that owns run admission, disconnect cancellation, provider-start fencing, and terminal settlement. Protocol implementations execute behind its callback interface; HTTP adapters retain validation and final stream rendering.diff --git a/api/server/controllers/agents/__tests__/openai.spec.js b/api/server/controllers/agents/__tests__/openai.spec.jsindex c82c0ac51b..ff2b5235bb 100644--- a/api/server/controllers/agents/__tests__/openai.spec.js+++ b/api/server/controllers/agents/__tests__/openai.spec.js@@ -217,14 +217,27 @@ jest.mock('@librechat/api', () => ({buildInitialToolSessions: jest.fn().mockReturnValue(mockInitialSessions),AgentRunEnvelopeError: MockAgentRunEnvelopeError,createAgentRunEnvelope: (...args) => mockCreateAgentRunEnvelope(...args),+ resolveConversationCodeEnvironmentDecision: ({+ requestedMode,+ requestedSelections,+ conversation,+ }) => {+ const codeWorkspaces = requestedSelections ?? conversation?.codeWorkspaces;+ return {+ mode: requestedMode ?? (codeWorkspaces?.length ? 'attached' : 'without_attached'),+ ...(codeWorkspaces !== undefined && { codeWorkspaces }),+ };+ },createMCPRuntimeRequestBody: ({messageId,conversationId,parentMessageId,+ codeEnvironmentMode,codeWorkspaces,}) => ({messageId,conversationId,+ ...(codeEnvironmentMode !== undefined && { codeEnvironmentMode }),...(codeWorkspaces !== undefined && { codeWorkspaces }),...(parentMessageId !== undefined && {parentMessageId: parentMessageId ?? '00000000-0000-0000-0000-000000000000',@@ -1608,6 +1621,7 @@ describe('OpenAIChatCompletionController', () => {messageId: 'chatcmpl-mock-nanoid-123',conversationId: 'conversation-123',parentMessageId: 'parent-123',+ codeEnvironmentMode: 'without_attached',},}),expect.anything(),@@ -1618,6 +1632,7 @@ describe('OpenAIChatCompletionController', () => {messageId: 'chatcmpl-mock-nanoid-123',conversationId: 'conversation-123',parentMessageId: 'parent-123',+ codeEnvironmentMode: 'without_attached',},}),);@@ -1629,6 +1644,7 @@ describe('OpenAIChatCompletionController', () => {messageId: 'chatcmpl-mock-nanoid-123',conversationId: 'conversation-123',parentMessageId: 'parent-123',+ codeEnvironmentMode: 'without_attached',},}),}),@@ -1655,6 +1671,7 @@ describe('OpenAIChatCompletionController', () => {expect(requestBody).toEqual({messageId: 'chatcmpl-mock-nanoid-123',conversationId: 'conversation-123',+ codeEnvironmentMode: 'without_attached',});expect(requestBody).not.toHaveProperty('parentMessageId');});diff --git a/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js b/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.jsindex 742917090c..90b9c89a33 100644--- a/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js+++ b/api/server/controllers/agents/__tests__/request.partialDisconnect.spec.js@@ -65,6 +65,8 @@ jest.mock('@librechat/api', () => ({resolveTitleTiming: jest.fn(() => 'immediate'),resolveConversationAnchor: jest.requireActual('@librechat/api').resolveConversationAnchor,resolveRunCodeWorkspaces: jest.requireActual('@librechat/api').resolveRunCodeWorkspaces,+ shouldPersistCodeWorkspaceInitializationError:+ jest.requireActual('@librechat/api').shouldPersistCodeWorkspaceInitializationError,getSafeErrorMetadata: jest.requireActual('@librechat/api').getSafeErrorMetadata,getSafeErrorText: jest.requireActual('@librechat/api').getSafeErrorText,GenerationJobManager: mockGenerationJobManager,diff --git a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.jsindex 3d8d74b261..b6f2dcba01 100644--- a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js+++ b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js@@ -278,6 +278,8 @@ jest.mock('@librechat/api', () => ({encodeAndFormatImages: jest.requireActual('@librechat/api').encodeAndFormatImages,getCodeWorkspaceSelectionErrorDetails:jest.requireActual('@librechat/api').getCodeWorkspaceSelectionErrorDetails,+ shouldPersistCodeWorkspaceInitializationError:+ jest.requireActual('@librechat/api').shouldPersistCodeWorkspaceInitializationError,getSafeErrorMetadata: jest.requireActual('@librechat/api').getSafeErrorMetadata,getSafeErrorText: jest.requireActual('@librechat/api').getSafeErrorText,GenerationJobManager: mockGenerationJobManager,@@ -337,11 +339,13 @@ jest.mock('@librechat/api', () => ({messageId,conversationId,parentMessageId,+ codeEnvironmentMode,codeWorkspaces,}) => ({messageId,conversationId,parentMessageId,+ ...(codeEnvironmentMode !== undefined ? { codeEnvironmentMode } : {}),...(codeWorkspaces !== undefined ? { codeWorkspaces } : {}),}),}));@@ -1430,6 +1434,53 @@ describe('ResumableAgentController resume metadata', () => {expect(requestBody.messageId).not.toBe(req.body.messageId);});+ it('pins a normalized code-environment decision before provider execution', async () => {+ let signalProviderStarted;+ const providerStarted = new Promise((resolve) => {+ signalProviderStarted = resolve;+ });+ const sendMessage = jest.fn(() => {+ signalProviderStarted();+ return new Promise(() => {});+ });+ const initializeClient = jest.fn(async ({ req }) => {+ req.body.codeEnvironmentMode = 'without_attached';+ delete req.body.codeWorkspaces;+ return { client: { options: {}, sendMessage } };+ });+ const req = {+ user: { id: 'user-123' },+ body: {+ text: 'Continue without my attached machine.',+ messageId: 'incoming-client-message',+ parentMessageId: 'previous-response',+ conversationId: 'conversation-123',+ endpointOption: { endpoint: 'agents', modelOptions: { model: 'gpt-4.1' } },+ },+ config: {},+ };++ await AgentController(req, createResumableResponse(), jest.fn(), initializeClient, null);+ await providerStarted;++ const initialRequestBody =+ mockGenerationJobManager.createJob.mock.calls[0][3].initialMetadata.mcpRequestBody;+ expect(initialRequestBody).not.toHaveProperty('codeEnvironmentMode');+ expect(mockGenerationJobManager.updateMetadata).toHaveBeenCalledWith(+ 'conversation-123',+ {+ mcpRequestBody: {+ ...initialRequestBody,+ codeEnvironmentMode: 'without_attached',+ },+ },+ 1000,+ );+ expect(mockGenerationJobManager.updateMetadata.mock.invocationCallOrder[0]).toBeLessThan(+ sendMessage.mock.invocationCallOrder[0],+ );+ });+it('uses the effective overridden conversation in the MCP request body', async () => {const initializeClient = jest.fn().mockRejectedValue(new Error('stop after MCP discovery'));const req = {@@ -3786,6 +3837,36 @@ describe('ResumableAgentController resume metadata', () => {expect(mockSaveConvo).not.toHaveBeenCalled();});+ it('does not persist a first turn whose code environment decision was rejected', async () => {+ const res = createResumableResponse();+ mockGenerationJobManager.claimGeneration.mockImplementation(+ async (_userId, _clientRequestId, streamId, claimedConversationId) =>+ wonGenerationClaim({ streamId, conversationId: claimedConversationId }),+ );+ const req = createFailedRequest({+ conversationId: undefined,+ clientRequestId: 'invalid-code-decision',+ codeEnvironmentMode: 'attached',+ codeWorkspaces: undefined,+ });+ const workspaceError = Object.assign(new Error('Choose an attached workspace'), {+ code: ErrorTypes.CODE_WORKSPACE_UNAVAILABLE,+ reason: 'required',+ status: 409,+ statusCode: 409,+ });++ await AgentController(req, res, jest.fn(), jest.fn().mockRejectedValue(workspaceError), null);++ expect(mockGenerationJobManager.completeJob).toHaveBeenCalledWith(+ expect.any(String),+ expect.stringContaining(ErrorTypes.CODE_WORKSPACE_UNAVAILABLE),+ 1000,+ );+ expect(mockSaveMessage).not.toHaveBeenCalled();+ expect(mockSaveConvo).not.toHaveBeenCalled();+ });+it('creates the conversation row for a failed first turn', async () => {const res = createResumableResponse();mockGenerationJobManager.claimGeneration.mockImplementation(@@ -3803,15 +3884,18 @@ describe('ResumableAgentController resume metadata', () => {modelOptions: { model: 'gpt-4o' },chatProjectId: '507f1f77bcf86cd799439011',},+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],+ });+ const initializeClient = jest.fn().mockImplementation(async ({ req: request }) => {+ request._codeEnvironmentDecision = {+ mode: 'attached',+ codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],+ };+ throw new Error('model unavailable');});- await AgentController(- req,- res,- jest.fn(),- jest.fn().mockRejectedValue(new Error('model unavailable')),- null,- );+ await AgentController(req, res, jest.fn(), initializeClient, null);const mintedConversationId = res.json.mock.calls[0][0].conversationId;expect(mockSaveMessage).toHaveBeenCalledWith(@@ -3829,6 +3913,8 @@ describe('ResumableAgentController resume metadata', () => {endpoint: 'azureOpenAI',model: 'gpt-4o',chatProjectId: '507f1f77bcf86cd799439011',+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],}),expect.objectContaining({ initialAgentId: null }),);diff --git a/api/server/controllers/agents/__tests__/responses.unit.spec.js b/api/server/controllers/agents/__tests__/responses.unit.spec.jsindex e639f015e5..41e07fffb5 100644--- a/api/server/controllers/agents/__tests__/responses.unit.spec.js+++ b/api/server/controllers/agents/__tests__/responses.unit.spec.js@@ -236,15 +236,28 @@ jest.mock('@librechat/api', () => ({buildRunToolSet: jest.fn().mockReturnValue(new Set()),AgentRunEnvelopeError: MockAgentRunEnvelopeError,createAgentRunEnvelope: (...args) => mockCreateAgentRunEnvelope(...args),+ resolveConversationCodeEnvironmentDecision: ({+ requestedMode,+ requestedSelections,+ conversation,+ }) => {+ const codeWorkspaces = requestedSelections ?? conversation?.codeWorkspaces;+ return {+ mode: requestedMode ?? (codeWorkspaces?.length ? 'attached' : 'without_attached'),+ ...(codeWorkspaces !== undefined && { codeWorkspaces }),+ };+ },getCodeWorkspaceSelections: jest.fn(),createMCPRuntimeRequestBody: ({messageId,conversationId,parentMessageId,+ codeEnvironmentMode,codeWorkspaces,}) => ({messageId,conversationId,+ ...(codeEnvironmentMode !== undefined && { codeEnvironmentMode }),...(codeWorkspaces !== undefined && { codeWorkspaces }),...(parentMessageId !== undefined && {parentMessageId: parentMessageId ?? '00000000-0000-0000-0000-000000000000',@@ -611,6 +624,38 @@ describe('createResponse controller', () => {},);+ it.each([false, true])(+ 'persists the normalized no-attached decision atomically: stream=%s',+ async (stream) => {+ const api = require('@librechat/api');+ const db = require('~/models');+ api.getCodeWorkspaceSelections.mockReturnValueOnce([+ { environmentId: 'machine', workspaceId: 'stale-project' },+ ]);+ api.validateResponseRequest.mockReturnValueOnce({+ request: {+ model: 'agent-123',+ input: 'Hello',+ stream,+ store: true,+ code_environment_mode: 'without_attached',+ },+ });++ await createResponse(req, res);++ expect(db.saveConvo).toHaveBeenCalledWith(+ expect.anything(),+ expect.objectContaining({+ codeEnvironmentMode: 'without_attached',+ }),+ expect.anything(),+ );+ expect(db.saveConvo.mock.calls.at(-1)[1]).not.toHaveProperty('codeWorkspaces');+ expect(api.getCodeWorkspaceSelections).not.toHaveBeenCalled();+ },+ );+it('enrolls, starts, and settles the remote execution lifecycle', async () => {await createResponse(req, res);@@ -905,6 +950,7 @@ describe('createResponse controller', () => {requestBody: {messageId: 'resp_mock-123',conversationId: expect.any(String),+ codeEnvironmentMode: 'without_attached',},}),expect.anything(),diff --git a/api/server/controllers/agents/__tests__/resume.spec.js b/api/server/controllers/agents/__tests__/resume.spec.jsindex dde2514f66..d83ef745ed 100644--- a/api/server/controllers/agents/__tests__/resume.spec.js+++ b/api/server/controllers/agents/__tests__/resume.spec.js@@ -2461,6 +2461,33 @@ describe('ResumeAgentController (POST /agents/chat/resume)', () => {await flush();});+ it('enforces the current fingerprint while retaining the rolling-deploy digest', async () => {+ const { computeAgentRequestFingerprint, computeLegacyAgentRequestFingerprint } =+ jest.requireActual('@librechat/api');+ const pausedBody = {+ endpoint: 'agents',+ agent_id: AGENT_ID,+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [{ environmentId: 'machine-a', workspaceId: 'project-a' }],+ };+ const job = makeToolApprovalJob();+ job.metadata.pendingAction.requestFingerprint =+ computeLegacyAgentRequestFingerprint(pausedBody);+ job.metadata.pendingAction.requestFingerprintV2 = computeAgentRequestFingerprint(pausedBody);+ mockGenerationJobManager.getJob.mockResolvedValue(job);++ const res = await post(+ approveBody({+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [{ environmentId: 'machine-a', workspaceId: 'project-b' }],+ }),+ );++ expect(res.status).toBe(403);+ expect(res.body.error).toMatch(/different agent configuration/i);+ expect(mockGenerationJobManager.approvals.resolve).not.toHaveBeenCalled();+ });+it('403 when the resume sends a different promptPrefix than the paused config', async () => {const { computeAgentRequestFingerprint } = jest.requireActual('@librechat/api');const job = makeToolApprovalJob();diff --git a/api/server/controllers/agents/client.js b/api/server/controllers/agents/client.jsindex f9370fdabc..fc61f61c58 100644--- a/api/server/controllers/agents/client.js+++ b/api/server/controllers/agents/client.js@@ -43,8 +43,8 @@ const {buildPendingAction,toClientPendingAction,captureCodeExecutionApprovalBinding,- getCodeWorkspaceSelections,computeAgentRequestFingerprint,+ computeLegacyAgentRequestFingerprint,getRunDiscoveredTools,captureResumeModelParameters,pickResumeContext,@@ -1999,6 +1999,7 @@ class AgentClient extends BaseClient {collectAttachedCodeEnvironmentPolicySettings(topLevelAgents),agentsEConfig?.toolApproval?.enabled !== false,);+ const codeEnvironmentDecision = this.options.req._codeEnvironmentDecision;return removeNullishValues(Object.assign(@@ -2013,9 +2014,12 @@ class AgentClient extends BaseClient {imageDetail: this.options.imageDetail,maxContextTokens: this.maxContextTokens,codeApprovalMode,- codeWorkspaces: getCodeWorkspaceSelections(- collectReachableAgents(topLevelAgents).map((agent) => agent?.codeExecutionContext),- ),+ codeEnvironmentMode:+ codeEnvironmentDecision?.mode ?? this.options.req.body.codeEnvironmentMode,+ codeWorkspaces:+ codeEnvironmentDecision != null+ ? codeEnvironmentDecision.codeWorkspaces+ : this.options.req.body.codeWorkspaces,},// TODO: PARSE OPTIONS BY PROVIDER, MAY CONTAIN SENSITIVE DATArunOptions,@@ -4310,7 +4314,11 @@ class AgentClient extends BaseClient {// Pin the graph-determining request fields so resume can't rebuild this paused// run on a different agent/tool set (esp. ephemeral agents, whose agent_id is// undefined so the id guard can't tell two configs apart).- requestFingerprint: computeAgentRequestFingerprint(this.options.req?.body ?? {}),+ // Keep the legacy digest in its established field so an old replica can+ // resume pauses written during a rolling deploy; current replicas also+ // enforce the stricter code-environment-aware digest below.+ requestFingerprint: computeLegacyAgentRequestFingerprint(this.options.req?.body ?? {}),+ requestFingerprintV2: computeAgentRequestFingerprint(this.options.req?.body ?? {}),// Persist those same fields verbatim so the resume route can REPLAY them — a// reload/cross-replica resume can't reconstruct the ephemeral config client-side,// so the server restores it and rebuilds the same graph (and the fingerprint matches).@@ -4516,6 +4524,9 @@ class AgentClient extends BaseClient {messageId: this.responseMessageId,conversationId: this.conversationId,parentMessageId: this.parentMessageId,+ codeEnvironmentMode:+ this.options.req.body.codeEnvironmentMode ??+ this.options.req.resolvedConversation?.codeEnvironmentMode,codeWorkspaces:this.options.req.body.codeWorkspaces ??this.options.req.resolvedConversation?.codeWorkspaces,@@ -5300,6 +5311,9 @@ class AgentClient extends BaseClient {messageId: this.responseMessageId,conversationId: this.conversationId,parentMessageId: this.parentMessageId,+ codeEnvironmentMode:+ this.options.req.body.codeEnvironmentMode ??+ this.options.req.resolvedConversation?.codeEnvironmentMode,codeWorkspaces:this.options.req.body.codeWorkspaces ??this.options.req.resolvedConversation?.codeWorkspaces,diff --git a/api/server/controllers/agents/client.test.js b/api/server/controllers/agents/client.test.jsindex 9cc76615c5..54b869ca88 100644--- a/api/server/controllers/agents/client.test.js+++ b/api/server/controllers/agents/client.test.js@@ -78,18 +78,46 @@ describe('AgentClient code approval persistence', () => {},req: {body: { codeApprovalMode: 'acceptEdits' },+ _codeEnvironmentDecision: {+ mode: 'attached',+ codeWorkspaces: [+ { environmentId: 'attached-vm', workspaceId: 'project-a' },+ { environmentId: 'team-vm', workspaceId: 'project-b' },+ ],+ },config: { endpoints: { [EModelEndpoint.agents]: {} } },},};expect(client.getSaveOptions()).toMatchObject({codeApprovalMode: 'acceptEdits',+ codeEnvironmentMode: 'attached',codeWorkspaces: [{ environmentId: 'attached-vm', workspaceId: 'project-a' },{ environmentId: 'team-vm', workspaceId: 'project-b' },],});});++ it('does not combine a normalized no-attached mode with stale request selections', () => {+ const client = Object.create(AgentClient.prototype);+ client.agentConfigs = new Map();+ client.options = {+ endpoint: EModelEndpoint.agents,+ agent: { id: 'attached-agent' },+ req: {+ body: {+ codeWorkspaces: [{ environmentId: 'attached-vm', workspaceId: 'stale-project' }],+ },+ _codeEnvironmentDecision: { mode: 'without_attached' },+ config: { endpoints: { [EModelEndpoint.agents]: {} } },+ },+ };++ const saveOptions = client.getSaveOptions();+ expect(saveOptions.codeEnvironmentMode).toBe('without_attached');+ expect(saveOptions).not.toHaveProperty('codeWorkspaces');+ });});function deferred() {diff --git a/api/server/controllers/agents/openai.js b/api/server/controllers/agents/openai.jsindex 36713ee168..c7659fb526 100644--- a/api/server/controllers/agents/openai.js+++ b/api/server/controllers/agents/openai.js@@ -67,6 +67,7 @@ const {executeAgentRun,waitForAgentExecutionWrites,resolveToolRoleGrants,+ resolveConversationCodeEnvironmentDecision,createTerminalRunErrorObserver,} = require('@librechat/api');const {@@ -456,6 +457,12 @@ const executeOpenAIChatCompletion = async (envelope, { req, res }) => {req.resolvedConversation = conversation;}+ const codeEnvironmentDecision = resolveConversationCodeEnvironmentDecision({+ conversationId,+ requestedMode: request.code_environment_mode,+ requestedSelections: request.code_workspaces,+ conversation: req.resolvedConversation,+ });const parentMessageId = request.parent_message_id ?? null;let mcpParentMessageId;if (@@ -469,7 +476,8 @@ const executeOpenAIChatCompletion = async (envelope, { req, res }) => {const mcpRequestBody = createMCPRuntimeRequestBody({messageId: responseId,conversationId,- codeWorkspaces: request.code_workspaces ?? req.resolvedConversation?.codeWorkspaces,+ codeEnvironmentMode: codeEnvironmentDecision.mode,+ codeWorkspaces: codeEnvironmentDecision.codeWorkspaces,parentMessageId: mcpParentMessageId,});diff --git a/api/server/controllers/agents/request.js b/api/server/controllers/agents/request.jsindex b2e3904d20..d4ea75e173 100644--- a/api/server/controllers/agents/request.js+++ b/api/server/controllers/agents/request.js@@ -44,6 +44,7 @@ const {resolveAgentTurnExecutionPlan,logAgentMemorySnapshot,getCodeWorkspaceSelectionErrorDetails,+ shouldPersistCodeWorkspaceInitializationError,} = require('@librechat/api');const { disposeClient } = require('~/server/cleanup');const {@@ -491,6 +492,7 @@ async function saveErrorTurn(const agentId = endpointOption?.agent_id ?? req.body?.agent_id;const chatProjectId = endpointOption?.chatProjectId ?? req.body?.chatProjectId;const seedConvo = isNewConvo || req.resolvedConversation === null;+ const codeEnvironmentDecision = req._codeEnvironmentDecision;const convoFields = seedConvo? {...(endpoint != null && { endpoint }),@@ -502,6 +504,12 @@ async function saveErrorTurn(...(endpointOption?.spec != null && { spec: endpointOption.spec }),...(agentId != null && { agent_id: agentId }),...(typeof chatProjectId === 'string' && chatProjectId.length > 0 && { chatProjectId }),+ ...(codeEnvironmentDecision?.mode != null && {+ codeEnvironmentMode: codeEnvironmentDecision.mode,+ ...(codeEnvironmentDecision.codeWorkspaces != null && {+ codeWorkspaces: codeEnvironmentDecision.codeWorkspaces,+ }),+ }),}: {};await saveConvo(@@ -1487,6 +1495,7 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTitconst mcpRequestBody = createMCPRuntimeRequestBody({messageId: preallocatedResponseMessageId,conversationId: effectiveConversationId,+ codeEnvironmentMode: req.body.codeEnvironmentMode,codeWorkspaces: resolveRunCodeWorkspaces({conversationId: effectiveConversationId,requestedSelections: req.body.codeWorkspaces,@@ -1920,6 +1929,22 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit});startupTelemetry?.mark('client_initialized');client = result.client;+ const normalizedMCPRequestBody = createMCPRuntimeRequestBody({+ messageId: mcpRequestBody.messageId,+ conversationId: mcpRequestBody.conversationId,+ codeEnvironmentMode: req.body.codeEnvironmentMode,+ codeWorkspaces: req.body.codeWorkspaces,+ ...(Object.prototype.hasOwnProperty.call(mcpRequestBody, 'parentMessageId') && {+ parentMessageId: mcpRequestBody.parentMessageId,+ }),+ });+ if (JSON.stringify(normalizedMCPRequestBody) !== JSON.stringify(mcpRequestBody)) {+ await GenerationJobManager.updateMetadata(+ streamId,+ { mcpRequestBody: normalizedMCPRequestBody },+ jobCreatedAt,+ );+ }if (typeof client?.options?.agent?.id === 'string' &&!isEphemeralAgentId(client.options.agent.id)@@ -3384,7 +3409,13 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTitconst initializationError = initializationFailure? JSON.stringify(initializationFailure): error.message || 'Failed to start generation';- const completionPromise = streamStarted+ const persistInitializationError = shouldPersistCodeWorkspaceInitializationError({+ streamStarted,+ isNewConversation: isNewConvo,+ failureCode: initializationFailure?.code,+ hasValidatedDecision: req._codeEnvironmentDecision != null,+ });+ const completionPromise = persistInitializationError? GenerationJobManager.completeJob(streamId, initializationError, jobCreatedAt, {beforeErrorPublication: () =>saveErrorTurn(req, {diff --git a/api/server/controllers/agents/responses.js b/api/server/controllers/agents/responses.jsindex 367fd04bc0..328052fe04 100644--- a/api/server/controllers/agents/responses.js+++ b/api/server/controllers/agents/responses.js@@ -18,8 +18,6 @@ const {createAgentRunEnvelope,createAgentExecutionContext,createMCPRuntimeRequestBody,- getCodeWorkspaceSelections,- collectReachableAgents,buildAgentScopedContext,buildInlineMemoryContext,buildAgentContextAttachmentsByAgentId,@@ -84,6 +82,7 @@ const {executeAgentRun,waitForAgentExecutionWrites,resolveToolRoleGrants,+ resolveConversationCodeEnvironmentDecision,createTerminalRunErrorObserver,} = require('@librechat/api');const {@@ -449,7 +448,14 @@ async function saveResponseOutput(* @param {object} agent* @returns {Promise<void>}*/-async function saveConversation(req, conversationId, agentId, agent, codeWorkspaces) {+async function saveConversation(+ req,+ conversationId,+ agentId,+ agent,+ codeEnvironmentMode,+ codeWorkspaces,+) {const title = resolveConversationTitle(req, agent?.name || 'Open Responses Conversation');await db.saveConvo({@@ -462,6 +468,7 @@ async function saveConversation(req, conversationId, agentId, agent, codeWorkspaconversationId,endpoint: EModelEndpoint.agents,agent_id: agentId,+ codeEnvironmentMode,...(codeWorkspaces !== undefined && { codeWorkspaces }),...(title != null && { title }),model: agent?.model,@@ -705,11 +712,18 @@ const executeResponse = async (envelope, { req, res }) => {}}+ const codeEnvironmentDecision = resolveConversationCodeEnvironmentDecision({+ conversationId,+ requestedMode: request.code_environment_mode,+ requestedSelections: request.code_workspaces,+ conversation: req.resolvedConversation,+ });const parentMessageId = null;const mcpRequestBody = createMCPRuntimeRequestBody({messageId: responseId,conversationId,- codeWorkspaces: request.code_workspaces ?? req.resolvedConversation?.codeWorkspaces,+ codeEnvironmentMode: codeEnvironmentDecision.mode,+ codeWorkspaces: codeEnvironmentDecision.codeWorkspaces,});const agentsEConfig = appConfig?.endpoints?.[EModelEndpoint.agents];const ordinaryToolCancellationEnabled =@@ -1342,9 +1356,8 @@ const executeResponse = async (envelope, { req, res }) => {conversationId,agentId,agent,- getCodeWorkspaceSelections(- collectReachableAgents(runAgents).map((config) => config.codeExecutionContext),- ),+ codeEnvironmentDecision.mode,+ codeEnvironmentDecision.codeWorkspaces,);// Save input messages@@ -1582,9 +1595,8 @@ const executeResponse = async (envelope, { req, res }) => {conversationId,agentId,agent,- getCodeWorkspaceSelections(- collectReachableAgents(runAgents).map((config) => config.codeExecutionContext),- ),+ codeEnvironmentDecision.mode,+ codeEnvironmentDecision.codeWorkspaces,);await saveInputMessages(req, conversationId, inputMessages, agentId);diff --git a/api/server/controllers/agents/resume.js b/api/server/controllers/agents/resume.jsindex 793e89568b..284027e51d 100644--- a/api/server/controllers/agents/resume.js+++ b/api/server/controllers/agents/resume.js@@ -23,6 +23,7 @@ const {findDisallowedDecisions,findIncompleteDecisions,computeAgentRequestFingerprint,+ computeLegacyAgentRequestFingerprint,captureAgentCheckpointGeneration,deleteAgentCheckpoint,buildAbortedResponseMetadata,@@ -917,7 +918,13 @@ const ResumeAgentController = async (req, res, next, initializeClient, addTitle)// when the paused action carries a fingerprint (in-flight pauses from before this// change won't), and recomputed from the resume body's graph-determining fields.const pinnedFingerprint = pendingAction.requestFingerprint;- if (pinnedFingerprint && pinnedFingerprint !== computeAgentRequestFingerprint(req.body ?? {})) {+ const pinnedFingerprintV2 = pendingAction.requestFingerprintV2;+ const legacyFingerprint = computeLegacyAgentRequestFingerprint(req.body ?? {});+ const currentFingerprint = computeAgentRequestFingerprint(req.body ?? {});+ if (+ (pinnedFingerprint && pinnedFingerprint !== legacyFingerprint) ||+ (pinnedFingerprintV2 && pinnedFingerprintV2 !== currentFingerprint)+ ) {return sendGenerationJson(res,403,@@ -1822,6 +1829,8 @@ const ResumeAgentController = async (req, res, next, initializeClient, addTitle)createMCPRuntimeRequestBody({messageId: job.metadata.responseMessageId,conversationId: streamId,+ codeEnvironmentMode:+ req.body.codeEnvironmentMode ?? req.resolvedConversation?.codeEnvironmentMode,codeWorkspaces: req.body.codeWorkspaces ?? req.resolvedConversation?.codeWorkspaces,parentMessageId: job.metadata.userMessage?.messageId ?? Constants.NO_PARENT,});diff --git a/api/server/routes/__tests__/config.spec.js b/api/server/routes/__tests__/config.spec.jsindex 529879ce9a..0ef6122842 100644--- a/api/server/routes/__tests__/config.spec.js+++ b/api/server/routes/__tests__/config.spec.js@@ -116,6 +116,7 @@ afterEach(() => {delete process.env.LANGFUSE_TRACING_ENABLED;delete process.env.LANGFUSE_SAMPLE_RATE;delete process.env.TENANT_ISOLATION_STRICT;+ delete process.env.CODE_ENVIRONMENT_DECISION_VERSION;});describe('GET /api/config', () => {@@ -350,8 +351,32 @@ describe('GET /api/config', () => {expect(response.body.modelSpecs).toEqual({ list: [{ name: 'test-spec' }] });expect(response.body.balance).toEqual({ enabled: true, startBalance: 10000 });expect(response.body.webSearch).toEqual({ searchProvider: 'tavily' });+ expect(response.body.codeEnvironmentDecisionVersion).toBeUndefined();});+ it('advertises code environment decisions only after deployment-wide activation', async () => {+ mockGetAppConfig.mockResolvedValue(baseAppConfig);+ process.env.CODE_ENVIRONMENT_DECISION_VERSION = '1';+ const app = createApp(mockUser);++ const response = await request(app).get('/api/config');++ expect(response.body.codeEnvironmentDecisionVersion).toBe(1);+ });++ it.each(['0', '2', '1.0', 'true'])(+ 'does not advertise unsupported code environment decision version %s',+ async (version) => {+ mockGetAppConfig.mockResolvedValue(baseAppConfig);+ process.env.CODE_ENVIRONMENT_DECISION_VERSION = version;+ const app = createApp(mockUser);++ const response = await request(app).get('/api/config');++ expect(response.body.codeEnvironmentDecisionVersion).toBeUndefined();+ },+ );+it('should strip private prompt fields from model spec presets', async () => {mockGetAppConfig.mockResolvedValue({...baseAppConfig,diff --git a/api/server/routes/config.js b/api/server/routes/config.jsindex 4f584b40c5..99ab46ad4e 100644--- a/api/server/routes/config.js+++ b/api/server/routes/config.js@@ -12,6 +12,7 @@ const {excludeHiddenModelSpecs,isFileSnapshotEnabled,getEndpointsDropParamsMap,+ resolveCodeEnvironmentDecisionVersion,} = require('@librechat/api');const { EModelEndpoint, defaultSocialLogins } = require('librechat-data-provider');const { logger, getTenantId, SystemCapabilities } = require('@librechat/data-schemas');@@ -249,6 +250,9 @@ router.get('/', async function (req, res) {}const appConfig = await getAppConfig(getAppConfigOptionsFromUser(req.user));+ const codeEnvironmentDecisionVersion = resolveCodeEnvironmentDecisionVersion(+ process.env.CODE_ENVIRONMENT_DECISION_VERSION,+ );const endpointsDropParamsMap = getEndpointsDropParamsMap(appConfig?.endpoints);@@ -309,6 +313,7 @@ router.get('/', async function (req, res) {langfuseConnectionAccess,insightsEnabled: isEnabled(process.env.ENABLE_INSIGHTS),compactionEnabled: appConfig?.summarization?.enabled !== false,+ ...(codeEnvironmentDecisionVersion != null ? { codeEnvironmentDecisionVersion } : {}),...(cloudFront ? { cloudFront } : {}),...(rum ? { rum } : {}),fileUploadSseEnabled: isEnabled(process.env.FILE_UPLOAD_SSE_ENABLED),diff --git a/api/server/services/Endpoints/agents/initialize.js b/api/server/services/Endpoints/agents/initialize.jsindex 286b0b412f..aad58efc5e 100644--- a/api/server/services/Endpoints/agents/initialize.js+++ b/api/server/services/Endpoints/agents/initialize.js@@ -3,6 +3,7 @@ const { createContentAggregator, GraphNodeKeys } = require('@librechat/agents');const {resolveSender,resolveRunConversation,+ resolveConversationCodeEnvironmentDecision,createConcurrencyLimiter,loadSkillStates,initializeAgent,@@ -23,6 +24,8 @@ const {getLazySubagentConfigId,resolveCodeExecutionContext,resolveCodeExecutionWorkspaceContext,+ optsOutOfAttachedCodeEnvironment,+ isImplicitStatefulCodeRouteAvailable,createStatefulCodeEnvironmentPolicyError,buildSubagentThreadTaskConfig,backgroundCompletionWakeupsEnabled,@@ -206,7 +209,7 @@ const initializeClient = async ({/** The normal controller resolves this once for timestamp anchoring. Reuse* that trusted document for child-thread execution policy; resume and direct* callers fall back to the same owner-scoped lookup. */- const runtimeRequestBody = requestBody ?? req.body;+ let runtimeRequestBody = requestBody ?? req.body;const conversationId = runtimeRequestBody?.conversationId;const requestConversationPromise = resolveRunConversation({request: req,@@ -584,6 +587,25 @@ const initializeClient = async ({]);/** Preserve the owner-scoped fallback for loaders that share this request. */req.resolvedConversation = requestConversation;+ const codeEnvironmentDecision = resolveConversationCodeEnvironmentDecision({+ conversationId,+ requestedMode: runtimeRequestBody?.codeEnvironmentMode,+ requestedSelections: runtimeRequestBody?.codeWorkspaces,+ conversation: requestConversation,+ });+ /** Trusted, normalized pair used by every persistence path, including init failures. */+ req._codeEnvironmentDecision = codeEnvironmentDecision;+ runtimeRequestBody = {+ ...runtimeRequestBody,+ codeEnvironmentMode: codeEnvironmentDecision.mode,+ codeWorkspaces: codeEnvironmentDecision.codeWorkspaces,+ };+ req.body.codeEnvironmentMode = codeEnvironmentDecision.mode;+ if (codeEnvironmentDecision.codeWorkspaces == null) {+ delete req.body.codeWorkspaces;+ } else {+ req.body.codeWorkspaces = codeEnvironmentDecision.codeWorkspaces;+ }delete endpointOption.agent;/** The deployment switch AND the role grant. `initializeAgent` rebuilds@@ -1032,8 +1054,21 @@ const initializeClient = async ({});const toLazySubagentMetadata = async (agent) => {+ const configuredCodeEnvironments =+ appConfig?.endpoints?.[EModelEndpoint.agents]?.statefulCodeSessions?.environments;+ const attachedEnvironmentOptOut = optsOutOfAttachedCodeEnvironment(+ agent,+ runtimeRequestBody,+ configuredCodeEnvironments,+ isImplicitStatefulCodeRouteAvailable(+ process.env.CODE_ENVIRONMENT_DECISION_VERSION,+ process.env.LIBRECHAT_CODE_BASEURL_STATEFUL,+ ),+ );const lazyCodeEnvAvailable =- codeEnvAvailable === true && agent.tools?.includes(Tools.execute_code) === true;+ codeEnvAvailable === true &&+ agent.tools?.includes(Tools.execute_code) === true &&+ !attachedEnvironmentOptOut;const statefulCodeSessions =statefulSessionsAvailable === true &&lazyCodeEnvAvailable &&@@ -1046,23 +1081,17 @@ const initializeClient = async ({) {throw createStatefulCodeEnvironmentPolicyError(statefulCodeEnvironment);}- const configuredCodeEnvironments =- appConfig?.endpoints?.[EModelEndpoint.agents]?.statefulCodeSessions?.environments;- const hasConfiguredCodeEnvironment =- agent.code_environment_id != null ||- configuredCodeEnvironments?.some((environment) => environment.default === true) === true;- const baseCodeExecutionContext =- lazyCodeEnvAvailable && (!statefulCodeSessions || hasConfiguredCodeEnvironment)- ? resolveCodeExecutionContext({- statefulSessions: statefulCodeSessions,- environment: statefulCodeEnvironment,- environmentId: agent.code_environment_id,- environments: configuredCodeEnvironments,- userId,- agentId: agent.id,- conversationId,- })- : undefined;+ const baseCodeExecutionContext = lazyCodeEnvAvailable+ ? resolveCodeExecutionContext({+ statefulSessions: statefulCodeSessions,+ environment: statefulCodeEnvironment,+ environmentId: agent.code_environment_id,+ environments: configuredCodeEnvironments,+ userId,+ agentId: agent.id,+ conversationId,+ })+ : undefined;const codeExecutionContext = baseCodeExecutionContext? await resolveCodeExecutionWorkspaceContext({context: baseCodeExecutionContext,diff --git a/api/server/services/Endpoints/agents/initialize.spec.js b/api/server/services/Endpoints/agents/initialize.spec.jsindex 836268ab19..52241abda3 100644--- a/api/server/services/Endpoints/agents/initialize.spec.js+++ b/api/server/services/Endpoints/agents/initialize.spec.js@@ -896,12 +896,17 @@ describe('initializeClient — subagent loading', () => {requestBody,});- expect(mockInitializeAgent.mock.calls[0][0].requestBody).toBe(requestBody);- expect(agentClientArgs.mcpRequestBody).toBe(requestBody);+ const normalizedRequestBody = mockInitializeAgent.mock.calls[0][0].requestBody;+ expect(normalizedRequestBody).toEqual({+ ...requestBody,+ codeEnvironmentMode: 'without_attached',+ codeWorkspaces: undefined,+ });+ expect(agentClientArgs.mcpRequestBody).toBe(normalizedRequestBody);await capturedToolExecuteOptions.loadTools([], PRIMARY_ID);expect(mockLoadToolsForExecution).toHaveBeenCalledWith(- expect.objectContaining({ requestBody }),+ expect.objectContaining({ requestBody: normalizedRequestBody }),);});@@ -1460,20 +1465,74 @@ describe('initializeClient — subagent loading', () => {const req = makeSubagentReq();req.config.endpoints.agents.capabilities.push('execute_code', 'stateful_code_sessions');req.config.endpoints.agents.statefulCodeSessions = { allowedEnvironments: ['user'] };+ process.env.CODE_ENVIRONMENT_DECISION_VERSION = '1';+ process.env.LIBRECHAT_CODE_BASEURL_STATEFUL = 'https://stateful-code.example.com/v1/';- await expect(- initializeClient({+ try {+ await expect(+ initializeClient({+ req,+ res: {},+ signal: new AbortController().signal,+ endpointOption: makeEndpointOption(),+ }),+ ).rejects.toMatchObject({+ code: ErrorTypes.STATEFUL_CODE_ENVIRONMENT_NOT_ALLOWED,+ });++ expect(agentClientArgs).toBeUndefined();+ expect(mockInitializeAgent).toHaveBeenCalledTimes(1);+ } finally {+ delete process.env.CODE_ENVIRONMENT_DECISION_VERSION;+ delete process.env.LIBRECHAT_CODE_BASEURL_STATEFUL;+ }+ });++ it('binds a versioned implicit stateful route into lazy subagent metadata', async () => {+ const subAgent = await createAgent({+ id: SUBAGENT_ID,+ name: 'Implicit Stateful Subagent',+ provider: 'openai',+ model: 'gpt-4',+ author: new mongoose.Types.ObjectId(),+ tools: ['execute_code'],+ stateful_code_sessions: true,+ stateful_code_environment: 'user',+ });+ await grantView(subAgent);+ mockInitializeAgent.mockResolvedValue(+ makePrimaryConfig({+ subagents: { enabled: true, allowSelf: false, agent_ids: [SUBAGENT_ID] },+ }),+ );+ const req = makeSubagentReq();+ req.body.codeEnvironmentMode = 'without_attached';+ req.config.endpoints.agents.capabilities.push('execute_code', 'stateful_code_sessions');+ req.config.endpoints.agents.statefulCodeSessions = { allowedEnvironments: ['user'] };+ process.env.CODE_ENVIRONMENT_DECISION_VERSION = '1';+ process.env.LIBRECHAT_CODE_BASEURL_STATEFUL = 'https://stateful-code.example.com/v1/';++ try {+ await initializeClient({req,res: {},signal: new AbortController().signal,endpointOption: makeEndpointOption(),- }),- ).rejects.toMatchObject({- code: ErrorTypes.STATEFUL_CODE_ENVIRONMENT_NOT_ALLOWED,- });+ });- expect(agentClientArgs).toBeUndefined();- expect(mockInitializeAgent).toHaveBeenCalledTimes(1);+ expect(agentClientArgs.agent.lazySubagentConfigs[0]).toEqual(+ expect.objectContaining({+ codeExecutionContext: expect.objectContaining({+ baseUrl: 'https://stateful-code.example.com/v1',+ executionProfile: 'stateful',+ statefulSessions: true,+ }),+ }),+ );+ } finally {+ delete process.env.CODE_ENVIRONMENT_DECISION_VERSION;+ delete process.env.LIBRECHAT_CODE_BASEURL_STATEFUL;+ }});it.each([@@ -1582,7 +1641,8 @@ describe('initializeClient — subagent loading', () => {signal: new AbortController().signal,endpointOption: makeEndpointOption(),});- if (!registered) {+ const defaultsWithoutAttached = source === 'resolved-null' || source === 'other-owner';+ if (!registered && !defaultsWithoutAttached) {await expect(initialization).rejects.toMatchObject({code: ErrorTypes.CODE_WORKSPACE_UNAVAILABLE,});@@ -1590,6 +1650,13 @@ describe('initializeClient — subagent loading', () => {return;}await initialization;+ if (defaultsWithoutAttached) {+ expect(fetchSpy).not.toHaveBeenCalled();+ expect(agentClientArgs.mcpRequestBody).toEqual(+ expect.objectContaining({ codeEnvironmentMode: 'without_attached' }),+ );+ return;+ }if (source === 'fallback' || source.startsWith('override')) {mockInitializeAgent.mockImplementationOnce(async (params) => {expect(params.req.resolvedConversation.codeWorkspaces).toEqual([@@ -2019,6 +2086,19 @@ describe('initializeClient — subagent loading', () => {'tool_intents','stateful_code_sessions',);+ req.config.endpoints.agents.statefulCodeSessions = {+ allowedEnvironments: ['user'],+ environments: [+ {+ id: 'managed-code',+ name: 'Managed code',+ type: 'managed',+ baseURL: 'https://stateful-code.example.com/v1',+ default: true,+ },+ ],+ };+ mockGetAppConfig.mockResolvedValue(req.config);const { userMCPAuthMap } = await initializeClient({req,res: {},diff --git a/client/src/components/Chat/Input/ChatForm.tsx b/client/src/components/Chat/Input/ChatForm.tsxindex f7e640a21a..6bc3a9715b 100644--- a/client/src/components/Chat/Input/ChatForm.tsx+++ b/client/src/components/Chat/Input/ChatForm.tsx@@ -650,6 +650,28 @@ const ChatForm = memo(function ChatForm({onRestoreToComposer={restoreReclaimedSteer}/>)}+ {(project ||+ (codeWorkspace.required && (!codeWorkspace.locked || !codeWorkspace.canSubmit))) && (+ <div+ data-testid="composer-context-rail"+ className={cn(+ 'mx-4 -mb-3 flex min-w-0 flex-wrap items-center gap-1 rounded-t-2xl',+ 'border border-border-light bg-surface-secondary px-2 pb-4 pt-1',+ isRTL && 'flex-row-reverse',+ )}+ >+ {project ? <ProjectLandingChip project={project} /> : null}+ {codeWorkspace.required && (!codeWorkspace.locked || !codeWorkspace.canSubmit) ? (+ <div className="min-w-0 px-1 pt-1">+ <CodeWorkspaceMenu+ setConversation={setConversation}+ workspace={codeWorkspace}+ disabled={disableInputs || isSubmitting}+ />+ </div>+ ) : null}+ </div>+ )}<div className={cn('flex w-full items-center', isRTL && 'flex-row-reverse')}><Mentionindex={index}@@ -703,7 +725,6 @@ const ChatForm = memo(function ChatForm({isTemporary && 'border-series-6/50 bg-series-6/10 high-contrast:border-series-6',)}>- {project ? <ProjectLandingChip project={project} /> : null}<TextareaHeader addedConvo={addedConvo} setAddedConvo={setAddedConvo} /><PendingManualSkillsChips conversationId={conversationId} />{quotesEnabled && (@@ -782,11 +803,6 @@ const ChatForm = memo(function ChatForm({onFocus={handleTextareaFocus}onBlur={handleTextareaBlur}aria-label={localize('com_ui_message_input')}- aria-describedby={- codeWorkspace.state === 'choose' || codeWorkspace.state === 'missing'- ? `code-workspace-hint-${index}`- : undefined- }onClick={handleFocusOrClick}style={{ height: 44, overflowY: 'auto' }}className={cn(@@ -805,15 +821,6 @@ const ChatForm = memo(function ChatForm({</div></div>)}- {(codeWorkspace.state === 'choose' || codeWorkspace.state === 'missing') && (- <p- id={`code-workspace-hint-${index}`}- role="status"- className="px-5 pb-2 text-sm text-text-secondary"- >- {localize('com_error_code_workspace_required')}- </p>- )}<divclassName={cn('@container flex flex-wrap items-center gap-2 px-2 pb-2',@@ -850,12 +857,6 @@ const ChatForm = memo(function ChatForm({setConversation={setConversation}disabled={disableInputs || isSubmitting}/>- <CodeWorkspaceMenu- conversation={conversation}- setConversation={setConversation}- workspace={codeWorkspace}- disabled={disableInputs || isSubmitting}- />{index === 0 && conversationId != null && (<PendingToolApprovalButton conversationId={conversationId} />)}@@ -964,6 +965,7 @@ function ChatFormWrapper({conversation?.model,conversation?.maxContextTokens,conversation?.codeApprovalMode,+ conversation?.codeEnvironmentMode,conversation?.codeWorkspaces,hasMessages,],diff --git a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsxindex 36ae9f01e6..e7f0560f27 100644--- a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx+++ b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx@@ -1,4 +1,3 @@-import { useEffect } from 'react';import * as Ariakit from '@ariakit/react';import { Check, ChevronDown, Folder, FolderX } from 'lucide-react';import { TooltipAnchor, composerControlClasses } from '@librechat/client';@@ -14,15 +13,14 @@ const stateLabels: Partial<Record<CodeWorkspaceResult['state'], TranslationKeys>missing: 'com_ui_code_workspace_missing',unavailable: 'com_ui_code_workspace_unavailable',unsupported: 'com_ui_code_workspace_unsupported',+ without_attached: 'com_ui_code_workspace_without_attached',};export default function CodeWorkspaceMenu({- conversation,setConversation,workspace,disabled,}: {- conversation: TConversation | null;setConversation: SetterOrUpdater<TConversation | null>;workspace: CodeWorkspaceResult;disabled: boolean;@@ -31,25 +29,6 @@ export default function CodeWorkspaceMenu({const menuStore = Ariakit.useMenuStore({ focusLoop: true, placement: 'top-start' });const isOpen = menuStore.useState('open');- /** Pin resolved defaults to this chat; later preference changes cannot move it. */- useEffect(() => {- if (conversation?.codeWorkspaces != null || workspace.selections == null) return;- setConversation((current) =>- current == null ||- current.codeWorkspaces != null ||- current.conversationId !== conversation?.conversationId ||- current.agent_id !== conversation?.agent_id- ? current- : { ...current, codeWorkspaces: workspace.selections },- );- }, [- conversation?.codeWorkspaces,- conversation?.conversationId,- conversation?.agent_id,- setConversation,- workspace.selections,- ]);-if (!workspace.required) return null;const environmentIds = new Set(workspace.environments.map(({ environment }) => environment.id));@@ -57,24 +36,39 @@ export default function CodeWorkspaceMenu({workspace.rememberSelection(selection);setConversation((current) => {if (current == null) return current;- const retained = (current.codeWorkspaces ?? []).filter(+ const retained = (current.codeWorkspaces ?? workspace.selections ?? []).filter(({ environmentId }) =>environmentIds.has(environmentId) && environmentId !== selection.environmentId,);return {...current,+ codeEnvironmentMode: 'attached',codeWorkspaces: [...retained, selection].sort((a, b) =>a.environmentId.localeCompare(b.environmentId),),};});};+ const selectWithoutAttached = () => {+ setConversation((current) =>+ current == null+ ? current+ : {+ ...current,+ codeEnvironmentMode: 'without_attached',+ codeWorkspaces: undefined,+ },+ );+ };const onlyEnvironment = workspace.environments.length === 1 ? workspace.environments[0] : null;const onlyDescriptor = onlyEnvironment?.workspaces.find(({ id }) => id === onlyEnvironment.selected?.workspaceId,);const labelKey = stateLabels[workspace.state];- let label = onlyDescriptor?.name ?? onlyDescriptor?.id;+ let label =+ workspace.mode === 'without_attached'+ ? localize('com_ui_code_workspace_without_attached')+ : (onlyDescriptor?.name ?? onlyDescriptor?.id);if (label == null && workspace.state === 'ready') {label = localize('com_ui_code_workspaces_selected', {0: workspace.selections?.length ?? 0,@@ -82,9 +76,33 @@ export default function CodeWorkspaceMenu({} else if (label == null) {label = labelKey ? localize(labelKey) : localize('com_ui_code_workspace_choose');}- const canChoose = workspace.environments.some(({ workspaces }) => workspaces.length > 0);const Icon =- workspace.state === 'missing' || workspace.state === 'unavailable' ? FolderX : Folder;+ workspace.mode === 'without_attached' ||+ workspace.state === 'missing' ||+ workspace.state === 'unavailable'+ ? FolderX+ : Folder;++ if (workspace.locked) {+ if (workspace.canSubmit) return null;+ const recovery = localize('com_ui_code_workspace_locked_recovery');+ return (+ <TooltipAnchor+ description={recovery}+ render={+ <div+ data-testid="code-workspace-locked-status"+ role="status"+ aria-label={`${label}. ${recovery}`}+ className={cn(composerControlClasses(), 'min-w-0 max-w-full cursor-default px-2.5')}+ />+ }+ >+ <Icon className="size-4 shrink-0 text-text-secondary" aria-hidden="true" />+ <span className="min-w-0 max-w-[16rem] truncate">{label}</span>+ </TooltipAnchor>+ );+ }return (<Ariakit.MenuProvider store={menuStore}>@@ -93,100 +111,131 @@ export default function CodeWorkspaceMenu({disabled={isOpen}render={<Ariakit.MenuButton- disabled={disabled || !canChoose}+ disabled={disabled}data-testid="code-workspace"aria-label={`${localize('com_ui_code_workspace')}: ${label}`}className={cn(composerControlClasses(),'min-w-0 max-w-full px-2.5 md:px-theme-normal',isOpen && 'bg-surface-hover',- (disabled || !canChoose) && 'cursor-not-allowed opacity-50',+ disabled && 'cursor-not-allowed opacity-50',)}/>}><Icon className="size-4 shrink-0 text-text-secondary" aria-hidden="true" /><span className="min-w-0 max-w-[12rem] truncate">{label}</span>- {canChoose && (- <ChevronDown- className={cn(- 'size-3 shrink-0 text-text-secondary transition-transform',- isOpen && 'rotate-180',- )}- aria-hidden="true"- />- )}- </TooltipAnchor>- {canChoose && (- <Ariakit.Menu- portal={true}- gutter={8}- unmountOnHide={true}+ <ChevronDownclassName={cn(- 'z-50 flex min-w-[280px] max-w-[min(360px,calc(100vw-2rem))] flex-col rounded-xl',- 'max-h-[var(--popover-available-height)] overflow-y-auto border border-border-light bg-presentation p-1.5 shadow-lg',- 'origin-bottom opacity-0 transition-[opacity,transform] duration-200 ease-out',- 'data-[enter]:scale-100 data-[enter]:opacity-100',- 'scale-95 data-[leave]:scale-95 data-[leave]:opacity-0',+ 'size-3 shrink-0 text-text-secondary transition-transform',+ isOpen && 'rotate-180',)}+ aria-hidden="true"+ />+ </TooltipAnchor>+ <Ariakit.Menu+ portal={true}+ gutter={8}+ unmountOnHide={true}+ className={cn(+ 'z-50 flex min-w-[280px] max-w-[min(360px,calc(100vw-2rem))] flex-col rounded-xl',+ 'max-h-[var(--popover-available-height)] overflow-y-auto border border-border-light bg-presentation p-1.5 shadow-lg',+ 'origin-bottom opacity-0 transition-[opacity,transform] duration-200 ease-out',+ 'data-[enter]:scale-100 data-[enter]:opacity-100',+ 'scale-95 data-[leave]:scale-95 data-[leave]:opacity-0',+ )}+ >+ <Ariakit.MenuHeading+ render={<div />}+ className="px-2.5 py-1.5 text-xs font-medium text-text-secondary">- {workspace.environments.map(({ environment, state, workspaces, selected }) => (- <div key={environment.id}>- <Ariakit.MenuHeading- render={<div />}- className="px-2.5 py-1.5 text-xs font-medium text-text-secondary"- >- {environment.name ?? environment.id}- </Ariakit.MenuHeading>- {workspaces.length === 0 && (- <div className="px-2.5 py-2 text-sm text-text-secondary">- {localize(stateLabels[state] ?? 'com_ui_code_workspace_unavailable')}- </div>- )}- {workspaces.map((descriptor) => {- const isSelected = descriptor.id === selected?.workspaceId;- return (- <Ariakit.MenuItemRadio- key={descriptor.id}- name={`codeWorkspace:${environment.id}`}- value={descriptor.id}- checked={isSelected}- hideOnClick={true}- onChange={() =>- selectWorkspace({ environmentId: environment.id, workspaceId: descriptor.id })- }- className={cn(- 'group flex w-full cursor-pointer items-start gap-3 rounded-lg px-2.5 py-2',- 'outline-none transition-colors duration-theme-fast',- 'hover:bg-surface-hover data-[active-item]:bg-surface-hover',- isSelected && 'bg-surface-active-alt',+ {localize('com_ui_code_environment')}+ </Ariakit.MenuHeading>+ {workspace.supportsEnvironmentDecisions && (+ <Ariakit.MenuItemRadio+ name="codeEnvironmentMode"+ value="without_attached"+ checked={workspace.mode === 'without_attached'}+ hideOnClick={true}+ onChange={selectWithoutAttached}+ className={cn(+ 'group flex w-full cursor-pointer items-start gap-3 rounded-lg px-2.5 py-2',+ 'outline-none transition-colors duration-theme-fast',+ 'hover:bg-surface-hover data-[active-item]:bg-surface-hover',+ workspace.mode === 'without_attached' && 'bg-surface-active-alt',+ )}+ >+ <FolderX className="mt-0.5 size-4 shrink-0 text-text-secondary" aria-hidden="true" />+ <div className="min-w-0 flex-1 text-left">+ <div className="truncate text-sm font-medium text-text-primary">+ {localize('com_ui_code_workspace_without_attached')}+ </div>+ <p className="text-xs text-text-secondary">+ {localize('com_ui_code_workspace_without_attached_info')}+ </p>+ </div>+ {workspace.mode === 'without_attached' && (+ <Check className="mt-0.5 size-4 shrink-0 text-text-primary" aria-hidden="true" />+ )}+ </Ariakit.MenuItemRadio>+ )}+ {workspace.environments.map(({ environment, state, workspaces, selected }) => (+ <div key={environment.id}>+ <Ariakit.MenuHeading+ render={<div />}+ className="px-2.5 py-1.5 text-xs font-medium text-text-secondary"+ >+ {environment.name ?? environment.id}+ </Ariakit.MenuHeading>+ {workspaces.length === 0 && (+ <div className="px-2.5 py-2 text-sm text-text-secondary">+ {localize(stateLabels[state] ?? 'com_ui_code_workspace_unavailable')}+ </div>+ )}+ {workspaces.map((descriptor) => {+ const isSelected =+ workspace.mode === 'attached' && descriptor.id === selected?.workspaceId;+ return (+ <Ariakit.MenuItemRadio+ key={descriptor.id}+ name={`codeWorkspace:${environment.id}`}+ value={descriptor.id}+ checked={isSelected}+ hideOnClick={true}+ onChange={() =>+ selectWorkspace({ environmentId: environment.id, workspaceId: descriptor.id })+ }+ className={cn(+ 'group flex w-full cursor-pointer items-start gap-3 rounded-lg px-2.5 py-2',+ 'outline-none transition-colors duration-theme-fast',+ 'hover:bg-surface-hover data-[active-item]:bg-surface-hover',+ isSelected && 'bg-surface-active-alt',+ )}+ >+ <Folder+ className="mt-0.5 size-4 shrink-0 text-text-secondary"+ aria-hidden="true"+ />+ <div className="min-w-0 flex-1 text-left">+ <div className="truncate text-sm font-medium text-text-primary">+ {descriptor.name ?? descriptor.id}+ </div>+ {descriptor.name && (+ <p className="truncate text-xs text-text-secondary">{descriptor.id}</p>)}- >- <Folder- className="mt-0.5 size-4 shrink-0 text-text-secondary"+ </div>+ {isSelected && (+ <Check+ className="mt-0.5 size-4 shrink-0 text-text-primary"aria-hidden="true"/>- <div className="min-w-0 flex-1 text-left">- <div className="truncate text-sm font-medium text-text-primary">- {descriptor.name ?? descriptor.id}- </div>- {descriptor.name && (- <p className="truncate text-xs text-text-secondary">{descriptor.id}</p>- )}- </div>- {isSelected && (- <Check- className="mt-0.5 size-4 shrink-0 text-text-primary"- aria-hidden="true"- />- )}- </Ariakit.MenuItemRadio>- );- })}- </div>- ))}- </Ariakit.Menu>- )}+ )}+ </Ariakit.MenuItemRadio>+ );+ })}+ </div>+ ))}+ </Ariakit.Menu></Ariakit.MenuProvider>);}diff --git a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsxindex 3a7408f175..f6fd8cc580 100644--- a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx+++ b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx@@ -23,7 +23,7 @@ jest.mock('@librechat/client', () => {});const conversation = {- conversationId: 'conversation-1',+ conversationId: 'new',endpoint: 'agents',agent_id: 'agent-1',title: 'Code',@@ -39,6 +39,9 @@ function workspace(overrides: Partial<CodeWorkspaceResult> = {}): CodeWorkspaceRconst selected = { environmentId: environment.id, workspaceId: 'project-a' };return {required: true,+ supportsEnvironmentDecisions: true,+ locked: false,+ mode: 'attached',state: 'ready',canSubmit: true,environments: [@@ -51,77 +54,154 @@ function workspace(overrides: Partial<CodeWorkspaceResult> = {}): CodeWorkspaceR],selections: [selected],resolveSelections: () => [selected],- resolveSubmission: () => ({ codeWorkspaces: [selected] }),+ resolveSubmission: () => ({ codeEnvironmentMode: 'attached', codeWorkspaces: [selected] }),rememberSelection: jest.fn(),...overrides,};}describe('CodeWorkspaceMenu', () => {- test('stores one unambiguous initial workspace on the conversation', () => {+ test('shows a suggested workspace without committing the conversation decision', () => {const setConversation = jest.fn();render(<CodeWorkspaceMenu- conversation={conversation}setConversation={setConversation}workspace={workspace()}disabled={false}/>,);- const update = setConversation.mock.calls[0][0];- expect(update(conversation)).toEqual({- ...conversation,- codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],- });- const navigated = { ...conversation, agent_id: 'different-agent' };- expect(update(navigated)).toBe(navigated);- const differentChat = { ...conversation, conversationId: 'different-chat' };- expect(update(differentChat)).toBe(differentChat);+ expect(setConversation).not.toHaveBeenCalled();expect(screen.getByTestId('code-workspace')).toHaveTextContent('Project A');});- test('keeps a missing binding until the user explicitly selects a replacement', async () => {- const savedConversation = {- ...conversation,- codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'removed-project' }],- };+ test('allows working without an attached workspace even while the worker is unavailable', async () => {const setConversation = jest.fn();- const rememberSelection = jest.fn();render(<CodeWorkspaceMenu- conversation={savedConversation}setConversation={setConversation}workspace={workspace({- state: 'missing',+ mode: undefined,+ state: 'unavailable',selections: undefined,environments: [{environment,- state: 'missing',- workspaces: [{ id: 'project-a', name: 'Project A' }],+ state: 'unavailable',+ workspaces: [],selected: undefined,},],- rememberSelection,})}disabled={false}/>,);- expect(setConversation).not.toHaveBeenCalled();- expect(screen.getByTestId('code-workspace')).toHaveTextContent('com_ui_code_workspace_missing');await userEvent.click(screen.getByTestId('code-workspace'));- await userEvent.click(await screen.findByText('Project A'));+ await userEvent.click(await screen.findByText('com_ui_code_workspace_without_attached'));++ const update = setConversation.mock.calls[0][0];+ expect(update(conversation)).toEqual({+ ...conversation,+ codeEnvironmentMode: 'without_attached',+ codeWorkspaces: undefined,+ });+ });++ test('does not offer selection-less decisions before the API advertises support', async () => {+ render(+ <CodeWorkspaceMenu+ setConversation={jest.fn()}+ workspace={workspace({ supportsEnvironmentDecisions: false })}+ disabled={false}+ />,+ );++ await userEvent.click(screen.getByTestId('code-workspace'));++ expect(+ screen.queryByRole('menuitemradio', { name: /com_ui_code_workspace_without_attached/ }),+ ).not.toBeInTheDocument();+ expect(screen.getByRole('menuitemradio', { name: /Project A/ })).toBeInTheDocument();+ });++ test('commits an explicit attached-workspace choice only when the user selects it', async () => {+ const setConversation = jest.fn();+ const rememberSelection = jest.fn();+ render(+ <CodeWorkspaceMenu+ setConversation={setConversation}+ workspace={workspace({ mode: undefined, state: 'choose', rememberSelection })}+ disabled={false}+ />,+ );++ await userEvent.click(screen.getByTestId('code-workspace'));+ await userEvent.click((await screen.findAllByText('Project A'))[1]);expect(rememberSelection).toHaveBeenCalledWith({environmentId: 'personal-vm',workspaceId: 'project-a',});const update = setConversation.mock.calls[0][0];- expect(update(savedConversation)).toEqual({- ...savedConversation,+ expect(update(conversation)).toEqual({+ ...conversation,+ codeEnvironmentMode: 'attached',codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],});});++ test('does not mark a suggested workspace selected in no-attached mode', async () => {+ render(+ <CodeWorkspaceMenu+ setConversation={jest.fn()}+ workspace={workspace({ mode: 'without_attached', state: 'without_attached' })}+ disabled={false}+ />,+ );++ await userEvent.click(screen.getByTestId('code-workspace'));++ expect(+ screen.getByRole('menuitemradio', { name: /com_ui_code_workspace_without_attached/ }),+ ).toHaveAttribute('aria-checked', 'true');+ expect(screen.getByRole('menuitemradio', { name: /Project A/ })).toHaveAttribute(+ 'aria-checked',+ 'false',+ );+ });++ test('hides the chooser after the conversation decision is locked', () => {+ render(+ <CodeWorkspaceMenu+ setConversation={jest.fn()}+ workspace={workspace({ locked: true })}+ disabled={false}+ />,+ );++ expect(screen.queryByTestId('code-workspace')).not.toBeInTheDocument();+ });++ test('shows recovery status when a locked workspace is unavailable', () => {+ render(+ <CodeWorkspaceMenu+ setConversation={jest.fn()}+ workspace={workspace({+ locked: true,+ canSubmit: false,+ state: 'unavailable',+ selections: undefined,+ environments: [+ { environment, state: 'unavailable', workspaces: [], selected: undefined },+ ],+ })}+ disabled={false}+ />,+ );++ expect(screen.getByTestId('code-workspace-locked-status')).toHaveAccessibleName(+ 'com_ui_code_workspace_unavailable. com_ui_code_workspace_locked_recovery',+ );+ });});diff --git a/client/src/components/Messages/Content/Error.tsx b/client/src/components/Messages/Content/Error.tsxindex b80b288d49..7577eef186 100644--- a/client/src/components/Messages/Content/Error.tsx+++ b/client/src/components/Messages/Content/Error.tsx@@ -85,6 +85,7 @@ const codeWorkspaceErrorKeys: Record<CodeWorkspaceSelectionErrorReason, Translatworker_unavailable: 'com_error_code_workspace_worker_unavailable',unsupported: 'com_error_code_workspace_unsupported',missing: 'com_error_code_workspace_missing',+ locked: 'com_error_code_workspace_locked',};/** Why a manual compaction could not run, keyed by the SDK's skip reason. */diff --git a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsxindex 748588a253..94308e44d8 100644--- a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx+++ b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx@@ -6,6 +6,7 @@ import useCodeWorkspace from '../useCodeWorkspace';const mockAgentPermissions = jest.fn();const mockAgentsConfig = jest.fn();const mockStatus = jest.fn();+const mockStartupConfig = jest.fn();const mockAgentsMap = jest.fn();const mockAccess = jest.fn();const mockPreference = jest.fn();@@ -25,11 +26,12 @@ jest.mock('../useGetAgentsConfig', () => () => mockAgentsConfig());jest.mock('~/Providers', () => ({ useAgentsMapContext: () => mockAgentsMap() }));jest.mock('~/data-provider', () => ({useCodeEnvironmentStatusQueries: (...args: unknown[]) => mockStatus(...args),+ useGetStartupConfig: () => ({ data: mockStartupConfig() }),}));const conversation = (codeWorkspaces?: TConversation['codeWorkspaces']): TConversation =>({- conversationId: 'conversation-1',+ conversationId: 'new',endpoint: EModelEndpoint.agents,agent_id: 'agent_primary',codeWorkspaces,@@ -40,6 +42,7 @@ describe('useCodeWorkspace', () => {mockPreference.mockReset();mockRememberPreference.mockReset();mockAccess.mockReturnValue(true);+ mockStartupConfig.mockReturnValue({ codeEnvironmentDecisionVersion: 1 });mockAgentPermissions.mockReturnValue({tools: [Tools.execute_code],agent: {@@ -101,12 +104,28 @@ describe('useCodeWorkspace', () => {expect(result.current.state).toBe('ready');expect(result.current.canSubmit).toBe(true);+ expect(result.current.locked).toBe(false);+ expect(result.current.mode).toBe('attached');expect(result.current.selections).toEqual([{ environmentId: 'personal-vm', workspaceId: 'project-a' },]);expect(mockStatus).toHaveBeenCalledWith(['personal-vm'], true);});+ it('does not emit a selection-less decision until the API advertises support', () => {+ mockStartupConfig.mockReturnValue({});+ mockStatus()[0].data.workspaces.push({ id: 'project-b', name: 'Project B' });++ const { result } = renderHook(() => useCodeWorkspace(conversation()));++ expect(result.current.supportsEnvironmentDecisions).toBe(false);+ expect(result.current.mode).toBeUndefined();+ expect(result.current.state).toBe('choose');+ expect(result.current.canSubmit).toBe(false);+ expect(result.current.resolveSubmission()).toBeUndefined();+ expect(result.current.resolveSubmission(undefined, 'without_attached')).toBeUndefined();+ });+it('uses an agent default ahead of the last used workspace only for new chats', () => {mockStatus()[0].data.workspaces.push({ id: 'project-b', name: 'Project B' });mockAgentPermissions().agent.code_workspace_id = 'project-b';@@ -119,7 +138,8 @@ describe('useCodeWorkspace', () => {);expect(result.current.selections?.[0].workspaceId).toBe('project-b');rerender({ id: 'existing' });- expect(result.current.canSubmit).toBe(false);+ expect(result.current.mode).toBe('without_attached');+ expect(result.current.canSubmit).toBe(true);});it('uses a valid last choice and preserves an explicit conversation binding', () => {@@ -275,7 +295,10 @@ describe('useCodeWorkspace', () => {});rerender();expect(result.current.state).toBe('missing');- expect(result.current.canSubmit).toBe(false);+ expect(result.current.canSubmit).toBe(true);+ expect(result.current.resolveSubmission()).toEqual({+ codeEnvironmentMode: 'without_attached',+ });});it.each(['ephemeral', 'openAI__gpt-4o'])('does not block ephemeral agent %s', (agent_id) => {@@ -334,7 +357,7 @@ describe('useCodeWorkspace', () => {expect(result.current.selections).toBeUndefined();});- it('requires a workspace in full access mode and enables submission after explicit selection', () => {+ it('allows ordinary chat without a workspace and uses one after explicit selection', () => {mockStatus.mockReturnValue([{data: {@@ -357,16 +380,21 @@ describe('useCodeWorkspace', () => {});expect(result.current.state).toBe('choose');- expect(result.current.canSubmit).toBe(false);+ expect(result.current.canSubmit).toBe(true);expect(result.current.selections).toBeUndefined();- expect(result.current.resolveSubmission()).toBeUndefined();+ expect(result.current.resolveSubmission()).toEqual({+ codeEnvironmentMode: 'without_attached',+ });const selection = { environmentId: 'personal-vm', workspaceId: 'canary-a' };rerender({ current: { ...initialConversation, codeWorkspaces: [selection] } });expect(result.current.state).toBe('ready');expect(result.current.canSubmit).toBe(true);- expect(result.current.resolveSubmission([selection])).toEqual({ codeWorkspaces: [selection] });+ expect(result.current.resolveSubmission([selection])).toEqual({+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [selection],+ });});it('submits an explicit selection from several advertised workspaces', () => {@@ -387,30 +415,35 @@ describe('useCodeWorkspace', () => {expect(result.current.canSubmit).toBe(true);expect(result.current.resolveSubmission([selection])).toEqual({+ codeEnvironmentMode: 'attached',codeWorkspaces: [selection],});});- it('blocks submission while the required worker status is loading', () => {+ it('allows ordinary chat while the attached worker status is loading', () => {mockStatus.mockReturnValue([{ data: undefined, isLoading: true, isError: false }]);const { result } = renderHook(() => useCodeWorkspace(conversation()));expect(result.current.required).toBe(true);expect(result.current.state).toBe('loading');- expect(result.current.canSubmit).toBe(false);- expect(result.current.resolveSubmission()).toBeUndefined();+ expect(result.current.canSubmit).toBe(true);+ expect(result.current.resolveSubmission()).toEqual({+ codeEnvironmentMode: 'without_attached',+ });});- it('blocks submission while endpoint capabilities are loading', () => {+ it('allows ordinary chat while endpoint capabilities are loading', () => {mockAgentsConfig.mockReturnValue({ agentsConfig: null, endpointsConfig: undefined });const { result } = renderHook(() => useCodeWorkspace(conversation()));expect(result.current.required).toBe(true);expect(result.current.state).toBe('loading');- expect(result.current.canSubmit).toBe(false);- expect(result.current.resolveSubmission()).toBeUndefined();+ expect(result.current.canSubmit).toBe(true);+ expect(result.current.resolveSubmission()).toEqual({+ codeEnvironmentMode: 'without_attached',+ });expect(mockStatus).toHaveBeenLastCalledWith([], false);});@@ -551,12 +584,14 @@ describe('useCodeWorkspace', () => {useCodeWorkspace({ ...conversation(), conversationId: 'new' }),);expect(result.current.state).toBe('choose');- expect(result.current.canSubmit).toBe(false);+ expect(result.current.canSubmit).toBe(true);expect(- result.current.resolveSubmission([- { environmentId: 'personal-vm', workspaceId: 'project-a' },- ]),+ result.current.resolveSubmission(+ [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],+ 'attached',+ ),).toEqual({+ codeEnvironmentMode: 'attached',codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],});});diff --git a/client/src/hooks/Agents/useCodeWorkspace.ts b/client/src/hooks/Agents/useCodeWorkspace.tsindex 78e64b8645..2c36cf3fde 100644--- a/client/src/hooks/Agents/useCodeWorkspace.ts+++ b/client/src/hooks/Agents/useCodeWorkspace.ts@@ -1,12 +1,18 @@import { useCallback, useMemo } from 'react';-import { AgentCapabilities, PermissionTypes, Permissions } from 'librechat-data-provider';import {EModelEndpoint,Tools,isEphemeralAgentId,isCodeWorkspaceSelections,} from 'librechat-data-provider';+import {+ AgentCapabilities,+ CODE_ENVIRONMENT_DECISION_VERSION,+ PermissionTypes,+ Permissions,+} from 'librechat-data-provider';import type {+ CodeEnvironmentMode,CodeWorkspaceDescriptor,CodeWorkspaceSelection,TConfig,@@ -15,7 +21,7 @@ import type {TPublicCodeEnvironment,} from 'librechat-data-provider';import { collectReachableAgents, findExecutionEnvironment } from './useCodeApprovalMode';-import { useCodeEnvironmentStatusQueries } from '~/data-provider';+import { useCodeEnvironmentStatusQueries, useGetStartupConfig } from '~/data-provider';import { useWorkspacePreferences } from './workspacePreferences';import useAgentToolPermissions from './useAgentToolPermissions';import useHasAccess from '~/hooks/Roles/useHasAccess';@@ -24,6 +30,7 @@ import { useAgentsMapContext } from '~/Providers';export type CodeWorkspaceState =| 'not_required'+ | 'without_attached'| 'loading'| 'choose'| 'ready'@@ -40,6 +47,9 @@ export interface CodeWorkspaceEnvironmentResult {export interface CodeWorkspaceResult {required: boolean;+ supportsEnvironmentDecisions: boolean;+ locked: boolean;+ mode?: CodeEnvironmentMode;state: CodeWorkspaceState;canSubmit: boolean;environments: CodeWorkspaceEnvironmentResult[];@@ -49,7 +59,10 @@ export interface CodeWorkspaceResult {) => CodeWorkspaceSelection[] | undefined;resolveSubmission: (selections?: CodeWorkspaceSelection[],- ) => { codeWorkspaces?: CodeWorkspaceSelection[] } | undefined;+ mode?: CodeEnvironmentMode,+ ) =>+ | { codeEnvironmentMode?: CodeEnvironmentMode; codeWorkspaces?: CodeWorkspaceSelection[] }+ | undefined;rememberSelection: (selection: CodeWorkspaceSelection) => void;}@@ -95,6 +108,9 @@ export default function useCodeWorkspace(conversation: TConversation | null,addedConversation?: TConversation | null,): CodeWorkspaceResult {+ const { data: startupConfig } = useGetStartupConfig();+ const supportsEnvironmentDecisions =+ startupConfig?.codeEnvironmentDecisionVersion === CODE_ENVIRONMENT_DECISION_VERSION;const preferences = useWorkspacePreferences(conversation?.agent_id);const { agentsConfig, endpointsConfig } = useGetAgentsConfig();const canRunCode = useHasAccess({@@ -199,6 +215,7 @@ export default function useCodeWorkspace(const isNewChat =conversation != null &&(conversation.conversationId == null || conversation.conversationId === 'new');+ const locked = conversation != null && !isNewChat;const environmentResults = attachedEnvironments.map((environment, index) => {const status = statuses[index];const workspaces =@@ -278,20 +295,55 @@ export default function useCodeWorkspace();const selections = resolveSelections(storedSelections);- const state = configurationPending- ? 'loading'- : aggregateState(required, metadataComplete, environmentResults, selections);+ let inferredMode: CodeEnvironmentMode | undefined = conversation?.codeEnvironmentMode;+ if (inferredMode == null && storedSelections != null) {+ inferredMode = 'attached';+ } else if (inferredMode == null && selections != null) {+ inferredMode = 'attached';+ } else if (inferredMode == null && required && supportsEnvironmentDecisions) {+ inferredMode = 'without_attached';+ }+ let state: CodeWorkspaceState;+ const hasLockedWithoutAttachedDecision =+ inferredMode === 'without_attached' &&+ (conversation?.codeEnvironmentMode === 'without_attached' || locked);+ if (hasLockedWithoutAttachedDecision) {+ state = 'without_attached';+ } else if (configurationPending) {+ state = 'loading';+ } else {+ state = aggregateState(required, metadataComplete, environmentResults, selections);+ }const resolveSubmission = useCallback((candidateSelections?: CodeWorkspaceSelection[],- ): { codeWorkspaces?: CodeWorkspaceSelection[] } | undefined => {+ candidateMode?: CodeEnvironmentMode,+ ):+ | { codeEnvironmentMode?: CodeEnvironmentMode; codeWorkspaces?: CodeWorkspaceSelection[] }+ | undefined => {if (!required) return {};+ const requestedMode =+ candidateMode ??+ inferredMode ??+ (isCodeWorkspaceSelections(candidateSelections) && candidateSelections.length > 0+ ? 'attached'+ : undefined);+ if (requestedMode === 'without_attached') {+ return supportsEnvironmentDecisions+ ? { codeEnvironmentMode: 'without_attached' }+ : undefined;+ }+ if (requestedMode == null && supportsEnvironmentDecisions) {+ return { codeEnvironmentMode: 'without_attached' };+ }const codeWorkspaces = resolveSelections(candidateSelections);- return codeWorkspaces == null ? undefined : { codeWorkspaces };+ return codeWorkspaces == null+ ? undefined+ : { codeEnvironmentMode: 'attached', codeWorkspaces };},- [required, resolveSelections],+ [inferredMode, required, resolveSelections, supportsEnvironmentDecisions],);- const canSubmit = resolveSubmission(storedSelections) != null;+ const canSubmit = resolveSubmission(storedSelections, conversation?.codeEnvironmentMode) != null;const rememberSelection = useCallback((selection: CodeWorkspaceSelection) => {preferences.remember(selection.environmentId, selection.workspaceId, [@@ -302,6 +354,9 @@ export default function useCodeWorkspace();return {required,+ supportsEnvironmentDecisions,+ locked,+ mode: inferredMode,state,canSubmit,environments: environmentResults,diff --git a/client/src/hooks/Agents/useSelectAgent.ts b/client/src/hooks/Agents/useSelectAgent.tsindex 339885bad9..d1b6dcba7d 100644--- a/client/src/hooks/Agents/useSelectAgent.ts+++ b/client/src/hooks/Agents/useSelectAgent.ts@@ -44,6 +44,7 @@ export default function useSelectAgent() {conversation: {...(conversation ?? {}),agent_id: agent.id,+ codeEnvironmentMode: switchesAgent ? undefined : conversation?.codeEnvironmentMode,codeWorkspaces: switchesAgent ? undefined : conversation?.codeWorkspaces,...specDisplayFieldReset,},@@ -51,6 +52,7 @@ export default function useSelectAgent() {});const currentConvo = {...resolvedConvo,+ codeEnvironmentMode: switchesAgent ? undefined : conversation?.codeEnvironmentMode,codeWorkspaces: switchesAgent ? undefined : conversation?.codeWorkspaces,};newConversation({@@ -73,6 +75,7 @@ export default function useSelectAgent() {endpoint: EModelEndpoint.agents,agent_id: agent.id,conversationId: Constants.NEW_CONVO as string,+ codeEnvironmentMode: undefined,codeWorkspaces: undefined,...specDisplayFieldReset,};diff --git a/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx b/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsxindex 1e1bfca18e..f922db8a3f 100644--- a/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx+++ b/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx@@ -1,6 +1,7 @@import { renderHook, act } from '@testing-library/react';import { Constants, ContentTypes, EModelEndpoint, createPayload } from 'librechat-data-provider';import type {+ CodeEnvironmentMode,CodeWorkspaceSelection,TConversation,TMessage,@@ -20,8 +21,9 @@ const mockGetQueryData = jest.fn(() => ({}));const mockLoggerWarn = jest.fn();const mockGetLatestConversation = jest.fn(() => null as TConversation | null);const mockResolveCodeWorkspaceSubmission = jest.fn<- { codeWorkspaces?: CodeWorkspaceSelection[] } | undefined,- [CodeWorkspaceSelection[]?]+ | { codeEnvironmentMode?: CodeEnvironmentMode; codeWorkspaces?: CodeWorkspaceSelection[] }+ | undefined,+ [CodeWorkspaceSelection[]?, CodeEnvironmentMode?]>(() => ({}));const mockCodeWorkspace = {resolveSubmission: mockResolveCodeWorkspaceSubmission,@@ -191,6 +193,7 @@ describe('useChatFunctions ask', () => {mockResolveCodeWorkspaceSubmission.mockReturnValue({ codeWorkspaces: [selection] });mockGetLatestConversation.mockReturnValue({...conversation('conversation-1'),+ codeEnvironmentMode: 'attached',codeWorkspaces: [selection],});const { result, setSubmission } = renderAsk([]);@@ -200,7 +203,7 @@ describe('useChatFunctions ask', () => {});const submission = setSubmission.mock.calls.at(-1)?.[0] as TSubmission;- expect(mockResolveCodeWorkspaceSubmission).toHaveBeenCalledWith([selection]);+ expect(mockResolveCodeWorkspaceSubmission).toHaveBeenCalledWith([selection], 'attached');expect(submission.codeWorkspaces).toEqual([selection]);});diff --git a/client/src/hooks/Chat/useChatFunctions.ts b/client/src/hooks/Chat/useChatFunctions.tsindex 2229640beb..d1e8ab1499 100644--- a/client/src/hooks/Chat/useChatFunctions.ts+++ b/client/src/hooks/Chat/useChatFunctions.ts@@ -332,12 +332,17 @@ export default function useChatFunctions({? latestCodeApprovalMode: fallbackCodeApprovalMode;const latestCodeWorkspaces = getConversation()?.codeWorkspaces ?? conversation?.codeWorkspaces;- const workspaceSubmission = codeWorkspaceState.resolveSubmission(latestCodeWorkspaces);+ const latestCodeEnvironmentMode =+ getConversation()?.codeEnvironmentMode ?? conversation?.codeEnvironmentMode;+ const workspaceSubmission = codeWorkspaceState.resolveSubmission(+ latestCodeWorkspaces,+ latestCodeEnvironmentMode,+ );if (workspaceSubmission == null) {logger.warn('[useChatFunctions] Refusing to send without an available code workspace');return false;}- const { codeWorkspaces } = workspaceSubmission;+ const { codeEnvironmentMode, codeWorkspaces } = workspaceSubmission;const endpoint = conversation?.endpoint;if (endpoint === null) {@@ -757,6 +762,7 @@ export default function useChatFunctions({addedConvo,manualSkills: manualSkills.length > 0 ? manualSkills : undefined,codeApprovalMode,+ codeEnvironmentMode,codeWorkspaces,clientRequestId,recoverySteerId: overrideRecoverySteerId,diff --git a/client/src/hooks/useNewConvo.ts b/client/src/hooks/useNewConvo.tsindex f12bafbca2..8424dd2954 100644--- a/client/src/hooks/useNewConvo.ts+++ b/client/src/hooks/useNewConvo.ts@@ -67,7 +67,9 @@ export function clearInheritedAgentWorkspace(conversation.agent_id != null &&conversation.agent_id !== previousConversation?.agent_id;- return startsNewAgentConversation ? { ...conversation, codeWorkspaces: undefined } : conversation;+ return startsNewAgentConversation+ ? { ...conversation, codeEnvironmentMode: undefined, codeWorkspaces: undefined }+ : conversation;}const useNewConvo = (index = 0) => {diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.jsonindex 1bf096b0d4..a3fd4d7d7c 100644--- a/client/src/locales/en/translation.json+++ b/client/src/locales/en/translation.json@@ -18,6 +18,9 @@"com_ui_code_workspace_missing": "Workspace missing","com_ui_code_workspace_unavailable": "Workspace unavailable","com_ui_code_workspace_unsupported": "Update worker for workspaces",+ "com_ui_code_workspace_without_attached": "No attached workspace",+ "com_ui_code_workspace_without_attached_info": "Chat without using files or commands on an attached machine.",+ "com_ui_code_workspace_locked_recovery": "Reconnect or restore this workspace, or start a new chat.","com_ui_code_workspaces_selected": "{{0}} code workspaces","com_ui_code_approval_ask": "Ask before changes","com_ui_code_approval_ask_description": "Ask before editing files or running commands",@@ -429,7 +432,8 @@"com_error_code_workspace_invalid": "The workspace selection is invalid; select an available workspace.","com_error_code_workspace_worker_unavailable": "The machine is unavailable; reconnect or choose another environment.","com_error_code_workspace_unsupported": "The worker does not support workspace selection.",- "com_error_code_workspace_missing": "The selected workspace is no longer registered; choose an available workspace.",+ "com_error_code_workspace_missing": "The selected workspace is no longer registered. Restore it on the attached machine or start a new chat.",+ "com_error_code_workspace_locked": "This chat already uses a different code environment. Continue with its original environment or start a new chat.","com_error_context_tokens_detail": "Your messages need {{0}} tokens, but only {{1}} are available.","com_error_empty_messages": "Your messages do not fit in the current context window, so there was nothing left to send to the model. Increase the max context size from the conversation parameters, shorten your message, or start a new conversation.","com_error_files_process": "An error occurred while processing the file.",diff --git a/packages/api/src/agents/__tests__/initialize.test.ts b/packages/api/src/agents/__tests__/initialize.test.tsindex 67ac3fdebe..14091518b8 100644--- a/packages/api/src/agents/__tests__/initialize.test.ts+++ b/packages/api/src/agents/__tests__/initialize.test.ts@@ -2462,6 +2462,274 @@ describe('initializeAgent — execute_code capability expansion', () => {expect(result.fileAuthoringToolNames).toEqual(new Set(['create_file', 'edit_file']));});+ it('withholds attached code tools when the conversation works without an environment', async () => {+ const { agent, req, res, loadTools, db } = createMocks();+ agent.tools = [Tools.execute_code];+ agent.tool_resources = {+ [EToolResources.execute_code]: { file_ids: ['attached-code-file'] },+ };+ agent.stateful_code_sessions = true;+ agent.code_environment_id = 'personal-vm';+ req.config = {+ endpoints: {+ [EModelEndpoint.agents]: {+ statefulCodeSessions: {+ environments: [+ {+ id: 'personal-vm',+ name: 'Personal VM',+ type: 'attached',+ baseURL: 'https://code.example.com/v1',+ },+ ],+ },+ },+ },+ } as unknown as NonNullable<typeof req.config>;++ const result = await initializeAgent(+ {+ req,+ res,+ agent,+ loadTools,+ requestBody: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'without_attached',+ },+ endpointOption: { endpoint: EModelEndpoint.agents },+ allowedProviders: new Set([Providers.OPENAI]),+ isInitialAgent: true,+ codeEnvAvailable: true,+ statefulSessionsAvailable: true,+ },+ db,+ );++ expect(result.codeEnvAvailable).toBe(false);+ expect(result.codeExecutionContext).toEqual(+ expect.objectContaining({ executionProfile: 'default', statefulSessions: false }),+ );+ expect(result.toolDefinitions?.map(({ name }) => name)).not.toEqual(+ expect.arrayContaining(['bash_tool', 'read_file', 'create_file', 'edit_file']),+ );+ const { primeResources } = jest.requireMock('../resources') as { primeResources: jest.Mock };+ const primeCall = primeResources.mock.calls[primeResources.mock.calls.length - 1][0];+ expect(primeCall.enabledToolResources.has(EToolResources.execute_code)).toBe(false);+ expect(primeCall.tool_resources).not.toHaveProperty(EToolResources.execute_code);+ });++ it('does not disable managed code tools for the without-attached decision', async () => {+ const { agent, req, res, loadTools, db } = createMocks();+ agent.tools = [Tools.execute_code];+ agent.stateful_code_sessions = true;+ agent.code_environment_id = 'managed-code';+ req.config = {+ endpoints: {+ [EModelEndpoint.agents]: {+ statefulCodeSessions: {+ environments: [+ {+ id: 'managed-code',+ name: 'Managed code',+ type: 'managed',+ baseURL: 'https://code.example.com/v1',+ },+ ],+ },+ },+ },+ } as NonNullable<typeof req.config>;++ const result = await initializeAgent(+ {+ req,+ res,+ agent,+ loadTools,+ requestBody: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'without_attached',+ },+ endpointOption: { endpoint: EModelEndpoint.agents },+ allowedProviders: new Set([Providers.OPENAI]),+ isInitialAgent: true,+ codeEnvAvailable: true,+ statefulSessionsAvailable: true,+ },+ db,+ );++ expect(result.codeEnvAvailable).toBe(true);+ expect(result.toolDefinitions?.map(({ name }) => name)).toEqual(+ expect.arrayContaining(['bash_tool', 'read_file']),+ );+ });++ it('honors without-attached when the configured environment is no longer visible', async () => {+ const { agent, req, res, loadTools, db } = createMocks();+ agent.tools = [Tools.execute_code];+ agent.stateful_code_sessions = true;+ agent.code_environment_id = 'revoked-vm';+ req.config = {+ endpoints: {+ [EModelEndpoint.agents]: {+ statefulCodeSessions: { environments: [] },+ },+ },+ } as unknown as NonNullable<typeof req.config>;++ const result = await initializeAgent(+ {+ req,+ res,+ agent,+ loadTools,+ requestBody: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'without_attached',+ },+ endpointOption: { endpoint: EModelEndpoint.agents },+ allowedProviders: new Set([Providers.OPENAI]),+ isInitialAgent: true,+ codeEnvAvailable: true,+ statefulSessionsAvailable: true,+ },+ db,+ );++ expect(result.codeEnvAvailable).toBe(false);+ expect(result.toolDefinitions?.map(({ name }) => name)).not.toEqual(+ expect.arrayContaining(['bash_tool', 'read_file', 'create_file', 'edit_file']),+ );+ });++ it('keeps an implicit managed stateful route enabled during attached opt-out', async () => {+ const { agent, req, res, loadTools, db } = createMocks();+ agent.tools = [Tools.execute_code];+ agent.stateful_code_sessions = true;+ delete agent.code_environment_id;+ process.env.CODE_ENVIRONMENT_DECISION_VERSION = '1';+ process.env.LIBRECHAT_CODE_BASEURL_STATEFUL = 'https://stateful-code.example.com/v1/';+ req.config = {+ endpoints: {+ [EModelEndpoint.agents]: {+ statefulCodeSessions: { environments: [] },+ },+ },+ } as unknown as NonNullable<typeof req.config>;++ try {+ const result = await initializeAgent(+ {+ req,+ res,+ agent,+ loadTools,+ requestBody: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'without_attached',+ },+ endpointOption: { endpoint: EModelEndpoint.agents },+ allowedProviders: new Set([Providers.OPENAI]),+ isInitialAgent: false,+ codeEnvAvailable: true,+ statefulSessionsAvailable: true,+ },+ db,+ );++ expect(result.codeEnvAvailable).toBe(true);+ expect(result.statefulCodeSessions).toBe(true);+ expect(result.toolDefinitions?.map(({ name }) => name)).toEqual(+ expect.arrayContaining(['bash_tool', 'read_file']),+ );+ } finally {+ delete process.env.CODE_ENVIRONMENT_DECISION_VERSION;+ delete process.env.LIBRECHAT_CODE_BASEURL_STATEFUL;+ }+ });++ it('honors attached opt-out when no implicit managed route is deployed', async () => {+ const { agent, req, res, loadTools, db } = createMocks();+ agent.tools = [Tools.execute_code];+ agent.stateful_code_sessions = true;+ delete agent.code_environment_id;+ req.config = {+ endpoints: {+ [EModelEndpoint.agents]: {+ statefulCodeSessions: { environments: [] },+ },+ },+ } as unknown as NonNullable<typeof req.config>;++ const result = await initializeAgent(+ {+ req,+ res,+ agent,+ loadTools,+ requestBody: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'without_attached',+ },+ endpointOption: { endpoint: EModelEndpoint.agents },+ allowedProviders: new Set([Providers.OPENAI]),+ isInitialAgent: false,+ codeEnvAvailable: true,+ statefulSessionsAvailable: true,+ },+ db,+ );++ expect(result.codeEnvAvailable).toBe(false);+ expect(result.statefulCodeSessions).toBe(false);+ expect(result.toolDefinitions?.map(({ name }) => name)).not.toEqual(+ expect.arrayContaining(['bash_tool', 'read_file']),+ );+ });++ it('keeps legacy opt-out classification until the deployment protocol is enabled', async () => {+ const { agent, req, res, loadTools, db } = createMocks();+ agent.tools = [Tools.execute_code];+ agent.stateful_code_sessions = true;+ delete agent.code_environment_id;+ process.env.LIBRECHAT_CODE_BASEURL_STATEFUL = 'https://stateful-code.example.com/v1/';+ req.config = {+ endpoints: {+ [EModelEndpoint.agents]: {+ statefulCodeSessions: { environments: [] },+ },+ },+ } as unknown as NonNullable<typeof req.config>;++ try {+ const result = await initializeAgent(+ {+ req,+ res,+ agent,+ loadTools,+ requestBody: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'without_attached',+ },+ endpointOption: { endpoint: EModelEndpoint.agents },+ allowedProviders: new Set([Providers.OPENAI]),+ isInitialAgent: false,+ codeEnvAvailable: true,+ statefulSessionsAvailable: true,+ },+ db,+ );++ expect(result.codeEnvAvailable).toBe(false);+ expect(result.statefulCodeSessions).toBe(false);+ } finally {+ delete process.env.LIBRECHAT_CODE_BASEURL_STATEFUL;+ }+ });+it('routes code-file priming through the stateful profile before tools load', async () => {const { agent, req, res, loadTools, db } = createMocks();agent.tools = ['execute_code'];diff --git a/packages/api/src/agents/hitl/policy.spec.ts b/packages/api/src/agents/hitl/policy.spec.tsindex e971a83032..813b601153 100644--- a/packages/api/src/agents/hitl/policy.spec.ts+++ b/packages/api/src/agents/hitl/policy.spec.ts@@ -11,6 +11,7 @@ import {buildPendingAction,toClientPendingAction,computeAgentRequestFingerprint,+ computeLegacyAgentRequestFingerprint,captureResumeModelParameters,sanitizeResumeModelParameters,pickResumeContext,@@ -379,6 +380,7 @@ describe('toClientPendingAction', () => {streamId: 'stream-1',conversationId: 'conv-1',requestFingerprint: 'fp-hash',+ requestFingerprintV2: 'fp-v2-hash',resumeContext: {endpoint: 'agents',model_parameters: { temperature: 0.5 },@@ -393,6 +395,7 @@ describe('toClientPendingAction', () => {expect(clientSafe).toBeDefined();expect(clientSafe?.resumeContext).toBeUndefined();expect(clientSafe?.requestFingerprint).toBeUndefined();+ expect(clientSafe?.requestFingerprintV2).toBeUndefined();expect(clientSafe?.codeExecutionBinding).toBeUndefined();expect(clientSafe?.actionId).toBe(full.actionId);expect(clientSafe?.streamId).toBe('stream-1');@@ -400,6 +403,7 @@ describe('toClientPendingAction', () => {// Non-mutating: the stored record keeps its replay state for the resume route.expect(full.resumeContext).toBeDefined();expect(full.requestFingerprint).toBe('fp-hash');+ expect(full.requestFingerprintV2).toBe('fp-v2-hash');expect(full.codeExecutionBinding).toEqual({version: 1,targets: [{ agentId: 'agent-1', targetHash: 'a'.repeat(64) }],@@ -662,6 +666,9 @@ describe('computeAgentRequestFingerprint', () => {expect(computeAgentRequestFingerprint(base)).not.toBe(computeAgentRequestFingerprint({ ...base, codeApprovalMode: null }),);+ expect(computeAgentRequestFingerprint(base)).not.toBe(+ computeAgentRequestFingerprint({ ...base, codeEnvironmentMode: 'without_attached' }),+ );expect(computeAgentRequestFingerprint(base)).not.toBe(computeAgentRequestFingerprint({...base,@@ -681,6 +688,25 @@ describe('computeAgentRequestFingerprint', () => {);});+ it('keeps a legacy-compatible digest while the current digest pins code environments', () => {+ const base = { endpoint: 'agents', agent_id: 'agent-1' };+ const withWorkspace = {+ ...base,+ codeWorkspaces: [{ environmentId: 'env-a', workspaceId: 'project-a' }],+ };+ const withAttachedWorkspace = { ...withWorkspace, codeEnvironmentMode: 'attached' as const };++ expect(computeLegacyAgentRequestFingerprint(base)).not.toBe(+ computeLegacyAgentRequestFingerprint(withAttachedWorkspace),+ );+ expect(computeLegacyAgentRequestFingerprint(withWorkspace)).toBe(+ computeLegacyAgentRequestFingerprint(withAttachedWorkspace),+ );+ expect(computeAgentRequestFingerprint(base)).not.toBe(+ computeAgentRequestFingerprint(withAttachedWorkspace),+ );+ });+it('differs when promptPrefix changes (ephemeral instructions)', () => {const base = { endpoint: 'agents', promptPrefix: 'be terse' };expect(computeAgentRequestFingerprint(base)).not.toBe(@@ -733,6 +759,7 @@ describe('pickResumeContext / applyResumeContext', () => {// Graph-determining: feeds the ephemeral agent id / checkpoint namespace (#14253).modelLabel: 'My Opus',codeApprovalMode: 'acceptEdits',+ codeEnvironmentMode: 'attached',codeWorkspaces: [{ environmentId: 'env-a', workspaceId: 'project-a' }],conversationId: 'c',decisions: [],@@ -749,6 +776,7 @@ describe('pickResumeContext / applyResumeContext', () => {manualSkills: ['code-reviewer'],modelLabel: 'My Opus',codeApprovalMode: 'acceptEdits',+ codeEnvironmentMode: 'attached',codeWorkspaces: [{ environmentId: 'env-a', workspaceId: 'project-a' }],});});@@ -788,6 +816,25 @@ describe('pickResumeContext / applyResumeContext', () => {expect('codeWorkspaces' in injected).toBe(false);});+ it('pins the code-environment decision across resume and removes a forged mode', () => {+ const restored: Record<string, unknown> = {+ conversationId: 'c',+ codeEnvironmentMode: 'attached',+ };+ applyResumeContext(restored, {+ endpoint: 'agents',+ codeEnvironmentMode: 'without_attached',+ });+ expect(restored.codeEnvironmentMode).toBe('without_attached');++ const injected: Record<string, unknown> = {+ conversationId: 'c',+ codeEnvironmentMode: 'attached',+ };+ applyResumeContext(injected, { endpoint: 'agents' });+ expect('codeEnvironmentMode' in injected).toBe(false);+ });+it('replays a dropped modelLabel so the ephemeral agent id stays stable (#14253)', () => {// Resume/reload case: the resolved llmConfig stripped modelLabel; the server restores// the original top-level value so parseCompactConvo re-derives the same sender/id.diff --git a/packages/api/src/agents/hitl/policy.ts b/packages/api/src/agents/hitl/policy.tsindex b0b4c2ceac..af37fa025c 100644--- a/packages/api/src/agents/hitl/policy.ts+++ b/packages/api/src/agents/hitl/policy.ts@@ -344,6 +344,8 @@ export interface PendingActionContext {threadId?: string;/** Fingerprint of the graph-determining request fields; see {@link computeAgentRequestFingerprint}. */requestFingerprint?: string;+ /** Current fingerprint; the legacy field remains populated for rolling-deploy compatibility. */+ requestFingerprintV2?: string;/** Graph-determining fields to replay on resume; see {@link RESUME_CONTEXT_KEYS}. */resumeContext?: Record<string, unknown>;/** Opaque server-only binding to the stateful code targets selected at pause time. */@@ -361,6 +363,7 @@ export interface AgentRequestFingerprintFields {promptPrefix?: string | null;ephemeralAgent?: Record<string, unknown> | null;codeApprovalMode?: string | null;+ codeEnvironmentMode?: string | null;codeWorkspaces?: unknown;}@@ -400,6 +403,7 @@ export const RESUME_CONTEXT_KEYS = ['promptPrefix','ephemeralAgent','codeApprovalMode',+ 'codeEnvironmentMode',// The selected attached workspace determines the code tools' execution root and// operation ceiling. Pin it across every pause type so a reload or crafted resume// cannot rebuild the graph against a different directory.@@ -730,6 +734,35 @@ export function applyResumeModelParameters(}export function computeAgentRequestFingerprint(fields: AgentRequestFingerprintFields): string {+ const canonical = JSON.stringify({+ endpoint: fields.endpoint ?? null,+ endpointType: fields.endpointType ?? null,+ agent_id: fields.agent_id ?? null,+ model: fields.model ?? null,+ spec: fields.spec ?? null,+ promptPrefix: fields.promptPrefix ?? null,+ ephemeralAgent: normalizeEphemeralAgent(fields.ephemeralAgent),+ ...(Object.prototype.hasOwnProperty.call(fields, 'codeApprovalMode')+ ? { codeApprovalMode: fields.codeApprovalMode ?? null }+ : {}),+ ...(Object.prototype.hasOwnProperty.call(fields, 'codeEnvironmentMode')+ ? { codeEnvironmentMode: fields.codeEnvironmentMode ?? null }+ : {}),+ ...(Object.prototype.hasOwnProperty.call(fields, 'codeWorkspaces')+ ? { codeWorkspaces: fields.codeWorkspaces ?? null }+ : {}),+ });+ return createHash('sha256').update(canonical).digest('hex');+}++/**+ * Fingerprint understood by replicas predating conversation-owned code environments.+ * Writers retain it in `requestFingerprint` while also storing the stricter current+ * fingerprint, allowing either replica generation to resume safely during a rollout.+ */+export function computeLegacyAgentRequestFingerprint(+ fields: AgentRequestFingerprintFields,+): string {const canonical = JSON.stringify({endpoint: fields.endpoint ?? null,endpointType: fields.endpointType ?? null,@@ -791,6 +824,7 @@ export function buildPendingAction(interruptId: ctx.interruptId,threadId: ctx.threadId,requestFingerprint: ctx.requestFingerprint,+ requestFingerprintV2: ctx.requestFingerprintV2,resumeContext: ctx.resumeContext,codeExecutionBinding: ctx.codeExecutionBinding,};@@ -811,6 +845,7 @@ export function toClientPendingAction(}const {requestFingerprint: _requestFingerprint,+ requestFingerprintV2: _requestFingerprintV2,resumeContext: _resumeContext,codeExecutionBinding: _codeExecutionBinding,...clientSafediff --git a/packages/api/src/agents/initialize.ts b/packages/api/src/agents/initialize.tsindex 8f754dc79f..4d2d977985 100644--- a/packages/api/src/agents/initialize.ts+++ b/packages/api/src/agents/initialize.ts@@ -67,6 +67,12 @@ import {unionPrimeAllowedTools,MAX_PRIMED_SKILLS_PER_TURN,} from './skills';+import {+ normalizeStatefulCodeEnvironment,+ resolveCodeExecutionContext,+ type CodeEnvironmentConfig,+ type CodeExecutionContext,+} from './execution';import {getContentTraversalFragments,isContentTraversalProtected,@@ -91,11 +97,6 @@ import {splitMCPToolKey,normalizeAgentToolKeys,} from '~/mcp/utils';-import {- normalizeStatefulCodeEnvironment,- resolveCodeExecutionContext,- type CodeExecutionContext,-} from './execution';import {createStatefulCodeEnvironmentPolicyError,isFatalAgentInitializationError,@@ -105,6 +106,7 @@ import { createConfiguredContentInspector, inspectContent } from '../protection/import { assertAgentAttachmentLimits, isModelBoundAttachmentFile } from './attachments';import { resolveAttachedWorkspaceCommandTimeoutMax } from '~/code/command';import { assertModelBoundContent } from '../middleware/modelBoundContent';+import { isImplicitStatefulCodeRouteAvailable } from '../code/config';import { registerMemoryTools, memoryToolUsageGuard } from './memory';import { applyIntentLabels, sanitizeIntentLabels } from './intent';import { ContentFilterError } from '../middleware/contentFilter';@@ -633,6 +635,25 @@ export type InitializedAgent = Agent & {export const DEFAULT_MAX_CONTEXT_TOKENS = 32000;+/** Returns true when a conversation-level choice disables an attached environment. */+export function optsOutOfAttachedCodeEnvironment(+ agent: Agent,+ requestBody: RequestBody | undefined,+ environments: readonly CodeEnvironmentConfig[] | undefined,+ implicitStatefulRouteAvailable = false,+): boolean {+ if (requestBody?.codeEnvironmentMode !== 'without_attached') return false;+ const configured = agent.code_environment_id+ ? environments?.find(({ id }) => id === agent.code_environment_id)+ : environments?.find(({ default: isDefault }) => isDefault === true);+ return (+ agent.stateful_code_sessions === true &&+ (configured?.type === 'attached' ||+ (configured == null &&+ (Boolean(agent.code_environment_id) || !implicitStatefulRouteAvailable)))+ );+}+/*** Parameters for initializing an agent* Matches the CJS signature from api/server/services/Endpoints/agents/agent.js@@ -1117,7 +1138,19 @@ export async function initializeAgent(* stateful agent must perform freshness checks and recovery uploads against* the same isolated deployment its eventual `/exec` request will use. */const agentRequestsCodeExec = (agent.tools ?? []).includes(Tools.execute_code);- const effectiveCodeEnvAvailable = params.codeEnvAvailable === true && agentRequestsCodeExec;+ const configuredCodeEnvironments =+ appConfig?.endpoints?.[EModelEndpoint.agents]?.statefulCodeSessions?.environments;+ const attachedEnvironmentOptOut = optsOutOfAttachedCodeEnvironment(+ agent,+ requestBody,+ configuredCodeEnvironments,+ isImplicitStatefulCodeRouteAvailable(+ process.env.CODE_ENVIRONMENT_DECISION_VERSION,+ process.env.LIBRECHAT_CODE_BASEURL_STATEFUL,+ ),+ );+ const effectiveCodeEnvAvailable =+ params.codeEnvAvailable === true && agentRequestsCodeExec && !attachedEnvironmentOptOut;const effectiveStatefulSessions =effectiveCodeEnvAvailable &¶ms.statefulSessionsAvailable === true &&@@ -1136,7 +1169,7 @@ export async function initializeAgent(statefulSessions: effectiveStatefulSessions,environment: statefulCodeEnvironment,environmentId: agent.code_environment_id,- environments: appConfig?.endpoints?.[EModelEndpoint.agents]?.statefulCodeSessions?.environments,+ environments: configuredCodeEnvironments,userId: requestFileOwnerId,agentId: agent.id,conversationId,@@ -1169,9 +1202,14 @@ export async function initializeAgent(}const toolResourceSet = resolveResendToolResources({tools: resourceToolNames,- codeEnvAvailable: params.codeEnvAvailable === true,+ codeEnvAvailable: params.codeEnvAvailable === true && !attachedEnvironmentOptOut,fileSearchAvailable: params.fileSearchAvailable,});+ let runtimeToolResources = agent.tool_resources;+ if (attachedEnvironmentOptOut && runtimeToolResources != null) {+ runtimeToolResources = { ...runtimeToolResources };+ delete runtimeToolResources[EToolResources.execute_code];+ }/*** Load conversation files for ALL agents, not just the initial agent.@@ -1488,7 +1526,7 @@ export async function initializeAgent(attachments: currentFiles? (Promise.resolve(currentFiles) as unknown as Promise<TFile[]>): undefined,- tool_resources: agent.tool_resources,+ tool_resources: runtimeToolResources,requestFileSet: new Set((authorizedRunFiles ?? requestFiles).map((file) => file.file_id)),enabledToolResources: toolResourceSet,checkSessionsAlive: db.checkSessionsAlive,diff --git a/packages/api/src/agents/openai/service.spec.ts b/packages/api/src/agents/openai/service.spec.tsindex 8ecde5caa0..2837ed7654 100644--- a/packages/api/src/agents/openai/service.spec.ts+++ b/packages/api/src/agents/openai/service.spec.ts@@ -154,6 +154,32 @@ describe('createAgentChatCompletion - MCP permission user propagation', () => {expect(streamConfig.configurable?.user).not.toHaveProperty('role');});+ it.each([+ { code_environment_mode: 'without_attached' },+ { code_workspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }] },+ ])('rejects code environment decision extensions it cannot persist: %o', async (extension) => {+ const res = createMockRes();+ const req = createMockReq(+ { id: 'user-123' },+ {+ model: 'agent_test',+ messages: [{ role: 'user', content: 'hi' }],+ conversation_id: 'conversation-123',+ ...extension,+ },+ );++ await createAgentChatCompletion(req, res, deps);++ expect(getResponseMock(res, 'status')).toHaveBeenCalledWith(400);+ expect(getResponseMock(res, 'json')).toHaveBeenCalledWith({+ error: expect.objectContaining({+ message: expect.stringContaining('cannot enforce a persisted conversation decision'),+ }),+ });+ expect(deps.initializeAgent).not.toHaveBeenCalled();+ });+it('adapts runtime tool loading to the request-backed public dependency', async () => {const req = createMockReq({ id: 'user-123', role: 'USER' });const res = createMockRes();diff --git a/packages/api/src/agents/openai/service.ts b/packages/api/src/agents/openai/service.tsindex 2214390bfc..cc61b0bf2b 100644--- a/packages/api/src/agents/openai/service.ts+++ b/packages/api/src/agents/openai/service.ts@@ -20,7 +20,6 @@ import type { LocatorTraversalReporter } from '../../protection/diagnostics';* ```*/import { nanoid } from 'nanoid';-import { isCodeWorkspaceSelections } from 'librechat-data-provider';import { AgentCapabilities, EModelEndpoint } from 'librechat-data-provider';import type {FiltersConfig,@@ -538,13 +537,11 @@ export function validateRequest(body: unknown): ChatCompletionValidationResult {if (request.conversation_id !== undefined && typeof request.conversation_id !== 'string') {return { valid: false, error: 'conversation_id must be a string' };}- if (- request.code_workspaces !== undefined &&- !isCodeWorkspaceSelections(request.code_workspaces)- ) {+ if (request.code_environment_mode !== undefined || request.code_workspaces !== undefined) {return {valid: false,- error: 'code_workspaces must contain unique environment/workspace selections',+ error:+ 'code_environment_mode and code_workspaces are not supported by this service because it cannot enforce a persisted conversation decision',};}@@ -655,7 +652,6 @@ export async function createAgentChatCompletion(const mcpRequestBody = createMCPRuntimeRequestBody({messageId: requestId,conversationId,- codeWorkspaces: request.code_workspaces,parentMessageId: mcpParentMessageId,});const created = Math.floor(Date.now() / 1000);diff --git a/packages/api/src/agents/openai/types.ts b/packages/api/src/agents/openai/types.tsindex c1b36b9287..623f7de9c0 100644--- a/packages/api/src/agents/openai/types.ts+++ b/packages/api/src/agents/openai/types.ts@@ -73,8 +73,6 @@ export interface ChatCompletionRequest {user?: string;/** Conversation ID (LibreChat extension) */conversation_id?: string;- /** Explicit registered workspaces for attached agents (LibreChat extension). */- code_workspaces?: import('librechat-data-provider').CodeWorkspaceSelection[];/** Parent message ID (LibreChat extension) */parent_message_id?: string;}diff --git a/packages/api/src/agents/responses/service.ts b/packages/api/src/agents/responses/service.tsindex 0b538b6f4f..4a0f74d165 100644--- a/packages/api/src/agents/responses/service.ts+++ b/packages/api/src/agents/responses/service.ts@@ -4,7 +4,7 @@* Core service for processing Open Responses API requests.* Handles input conversion, message formatting, and request validation.*/-import { isCodeWorkspaceSelections } from 'librechat-data-provider';+import { isCodeEnvironmentMode, isCodeWorkspaceSelections } from 'librechat-data-provider';import type { Response as ServerResponse } from 'express';import type {RequestValidationResult,@@ -81,6 +81,12 @@ export function validateResponseRequest(body: unknown): RequestValidationResult}const request = body as Record<string, unknown>;+ if (+ request.code_environment_mode !== undefined &&+ !isCodeEnvironmentMode(request.code_environment_mode)+ ) {+ return { valid: false, error: 'code_environment_mode is invalid' };+ }if (request.code_workspaces !== undefined &&!isCodeWorkspaceSelections(request.code_workspaces)diff --git a/packages/api/src/agents/responses/types.ts b/packages/api/src/agents/responses/types.tsindex d5bf1dbcb7..161adc4f90 100644--- a/packages/api/src/agents/responses/types.ts+++ b/packages/api/src/agents/responses/types.ts@@ -326,6 +326,8 @@ export type Metadata = Record<string, string>;/** Open Responses API Request */export interface ResponseRequest {+ /** Immutable attached-environment choice (LibreChat extension). */+ code_environment_mode?: import('librechat-data-provider').CodeEnvironmentMode;/** Explicit registered workspaces for attached agents (LibreChat extension). */code_workspaces?: import('librechat-data-provider').CodeWorkspaceSelection[];/** Model/agent ID to use */diff --git a/packages/api/src/code/capabilities.spec.ts b/packages/api/src/code/capabilities.spec.tsindex 4bf08e2b5c..a820f6cd69 100644--- a/packages/api/src/code/capabilities.spec.ts+++ b/packages/api/src/code/capabilities.spec.ts@@ -444,6 +444,39 @@ describe('resolveCodeExecutionWorkspaceContext', () => {});});+ it('accepts an equivalent retry regardless of selection order', async () => {+ jest.spyOn(globalThis, 'fetch').mockResolvedValue(workspaceStatus([{ id: 'project-a' }]));+ const personal = { environmentId: 'personal', workspaceId: 'project-a' };+ const team = { environmentId: 'team', workspaceId: 'project-b' };++ await expect(+ resolveCodeExecutionWorkspaceContext({+ context,+ requestedSelections: [team, personal],+ persistedSelections: [personal, team],+ environments,+ getAppConfig,+ }),+ ).resolves.toMatchObject({ codeWorkspace: personal });+ });++ it('rejects a request that changes a persisted workspace before contacting Code API', async () => {+ const fetchSpy = jest+ .spyOn(globalThis, 'fetch')+ .mockRejectedValue(new Error('Unexpected status request'));++ await expect(+ resolveCodeExecutionWorkspaceContext({+ context,+ requestedSelections: [{ environmentId: 'personal', workspaceId: 'project-b' }],+ persistedSelections: [{ environmentId: 'personal', workspaceId: 'project-a' }],+ environments,+ getAppConfig,+ }),+ ).rejects.toMatchObject({ reason: 'locked' });+ expect(fetchSpy).not.toHaveBeenCalled();+ });+it('fails when the saved workspace disappears instead of selecting another', async () => {jest.spyOn(globalThis, 'fetch').mockResolvedValue(workspaceStatus([{ id: 'replacement' }]));diff --git a/packages/api/src/code/capabilities.ts b/packages/api/src/code/capabilities.tsindex 9014784efd..9f049247a8 100644--- a/packages/api/src/code/capabilities.ts+++ b/packages/api/src/code/capabilities.ts@@ -29,7 +29,9 @@ function codeWorkspaceSelectionErrorMessage(reason: CodeWorkspaceSelectionErrorRcase 'unsupported':return 'The attached code environment does not advertise selectable workspaces. Update the LibreChat Code worker and try again.';case 'missing':- return 'The selected workspace is no longer registered on this machine. Choose another workspace explicitly or restore the previous registration.';+ return 'The selected workspace is no longer registered on this machine. Restore the previous registration or start a new conversation.';+ case 'locked':+ return 'This conversation already has a different code environment decision.';}}@@ -44,6 +46,28 @@ export class CodeWorkspaceSelectionError extends Error {}}+function canonicalWorkspaceSelections(+ selections: CodeWorkspaceSelection[],+): CodeWorkspaceSelection[] {+ return [...selections].sort((left, right) => {+ if (left.environmentId < right.environmentId) return -1;+ if (left.environmentId > right.environmentId) return 1;+ if (left.workspaceId < right.workspaceId) return -1;+ if (left.workspaceId > right.workspaceId) return 1;+ return 0;+ });+}++function sameWorkspaceSelections(+ left: CodeWorkspaceSelection[],+ right: CodeWorkspaceSelection[],+): boolean {+ return (+ JSON.stringify(canonicalWorkspaceSelections(left)) ===+ JSON.stringify(canonicalWorkspaceSelections(right))+ );+}+async function readAuthorizedAttachedWorkerStatus(context: CodeExecutionContext,environments: readonly CodeEnvironmentConfig[] | undefined,@@ -91,12 +115,7 @@ async function readAuthorizedAttachedWorkerStatus(});}-/**- * Resolves a conversation preference into a live worker capability. Request- * state wins so a user can deliberately change directories on this turn;- * persisted state supplies reconnect and non-browser clients. Neither path is- * trusted until the worker confirms the exact environment/workspace pair.- */+/** Resolves an immutable conversation selection into a live worker capability. */export async function resolveCodeExecutionWorkspaceContext({context,requestedSelections,@@ -111,8 +130,16 @@ export async function resolveCodeExecutionWorkspaceContext({getAppConfig?: CodeCapabilityConfigLoader;}): Promise<CodeExecutionContext> {if (context.environmentType !== 'attached') return context;- const rawSelections =- requestedSelections === undefined ? persistedSelections : requestedSelections;+ if (+ persistedSelections !== undefined &&+ requestedSelections !== undefined &&+ (!isCodeWorkspaceSelections(persistedSelections) ||+ !isCodeWorkspaceSelections(requestedSelections) ||+ !sameWorkspaceSelections(persistedSelections, requestedSelections))+ ) {+ throw new CodeWorkspaceSelectionError('locked');+ }+ const rawSelections = persistedSelections ?? requestedSelections;if (rawSelections == null) {throw new CodeWorkspaceSelectionError('required');}diff --git a/packages/api/src/code/config.spec.ts b/packages/api/src/code/config.spec.tsindex b3f3a31042..c6a4c0608c 100644--- a/packages/api/src/code/config.spec.ts+++ b/packages/api/src/code/config.spec.ts@@ -1,6 +1,31 @@import { EModelEndpoint } from 'librechat-data-provider';import type { AppConfig } from '@librechat/data-schemas';-import { mergeAccessibleCodeEnvironments } from './config';+import {+ isImplicitStatefulCodeRouteAvailable,+ mergeAccessibleCodeEnvironments,+ resolveCodeEnvironmentDecisionVersion,+} from './config';++describe('resolveCodeEnvironmentDecisionVersion', () => {+ it('advertises the exact supported protocol version', () => {+ expect(resolveCodeEnvironmentDecisionVersion('1')).toBe(1);+ });++ it.each([undefined, '0', '2', '1.0', 'true'])(+ 'keeps unsupported configured version %s on the legacy-safe path',+ (version) => {+ expect(resolveCodeEnvironmentDecisionVersion(version)).toBeUndefined();+ },+ );+});++describe('isImplicitStatefulCodeRouteAvailable', () => {+ it('requires both the deployed protocol version and a non-empty managed base URL', () => {+ expect(isImplicitStatefulCodeRouteAvailable('1', 'https://code.example/v1')).toBe(true);+ expect(isImplicitStatefulCodeRouteAvailable(undefined, 'https://code.example/v1')).toBe(false);+ expect(isImplicitStatefulCodeRouteAvailable('1', ' ')).toBe(false);+ });+});describe('mergeAccessibleCodeEnvironments', () => {test('adds principal environments without allowing them to shadow deployment entries', async () => {diff --git a/packages/api/src/code/config.ts b/packages/api/src/code/config.tsindex aa7e8414cd..922263cfe8 100644--- a/packages/api/src/code/config.ts+++ b/packages/api/src/code/config.ts@@ -1,5 +1,5 @@import { logger } from '@librechat/data-schemas';-import { EModelEndpoint } from 'librechat-data-provider';+import { CODE_ENVIRONMENT_DECISION_VERSION, EModelEndpoint } from 'librechat-data-provider';import type { AppConfig } from '@librechat/data-schemas';import type {AccessibleCodeEnvironmentConfiguration,@@ -18,6 +18,29 @@ type StatefulCodeConfig = NonNullable<>['statefulCodeSessions'];type CodeEnvironmentConfig = NonNullable<NonNullable<StatefulCodeConfig>['environments']>[number];+/**+ * Resolves the deployment-wide browser protocol gate. The exact version match+ * keeps older and future wire shapes on the legacy-safe path.+ */+export function resolveCodeEnvironmentDecisionVersion(+ configuredVersion?: string,+): typeof CODE_ENVIRONMENT_DECISION_VERSION | undefined {+ return configuredVersion === String(CODE_ENVIRONMENT_DECISION_VERSION)+ ? CODE_ENVIRONMENT_DECISION_VERSION+ : undefined;+}++/** Enables the implicit managed route only after the versioned rollout is complete. */+export function isImplicitStatefulCodeRouteAvailable(+ configuredVersion?: string,+ statefulBaseURL?: string,+): boolean {+ return (+ resolveCodeEnvironmentDecisionVersion(configuredVersion) != null &&+ (statefulBaseURL?.trim().length ?? 0) > 0+ );+}+function isExecutableCodeEnvironment(environment: CodeEnvironmentConfig): boolean {return !(environment.pairing?.allowPrincipalWorkers === true &&diff --git a/packages/api/src/code/decision.spec.ts b/packages/api/src/code/decision.spec.tsnew file mode 100644index 0000000000..1a145ba76d--- /dev/null+++ b/packages/api/src/code/decision.spec.ts@@ -0,0 +1,123 @@+import { resolveConversationCodeEnvironmentDecision } from './decision';+import { CodeWorkspaceSelectionError } from './capabilities';++const selection = { environmentId: 'personal-vm', workspaceId: 'project-a' };++describe('resolveConversationCodeEnvironmentDecision', () => {+ it('defaults a new conversation without a selection to no attached environment', () => {+ expect(resolveConversationCodeEnvironmentDecision({ conversationId: 'new' })).toEqual({+ mode: 'without_attached',+ });+ });++ it('accepts and canonicalizes a new attached decision', () => {+ expect(+ resolveConversationCodeEnvironmentDecision({+ conversationId: 'new',+ requestedMode: 'attached',+ requestedSelections: [{ environmentId: 'team-vm', workspaceId: 'project-b' }, selection],+ }),+ ).toEqual({+ mode: 'attached',+ codeWorkspaces: [selection, { environmentId: 'team-vm', workspaceId: 'project-b' }],+ });+ });++ it('infers legacy persisted decisions', () => {+ expect(+ resolveConversationCodeEnvironmentDecision({+ conversationId: 'conversation-1',+ conversation: { conversationId: 'conversation-1', codeWorkspaces: [selection] },+ }),+ ).toEqual({ mode: 'attached', codeWorkspaces: [selection] });+ expect(+ resolveConversationCodeEnvironmentDecision({+ conversationId: 'conversation-1',+ conversation: { conversationId: 'conversation-1' },+ }),+ ).toEqual({ mode: 'without_attached' });+ });++ it('allows an identical retry of a persisted decision', () => {+ expect(+ resolveConversationCodeEnvironmentDecision({+ conversationId: 'conversation-1',+ requestedMode: 'attached',+ requestedSelections: [selection],+ conversation: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [selection],+ },+ }),+ ).toEqual({ mode: 'attached', codeWorkspaces: [selection] });+ });++ it.each([+ {+ requestedMode: 'without_attached',+ requestedSelections: undefined,+ },+ {+ requestedMode: 'attached',+ requestedSelections: [{ environmentId: 'personal-vm', workspaceId: 'project-b' }],+ },+ ])('rejects a conflicting change to a persisted attached decision', (requested) => {+ expect(() =>+ resolveConversationCodeEnvironmentDecision({+ conversationId: 'conversation-1',+ ...requested,+ conversation: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'attached',+ codeWorkspaces: [selection],+ },+ }),+ ).toThrow(expect.objectContaining<Partial<CodeWorkspaceSelectionError>>({ reason: 'locked' }));+ });++ it('rejects attaching a workspace to a conversation locked without one', () => {+ expect(() =>+ resolveConversationCodeEnvironmentDecision({+ conversationId: 'conversation-1',+ requestedMode: 'attached',+ requestedSelections: [selection],+ conversation: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'without_attached',+ },+ }),+ ).toThrow(expect.objectContaining<Partial<CodeWorkspaceSelectionError>>({ reason: 'locked' }));+ });++ it('rejects contradictory decision fields', () => {+ expect(() =>+ resolveConversationCodeEnvironmentDecision({+ conversationId: 'new',+ requestedMode: 'without_attached',+ requestedSelections: [selection],+ }),+ ).toThrow(expect.objectContaining<Partial<CodeWorkspaceSelectionError>>({ reason: 'invalid' }));+ expect(() =>+ resolveConversationCodeEnvironmentDecision({+ conversationId: 'new',+ requestedMode: 'attached',+ }),+ ).toThrow(+ expect.objectContaining<Partial<CodeWorkspaceSelectionError>>({ reason: 'required' }),+ );+ });++ it('rejects an invalid persisted mode instead of treating it as attached', () => {+ expect(() =>+ resolveConversationCodeEnvironmentDecision({+ conversationId: 'conversation-1',+ conversation: {+ conversationId: 'conversation-1',+ codeEnvironmentMode: 'future-mode' as never,+ codeWorkspaces: [selection],+ },+ }),+ ).toThrow(expect.objectContaining<Partial<CodeWorkspaceSelectionError>>({ reason: 'invalid' }));+ });+});diff --git a/packages/api/src/code/decision.ts b/packages/api/src/code/decision.tsnew file mode 100644index 0000000000..01f54ffbcc--- /dev/null+++ b/packages/api/src/code/decision.ts@@ -0,0 +1,104 @@+import { isCodeEnvironmentMode, isCodeWorkspaceSelections } from 'librechat-data-provider';+import type {+ CodeEnvironmentMode,+ CodeWorkspaceSelection,+ TConversation,+} from 'librechat-data-provider';+import { CodeWorkspaceSelectionError } from './capabilities';++export interface ConversationCodeEnvironmentDecision {+ mode: CodeEnvironmentMode;+ codeWorkspaces?: CodeWorkspaceSelection[];+}++type StoredConversationDecision = Pick<+ TConversation,+ 'conversationId' | 'codeEnvironmentMode' | 'codeWorkspaces'+>;++function canonicalSelections(selections: CodeWorkspaceSelection[]): CodeWorkspaceSelection[] {+ return [...selections].sort((left, right) => {+ if (left.environmentId < right.environmentId) return -1;+ if (left.environmentId > right.environmentId) return 1;+ if (left.workspaceId < right.workspaceId) return -1;+ if (left.workspaceId > right.workspaceId) return 1;+ return 0;+ });+}++function sameSelections(left: CodeWorkspaceSelection[], right: CodeWorkspaceSelection[]): boolean {+ return JSON.stringify(canonicalSelections(left)) === JSON.stringify(canonicalSelections(right));+}++function validateDecision(mode: unknown, selections: unknown): ConversationCodeEnvironmentDecision {+ if (!isCodeEnvironmentMode(mode)) {+ throw new CodeWorkspaceSelectionError('invalid');+ }+ if (mode === 'without_attached') {+ if (+ selections !== undefined &&+ (!isCodeWorkspaceSelections(selections) || selections.length > 0)+ ) {+ throw new CodeWorkspaceSelectionError('invalid');+ }+ return { mode };+ }+ if (!isCodeWorkspaceSelections(selections) || selections.length === 0) {+ throw new CodeWorkspaceSelectionError('required');+ }+ return { mode, codeWorkspaces: canonicalSelections(selections) };+}++/** Resolves one immutable conversation choice before attached tools are registered. */+export function resolveConversationCodeEnvironmentDecision({+ conversationId,+ requestedMode,+ requestedSelections,+ conversation,+}: {+ conversationId: string;+ requestedMode?: unknown;+ requestedSelections?: unknown;+ conversation?: StoredConversationDecision | null;+}): ConversationCodeEnvironmentDecision {+ const ownsConversation = conversation != null && conversation.conversationId === conversationId;+ const persistedMode = ownsConversation ? conversation.codeEnvironmentMode : undefined;+ const persistedSelections = ownsConversation ? conversation.codeWorkspaces : undefined;+ let inferredPersistedMode: unknown = persistedMode;+ if (inferredPersistedMode == null && ownsConversation) {+ inferredPersistedMode = persistedSelections?.length ? 'attached' : 'without_attached';+ }++ if (inferredPersistedMode != null) {+ const persisted = validateDecision(inferredPersistedMode, persistedSelections);+ if (requestedMode !== undefined && requestedMode !== persisted.mode) {+ throw new CodeWorkspaceSelectionError('locked');+ }+ if (+ persisted.mode === 'attached' &&+ requestedSelections !== undefined &&+ (!isCodeWorkspaceSelections(requestedSelections) ||+ !sameSelections(requestedSelections, persisted.codeWorkspaces ?? []))+ ) {+ throw new CodeWorkspaceSelectionError('locked');+ }+ if (+ persisted.mode === 'without_attached' &&+ requestedSelections !== undefined &&+ (!isCodeWorkspaceSelections(requestedSelections) || requestedSelections.length > 0)+ ) {+ throw new CodeWorkspaceSelectionError('locked');+ }+ return persisted;+ }++ if (requestedMode !== undefined && !isCodeEnvironmentMode(requestedMode)) {+ throw new CodeWorkspaceSelectionError('invalid');+ }+ const mode =+ requestedMode ??+ (isCodeWorkspaceSelections(requestedSelections) && requestedSelections.length > 0+ ? 'attached'+ : 'without_attached');+ return validateDecision(mode, requestedSelections);+}diff --git a/packages/api/src/code/errors.spec.ts b/packages/api/src/code/errors.spec.tsindex a0945f04cf..2efac324f5 100644--- a/packages/api/src/code/errors.spec.ts+++ b/packages/api/src/code/errors.spec.ts@@ -1,5 +1,8 @@import { ErrorTypes } from 'librechat-data-provider';-import { getCodeWorkspaceSelectionErrorDetails } from './errors';+import {+ getCodeWorkspaceSelectionErrorDetails,+ shouldPersistCodeWorkspaceInitializationError,+} from './errors';describe('getCodeWorkspaceSelectionErrorDetails', () => {it.each(['required', 'invalid', 'worker_unavailable', 'unsupported', 'missing'] as const)(@@ -23,3 +26,40 @@ describe('getCodeWorkspaceSelectionErrorDetails', () => {expect(getCodeWorkspaceSelectionErrorDetails(error)).toEqual({});});});++describe('shouldPersistCodeWorkspaceInitializationError', () => {+ it('keeps a rejected first-turn decision retryable', () => {+ expect(+ shouldPersistCodeWorkspaceInitializationError({+ streamStarted: true,+ isNewConversation: true,+ failureCode: ErrorTypes.CODE_WORKSPACE_UNAVAILABLE,+ hasValidatedDecision: false,+ }),+ ).toBe(false);+ });++ it.each([+ { isNewConversation: false, hasValidatedDecision: false },+ { isNewConversation: true, hasValidatedDecision: true },+ ])('persists an initialized workspace failure for %o', (state) => {+ expect(+ shouldPersistCodeWorkspaceInitializationError({+ streamStarted: true,+ failureCode: ErrorTypes.CODE_WORKSPACE_UNAVAILABLE,+ ...state,+ }),+ ).toBe(true);+ });++ it('does not persist any initialization error before the stream starts', () => {+ expect(+ shouldPersistCodeWorkspaceInitializationError({+ streamStarted: false,+ isNewConversation: false,+ failureCode: 'MODEL_UNAVAILABLE',+ hasValidatedDecision: true,+ }),+ ).toBe(false);+ });+});diff --git a/packages/api/src/code/errors.ts b/packages/api/src/code/errors.tsindex ff71e8c1fc..4bf582e3ee 100644--- a/packages/api/src/code/errors.ts+++ b/packages/api/src/code/errors.ts@@ -21,3 +21,29 @@ export function getCodeWorkspaceSelectionErrorDetails(}return { reason: error.reason };}++/**+ * A rejected decision must remain retryable. Publishing the generation error+ * is safe, but persisting a first-turn conversation without a validated+ * decision would turn the retry into a locked legacy conversation.+ */+export function shouldPersistCodeWorkspaceInitializationError({+ streamStarted,+ isNewConversation,+ failureCode,+ hasValidatedDecision,+}: {+ streamStarted: boolean;+ isNewConversation: boolean;+ failureCode?: string;+ hasValidatedDecision: boolean;+}): boolean {+ if (!streamStarted) {+ return false;+ }+ return !(+ isNewConversation &&+ failureCode === ErrorTypes.CODE_WORKSPACE_UNAVAILABLE &&+ !hasValidatedDecision+ );+}diff --git a/packages/api/src/code/index.ts b/packages/api/src/code/index.tsindex 4006a47405..219208b069 100644--- a/packages/api/src/code/index.ts+++ b/packages/api/src/code/index.ts@@ -6,4 +6,5 @@ export * from './lifecycle';export * from './workspace';export * from './command';export * from './capabilities';+export * from './decision';export * from './errors';diff --git a/packages/api/src/code/remoteWorkspace.spec.ts b/packages/api/src/code/remoteWorkspace.spec.tsindex 4333837b0e..a2a4428d53 100644--- a/packages/api/src/code/remoteWorkspace.spec.ts+++ b/packages/api/src/code/remoteWorkspace.spec.ts@@ -4,29 +4,36 @@ import { validateRequest } from '../agents/openai/service';const selections = [{ environmentId: 'machine', workspaceId: 'project' }];describe('remote workspace selection envelopes', () => {- it.each([- [- 'chat completions',- (code_workspaces: unknown) =>- validateRequest({- model: 'agent',- messages: [{ role: 'user', content: 'hello' }],- code_workspaces,- }),- ],- [- 'responses',- (code_workspaces: unknown) =>- validateResponseRequest({ model: 'agent', input: 'hello', code_workspaces }),- ],- ] as const)(- 'validates %s selection identity without accepting duplicate environments',- (_name, validate) => {- expect(validate(selections).valid).toBe(true);- expect(validate([...selections, ...selections]).valid).toBe(false);- expect(validate([{ ...selections[0], path: '/secret' }]).valid).toBe(false);- },- );+ it('rejects workspace extensions on chat completions, which cannot persist the decision', () => {+ expect(+ validateRequest({+ model: 'agent',+ messages: [{ role: 'user', content: 'hello' }],+ code_workspaces: selections,+ }).valid,+ ).toBe(false);+ });++ it('validates responses selection identity without accepting duplicate environments', () => {+ expect(+ validateResponseRequest({ model: 'agent', input: 'hello', code_workspaces: selections })+ .valid,+ ).toBe(true);+ expect(+ validateResponseRequest({+ model: 'agent',+ input: 'hello',+ code_workspaces: [...selections, ...selections],+ }).valid,+ ).toBe(false);+ expect(+ validateResponseRequest({+ model: 'agent',+ input: 'hello',+ code_workspaces: [{ ...selections[0], path: '/secret' }],+ }).valid,+ ).toBe(false);+ });it('carries selections into the runtime envelope', () => {expect(createMCPRuntimeRequestBody({diff --git a/packages/api/src/mcp/request.ts b/packages/api/src/mcp/request.tsindex 93a9aa749a..df5cf9f64e 100644--- a/packages/api/src/mcp/request.ts+++ b/packages/api/src/mcp/request.ts@@ -15,16 +15,19 @@ export function createMCPRuntimeRequestBody({messageId,conversationId,parentMessageId,+ codeEnvironmentMode,codeWorkspaces,}: {messageId: string;conversationId: string;parentMessageId?: string | null;+ codeEnvironmentMode?: MCPRuntimeRequestBody['codeEnvironmentMode'];codeWorkspaces?: MCPRuntimeRequestBody['codeWorkspaces'];}): MCPRuntimeRequestBody {return {messageId,conversationId,+ ...(codeEnvironmentMode !== undefined && { codeEnvironmentMode }),...(codeWorkspaces !== undefined && { codeWorkspaces }),...(parentMessageId !== undefined && {parentMessageId: parentMessageId ?? Constants.NO_PARENT,diff --git a/packages/api/src/mcp/types/index.ts b/packages/api/src/mcp/types/index.tsindex 03f604ff36..8fac212b02 100644--- a/packages/api/src/mcp/types/index.ts+++ b/packages/api/src/mcp/types/index.ts@@ -28,7 +28,7 @@ import type { RequestBody } from '~/types/http';import type * as o from '~/mcp/oauth/types';export type MCPRuntimeRequestBody = Required<Pick<RequestBody, 'messageId' | 'conversationId'>> &- Pick<RequestBody, 'parentMessageId' | 'codeWorkspaces'>;+ Pick<RequestBody, 'parentMessageId' | 'codeEnvironmentMode' | 'codeWorkspaces'>;export type StdioOptions = z.infer<typeof StdioOptionsSchema>;export type WebSocketOptions = z.infer<typeof WebSocketOptionsSchema>;diff --git a/packages/api/src/types/http.ts b/packages/api/src/types/http.tsindex a5f6121606..2ead23ff08 100644--- a/packages/api/src/types/http.ts+++ b/packages/api/src/types/http.ts@@ -1,5 +1,6 @@import type {CodeApprovalMode,+ CodeEnvironmentMode,CodeWorkspaceSelection,TEndpointOption,Agents,@@ -25,6 +26,7 @@ export type RequestBody = {/** Browser IANA timezone used to resolve local-time prompt variables (e.g. `{{current_datetime}}`). */timezone?: string;codeApprovalMode?: CodeApprovalMode;+ codeEnvironmentMode?: CodeEnvironmentMode;codeWorkspaces?: CodeWorkspaceSelection[];};diff --git a/packages/data-provider/specs/codeWorkspace.spec.ts b/packages/data-provider/specs/codeWorkspace.spec.tsindex ae5786c8bb..543dbd4150 100644--- a/packages/data-provider/specs/codeWorkspace.spec.ts+++ b/packages/data-provider/specs/codeWorkspace.spec.ts@@ -1,4 +1,18 @@-import { isCodeWorkspaceSelection, isCodeWorkspaceSelections } from '../src/code/workspace';+import {+ isCodeEnvironmentMode,+ isCodeWorkspaceSelection,+ isCodeWorkspaceSelections,+} from '../src/code/workspace';++describe('isCodeEnvironmentMode', () => {+ it.each(['attached', 'without_attached'])('accepts %s', (mode) => {+ expect(isCodeEnvironmentMode(mode)).toBe(true);+ });++ it.each(['managed', 'none', '', null])('rejects %p', (mode) => {+ expect(isCodeEnvironmentMode(mode)).toBe(false);+ });+});describe('isCodeWorkspaceSelection', () => {it('accepts an exact environment/workspace binding', () => {diff --git a/packages/data-provider/specs/createPayload.spec.ts b/packages/data-provider/specs/createPayload.spec.tsindex 7d8de11e8b..d0c1a8780d 100644--- a/packages/data-provider/specs/createPayload.spec.ts+++ b/packages/data-provider/specs/createPayload.spec.ts@@ -49,8 +49,10 @@ describe('createPayload server URL', () => {it('forwards the conversation-selected code workspace to agents', () => {const submission = makeSubmission('agents');+ submission.codeEnvironmentMode = 'attached';submission.codeWorkspaces = [{ environmentId: 'personal-vm', workspaceId: 'project-a' }];+ expect(createPayload(submission).payload.codeEnvironmentMode).toBe('attached');expect(createPayload(submission).payload.codeWorkspaces).toEqual([{ environmentId: 'personal-vm', workspaceId: 'project-a' },]);diff --git a/packages/data-provider/src/code/workspace.ts b/packages/data-provider/src/code/workspace.tsindex 9b352156ea..532c6c0592 100644--- a/packages/data-provider/src/code/workspace.ts+++ b/packages/data-provider/src/code/workspace.ts@@ -1,6 +1,8 @@export const CODE_WORKSPACE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;/** Protocol-v1 ceiling enforced by the worker and Code API. */export const CODE_WORKSPACE_MAX_COUNT = 32;+/** API/client protocol for immutable conversation-owned environment decisions. */+export const CODE_ENVIRONMENT_DECISION_VERSION = 1 as const;export const CODE_WORKSPACE_OPERATIONS = ['read_file','search_text',@@ -16,11 +18,14 @@ export const CODE_WORKSPACE_SELECTION_ERROR_REASONS = ['worker_unavailable','unsupported','missing',+ 'locked',] as const;+export const CODE_ENVIRONMENT_MODES = ['attached', 'without_attached'] as const;export type CodeWorkspaceOperation = (typeof CODE_WORKSPACE_OPERATIONS)[number];export type CodeWorkspaceSelectionErrorReason =(typeof CODE_WORKSPACE_SELECTION_ERROR_REASONS)[number];+export type CodeEnvironmentMode = (typeof CODE_ENVIRONMENT_MODES)[number];/** Public, path-free description of one root registered by an attached worker. */export interface CodeWorkspaceDescriptor {@@ -36,6 +41,10 @@ export interface CodeWorkspaceSelection {workspaceId: string;}+export function isCodeEnvironmentMode(value: unknown): value is CodeEnvironmentMode {+ return CODE_ENVIRONMENT_MODES.some((mode) => mode === value);+}+export function isCodeWorkspaceSelectionErrorReason(value: unknown,): value is CodeWorkspaceSelectionErrorReason {diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex 13bfa03cb7..1799e71653 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -18,6 +18,7 @@ import {eReasoningResponseKeySchema,} from './schemas';import { ComponentTypes, SettingTypes, OptionTypes } from './generate';+import { CODE_ENVIRONMENT_DECISION_VERSION } from './code/workspace';import { MAX_SUBAGENTS, MAX_SUBAGENTS_CEILING } from './limits';import { STATEFUL_CODE_ENVIRONMENTS } from './stateful-code';import { specsConfigSchema, TSpecsConfig } from './models';@@ -2116,6 +2117,9 @@ export type TStartupConfig = {/** Manual context compaction, gated by the same `summarization.enabled`* switch that governs the automatic detour. */compactionEnabled?: boolean;+ /** Conversation-owned code-environment decision protocol supported by the API.+ * Clients must not emit selection-less decisions unless this is advertised. */+ codeEnvironmentDecisionVersion?: typeof CODE_ENVIRONMENT_DECISION_VERSION;interface?: TInterfaceConfig;turnstile?: TTurnstileConfig;balance?: TBalanceConfig;diff --git a/packages/data-provider/src/createPayload.ts b/packages/data-provider/src/createPayload.tsindex dcad9ff5ae..6d080df248 100644--- a/packages/data-provider/src/createPayload.ts+++ b/packages/data-provider/src/createPayload.ts@@ -26,6 +26,7 @@ export default function createPayload(submission: t.TSubmission) {endpointOption,manualSkills,codeApprovalMode,+ codeEnvironmentMode,codeWorkspaces,clientRequestId,recoverySteerId,@@ -63,6 +64,7 @@ export default function createPayload(submission: t.TSubmission) {ephemeralAgent: s.isAssistantsEndpoint(endpoint) ? undefined : ephemeralAgent,manualSkills: s.isAssistantsEndpoint(endpoint) ? undefined : manualSkills,codeApprovalMode: s.isAssistantsEndpoint(endpoint) ? undefined : codeApprovalMode,+ codeEnvironmentMode: s.isAssistantsEndpoint(endpoint) ? undefined : codeEnvironmentMode,codeWorkspaces: s.isAssistantsEndpoint(endpoint) ? undefined : codeWorkspaces,timezone: getUserTimezone(),clientRequestId,diff --git a/packages/data-provider/src/schemas.ts b/packages/data-provider/src/schemas.tsindex 434aaa3633..7b13105363 100644--- a/packages/data-provider/src/schemas.ts+++ b/packages/data-provider/src/schemas.ts@@ -2,8 +2,8 @@ import { z } from 'zod';import type { TMessageContentParts, AgentSubagentGraph, FunctionTool } from './types/assistants';import type { SearchResultData } from './types/web';import type { TFile } from './types/files';+import { CODE_ENVIRONMENT_MODES, CODE_WORKSPACE_ID_PATTERN } from './code/workspace';import { userSubmittedMessageFieldPathSchema } from './filters';-import { CODE_WORKSPACE_ID_PATTERN } from './code/workspace';import { TFeedback, feedbackSchema } from './feedback';import { CODE_APPROVAL_MODES } from './code/approval';import { Tools } from './types/assistants';@@ -1120,6 +1120,7 @@ export const tConversationSchema = z.object({/** Server-derived: an active shared link exists for this conversation. Not persisted. */isShared: z.boolean().optional(),codeApprovalMode: z.enum(CODE_APPROVAL_MODES).optional(),+ codeEnvironmentMode: z.enum(CODE_ENVIRONMENT_MODES).optional(),codeWorkspaces: z.array(zdiff --git a/packages/data-provider/src/types.ts b/packages/data-provider/src/types.tsindex 946d9bf57e..c159aecbf1 100644--- a/packages/data-provider/src/types.ts+++ b/packages/data-provider/src/types.ts@@ -12,6 +12,7 @@ import type {} from './schemas';import type {CodeWorkspaceDescriptor,+ CodeEnvironmentMode,CodeWorkspaceOperation,CodeWorkspaceSelection,} from './code/workspace';@@ -161,6 +162,8 @@ export type TPayload = Partial<TMessage> &manualSkills?: string[];/** Conversation-scoped preference for code tool approval behavior. */codeApprovalMode?: CodeApprovalMode;+ /** Immutable conversation choice for attached code execution. */+ codeEnvironmentMode?: CodeEnvironmentMode;/** Conversation-selected workspaces, with at most one binding per environment. */codeWorkspaces?: CodeWorkspaceSelection[];/** Browser IANA timezone (e.g. `America/New_York`) used to resolve local-time prompt variables server-side. */@@ -244,6 +247,8 @@ export type TSubmission = {manualSkills?: string[];/** Conversation-scoped preference for code tool approval behavior. */codeApprovalMode?: CodeApprovalMode;+ /** Immutable conversation choice for attached code execution. */+ codeEnvironmentMode?: CodeEnvironmentMode;/** Conversation-selected workspaces, with at most one binding per environment. */codeWorkspaces?: CodeWorkspaceSelection[];/** Stable per-submission idempotency key (uuid) forwarded to the server to dedup retried start-generation requests. */diff --git a/packages/data-provider/src/types/agents.ts b/packages/data-provider/src/types/agents.tsindex f07e7944e2..e95baff743 100644--- a/packages/data-provider/src/types/agents.ts+++ b/packages/data-provider/src/types/agents.ts@@ -539,6 +539,8 @@ export namespace Agents {* so the id check can't.*/requestFingerprint?: string;+ /** Current-version fingerprint; server-only and omitted from client projections. */+ requestFingerprintV2?: string;/*** Graph-determining request fields (endpoint, agent_id, model, spec, promptPrefix,* ephemeralAgent) captured at pause. The resume route REPLAYS these onto the requestdiff --git a/packages/data-schemas/src/schema/defaults.ts b/packages/data-schemas/src/schema/defaults.tsindex 9aee90dcdc..3bc5a32140 100644--- a/packages/data-schemas/src/schema/defaults.ts+++ b/packages/data-schemas/src/schema/defaults.ts@@ -1,5 +1,5 @@import { Schema } from 'mongoose';-import { CODE_APPROVAL_MODES } from 'librechat-data-provider';+import { CODE_APPROVAL_MODES, CODE_ENVIRONMENT_MODES } from 'librechat-data-provider';// @ts-ignoreexport const conversationPreset: {@@ -121,6 +121,10 @@ export const conversationPreset: {type: StringConstructor;enum: string[];};+ codeEnvironmentMode: {+ type: StringConstructor;+ enum: string[];+ };codeWorkspaces: {type: {environmentId: { type: StringConstructor; required: boolean };@@ -316,6 +320,10 @@ export const conversationPreset: {type: String,enum: [...CODE_APPROVAL_MODES],},+ codeEnvironmentMode: {+ type: String,+ enum: [...CODE_ENVIRONMENT_MODES],+ },codeWorkspaces: {type: [{diff --git a/packages/data-schemas/src/types/convo.ts b/packages/data-schemas/src/types/convo.tsindex 4b89956e8d..f61cc993bd 100644--- a/packages/data-schemas/src/types/convo.ts+++ b/packages/data-schemas/src/types/convo.ts@@ -1,5 +1,6 @@import type {CodeApprovalMode,+ CodeEnvironmentMode,CodeWorkspaceSelection,TSubagentThreadLineage,} from 'librechat-data-provider';@@ -270,6 +271,7 @@ export interface IConversation extends Document {imageDetail?: string;agent_id?: string;codeApprovalMode?: CodeApprovalMode;+ codeEnvironmentMode?: CodeEnvironmentMode;codeWorkspaces?: CodeWorkspaceSelection[];/** Immutable primary persisted-agent attribution for Insights. */initial_agent_id?: string | null;