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

🪁 fix: Keep Workspace Discovery Reactive (#16296)

lia-by-librechat[bot]d0850e7389be
diff --git a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx
index dbbcdf9188..6646ef5a5f 100644
--- a/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx
+++ b/client/src/components/Chat/Input/CodeWorkspaceMenu.tsx
@@ -1,6 +1,6 @@
import { useState } from 'react';
import * as Ariakit from '@ariakit/react';
-import { Check, ChevronDown, Folder, FolderSync, FolderX } from 'lucide-react';
+import { Check, ChevronDown, Folder, FolderSync, FolderX, RefreshCw } from 'lucide-react';
import { TooltipAnchor, composerControlClasses, useToastContext } from '@librechat/client';
import type { CodeWorkspaceSelection, TConversation } from 'librechat-data-provider';
import type { SetterOrUpdater } from 'recoil';
@@ -10,13 +10,16 @@ import type {
CodeWorkspaceResult,
TranslationKeys,
} from '~/hooks';
+import {
+ useCodeWorkspaceRefresh,
+ useMoveConversationCodeEnvironmentMutation,
+} from '~/data-provider';
import {
cn,
codeWorkspaceErrorKeys,
getCodeWorkspaceErrorReason,
getResponseStatus,
} from '~/utils';
-import { useMoveConversationCodeEnvironmentMutation } from '~/data-provider';
import { useLocalize } from '~/hooks';
const stateLabels: Partial<Record<CodeWorkspaceResult['state'], TranslationKeys>> = {
@@ -174,6 +177,7 @@ export default function CodeWorkspaceMenu({
const menuStore = Ariakit.useMenuStore({ focusLoop: true, placement: 'top-start' });
const isOpen = menuStore.useState('open');
const moveMutation = useMoveConversationCodeEnvironmentMutation();
+ const { refresh, isRefreshing } = useCodeWorkspaceRefresh();
const [moveDraft, setMoveDraft] = useState<{
conversationId: string;
workspaces: Record<string, string>;
@@ -217,7 +221,7 @@ export default function CodeWorkspaceMenu({
);
const labelKey = stateLabels[workspace.state];
let label =
- workspace.mode === 'without_attached'
+ workspace.state === 'without_attached'
? localize('com_ui_code_workspace_without_attached')
: (onlyDescriptor?.name ?? onlyDescriptor?.id);
if (label == null && workspace.state === 'ready') {
@@ -241,16 +245,22 @@ export default function CodeWorkspaceMenu({
<TooltipAnchor
description={recovery}
render={
- <div
+ <button
+ type="button"
data-testid="code-workspace-locked-status"
- role="status"
- aria-label={`${label}. ${recovery}`}
- className={cn(composerControlClasses(), 'min-w-0 max-w-full cursor-default px-2.5')}
+ disabled={disabled || isRefreshing}
+ onClick={() => void refresh()}
+ aria-label={`${label}. ${recovery}. ${localize('com_ui_retry')}`}
+ aria-busy={isRefreshing}
+ className={cn(composerControlClasses(), 'min-w-0 max-w-full px-2.5')}
/>
}
>
<Icon className="size-4 shrink-0 text-text-secondary" aria-hidden="true" />
- <span className="min-w-0 max-w-[16rem] truncate">{label}</span>
+ <span role="status" className="min-w-0 max-w-[16rem] truncate">
+ {label}
+ </span>
+ <RefreshCw className="size-3 shrink-0 text-text-secondary" aria-hidden="true" />
</TooltipAnchor>
);
}
@@ -424,6 +434,22 @@ export default function CodeWorkspaceMenu({
))}
</>
)}
+ <Ariakit.MenuSeparator className="my-1 h-0 w-full border-t border-border-light" />
+ <Ariakit.MenuItem
+ disabled={buttonDisabled || isRefreshing}
+ hideOnClick={false}
+ onClick={() => void refresh()}
+ aria-busy={isRefreshing}
+ className={cn(
+ menuItemClasses(),
+ 'items-center aria-disabled:cursor-not-allowed aria-disabled:opacity-50',
+ )}
+ >
+ <RefreshCw className="size-4 shrink-0 text-text-secondary" aria-hidden="true" />
+ <span className="text-sm font-medium text-text-primary">
+ {localize('com_ui_refresh')}
+ </span>
+ </Ariakit.MenuItem>
</Ariakit.Menu>
</Ariakit.MenuProvider>
);
diff --git a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx
index c059b39fe3..2765297bc4 100644
--- a/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx
+++ b/client/src/components/Chat/Input/__tests__/CodeWorkspaceMenu.spec.tsx
@@ -88,6 +88,37 @@ function renderMenu(ui: React.ReactElement) {
}
describe('CodeWorkspaceMenu', () => {
+ test('shows loading rather than the inferred no-workspace fallback on first load', () => {
+ renderMenu(
+ <CodeWorkspaceMenu
+ setConversation={jest.fn()}
+ workspace={workspace({
+ mode: 'without_attached',
+ state: 'loading',
+ selections: undefined,
+ environments: [{ environment, state: 'loading', workspaces: [] }],
+ })}
+ disabled={false}
+ />,
+ );
+ expect(screen.getByTestId('code-workspace')).toHaveTextContent('com_ui_code_workspace_loading');
+ });
+
+ test('can retry a locked unavailable workspace without changing its saved decision', async () => {
+ const invalidate = jest.spyOn(QueryClient.prototype, 'invalidateQueries');
+ const setConversation = jest.fn();
+ renderMenu(
+ <CodeWorkspaceMenu
+ setConversation={setConversation}
+ workspace={workspace({ locked: true, state: 'unavailable', canSubmit: false })}
+ disabled={false}
+ />,
+ );
+ await userEvent.click(screen.getByRole('button', { name: /com_ui_retry/ }));
+ expect(invalidate).toHaveBeenCalled();
+ expect(setConversation).not.toHaveBeenCalled();
+ });
+
test('shows the instruction file and truncation reported by the worker', async () => {
const state = workspace();
state.environments[0].workspaces[0].instructions = [
@@ -260,7 +291,7 @@ describe('CodeWorkspaceMenu', () => {
);
expect(screen.getByTestId('code-workspace-locked-status')).toHaveAccessibleName(
- 'com_ui_code_workspace_unavailable. com_ui_code_workspace_locked_recovery',
+ 'com_ui_code_workspace_unavailable. com_ui_code_workspace_locked_recovery. com_ui_retry',
);
});
diff --git a/client/src/data-provider/Agents/queries.ts b/client/src/data-provider/Agents/queries.ts
index d51328aa25..0e6c1d06c7 100644
--- a/client/src/data-provider/Agents/queries.ts
+++ b/client/src/data-provider/Agents/queries.ts
@@ -6,6 +6,7 @@ import type {
UseInfiniteQueryOptions,
} from '@tanstack/react-query';
import type t from 'librechat-data-provider';
+import { retryTransientQuery } from '../retry';
import { isEphemeralAgent } from '~/common';
/**
@@ -74,8 +75,13 @@ export const useListAgentsQuery = <TData = t.AgentListResponse>(
params: t.AgentListParams = defaultAgentParams,
config?: UseQueryOptions<t.AgentListResponse, unknown, TData>,
): QueryObserverResult<TData> => {
- const queryClient = useQueryClient();
- const endpointsConfig = queryClient.getQueryData<t.TEndpointsConfig>([QueryKeys.endpoints]);
+ /** The shell owns fetching endpoints. Observe its query, but do not start a second
+ * request or couple this shared agent hook to the shell's Recoil gate. */
+ const { data: endpointsConfig } = useQuery<t.TEndpointsConfig>(
+ [QueryKeys.endpoints],
+ () => dataService.getAIEndpoints(),
+ { enabled: false },
+ );
const enabled = !!endpointsConfig?.[EModelEndpoint.agents];
return useQuery<t.AgentListResponse, unknown, TData>(
@@ -83,10 +89,10 @@ export const useListAgentsQuery = <TData = t.AgentListResponse>(
() => fetchAllAgentPages(params),
{
staleTime: 1000 * 5,
- refetchOnWindowFocus: false,
- refetchOnReconnect: false,
- refetchOnMount: false,
- retry: false,
+ refetchOnWindowFocus: true,
+ refetchOnReconnect: true,
+ refetchOnMount: true,
+ retry: retryTransientQuery,
...config,
enabled: config?.enabled !== undefined ? config.enabled && enabled : enabled,
},
@@ -109,10 +115,11 @@ export const useGetAgentByIdQuery = (
agent_id: agent_id as string,
}),
{
- refetchOnWindowFocus: false,
- refetchOnReconnect: false,
- refetchOnMount: false,
- retry: false,
+ staleTime: 1000 * 5,
+ refetchOnWindowFocus: true,
+ refetchOnReconnect: true,
+ refetchOnMount: true,
+ retry: retryTransientQuery,
...config,
enabled: isValidAgentId && (config?.enabled ?? true),
},
diff --git a/client/src/data-provider/CodeEnvironments.ts b/client/src/data-provider/CodeEnvironments.ts
index 6dad49dab8..3213accea3 100644
--- a/client/src/data-provider/CodeEnvironments.ts
+++ b/client/src/data-provider/CodeEnvironments.ts
@@ -1,5 +1,11 @@
-import { useMutation, useQueries, useQuery, useQueryClient } from '@tanstack/react-query';
import { DynamicQueryKeys, MutationKeys, QueryKeys, dataService } from 'librechat-data-provider';
+import {
+ useIsFetching,
+ useMutation,
+ useQueries,
+ useQuery,
+ useQueryClient,
+} from '@tanstack/react-query';
import type {
TConversation,
CodeEnvironmentUserSettings,
@@ -9,7 +15,9 @@ import type {
TCodeEnvironmentStatusResponse,
TCodeEnvironmentsResponse,
} from 'librechat-data-provider';
+import type { QueryFilters } from '@tanstack/react-query';
import { CONVERSATION_LIST_KEYS, updateConvoInAllQueries } from '~/utils';
+import { retryTransientQuery } from './retry';
export type CodeEnvironmentPairingResponse = TCodeEnvironmentPairingResponse;
@@ -21,30 +29,41 @@ export function useCodeEnvironmentsQuery(enabled = true) {
);
}
+function codeEnvironmentStatusOptions(id: string, enabled: boolean) {
+ return {
+ queryKey: DynamicQueryKeys.codeEnvironmentStatus(id),
+ queryFn: (): Promise<TCodeEnvironmentStatusResponse> =>
+ dataService.getCodeEnvironmentStatus(id),
+ enabled: enabled && id.length > 0,
+ staleTime: 10_000,
+ refetchInterval: 10_000,
+ refetchIntervalInBackground: false,
+ retry: retryTransientQuery,
+ };
+}
+
export function useCodeEnvironmentStatusQuery(id: string, enabled = true) {
- return useQuery<TCodeEnvironmentStatusResponse>(
- DynamicQueryKeys.codeEnvironmentStatus(id),
- () => dataService.getCodeEnvironmentStatus(id),
- {
- enabled: enabled && id.length > 0,
- refetchInterval: 10_000,
- refetchIntervalInBackground: false,
- retry: false,
- },
- );
+ return useQuery(codeEnvironmentStatusOptions(id, enabled));
}
export function useCodeEnvironmentStatusQueries(ids: string[], enabled = true) {
- return useQueries({
- queries: ids.map((id) => ({
- queryKey: DynamicQueryKeys.codeEnvironmentStatus(id),
- queryFn: () => dataService.getCodeEnvironmentStatus(id),
- enabled: enabled && id.length > 0,
- refetchInterval: 10_000,
- refetchIntervalInBackground: false,
- retry: false,
- })),
- });
+ return useQueries({ queries: ids.map((id) => codeEnvironmentStatusOptions(id, enabled)) });
+}
+
+/** Refresh discovery, not the conversation draft or expanded agent editor records. */
+const isWorkspaceDiscovery: NonNullable<QueryFilters['predicate']> = ({ queryKey }) =>
+ queryKey[0] === QueryKeys.endpoints ||
+ queryKey[0] === QueryKeys.agents ||
+ queryKey[0] === QueryKeys.codeEnvironments ||
+ (queryKey[0] === QueryKeys.agent && queryKey.length === 2);
+
+export function useCodeWorkspaceRefresh() {
+ const queryClient = useQueryClient();
+ const isRefreshing = useIsFetching({ predicate: isWorkspaceDiscovery }) > 0;
+ return {
+ isRefreshing,
+ refresh: () => queryClient.invalidateQueries({ predicate: isWorkspaceDiscovery }),
+ };
}
export function usePairCodeEnvironmentMutation() {
diff --git a/client/src/data-provider/__tests__/workspaceFreshness.spec.tsx b/client/src/data-provider/__tests__/workspaceFreshness.spec.tsx
new file mode 100644
index 0000000000..a59af1dabc
--- /dev/null
+++ b/client/src/data-provider/__tests__/workspaceFreshness.spec.tsx
@@ -0,0 +1,220 @@
+import { createElement } from 'react';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider, focusManager, useQueries } from '@tanstack/react-query';
+import {
+ dataService,
+ DynamicQueryKeys,
+ EModelEndpoint,
+ PermissionBits,
+ QueryKeys,
+} from 'librechat-data-provider';
+import type {
+ Agent,
+ AgentListResponse,
+ TCodeEnvironmentStatusResponse,
+} from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import {
+ useCodeWorkspaceRefresh,
+ useCodeEnvironmentStatusQueries,
+ useCodeEnvironmentStatusQuery,
+} from '../CodeEnvironments';
+import { useGetAgentByIdQuery, useListAgentsQuery } from '../Agents/queries';
+
+jest.mock('librechat-data-provider', () => {
+ const actual =
+ jest.requireActual<typeof import('librechat-data-provider')>('librechat-data-provider');
+ return { ...actual, dataService: { ...actual.dataService } };
+});
+
+const ready: TCodeEnvironmentStatusResponse = {
+ environmentId: 'vm',
+ status: 'ready',
+ workspaces: [{ id: 'project' }],
+};
+const agent = {
+ id: 'agent_primary',
+ code_environment_id: 'vm',
+ code_workspace_id: 'project',
+} as Agent;
+const agentList = { object: 'list', data: [agent], has_more: false } as AgentListResponse;
+
+function setup() {
+ const client = new QueryClient({
+ defaultOptions: { queries: { retryDelay: 0, cacheTime: Infinity } },
+ });
+ client.setQueryData([QueryKeys.endpoints], { [EModelEndpoint.agents]: {} });
+ const wrapper = ({ children }: { children: ReactNode }) =>
+ createElement(QueryClientProvider, { client }, children);
+ return { client, wrapper };
+}
+
+describe('workspace query lifecycle', () => {
+ afterEach(() => focusManager.setFocused(undefined));
+
+ it.each(['single', 'multiple'] as const)(
+ 'retries a transient %s status request without a reload',
+ async (kind) => {
+ const request = jest
+ .spyOn(dataService, 'getCodeEnvironmentStatus')
+ .mockRejectedValueOnce({ status: 503 })
+ .mockResolvedValue(ready);
+ const { client, wrapper } = setup();
+ const { result, unmount } = renderHook(
+ () =>
+ kind === 'single'
+ ? useCodeEnvironmentStatusQuery('vm')
+ : useCodeEnvironmentStatusQueries(['vm'])[0],
+ { wrapper },
+ );
+ await waitFor(() => expect(result.current.data).toEqual(ready));
+ expect(request).toHaveBeenCalledTimes(2);
+ unmount();
+ client.clear();
+ },
+ );
+
+ it.each([401, 403, 404, 429])('does not retry status HTTP %s', async (status) => {
+ const request = jest
+ .spyOn(dataService, 'getCodeEnvironmentStatus')
+ .mockRejectedValue({ status });
+ const { client, wrapper } = setup();
+ const { result, unmount } = renderHook(() => useCodeEnvironmentStatusQuery('vm'), { wrapper });
+ await waitFor(() => expect(result.current.isError).toBe(true));
+ expect(request).toHaveBeenCalledTimes(1);
+ unmount();
+ client.clear();
+ });
+
+ it('bounds transient retries instead of fetching indefinitely', async () => {
+ const request = jest
+ .spyOn(dataService, 'getCodeEnvironmentStatus')
+ .mockRejectedValue({ status: 503 });
+ const { client, wrapper } = setup();
+ const { result, unmount } = renderHook(() => useCodeEnvironmentStatusQuery('vm'), { wrapper });
+ await waitFor(() => expect(result.current.isError).toBe(true));
+ expect(request).toHaveBeenCalledTimes(3);
+ unmount();
+ client.clear();
+ });
+
+ it('refreshes discovery but not saved conversation or expanded editor snapshots', async () => {
+ const { client, wrapper } = setup();
+ const keys = [
+ [QueryKeys.endpoints],
+ [QueryKeys.agents],
+ [QueryKeys.agent, agent.id],
+ DynamicQueryKeys.codeEnvironmentStatus('vm'),
+ [QueryKeys.agent, agent.id, 'expanded'],
+ [QueryKeys.conversation, 'saved-chat'],
+ ];
+ const requests = keys.map(() => jest.fn().mockResolvedValue({ loaded: true }));
+ const { result, unmount } = renderHook(
+ () => {
+ useQueries({
+ queries: keys.map((queryKey, i) => ({
+ queryKey,
+ queryFn: requests[i],
+ staleTime: Infinity,
+ })),
+ });
+ return useCodeWorkspaceRefresh();
+ },
+ { wrapper },
+ );
+ await waitFor(() => expect(result.current.isRefreshing).toBe(false));
+ const before = requests.map((request) => request.mock.calls.length);
+ await act(async () => {
+ await result.current.refresh();
+ });
+ requests.forEach((request, i) => {
+ expect(request).toHaveBeenCalledTimes(before[i] + (i < 4 ? 1 : 0));
+ });
+ unmount();
+ client.clear();
+ });
+
+ it('shares a fresh status between composer, submit hook and settings observers', async () => {
+ const request = jest.spyOn(dataService, 'getCodeEnvironmentStatus').mockResolvedValue(ready);
+ const { client, wrapper } = setup();
+ const first = renderHook(() => useCodeEnvironmentStatusQuery('vm'), { wrapper });
+ await waitFor(() => expect(first.result.current.isSuccess).toBe(true));
+ const second = renderHook(() => useCodeEnvironmentStatusQueries(['vm']), { wrapper });
+ await act(async () => {});
+ expect(second.result.current[0].data).toEqual(ready);
+ expect(request).toHaveBeenCalledTimes(1);
+ first.unmount();
+ second.unmount();
+ client.clear();
+ });
+
+ it('revalidates stale agent defaults on mount and focus', async () => {
+ const request = jest.spyOn(dataService, 'getAgentById').mockResolvedValue(agent);
+ const { client, wrapper } = setup();
+ client.setQueryData(
+ [QueryKeys.agent, agent.id],
+ { ...agent, code_workspace_id: 'old' },
+ { updatedAt: 1 },
+ );
+ const { result, unmount } = renderHook(() => useGetAgentByIdQuery(agent.id), { wrapper });
+ await waitFor(() => expect(result.current.data?.code_workspace_id).toBe('project'));
+ act(() => {
+ client.setQueryData(
+ [QueryKeys.agent, agent.id],
+ { ...agent, code_workspace_id: 'old' },
+ { updatedAt: 1 },
+ );
+ focusManager.setFocused(false);
+ focusManager.setFocused(true);
+ });
+ await waitFor(() => expect(request).toHaveBeenCalledTimes(2));
+ unmount();
+ client.clear();
+ });
+
+ it('starts agent discovery from cached endpoint configuration without Recoil or a duplicate request', async () => {
+ const request = jest.spyOn(dataService, 'listAgents').mockResolvedValue(agentList);
+ const getEndpoints = jest.spyOn(dataService, 'getAIEndpoints');
+ const { client, wrapper } = setup();
+ client.removeQueries([QueryKeys.endpoints]);
+ const { result, unmount } = renderHook(() => useListAgentsQuery(), { wrapper });
+ expect(request).not.toHaveBeenCalled();
+ act(() => {
+ client.setQueryData([QueryKeys.endpoints], { [EModelEndpoint.agents]: {} });
+ });
+ await waitFor(() => expect(result.current.data?.data).toEqual([agent]));
+ expect(request).toHaveBeenCalledTimes(1);
+ expect(getEndpoints).not.toHaveBeenCalled();
+ unmount();
+ client.clear();
+ });
+
+ it('revalidates stale reachable-agent metadata on mount', async () => {
+ const request = jest.spyOn(dataService, 'listAgents').mockResolvedValue(agentList);
+ const { client, wrapper } = setup();
+ const params = { requiredPermission: PermissionBits.VIEW, limit: 100 };
+ client.setQueryData([QueryKeys.agents, params], { ...agentList, data: [] }, { updatedAt: 1 });
+ const { result, unmount } = renderHook(() => useListAgentsQuery(params), { wrapper });
+ await waitFor(() => expect(result.current.data?.data).toEqual([agent]));
+ expect(request).toHaveBeenCalledTimes(1);
+ unmount();
+ client.clear();
+ });
+
+ it('retains a previous status while a background request retries', async () => {
+ const request = jest
+ .spyOn(dataService, 'getCodeEnvironmentStatus')
+ .mockRejectedValueOnce(new Error('Network interrupted'))
+ .mockResolvedValue(ready);
+ const { client, wrapper } = setup();
+ client.setQueryData(DynamicQueryKeys.codeEnvironmentStatus('vm'), ready, { updatedAt: 1 });
+ const { result, unmount } = renderHook(() => useCodeEnvironmentStatusQuery('vm'), { wrapper });
+ expect(result.current.data).toEqual(ready);
+ expect(result.current.isFetching).toBe(true);
+ await waitFor(() => expect(request).toHaveBeenCalledTimes(2));
+ await waitFor(() => expect(result.current.isFetching).toBe(false));
+ expect(result.current.isSuccess).toBe(true);
+ unmount();
+ client.clear();
+ });
+});
diff --git a/client/src/data-provider/retry.ts b/client/src/data-provider/retry.ts
new file mode 100644
index 0000000000..cc7e2657e9
--- /dev/null
+++ b/client/src/data-provider/retry.ts
@@ -0,0 +1,7 @@
+import { getResponseStatus } from '~/utils/errors';
+
+/** Retry transport and server failures, never an authorization or resource decision. */
+export function retryTransientQuery(failureCount: number, error: unknown): boolean {
+ const status = getResponseStatus(error);
+ return failureCount < 2 && (status == null || status >= 500);
+}
diff --git a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx
index bc63cbfdcf..c2a98c1d12 100644
--- a/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx
+++ b/client/src/hooks/Agents/__tests__/useCodeWorkspace.test.tsx
@@ -99,6 +99,14 @@ describe('useCodeWorkspace', () => {
},
);
+ it('reports unavailable when a ready worker advertises no workspaces', () => {
+ mockStatus()[0].data.workspaces = [];
+ const { result } = renderHook(() => useCodeWorkspace(conversation()));
+ expect(result.current.state).toBe('unavailable');
+ expect(result.current.canSubmit).toBe(true);
+ expect(result.current.resolveSubmission(undefined, 'attached')).toBeUndefined();
+ });
+
it('selects one unambiguous initial workspace', () => {
const { result } = renderHook(() => useCodeWorkspace(conversation()));
diff --git a/client/src/hooks/Agents/__tests__/workspaceLifecycle.spec.tsx b/client/src/hooks/Agents/__tests__/workspaceLifecycle.spec.tsx
new file mode 100644
index 0000000000..5f4bf838d5
--- /dev/null
+++ b/client/src/hooks/Agents/__tests__/workspaceLifecycle.spec.tsx
@@ -0,0 +1,124 @@
+import { createElement } from 'react';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { dataService, DynamicQueryKeys } from 'librechat-data-provider';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TCodeEnvironmentStatusResponse, TConversation } from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import useCodeWorkspace from '../useCodeWorkspace';
+
+jest.mock('librechat-data-provider', () => {
+ const actual =
+ jest.requireActual<typeof import('librechat-data-provider')>('librechat-data-provider');
+ return { ...actual, dataService: { ...actual.dataService } };
+});
+jest.mock('~/data-provider', () => ({
+ useCodeEnvironmentStatusQueries: jest.requireActual('~/data-provider/CodeEnvironments')
+ .useCodeEnvironmentStatusQueries,
+ useGetStartupConfig: () => ({ data: { codeEnvironmentDecisionVersion: 1 } }),
+}));
+jest.mock('../workspacePreferences', () => ({
+ useWorkspacePreferences: () => ({ get: () => undefined, remember: jest.fn() }),
+}));
+jest.mock('~/hooks/Roles/useHasAccess', () => () => true);
+jest.mock('~/Providers', () => ({ useAgentsMapContext: () => ({}) }));
+jest.mock('../useAgentToolPermissions', () => (id: string) => ({
+ agent: id
+ ? { id, stateful_code_sessions: true, code_environment_id: 'vm', tools: ['execute_code'] }
+ : undefined,
+}));
+jest.mock('../useGetAgentsConfig', () => () => ({
+ agentsConfig: {
+ capabilities: ['execute_code', 'stateful_code_sessions'],
+ statefulCodeSessions: { environments: [{ id: 'vm', name: 'VM', type: 'attached' }] },
+ },
+}));
+
+const selected = { environmentId: 'vm', workspaceId: 'project' };
+const ready: TCodeEnvironmentStatusResponse = {
+ environmentId: 'vm',
+ status: 'ready',
+ workspaces: [{ id: 'project' }],
+};
+const saved = {
+ conversationId: 'saved-chat',
+ endpoint: 'agents',
+ agent_id: 'agent_primary',
+ codeEnvironmentMode: 'attached',
+ codeWorkspaces: [selected],
+} as TConversation;
+
+function setup(conversation: TConversation = saved) {
+ const client = new QueryClient({
+ defaultOptions: { queries: { retryDelay: 0, cacheTime: Infinity } },
+ });
+ const wrapper = ({ children }: { children: ReactNode }) =>
+ createElement(QueryClientProvider, { client }, children);
+ return { client, ...renderHook(() => useCodeWorkspace(conversation), { wrapper }) };
+}
+
+describe('workspace status recovery', () => {
+ it('restores the saved selection when a delayed initial status request resolves', async () => {
+ let resolve = (_status: TCodeEnvironmentStatusResponse) => {};
+ jest.spyOn(dataService, 'getCodeEnvironmentStatus').mockReturnValue(
+ new Promise((done) => {
+ resolve = done;
+ }),
+ );
+ const { result, client, unmount } = setup();
+ expect(result.current.state).toBe('loading');
+ expect(result.current.canSubmit).toBe(false);
+ await act(async () => resolve(ready));
+ await waitFor(() => expect(result.current.state).toBe('ready'));
+ expect(result.current.selections).toEqual([selected]);
+ expect(result.current.locked).toBe(true);
+ expect(result.current.resolveSubmission(saved.codeWorkspaces, 'attached')).toEqual({
+ codeEnvironmentMode: 'attached',
+ codeWorkspaces: [selected],
+ });
+ unmount();
+ client.clear();
+ });
+
+ it('recovers an exhausted background failure without replacing the saved selection', async () => {
+ const request = jest.spyOn(dataService, 'getCodeEnvironmentStatus').mockResolvedValue(ready);
+ const { result, client, unmount } = setup();
+ await waitFor(() => expect(result.current.state).toBe('ready'));
+ request.mockRejectedValue(new Error('offline'));
+ await act(async () => {
+ await client.invalidateQueries(DynamicQueryKeys.codeEnvironmentStatus('vm'));
+ });
+ await waitFor(() => expect(result.current.state).toBe('unavailable'));
+ expect(result.current.canSubmit).toBe(false);
+ expect(result.current.environments[0].selected).toEqual(selected);
+ request.mockResolvedValue(ready);
+ await act(async () => {
+ await client.invalidateQueries(DynamicQueryKeys.codeEnvironmentStatus('vm'));
+ });
+ await waitFor(() => expect(result.current.state).toBe('ready'));
+ expect(result.current.selections).toEqual([selected]);
+ unmount();
+ client.clear();
+ });
+
+ it('recovers an empty first response into the sole workspace without a reload', async () => {
+ const request = jest
+ .spyOn(dataService, 'getCodeEnvironmentStatus')
+ .mockResolvedValue({ ...ready, workspaces: [] });
+ const { result, client, unmount } = setup({
+ ...saved,
+ conversationId: 'new',
+ codeEnvironmentMode: undefined,
+ codeWorkspaces: undefined,
+ });
+ await waitFor(() => expect(result.current.state).toBe('unavailable'));
+ expect(result.current.resolveSubmission(undefined, 'attached')).toBeUndefined();
+ request.mockResolvedValue(ready);
+ await act(async () => {
+ await client.invalidateQueries(DynamicQueryKeys.codeEnvironmentStatus('vm'));
+ });
+ await waitFor(() => expect(result.current.state).toBe('ready'));
+ expect(result.current.selections).toEqual([selected]);
+ unmount();
+ client.clear();
+ });
+});
diff --git a/client/src/hooks/Agents/useCodeWorkspace.ts b/client/src/hooks/Agents/useCodeWorkspace.ts
index 07a4d1f4ae..67c7c8f5a3 100644
--- a/client/src/hooks/Agents/useCodeWorkspace.ts
+++ b/client/src/hooks/Agents/useCodeWorkspace.ts
@@ -308,6 +308,7 @@ export default function useCodeWorkspace(
} else if (status.data.workspaces == null) state = 'unsupported';
else if (selected != null) state = 'ready';
else if (stored != null) state = 'missing';
+ else if (workspaces.length === 0) state = 'unavailable';
return { environment, state, workspaces, selected };
});
diff --git a/client/src/routes/ChatRoute.tsx b/client/src/routes/ChatRoute.tsx
index c0329ea788..27e9f437a6 100644
--- a/client/src/routes/ChatRoute.tsx
+++ b/client/src/routes/ChatRoute.tsx
@@ -142,8 +142,8 @@ export default function ChatRoute() {
const assistantListMap = useAssistantListMap();
/** The map comes from Root's shared context (one mapping pass app-wide); the
* select-less observer only tracks settle state. Only a loaded list may
- * invalidate a stored agent pick: on a transient catalog failure (retries are
- * disabled) the map stays unknown, the pick stays trusted, and the gate below
+ * invalidate a stored agent pick: on a transient catalog failure after retries,
+ * the map stays unknown, the pick stays trusted, and the gate below
* releases so the landing never hangs on the error. */
const agentsMap: TAgentsMap | undefined = useAgentsMapContext();
const agentsQuery = useListAgentsQuery(