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
🪄 feat: Smooth Activity Phase Transitions (#14832)
Danny Avila5d3edeb383ea
diff --git a/client/src/components/Chat/Messages/Content/ActivityPhaseGroup.tsx b/client/src/components/Chat/Messages/Content/ActivityPhaseGroup.tsxindex 7bf86bab8f..431b285ce1 100644--- a/client/src/components/Chat/Messages/Content/ActivityPhaseGroup.tsx+++ b/client/src/components/Chat/Messages/Content/ActivityPhaseGroup.tsx@@ -1,31 +1,147 @@-import { ChevronDown, ListTree } from 'lucide-react';+import { useId, useCallback, useEffect, useMemo, useRef, useState } from 'react';+import { Button } from '@librechat/client';+import { ChevronDown } from 'lucide-react';import { ContentTypes } from 'librechat-data-provider';import type { TMessageContentParts } from 'librechat-data-provider';-import type { ReactNode } from 'react';+import type { CSSProperties, ReactNode } from 'react';+import {+ useExpandCollapse,+ scheduleMessageContentLayoutReconcile,+ EXPAND_TRANSITION,+} from '~/hooks';+import useSmoothStreaming from '~/hooks/Messages/useSmoothStreaming';import { getActivityLabelText } from '~/utils/activityLabels';import { EmptyText } from './Parts';import Container from './Container';import { cn } from '~/utils';+/** Matches `EXPAND_TRANSITION` so the header, the panel, and the card chrome+ * all resolve on the same curve — three properties animating on two different+ * easings is what makes a fold read as two separate movements. */+const FOLD_EASING = 'duration-300 ease-[cubic-bezier(0.16,1,0.3,1)] motion-reduce:transition-none';+type ActivityPhasePart = Extract<TMessageContentParts, { type: ContentTypes.ACTIVITY_LABEL }> & {activity_label_type?: 'phase';activity_start_index?: number;activity_end_index?: number;};+/**+ * Runs `callback` once the browser has painted the current styles. One frame+ * is not enough: React can flush passive effects before paint, and a start+ * value the compositor never saw produces an instant jump rather than a+ * transition. Returns a canceller for whichever frame is still pending.+ */+function schedulePostPaint(callback: () => void): () => void {+ let frameId: number | undefined;+ frameId = window.requestAnimationFrame(() => {+ frameId = window.requestAnimationFrame(() => {+ frameId = undefined;+ callback();+ });+ });+ return () => {+ if (frameId != null) {+ window.cancelAnimationFrame(frameId);+ frameId = undefined;+ }+ };+}+export default function ActivityPhaseGroup({labelPart,children,hasContent,showCursor = false,+ animateEntrance = false,}: {labelPart: ActivityPhasePart;children: ReactNode;hasContent: boolean;showCursor?: boolean;+ animateEntrance?: boolean;}) {const label = getActivityLabelText(labelPart);const hasFailure = labelPart.status === 'failed' || labelPart.status === 'partial';+ const smoothStreaming = useSmoothStreaming();+ /** Capture the marker's arrival state. The parent renderer records the new+ * marker after this commit; a later sibling update must not cancel the+ * already-scheduled fold before its first animation frame. */+ const [shouldAnimateEntrance] = useState(smoothStreaming && animateEntrance && label.length > 0);+ /** A filled phase marker lands on top of activity the reader is already+ * looking at. The card therefore mounts in the shape of what was there+ * BEFORE it — header at zero height, panel open, chrome transparent — and+ * folds into the summary on the next painted frame. Growing the header+ * while the panel collapses keeps the block's height strictly decreasing,+ * so the content compresses upward instead of being shoved down by a+ * header that appeared underneath it and then yanked back up. */+ const foldsIn = shouldAnimateEntrance && hasContent;+ const [isExpanded, setIsExpanded] = useState(foldsIn);+ const [isSettled, setIsSettled] = useState(!foldsIn);+ const rootRef = useRef<HTMLDivElement | null>(null);+ const panelId = useId();+ const cancelEntranceRef = useRef<(() => void) | null>(null);+ const cancelLayoutReconcileRef = useRef<(() => void) | null>(null);+ const previousIsExpandedRef = useRef(isExpanded);+ const userOverrideRef = useRef(false);+ const { style: expandStyle, ref: expandRef } = useExpandCollapse(isExpanded);++ useEffect(() => {+ if (!foldsIn || userOverrideRef.current) {+ return;+ }+ cancelEntranceRef.current = schedulePostPaint(() => {+ cancelEntranceRef.current = null;+ if (userOverrideRef.current) {+ return;+ }+ setIsSettled(true);+ setIsExpanded(false);+ });+ return () => {+ cancelEntranceRef.current?.();+ cancelEntranceRef.current = null;+ };+ }, [foldsIn]);++ useEffect(() => {+ const wasExpanded = previousIsExpandedRef.current;+ previousIsExpandedRef.current = isExpanded;+ if (wasExpanded && !isExpanded) {+ cancelLayoutReconcileRef.current?.();+ cancelLayoutReconcileRef.current = scheduleMessageContentLayoutReconcile(rootRef.current);+ }+ }, [isExpanded]);++ useEffect(+ () => () => {+ cancelLayoutReconcileRef.current?.();+ },+ [],+ );++ const handleToggle = useCallback(() => {+ userOverrideRef.current = true;+ cancelEntranceRef.current?.();+ cancelEntranceRef.current = null;+ setIsSettled(true);+ setIsExpanded((expanded) => !expanded);+ }, []);++ /** Only the folding entrance drives the header off its natural height.+ * History and reduced-motion render the plain, unstyled row. */+ const headerStyle = useMemo<CSSProperties | undefined>(() => {+ if (!foldsIn) {+ return undefined;+ }+ return {+ display: 'grid',+ gridTemplateRows: isSettled ? '1fr' : '0fr',+ transition: EXPAND_TRANSITION,+ opacity: isSettled ? 1 : 0,+ };+ }, [foldsIn, isSettled]);+const cursor = showCursor ? (<Container><EmptyText />@@ -35,15 +151,16 @@ export default function ActivityPhaseGroup({return <>{children}</>;}const group = !hasContent ? (- <div className="my-2 flex min-h-10 w-full items-center gap-2 rounded-lg border border-border-light bg-surface-secondary/40 px-3 py-2 text-text-secondary">- <ListTree- className={cn('size-4 shrink-0', hasFailure && 'text-amber-600 dark:text-amber-400')}- aria-hidden="true"- />+ <div+ className={cn(+ 'my-2 flex min-h-10 w-full items-center rounded-lg border border-border-light bg-surface-secondary/40 px-3 py-2 text-text-secondary',+ shouldAnimateEntrance && `animate-in fade-in-0 motion-reduce:animate-none ${FOLD_EASING}`,+ )}+ ><spanclassName={cn(- 'min-w-0 flex-1 truncate text-sm font-medium',- hasFailure && 'text-amber-600 dark:text-amber-400',+ 'min-w-0 flex-1 truncate text-left text-sm font-medium',+ hasFailure && 'text-text-warning',)}role="status"title={label}@@ -52,32 +169,68 @@ export default function ActivityPhaseGroup({</span></div>) : (- <details className="group/activity-phase my-2 w-full rounded-lg border border-border-light bg-surface-secondary/40">- <summary- className="flex min-h-10 cursor-pointer list-none items-center gap-2 px-3 py-2 text-text-secondary transition-colors hover:bg-surface-hover hover:text-text-primary focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring-primary [&::-webkit-details-marker]:hidden"- aria-label={label}- title={label}+ <div+ className={cn(+ 'my-2 w-full rounded-lg border transition-colors',+ FOLD_EASING,+ isSettled ? 'border-border-light bg-surface-secondary/40' : 'border-transparent',+ )}+ ref={rootRef}+ >+ <div style={headerStyle}>+ <div className="overflow-hidden">+ <Button+ variant="ghost"+ type="button"+ className="flex h-auto min-h-10 w-full items-center justify-start gap-2 rounded-lg bg-transparent px-3 py-2 text-left text-text-secondary hover:bg-surface-hover hover:text-text-primary focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring-primary focus-visible:ring-offset-0"+ onClick={handleToggle}+ aria-expanded={isExpanded}+ aria-controls={panelId}+ aria-label={label}+ title={label}+ >+ <span+ className={cn(+ 'min-w-0 flex-1 truncate text-left text-sm font-medium',+ hasFailure && 'text-text-warning',+ )}+ role="status"+ >+ {label}+ </span>+ <ChevronDown+ className={cn(+ 'size-4 shrink-0 transition-transform duration-200 ease-out motion-reduce:transition-none',+ isExpanded && 'rotate-180',+ )}+ aria-hidden="true"+ />+ </Button>+ </div>+ </div>+ <div+ id={panelId}+ style={expandStyle}+ aria-hidden={!isExpanded}+ data-testid="activity-phase-panel">- <ListTree- className={cn('size-4 shrink-0', hasFailure && 'text-amber-600 dark:text-amber-400')}- aria-hidden="true"- />- <span- className={cn(- 'min-w-0 flex-1 truncate text-sm font-medium',- hasFailure && 'text-amber-600 dark:text-amber-400',- )}- role="status"- >- {label}- </span>- <ChevronDown- className="size-4 shrink-0 transition-transform duration-200 group-open/activity-phase:rotate-180"- aria-hidden="true"- />- </summary>- <div className="border-t border-border-light px-3 py-2">{children}</div>- </details>+ <div className="overflow-hidden" ref={expandRef}>+ {/** Padding and the divider ride the same curve as the fold: the+ * children occupy the exact position they held before the marker+ * arrived and settle into the card as it materializes, instead of+ * stepping sideways by the card's inset on the first frame. */}+ <div+ className={cn(+ 'border-t transition-[border-color,padding]',+ FOLD_EASING,+ isSettled ? 'border-border-light px-3 py-2' : 'border-transparent px-0 py-0',+ )}+ >+ {children}+ </div>+ </div>+ </div>+ </div>);return (<>diff --git a/client/src/components/Chat/Messages/Content/ContentParts.tsx b/client/src/components/Chat/Messages/Content/ContentParts.tsxindex 7656949a65..6db6f77244 100644--- a/client/src/components/Chat/Messages/Content/ContentParts.tsx+++ b/client/src/components/Chat/Messages/Content/ContentParts.tsx@@ -1,4 +1,4 @@-import { memo, useRef, useMemo, useCallback, Fragment } from 'react';+import { memo, useRef, useMemo, useEffect, useCallback, Fragment } from 'react';import { ContentTypes } from 'librechat-data-provider';import type {TMessageContentParts,@@ -215,6 +215,37 @@ const ContentParts = memo(function ContentParts({(localIndex: number) => contentIndices?.[localIndex] ?? localIndex + contentIndexOffset,[contentIndexOffset, contentIndices],);+ /** Hoisted above the early returns to feed the entrance-detection hook+ * below, so it is memoized rather than re-walked on every unrelated+ * re-render of a message that has no phases at all. */+ const phaseSegments = useMemo(+ () => (nestedActivityPhase ? undefined : groupActivityPhases(content)),+ [nestedActivityPhase, content],+ );+ const completedPhaseIndices = useMemo(() => {+ const indices = new Set<number>();+ for (const segment of phaseSegments ?? []) {+ if (segment.type === 'phase') {+ indices.add(segment.labelIndex);+ }+ }+ return indices;+ }, [phaseSegments]);+ /** A phase label can finish after the root text stream settles, so+ * `isSubmitting` is not a reliable entrance signal. Compare committed+ * phase markers instead: a marker that appears after this renderer has+ * mounted is live; markers present on the first render are history.+ *+ * The recorded set is scoped to the message it described. `MultiMessage`+ * renders siblings without a key, so this instance survives a sibling+ * switch with its refs intact — an unscoped set would report the previous+ * sibling's phases and animate the newly selected sibling's history. */+ const previousPhaseRef = useRef<{ messageId: string; indices: Set<number> } | null>(null);+ const previousPhaseIndices =+ previousPhaseRef.current?.messageId === messageId ? previousPhaseRef.current.indices : null;+ useEffect(() => {+ previousPhaseRef.current = { messageId, indices: completedPhaseIndices };+ }, [messageId, completedPhaseIndices]);const handleGroupExpansionChange = useCallback((groupId: string, state: ToolCallGroupExpansionState) => {@@ -452,7 +483,6 @@ const ContentParts = memo(function ContentParts({);}- const phaseSegments = nestedActivityPhase ? undefined : groupActivityPhases(content);if (phaseSegments != null) {const relativeGlobalLastContentIdx = lastVisibleContentIdx(content ?? []);const globalLastContentIdx =@@ -500,6 +530,9 @@ const ContentParts = memo(function ContentParts({key={`activity-phase-${messageId}-${segment.labelIndex}`}labelPart={segment.labelPart}hasContent={segment.hasContent}+ animateEntrance={+ previousPhaseIndices != null && !previousPhaseIndices.has(segment.labelIndex)+ }showCursor={isLast &&effectiveIsSubmitting &&diff --git a/client/src/components/Chat/Messages/Content/Part.tsx b/client/src/components/Chat/Messages/Content/Part.tsxindex 3e636da8ff..61f9a105d5 100644--- a/client/src/components/Chat/Messages/Content/Part.tsx+++ b/client/src/components/Chat/Messages/Content/Part.tsx@@ -166,7 +166,7 @@ const Part = memo(function Part({const failed = part.status === 'failed' || part.status === 'partial';return (<div- className={`my-1 break-words pl-1 text-sm italic ${failed ? 'text-amber-600 dark:text-amber-400' : 'text-text-secondary'}`}+ className={`my-1 break-words pl-1 text-sm italic ${failed ? 'text-text-warning' : 'text-text-secondary'}`}>{display}</div>diff --git a/client/src/components/Chat/Messages/Content/ToolCallGroup.tsx b/client/src/components/Chat/Messages/Content/ToolCallGroup.tsxindex d70a10e0bc..85ea2f778e 100644--- a/client/src/components/Chat/Messages/Content/ToolCallGroup.tsx+++ b/client/src/components/Chat/Messages/Content/ToolCallGroup.tsx@@ -379,7 +379,7 @@ export default function ToolCallGroup({<spanclassName={cn('tool-status-text min-w-0 truncate font-medium',- activityFailed && 'text-amber-600 dark:text-amber-400',+ activityFailed && 'text-text-warning',)}role="status"title={groupLabel}diff --git a/client/src/components/Chat/Messages/Content/__tests__/ActivityPhaseGroup.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ActivityPhaseGroup.test.tsxindex 897b42eff0..b4f7d237a2 100644--- a/client/src/components/Chat/Messages/Content/__tests__/ActivityPhaseGroup.test.tsx+++ b/client/src/components/Chat/Messages/Content/__tests__/ActivityPhaseGroup.test.tsx@@ -1,17 +1,86 @@-import { render } from '@testing-library/react';import { ContentTypes } from 'librechat-data-provider';+import { act, fireEvent, render, screen } from '@testing-library/react';import type { TMessageContentParts } from 'librechat-data-provider';import ActivityPhaseGroup from '../ActivityPhaseGroup';+const mockUseSmoothStreaming = jest.fn(() => true);+const mockScheduleLayoutReconcile = jest.fn((_target: HTMLElement | null) => jest.fn());++jest.mock('~/hooks/Messages/useSmoothStreaming', () => ({+ __esModule: true,+ default: () => mockUseSmoothStreaming(),+}));++jest.mock('~/hooks', () => {+ const expandCollapse = jest.requireActual('~/hooks/Messages/useExpandCollapse');+ return {+ useExpandCollapse: expandCollapse.default,+ EXPAND_TRANSITION: expandCollapse.EXPAND_TRANSITION,+ scheduleMessageContentLayoutReconcile: (target: HTMLElement | null) =>+ mockScheduleLayoutReconcile(target),+ };+});++const LABEL = 'Compared both release paths';+const labelPart = {type: ContentTypes.ACTIVITY_LABEL,- [ContentTypes.ACTIVITY_LABEL]: 'Compared both release paths',+ [ContentTypes.ACTIVITY_LABEL]: LABEL,activity_label_type: 'phase',activity_start_index: 0,pending: false,} as unknown as Extract<TMessageContentParts, { type: ContentTypes.ACTIVITY_LABEL }>;describe('ActivityPhaseGroup', () => {+ let frames: Array<FrameRequestCallback | undefined>;+ const originalRequestAnimationFrame = window.requestAnimationFrame;+ const originalCancelAnimationFrame = window.cancelAnimationFrame;++ /** The fold waits for a painted start value, so it spans more than one+ * frame. Drain the queue the way a real compositor would. */+ const flushFrames = () =>+ act(() => {+ for (let index = 0; index < frames.length; index += 1) {+ const frame = frames[index];+ frames[index] = undefined;+ frame?.(index);+ }+ });++ const pendingFrames = () => frames.filter((frame) => frame != null).length;++ beforeEach(() => {+ frames = [];+ mockUseSmoothStreaming.mockReturnValue(true);+ mockScheduleLayoutReconcile.mockClear();+ Object.defineProperty(window, 'requestAnimationFrame', {+ configurable: true,+ writable: true,+ value: jest.fn((callback: FrameRequestCallback) => frames.push(callback)),+ });+ Object.defineProperty(window, 'cancelAnimationFrame', {+ configurable: true,+ writable: true,+ value: jest.fn((handle: number) => {+ frames[handle - 1] = undefined;+ }),+ });+ });++ afterEach(() => {+ jest.restoreAllMocks();+ if (originalRequestAnimationFrame == null) {+ Reflect.deleteProperty(window, 'requestAnimationFrame');+ } else {+ window.requestAnimationFrame = originalRequestAnimationFrame;+ }+ if (originalCancelAnimationFrame == null) {+ Reflect.deleteProperty(window, 'cancelAnimationFrame');+ } else {+ window.cancelAnimationFrame = originalCancelAnimationFrame;+ }+ });+test('renders a streaming cursor after an active tail phase', () => {const { container } = render(<ActivityPhaseGroup labelPart={labelPart} hasContent showCursor>@@ -21,4 +90,106 @@ describe('ActivityPhaseGroup', () => {expect(container.querySelector('.result-thinking')).toBeInTheDocument();});++ test('renders the label flush left with no leading glyph', () => {+ render(+ <ActivityPhaseGroup labelPart={labelPart} hasContent>+ <div data-testid="phase-content" />+ </ActivityPhaseGroup>,+ );++ const trigger = screen.getByRole('button', { name: LABEL });+ expect(trigger).toHaveClass('justify-start', 'text-left');+ expect(screen.getByText(LABEL)).toHaveClass('flex-1', 'text-left');+ expect(trigger.querySelectorAll('svg')).toHaveLength(1);+ });++ test('mounts in the pre-marker shape, then folds the activity into the summary', () => {+ const { container } = render(+ <ActivityPhaseGroup labelPart={labelPart} hasContent animateEntrance>+ <div data-testid="phase-content" />+ </ActivityPhaseGroup>,+ );++ const card = container.querySelector('.my-2') as HTMLElement;+ const trigger = screen.getByRole('button', { name: LABEL });+ const header = trigger.parentElement?.parentElement as HTMLElement;+ const panel = screen.getByTestId('activity-phase-panel');++ /** Frame zero must be indistinguishable from the layout the marker+ * replaced: no chrome, no header height, activity still open. */+ expect(card).toHaveClass('border-transparent');+ expect(card).not.toHaveClass('bg-surface-secondary/40');+ expect(header).toHaveStyle({ gridTemplateRows: '0fr', opacity: '0' });+ expect(trigger).toHaveAttribute('aria-expanded', 'true');+ expect(panel).toHaveAttribute('aria-hidden', 'false');++ flushFrames();++ expect(header).toHaveStyle({ gridTemplateRows: '1fr', opacity: '1' });+ expect(card).toHaveClass('border-border-light', 'bg-surface-secondary/40');+ expect(trigger).toHaveAttribute('aria-expanded', 'false');+ expect(panel).toHaveAttribute('aria-hidden', 'true');+ expect(mockScheduleLayoutReconcile).toHaveBeenCalledTimes(1);+ });++ test('keeps historical phases closed without replaying the entrance', () => {+ render(+ <ActivityPhaseGroup labelPart={labelPart} hasContent>+ <div data-testid="phase-content" />+ </ActivityPhaseGroup>,+ );++ const trigger = screen.getByRole('button', { name: LABEL });+ const header = trigger.parentElement?.parentElement as HTMLElement;+ expect(trigger).toHaveAttribute('aria-expanded', 'false');+ expect(header.getAttribute('style')).toBeNull();+ expect(pendingFrames()).toBe(0);++ fireEvent.click(trigger);+ expect(trigger).toHaveAttribute('aria-expanded', 'true');+ });++ test('honors the smooth-streaming preference', () => {+ mockUseSmoothStreaming.mockReturnValue(false);++ const { container } = render(+ <ActivityPhaseGroup labelPart={labelPart} hasContent animateEntrance>+ <div data-testid="phase-content" />+ </ActivityPhaseGroup>,+ );++ const trigger = screen.getByRole('button', { name: LABEL });+ expect(trigger).toHaveAttribute('aria-expanded', 'false');+ expect(container.querySelector('.my-2')).toHaveClass('border-border-light');+ expect(pendingFrames()).toBe(0);+ });++ test('a click during the entrance wins over the scheduled fold', () => {+ render(+ <ActivityPhaseGroup labelPart={labelPart} hasContent animateEntrance>+ <div data-testid="phase-content" />+ </ActivityPhaseGroup>,+ );++ const trigger = screen.getByRole('button', { name: LABEL });+ fireEvent.click(trigger);+ expect(trigger).toHaveAttribute('aria-expanded', 'false');++ flushFrames();++ expect(trigger).toHaveAttribute('aria-expanded', 'false');+ });++ test('a phase without activity renders a label-only header', () => {+ render(+ <ActivityPhaseGroup labelPart={labelPart} hasContent={false} animateEntrance>+ <div data-testid="phase-content" />+ </ActivityPhaseGroup>,+ );++ expect(screen.queryByRole('button')).not.toBeInTheDocument();+ expect(screen.getByText(LABEL)).toHaveClass('text-left');+ expect(pendingFrames()).toBe(0);+ });});diff --git a/client/src/components/Chat/Messages/Content/__tests__/ContentParts.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ContentParts.test.tsxindex df52bb72d7..75cc6977e3 100644--- a/client/src/components/Chat/Messages/Content/__tests__/ContentParts.test.tsx+++ b/client/src/components/Chat/Messages/Content/__tests__/ContentParts.test.tsx@@ -69,8 +69,20 @@ jest.mock('../ToolCallGroup', () => ({jest.mock('../ActivityPhaseGroup', () => ({__esModule: true,- default: ({ children, showCursor }: { children: React.ReactNode; showCursor?: boolean }) => (- <div data-testid="activity-phase-group" data-show-cursor={String(showCursor === true)}>+ default: ({+ children,+ showCursor,+ animateEntrance,+ }: {+ children: React.ReactNode;+ showCursor?: boolean;+ animateEntrance?: boolean;+ }) => (+ <div+ data-testid="activity-phase-group"+ data-show-cursor={String(showCursor === true)}+ data-animate-entrance={String(animateEntrance === true)}+ >{children}</div>),@@ -350,6 +362,7 @@ describe('ContentParts — activity phase state', () => {const parent = screen.getByTestId('activity-phase-group');const finalPart = screen.getByTestId(`real-part-${ContentTypes.TEXT}`);expect(parent.compareDocumentPosition(finalPart)).toBe(Node.DOCUMENT_POSITION_FOLLOWING);+ expect(parent).toHaveAttribute('data-animate-entrance', 'false');expect(finalPart).toHaveAttribute('data-index', '2');});@@ -448,6 +461,47 @@ describe('ContentParts — activity phase state', () => {rerender(<ContentParts {...baseProps} content={[...tools, completedPhase]} />);expect(screen.getByTestId('activity-phase-group')).toBeInTheDocument();+ expect(screen.getByTestId('activity-phase-group')).toHaveAttribute(+ 'data-animate-entrance',+ 'true',+ );expect(screen.getByTestId('tool-call-group')).toHaveAttribute('data-initial-expanded', 'false');});++ test('does not replay the entrance when switching to a sibling with its own phases', () => {+ const phase = (label: string) =>+ ({+ type: ContentTypes.ACTIVITY_LABEL,+ [ContentTypes.ACTIVITY_LABEL]: label,+ activity_label_type: 'phase',+ activity_start_index: 0,+ activity_count: 1,+ pending: false,+ }) as unknown as TMessageContentParts;++ const tool = {+ type: ContentTypes.TOOL_CALL,+ [ContentTypes.TOOL_CALL]: { id: 'tool-1', name: 'search', args: {}, output: 'one' },+ } as unknown as TMessageContentParts;++ const { rerender } = render(+ <ContentParts {...baseProps} messageId="sibling-a" content={[tool, phase('First')]} />,+ );+ expect(screen.getByTestId('activity-phase-group')).toHaveAttribute(+ 'data-animate-entrance',+ 'false',+ );++ /** MultiMessage swaps siblings without a key, so this instance keeps its+ * refs while messageId and content change wholesale. The incoming+ * sibling's phase is history and must not animate. */+ rerender(+ <ContentParts {...baseProps} messageId="sibling-b" content={[tool, tool, phase('Second')]} />,+ );++ expect(screen.getByTestId('activity-phase-group')).toHaveAttribute(+ 'data-animate-entrance',+ 'false',+ );+ });});diff --git a/client/src/hooks/Messages/__tests__/useExpandCollapse.spec.tsx b/client/src/hooks/Messages/__tests__/useExpandCollapse.spec.tsxnew file mode 100644index 0000000000..8025bd45b1--- /dev/null+++ b/client/src/hooks/Messages/__tests__/useExpandCollapse.spec.tsx@@ -0,0 +1,70 @@+import { renderHook } from '@testing-library/react';+import useExpandCollapse, {+ EXPAND_TRANSITION,+ REDUCED_MOTION_EXPAND_TRANSITION,+} from '../useExpandCollapse';++function stubReducedMotion(reduce: boolean) {+ window.matchMedia = jest.fn().mockImplementation((query: string) => ({+ matches: query.includes('prefers-reduced-motion') ? reduce : false,+ media: query,+ onchange: null,+ addListener: jest.fn(),+ removeListener: jest.fn(),+ addEventListener: jest.fn(),+ removeEventListener: jest.fn(),+ dispatchEvent: jest.fn(),+ })) as unknown as typeof window.matchMedia;+}++describe('useExpandCollapse', () => {+ const original = window.matchMedia;++ afterEach(() => {+ window.matchMedia = original;+ });++ test('animates the disclosure by default', () => {+ stubReducedMotion(false);++ const { result } = renderHook(() => useExpandCollapse(true));++ expect(result.current.style.transition).toBe(EXPAND_TRANSITION);+ expect(result.current.style.gridTemplateRows).toBe('1fr');+ expect(result.current.style.opacity).toBe(1);+ });++ /** The transition is an inline style, so it cannot carry a media query.+ * Without this the panel still folds over 300ms for a reader who asked+ * the platform for no motion. */+ test('collapses the duration under prefers-reduced-motion', () => {+ stubReducedMotion(true);++ const { result } = renderHook(() => useExpandCollapse(true));++ expect(result.current.style.transition).toBe(REDUCED_MOTION_EXPAND_TRANSITION);+ expect(result.current.style.transition).not.toBe(EXPAND_TRANSITION);+ });++ /** `transition: none` would emit no `transitionend`, and ToolCallGroup+ * waits on that event to unmount a collapsed body. Keeping a real (if+ * imperceptible) transition preserves that completion signal. */+ test('keeps a transition that still emits transitionend', () => {+ stubReducedMotion(true);++ const { result } = renderHook(() => useExpandCollapse(false));++ expect(result.current.style.transition).not.toBe('none');+ expect(result.current.style.transition).toContain('grid-template-rows');+ expect(result.current.style.transition).toContain('opacity');+ });++ test('still collapses to a zero row under reduced motion', () => {+ stubReducedMotion(true);++ const { result } = renderHook(() => useExpandCollapse(false));++ expect(result.current.style.gridTemplateRows).toBe('0fr');+ expect(result.current.style.opacity).toBe(0);+ });+});diff --git a/client/src/hooks/Messages/useExpandCollapse.ts b/client/src/hooks/Messages/useExpandCollapse.tsindex dc298c7f6c..f32ffd80c3 100644--- a/client/src/hooks/Messages/useExpandCollapse.ts+++ b/client/src/hooks/Messages/useExpandCollapse.ts@@ -1,14 +1,32 @@import { useRef, useLayoutEffect, useMemo } from 'react';+import { useMediaQuery } from '@librechat/client';import type { CSSProperties } from 'react';export const EXPAND_TRANSITION ='grid-template-rows 0.3s cubic-bezier(0.16, 1, 0.3, 1), opacity 0.3s cubic-bezier(0.16, 1, 0.3, 1)';+/**+ * Reduced motion shortens the duration instead of removing the transition.+ * `transition: none` emits no `transitionend`, and consumers wait on that+ * event to unmount a collapsed subtree — dropping it would leave every closed+ * panel's children mounted for exactly the readers who opted out of motion.+ * 0.01ms is imperceptible and still fires.+ */+export const REDUCED_MOTION_EXPAND_TRANSITION =+ 'grid-template-rows 0.01ms linear, opacity 0.01ms linear';++/**+ * The disclosure motion is an inline style, so it cannot carry a+ * `prefers-reduced-motion` media query the way a utility class can. Resolve+ * the preference here instead and drop the transition outright — every+ * expanding panel in the message content shares this hook.+ */export default function useExpandCollapse(isExpanded: boolean): {style: CSSProperties;ref: React.RefObject<HTMLDivElement>;} {const ref = useRef<HTMLDivElement>(null);+ const reducedMotion = useMediaQuery('(prefers-reduced-motion: reduce)');useLayoutEffect(() => {const el = ref.current;@@ -27,10 +45,10 @@ export default function useExpandCollapse(isExpanded: boolean): {() => ({display: 'grid',gridTemplateRows: isExpanded ? '1fr' : '0fr',- transition: EXPAND_TRANSITION,+ transition: reducedMotion ? REDUCED_MOTION_EXPAND_TRANSITION : EXPAND_TRANSITION,opacity: isExpanded ? 1 : 0,}),- [isExpanded],+ [isExpanded, reducedMotion],);return { style, ref };diff --git a/e2e/specs/mock/activity-phases.spec.ts b/e2e/specs/mock/activity-phases.spec.tsindex fe70d04708..23b77f1e4d 100644--- a/e2e/specs/mock/activity-phases.spec.ts+++ b/e2e/specs/mock/activity-phases.spec.ts@@ -214,7 +214,7 @@ test.describe('parent activity phases', () => {const finalTextIndex = content.findIndex((part) => contentPartText(part).includes(finalText));expect(finalTextIndex).toBe(phasePart?.activity_end_index);- const parent = messagesView(page).locator(`summary[aria-label="${PARENT_LABEL}"]`);+ const parent = messagesView(page).getByRole('button', { name: PARENT_LABEL, exact: true });await expect(parent).toBeVisible({ timeout: 30000 });await expect(messagesView(page).getByText(finalText)).toBeVisible({ timeout: 30000 });await parent.click();@@ -241,7 +241,10 @@ test.describe('parent activity phases', () => {).toBe(true);await page.reload();- const reloadedParent = messagesView(page).locator(`summary[aria-label="${PARENT_LABEL}"]`);+ const reloadedParent = messagesView(page).getByRole('button', {+ name: PARENT_LABEL,+ exact: true,+ });await expect(reloadedParent).toBeVisible({ timeout: 30000 });await expect(messagesView(page).getByText(finalText)).toBeVisible();await reloadedParent.click();diff --git a/packages/client/src/hooks/__tests__/useMediaQuery.spec.tsx b/packages/client/src/hooks/__tests__/useMediaQuery.spec.tsxnew file mode 100644index 0000000000..1f775d3396--- /dev/null+++ b/packages/client/src/hooks/__tests__/useMediaQuery.spec.tsx@@ -0,0 +1,66 @@+import { renderHook, act } from '@testing-library/react';+import useMediaQuery from '../useMediaQuery';++type Listener = () => void;++/** The shared setup installs a writable (not configurable) `matchMedia`, so+ * these stubs assign over it rather than redefining the property. */+function stubMatchMedia(matches: boolean) {+ const listeners = new Set<Listener>();+ const media = {+ matches,+ addEventListener: (_event: string, listener: Listener) => listeners.add(listener),+ removeEventListener: (_event: string, listener: Listener) => listeners.delete(listener),+ };+ window.matchMedia = jest.fn(() => media) as unknown as typeof window.matchMedia;+ return (next: boolean) => {+ media.matches = next;+ for (const listener of listeners) {+ listener();+ }+ };+}++describe('useMediaQuery', () => {+ const original = window.matchMedia;++ afterEach(() => {+ window.matchMedia = original;+ });++ /** Callers that branch once at mount — freezing an entrance animation,+ * choosing a layout before paint — only ever see the first render. */+ test('reports a match on the first render, before any effect runs', () => {+ stubMatchMedia(true);++ const { result } = renderHook(() => useMediaQuery('(prefers-reduced-motion: reduce)'));++ expect(result.current).toBe(true);+ });++ test('reports no match on the first render when the query does not match', () => {+ stubMatchMedia(false);++ const { result } = renderHook(() => useMediaQuery('(prefers-reduced-motion: reduce)'));++ expect(result.current).toBe(false);+ });++ test('tracks later changes to the query', () => {+ const change = stubMatchMedia(false);+ const { result } = renderHook(() => useMediaQuery('(min-width: 768px)'));+ expect(result.current).toBe(false);++ act(() => change(true));++ expect(result.current).toBe(true);+ });++ test('falls back to no match where matchMedia is unavailable', () => {+ window.matchMedia = undefined as unknown as typeof window.matchMedia;++ const { result } = renderHook(() => useMediaQuery('(min-width: 768px)'));++ expect(result.current).toBe(false);+ });+});diff --git a/packages/client/src/hooks/useMediaQuery.tsx b/packages/client/src/hooks/useMediaQuery.tsxindex 067474c964..1a17617776 100644--- a/packages/client/src/hooks/useMediaQuery.tsx+++ b/packages/client/src/hooks/useMediaQuery.tsx@@ -1,9 +1,25 @@import { useEffect, useState } from 'react';+function readMatches(query: string): boolean {+ if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') {+ return false;+ }+ return window.matchMedia(query).matches;+}++/**+ * Resolves the query on the FIRST render rather than after a passive effect.+ * Callers that branch once at mount — freezing an entrance animation, picking+ * a layout before paint — read the deferred value as "no match" and never see+ * the correction, which is how `prefers-reduced-motion` came to be ignored.+ */export default function useMediaQuery(query: string): boolean {- const [matches, setMatches] = useState(false);+ const [matches, setMatches] = useState(() => readMatches(query));useEffect(() => {+ if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') {+ return;+ }const media = window.matchMedia(query);if (media.matches !== matches) {setMatches(media.matches);