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

22.6 KB
Raw Blame
import { createElement } from 'react';
import { MemoryRouter } from 'react-router-dom';
import { act, renderHook, waitFor } from '@testing-library/react';
import { Constants, QueryKeys, dataService } from 'librechat-data-provider';
import { QueryClient, focusManager, QueryClientProvider } from '@tanstack/react-query';
import type { TMessage } from 'librechat-data-provider';
import type { ReactNode } from 'react';
import {
  getStableMessages,
  shouldPreserveMessagesOnNotFound,
  useSubagentAttachmentCallsQueries,
  useGetMessagesByConvoId,
} from '../queries';
import { clearMessagesCache, logger } from '~/utils';

jest.mock('librechat-data-provider', () => {
  const actual = jest.requireActual('librechat-data-provider');
  return {
    ...actual,
    dataService: {
      ...actual.dataService,
      getMessagesByConvoId: jest.fn(),
      getSubagentAttachmentCalls: jest.fn(),
    },
  };
});

jest.mock('~/utils', () => {
  const actual = jest.requireActual('~/utils');
  return {
    ...actual,
    logger: {
      ...actual.logger,
      warn: jest.fn(),
    },
  };
});

const message = (overrides: Partial<TMessage>): TMessage =>
  ({
    messageId: 'message-id',
    conversationId: 'convo-id',
    parentMessageId: '00000000-0000-0000-0000-000000000000',
    text: '',
    sender: 'User',
    isCreatedByUser: true,
    createdAt: '2026-05-21T12:00:00.000Z',
    updatedAt: '2026-05-21T12:00:00.000Z',
    ...overrides,
  }) as TMessage;

function createWrapper(queryClient: QueryClient, initialEntry: string) {
  return function Wrapper({ children }: { children: ReactNode }) {
    return createElement(
      QueryClientProvider,
      { client: queryClient },
      createElement(MemoryRouter, { initialEntries: [initialEntry] }, children),
    );
  };
}

function deferred<T>() {
  let resolve!: (value: T) => void;
  let reject!: (reason?: unknown) => void;
  const promise = new Promise<T>((res, rej) => {
    resolve = res;
    reject = rej;
  });
  return { promise, resolve, reject };
}

afterEach(() => {
  jest.clearAllMocks();
});

describe('getStableMessages', () => {
  it('keeps cache when an empty result races with unhydrated stream messages', () => {
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({ messageId: 'user-2', createdAt: undefined, updatedAt: undefined }),
      message({
        messageId: 'user-2_',
        parentMessageId: 'user-2',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];

    const result = getStableMessages({
      pathname: '/c/convo-id',
      result: [],
      currentMessages,
      isStreaming: true,
    });

    expect(result).toBe(currentMessages);
  });

  it('keeps cache when a prefix result races with a pending assistant tail', () => {
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({ messageId: 'user-2', createdAt: undefined, updatedAt: undefined }),
      message({
        messageId: 'user-2_',
        parentMessageId: 'user-2',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];

    const result = getStableMessages({
      pathname: '/c/convo-id',
      result: [currentMessages[0]],
      currentMessages,
      isStreaming: true,
    });

    expect(result).toBe(currentMessages);
  });

  it('accepts a shorter result when the app is not streaming', () => {
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({
        messageId: 'user-2_',
        parentMessageId: 'user-2',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];
    const serverMessages = [currentMessages[0]];

    const result = getStableMessages({
      pathname: '/c/convo-id',
      result: serverMessages,
      currentMessages,
      isStreaming: false,
    });

    expect(result).toBe(serverMessages);
  });

  it('accepts a shorter result when an unhydrated message is not the assistant tail', () => {
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({ messageId: 'old-unhydrated', createdAt: undefined, updatedAt: undefined }),
      message({ messageId: 'persisted-3' }),
    ];
    const serverMessages = [currentMessages[0]];

    const result = getStableMessages({
      pathname: '/c/convo-id',
      result: serverMessages,
      currentMessages,
      isStreaming: true,
    });

    expect(result).toBe(serverMessages);
  });

  it('accepts a shorter result when the server result is not a prefix of cache', () => {
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({ messageId: 'persisted-2' }),
      message({
        messageId: 'persisted-2_',
        parentMessageId: 'persisted-2',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];
    const serverMessages = [message({ messageId: 'different-1' })];

    const result = getStableMessages({
      pathname: '/c/convo-id',
      result: serverMessages,
      currentMessages,
      isStreaming: true,
    });

    expect(result).toBe(serverMessages);
  });

  it('accepts a shorter result when an unhydrated assistant tail has no parent turn', () => {
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({
        messageId: 'orphaned-response_',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];
    const serverMessages = [currentMessages[0]];

    const result = getStableMessages({
      pathname: '/c/convo-id',
      result: serverMessages,
      currentMessages,
      isStreaming: true,
    });

    expect(result).toBe(serverMessages);
  });

  it('accepts fewer persisted messages when the cache is fully hydrated', () => {
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({ messageId: 'persisted-2' }),
      message({ messageId: 'persisted-3' }),
    ];
    const serverMessages = [currentMessages[0], currentMessages[1]];

    const result = getStableMessages({
      pathname: '/c/convo-id',
      result: serverMessages,
      currentMessages,
      isStreaming: true,
    });

    expect(result).toBe(serverMessages);
  });

  it('does not preserve cache on the new conversation route', () => {
    const currentMessages = [message({ messageId: 'user-1', createdAt: undefined })];

    const result = getStableMessages({
      pathname: '/c/new',
      result: [],
      currentMessages,
      isStreaming: true,
    });

    expect(result).toEqual([]);
  });
});

describe('shouldPreserveMessagesOnNotFound', () => {
  it('keeps cache when a transient 404 races with a pending assistant tail', () => {
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({ messageId: 'user-2' }),
      message({
        messageId: 'user-2_',
        parentMessageId: 'user-2',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];

    expect(
      shouldPreserveMessagesOnNotFound({
        pathname: '/c/convo-id',
        currentMessages,
        isStreaming: true,
      }),
    ).toBe(true);
  });

  it('does not preserve cache when no stream or active job is live', () => {
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({ messageId: 'user-2' }),
      message({
        messageId: 'user-2_',
        parentMessageId: 'user-2',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];

    expect(
      shouldPreserveMessagesOnNotFound({
        pathname: '/c/convo-id',
        currentMessages,
        isStreaming: false,
      }),
    ).toBe(false);
  });

  it('does not preserve cache on the new conversation route', () => {
    const currentMessages = [
      message({ messageId: 'user-1' }),
      message({
        messageId: 'user-1_',
        parentMessageId: 'user-1',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];

    expect(
      shouldPreserveMessagesOnNotFound({
        pathname: '/c/new',
        currentMessages,
        isStreaming: true,
      }),
    ).toBe(false);
  });

  it('does not preserve cache when there is no pending assistant tail', () => {
    const currentMessages = [message({ messageId: 'persisted-1' })];

    expect(
      shouldPreserveMessagesOnNotFound({
        pathname: '/c/convo-id',
        currentMessages,
        isStreaming: true,
      }),
    ).toBe(false);
  });
});

describe('useGetMessagesByConvoId', () => {
  it('observes optimistic new-chat messages without requesting them from the API', async () => {
    const queryClient = new QueryClient({
      defaultOptions: { queries: { retry: false } },
    });
    const optimisticMessages = [message({ conversationId: Constants.NEW_CONVO as string })];

    const { result, unmount } = renderHook(() => useGetMessagesByConvoId(Constants.NEW_CONVO), {
      wrapper: createWrapper(queryClient, '/c/new'),
    });

    await waitFor(() => {
      expect(result.current.data).toEqual([]);
    });
    expect(dataService.getMessagesByConvoId).not.toHaveBeenCalled();

    act(() => {
      queryClient.setQueryData([QueryKeys.messages, Constants.NEW_CONVO], optimisticMessages);
    });

    await waitFor(() => {
      expect(result.current.data).toEqual(optimisticMessages);
    });

    await act(async () => {
      await result.current.refetch();
    });
    expect(result.current.data).toEqual(optimisticMessages);
    expect(dataService.getMessagesByConvoId).not.toHaveBeenCalled();

    unmount();
  });

  it('loads server history after a cleared empty cache is removed', async () => {
    const conversationId = 'convo-id';
    const queryClient = new QueryClient({
      defaultOptions: { queries: { retry: false } },
    });
    const serverMessages = [message({ messageId: 'persisted-1' })];
    const mockGetMessagesByConvoId = dataService.getMessagesByConvoId as jest.MockedFunction<
      typeof dataService.getMessagesByConvoId
    >;
    mockGetMessagesByConvoId.mockResolvedValue(serverMessages);
    queryClient.setQueryData([QueryKeys.messages, conversationId], []);

    clearMessagesCache(queryClient, conversationId);
    expect(queryClient.getQueryData([QueryKeys.messages, conversationId])).toBeUndefined();

    const { result, unmount } = renderHook(() => useGetMessagesByConvoId(conversationId), {
      wrapper: createWrapper(queryClient, `/c/${conversationId}`),
    });

    await waitFor(() => {
      expect(result.current.data).toEqual(serverMessages);
    });
    expect(mockGetMessagesByConvoId).toHaveBeenCalledTimes(1);
    expect(mockGetMessagesByConvoId).toHaveBeenCalledWith(conversationId, { toolPreviews: true });

    unmount();
  });

  it('does not discard server history when an empty cache changes during the initial request', async () => {
    const conversationId = 'convo-id';
    const queryClient = new QueryClient({
      defaultOptions: { queries: { retry: false } },
    });
    const request = deferred<TMessage[]>();
    const serverMessages = [message({ messageId: 'persisted-1' })];
    const interveningMessages = [
      message({ messageId: 'intervening-user', createdAt: undefined, updatedAt: undefined }),
    ];
    const mockGetMessagesByConvoId = dataService.getMessagesByConvoId as jest.MockedFunction<
      typeof dataService.getMessagesByConvoId
    >;
    mockGetMessagesByConvoId.mockReturnValue(request.promise);

    const { result, unmount } = renderHook(() => useGetMessagesByConvoId(conversationId), {
      wrapper: createWrapper(queryClient, `/c/${conversationId}`),
    });

    await waitFor(() => {
      expect(mockGetMessagesByConvoId).toHaveBeenCalledWith(conversationId, { toolPreviews: true });
    });

    act(() => {
      queryClient.setQueryData([QueryKeys.messages, conversationId], interveningMessages);
    });

    await act(async () => {
      request.resolve(serverMessages);
      await request.promise;
    });

    await waitFor(() => {
      expect(result.current.data).toEqual(serverMessages);
    });
    expect(queryClient.getQueryData([QueryKeys.messages, conversationId])).toEqual(serverMessages);

    unmount();
  });

  it('keeps a concurrent cache write during a warm refetch', async () => {
    const conversationId = 'convo-id';
    const queryClient = new QueryClient({
      defaultOptions: { queries: { retry: false } },
    });
    const request = deferred<TMessage[]>();
    const cachedMessages = [message({ messageId: 'persisted-1' })];
    const staleServerMessages = [message({ messageId: 'persisted-1', text: 'stale' })];
    const concurrentMessages = [
      ...cachedMessages,
      message({ messageId: 'new-user', createdAt: undefined, updatedAt: undefined }),
    ];
    queryClient.setQueryData([QueryKeys.messages, conversationId], cachedMessages);
    const mockGetMessagesByConvoId = dataService.getMessagesByConvoId as jest.MockedFunction<
      typeof dataService.getMessagesByConvoId
    >;
    mockGetMessagesByConvoId.mockReturnValue(request.promise);

    const { result, unmount } = renderHook(
      () => useGetMessagesByConvoId(conversationId, { enabled: false }),
      { wrapper: createWrapper(queryClient, `/c/${conversationId}`) },
    );

    const refetchPromise = result.current.refetch();

    await waitFor(() => {
      expect(mockGetMessagesByConvoId).toHaveBeenCalledWith(conversationId, { toolPreviews: true });
    });

    act(() => {
      queryClient.setQueryData([QueryKeys.messages, conversationId], concurrentMessages);
    });

    let refetchData: TMessage[] | undefined;
    await act(async () => {
      request.resolve(staleServerMessages);
      refetchData = (await refetchPromise).data;
    });

    expect(refetchData).toEqual(concurrentMessages);
    expect(queryClient.getQueryData([QueryKeys.messages, conversationId])).toEqual(
      concurrentMessages,
    );

    unmount();
  });

  it('applies fresh server data when a warm cache is unchanged during refetch', async () => {
    const conversationId = 'convo-id';
    const queryClient = new QueryClient({
      defaultOptions: { queries: { retry: false } },
    });
    const cachedMessages = [message({ messageId: 'persisted-1', text: 'cached' })];
    const freshServerMessages = [message({ messageId: 'persisted-1', text: 'fresh' })];
    queryClient.setQueryData([QueryKeys.messages, conversationId], cachedMessages);
    const mockGetMessagesByConvoId = dataService.getMessagesByConvoId as jest.MockedFunction<
      typeof dataService.getMessagesByConvoId
    >;
    mockGetMessagesByConvoId.mockResolvedValue(freshServerMessages);

    const { result, unmount } = renderHook(
      () => useGetMessagesByConvoId(conversationId, { enabled: false }),
      { wrapper: createWrapper(queryClient, `/c/${conversationId}`) },
    );

    let refetchData: TMessage[] | undefined;
    await act(async () => {
      refetchData = (await result.current.refetch()).data;
    });

    expect(refetchData).toEqual(freshServerMessages);
    expect(queryClient.getQueryData([QueryKeys.messages, conversationId])).toEqual(
      freshServerMessages,
    );

    unmount();
  });

  it('keeps a concurrent warm cache write when the refetch fails', async () => {
    const conversationId = 'convo-id';
    const queryClient = new QueryClient({
      defaultOptions: { queries: { retry: false } },
    });
    const request = deferred<TMessage[]>();
    const cachedMessages = [message({ messageId: 'persisted-1' })];
    const concurrentMessages = [
      ...cachedMessages,
      message({ messageId: 'new-user', createdAt: undefined, updatedAt: undefined }),
    ];
    queryClient.setQueryData([QueryKeys.messages, conversationId], cachedMessages);
    const mockGetMessagesByConvoId = dataService.getMessagesByConvoId as jest.MockedFunction<
      typeof dataService.getMessagesByConvoId
    >;
    mockGetMessagesByConvoId.mockReturnValue(request.promise);

    const { result, unmount } = renderHook(
      () => useGetMessagesByConvoId(conversationId, { enabled: false }),
      { wrapper: createWrapper(queryClient, `/c/${conversationId}`) },
    );

    const refetchPromise = result.current.refetch();

    await waitFor(() => {
      expect(mockGetMessagesByConvoId).toHaveBeenCalledWith(conversationId, { toolPreviews: true });
    });

    act(() => {
      queryClient.setQueryData([QueryKeys.messages, conversationId], concurrentMessages);
      request.reject({ status: 500 });
    });

    let refetchData: TMessage[] | undefined;
    await act(async () => {
      refetchData = (await refetchPromise).data;
    });

    expect(refetchData).toEqual(concurrentMessages);
    expect(queryClient.getQueryData([QueryKeys.messages, conversationId])).toEqual(
      concurrentMessages,
    );
    expect(result.current.isError).toBe(false);

    unmount();
  });

  it('keeps cache during submitting cleanup when active job cache still marks the stream active', async () => {
    const conversationId = 'convo-id';
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({ messageId: 'user-2', createdAt: undefined, updatedAt: undefined }),
      message({
        messageId: 'user-2_',
        parentMessageId: 'user-2',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];
    const serverMessages = [currentMessages[0]];
    const queryClient = new QueryClient({
      defaultOptions: { queries: { retry: false } },
    });
    queryClient.setQueryData([QueryKeys.messages, conversationId], currentMessages);
    queryClient.setQueryData([QueryKeys.activeJobs], { activeJobIds: [conversationId] });

    const mockGetMessagesByConvoId = dataService.getMessagesByConvoId as jest.MockedFunction<
      typeof dataService.getMessagesByConvoId
    >;
    mockGetMessagesByConvoId.mockResolvedValue(serverMessages);

    const { result, unmount } = renderHook(
      () => useGetMessagesByConvoId(conversationId, undefined, { isStreaming: false }),
      { wrapper: createWrapper(queryClient, `/c/${conversationId}`) },
    );

    await act(async () => {
      await result.current.refetch();
    });

    await waitFor(() => {
      expect(result.current.data).toBe(currentMessages);
    });
    expect(dataService.getMessagesByConvoId).toHaveBeenCalledWith(conversationId, {
      toolPreviews: true,
    });
    expect(queryClient.getQueryData([QueryKeys.messages, conversationId])).toBe(currentMessages);

    unmount();
  });

  it('keeps cache when a transient 404 races with a regenerated pending assistant tail', async () => {
    const conversationId = 'convo-id';
    const currentMessages = [
      message({ messageId: 'persisted-1' }),
      message({
        messageId: 'user-2',
        parentMessageId: 'persisted-1',
      }),
      message({
        messageId: 'user-2_',
        parentMessageId: 'user-2',
        isCreatedByUser: false,
        createdAt: undefined,
        updatedAt: undefined,
      }),
    ];
    const queryClient = new QueryClient({
      defaultOptions: { queries: { retry: false } },
    });
    queryClient.setQueryData([QueryKeys.messages, conversationId], currentMessages);

    const mockGetMessagesByConvoId = dataService.getMessagesByConvoId as jest.MockedFunction<
      typeof dataService.getMessagesByConvoId
    >;
    mockGetMessagesByConvoId.mockRejectedValueOnce({ status: 404 });

    const { result, unmount } = renderHook(
      () => useGetMessagesByConvoId(conversationId, { enabled: false }, { isStreaming: true }),
      { wrapper: createWrapper(queryClient, `/c/${conversationId}`) },
    );

    await act(async () => {
      await result.current.refetch();
    });

    await waitFor(() => {
      expect(result.current.data).toBe(currentMessages);
    });
    expect(dataService.getMessagesByConvoId).toHaveBeenCalledWith(conversationId, {
      toolPreviews: true,
    });
    expect(queryClient.getQueryData([QueryKeys.messages, conversationId])).toBe(currentMessages);
    expect(logger.warn).toHaveBeenCalledWith(
      'messages',
      expect.stringContaining('returned 404 while cache has a pending assistant tail'),
      currentMessages,
    );

    unmount();
  });
});

describe('useSubagentAttachmentCallsQueries', () => {
  afterEach(() => {
    jest.useRealTimers();
    focusManager.setFocused(undefined);
  });

  it('asks again on focus after the read failed, and not once it answered', async () => {
    const queryClient = new QueryClient();
    const answer = { parts: [{ toolCallId: 'subagent', calls: [{ id: 'child' }] }] };
    const params = {
      conversationId: 'convo-id',
      messageId: 'message-id',
      files: [{ toolCallId: 'child' }],
    };
    /** The first read and its three retries fail; the next one succeeds. */
    jest
      .mocked(dataService.getSubagentAttachmentCalls)
      .mockReset()
      .mockRejectedValueOnce(new Error('unavailable'))
      .mockRejectedValueOnce(new Error('unavailable'))
      .mockRejectedValueOnce(new Error('unavailable'))
      .mockRejectedValueOnce(new Error('unavailable'))
      .mockResolvedValue(answer);
    jest.useFakeTimers();

    const { result, unmount } = renderHook(() => useSubagentAttachmentCallsQueries(params, true), {
      wrapper: createWrapper(queryClient, '/c/convo-id'),
    });

    await waitFor(() => expect(result.current[0].isError).toBe(true), { timeout: 20_000 });
    expect(dataService.getSubagentAttachmentCalls).toHaveBeenCalledTimes(4);
    expect(dataService.getSubagentAttachmentCalls).toHaveBeenCalledWith(params);
    act(() => {
      focusManager.setFocused(false);
      focusManager.setFocused(true);
    });
    await waitFor(() => expect(result.current[0].data).toEqual(answer));

    act(() => {
      focusManager.setFocused(false);
      focusManager.setFocused(true);
    });
    expect(dataService.getSubagentAttachmentCalls).toHaveBeenCalledTimes(5);
    unmount();
    queryClient.clear();
    jest.useRealTimers();
  });

  it('asks for more files than one lookup names in bounded batches', async () => {
    const queryClient = new QueryClient();
    jest
      .mocked(dataService.getSubagentAttachmentCalls)
      .mockReset()
      .mockResolvedValue({ parts: [] });
    const files = Array.from({ length: 40 }, (_, i) => ({ toolCallId: `child-${i}` }));

    const { result, unmount } = renderHook(
      () =>
        useSubagentAttachmentCallsQueries(
          { conversationId: 'convo-id', messageId: 'message-id', files },
          true,
        ),
      { wrapper: createWrapper(queryClient, '/c/convo-id') },
    );

    await waitFor(() => expect(result.current.every((query) => query.isSuccess)).toBe(true));
    const batches = jest
      .mocked(dataService.getSubagentAttachmentCalls)
      .mock.calls.map(([params]) => params.files.length);
    expect(batches).toEqual([32, 8]);
    unmount();
    queryClient.clear();
  });
});