Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import React, { useEffect, useState } from 'react';
import userEvent from '@testing-library/user-event';
import { QueryKeys, dataService } from 'librechat-data-provider';
import { render, screen, waitFor } from '@testing-library/react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import type { TStartupConfig, TTraceViewerConfig } from 'librechat-data-provider';
import { IsolatedAtomStore } from 'test/harness';
import useTraceControl from '../useTraceControl';
import TraceSurface from '../Surface';
import TraceButton from '../Button';
jest.mock('librechat-data-provider', () => {
const actual =
jest.requireActual<typeof import('librechat-data-provider')>('librechat-data-provider');
return { ...actual, dataService: { ...actual.dataService } };
});
type MockStartupConfig = Omit<Partial<TStartupConfig>, 'interface'> & {
interface?: Partial<NonNullable<TStartupConfig['interface']>>;
};
let mockStartupConfig: MockStartupConfig = {};
jest.mock('~/data-provider/Endpoints/queries', () => ({
useGetStartupConfig: () => ({ data: mockStartupConfig }),
}));
jest.mock('~/hooks', () => ({
useLocalize: () => (key: string) => key,
}));
jest.mock('@librechat/client', () => {
const actual = jest.requireActual('@librechat/client');
return {
...actual,
TooltipAnchor: ({ render: node }: { render: React.ReactNode }) => node,
};
});
const mounts = { count: 0 };
function Chat() {
const [draft, setDraft] = useState('');
useEffect(() => {
mounts.count++;
}, []);
return <input aria-label="composer" value={draft} onChange={(e) => setDraft(e.target.value)} />;
}
function Host({
conversationId,
traceViewer = { enabled: true },
isSubmitting = false,
enabled = true,
}: {
conversationId: string;
traceViewer?: TTraceViewerConfig;
isSubmitting?: boolean;
enabled?: boolean;
}) {
const trace = useTraceControl({ conversationId, traceViewer, isSubmitting, enabled });
return (
<TraceSurface conversationId={conversationId}>
<div data-testid="chat-pane">
{trace.show && <TraceButton onClick={trace.open} />}
<Chat />
</div>
</TraceSurface>
);
}
function renderHost(props: React.ComponentProps<typeof Host>) {
const client = new QueryClient({
defaultOptions: { queries: { retry: false } },
logger: { log: () => undefined, warn: () => undefined, error: () => undefined },
});
const wrap = (next: React.ComponentProps<typeof Host>) => (
<QueryClientProvider client={client}>
<IsolatedAtomStore>
<Host {...next} />
</IsolatedAtomStore>
</QueryClientProvider>
);
const utils = render(wrap(props));
return {
...utils,
client,
rerenderHost: (next: React.ComponentProps<typeof Host>) => utils.rerender(wrap(next)),
};
}
const traceButton = () => screen.queryByTestId('header-trace-button');
const chatPane = () => screen.getByTestId('chat-pane').parentElement as HTMLElement;
describe('trace entry point and surface', () => {
let availability: jest.SpiedFunction<typeof dataService.getConversationTraceAvailability>;
beforeEach(() => {
mounts.count = 0;
mockStartupConfig = { interface: { traceViewer: { enabled: true } } };
availability = jest
.spyOn(dataService, 'getConversationTraceAvailability')
.mockResolvedValue({ available: true });
jest.spyOn(dataService, 'getConversationTraceRecords').mockResolvedValue({ records: [] });
});
it('shows the control only for an available trace on an enabled deployment', async () => {
renderHost({ conversationId: 'convo-1' });
expect(await screen.findByTestId('header-trace-button')).toBeInTheDocument();
expect(availability).toHaveBeenCalledWith('convo-1');
});
it.each([
['the viewer is disabled', { conversationId: 'convo-1', traceViewer: { enabled: false } }],
['the chat is new', { conversationId: 'new' }],
['the host opts out', { conversationId: 'convo-1', enabled: false }],
])('never asks for availability when %s', async (_label, props) => {
renderHost(props);
await waitFor(() => expect(traceButton()).not.toBeInTheDocument());
expect(availability).not.toHaveBeenCalled();
});
it('hides the control for a conversation with no sampled trace', async () => {
availability.mockResolvedValue({ available: false });
renderHost({ conversationId: 'convo-1' });
await waitFor(() => expect(availability).toHaveBeenCalled());
expect(traceButton()).not.toBeInTheDocument();
});
it('re-reads availability once a running response settles', async () => {
availability.mockResolvedValue({ available: false });
const { rerenderHost } = renderHost({ conversationId: 'convo-1' });
await waitFor(() => expect(availability).toHaveBeenCalledTimes(1));
rerenderHost({ conversationId: 'convo-1', isSubmitting: true });
availability.mockResolvedValue({ available: true });
expect(availability).toHaveBeenCalledTimes(1);
rerenderHost({ conversationId: 'convo-1', isSubmitting: false });
expect(await screen.findByTestId('header-trace-button')).toBeInTheDocument();
expect(availability).toHaveBeenCalledTimes(2);
});
it('reads the trace again after a response settles instead of reusing cached pages', async () => {
const list = jest
.spyOn(dataService, 'getConversationTraceRecords')
.mockResolvedValue({ records: [] });
const { rerenderHost } = renderHost({ conversationId: 'convo-1' });
const close = () => userEvent.click(screen.getByRole('button', { name: 'com_ui_trace_close' }));
await userEvent.click(await screen.findByTestId('header-trace-button'));
await waitFor(() => expect(list).toHaveBeenCalledTimes(1));
await close();
await userEvent.click(screen.getByTestId('header-trace-button'));
await close();
expect(list).toHaveBeenCalledTimes(1);
rerenderHost({ conversationId: 'convo-1', isSubmitting: true });
rerenderHost({ conversationId: 'convo-1', isSubmitting: false });
await userEvent.click(await screen.findByTestId('header-trace-button'));
await waitFor(() => expect(list).toHaveBeenCalledTimes(2));
});
it('marks cached record details stale too when a response settles', async () => {
const { rerenderHost, client } = renderHost({ conversationId: 'convo-1' });
const detailKey = [QueryKeys.conversationTraceRecord, 'convo-1', 'obs-1', null];
client.setQueryData(detailKey, { record: {}, contentAvailable: true });
rerenderHost({ conversationId: 'convo-1', isSubmitting: true });
rerenderHost({ conversationId: 'convo-1', isSubmitting: false });
await waitFor(() => expect(client.getQueryState(detailKey)?.isInvalidated).toBe(true));
});
it('retries a transient availability failure instead of hiding the control for good', async () => {
availability
.mockRejectedValueOnce(
Object.assign(new Error('unavailable'), {
isAxiosError: true,
response: { status: 503 },
}),
)
.mockResolvedValue({ available: true });
const client = new QueryClient({
defaultOptions: { queries: { retryDelay: 1 } },
logger: { log: () => undefined, warn: () => undefined, error: () => undefined },
});
render(
<QueryClientProvider client={client}>
<IsolatedAtomStore>
<Host conversationId="convo-1" />
</IsolatedAtomStore>
</QueryClientProvider>,
);
expect(await screen.findByTestId('header-trace-button')).toBeInTheDocument();
expect(availability).toHaveBeenCalledTimes(2);
});
it('checks availability again when the server cannot decide yet', async () => {
availability
.mockResolvedValueOnce({ available: false, retryAfterMs: 20 })
.mockResolvedValue({ available: true });
renderHost({ conversationId: 'convo-1' });
expect(await screen.findByTestId('header-trace-button')).toBeInTheDocument();
expect(availability).toHaveBeenCalledTimes(2);
});
it('covers the chat without unmounting it and restores it with focus on close', async () => {
renderHost({ conversationId: 'convo-1' });
await userEvent.type(screen.getByLabelText('composer'), 'unsent draft');
const button = await screen.findByTestId('header-trace-button');
await userEvent.click(button);
expect(await screen.findByTestId('trace-viewer')).toBeInTheDocument();
expect(chatPane()).toHaveAttribute('inert');
expect(chatPane()).toHaveClass('isolate');
expect(screen.getByRole('button', { name: 'com_ui_trace_close' })).toHaveFocus();
await userEvent.click(screen.getByRole('button', { name: 'com_ui_trace_close' }));
expect(screen.queryByTestId('trace-viewer')).not.toBeInTheDocument();
expect(chatPane()).not.toHaveAttribute('inert');
expect(screen.getByLabelText('composer')).toHaveValue('unsent draft');
expect(mounts.count).toBe(1);
expect(screen.getByTestId('header-trace-button')).toHaveFocus();
});
it('leaves focus where a navigation put it when that navigation closes the trace', async () => {
const outside = document.createElement('button');
outside.textContent = 'sidebar link';
document.body.appendChild(outside);
const { rerenderHost, client } = renderHost({ conversationId: 'convo-1' });
/** The next chat also has a trace, so the opener stays mounted and could steal focus back. */
client.setQueryData([QueryKeys.conversationTraceAvailability, 'convo-2'], { available: true });
await userEvent.click(await screen.findByTestId('header-trace-button'));
expect(await screen.findByTestId('trace-viewer')).toBeInTheDocument();
outside.focus();
rerenderHost({ conversationId: 'convo-2' });
expect(screen.queryByTestId('trace-viewer')).not.toBeInTheDocument();
expect(outside).toHaveFocus();
outside.remove();
});
it('does not carry an open trace into another conversation', async () => {
const { rerenderHost } = renderHost({ conversationId: 'convo-1' });
await userEvent.click(await screen.findByTestId('header-trace-button'));
expect(await screen.findByTestId('trace-viewer')).toBeInTheDocument();
rerenderHost({ conversationId: 'convo-2' });
expect(screen.queryByTestId('trace-viewer')).not.toBeInTheDocument();
rerenderHost({ conversationId: 'convo-1' });
expect(screen.queryByTestId('trace-viewer')).not.toBeInTheDocument();
});
});