diff --git a/client/src/hooks/SSE/__tests__/workspace.spec.tsx b/client/src/hooks/SSE/__tests__/workspace.spec.tsx new file mode 100644 index 0000000000..ca9cec3862 --- /dev/null +++ b/client/src/hooks/SSE/__tests__/workspace.spec.tsx @@ -0,0 +1,267 @@ +import { useState } from 'react'; +import { RecoilRoot } from 'recoil'; +import { MemoryRouter } from 'react-router-dom'; +import { act, renderHook } from '@testing-library/react'; +import { QueryClient, QueryClientProvider } from '@tanstack/react-query'; +import { Constants, EModelEndpoint, QueryKeys } from 'librechat-data-provider'; +import type { EventSubmission, TConversation } from 'librechat-data-provider'; +import useCodeWorkspace from '~/hooks/Agents/useCodeWorkspace'; +import useEventHandlers from '../useEventHandlers'; + +const mockStatus = jest.fn(); +const mockStartupConfig = jest.fn(); +const mockApplyAgentTemplate = jest.fn(); +const mockAnnounce = jest.fn(); +const mockReset = jest.fn(); + +jest.mock('~/hooks/Agents', () => ({ useApplyAgentTemplate: () => mockApplyAgentTemplate })); +jest.mock('~/hooks/AuthContext', () => ({ useAuthContext: () => ({ token: 'test' }) })); +jest.mock('~/Providers', () => ({ + useLiveAnnouncer: () => ({ announcePolite: mockAnnounce }), + useAgentsMapContext: () => ({}), +})); +jest.mock('~/hooks/SSE/useContentHandler', () => () => ({})); +jest.mock('~/hooks/SSE/useAttachmentHandler', () => () => jest.fn()); +jest.mock('~/hooks/SSE/useStepHandler', () => () => ({ + resetSubagentAtoms: mockReset, + resetPtcAtoms: mockReset, +})); +jest.mock('~/hooks/Agents/workspacePreferences', () => ({ + useWorkspacePreferences: () => ({ get: () => undefined }), +})); +jest.mock('~/hooks/Roles/useHasAccess', () => () => true); +jest.mock('~/hooks/Agents/useAgentToolPermissions', () => () => ({ + agent: { + id: 'agent_primary', + stateful_code_sessions: true, + code_environment_id: 'personal-vm', + tools: ['execute_code'], + }, +})); +jest.mock('~/hooks/Agents/useGetAgentsConfig', () => () => ({ + agentsConfig: { + capabilities: ['execute_code', 'stateful_code_sessions'], + statefulCodeSessions: { + environments: [{ id: 'personal-vm', type: 'attached', name: 'Personal VM' }], + }, + }, +})); +jest.mock('~/data-provider', () => ({ + ...jest.requireActual('~/data-provider'), + useCodeEnvironmentStatusQueries: () => mockStatus(), + useGetStartupConfig: () => ({ data: mockStartupConfig() }), +})); + +const selection = { environmentId: 'personal-vm', workspaceId: 'project-a' }; +const initialConversation = { + conversationId: Constants.NEW_CONVO, + endpoint: EModelEndpoint.agents, + agent_id: 'agent_primary', + title: 'New Chat', +} as TConversation; + +function setup(current = initialConversation, isAddedRequest = false) { + const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } }); + queryClient.setQueryData([QueryKeys.allConversations], { pages: [], pageParams: [] }); + const wrapper = ({ children }: { children: React.ReactNode }) => ( + + + {children} + + + ); + const hook = renderHook( + () => { + const [conversation, setConversation] = useState(current); + const handlers = useEventHandlers({ + isAddedRequest, + setConversation, + setMessages: jest.fn(), + getMessages: () => [], + setCompleted: jest.fn(), + setIsSubmitting: jest.fn(), + setShowStopButton: jest.fn(), + }); + return { + conversation, + setConversation, + workspace: useCodeWorkspace(conversation), + ...handlers, + }; + }, + { wrapper }, + ); + const submission: EventSubmission = { + isTemporary: false, + endpointOption: { endpoint: EModelEndpoint.agents }, + conversation: current, + messages: [], + userMessage: { + messageId: 'user-1', + text: 'Hello', + sender: 'User', + isCreatedByUser: true, + parentMessageId: String(Constants.NO_PARENT), + conversationId: 'saved-chat', + }, + initialResponse: { + messageId: 'response-1', + parentMessageId: 'user-1', + conversationId: 'saved-chat', + text: '', + sender: 'Assistant', + isCreatedByUser: false, + }, + ...hook.result.current.workspace.resolveSubmission( + current.codeWorkspaces, + current.codeEnvironmentMode, + ), + }; + const createdData = { + conversation: current, + requestMessage: submission.userMessage, + responseMessage: submission.initialResponse, + }; + return { ...hook, submission, createdData, queryClient }; +} + +describe('workspace decision at stream acknowledgement', () => { + beforeEach(() => { + mockStartupConfig.mockReturnValue({ codeEnvironmentDecisionVersion: 1 }); + mockStatus.mockReturnValue([ + { + data: { + environmentId: 'personal-vm', + status: 'ready', + workspaces: [{ id: 'project-a', name: 'Project A' }], + }, + isLoading: false, + isError: false, + }, + ]); + }); + + it.each([ + ['created', true, false], + ['sync', true, false], + ['created', false, false], + ['sync', false, false], + ['created', true, true], + ['sync', true, true], + ] as const)( + 'seals an automatic workspace on %s (decision protocol %s, added pane %s)', + (event, decisions, isAddedRequest) => { + mockStartupConfig.mockReturnValue(decisions ? { codeEnvironmentDecisionVersion: 1 } : {}); + const { result, submission, createdData } = setup(initialConversation, isAddedRequest); + expect(result.current.conversation?.codeWorkspaces).toBeUndefined(); + expect(submission.codeWorkspaces).toEqual([selection]); + expect(result.current.workspace.locked).toBe(false); + + act(() => { + if (event === 'created') { + result.current.createdHandler(createdData, submission); + } else { + result.current.syncHandler( + { + sync: true, + thread_id: 'thread', + conversationId: 'saved-chat', + requestMessage: submission.userMessage, + responseMessage: submission.initialResponse, + }, + submission, + ); + } + }); + + expect(result.current.conversation).toMatchObject({ + conversationId: 'saved-chat', + codeEnvironmentMode: 'attached', + codeWorkspaces: [selection], + }); + expect(result.current.workspace).toMatchObject({ + locked: true, + canSubmit: true, + state: 'ready', + }); + }, + ); + + it('seals a without-attached submission while multiple workspaces remain available', () => { + mockStatus.mockReturnValue([ + { + data: { + environmentId: 'personal-vm', + status: 'ready', + workspaces: [{ id: 'project-a' }, { id: 'project-b' }], + }, + }, + ]); + const { result, submission, createdData } = setup(); + expect(submission.codeEnvironmentMode).toBe('without_attached'); + act(() => result.current.createdHandler(createdData, submission)); + expect(result.current.workspace).toMatchObject({ + locked: true, + canSubmit: true, + state: 'without_attached', + }); + }); + + it('does not replace a saved decision with a replay of an older submission', () => { + const { result, submission, createdData } = setup({ + ...initialConversation, + conversationId: 'saved-chat', + codeEnvironmentMode: 'without_attached', + }); + act(() => + result.current.createdHandler(createdData, { + ...submission, + codeEnvironmentMode: 'attached', + codeWorkspaces: [selection], + }), + ); + expect(result.current.conversation?.codeEnvironmentMode).toBe('without_attached'); + expect(result.current.conversation?.codeWorkspaces).toBeUndefined(); + }); + + it('records a first decision on a saved conversation that has not used a workspace', () => { + const { result, submission, createdData } = setup({ + ...initialConversation, + conversationId: 'saved-chat', + }); + expect(result.current.workspace.locked).toBe(false); + act(() => result.current.createdHandler(createdData, submission)); + expect(result.current.conversation?.codeWorkspaces).toEqual([selection]); + expect(result.current.workspace.locked).toBe(true); + }); + + it('uses the submitted without-attached choice rather than a stale draft selection', () => { + const { result, submission, createdData } = setup({ + ...initialConversation, + codeEnvironmentMode: 'attached', + codeWorkspaces: [selection], + }); + act(() => + result.current.createdHandler(createdData, { + ...submission, + codeEnvironmentMode: 'without_attached', + codeWorkspaces: undefined, + }), + ); + expect(result.current.conversation?.codeWorkspaces).toBeUndefined(); + expect(result.current.workspace).toMatchObject({ locked: true, state: 'without_attached' }); + }); + + it('leaves an undecided conversation editable when the submission has no decision', () => { + const { result, submission, createdData } = setup(); + act(() => + result.current.createdHandler(createdData, { + ...submission, + codeEnvironmentMode: undefined, + codeWorkspaces: undefined, + }), + ); + expect(result.current.conversation?.codeEnvironmentMode).toBeUndefined(); + expect(result.current.workspace.locked).toBe(false); + }); +}); diff --git a/client/src/hooks/SSE/useEventHandlers.ts b/client/src/hooks/SSE/useEventHandlers.ts index 52a5d17d2b..c1d801b078 100644 --- a/client/src/hooks/SSE/useEventHandlers.ts +++ b/client/src/hooks/SSE/useEventHandlers.ts @@ -103,6 +103,25 @@ export const buildCreatedInitialResponse = ({ conversationId: userMessage.conversationId ?? initialResponse.conversationId, }); +/** Apply the resolved request choice only after acknowledgement. A saved decision may have + * moved since this event was emitted, so replay must never replace it. */ +function acknowledgedCodeEnvironment( + current: TConversation | null, + submission: EventSubmission, +): Pick { + const { codeEnvironmentMode, codeWorkspaces } = submission; + if (codeEnvironmentMode == null && !codeWorkspaces?.length) return {}; + const saved = + current?.conversationId != null && + current.conversationId !== Constants.NEW_CONVO && + current.conversationId !== Constants.PENDING_CONVO; + if (saved && (current.codeEnvironmentMode != null || current.codeWorkspaces?.length)) return {}; + return { + codeEnvironmentMode, + codeWorkspaces: codeEnvironmentMode === 'without_attached' ? undefined : codeWorkspaces, + }; +} + export const isInitialNewConversationSubmission = ({ userMessage, }: Pick): boolean => @@ -718,6 +737,7 @@ export default function useEventHandlers({ }); update = tConvoUpdateSchema.parse({ ...prevState, + ...acknowledgedCodeEnvironment(prevState, submission), conversationId, thread_id, title, @@ -742,6 +762,7 @@ export default function useEventHandlers({ setConversation((prevState) => { update = tConvoUpdateSchema.parse({ ...prevState, + ...acknowledgedCodeEnvironment(prevState, submission), conversationId, thread_id, messages: [requestMessage.messageId, responseMessage.messageId], @@ -801,6 +822,7 @@ export default function useEventHandlers({ }); update = tConvoUpdateSchema.parse({ ...prevState, + ...acknowledgedCodeEnvironment(prevState, submission), conversationId, title, }) as TConversation; @@ -823,6 +845,7 @@ export default function useEventHandlers({ setConversation((prevState) => { update = tConvoUpdateSchema.parse({ ...prevState, + ...acknowledgedCodeEnvironment(prevState, submission), conversationId, }) as TConversation; return update;