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 = {}): 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( { 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() { { + 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, + }); + } + }} + > + + + + + + {localize('com_ui_code_workspace_last_used')} + + {workspaceId && + (workspaceDiscoveryState !== 'ready' || + !workspaces.some(({ id }) => id === workspaceId)) && ( + + {workspaceId} —{' '} + {localize( + workspaceDiscoveryState === 'ready' + ? 'com_ui_code_workspace_missing' + : WORKSPACE_STATUS_LABELS[workspaceDiscoveryState], + )} + + )} + {workspaces.map(({ id, name }) => ( + + {name ?? id} + + ))} + + + {workspaceDiscoveryState !== 'ready' && ( +

+ {localize(WORKSPACE_STATUS_LABELS[workspaceDiscoveryState])} +

+ )} +

+ {localize('com_ui_code_workspace_default_description')} +

+ + )} {showGitIdentity && (
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: () =>
})); jest.mock('../../../FileContext', () => ({ __esModule: true, default: () =>
})); jest.mock('../../../FileSearch', () => ({ __esModule: true, default: () =>
})); 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({ 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 {JSON.stringify(methods.watch('git_identity'))} + {methods.watch('code_workspace_id')} + {methods.watch('code_environment_id')} ); } +test('saves a workspace default bound to the selected machine and permits clearing it', async () => { + HTMLElement.prototype.scrollIntoView = jest.fn(); + render(); + 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(); + + 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(); + + 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(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(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([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( + { + 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(); + const defaults = new Map>(); + const preferenceAgentIds = new Map>(); 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(); + 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(); + 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(); + 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, @@ -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('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; +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; stateful_code_environment: z.ZodOptional>; code_environment_id: z.ZodOptional; + code_workspace_id: z.ZodOptional; git_identity: typeof agentGitIdentitySchema; artifacts: z.ZodOptional; recursion_limit: z.ZodOptional; @@ -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>; code_environment_id: z.ZodOptional; git_identity: typeof agentGitIdentitySchema; + code_workspace_id: z.ZodOptional; artifacts: z.ZodOptional; recursion_limit: z.ZodOptional; conversation_starters: z.ZodOptional>; @@ -810,6 +819,7 @@ export const agentUpdateSchema: z.ZodObject< stateful_code_sessions: z.ZodOptional; stateful_code_environment: z.ZodOptional>; code_environment_id: z.ZodOptional>; + code_workspace_id: z.ZodOptional; git_identity: typeof agentGitIdentityUpdateSchema; artifacts: z.ZodOptional; recursion_limit: z.ZodOptional; @@ -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({ + 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; limit?: number | null; after?: string | null; includeSkillConfig?: boolean; + includeExecutionConfig?: boolean; }) => Promise<{ object: string; data: Array>; @@ -1352,12 +1354,14 @@ export function createAgentMethods( limit = 100, after = null, includeSkillConfig = false, + includeExecutionConfig = false, }: { accessibleIds?: Types.ObjectId[]; otherParams?: Record; limit?: number | null; after?: string | null; includeSkillConfig?: boolean; + includeExecutionConfig?: boolean; }): Promise<{ object: string; data: Array>; @@ -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 = {}; 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 = new Schema( 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 { 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[];