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 from 'react';
import { RecoilRoot } from 'recoil';
import { Provider, createStore } from 'jotai';
import { act, fireEvent, render, screen } from '@testing-library/react';
import type { TConversation, TMessage } from 'librechat-data-provider';
import {
MessagesViewContext,
type MessagesViewContextValue,
} from '~/Providers/MessagesViewContext';
type MockScrollToBottom = jest.Mock & {
cancel: jest.Mock;
flush: jest.Mock;
};
const mockScrollToBottom = jest.fn() as MockScrollToBottom;
mockScrollToBottom.cancel = jest.fn();
mockScrollToBottom.flush = jest.fn();
const mockHandleSmoothToRef = jest.fn();
let mockScrollCallback: (() => void) | undefined;
jest.mock('~/hooks/useScrollToRef', () => ({
__esModule: true,
default: ({ callback }: { callback: () => void }) => {
mockScrollCallback = callback;
return {
scrollToRef: mockScrollToBottom,
handleSmoothToRef: mockHandleSmoothToRef,
};
},
}));
jest.mock('../messageLayout', () => ({
reconcileMessageContentLayout: jest.fn(),
}));
import useMessageScrolling from '../useMessageScrolling';
import { reconcileMessageContentLayout } from '../messageLayout';
import { autoScrollAtom } from '~/store/autoScroll';
const mockReconcileMessageContentLayout = reconcileMessageContentLayout as jest.Mock;
class MockResizeObserver {
static instances: MockResizeObserver[] = [];
static reset() {
MockResizeObserver.instances = [];
}
static last(): MockResizeObserver | undefined {
return MockResizeObserver.instances[MockResizeObserver.instances.length - 1];
}
readonly callback: ResizeObserverCallback;
observe = jest.fn();
unobserve = jest.fn();
disconnect = jest.fn();
constructor(callback: ResizeObserverCallback) {
this.callback = callback;
MockResizeObserver.instances.push(this);
}
trigger() {
this.callback([], this as unknown as ResizeObserver);
}
}
class MockIntersectionObserver {
static instances: MockIntersectionObserver[] = [];
static reset() {
MockIntersectionObserver.instances = [];
}
readonly callback: IntersectionObserverCallback;
observe = jest.fn();
unobserve = jest.fn();
disconnect = jest.fn();
takeRecords = jest.fn(() => []);
constructor(callback: IntersectionObserverCallback) {
this.callback = callback;
MockIntersectionObserver.instances.push(this);
}
}
/** Matches the hook's glide fallback, the window in which a landing is still pending. */
const glideWindow = 700;
const originalResizeObserver = global.ResizeObserver;
const originalIntersectionObserver = global.IntersectionObserver;
function setRect(element: HTMLElement, rect: Partial<DOMRect>): void {
element.getBoundingClientRect = jest.fn(
() =>
({
x: rect.x ?? 0,
y: rect.y ?? 0,
top: rect.top ?? 0,
left: rect.left ?? 0,
right: rect.right ?? 0,
bottom: rect.bottom ?? 0,
width: rect.width ?? 0,
height: rect.height ?? 0,
toJSON: () => ({}),
}) as DOMRect,
);
}
const conversation = {
conversationId: 'conversation-1',
endpoint: 'openAI',
model: 'gpt-4',
} as TConversation;
const message = {
messageId: 'message-1',
conversationId: conversation.conversationId,
isCreatedByUser: false,
} as TMessage;
function createContextValue(
overrides: Partial<MessagesViewContextValue> = {},
): MessagesViewContextValue {
return {
conversation,
conversationId: conversation.conversationId,
isSubmitting: true,
abortScroll: false,
setAbortScroll: jest.fn(),
ask: jest.fn(),
regenerate: jest.fn(),
handleContinue: jest.fn(),
index: 0,
latestMessageId: message.messageId,
latestMessageDepth: 0,
getMessages: jest.fn(),
setMessages: jest.fn(),
...overrides,
} as MessagesViewContextValue;
}
function ScrollingHarness({ messagesTree }: { messagesTree?: TMessage[] | null }) {
const { contentRef, scrollableRef, messagesEndRef, debouncedHandleScroll } =
useMessageScrolling(messagesTree);
return (
<div ref={scrollableRef} onScroll={debouncedHandleScroll} data-testid="scrollable">
<div ref={contentRef} data-testid="content">
<div ref={messagesEndRef} data-testid="end" />
</div>
</div>
);
}
function renderScrolling({
contextOverrides,
messagesTree,
}: {
contextOverrides?: Partial<MessagesViewContextValue>;
messagesTree?: TMessage[] | null;
} = {}) {
return render(
<RecoilRoot>
<MessagesViewContext.Provider value={createContextValue(contextOverrides)}>
<ScrollingHarness messagesTree={messagesTree} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
}
describe('useMessageScrolling resize reconciliation', () => {
beforeEach(() => {
MockResizeObserver.reset();
MockIntersectionObserver.reset();
mockScrollToBottom.mockClear();
mockScrollToBottom.cancel.mockClear();
mockScrollToBottom.flush.mockClear();
mockHandleSmoothToRef.mockClear();
mockReconcileMessageContentLayout.mockClear();
mockScrollCallback = undefined;
(global as unknown as { ResizeObserver: typeof MockResizeObserver }).ResizeObserver =
MockResizeObserver;
(
global as unknown as { IntersectionObserver: typeof MockIntersectionObserver }
).IntersectionObserver = MockIntersectionObserver;
});
afterEach(() => {
(global as unknown as { ResizeObserver: typeof ResizeObserver | undefined }).ResizeObserver =
originalResizeObserver;
(
global as unknown as { IntersectionObserver: typeof IntersectionObserver | undefined }
).IntersectionObserver = originalIntersectionObserver;
});
it('rides the bottom when streaming content resizes and auto-scroll is active', () => {
renderScrolling();
const observer = MockResizeObserver.last();
expect(observer?.observe).toHaveBeenCalledWith(screen.getByTestId('content'));
const scrollable = screen.getByTestId('scrollable');
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
scrollable.scrollTop = 700;
act(() => {
observer?.trigger();
});
/** Written straight to the element rather than routed through the throttled
* scrollIntoView helper, so an answer arriving a few pixels at a time flows
* instead of lurching once every throttle window. */
expect(scrollable.scrollTop).toBe(800);
});
it('reconciles message layout after an explicit scroll to bottom', () => {
renderScrolling();
const scrollable = screen.getByTestId('scrollable');
act(() => {
mockScrollCallback?.();
});
expect(mockReconcileMessageContentLayout).toHaveBeenCalledWith(scrollable);
});
/**
* `useMessageProcess` raises the abort flag on any wheel at all, downward ones
* included, through a throttle whose trailing call lands after the gesture has
* ended. Gating on it meant scrolling down to the newest word could never resume
* the ride, while the scroll-to-bottom button, which touches no wheel, always
* could. Position and direction answer that question instead.
*/
it('rides the bottom for a reader who is on it, even with the abort flag raised', () => {
renderScrolling({ contextOverrides: { abortScroll: true } });
const scrollable = screen.getByTestId('scrollable');
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
scrollable.scrollTop = 700;
act(() => {
MockResizeObserver.last()?.trigger();
});
expect(scrollable.scrollTop).toBe(800);
});
it('does not follow resizes after the user scrolls away from the bottom', () => {
renderScrolling();
const scrollable = screen.getByTestId('scrollable');
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
scrollable.scrollTop = 100;
fireEvent.scroll(scrollable);
act(() => {
MockResizeObserver.last()?.trigger();
});
expect(mockScrollToBottom).not.toHaveBeenCalled();
});
it('judges the first scroll against a real previous position, not against the top', () => {
const setAbortScroll = jest.fn();
renderScrolling({ contextOverrides: { setAbortScroll } });
const scrollable = screen.getByTestId('scrollable');
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
/** A thread opens at its end, so the reader's first gesture carries a large
* positive scrollTop. Measured from 0 it read as a jump down onto the end, and
* the reader was re-pinned to the stream they were trying to leave. */
setAbortScroll.mockClear();
scrollable.scrollTop = 700;
fireEvent.scroll(scrollable);
expect(setAbortScroll).not.toHaveBeenCalled();
/** With a baseline taken, the same gesture is judged on its real delta. */
scrollable.scrollTop = 500;
fireEvent.scroll(scrollable);
act(() => {
MockResizeObserver.last()?.trigger();
});
expect(scrollable.scrollTop).toBe(500);
});
it('obeys the first scroll away from a thread that was placed at its end', () => {
renderScrolling();
const scrollable = screen.getByTestId('scrollable');
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
/** The thread opens at its end without the reader touching it, so the position
* it was placed at is what their first gesture has to be judged against. */
scrollable.scrollTop = 800;
act(() => {
mockScrollCallback?.();
});
/** One PageUp, and it is the first event the handler sees. A key press buys a
* single resize of grace and clears no flag of its own, so if the gesture is
* spent taking a baseline the reader is ridden straight back to the end. */
fireEvent.keyDown(screen.getByTestId('content'), { key: 'PageUp' });
scrollable.scrollTop = 300;
fireEvent.scroll(scrollable);
act(() => {
MockResizeObserver.last()?.trigger();
MockResizeObserver.last()?.trigger();
});
expect(scrollable.scrollTop).toBe(300);
});
it('does not follow the next resize after user interaction inside message content', () => {
renderScrolling();
fireEvent.pointerDown(screen.getByTestId('content'));
act(() => {
MockResizeObserver.last()?.trigger();
});
expect(mockScrollToBottom).not.toHaveBeenCalled();
});
/**
* One interaction rarely settles in a single frame: expanding a tool result renders
* the container, then its contents arrive and grow it again. Only the first resize
* was credited to the interaction, so the second read the reader as still riding the
* stream and put them back on the bottom they had just deliberately left.
*/
it('keeps an interaction that settles over several resizes from re-pinning the reader', () => {
renderScrolling();
const scrollable = screen.getByTestId('scrollable');
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
scrollable.scrollTop = 800;
fireEvent.pointerDown(screen.getByTestId('content'));
/** The expansion renders, which is the resize the interaction is credited with. */
Object.defineProperty(scrollable, 'scrollHeight', { value: 2000, configurable: true });
act(() => {
MockResizeObserver.last()?.trigger();
});
expect(scrollable.scrollTop).toBe(800);
/** Its contents then load. This belongs to the same interaction, not to the stream. */
Object.defineProperty(scrollable, 'scrollHeight', { value: 2600, configurable: true });
act(() => {
MockResizeObserver.last()?.trigger();
});
expect(scrollable.scrollTop).toBe(800);
});
it('clamps the scroll position back to content after a resize shrink', () => {
renderScrolling({ contextOverrides: { abortScroll: true } });
const scrollable = screen.getByTestId('scrollable');
Object.defineProperty(scrollable, 'scrollHeight', { value: 500, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
scrollable.scrollTop = 450;
act(() => {
MockResizeObserver.last()?.trigger();
});
expect(scrollable.scrollTop).toBe(300);
expect(mockScrollToBottom).not.toHaveBeenCalled();
});
/**
* Sending arms a smooth glide down to the newest word, and the landing re-pins the
* thread to the bottom. The landing is scheduled for the whole glide window, so a
* reader who changes their mind and heads up mid-flight was pinned again anyway and
* dragged back on the next streaming resize.
*/
it('lets an upward gesture during the send glide beat the pending landing', () => {
jest.useFakeTimers();
try {
const view = render(
<RecoilRoot>
<MessagesViewContext.Provider value={createContextValue({ isSubmitting: false })}>
<ScrollingHarness messagesTree={[message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
const scrollable = screen.getByTestId('scrollable');
const scrollTo = jest.fn();
(scrollable as unknown as { scrollTo: jest.Mock }).scrollTo = scrollTo;
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
scrollable.scrollTop = 0;
view.rerender(
<RecoilRoot>
<MessagesViewContext.Provider value={createContextValue({ isSubmitting: true })}>
<ScrollingHarness messagesTree={[message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
expect(scrollTo).toHaveBeenCalledWith({ top: 800, behavior: 'smooth' });
/** The reader heads up while the glide is still in flight. */
scrollable.scrollTop = 400;
fireEvent.wheel(scrollable, { deltaY: -120 });
act(() => {
jest.advanceTimersByTime(glideWindow);
});
Object.defineProperty(scrollable, 'scrollHeight', { value: 1200, configurable: true });
act(() => {
MockResizeObserver.last()?.trigger();
});
expect(scrollable.scrollTop).toBe(400);
} finally {
jest.useRealTimers();
}
});
/**
* A reader who scrolls away during one answer leaves the abort flag raised, and
* nothing lowers it until the next connection opens, which is after the send has
* already been seen. Spending the start of the turn on that first pass left the
* answer the reader had just asked for streaming offscreen.
*/
it('starts the turn once a stale abort flag clears', () => {
const view = render(
<RecoilRoot>
<MessagesViewContext.Provider value={createContextValue({ isSubmitting: false })}>
<ScrollingHarness messagesTree={[message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
const scrollable = screen.getByTestId('scrollable');
const scrollTo = jest.fn();
(scrollable as unknown as { scrollTo: jest.Mock }).scrollTo = scrollTo;
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
scrollable.scrollTop = 0;
/** They left the bottom during the previous answer, which is what raised it. */
fireEvent.wheel(scrollable, { deltaY: -120 });
view.rerender(
<RecoilRoot>
<MessagesViewContext.Provider
value={createContextValue({ isSubmitting: true, abortScroll: true })}
>
<ScrollingHarness messagesTree={[message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
expect(scrollTo).not.toHaveBeenCalled();
/** The connection opens and lowers the flag. */
view.rerender(
<RecoilRoot>
<MessagesViewContext.Provider
value={createContextValue({ isSubmitting: true, abortScroll: false })}
>
<ScrollingHarness messagesTree={[message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
expect(scrollTo).toHaveBeenCalledWith({ top: 800, behavior: 'smooth' });
});
it('leaves the send glide alone while the answer streams in', () => {
const view = render(
<RecoilRoot>
<MessagesViewContext.Provider value={createContextValue({ isSubmitting: false })}>
<ScrollingHarness messagesTree={[message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
const scrollable = screen.getByTestId('scrollable');
const scrollTo = jest.fn();
(scrollable as unknown as { scrollTo: jest.Mock }).scrollTo = scrollTo;
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
scrollable.scrollTop = 0;
view.rerender(
<RecoilRoot>
<MessagesViewContext.Provider value={createContextValue({ isSubmitting: true })}>
<ScrollingHarness messagesTree={[message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
expect(scrollTo).toHaveBeenCalledWith({ top: 800, behavior: 'smooth' });
/** The next delta of the answer arrives while the glide is still travelling. */
Object.defineProperty(scrollable, 'scrollHeight', { value: 1100, configurable: true });
view.rerender(
<RecoilRoot>
<MessagesViewContext.Provider value={createContextValue({ isSubmitting: true })}>
<ScrollingHarness messagesTree={[message, message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
/** A plain follow would have written scrollTop outright and killed the animation. */
expect(scrollable.scrollTop).toBe(0);
});
/**
* Following stands down for the length of the glide, so an answer that arrives
* while it travels moves the bottom past the target the glide aimed at. Landing
* has to close that gap, or a short response settles short of its own end.
*/
it('catches up to the new bottom when the glide lands', () => {
const view = render(
<RecoilRoot>
<MessagesViewContext.Provider value={createContextValue({ isSubmitting: false })}>
<ScrollingHarness messagesTree={[message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
const scrollable = screen.getByTestId('scrollable');
(scrollable as unknown as { scrollTo: jest.Mock }).scrollTo = jest.fn();
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
scrollable.scrollTop = 0;
view.rerender(
<RecoilRoot>
<MessagesViewContext.Provider value={createContextValue({ isSubmitting: true })}>
<ScrollingHarness messagesTree={[message]} />
</MessagesViewContext.Provider>
</RecoilRoot>,
);
/** The whole answer arrives before the glide reports that it landed. */
Object.defineProperty(scrollable, 'scrollHeight', { value: 1400, configurable: true });
act(() => {
fireEvent(scrollable, new Event('scrollend'));
});
expect(scrollable.scrollTop).toBe(1200);
});
it('does not clamp to rendered content bottom during general resize reconciliation', () => {
renderScrolling();
const scrollable = screen.getByTestId('scrollable');
const content = screen.getByTestId('content');
Object.defineProperty(scrollable, 'scrollHeight', { value: 1000, configurable: true });
Object.defineProperty(scrollable, 'clientHeight', { value: 200, configurable: true });
/** Move away from the end so the reader is left alone, which is the state this
* is about: reconciliation must not drag them to the rendered content bottom. */
scrollable.scrollTop = 900;
fireEvent.scroll(scrollable);
scrollable.scrollTop = 700;
fireEvent.scroll(scrollable);
setRect(scrollable, { top: 0, bottom: 200, height: 200 });
setRect(content, { top: -700, bottom: -200, height: 500 });
act(() => {
MockResizeObserver.last()?.trigger();
});
expect(scrollable.scrollTop).toBe(700);
expect(mockScrollToBottom).not.toHaveBeenCalled();
});
});
describe('useMessageScrolling navigation landing', () => {
const treeFor = (conversationId: string): TMessage[] => [
{ ...message, conversationId } as TMessage,
];
const harness = (
store: ReturnType<typeof createStore>,
conversationId: string,
messagesTree: TMessage[] | null,
) => (
<RecoilRoot>
<Provider store={store}>
<MessagesViewContext.Provider
value={createContextValue({
isSubmitting: false,
conversation: { ...conversation, conversationId } as TConversation,
conversationId,
})}
>
<ScrollingHarness messagesTree={messagesTree} />
</MessagesViewContext.Provider>
</Provider>
</RecoilRoot>
);
function renderLanding(
conversationId: string,
messagesTree: TMessage[] | null,
autoScroll = true,
) {
const store = createStore();
store.set(autoScrollAtom, autoScroll);
const view = render(harness(store, conversationId, messagesTree));
return {
...view,
rerenderWith: (nextId: string, nextTree: TMessage[] | null) =>
view.rerender(harness(store, nextId, nextTree)),
};
}
beforeEach(() => {
MockResizeObserver.reset();
MockIntersectionObserver.reset();
mockScrollToBottom.mockClear();
mockScrollToBottom.cancel.mockClear();
(global as unknown as { ResizeObserver: typeof MockResizeObserver }).ResizeObserver =
MockResizeObserver;
(
global as unknown as { IntersectionObserver: typeof MockIntersectionObserver }
).IntersectionObserver = MockIntersectionObserver;
});
afterEach(() => {
(global as unknown as { ResizeObserver: typeof ResizeObserver | undefined }).ResizeObserver =
originalResizeObserver;
(
global as unknown as { IntersectionObserver: typeof IntersectionObserver | undefined }
).IntersectionObserver = originalIntersectionObserver;
});
it('waits for the opened conversation to own the rendered rows', () => {
/** The id reaches the hook commits before the tree does. Landing on the
* outgoing thread spends the one scroll this navigation gets, and leaves
* the reader at the top of the thread they actually asked for. */
renderLanding('conversation-2', treeFor('conversation-1'));
expect(mockScrollToBottom).not.toHaveBeenCalled();
});
it('lands once the rendered tree names the opened conversation', () => {
const { rerenderWith } = renderLanding('conversation-2', treeFor('conversation-1'));
expect(mockScrollToBottom).not.toHaveBeenCalled();
rerenderWith('conversation-2', treeFor('conversation-2'));
expect(mockScrollToBottom).toHaveBeenCalledTimes(1);
});
it('does not re-land on the tree identities a stream mints', () => {
const { rerenderWith } = renderLanding('conversation-2', treeFor('conversation-2'));
expect(mockScrollToBottom).toHaveBeenCalledTimes(1);
/** Every delta writes a fresh array; re-landing on those would haul back a
* reader who deliberately scrolled up. */
rerenderWith('conversation-2', treeFor('conversation-2'));
rerenderWith('conversation-2', treeFor('conversation-2'));
expect(mockScrollToBottom).toHaveBeenCalledTimes(1);
});
it('lands again for the next conversation opened', () => {
const { rerenderWith } = renderLanding('conversation-2', treeFor('conversation-2'));
expect(mockScrollToBottom).toHaveBeenCalledTimes(1);
rerenderWith('conversation-3', treeFor('conversation-2'));
expect(mockScrollToBottom).toHaveBeenCalledTimes(1);
rerenderWith('conversation-3', treeFor('conversation-3'));
expect(mockScrollToBottom).toHaveBeenCalledTimes(2);
});
it('stays put when the setting is off', () => {
renderLanding('conversation-2', treeFor('conversation-2'), false);
expect(mockScrollToBottom).not.toHaveBeenCalled();
});
});