Skip to content

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

🏡 feat: Remember Agent Workspace Defaults (#15843)

Danny Avila1d45f5bd407a
diff --git a/api/server/controllers/agents/v1.js b/api/server/controllers/agents/v1.js
index 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.js
index 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.ts
index 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.tsx
index 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.tsx
index 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> = {}): CodeWorkspaceR
selections: [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(
<CodeWorkspaceMenu
conversation={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.tsx
index 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.tsx
index 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.tsx
index 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() {
<Select
value={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.tsx
index 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.tsx
index 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_identi
execute_code: true,
stateful_code_sessions: true,
git_identity: savedIdentity,
+ code_workspace_id: savedWorkspace,
},
});
return (
@@ -44,10 +69,55 @@ function IdentityForm({ savedIdentity }: { savedIdentity?: AgentForm['git_identi
Disable 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.ts
index 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.ts
index 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.ts
index 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.tsx
index 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']): TConver
describe('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.ts
index 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.tsx
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.tsx
index 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.ts
index 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.ts
index 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.json
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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 agents
const 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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[];