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: Remember Agent Workspace Defaults (#15843)
Danny Avila1d45f5bd407a
diff --git a/api/server/controllers/agents/v1.js b/api/server/controllers/agents/v1.jsindex f728a5bd4d..635387f383 100644--- a/api/server/controllers/agents/v1.js+++ b/api/server/controllers/agents/v1.js@@ -38,6 +38,9 @@ const {isContentTraversalLimitError,resolveCanonicalFileReferences,reportLocatorTraversalFailure,+ reconcileAgentWorkspaceDefault,+ shouldValidateAgentWorkspaceDefaultBinding,+ validateAgentWorkspaceDefaultBinding,} = require('@librechat/api');const {Time,@@ -480,13 +483,27 @@ const validateStatefulCodeEnvironment = (environment,environmentId,environmentIdSelected = false,+ workspaceId,+ currentWorkspaceId,+ currentEnvironmentId,) => {+ const configuredEnvironments =+ req.config?.endpoints?.[EModelEndpoint.agents]?.statefulCodeSessions?.environments ?? [];+ const workspaceValidation = validateAgentWorkspaceDefaultBinding({+ workspaceId,+ environmentId,+ currentWorkspaceId,+ currentEnvironmentId,+ environments: configuredEnvironments,+ });+ if (!workspaceValidation.valid) {+ res.status(400).json({ error: workspaceValidation.error });+ return false;+ }if (enabled !== true && !environmentIdSelected) {return true;}if (environmentId != null) {- const configuredEnvironments =- req.config?.endpoints?.[EModelEndpoint.agents]?.statefulCodeSessions?.environments ?? [];const configuredEnvironment = configuredEnvironments.find((configured) => configured.id === environmentId,);@@ -780,6 +797,7 @@ const createAgentHandler = async (req, res) => {agentData.stateful_code_environment,agentData.code_environment_id,agentData.code_environment_id != null,+ agentData.code_workspace_id,)) {return;@@ -1066,7 +1084,7 @@ const updateAgentHandler = async (req, res) => {_id,...rest} = validatedData;- const updateData = removeNullishValues(rest);+ let updateData = removeNullishValues(rest);if (codeEnvironmentIdField !== undefined) {updateData.code_environment_id = codeEnvironmentIdField;}@@ -1079,10 +1097,12 @@ const updateAgentHandler = async (req, res) => {updateData.stateful_code_sessions !== undefined ||updateData.stateful_code_environment !== undefined ||updateData.code_environment_id !== undefined;+ const includesWorkspaceConfiguration = updateData.code_workspace_id !== undefined;const includesToolsConfiguration = Array.isArray(updateData.tools);const includesToolOptionsConfiguration = updateData.tool_options !== undefined;if (includesStatefulConfiguration ||+ includesWorkspaceConfiguration ||includesToolsConfiguration ||includesToolOptionsConfiguration) {@@ -1094,6 +1114,11 @@ const updateAgentHandler = async (req, res) => {const codeEnvironmentSelectionChanged =updateData.code_environment_id !== undefined &&updateData.code_environment_id !== existingAgent.code_environment_id;+ updateData = reconcileAgentWorkspaceDefault({+ update: updateData,+ request: validatedData,+ currentEnvironmentId: existingAgent.code_environment_id,+ });const statefulConfigurationChanged =(updateData.stateful_code_sessions !== undefined &&(updateData.stateful_code_sessions === true) !==@@ -1106,7 +1131,20 @@ const updateAgentHandler = async (req, res) => {includesToolsConfiguration &&updateData.tools.includes(Tools.execute_code) &&existingAgent.tools?.includes(Tools.execute_code) !== true;- if (statefulConfigurationChanged || activatesCodeExecution) {+ const effectiveCodeWorkspaceId =+ updateData.code_workspace_id ?? existingAgent.code_workspace_id;+ const selectsWorkspaceDefault =+ includesWorkspaceConfiguration &&+ shouldValidateAgentWorkspaceDefaultBinding({+ workspaceId: effectiveCodeWorkspaceId,+ environmentId:+ updateData.code_environment_id === null+ ? undefined+ : (updateData.code_environment_id ?? existingAgent.code_environment_id),+ currentWorkspaceId: existingAgent.code_workspace_id,+ currentEnvironmentId: existingAgent.code_environment_id,+ });+ if (statefulConfigurationChanged || selectsWorkspaceDefault || activatesCodeExecution) {const effectiveStatefulSessions =updateData.stateful_code_sessions ?? existingAgent.stateful_code_sessions;const effectiveStatefulEnvironment =@@ -1123,6 +1161,9 @@ const updateAgentHandler = async (req, res) => {effectiveStatefulEnvironment,effectiveCodeEnvironmentId,codeEnvironmentSelectionChanged,+ effectiveCodeWorkspaceId,+ existingAgent.code_workspace_id,+ existingAgent.code_environment_id,)) {return;@@ -1428,6 +1469,8 @@ const duplicateAgentHandler = async (req, res) => {newAgentData.stateful_code_sessions,newAgentData.stateful_code_environment,newAgentData.code_environment_id,+ false,+ newAgentData.code_workspace_id,)) {return;@@ -1829,6 +1872,7 @@ const getListAgentsHandler = async (req, res) => {limit,after: cursor,includeSkillConfig: true,+ includeExecutionConfig: true,});const agents = data?.data ?? [];@@ -2034,6 +2078,8 @@ const revertAgentVersionHandler = async (req, res) => {revertVersion.stateful_code_sessions,revertVersion.stateful_code_environment,revertVersion.code_environment_id,+ false,+ revertVersion.code_workspace_id,)) {return;diff --git a/api/server/controllers/agents/v1.spec.js b/api/server/controllers/agents/v1.spec.jsindex 91c351f795..a782d3f5b4 100644--- a/api/server/controllers/agents/v1.spec.js+++ b/api/server/controllers/agents/v1.spec.js@@ -316,6 +316,76 @@ describe('Agent Controllers - Mass Assignment Protection', () => {expect(await Agent.countDocuments()).toBe(0);});+ test('rejects a workspace default without an explicit attached environment', async () => {+ mockReq.config = {+ endpoints: {+ agents: {+ statefulCodeSessions: {+ allowedEnvironments: ['user'],+ environments: [+ {+ id: 'default-vm',+ name: 'Default VM',+ type: 'attached',+ baseURL: 'https://code.example.com/v1',+ default: true,+ },+ ],+ },+ },+ },+ };+ mockReq.body = {+ name: 'Unbound Workspace Agent',+ provider: 'openai',+ model: 'gpt-4',+ code_workspace_id: 'project-a',+ };++ await createAgentHandler(mockReq, mockRes);++ expect(mockRes.status).toHaveBeenCalledWith(400);+ expect(mockRes.json).toHaveBeenCalledWith({+ error: 'Code workspace defaults require an explicit attached code environment',+ });+ expect(await Agent.countDocuments()).toBe(0);+ });++ test('rejects a workspace default for a managed environment', async () => {+ mockReq.config = {+ endpoints: {+ agents: {+ statefulCodeSessions: {+ allowedEnvironments: ['user'],+ environments: [+ {+ id: 'managed-runtime',+ name: 'Managed Runtime',+ type: 'managed',+ baseURL: 'https://code.example.com/v1',+ },+ ],+ },+ },+ },+ };+ mockReq.body = {+ name: 'Managed Workspace Agent',+ provider: 'openai',+ model: 'gpt-4',+ code_environment_id: 'managed-runtime',+ code_workspace_id: 'project-a',+ };++ await createAgentHandler(mockReq, mockRes);++ expect(mockRes.status).toHaveBeenCalledWith(400);+ expect(mockRes.json).toHaveBeenCalledWith({+ error: 'Code workspace defaults require an explicit attached code environment',+ });+ expect(await Agent.countDocuments()).toBe(0);+ });+test('should block configured agent instruction content before persistence', async () => {mockReq.config = {filters: {@@ -1605,12 +1675,74 @@ describe('Agent Controllers - Mass Assignment Protection', () => {expect(agentInDb.code_environment_id).toBeUndefined();});+ test('allows a workspace-only update for an existing attached environment', async () => {+ await Agent.updateOne({ id: existingAgentId }, { code_environment_id: 'attached-vm' });+ mockReq.user.id = existingAgentAuthorId.toString();+ mockReq.params.id = existingAgentId;+ mockReq.config = {+ endpoints: {+ agents: {+ statefulCodeSessions: {+ allowedEnvironments: ['user'],+ environments: [+ {+ id: 'attached-vm',+ name: 'Attached VM',+ type: 'attached',+ baseURL: 'https://bridge.example.com/v1',+ },+ ],+ },+ },+ },+ };+ mockReq.body = { code_workspace_id: 'project-a' };++ await updateAgentHandler(mockReq, mockRes);++ expect(mockRes.status).not.toHaveBeenCalledWith(400);+ const agentInDb = await Agent.findOne({ id: existingAgentId });+ expect(agentInDb.code_environment_id).toBe('attached-vm');+ expect(agentInDb.code_workspace_id).toBe('project-a');+ });++ test('rejects a workspace-only update without an attached environment', async () => {+ mockReq.user.id = existingAgentAuthorId.toString();+ mockReq.params.id = existingAgentId;+ mockReq.config = {+ endpoints: {+ agents: {+ statefulCodeSessions: {+ allowedEnvironments: ['user'],+ environments: [+ {+ id: 'default-vm',+ name: 'Default VM',+ type: 'attached',+ baseURL: 'https://bridge.example.com/v1',+ default: true,+ },+ ],+ },+ },+ },+ };+ mockReq.body = { code_workspace_id: 'project-a' };++ await updateAgentHandler(mockReq, mockRes);++ expect(mockRes.status).toHaveBeenCalledWith(400);+ const agentInDb = await Agent.findOne({ id: existingAgentId });+ expect(agentInDb.code_workspace_id).toBeUndefined();+ });+test('allows disabling stateful sessions after the configured environment is removed', async () => {await Agent.updateOne({ id: existingAgentId },{stateful_code_sessions: true,code_environment_id: 'removed-vm',+ code_workspace_id: 'project-a',},);mockReq.user.id = existingAgentAuthorId.toString();@@ -1628,6 +1760,7 @@ describe('Agent Controllers - Mass Assignment Protection', () => {mockReq.body = {stateful_code_sessions: false,code_environment_id: 'removed-vm',+ code_workspace_id: 'project-a',};await updateAgentHandler(mockReq, mockRes);@@ -1636,6 +1769,7 @@ describe('Agent Controllers - Mass Assignment Protection', () => {const agentInDb = await Agent.findOne({ id: existingAgentId });expect(agentInDb.stateful_code_sessions).toBe(false);expect(agentInDb.code_environment_id).toBe('removed-vm');+ expect(agentInDb.code_workspace_id).toBe('project-a');});test('restores the deployment-default code environment', async () => {@@ -1644,6 +1778,7 @@ describe('Agent Controllers - Mass Assignment Protection', () => {{stateful_code_sessions: true,code_environment_id: 'attached-vm',+ code_workspace_id: 'project-a',},);mockReq.user.id = existingAgentAuthorId.toString();@@ -1673,6 +1808,7 @@ describe('Agent Controllers - Mass Assignment Protection', () => {expect(mockRes.status).not.toHaveBeenCalledWith(400);const agentInDb = await Agent.findOne({ id: existingAgentId });expect(agentInDb.code_environment_id).toBeUndefined();+ expect(agentInDb.code_workspace_id).toBe('');});test('clears a configured Git identity', async () => {@@ -3332,16 +3468,20 @@ describe('Agent Controllers - Mass Assignment Protection', () => {expect(Object.keys(agent).sort()).toEqual(['_id',+ 'agent_ids','author','avatar','category','conversation_starters','description',+ 'edges','id','isEditable','is_promoted','name',+ 'subagents','support_contact',+ 'tools','updatedAt',].sort(),);@@ -3353,6 +3493,9 @@ describe('Agent Controllers - Mass Assignment Protection', () => {author: userA.toString(),category: 'general',is_promoted: true,+ tools: ['execute_code'],+ edges: [{ from: agentA1.id, to: agentA2.id }],+ subagents: { enabled: true, agent_ids: [agentA2.id] },}),);});diff --git a/client/src/common/agents-types.ts b/client/src/common/agents-types.tsindex 7bad08b819..5cbaa75941 100644--- a/client/src/common/agents-types.ts+++ b/client/src/common/agents-types.ts@@ -52,6 +52,7 @@ export type AgentForm = {stateful_code_environment?: StatefulCodeEnvironment;/** Operator-configured managed or attached execution environment. */code_environment_id?: string | null;+ code_workspace_id?: string;/** Git authorship applied to sandboxed commands for this agent. */git_identity?: Agent['git_identity'];provider?: AgentProvider | OptionWithIcon;diff --git a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsxindex 4af4cd4abd..36ae9f01e6 100644--- a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx+++ b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx@@ -31,22 +31,30 @@ export default function CodeWorkspaceMenu({const menuStore = Ariakit.useMenuStore({ focusLoop: true, placement: 'top-start' });const isOpen = menuStore.useState('open');- /** A single advertised root per reachable environment is an unambiguous- * initial choice. Once a conversation owns any binding, even a partial or- * stale set, only explicit user actions may replace or complete it. */+ /** 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 == null ||+ current.codeWorkspaces != null ||+ current.conversationId !== conversation?.conversationId ||+ current.agent_id !== conversation?.agent_id? current: { ...current, codeWorkspaces: workspace.selections },);- }, [conversation?.codeWorkspaces, setConversation, 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));const selectWorkspace = (selection: CodeWorkspaceSelection) => {+ workspace.rememberSelection(selection);setConversation((current) => {if (current == null) return current;const retained = (current.codeWorkspaces ?? []).filter(diff --git a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsxindex 383ca7cac7..3a7408f175 100644--- a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx+++ b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx@@ -52,6 +52,7 @@ function workspace(overrides: Partial<CodeWorkspaceResult> = {}): CodeWorkspaceRselections: [selected],resolveSelections: () => [selected],resolveSubmission: () => ({ codeWorkspaces: [selected] }),+ rememberSelection: jest.fn(),...overrides,};}@@ -73,6 +74,10 @@ describe('CodeWorkspaceMenu', () => {...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(screen.getByTestId('code-workspace')).toHaveTextContent('Project A');});@@ -82,6 +87,7 @@ describe('CodeWorkspaceMenu', () => {codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'removed-project' }],};const setConversation = jest.fn();+ const rememberSelection = jest.fn();render(<CodeWorkspaceMenuconversation={savedConversation}@@ -97,6 +103,7 @@ describe('CodeWorkspaceMenu', () => {selected: undefined,},],+ rememberSelection,})}disabled={false}/>,@@ -107,6 +114,10 @@ describe('CodeWorkspaceMenu', () => {await userEvent.click(screen.getByTestId('code-workspace'));await userEvent.click(await screen.findByText('Project A'));+ expect(rememberSelection).toHaveBeenCalledWith({+ environmentId: 'personal-vm',+ workspaceId: 'project-a',+ });const update = setConversation.mock.calls[0][0];expect(update(savedConversation)).toEqual({...savedConversation,diff --git a/client/src/components/SidePanel/Agents/AgentPanel.tsx b/client/src/components/SidePanel/Agents/AgentPanel.tsxindex 8d22a32c03..553455cbfa 100644--- a/client/src/components/SidePanel/Agents/AgentPanel.tsx+++ b/client/src/components/SidePanel/Agents/AgentPanel.tsx@@ -91,6 +91,7 @@ export function composeAgentUpdatePayload(stateful_code_sessions,stateful_code_environment,code_environment_id,+ code_workspace_id,git_identity,recursion_limit,category,@@ -152,6 +153,7 @@ export function composeAgentUpdatePayload(stateful_code_sessions: normalizedStatefulCodeSessions,stateful_code_environment: normalizedStatefulCodeEnvironment,code_environment_id: agent_id ? code_environment_id : (code_environment_id ?? undefined),+ code_workspace_id,git_identity: normalizedGitIdentity,recursion_limit,category,diff --git a/client/src/components/SidePanel/Agents/AgentSelect.tsx b/client/src/components/SidePanel/Agents/AgentSelect.tsxindex a586fa8634..7efe63d705 100644--- a/client/src/components/SidePanel/Agents/AgentSelect.tsx+++ b/client/src/components/SidePanel/Agents/AgentSelect.tsx@@ -101,6 +101,7 @@ function AgentSelect({avatar_action: null,stateful_code_environment: fullAgent.stateful_code_environment ?? 'user',code_environment_id: fullAgent.code_environment_id,+ code_workspace_id: fullAgent.code_workspace_id,git_identity: fullAgent.git_identity,};diff --git a/client/src/components/SidePanel/Agents/Code/Settings.tsx b/client/src/components/SidePanel/Agents/Code/Settings.tsxindex c70a9014b5..291edf8043 100644--- a/client/src/components/SidePanel/Agents/Code/Settings.tsx+++ b/client/src/components/SidePanel/Agents/Code/Settings.tsx@@ -24,6 +24,7 @@ import {import type { StatefulCodeEnvironment } from 'librechat-data-provider';import type { AgentForm } from '~/common';import { useAuthContext, useGetAgentsConfig, useLocalize } from '~/hooks';+import { useCodeEnvironmentStatusQueries } from '~/data-provider';import { ESide } from '~/common';const ENVIRONMENT_LABELS = {@@ -33,6 +34,11 @@ const ENVIRONMENT_LABELS = {} as const;const DEPLOYMENT_DEFAULT_ENVIRONMENT = '__deployment_default__';+const WORKSPACE_STATUS_LABELS = {+ loading: 'com_ui_code_workspace_loading',+ unavailable: 'com_ui_code_workspace_unavailable',+ unsupported: 'com_ui_code_workspace_unsupported',+} as const;export default function CodeSettings() {const localize = useLocalize();@@ -52,6 +58,7 @@ export default function CodeSettings() {const codeEnabled = watch(AgentCapabilities.execute_code);const environment = watch('stateful_code_environment') ?? 'user';const codeEnvironmentId = watch('code_environment_id');+ const workspaceId = watch('code_workspace_id') ?? '';const configuredEnvironments = agentsConfig?.statefulCodeSessions?.allowedEnvironments;const executionEnvironments = agentsConfig?.statefulCodeSessions?.environments ?? [];const statefulSessionsAvailable =@@ -65,6 +72,30 @@ export default function CodeSettings() {codeEnabled &&enabled &&effectiveExecutionEnvironment?.type === 'attached';+ const workspaceStatuses = useCodeEnvironmentStatusQueries(+ effectiveExecutionEnvironment?.type === 'attached' ? [effectiveExecutionEnvironment.id] : [],+ showGitIdentity === true,+ );+ const workspaceStatusQuery = workspaceStatuses[0];+ const workspaceStatus = workspaceStatusQuery?.data;+ let workspaceDiscoveryState: 'loading' | 'unavailable' | 'unsupported' | 'ready' = 'ready';+ if (workspaceStatusQuery == null || workspaceStatusQuery.isLoading) {+ workspaceDiscoveryState = 'loading';+ } else if (+ workspaceStatusQuery.isError ||+ workspaceStatus?.status !== 'ready' ||+ workspaceStatus.environmentId !== effectiveExecutionEnvironment?.id+ ) {+ workspaceDiscoveryState = 'unavailable';+ } else if (workspaceStatus.workspaces == null) {+ workspaceDiscoveryState = 'unsupported';+ }+ const workspaces =+ workspaceDiscoveryState === 'ready' &&+ workspaceStatus?.status === 'ready' &&+ workspaceStatus.environmentId === effectiveExecutionEnvironment?.id+ ? (workspaceStatus.workspaces ?? [])+ : [];const releaseIdentity = useCallback(() => {const identity = getValues('git_identity');const empty = !identity?.name?.trim() && !identity?.email?.trim();@@ -151,6 +182,7 @@ export default function CodeSettings() {<Selectvalue={codeEnvironmentId ?? DEPLOYMENT_DEFAULT_ENVIRONMENT}onValueChange={(value) => {+ setValue('code_workspace_id', '', { shouldDirty: true });setValue('code_environment_id',value === DEPLOYMENT_DEFAULT_ENVIRONMENT ? null : value,@@ -215,6 +247,65 @@ export default function CodeSettings() {<p className="text-xs text-text-tertiary">{localize('com_nav_info_stateful_code_environment')}</p>+ {showGitIdentity && (+ <div className="space-y-2">+ <label+ htmlFor="code-workspace-default"+ className="text-xs font-medium text-text-secondary"+ >+ {localize('com_ui_code_workspace_default')}+ </label>+ <Select+ value={workspaceId || '__automatic__'}+ onValueChange={(value) => {+ if (value !== '__automatic__' && !workspaces.some(({ id }) => id === value))+ return;+ setValue('code_workspace_id', value === '__automatic__' ? '' : value, {+ shouldDirty: true,+ });+ if (value !== '__automatic__' && effectiveExecutionEnvironment) {+ setValue('code_environment_id', effectiveExecutionEnvironment.id, {+ shouldDirty: true,+ });+ }+ }}+ >+ <SelectTrigger id="code-workspace-default">+ <SelectValue />+ </SelectTrigger>+ <SelectContent>+ <SelectItem value="__automatic__">+ {localize('com_ui_code_workspace_last_used')}+ </SelectItem>+ {workspaceId &&+ (workspaceDiscoveryState !== 'ready' ||+ !workspaces.some(({ id }) => id === workspaceId)) && (+ <SelectItem value={workspaceId} disabled>+ {workspaceId} —{' '}+ {localize(+ workspaceDiscoveryState === 'ready'+ ? 'com_ui_code_workspace_missing'+ : WORKSPACE_STATUS_LABELS[workspaceDiscoveryState],+ )}+ </SelectItem>+ )}+ {workspaces.map(({ id, name }) => (+ <SelectItem key={id} value={id}>+ {name ?? id}+ </SelectItem>+ ))}+ </SelectContent>+ </Select>+ {workspaceDiscoveryState !== 'ready' && (+ <p className="text-xs text-text-tertiary" role="status">+ {localize(WORKSPACE_STATUS_LABELS[workspaceDiscoveryState])}+ </p>+ )}+ <p className="text-xs text-text-tertiary">+ {localize('com_ui_code_workspace_default_description')}+ </p>+ </div>+ )}{showGitIdentity && (<div className="space-y-2 border-t border-border-light pt-3"><div className="text-xs font-medium text-text-secondary">diff --git a/client/src/components/SidePanel/Agents/Tools/ItemDialog/__tests__/BuiltinSection.spec.tsx b/client/src/components/SidePanel/Agents/Tools/ItemDialog/__tests__/BuiltinSection.spec.tsxindex 9058626025..ccc13227cb 100644--- a/client/src/components/SidePanel/Agents/Tools/ItemDialog/__tests__/BuiltinSection.spec.tsx+++ b/client/src/components/SidePanel/Agents/Tools/ItemDialog/__tests__/BuiltinSection.spec.tsx@@ -19,7 +19,10 @@ jest.mock('~/hooks', () => ({}),useAgentCapabilities: () => ({ backgroundToolsEnabled: false }),}));-jest.mock('~/data-provider', () => ({ useVerifyAgentToolAuth: () => ({ data: undefined }) }));+jest.mock('~/data-provider', () => ({+ useVerifyAgentToolAuth: () => ({ data: undefined }),+ useCodeEnvironmentStatusQueries: () => [],+}));jest.mock('../../../Search/Action', () => ({ __esModule: true, default: () => <div /> }));jest.mock('../../../FileContext', () => ({ __esModule: true, default: () => <div /> }));jest.mock('../../../FileSearch', () => ({ __esModule: true, default: () => <div /> }));diff --git a/client/src/components/SidePanel/Agents/__tests__/CodeSettings.spec.tsx b/client/src/components/SidePanel/Agents/__tests__/CodeSettings.spec.tsxindex 4df0676a84..c8cfaaffba 100644--- a/client/src/components/SidePanel/Agents/__tests__/CodeSettings.spec.tsx+++ b/client/src/components/SidePanel/Agents/__tests__/CodeSettings.spec.tsx@@ -6,6 +6,10 @@ import { AgentCapabilities } from 'librechat-data-provider';import { render, screen, fireEvent, waitFor } from '@testing-library/react';import type { AgentForm } from '~/common';import CodeSettings from '../Code/Settings';+const mockWorkspaceStatusQueries = jest.fn();+jest.mock('~/data-provider', () => ({+ useCodeEnvironmentStatusQueries: () => mockWorkspaceStatusQueries(),+}));jest.mock('~/hooks', () => ({useLocalize: () => (key: string) => key,@@ -20,7 +24,27 @@ jest.mock('~/hooks', () => ({}),}));-function IdentityForm({ savedIdentity }: { savedIdentity?: AgentForm['git_identity'] }) {+beforeEach(() => {+ mockWorkspaceStatusQueries.mockReturnValue([+ {+ data: {+ status: 'ready',+ environmentId: 'byom',+ workspaces: [{ id: 'project-a', name: 'Project A' }],+ },+ isLoading: false,+ isError: false,+ },+ ]);+});++function IdentityForm({+ savedIdentity,+ savedWorkspace,+}: {+ savedIdentity?: AgentForm['git_identity'];+ savedWorkspace?: string;+}) {const [dialogOpen, setDialogOpen] = useState(true);const methods = useForm<AgentForm>({mode: 'onChange',@@ -28,6 +52,7 @@ function IdentityForm({ savedIdentity }: { savedIdentity?: AgentForm['git_identiexecute_code: true,stateful_code_sessions: true,git_identity: savedIdentity,+ code_workspace_id: savedWorkspace,},});return (@@ -44,10 +69,55 @@ function IdentityForm({ savedIdentity }: { savedIdentity?: AgentForm['git_identiDisable sessions</button><output data-testid="identity">{JSON.stringify(methods.watch('git_identity'))}</output>+ <output data-testid="workspace-default">{methods.watch('code_workspace_id')}</output>+ <output data-testid="machine-default">{methods.watch('code_environment_id')}</output></FormProvider>);}+test('saves a workspace default bound to the selected machine and permits clearing it', async () => {+ HTMLElement.prototype.scrollIntoView = jest.fn();+ render(<IdentityForm />);+ fireEvent.click(screen.getByRole('combobox', { name: 'com_ui_code_workspace_default' }));+ fireEvent.click(await screen.findByRole('option', { name: 'Project A' }));+ expect(screen.getByTestId('workspace-default')).toHaveTextContent('project-a');+ expect(screen.getByTestId('machine-default')).toHaveTextContent('byom');+ fireEvent.click(screen.getByRole('combobox', { name: 'com_ui_code_workspace_default' }));+ fireEvent.click(await screen.findByRole('option', { name: 'com_ui_code_workspace_last_used' }));+ expect(screen.getByTestId('workspace-default')).toBeEmptyDOMElement();+});++test.each([+ [{ isLoading: true, isError: false }, 'com_ui_code_workspace_loading'],+ [{ isLoading: false, isError: true }, 'com_ui_code_workspace_unavailable'],+ [+ {+ isLoading: false,+ isError: false,+ data: { status: 'ready', environmentId: 'byom', workspaces: undefined },+ },+ 'com_ui_code_workspace_unsupported',+ ],+])('preserves a saved workspace while discovery reports %s', (query, expectedLabel) => {+ mockWorkspaceStatusQueries.mockReturnValue([query]);+ render(<IdentityForm savedWorkspace="project-a" />);++ expect(screen.getByText(expectedLabel, { selector: 'p[role="status"]' })).toBeInTheDocument();+ expect(screen.getByTestId('workspace-default')).toHaveTextContent('project-a');+ expect(screen.queryByText(/com_ui_code_workspace_missing/)).not.toBeInTheDocument();+});++test('permits clearing a saved workspace while discovery is unavailable', async () => {+ HTMLElement.prototype.scrollIntoView = jest.fn();+ mockWorkspaceStatusQueries.mockReturnValue([{ isLoading: false, isError: true }]);+ render(<IdentityForm savedWorkspace="project-a" />);++ fireEvent.click(screen.getByRole('combobox', { name: 'com_ui_code_workspace_default' }));+ fireEvent.click(await screen.findByRole('option', { name: 'com_ui_code_workspace_last_used' }));++ expect(screen.getByTestId('workspace-default')).toBeEmptyDOMElement();+});+test.each(['', 'not-an-email'])('restores the saved identity when reopening an invalid draft: %s',async (email) => {diff --git a/client/src/data-provider/Agents/__tests__/mutations.test.ts b/client/src/data-provider/Agents/__tests__/mutations.test.tsindex d16963cc90..0cf839de97 100644--- a/client/src/data-provider/Agents/__tests__/mutations.test.ts+++ b/client/src/data-provider/Agents/__tests__/mutations.test.ts@@ -65,6 +65,7 @@ describe('useDeleteAgentMutation', () => {const affectedQueryKey = [QueryKeys.agent, affectedId, 'expanded'];const affectedSourceQueryKey = [QueryKeys.agent, affectedSourceId, 'expanded'];const unrelatedQueryKey = [QueryKeys.agent, unrelatedId, 'expanded'];+ const viewListKey = [QueryKeys.agents, { requiredPermission: PermissionBits.VIEW }];const staleAffectedAgent = createAgent(affectedId, [{ from: affectedId, to: targetId, edgeType: 'handoff' },]);@@ -79,6 +80,9 @@ describe('useDeleteAgentMutation', () => {const refreshedAffectedSourceAgent = createAgent(affectedSourceId, [{ from: 'agent_surviving_source', to: affectedSourceId, edgeType: 'handoff' },]);+ const locallyPrunedAffectedSourceAgent = createAgent(affectedSourceId, [+ { from: ['agent_surviving_source'], to: affectedSourceId, edgeType: 'handoff' },+ ]);const unrelatedAgent = createAgent(unrelatedId, [{ from: unrelatedId, to: 'agent_other', edgeType: 'handoff' },]);@@ -95,6 +99,13 @@ describe('useDeleteAgentMutation', () => {await queryClient.prefetchQuery(affectedQueryKey, affectedFetch);await queryClient.prefetchQuery(affectedSourceQueryKey, affectedSourceFetch);await queryClient.prefetchQuery(unrelatedQueryKey, unrelatedFetch);+ queryClient.setQueryData<AgentListResponse>(viewListKey, {+ object: 'list',+ data: [staleAffectedAgent, staleAffectedSourceAgent, unrelatedAgent, createAgent(targetId)],+ first_id: affectedId,+ last_id: targetId,+ has_more: false,+ });queryClient.setQueryData([QueryKeys.agent, targetId], createAgent(targetId));queryClient.setQueryData([QueryKeys.agent, targetId, 'expanded'], createAgent(targetId));@@ -114,6 +125,11 @@ describe('useDeleteAgentMutation', () => {expect(queryClient.getQueryData(affectedSourceQueryKey)).toEqual(refreshedAffectedSourceAgent);expect(unrelatedFetch).toHaveBeenCalledTimes(1);expect(queryClient.getQueryData(unrelatedQueryKey)).toEqual(unrelatedAgent);+ expect(queryClient.getQueryData<AgentListResponse>(viewListKey)?.data).toEqual([+ refreshedAffectedAgent,+ locallyPrunedAffectedSourceAgent,+ unrelatedAgent,+ ]);expect(queryClient.getQueryData([QueryKeys.agent, targetId])).toBeUndefined();expect(queryClient.getQueryData([QueryKeys.agent, targetId, 'expanded'])).toBeUndefined();});diff --git a/client/src/data-provider/Agents/mutations.ts b/client/src/data-provider/Agents/mutations.tsindex 9ef291f18c..c60c7d24bb 100644--- a/client/src/data-provider/Agents/mutations.ts+++ b/client/src/data-provider/Agents/mutations.ts@@ -30,6 +30,31 @@ const hasEdgeWithAgent = (data: unknown, agentId: string): boolean => {);};+const pruneEdgeEndpoint = (+ endpoint: t.GraphEdge['from'],+ agentId: string,+): t.GraphEdge['from'] | null => {+ if (Array.isArray(endpoint)) {+ const retained = endpoint.filter((id) => id !== agentId);+ return retained.length > 0 ? retained : null;+ }+ return endpoint === agentId ? null : endpoint;+};++/** Mirrors the server's deletion cleanup so cached execution graphs stop referencing the+ * deleted agent immediately, before the authoritative refetch completes. */+const pruneAgentEdges = (agent: t.Agent, agentId: string): t.Agent => {+ if (!hasEdgeWithAgent(agent, agentId)) {+ return agent;+ }+ const edges = (agent.edges ?? []).flatMap((edge) => {+ const from = pruneEdgeEndpoint(edge.from, agentId);+ const to = pruneEdgeEndpoint(edge.to, agentId);+ return from == null || to == null ? [] : [{ ...edge, from, to }];+ });+ return { ...agent, edges };+};+/*** Mutation responses omit list-only `isEditable`. When merging into a cached list* row, keep the ACL flag the list endpoint set rather than inferring it from@@ -156,7 +181,9 @@ export const useDeleteAgentMutation = (return options?.onSuccess?.(_data, variables, context);}- data = listRes.data.filter((agent) => agent.id !== variables.agent_id);+ data = listRes.data+ .filter((agent) => agent.id !== variables.agent_id)+ .map((agent) => pruneAgentEdges(agent, variables.agent_id));queryClient.setQueryData<t.AgentListResponse>([QueryKeys.agents, key], {...listRes,@@ -168,15 +195,20 @@ export const useDeleteAgentMutation = (queryClient.removeQueries([QueryKeys.agent, variables.agent_id]);queryClient.removeQueries([QueryKeys.agent, variables.agent_id, 'expanded']);- /** Deletion removes the agent from every edge endpoint server-side. Expanded queries- * opt out of refetch-on-mount, so refresh every cached graph known to reference it. */+ /** Deletion removes the agent from every edge endpoint server-side. Refresh every cached+ * graph known to reference it, then mirror that cleanup immediately while refetch runs. */queryClient.invalidateQueries({queryKey: [QueryKeys.agent],- predicate: (query) =>- query.queryKey[2] === 'expanded' &&- hasEdgeWithAgent(query.state.data, variables.agent_id),+ predicate: (query) => hasEdgeWithAgent(query.state.data, variables.agent_id),refetchType: 'all',});+ queryClient.setQueriesData<t.Agent>(+ {+ queryKey: [QueryKeys.agent],+ predicate: (query) => hasEdgeWithAgent(query.state.data, variables.agent_id),+ },+ (agent) => (agent ? pruneAgentEdges(agent, variables.agent_id) : agent),+ );invalidateAgentMarketplaceQueries(queryClient);return options?.onSuccess?.(_data, variables, data);diff --git a/client/src/hooks/Agents/__tests__/useAgentToolPermissions.test.ts b/client/src/hooks/Agents/__tests__/useAgentToolPermissions.test.tsindex 615eba9495..21b82f5f55 100644--- a/client/src/hooks/Agents/__tests__/useAgentToolPermissions.test.ts+++ b/client/src/hooks/Agents/__tests__/useAgentToolPermissions.test.ts@@ -149,6 +149,33 @@ describe('useAgentToolPermissions', () => {expect(result.current.statefulCodeSessionsAllowedByAgent).toBe(true);});+ it('preserves execution graph metadata omitted by the basic agent response', () => {+ const agentId = 'agent_test';+ mockUseAgentsMapContext.mockReturnValue({+ [agentId]: {+ id: agentId,+ tools: [Tools.execute_code],+ code_environment_id: 'attached-vm',+ code_workspace_id: 'project-a',+ stateful_code_sessions: true,+ agent_ids: ['agent-child'],+ },+ });+ mockUseGetAgentByIdQuery.mockReturnValue({+ data: { id: agentId, name: 'Safe agent response' },+ });++ const { result } = renderHook(() => useAgentToolPermissions(agentId));++ expect(result.current.agent).toMatchObject({+ id: agentId,+ name: 'Safe agent response',+ code_environment_id: 'attached-vm',+ code_workspace_id: 'project-a',+ agent_ids: ['agent-child'],+ });+ });+it('should fallback to agent map data when API data is not available', () => {const agentId = 'agent_test';const agentMapData = {diff --git a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsxindex 79581e871c..748588a253 100644--- a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx+++ b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx@@ -8,6 +8,11 @@ const mockAgentsConfig = jest.fn();const mockStatus = jest.fn();const mockAgentsMap = jest.fn();const mockAccess = jest.fn();+const mockPreference = jest.fn();+const mockRememberPreference = jest.fn();+jest.mock('../workspacePreferences', () => ({+ useWorkspacePreferences: () => ({ get: mockPreference, remember: mockRememberPreference }),+}));jest.mock('~/hooks/Roles/useHasAccess', () => () => mockAccess());jest.mock(@@ -32,6 +37,8 @@ const conversation = (codeWorkspaces?: TConversation['codeWorkspaces']): TConverdescribe('useCodeWorkspace', () => {beforeEach(() => {+ mockPreference.mockReset();+ mockRememberPreference.mockReset();mockAccess.mockReturnValue(true);mockAgentPermissions.mockReturnValue({tools: [Tools.execute_code],@@ -100,6 +107,177 @@ describe('useCodeWorkspace', () => {expect(mockStatus).toHaveBeenCalledWith(['personal-vm'], true);});+ 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';+ mockPreference.mockReturnValue('project-a');+ const { result, rerender } = renderHook(+ ({ id }) => useCodeWorkspace({ ...conversation(), conversationId: id }),+ {+ initialProps: { id: 'new' },+ },+ );+ expect(result.current.selections?.[0].workspaceId).toBe('project-b');+ rerender({ id: 'existing' });+ expect(result.current.canSubmit).toBe(false);+ });++ it('uses a valid last choice and preserves an explicit conversation binding', () => {+ mockStatus()[0].data.workspaces.push({ id: 'project-b', name: 'Project B' });+ mockPreference.mockReturnValue('project-b');+ const { result } = renderHook(() =>+ useCodeWorkspace({ ...conversation(), conversationId: 'new' }),+ );+ expect(result.current.selections?.[0].workspaceId).toBe('project-b');+ const saved = [{ environmentId: 'personal-vm', workspaceId: 'project-a' }];+ const existing = renderHook(() =>+ useCodeWorkspace({ ...conversation(saved), conversationId: 'new' }),+ );+ expect(existing.result.current.selections).toEqual(saved);+ });++ it('reads and records preferences for the root that reaches each environment', () => {+ const primaryAgent = {+ id: 'agent_primary',+ stateful_code_sessions: true,+ code_environment_id: 'primary-vm',+ tools: [Tools.execute_code],+ };+ const addedAgent = {+ id: 'agent_added',+ stateful_code_sessions: true,+ code_environment_id: 'added-vm',+ tools: [Tools.execute_code],+ };+ mockAgentPermissions.mockImplementation((agentId) => ({+ tools: [Tools.execute_code],+ agent: agentId === 'agent_added' ? addedAgent : primaryAgent,+ }));+ mockAgentsConfig.mockReturnValue({+ agentsConfig: {+ capabilities: ['execute_code', 'stateful_code_sessions'],+ statefulCodeSessions: {+ environments: [+ { id: 'primary-vm', name: 'Primary VM', type: 'attached' },+ { id: 'added-vm', name: 'Added VM', type: 'attached' },+ ],+ },+ },+ });+ mockStatus.mockReturnValue(+ ['added-vm', 'primary-vm'].map((environmentId) => ({+ data: {+ environmentId,+ status: 'ready',+ workspaces: [{ id: 'project-a' }, { id: 'project-b' }],+ },+ isLoading: false,+ isError: false,+ })),+ );+ mockPreference.mockImplementation((environmentId, agentId) =>+ environmentId === 'added-vm' && agentId === 'agent_added' ? 'project-b' : 'project-a',+ );++ const addedConversation = {+ ...conversation(),+ conversationId: 'new',+ agent_id: 'agent_added',+ };+ const { result } = renderHook(() =>+ useCodeWorkspace({ ...conversation(), conversationId: 'new' }, addedConversation),+ );++ expect(result.current.selections).toEqual([+ { environmentId: 'added-vm', workspaceId: 'project-b' },+ { environmentId: 'primary-vm', workspaceId: 'project-a' },+ ]);+ result.current.rememberSelection({ environmentId: 'added-vm', workspaceId: 'project-a' });+ expect(mockRememberPreference).toHaveBeenCalledWith('added-vm', 'project-a', ['agent_added']);+ });++ it('applies an added agent default after the primary workspace is already pinned', () => {+ const primaryAgent = {+ id: 'agent_primary',+ stateful_code_sessions: true,+ code_environment_id: 'primary-vm',+ code_workspace_id: 'primary-project',+ tools: [Tools.execute_code],+ };+ const addedAgent = {+ id: 'agent_added',+ stateful_code_sessions: true,+ code_environment_id: 'added-vm',+ code_workspace_id: 'added-project',+ tools: [Tools.execute_code],+ };+ mockAgentPermissions.mockImplementation((agentId) => ({+ tools: [Tools.execute_code],+ agent: agentId === 'agent_added' ? addedAgent : primaryAgent,+ }));+ mockAgentsConfig.mockReturnValue({+ agentsConfig: {+ capabilities: ['execute_code', 'stateful_code_sessions'],+ statefulCodeSessions: {+ environments: [+ { id: 'primary-vm', type: 'attached' },+ { id: 'added-vm', type: 'attached' },+ ],+ },+ },+ });+ mockStatus.mockImplementation((environmentIds: string[]) =>+ environmentIds.map((environmentId) => ({+ data: {+ environmentId,+ status: 'ready',+ workspaces: [+ { id: environmentId === 'primary-vm' ? 'primary-project' : 'added-project' },+ ],+ },+ isLoading: false,+ isError: false,+ })),+ );+ const primarySelection = {+ environmentId: 'primary-vm',+ workspaceId: 'primary-project',+ };+ const addedConversation = {+ ...conversation(),+ conversationId: 'new',+ agent_id: 'agent_added',+ };++ const { result } = renderHook(() =>+ useCodeWorkspace(+ { ...conversation([primarySelection]), conversationId: 'new' },+ addedConversation,+ ),+ );++ expect(result.current.selections).toEqual([+ { environmentId: 'added-vm', workspaceId: 'added-project' },+ primarySelection,+ ]);+ expect(result.current.canSubmit).toBe(true);+ });++ it('ignores stale remembered choices but never silently replaces a missing agent default', () => {+ mockPreference.mockReturnValue('gone');+ const { result, rerender } = renderHook(() =>+ useCodeWorkspace({ ...conversation(), conversationId: 'new' }),+ );+ expect(result.current.selections?.[0].workspaceId).toBe('project-a');+ mockAgentPermissions.mockReturnValue({+ ...mockAgentPermissions(),+ agent: { ...mockAgentPermissions().agent, code_workspace_id: 'gone' },+ });+ rerender();+ expect(result.current.state).toBe('missing');+ expect(result.current.canSubmit).toBe(false);+ });+it.each(['ephemeral', 'openAI__gpt-4o'])('does not block ephemeral agent %s', (agent_id) => {mockAgentPermissions.mockReturnValue({});const { result } = renderHook(() => useCodeWorkspace({ ...conversation(), agent_id }));@@ -351,6 +529,38 @@ describe('useCodeWorkspace', () => {expect(result.current.resolveSubmission()).toEqual({});});+ it('requires an explicit choice when reachable agents disagree on one machine', () => {+ const primary = {+ ...mockAgentPermissions().agent,+ code_workspace_id: 'project-a',+ subagents: { enabled: true, agent_ids: ['child'] },+ };+ mockAgentPermissions.mockImplementation((id?: string) => ({+ agent: id === 'agent_primary' ? primary : undefined,+ }));+ mockAgentsMap.mockReturnValue({+ child: {+ id: 'child',+ stateful_code_sessions: true,+ code_environment_id: 'personal-vm',+ code_workspace_id: 'project-b',+ tools: [Tools.execute_code],+ },+ });+ const { result } = renderHook(() =>+ useCodeWorkspace({ ...conversation(), conversationId: 'new' }),+ );+ expect(result.current.state).toBe('choose');+ expect(result.current.canSubmit).toBe(false);+ expect(+ result.current.resolveSubmission([+ { environmentId: 'personal-vm', workspaceId: 'project-a' },+ ]),+ ).toEqual({+ codeWorkspaces: [{ environmentId: 'personal-vm', workspaceId: 'project-a' }],+ });+ });+it.each(['subagent', 'handoff'])('collects every attached environment through %s', (kind) => {const primary = {id: 'agent_primary',diff --git a/client/src/hooks/Agents/__tests__/useSelectAgent.spec.ts b/client/src/hooks/Agents/__tests__/useSelectAgent.spec.tsindex 04a56ba554..d15e1a5d12 100644--- a/client/src/hooks/Agents/__tests__/useSelectAgent.spec.ts+++ b/client/src/hooks/Agents/__tests__/useSelectAgent.spec.ts@@ -124,6 +124,48 @@ describe('useSelectAgent', () => {spec: null,iconURL: null,modelLabel: null,+ codeWorkspaces: undefined,});});++ it('does not carry a prior agent workspace binding into the selected agent', async () => {+ mockGetConversation.mockResolvedValue({+ endpoint: EModelEndpoint.agents,+ agent_id: 'agent-old',+ codeWorkspaces: [{ environmentId: 'machine-a', workspaceId: 'project-old' }],+ } as TConversation);+ mockFetchQuery.mockResolvedValue({ id: 'agent-1', name: 'Full Agent' });+ const { result } = renderHook(() => useSelectAgent());++ await act(async () => {+ await result.current.onSelect('agent-1');+ });++ expect(mockNewConversation.mock.calls[0][0].template.codeWorkspaces).toBeUndefined();+ expect(mockNewConversation.mock.calls[1][0].template.codeWorkspaces).toBeUndefined();+ expect(mockGetDefaultConversation.mock.calls[0][0].conversation.codeWorkspaces).toBeUndefined();+ });++ it('preserves a workspace selected while the same agent is hydrating', async () => {+ const selectedWorkspace = [{ environmentId: 'machine-a', workspaceId: 'project-a' }];+ mockGetConversation+ .mockResolvedValueOnce({+ endpoint: EModelEndpoint.agents,+ agent_id: 'agent-old',+ } as TConversation)+ .mockResolvedValueOnce({+ endpoint: EModelEndpoint.agents,+ agent_id: 'agent-1',+ codeWorkspaces: selectedWorkspace,+ } as TConversation);+ mockFetchQuery.mockResolvedValue({ id: 'agent-1', name: 'Full Agent' });+ const { result } = renderHook(() => useSelectAgent());++ await act(async () => {+ await result.current.onSelect('agent-1');+ });++ expect(mockNewConversation.mock.calls[0][0].template.codeWorkspaces).toBeUndefined();+ expect(mockNewConversation.mock.calls[1][0].template.codeWorkspaces).toEqual(selectedWorkspace);+ });});diff --git a/client/src/hooks/Agents/__tests__/workspacePreferences.test.tsx b/client/src/hooks/Agents/__tests__/workspacePreferences.test.tsxnew file mode 100644index 0000000000..240a54cf6f--- /dev/null+++ b/client/src/hooks/Agents/__tests__/workspacePreferences.test.tsx@@ -0,0 +1,52 @@+import { Provider } from 'jotai';+import { act, renderHook } from '@testing-library/react';+import { useWorkspacePreferences } from '../workspacePreferences';++const mockUser = { id: 'user-a', tenantId: 'tenant-a' };+jest.mock('~/hooks/AuthContext', () => ({ useAuthContext: () => ({ user: mockUser }) }));++beforeEach(() => {+ localStorage.clear();+ mockUser.id = 'user-a';+ mockUser.tenantId = 'tenant-a';+});++test('persists choices across mounts and scopes them by user, tenant, agent and machine', () => {+ const first = renderHook(() => useWorkspacePreferences('agent-a'), { wrapper: Provider });+ act(() => first.result.current.remember('machine-a', 'project-a'));+ first.unmount();+ const { result, rerender } = renderHook(({ agent }) => useWorkspacePreferences(agent), {+ wrapper: Provider,+ initialProps: { agent: 'agent-a' },+ });+ expect(result.current.get('machine-a')).toBe('project-a');+ expect(result.current.get('machine-b')).toBeUndefined();+ rerender({ agent: 'agent-b' });+ expect(result.current.get('machine-a')).toBeUndefined();+ mockUser.id = 'user-b';+ rerender({ agent: 'agent-a' });+ expect(result.current.get('machine-a')).toBeUndefined();+ mockUser.id = 'user-a';+ mockUser.tenantId = 'tenant-b';+ rerender({ agent: 'agent-a' });+ expect(result.current.get('machine-a')).toBeUndefined();+});++test('storage errors never prevent a manual choice', () => {+ const { result } = renderHook(() => useWorkspacePreferences('agent-a'), { wrapper: Provider });+ jest.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {+ throw new Error('quota');+ });+ expect(() => act(() => result.current.remember('machine-a', 'project-a'))).not.toThrow();+});++test('records a shared selection for every root agent that reaches the machine', () => {+ const first = renderHook(() => useWorkspacePreferences(), { wrapper: Provider });+ act(() => first.result.current.remember('machine-a', 'project-a', ['agent-a', 'agent-b']));+ first.unmount();++ const { result } = renderHook(() => useWorkspacePreferences(), { wrapper: Provider });+ expect(result.current.get('machine-a', 'agent-a')).toBe('project-a');+ expect(result.current.get('machine-a', 'agent-b')).toBe('project-a');+ expect(result.current.get('machine-a', 'agent-c')).toBeUndefined();+});diff --git a/client/src/hooks/Agents/useAgentToolPermissions.ts b/client/src/hooks/Agents/useAgentToolPermissions.tsindex 05db7cf22c..3324ab4f8d 100644--- a/client/src/hooks/Agents/useAgentToolPermissions.ts+++ b/client/src/hooks/Agents/useAgentToolPermissions.ts@@ -77,12 +77,18 @@ export default function useAgentToolPermissions(return tools?.includes(Tools.execute_code) ?? false;}, [agentId, selectedAgent, tools, ephemeralAgent]);+ const agent = useMemo(() => {+ if (selectedAgent == null) return agentData;+ if (agentData == null) return selectedAgent;+ return { ...selectedAgent, ...agentData };+ }, [agentData, selectedAgent]);+return {fileSearchAllowedByAgent,codeAllowedByAgent,statefulCodeSessionsAllowedByAgent,codeEnvironmentId,- agent: agentData ?? selectedAgent,+ agent,provider,tools,};diff --git a/client/src/hooks/Agents/useCodeWorkspace.ts b/client/src/hooks/Agents/useCodeWorkspace.tsindex a860a47ffe..78e64b8645 100644--- a/client/src/hooks/Agents/useCodeWorkspace.ts+++ b/client/src/hooks/Agents/useCodeWorkspace.ts@@ -16,6 +16,7 @@ import type {} from 'librechat-data-provider';import { collectReachableAgents, findExecutionEnvironment } from './useCodeApprovalMode';import { useCodeEnvironmentStatusQueries } from '~/data-provider';+import { useWorkspacePreferences } from './workspacePreferences';import useAgentToolPermissions from './useAgentToolPermissions';import useHasAccess from '~/hooks/Roles/useHasAccess';import useGetAgentsConfig from './useGetAgentsConfig';@@ -49,6 +50,7 @@ export interface CodeWorkspaceResult {resolveSubmission: (selections?: CodeWorkspaceSelection[],) => { codeWorkspaces?: CodeWorkspaceSelection[] } | undefined;+ rememberSelection: (selection: CodeWorkspaceSelection) => void;}function aggregateState(@@ -93,6 +95,7 @@ export default function useCodeWorkspace(conversation: TConversation | null,addedConversation?: TConversation | null,): CodeWorkspaceResult {+ const preferences = useWorkspacePreferences(conversation?.agent_id);const { agentsConfig, endpointsConfig } = useGetAgentsConfig();const canRunCode = useHasAccess({permissionType: PermissionTypes.RUN_CODE,@@ -118,6 +121,8 @@ export default function useCodeWorkspace();const workspaceMetadata = useMemo(() => {const unique = new Map<string, TPublicCodeEnvironment>();+ const defaults = new Map<string, Set<string>>();+ const preferenceAgentIds = new Map<string, Set<string>>();let complete = true;for (const agent of reachable.agents) {if (agent.stateful_code_sessions !== true || !agent.tools?.includes(Tools.execute_code)) {@@ -125,13 +130,47 @@ export default function useCodeWorkspace(}const environment = findExecutionEnvironment(agent, statefulCodeSessions?.environments);if (agent.code_environment_id && environment == null) complete = false;- if (environment?.type === 'attached') unique.set(environment.id, environment);+ if (environment?.type !== 'attached') continue;+ unique.set(environment.id, environment);+ if (agent.code_environment_id === environment.id && agent.code_workspace_id) {+ const choices = defaults.get(environment.id) ?? new Set<string>();+ choices.add(agent.code_workspace_id);+ defaults.set(environment.id, choices);+ }+ }++ for (const [rootAgent, rootAgentId] of [+ [primaryAgent, conversation?.agent_id],+ [addedAgent, addedConversation?.agent_id],+ ] as const) {+ if (!rootAgent || !rootAgentId) continue;+ const rootReachable = collectReachableAgents([rootAgent], agentsMap, [rootAgentId]);+ for (const agent of rootReachable.agents) {+ if (agent.stateful_code_sessions !== true || !agent.tools?.includes(Tools.execute_code)) {+ continue;+ }+ const environment = findExecutionEnvironment(agent, statefulCodeSessions?.environments);+ if (environment?.type !== 'attached') continue;+ const owners = preferenceAgentIds.get(environment.id) ?? new Set<string>();+ owners.add(rootAgentId);+ preferenceAgentIds.set(environment.id, owners);+ }}return {complete,+ defaults,+ preferenceAgentIds,environments: [...unique.values()].sort((a, b) => a.id.localeCompare(b.id)),};- }, [reachable.agents, statefulCodeSessions?.environments]);+ }, [+ addedAgent,+ addedConversation?.agent_id,+ agentsMap,+ conversation?.agent_id,+ primaryAgent,+ reachable.agents,+ statefulCodeSessions?.environments,+ ]);const isAgentsConversation =(conversation?.endpointType ?? conversation?.endpoint) === EModelEndpoint.agents;const expectedRoot = conversation?.agent_id != null || addedConversation?.agent_id != null;@@ -153,19 +192,42 @@ export default function useCodeWorkspace(required && selectionMetadataComplete,);const storedSelections = conversation?.codeWorkspaces;+ const attachedEnvironmentIds = new Set(attachedEnvironments.map(({ id }) => id));+ const hasForeignStoredSelection = storedSelections?.some(+ ({ environmentId }) => !attachedEnvironmentIds.has(environmentId),+ );+ const isNewChat =+ conversation != null &&+ (conversation.conversationId == null || conversation.conversationId === 'new');const environmentResults = attachedEnvironments.map((environment, index) => {const status = statuses[index];const workspaces =status?.data?.status === 'ready' && Array.isArray(status.data.workspaces)? status.data.workspaces: [];- const stored = storedSelections?.find(({ environmentId }) => environmentId === environment.id);+ let stored = storedSelections?.find(({ environmentId }) => environmentId === environment.id);+ let conflictingDefaults = false;+ if (stored == null && isNewChat && !hasForeignStoredSelection) {+ const defaults = workspaceMetadata.defaults.get(environment.id) ?? new Set<string>();+ let preferred: string | undefined;+ if (defaults.size === 1) preferred = [...defaults][0];+ else if (defaults.size === 0) {+ preferred = [...(workspaceMetadata.preferenceAgentIds.get(environment.id) ?? [])]+ .map((agentId) => preferences.get(environment.id, agentId))+ .find((workspaceId) => workspaces.some(({ id }) => id === workspaceId));+ }+ if (preferred && (defaults.size > 0 || workspaces.some(({ id }) => id === preferred))) {+ stored = { environmentId: environment.id, workspaceId: preferred };+ }+ conflictingDefaults = defaults.size > 1;+ }const selected = resolveEnvironmentSelection({environment,status: status?.data,workspaces,stored,- hasStoredSelections: storedSelections != null,+ hasStoredSelections:+ stored != null || conflictingDefaults || hasForeignStoredSelection === true,});let state: CodeWorkspaceEnvironmentResult['state'] = 'choose';if (status == null || status.isLoading) state = 'loading';@@ -204,11 +266,8 @@ export default function useCodeWorkspace(});continue;}- if (selections == null && result.workspaces.length === 1 && result.state === 'ready') {- resolved.push({- environmentId: result.environment.id,- workspaceId: result.workspaces[0].id,- });+ if (requested == null && result.selected != null && result.state === 'ready') {+ resolved.push(result.selected);continue;}return undefined;@@ -233,6 +292,14 @@ export default function useCodeWorkspace([required, resolveSelections],);const canSubmit = resolveSubmission(storedSelections) != null;+ const rememberSelection = useCallback(+ (selection: CodeWorkspaceSelection) => {+ preferences.remember(selection.environmentId, selection.workspaceId, [+ ...(workspaceMetadata.preferenceAgentIds.get(selection.environmentId) ?? []),+ ]);+ },+ [preferences, workspaceMetadata.preferenceAgentIds],+ );return {required,state,@@ -241,5 +308,6 @@ export default function useCodeWorkspace(selections,resolveSelections,resolveSubmission,+ rememberSelection,};}diff --git a/client/src/hooks/Agents/useSelectAgent.ts b/client/src/hooks/Agents/useSelectAgent.tsindex d4c68017cf..339885bad9 100644--- a/client/src/hooks/Agents/useSelectAgent.ts+++ b/client/src/hooks/Agents/useSelectAgent.ts@@ -39,10 +39,20 @@ export default function useSelectAgent() {});return;}- const currentConvo = getDefaultConversation({- conversation: { ...(conversation ?? {}), agent_id: agent.id, ...specDisplayFieldReset },+ const switchesAgent = conversation?.agent_id !== agent.id;+ const resolvedConvo = getDefaultConversation({+ conversation: {+ ...(conversation ?? {}),+ agent_id: agent.id,+ codeWorkspaces: switchesAgent ? undefined : conversation?.codeWorkspaces,+ ...specDisplayFieldReset,+ },preset: template,});+ const currentConvo = {+ ...resolvedConvo,+ codeWorkspaces: switchesAgent ? undefined : conversation?.codeWorkspaces,+ };newConversation({template: currentConvo,preset: template as Partial<TPreset>,@@ -63,6 +73,7 @@ export default function useSelectAgent() {endpoint: EModelEndpoint.agents,agent_id: agent.id,conversationId: Constants.NEW_CONVO as string,+ codeWorkspaces: undefined,...specDisplayFieldReset,};diff --git a/client/src/hooks/Agents/workspacePreferences.ts b/client/src/hooks/Agents/workspacePreferences.tsnew file mode 100644index 0000000000..db90375644--- /dev/null+++ b/client/src/hooks/Agents/workspacePreferences.ts@@ -0,0 +1,51 @@+import { useAtom } from 'jotai';+import { createStorageAtom } from '~/store/jotai-utils';+import { useAuthContext } from '~/hooks/AuthContext';++interface WorkspacePreference {+ key: string;+ workspaceId: string;+}++const preferences = createStorageAtom<WorkspacePreference[]>('codeWorkspacePreferences', []);++function validEntries(saved: WorkspacePreference[]): WorkspacePreference[] {+ return Array.isArray(saved)+ ? saved.filter(+ (entry) => entry && typeof entry.key === 'string' && typeof entry.workspaceId === 'string',+ )+ : [];+}++/** Browser-local hints, never authorization or conversation bindings. */+export function useWorkspacePreferences(agentId?: string | null) {+ const { user } = useAuthContext();+ const [saved, setSaved] = useAtom(preferences);+ const keyFor = (environmentId: string, ownerAgentId = agentId) =>+ JSON.stringify([user?.tenantId ?? '', user?.id, ownerAgentId, environmentId]);+ const entries = validEntries(saved);+ return {+ get: (environmentId: string, ownerAgentId = agentId) =>+ user?.id && ownerAgentId+ ? entries.find((entry) => entry.key === keyFor(environmentId, ownerAgentId))?.workspaceId+ : undefined,+ remember: (environmentId: string, workspaceId: string, ownerAgentIds = [agentId]) => {+ if (!user?.id) return;+ const keys = ownerAgentIds+ .filter((ownerAgentId): ownerAgentId is string => Boolean(ownerAgentId))+ .map((ownerAgentId) => keyFor(environmentId, ownerAgentId));+ if (keys.length === 0) return;+ // Bound this browser's disposable MRU cache; evictions only restore the chooser.+ try {+ setSaved((current) =>+ [+ ...keys.map((key) => ({ key, workspaceId })),+ ...validEntries(current).filter((entry) => !keys.includes(entry.key)),+ ].slice(0, 100),+ );+ } catch {+ // Disabled or full browser storage must not prevent explicit workspace selection.+ }+ },+ };+}diff --git a/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx b/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsxindex 85f440f9bf..1e1bfca18e 100644--- a/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx+++ b/client/src/hooks/Chat/__tests__/useChatFunctions.regenerate.spec.tsx@@ -25,6 +25,7 @@ const mockResolveCodeWorkspaceSubmission = jest.fn<>(() => ({}));const mockCodeWorkspace = {resolveSubmission: mockResolveCodeWorkspaceSubmission,+ rememberSelection: jest.fn(),};jest.mock('react-router-dom', () => ({diff --git a/client/src/hooks/__tests__/useNewConvo.spec.ts b/client/src/hooks/__tests__/useNewConvo.spec.tsindex 7c2c8313ae..7cd58715a4 100644--- a/client/src/hooks/__tests__/useNewConvo.spec.ts+++ b/client/src/hooks/__tests__/useNewConvo.spec.ts@@ -1,4 +1,6 @@import { renderHook, act } from '@testing-library/react';+import { Constants, EModelEndpoint } from 'librechat-data-provider';+import type { TConversation } from 'librechat-data-provider';const mockDeleteFiles = jest.fn();const mockSetFiles = jest.fn();@@ -113,7 +115,53 @@ jest.mock('~/store', () => ({},}));-import useNewConvo from '../useNewConvo';+import useNewConvo, { clearInheritedAgentWorkspace } from '../useNewConvo';++describe('clearInheritedAgentWorkspace', () => {+ const workspaceBinding = [{ environmentId: 'machine-a', workspaceId: 'project-a' }];++ it('clears a workspace inherited by a new chat when the agent changes', () => {+ expect(+ clearInheritedAgentWorkspace(+ {+ conversationId: Constants.NEW_CONVO,+ endpoint: EModelEndpoint.agents,+ agent_id: 'agent-b',+ codeWorkspaces: workspaceBinding,+ } as TConversation,+ { agent_id: 'agent-a' } as TConversation,+ ).codeWorkspaces,+ ).toBeUndefined();+ });++ it('preserves an existing conversation workspace binding', () => {+ expect(+ clearInheritedAgentWorkspace(+ {+ conversationId: 'conversation-1',+ endpoint: EModelEndpoint.agents,+ agent_id: 'agent-b',+ codeWorkspaces: workspaceBinding,+ } as TConversation,+ { agent_id: 'agent-a' } as TConversation,+ ).codeWorkspaces,+ ).toEqual(workspaceBinding);+ });++ it('preserves a new-chat workspace binding when the agent is unchanged', () => {+ expect(+ clearInheritedAgentWorkspace(+ {+ conversationId: Constants.NEW_CONVO,+ endpoint: EModelEndpoint.agents,+ agent_id: 'agent-a',+ codeWorkspaces: workspaceBinding,+ } as TConversation,+ { agent_id: 'agent-a' } as TConversation,+ ).codeWorkspaces,+ ).toEqual(workspaceBinding);+ });+});describe('useNewConvo reset cleanup', () => {beforeEach(() => {diff --git a/client/src/hooks/useNewConvo.ts b/client/src/hooks/useNewConvo.tsindex 32f1ee71b4..f12bafbca2 100644--- a/client/src/hooks/useNewConvo.ts+++ b/client/src/hooks/useNewConvo.ts@@ -58,6 +58,18 @@ import { usePauseGlobalAudio } from './Audio';import { useHasAccess } from '~/hooks';import store from '~/store';+export function clearInheritedAgentWorkspace(+ conversation: TConversation,+ previousConversation?: TConversation | null,+): TConversation {+ const startsNewAgentConversation =+ conversation.conversationId === Constants.NEW_CONVO &&+ conversation.agent_id != null &&+ conversation.agent_id !== previousConversation?.agent_id;++ return startsNewAgentConversation ? { ...conversation, codeWorkspaces: undefined } : conversation;+}+const useNewConvo = (index = 0) => {const navigate = useNavigate();const [searchParams] = useSearchParams();@@ -349,7 +361,7 @@ const useNewConvo = (index = 0) => {? { endpoint: _template.endpoint, chatProjectId: _template.chatProjectId }: _template;- const conversation = {+ let conversation = {conversationId: Constants.NEW_CONVO as string,title: 'New Chat',endpoint: null,@@ -373,6 +385,7 @@ const useNewConvo = (index = 0) => {}const prevConversation = getConversation();+ conversation = clearInheritedAgentWorkspace(conversation, prevConversation);applyModelSpecEffects({startupConfig,specName: preset?.spec,diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.jsonindex 63b2b06f53..fdd8d513b1 100644--- a/client/src/locales/en/translation.json+++ b/client/src/locales/en/translation.json@@ -1,4 +1,7 @@{+ "com_ui_code_workspace_default": "Default workspace for new chats",+ "com_ui_code_workspace_last_used": "Last used workspace",+ "com_ui_code_workspace_default_description": "New chats use this workspace. Without a default, reuse your last available choice for this agent and machine in this browser. Existing chats keep their workspace.","com_ui_schedule_mcp_ready": "Ready for scheduled chats","com_ui_schedule_mcp_reauth": "Reconnect this MCP server before enabling the schedule.","com_ui_schedule_mcp_configuration": "Configure or remove this MCP server before enabling the schedule.",diff --git a/packages/api/src/agents/index.ts b/packages/api/src/agents/index.tsindex 78bfe7f689..53c81e15ea 100644--- a/packages/api/src/agents/index.ts+++ b/packages/api/src/agents/index.ts@@ -77,6 +77,7 @@ export * from './activityLabels';export * from './activityPhases';export * from './subagentDelivery';export * from './view';+export * from './workspace';export * from './reasoningLabels';export * from './refusal';export * from './toolValidation';diff --git a/packages/api/src/agents/management.ts b/packages/api/src/agents/management.tsindex af834b0609..3c297b9741 100644--- a/packages/api/src/agents/management.ts+++ b/packages/api/src/agents/management.ts@@ -279,6 +279,7 @@ export function projectAgentManagementResponse(stateful_code_sessions: source.stateful_code_sessions,stateful_code_environment: source.stateful_code_environment,code_environment_id: source.code_environment_id,+ code_workspace_id: source.code_workspace_id,git_identity: source.git_identity,artifacts: source.artifacts,recursion_limit: source.recursion_limit,diff --git a/packages/api/src/agents/validation.ts b/packages/api/src/agents/validation.tsindex e5baf2be8a..47e917267d 100644--- a/packages/api/src/agents/validation.ts+++ b/packages/api/src/agents/validation.ts@@ -1,5 +1,6 @@import { z } from 'zod';import {+ CODE_WORKSPACE_ID_PATTERN,MemoryScope,SkillsScope,getMaxSubagents,@@ -25,6 +26,11 @@ import type { Request, Response } from 'express';*/type LooseRequest = Request<unknown, unknown, unknown>;+const agentCodeWorkspaceIdSchema: z.ZodUnion<[z.ZodLiteral<''>, z.ZodString]> = z.union([+ z.literal(''),+ z.string().regex(CODE_WORKSPACE_ID_PATTERN),+]);+/** Avatar schema shared between create and update */export const agentAvatarSchema: z.ZodObject<{@@ -500,6 +506,7 @@ export const agentBaseSchema: z.ZodObject<stateful_code_sessions: z.ZodOptional<z.ZodBoolean>;stateful_code_environment: z.ZodOptional<z.ZodEnum<['user', 'agent-user', 'conversation']>>;code_environment_id: z.ZodOptional<z.ZodString>;+ code_workspace_id: z.ZodOptional<typeof agentCodeWorkspaceIdSchema>;git_identity: typeof agentGitIdentitySchema;artifacts: z.ZodOptional<z.ZodString>;recursion_limit: z.ZodOptional<z.ZodNumber>;@@ -576,6 +583,7 @@ export const agentBaseSchema: z.ZodObject<stateful_code_sessions: z.boolean().optional(),stateful_code_environment: z.enum(['user', 'agent-user', 'conversation']).optional(),code_environment_id: agentCodeEnvironmentIdSchema.optional(),+ code_workspace_id: agentCodeWorkspaceIdSchema.optional(),git_identity: agentGitIdentitySchema,artifacts: z.string().optional(),recursion_limit: z.number().optional(),@@ -676,6 +684,7 @@ export const agentCreateSchema: z.ZodObject<stateful_code_environment: z.ZodOptional<z.ZodEnum<['user', 'agent-user', 'conversation']>>;code_environment_id: z.ZodOptional<z.ZodString>;git_identity: typeof agentGitIdentitySchema;+ code_workspace_id: z.ZodOptional<typeof agentCodeWorkspaceIdSchema>;artifacts: z.ZodOptional<z.ZodString>;recursion_limit: z.ZodOptional<z.ZodNumber>;conversation_starters: z.ZodOptional<z.ZodArray<z.ZodString, 'many'>>;@@ -810,6 +819,7 @@ export const agentUpdateSchema: z.ZodObject<stateful_code_sessions: z.ZodOptional<z.ZodBoolean>;stateful_code_environment: z.ZodOptional<z.ZodEnum<['user', 'agent-user', 'conversation']>>;code_environment_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;+ code_workspace_id: z.ZodOptional<typeof agentCodeWorkspaceIdSchema>;git_identity: typeof agentGitIdentityUpdateSchema;artifacts: z.ZodOptional<z.ZodString>;recursion_limit: z.ZodOptional<z.ZodNumber>;@@ -895,6 +905,7 @@ export const agentUpdateSchema: z.ZodObject<> = agentBaseSchema.extend({avatar: z.union([agentAvatarSchema, z.null()]).optional(),code_environment_id: agentCodeEnvironmentIdSchema.nullable().optional(),+ code_workspace_id: agentCodeWorkspaceIdSchema.optional(),git_identity: agentGitIdentityUpdateSchema,provider: z.string().optional(),model: z.string().nullable().optional(),diff --git a/packages/api/src/agents/workspace-default.spec.ts b/packages/api/src/agents/workspace-default.spec.tsnew file mode 100644index 0000000000..bc72caf66c--- /dev/null+++ b/packages/api/src/agents/workspace-default.spec.ts@@ -0,0 +1,18 @@+import { agentUpdateSchema } from './validation';++describe('agent workspace default', () => {+ it('retains a default and an explicit reset through update validation', () => {+ expect(agentUpdateSchema.parse({ code_workspace_id: 'primary' }).code_workspace_id).toBe(+ 'primary',+ );+ expect(agentUpdateSchema.parse({ code_workspace_id: '' }).code_workspace_id).toBe('');+ expect(agentUpdateSchema.parse({}).code_workspace_id).toBeUndefined();+ });++ it('rejects malformed or non-string defaults', () => {+ expect(agentUpdateSchema.safeParse({ code_workspace_id: 'x'.repeat(129) }).success).toBe(false);+ expect(agentUpdateSchema.safeParse({ code_workspace_id: 'bad workspace' }).success).toBe(false);+ expect(agentUpdateSchema.safeParse({ code_workspace_id: '../escape' }).success).toBe(false);+ expect(agentUpdateSchema.safeParse({ code_workspace_id: {} }).success).toBe(false);+ });+});diff --git a/packages/api/src/agents/workspace.spec.ts b/packages/api/src/agents/workspace.spec.tsnew file mode 100644index 0000000000..e1caeeb25c--- /dev/null+++ b/packages/api/src/agents/workspace.spec.ts@@ -0,0 +1,104 @@+import {+ AGENT_WORKSPACE_ATTACHED_ENVIRONMENT_ERROR,+ reconcileAgentWorkspaceDefault,+ validateAgentWorkspaceDefaultBinding,+} from './workspace';++describe('reconcileAgentWorkspaceDefault', () => {+ it('clears a stale default when the attached environment changes', () => {+ expect(+ reconcileAgentWorkspaceDefault({+ update: { code_environment_id: 'machine-b' },+ request: { code_environment_id: 'machine-b' },+ currentEnvironmentId: 'machine-a',+ }),+ ).toEqual({ code_environment_id: 'machine-b', code_workspace_id: '' });+ });++ it('preserves an explicit replacement default', () => {+ expect(+ reconcileAgentWorkspaceDefault({+ update: { code_environment_id: 'machine-b', code_workspace_id: 'project-b' },+ request: { code_environment_id: 'machine-b', code_workspace_id: 'project-b' },+ currentEnvironmentId: 'machine-a',+ }),+ ).toEqual({ code_environment_id: 'machine-b', code_workspace_id: 'project-b' });+ });++ it('does not clear the default when an unchanged environment is resubmitted', () => {+ expect(+ reconcileAgentWorkspaceDefault({+ update: { code_environment_id: 'machine-a' },+ request: { code_environment_id: 'machine-a' },+ currentEnvironmentId: 'machine-a',+ }),+ ).toEqual({ code_environment_id: 'machine-a' });+ });+});++describe('validateAgentWorkspaceDefaultBinding', () => {+ const environments = [+ { id: 'attached-vm', type: 'attached' },+ { id: 'managed-runtime', type: 'managed' },+ ];++ it('accepts a new default bound to an explicit attached environment', () => {+ expect(+ validateAgentWorkspaceDefaultBinding({+ workspaceId: 'project-a',+ environmentId: 'attached-vm',+ environments,+ }),+ ).toEqual({ valid: true });+ });++ it.each([+ ['an omitted environment', undefined],+ ['a managed environment', 'managed-runtime'],+ ['an unconfigured environment', 'missing-vm'],+ ])('rejects a new default bound to %s', (_label, environmentId) => {+ expect(+ validateAgentWorkspaceDefaultBinding({+ workspaceId: 'project-a',+ environmentId,+ environments,+ }),+ ).toEqual({ valid: false, error: AGENT_WORKSPACE_ATTACHED_ENVIRONMENT_ERROR });+ });++ it('skips an unchanged binding after its environment is removed', () => {+ expect(+ validateAgentWorkspaceDefaultBinding({+ workspaceId: 'project-a',+ environmentId: 'removed-vm',+ currentWorkspaceId: 'project-a',+ currentEnvironmentId: 'removed-vm',+ environments,+ }),+ ).toEqual({ valid: true });+ });++ it('revalidates the same workspace when it is rebound to another environment', () => {+ expect(+ validateAgentWorkspaceDefaultBinding({+ workspaceId: 'project-a',+ environmentId: 'managed-runtime',+ currentWorkspaceId: 'project-a',+ currentEnvironmentId: 'attached-vm',+ environments,+ }),+ ).toEqual({ valid: false, error: AGENT_WORKSPACE_ATTACHED_ENVIRONMENT_ERROR });+ });++ it('allows clearing a stale default', () => {+ expect(+ validateAgentWorkspaceDefaultBinding({+ workspaceId: '',+ environmentId: 'removed-vm',+ currentWorkspaceId: 'project-a',+ currentEnvironmentId: 'removed-vm',+ environments,+ }),+ ).toEqual({ valid: true });+ });+});diff --git a/packages/api/src/agents/workspace.ts b/packages/api/src/agents/workspace.tsnew file mode 100644index 0000000000..6cebbd41ae--- /dev/null+++ b/packages/api/src/agents/workspace.ts@@ -0,0 +1,85 @@+interface AgentWorkspaceUpdate {+ code_environment_id?: string | null;+ code_workspace_id?: string;+ [key: string]: unknown;+}++interface AgentWorkspaceEnvironment {+ id: string;+ type?: string;+}++export const AGENT_WORKSPACE_ATTACHED_ENVIRONMENT_ERROR =+ 'Code workspace defaults require an explicit attached code environment';++export function shouldValidateAgentWorkspaceDefaultBinding({+ workspaceId,+ environmentId,+ currentWorkspaceId,+ currentEnvironmentId,+}: {+ workspaceId?: string;+ environmentId?: string | null;+ currentWorkspaceId?: string;+ currentEnvironmentId?: string | null;+}): boolean {+ return Boolean(+ workspaceId &&+ (workspaceId !== currentWorkspaceId ||+ (environmentId ?? undefined) !== (currentEnvironmentId ?? undefined)),+ );+}++/** Validate only a newly selected or rebound machine-scoped workspace default. */+export function validateAgentWorkspaceDefaultBinding({+ workspaceId,+ environmentId,+ currentWorkspaceId,+ currentEnvironmentId,+ environments,+}: {+ workspaceId?: string;+ environmentId?: string | null;+ currentWorkspaceId?: string;+ currentEnvironmentId?: string | null;+ environments?: readonly AgentWorkspaceEnvironment[];+}): { valid: true } | { valid: false; error: string } {+ if (+ !shouldValidateAgentWorkspaceDefaultBinding({+ workspaceId,+ environmentId,+ currentWorkspaceId,+ currentEnvironmentId,+ })+ ) {+ return { valid: true };+ }++ const configuredEnvironment = environments?.find(+ (environment) => environment.id === (environmentId ?? undefined),+ );+ if (configuredEnvironment?.type === 'attached') {+ return { valid: true };+ }++ return { valid: false, error: AGENT_WORKSPACE_ATTACHED_ENVIRONMENT_ERROR };+}++/** Clear a machine-scoped default when its environment changes without a replacement default. */+export function reconcileAgentWorkspaceDefault<T extends AgentWorkspaceUpdate>({+ update,+ request,+ currentEnvironmentId,+}: {+ update: T;+ request: AgentWorkspaceUpdate;+ currentEnvironmentId?: string | null;+}): T {+ const changesEnvironment =+ Object.prototype.hasOwnProperty.call(request, 'code_environment_id') &&+ request.code_environment_id !== currentEnvironmentId;+ if (!changesEnvironment || Object.prototype.hasOwnProperty.call(request, 'code_workspace_id')) {+ return update;+ }+ return { ...update, code_workspace_id: '' };+}diff --git a/packages/data-provider/src/schemas.ts b/packages/data-provider/src/schemas.tsindex 7fe252767d..434aaa3633 100644--- a/packages/data-provider/src/schemas.ts+++ b/packages/data-provider/src/schemas.ts@@ -386,6 +386,7 @@ export const defaultAgentFormValues = {[Tools.memory]: false,stateful_code_environment: 'user' as const,code_environment_id: undefined as string | null | undefined,+ code_workspace_id: undefined as string | undefined,category: 'general',support_contact: {name: '',diff --git a/packages/data-provider/src/types/assistants.ts b/packages/data-provider/src/types/assistants.tsindex f0cd8c909b..3644a64e8c 100644--- a/packages/data-provider/src/types/assistants.ts+++ b/packages/data-provider/src/types/assistants.ts@@ -364,6 +364,8 @@ export type Agent = {stateful_code_environment?: StatefulCodeEnvironment;/** Operator-configured managed or attached stateful execution environment. */code_environment_id?: string | null;+ /** Default attached workspace for new chats; empty means no agent default. */+ code_workspace_id?: string;/** Non-secret Git authorship injected into this agent's sandboxed commands. */git_identity?: AgentGitIdentity | null;artifacts?: ArtifactModes;@@ -427,6 +429,7 @@ export type AgentCreateParams = {| 'stateful_code_sessions'| 'stateful_code_environment'| 'code_environment_id'+ | 'code_workspace_id'| 'artifacts'| 'recursion_limit'| 'category'@@ -461,6 +464,7 @@ export type AgentUpdateParams = {| 'stateful_code_environment'| 'code_environment_id'| 'git_identity'+ | 'code_workspace_id'| 'artifacts'| 'recursion_limit'| 'category'diff --git a/packages/data-schemas/src/methods/agent.spec.ts b/packages/data-schemas/src/methods/agent.spec.tsindex 89ec4fd6d7..fc24723e3c 100644--- a/packages/data-schemas/src/methods/agent.spec.ts+++ b/packages/data-schemas/src/methods/agent.spec.ts@@ -2440,6 +2440,22 @@ describe('Agent Methods', () => {expect(updated!.versions![1].code_environment_id).toBeUndefined();});+ test('persists and restores the workspace default without retaining a later preference', async () => {+ const agentId = `agent_${uuidv4()}`;+ await createAgent({+ id: agentId,+ provider: 'test',+ model: 'test-model',+ author: new mongoose.Types.ObjectId(),+ });+ await updateAgent({ id: agentId }, { code_workspace_id: 'project-a' });+ expect((await getAgent({ id: agentId }))?.code_workspace_id).toBe('project-a');+ await updateAgent({ id: agentId }, { code_workspace_id: '' });+ expect((await getAgent({ id: agentId }))?.code_workspace_id).toBe('');+ expect((await revertAgentVersion({ id: agentId }, 1))?.code_workspace_id).toBe('project-a');+ expect((await revertAgentVersion({ id: agentId }, 0))?.code_workspace_id).toBeUndefined();+ });+test('should handle parameter objects correctly', async () => {const agentId = `agent_${uuidv4()}`;const authorId = new mongoose.Types.ObjectId();@@ -5005,6 +5021,69 @@ describe('Support Contact Field', () => {expect(result.data[0].conversation_starters).toEqual(starters);});+ test('should include workspace execution metadata only when explicitly requested', async () => {+ const scopedAgent = await createAgent({+ id: `agent_${uuidv4().slice(0, 12)}`,+ name: 'Workspace Agent',+ description: 'Agent with attached workspace defaults',+ provider: 'openai',+ model: 'gpt-4',+ author: userA,+ tools: [EToolResources.execute_code, 'private_mcp_tool'],+ stateful_code_sessions: true,+ code_environment_id: 'machine-a',+ code_workspace_id: 'project-a',+ agent_ids: [agentA1.id],+ edges: [{ from: 'source', to: agentA1.id, prompt: 'Private routing prompt' }],+ subagents: {+ enabled: true,+ agent_ids: [agentA1.id],+ graphs: [+ {+ type: 'collapsed_team',+ name: 'Private graph name',+ agent_ids: [agentA1.id],+ edges: [],+ entry_agent_id: agentA1.id,+ result_agent_id: agentA1.id,+ },+ ],+ },+ });++ const defaultResult = await getListAgentsByAccess({+ accessibleIds: [scopedAgent._id] as mongoose.Types.ObjectId[],+ otherParams: {},+ });+ expect(defaultResult.data[0].tools).toBeUndefined();+ expect(defaultResult.data[0].code_workspace_id).toBeUndefined();+ expect(defaultResult.data[0].edges).toBeUndefined();++ const result = await getListAgentsByAccess({+ accessibleIds: [scopedAgent._id] as mongoose.Types.ObjectId[],+ otherParams: {},+ includeExecutionConfig: true,+ });++ expect(result.data[0]).toMatchObject({+ tools: [EToolResources.execute_code],+ stateful_code_sessions: true,+ code_environment_id: 'machine-a',+ code_workspace_id: 'project-a',+ agent_ids: [agentA1.id],+ edges: [{ from: 'source', to: agentA1.id }],+ subagents: {+ enabled: true,+ agent_ids: [agentA1.id],+ graphs: [{ agent_ids: [agentA1.id] }],+ },+ });+ expect(result.data[0].tools).not.toContain('private_mcp_tool');+ expect(result.data[0].edges).not.toEqual(+ expect.arrayContaining([expect.objectContaining({ prompt: expect.anything() })]),+ );+ });+test('should return multiple accessible agents when provided', async () => {// Give User B access to two of User A's agentsconst accessibleIds = [agentA1._id, agentA3._id] as mongoose.Types.ObjectId[];diff --git a/packages/data-schemas/src/methods/agent.ts b/packages/data-schemas/src/methods/agent.tsindex 885202e828..e68c253a2f 100644--- a/packages/data-schemas/src/methods/agent.ts+++ b/packages/data-schemas/src/methods/agent.ts@@ -604,12 +604,14 @@ export function createAgentMethods(limit,after,includeSkillConfig,+ includeExecutionConfig,}: {accessibleIds?: Types.ObjectId[];otherParams?: Record<string, unknown>;limit?: number | null;after?: string | null;includeSkillConfig?: boolean;+ includeExecutionConfig?: boolean;}) => Promise<{object: string;data: Array<Record<string, unknown>>;@@ -1352,12 +1354,14 @@ export function createAgentMethods(limit = 100,after = null,includeSkillConfig = false,+ includeExecutionConfig = false,}: {accessibleIds?: Types.ObjectId[];otherParams?: Record<string, unknown>;limit?: number | null;after?: string | null;includeSkillConfig?: boolean;+ includeExecutionConfig?: boolean;}): Promise<{object: string;data: Array<Record<string, unknown>>;@@ -1425,6 +1429,18 @@ export function createAgentMethods(projection.skill_authoring_enabled = 1;projection.skills_scope = 1;}+ if (includeExecutionConfig) {+ projection.tools = 1;+ projection.stateful_code_sessions = 1;+ projection.code_environment_id = 1;+ projection.code_workspace_id = 1;+ projection.agent_ids = 1;+ projection['edges.from'] = 1;+ projection['edges.to'] = 1;+ projection['subagents.enabled'] = 1;+ projection['subagents.agent_ids'] = 1;+ projection['subagents.graphs.agent_ids'] = 1;+ }let query = Agent.find(baseQuery, projection).sort({ updatedAt: -1, _id: 1 });@@ -1437,6 +1453,12 @@ export function createAgentMethods(const hasMore = isPaginated && normalizedLimit ? agents.length > normalizedLimit : false;const data = (isPaginated && normalizedLimit ? agents.slice(0, normalizedLimit) : agents).map((agent) => {+ if (includeExecutionConfig) {+ agent.tools =+ Array.isArray(agent.tools) && agent.tools.includes(EToolResources.execute_code)+ ? [EToolResources.execute_code]+ : [];+ }if (agent.author) {agent.author = (agent.author as Types.ObjectId).toString();}@@ -1578,6 +1600,7 @@ export function createAgentMethods(const unsetOnRestore: Record<string, 1> = {};for (const field of ['code_environment_id',+ 'code_workspace_id','git_identity','skills_scope','skill_authoring_enabled',diff --git a/packages/data-schemas/src/schema/agent.ts b/packages/data-schemas/src/schema/agent.tsindex 77e8792e5d..2f5fdfe539 100644--- a/packages/data-schemas/src/schema/agent.ts+++ b/packages/data-schemas/src/schema/agent.ts@@ -94,6 +94,7 @@ const agentSchema: Schema<IAgent> = new Schema<IAgent>(code_environment_id: {type: String,},+ code_workspace_id: { type: String },git_identity: {type: new Schema({diff --git a/packages/data-schemas/src/schema/agentWorkspace.spec.ts b/packages/data-schemas/src/schema/agentWorkspace.spec.tsnew file mode 100644index 0000000000..d51c452b42--- /dev/null+++ b/packages/data-schemas/src/schema/agentWorkspace.spec.ts@@ -0,0 +1,10 @@+import { model, models } from 'mongoose';+import agentSchema from './agent';++it('retains the agent workspace preference and explicit reset through serialization', () => {+ const Agent = models.WorkspaceDefaultAgent ?? model('WorkspaceDefaultAgent', agentSchema);+ const agent = new Agent({ code_environment_id: 'machine-a', code_workspace_id: 'project-a' });+ expect(new Agent(agent.toObject()).toObject().code_workspace_id).toBe('project-a');+ agent.code_workspace_id = '';+ expect(new Agent(agent.toObject()).toObject().code_workspace_id).toBe('');+});diff --git a/packages/data-schemas/src/types/agent.ts b/packages/data-schemas/src/types/agent.tsindex 8e55020542..6f277f3eaf 100644--- a/packages/data-schemas/src/types/agent.ts+++ b/packages/data-schemas/src/types/agent.ts@@ -43,6 +43,7 @@ export interface IAgent extends Omit<Document, 'model'> {stateful_code_sessions?: boolean;stateful_code_environment?: 'user' | 'agent-user' | 'conversation';code_environment_id?: string;+ code_workspace_id?: string;git_identity?: AgentGitIdentity | null;/** @deprecated Use edges instead */agent_ids?: string[];