Move the existing streaming fade engine into @librechat/chat and its waiting-dot, cursor and fade styles into the shared client stylesheet.
Use the effective host smoothing policy consistently in Markdown, including nested subagent content, while preserving optional renderer callbacks and raw fallback behavior.
- refactor: Move Reasoning Parts into the Chat Package
- fix: Lay Out the Web Search Details Button as a Flex Item
- test: Cover Part Disclosures and the Styles They Ship With
- test: Cover a Consumer Opening a Thought With the Package Styles
- fix: Size the Web Search Row Button by Its Content
- test: Hold the Part Motion and Peek Fade to Their Old Inline Styles
- refactor: Move the Tool Call Card Into the Chat Package
- test: Render Tool Calls Through the App Host
- fix: Keep the Tool Call OAuth Bind Stable Across Catalog Updates
- refactor: Render Pending Turn and Steers from the Package
- refactor: Keep Package Pending Rows Inert Without a Steer Host
- fix: Read the Host Thread Mode on Every Render
- fix: Point the Hosts Guard at the Messages Loader
- fix: Follow the Moved Pending Rows in the Guard and Lazy Chunk Specs
- fix: Ship Message Body Typography With the Shared Theme Styles
- fix: Keep the App Message Typography Cascade With the Shared Styles
* 🎞️ perf: Run the In-Flight Label Sweep on the Compositor
The sweep on a running tool call, streaming reasoning and the elapsed timer
animated `background-position` under `background-clip: text`, which no
browser can hand to the compositor. Every frame of it ran style, paint and
commit on the main thread, and each paint walked the transcript around the
label, so the cost of a frame grew with the conversation and the sweep
stuttered whenever the main thread was busy.
`Shimmer` in `@librechat/client` draws the same sweep from two transforms
that cancel: a masked band slides across the label while a second copy of the
text inside it slides back, so the glyphs hold still and only the gap in the
mask moves. The copy is generated content, so the label is still one text
node. Every in-flight label renders through it.
`e2e/benchmarks-fade` measures a frame and each kind of stream event inside
an exported conversation, from a Chromium trace of the built client.
* 🧪 test: Let the Frame Benchmark Open a Chat in a Chosen Theme
* fix: Keep the Projects Section Expanded by Default
* fix: Label the Streaming Dot With a Tooltip and an Accessible Name
* fix: Move the Welcome Screen Footer Directly Under the Composer
* fix: Drop the Agent Name From Responses When the Selector Already Shows It
* fix: Align the Sidebar Section Headings With the Date Labels
* feat: Make the Welcome Footer Placement and Response Author Configurable
* fix: Hide the Memories Panel on the Agents Route
* test: Cover the Launch QA Chat Chrome in E2E Scenarios
* test: Assert the Section Heading Padding Merge Without Mocking App Internals
* fix: Read the Response Author Setting Through the Messages Host
* test: Give the Consumer Spec's Messages Host the Author Setting
* refactor: Ship Icon Sizes, Status Type and the Label Sweep From @librechat/client
* test: Prove a Consumer Gets the Shared Part Classes From the Published Stylesheet
* test: Stop Asserting the Blockified Display of the Elapsed Reading
* fix: End the Status Row Type Chain in a Length for Standalone Consumers
* refactor: Move the Message Rows Into @librechat/chat
MessageRender, Message, MessageContent, ContentRender, MessageParts and the thread's ThreadMessage now live in the package, and the thread renders them directly, retiring MessagesHost.renderMessageRow. Pieces owned elsewhere reach the rows through new host slots.
* test: Render the Real Thread Message in the Thread Specs
The thread specs replaced ThreadMessage with a fabricated row, so sibling paging and edit assertions drove the stub. They now render the real row chain with fake hosts and page and edit through its real controls.
* test: Keep a 12,000-Message Chain Covered at the Row Resolver
The thread specs now render real rows, so their large-chain case was cut to 60 messages. The 12,000-message chain, which guards the iterative branch walk and row reuse on a long conversation, moves to the resolver spec where it does not mount every row.
* test: Keep the Child Thread Spec Rendering Real Rows Under the Client Mock
The child-thread spec relied on the test host's renderMessageRow slot to draw nothing. The thread now mounts the package rows directly, so the spec's agents map and client package mocks have to cover them.
* refactor: Move Leaf Content Parts Into the Chat Package
Container, ToolAuthWarning, ToolPreparation, the failed-reveal pill, the fold
rail, the background task guidance keys, MemoryInfo, PendingSkillCall,
ResumeAuthorHeader, DialogImage and ToolCallLimitNotice move from
client/src/components/Chat/Messages/Content to packages/chat/src/components/parts
and export from @librechat/chat/components. Their specs move with them.
Client importers and mocks point at the package entry. Design-lint
suppressions follow the moved files.
* fix: Ship the Tool Row Type Scale With the Component Library
The progress-text rules move from the SPA stylesheet to packages/client/src/theme/parts.css, which ThemeProvider loads into @librechat/client/style.css, so the package's PendingSkillCall row keeps its type size without the app's CSS. The two class names join the no-unknown-classes allow list, and PendingSkillCall needs no suppression.
* test: Check the Tool Row Label Keeps the Chat Type Scale
* test: Find the Tool Row Label Around Its Toggle
* test: Capture the Staged Skill Row in Its Loading State
* fix: End the Tool Row Type Chain in a Length for Standalone Consumers
--font-size-base and --markdown-font-size are declared only in the app's
stylesheet, so the .progress-text-wrapper font-size and line-height were invalid
for a consumer that loads the published theme alone. The chain now ends in
var(--font-size-base, 1rem), and the consumer spec reads the published
stylesheet for it.
* test: Cover the Memory Limit Alert in Both Themes and Modes
* refactor: Move the Message Row Hooks Into @librechat/chat
* test: Point the Live Attachment Scenario at the Moved useAttachments Spec
The scenario ran the client's useAttachments spec by path, which moved into packages/chat with the hook. It now runs the spec from that workspace.
* refactor: Move the Message Navigation Rail Into @librechat/chat
* refactor: Render the Message Navigation Rail From @librechat/chat
* test: Cover the Navigation Rail Jumping Between a Thread's Ends
* refactor: Move Message Scrolling Into @librechat/chat
* refactor: Run Message Scrolling in the Package Message List
* test: Pin the Scroll Throttle's Coalescing Window
* refactor: Move the Assistants Stream Hook into @librechat/chat
* refactor: Stream Assistants Turns Through the Package Legacy Stream
* test: Cover Assistants Send, Stop and Failure Through the Legacy Stream
* test: Give the Test Stream Hosts the Legacy Services Member
* test: Keep the Assistants Failure Case for Its Own Fix
* test: Give the Consumer Spec Host the Legacy Services Member
* feat: Add the Composer Placement Transition Recipe
* refactor: Move the Composer Layout Into the Chat Package
* test: Expect No Refocus on a Coarse Pointer in the Composer Frame Scenario
* fix: Render No Context Rail for a Boolean Slot
* feat: Add a Composer Variant to TextareaAutosize
* refactor: Move the Composer Field and Action Slot Into the Chat Package
* test: Wait for the Collapse Transition in the Composer Field Scenario
* fix: Keep the Composer Touch Font Floor in the Shared Field Stylesheet
* test: Floor a Small Chat Font on the Composer Draft on Touch
* refactor: Render Thread Rows Through MessagesHost Slots
* refactor: Move the Thread Renderers Into @librechat/chat as the Default MessagesView Thread
* test: Verify Sibling Switching, Activity Anchors and Editing on the Package Thread
* refactor: Move HoverButtons into @librechat/chat Behind Thread and Read-Aloud Host Members
* test: Cover HoverButtons Against a Fake Host and the App Read-Aloud Slot
* test: Add Hover Toolbar Scenarios to the Mock Harness
* test: Target the Edit Textarea by Test Id in the Hover Edit Scenario
* fix: Keep Module-Scope Atoms Out of the Components Entry by Reading HoverButtons State Through the Chat Contract and Host
* test: Render the Hover Toolbar Specs Through the Real English Bundle
* refactor: Route Stream Event Handler Effects Through Grouped Host Services
* test: Confirm the Titled Endpoint Pick in the Generated Title Scenario
* test: Give the Subagent Index Test Host the Event Services Member
* test: Give the Consumer Spec Host the Event Services Member
* feat: Derive the Chat Pane's Heading, Footers, Project and Read-Only State in @librechat/chat
* refactor: Lay Out the Chat View Through the Package ChatScreen
* refactor: Move the Subagent Transcript Into @librechat/chat Behind a Subagents Host
SubagentActivity, its scroll surface, content, status and guidance history
move into @librechat/chat/components, and ScrollToBottom moves into the
package with them. A new SubagentsHost carries what still lives in the app:
the content-parts and steer renderers, the animated jump-to-latest control,
and the read of a shortened guidance receipt, which stays an app query. The
prompt preview reuses renderMarkdown with a new codeExecution flag, and the
task content scope becomes a plain package context.
* refactor: Draw Content Parts Through the Message Parts Host
renderContentParts moves from SubagentsHost onto MessagePartsHost as the one
content slot, typed as ContentPartsSlotProps: the transcript fields plus the
optional row fields message rows pass. The app fills it through a registered
renderer, so the host module does not import the content stack, and omitted
row fields keep an assistant reply's defaults.
* refactor: Let the Content Parts Slot Carry Sparse Content
Main message rows keep holes at streaming and parallel indexes, and part indexes depend on those positions, so the slot's content keeps undefined entries as ContentParts already accepts them.
* test: Exercise the Real App Renderers in the Host Registration Spec
The transcript host test now renders the app's ContentParts and SteerPart under the providers they read, so the registered content renderer and steer slot are proven against the real components; only the receipt request stays mocked.
The chat surface context, the durable task panel hook and the event subagent
activity group move into the package. The surface context and read hooks live
apart from the provider that binds the panel atoms, so the components entry
loads no module-scope atom. Share state and the inline agent avatar reach the
package through two new MessagePartsHost members, useShare and
renderAgentAvatar, which the app fills from ShareContext and renderAgentAvatar
with the same options as before.
* refactor: Move Subagent Authors Into @librechat/chat Behind a Message Icon Slot
* fix: Register the Message Parts Host From the App Entry
* test: Give the Consumer Spec's Messages Host the Icon Slot
* refactor: Add a Command Popover with a Host Windowed List Slot
* refactor: Move the Mention Popover Into the Chat Package
* test: Cover the Mention Popover Combobox in the Mock Harness
* style: Draw the Mention Popover Like the Prompts and Skills Popovers
* test: Walk to the Endpoint Row Before Drilling Into Its Models
* test: Drill Into a Plain Custom Endpoint in the Mention Scenario
* refactor: Share the Command Character Helper From the Chat Core
* refactor: Move the MessagesView Root Into @librechat/chat
* fix: Read Submitting State From the Chat Contract and Complete the Test Hosts
* test: Tell the Scroll Control Apart From the Rail's End Marker
* refactor: Move the Fork and Feedback Actions into @librechat/chat
Fork reads the viewer's fork defaults and starts the fork through two new
MessagesHost members, keeping its toasts and rate-limit copy in the package; the
app supplies them from its settings atoms and the fork mutation, whose own
callbacks open the copy so a row that unmounts mid-request still lands there.
Feedback moves as is. @ariakit/react becomes a peer dependency of the package.
* test: Cover Fork and Feedback in the Mock Harness
* chore: Sort MessageRow Spec Imports
* fix: Resolve Fork Labels Per Call and Pin the Fork Toast Locator
* test: Give the Consumer Spec Messages Host the Fork Members
* feat: Add a Minimal Consumer Example for @librechat/chat
A Vite React page under packages/chat/example renders a themed chat from the package's public entries and the @librechat/client theme, with an in-memory transport standing in for the server. Its jsdom smoke test runs in the package's jest suite, the package typecheck covers it, and ESLint keeps it to public imports and semantic theme roles.
* fix: Let Enter Confirm an IME Composition in the Example Composer
* fix: Report a Failed Turn in the Example and Restore Its Text
* fix: Localize the Example Copy and Guard the Safari IME Enter
* fix: Drop a Rejected Turn, Load the Component CSS, and Keep the i18n Instance in the Example Build
* refactor: Replace the Example App With a Public-Entry Consumer Spec
The owner does not want an example app in the repository. packages/chat/test/consumer.spec.tsx keeps what it proved: a chat built only from @librechat/chat, /react, /components and @librechat/client, over an in-memory transport, streams a reply into the message list under the ClickHouse theme. It sits outside src because chat/boundary rejects self-imports there; jest maps the entry names to the sources and the package typecheck covers it. The example app, its Vite, Tailwind and PostCSS config, its lint block, script and dependency lines are removed.
* chore: Declare the Consumer Spec's i18next Dev Dependencies
* chore: Retest Against Current Dev