* 🧽 fix: Replace an Abandoned Summary Attempt's Text When Its Retry Streams
Summary deltas append to the in-flight summary part. Once the agents SDK
streams them while the provider is still responding, an attempt that is
then abandoned (a retry, a fallback provider) has already put text in the
part, and the next attempt's deltas would follow it until the completion
event replaced the lot.
A delta may now carry `reset`: the part's content is replaced instead of
extended, and a reset with no content empties it. The part keeps its slot
and stays in flight. Deltas without the field behave as before, so this
is inert until the SDK sends it.
* 🦿 chore: Bump Agents SDK to 4.2.3
4.2.3 dispatches each summary delta while the provider is still responding
and marks the first delta after an abandoned attempt `reset`, which the
chat reducer now honors. It also stops sending reasoning as summary text,
which is where the `incoming.content is not iterable` handler errors
during compaction came from.
The release changed only the SDK's own dev dependencies and overrides, so
the lockfile moves the package's version, URL and integrity and nothing
else.
Add theme-selected welcome backdrops and focus the composer when the welcome greeting settles. Preserve popup and touch-device focus behavior, with acceptance coverage for themes, focus, and composer layout.
- 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 Ask User Question Cards Into the Chat Package
- fix: Preserve Ask Card Styling Without Suppression Growth
- fix: Provide Live Ask Pauses As Scoped Context Data
- test: Cover the Settled Ask Record Collapse Cascade
- fix: Give the Ask Call Spec Host the Tool Call Chrome
* 🫁 fix: Ease Context Usage Popover Size Transitions
Expanding snapped the card to its wide width in one frame; collapsing snapped it narrow first, reflowed the details into one column and made the card taller than it had been before rolling up.
- The popover owns the card width and eases it at the pace of the roll it travels with.
- The details hold the wide card's width through both rolls, so the card uncovers one settled layout.
- The per-tool breakdown and the usage sections roll instead of jumping.
- A press inside the card pins it, so a control that shrinks it from under the pointer no longer closes it.
* 🫁 fix: Restart the Details Width Hold on Every Opening
A collapse reversed midway kept the details mounted with their mount-time hold already spent, so they reflowed to the narrowing card, flashed one column and gave the roll a taller height to snap back from. The hold is now keyed to the open state and restarts with each opening.
A card that opens already expanded resizes nothing, so it no longer holds: with a classic scrollbar on a viewport-capped card the held width could sit across the two-column threshold from the settled one.
---------
Co-authored-by: Lia <lia@librechat.ai>
- 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
* 🎞️ 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
* 🧵 perf: Keep the Composer, Nav Rail and Row Toolbars Out of Every Stream Event
A streamed delta rewrites one row, but each one also re-rendered the composer
form (and re-measured its textarea), the message nav rail (re-translating a
label per message), the sidebar's chat provider and the pending-steers row,
because each subscribed to the whole streaming message or the whole messages
array to read something a delta never changes.
- The chat contract and steering read a projection of the branch tail (where it
sits, whether the run is paused) and fetch the message itself when a turn is
built, through `useBranchTailGetter`. `ChatTurnsParams` carries
`getLatestMessage` in place of `latestMessage`.
- The compact action and pending steers select what they use of the tail.
- The URL-prompt hook observes the history only while a submission waits on it.
- The nav rail's ribs are memoized apart from the rail.
- A row's toolbar keeps one element per glyph and stable handlers, so a send
and its completion no longer re-render every button of every row.
`e2e/benchmarks-fade` gains a render-reason probe (`FADE_PERF_WHY`), a whole-run
profile, and windows for the send and its confirming frame.
* 🫥 perf: Conceal Rerun During a Run Instead of Unmounting It on Every Row
A run starting or ending withholds, then restores, the rerun control on every
row of the thread at once. Unmounting and remounting a button on each row made
the browser re-style the whole transcript both times: the stylesheet holds
`:has(:disabled)` rules and a message row is a `:has()` anchor, so a button
entering, leaving or flipping `disabled` inside a row invalidates that row's
entire subtree. In a 250-message thread that was 80 to 100 ms inside the send
keypress and again inside the final frame.
The control now stays mounted for as long as the row has a rerun to offer and
is concealed by visibility while a run is in flight: no focus, no pointer, no
place in the accessibility tree, and no layout where the toolbar starts at the
row's edge. Below `lg`, where the toolbar is centered, it leaves the flow as
before. It is deliberately not also `disabled`. The reply being written still
mounts no controls at all.
* 🎯 perf: Write :has() Rules So a Change in a Row Does Not Re-style the Row
Two selector shapes in the stylesheet left the browser unable to tell which
elements a `:has()` rule could reach, so it re-styled the whole subtree of
every `:has()` anchor above any change:
- Tailwind's `group-has-[…]`, which compiles to
`.x:is(:where(.group):has(…) *)`. Message rows and their toolbars are
`group`s, so a button mounting or unmounting in a row re-styled the row.
- `theme-disabled-within:[&_*]:…`, which compiles to `…:has(:disabled) *`.
With it in the sheet, a `disabled` flip did the same.
Either one alone was enough: flipping `disabled` on one button per row of a
250-message thread took 100 to 110 ms, and mounting one took 88 ms. A run
starting or ending did one of those on every row.
The row-hover reveal, the header label crossfade and the toolbar's
hover-active hold now use `grouped-*` custom variants that emit
`:where(.group):has(…) .x`: the same elements at the same specificity, with a
subject the browser can read. A wrapper's parts take the disabled fill from
classes the component adds while it is disabled, through `theme-disabled-fill`,
instead of from `:has(:disabled) *`. The same two changes now cost 25 to 42 ms
and 27 ms.
`has-selectors.spec.ts` reads the stylesheet the app ships and fails on either
shape; `restyle.perf.spec.ts` measures the cost.
* 📱 fix: Keep a Concealed Rerun Hidden on Narrow Screens
The narrow-screen stylesheet forces every toolbar button visible from outside
any cascade layer, so it outranked the utilities that conceal a rerun while a
run is in flight: below 1024px the button stayed on screen and in the tab
order, inert. A concealed button now carries `data-concealed`, and that rule
leaves it alone.
Covered at a narrow and a wide viewport by what the reader gets: the settled
reply's rerun is hidden and cannot take focus during a run, and is back after.
* 🧮 perf: Skip the Pause Scan in Pending Steers When None Are Pending
The pending-steers row follows the conversation's messages, so it renders for
every streamed delta, and it resolved the run's pause state before checking
whether it had anything to show. That check walks every part of every message.
It now runs only with a steer to display.
- refactor: Move the Composer Palette Into the Chat Package
- fix: Keep the Palette Usable Without a Windowed List or Catalog Host
- test: Cover Picking Palette Rows With the Mouse
- fix: Leave Palette Keys to IME Composition and Focus to the Field a Press Moved It To
- fix: Localize the Palette Without Its Data Host
- fix: Ship the Composer Popover Motion With the Client Package
- test: Check the Composer Motion Survives the App Cascade
- fix: Offer Palette Favorites Only Where the Host Stores Them
- fix: Name the Palette Favorite Shortcut Only Where It Works
- fix: Leave the Bookmark Shortcut Alone Where the Palette Stores No Favorites
- refactor: Move Attachment and Retrieval Rows Into the Chat Package
- refactor: Drop Dashes From the Moved Attachment Comments
- test: Cover the Moved Attachment and Retrieval Rows
- refactor: Keep the Shared Button on the Attachment Preview Download
- test: Pin the Fold and Settle Motion Against the App Stylesheet
- 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
- refactor: Move Tool Approval Review into the Chat Package
- refactor: Tag the Response Review Tool Batch Spec as a Scenario
- fix: Resume the Composer Review Panel Through the App Host
- refactor: Move the Code Workspace Menu Into the Chat Package
- refactor: Share the Composer Chip Classes From the Chat Package
- test: Provide the Shared Composer Class Helpers to the Workspace Menu Spec
* style: Restyle the Fork Popover and Calm the Feedback Hover
* fix: Follow the Stored Fork Mode and Update the Specs for the New Fork Popover
* test: Find the Fork Options Link by Both of Its Names
* 👁️ fix: Hold the Seen Check's History Refetch While a Run Streams
The seen check revalidates a conversation's history when the list reports a reply that no fetch has shown yet, and it asked for that refetch whenever the messages query was idle, including under a run the pane is attached to.
A resumed run writes its response into the cache from the stream's sync. A refetch that starts after that sync returns the stored row for the same message, and the cache takes it because both lists are the same length, so the live response is replaced by what was persisted when the run began until the stream's next event rewrites it. A manual compaction resumed after a reload shows it for as long as the summarizer takes: its stored row is an empty summary part with no running marker, so "Summarizing..." disappears and nothing stands in for it.
The refetch now waits while a run is in flight. The check already re-runs when the run ends, which is when revalidating is safe.
* 🧪 test: Wait for the Late Subagent File's Stream Before Reading Its Turn as Over
Stop is withheld between a turn's admission and its stream attaching: no generation epoch exists yet for it to stop. The scenario read Stop's absence right after the POST as the end of the turn, then asserted without waiting that its route had injected the late file into that stream. When the check ran inside that interval the stream had not been requested yet, so the assertion failed on a turn that went on to deliver the file.
It now waits for the reply only the stream carries, then for Stop to go.
* 🧷 fix: Promote Unapplied Steers to Durable Queued Turns at Run End
A steer the server accepted (202) but the run never applied was handed back
in FINAL as `pendingSteers` and re-owned by the browser as a tab-local queued
message. A reload, closed tab, or a predecessor race before the drain lost it.
At terminal publication, a normally completed run now promotes such steers
into server-owned agent queued turns (parent: the ended response, epoch: the
ended generation's createdAt, chained behind any turn already queued against
that epoch). The job store hands the parked copy over atomically
(`promoteSteerLeftover`: parked item removed, receipt settled `recovered`), so
status recovery, lost-ACK retries and legacy recovery starts cannot queue the
same words again. FINAL reports the receipts in `promotedSteers`; the client
adopts them as server rows instead of converting the steer locally.
Promotion is opt-in per steer (`promoteLeftover`, sent only by clients that
adopt receipts and only for steers with no tab-only context), so older
clients keep the legacy path unchanged, and older servers simply never
report `promotedSteers`.
* 🔒 fix: Settle a Promoted Steer's Hand-Off at Admission, Not Only at FINAL
The job-store hand-off of a promoted steer now returns an outcome and stamps
the receipt with the owning queued turn, so it is idempotent for that turn.
The queued-turn resolver repeats it before admitting a promoted turn: it
completes a hand-off a crash interrupted, and cancels the turn when the
parked copy was discarded or recovered elsewhere, so the words never run
twice. At FINAL, a row whose hand-off was refused and whose retirement cannot
be confirmed is withheld from `pendingSteers` and left for that admission
check. The conservative reconcile frame keeps `promotedSteers`, and the
client adopts it there before sweeping local chips.
* 🔏 fix: Give Promoted Steers Durable Ownership, Their Run's Queue Lineage and Approval Mode
A turn promoted from an unapplied steer now records its source on its own
row: the steer's ids, the generation that accepted it, and a mark set only
once the job store handed the parked copy to that row. Admission runs a
promoted turn on that mark or on a hand-off the job store confirms now;
without proof (the store's evidence expired, or the host cannot ask) the
turn is held for review instead of running.
- Hand-off replies that are lost no longer cancel the row. The row stays as
the client's handle and its admission settles ownership, so a committed
hand-off can no longer leave the steer with no runnable copy.
- A replayed promotion never hands the parked copy to a row that was
cancelled or failed.
- Promoted turns join the queue lineage of the generation that accepted
the steer, so a sibling still queued behind that run no longer strands
them with a predecessor mismatch.
- The steer request carries the sender's code approval mode onto the
promoted turn; an unreadable mode keeps the steer on the client path.
- A steer whose quotes its owner stripped stays on the client path.
- The queued-turn receipt names the promoted steer by both ids, and the
receipt list retires a pane's local copies even when it missed FINAL.
* 🚧 fix: Fence Promoted Turns to Workers That Prove Steer Ownership
A promoted row without an approval mode was published under the v1 queued
turn capability, so during a rolling deploy a worker that predates the
ownership check could claim it and run an unsettled row while the parked
steer was still recoverable elsewhere.
Promoted rows now publish under a new agent_queued_turn_v3 capability and a
v3 delivery identity, always reserved before insertion. A replica that
projects an older version can neither publish the reserved delivery nor
claim it, and enqueue refuses a promoted row without a reservation.
* 🪦 fix: Keep a Dead Promoted Turn Answering for Words It Held
A pane that learns of a promoted steer from the receipt list dropped the
mapping for every dead row. A row quarantined as ADMISSION_INDETERMINATE can
still settle as admitted, and a row that died after it was proven the sole
owner of the words is their only surface, so in both cases the pane kept a
chip whose recovery could never run.
The receipt now says whether the turn owned its steer's words, and a dead
receipt keeps answering for them when it did or when its admission is
indeterminate. A replayed promotion applies the same rule to a settled row.
* 🧾 fix: Find Promoted Turns by the Steer a Pane Holds, Join Root Lineages, Redact Hand-off Errors
- A promoted turn's request id is now derived from the client steer id, and a
pane asks for the receipts of the steers it still holds a local copy of
(recovery rows and failed chips). A promoted turn that already ran is only
listed when asked for by name, so a pane that missed FINAL now finds it
and retires its copy. A client steer id too long to key a queued turn is
not promoted.
- The lineage lookup includes a generation admitted from a root queued turn,
which has a parent and no epoch. The promoted turn joins that lineage
without an epoch instead of opening a second one.
- A failed hand-off at admission reports a fixed message. The job store's
own error text stays out of the dead-letter record a client can read, and
promotion logs carry safe error metadata instead of error text.
* 🔢 fix: Ask for Held Steers First Under the Receipt Lookup Limit
The receipt list answers for at most 100 request ids, and a pane's server
rows were listed ahead of the steers it still holds, so a full server queue
could push every held steer out of the request. A promoted turn that had
already run was then never found.
Held steers now come first. An active server row is listed whether or not
it is asked for, while a settled promoted turn is found only by name.
* fix: Bound Generation Status Reads So a Silent Request Cannot Strand the Pane
* test: Cover Status Reads That Never Answer Across Terminal, Error and Foreground Paths
* test: Match Scenario Replies Exactly
* refactor: Move Part Helpers and activityLabels Into the Chat Package
activityLabels moves to packages/chat/src/core/parts and exports from
@librechat/chat. useLazyCollapseBody, useProgress and useThrottledValue move
to packages/chat/src/react/parts (@librechat/chat/react). useExpandCollapse,
CopyButton, ActionButton, LangIcon and its icon paths move to
packages/chat/src/components/parts (@librechat/chat/components), since they
read @librechat/client. Specs move with them, client importers and mocks point
at the package entries, and design-lint suppressions follow the moved files.
The fold-type set in activityLabels is built on first use so the module reads
no data-provider enum at load, with a spec pinning its members.
* test: Point the About Spec's Localize Mock at the Package's Copy Button
* chore: Retest Against Current Dev
* 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: Move the Queued Follow-Up Row Into @librechat/chat
The package owns which queued turn is drawn, when it follows the reader to the end of the thread, and where the composer's queued actions attach. The app keeps who sent it, their icon and how the text reads, passed in as props.
* test: Tag the Queued Follow-Up Row Scenario
The spec already drives the queued turn through its reveal and handoff in the browser; the tag lets the gate record it as evidence for the row the package now draws.
* chore: Retest Against Current Dev
* test: Keep Jotai's Real Exports in the Search Route Spec
PendingTurn now ships from the package components entry, which loads the steer rows and the pane submission atom at import. The spec replaced the whole jotai module with useAtomValue alone, so atom() was undefined and the suite failed to load.
* refactor: Move Conversation Starters Into @librechat/chat With a Starter Button Variant
The welcome screen's suggested first messages render through a package component built on a new starter Button variant instead of a raw button. The app keeps resolving which starters apply (agent, spec, assistant) and sends the chosen text.
* test: Pin the Starter Variant Under the ClickHouse Reference Theme
A starter takes its fill and ink from the theme roles in light and dark, so a theme that repaints the surface repaints the chip.
* fix: Cap the Starter Width at the Call Site, Not in the Button Variant
The Button primitive spec rejects fixed sizes in the variant recipe, so the 16rem cap moves to the package component that lays the chips out.
* fix: Keep the Starter Stagger Ahead of the Unlayered Fade Rule
The unlayered fade-in rule sets the animation shorthand, which resets the delay and fill mode a layered utility sets, so every chip animated at once. The variant now declares the whole animation in one utility, and the cap scenario asserts the computed delay and fill mode.
* fix: Ship the Starter Fade From the Shared Tailwind Preset
The starter variant referenced a keyframe that only the app stylesheet defines, so a host using the published preset would get no entrance. The keyframe and its staggered animation now live in the preset next to the loading dots, and the variant uses the animate-starter-in utility.
* chore: Retest Against Current Dev
* refactor: Move the Attachment Row Into @librechat/chat Behind the Files Host
* test: Cover the Attachment Row Against a Fake Files Host
* test: Run the Files Host Deletion Against the Real Hooks and Mock Only the Service Call
* test: Drive the Fallback Deletion Through the Real File Card
* test: Run the Row's Host Cases Against the Real Thumbnail and File Card
* test: Read the Host Preview From the Thumbnail Image Source
* chore: Retest Against Current Dev
* refactor: Move the Scroll Button Into @librechat/chat
* refactor: Make the Package Scroll Button the Message List Default
* test: Pin the Scroll Control Fade and Its Reduced-Motion Path
* fix: Drop the Scroll Control's IntersectionObserver Guard
The observer starts in an effect, which never runs in a server render, and every browser has the API. The guard existed only for jsdom, which now gets an inert observer from the package's jest setup.
* chore: Retest Against Current Dev
* refactor: Retire Host Tool Outcome, Sibling and Approval Members
The package now owns the tool outcome rules and the attachment merge they
read, selects the visible sibling through its own atom, and derives the steer
path's code approval mode from raw inputs. ChatHost loses getMappingOptions and
useSetSiblingIdx; SteerHost.useCodeApprovalMode becomes useCodeApprovalInputs.
* refactor: Select the Branch Tail Inside @librechat/chat
The tail of the branch on screen becomes package logic, read through
useBranchTail. ChatHost loses useLatestMessage and useLatestMessageId;
SteerHost.useLatestMessage becomes the useRouteConversationId adapter.
* test: Exercise Steering Against a Real Message Cache
The steering spec mocked React Query to return one message list for every key, so
it could not notice a read of another conversation's cache or a tail that stops
following the cache. It now provides a real QueryClient, seeds each conversation
key, and covers the route and another chat holding different tails and a cache
that hydrates after mount.
* refactor: Read the Thread Panel's Jotai State Through the Chat Surface
* refactor: Move the Subagent Thread Panel Into @librechat/chat
* test: Spec the Subagent Thread Panel Against Fake Hosts
* test: Cover the App Subagents Host Adapters the Panel Move Relies On
* fix: Style the Moved Subagent Panel With Shared Variants
* test: Pin the Shared Variants the Panel Draws Its Picker and Inline Actions With
* perf: Keep the Subagent Thread Panel Out of the Boot Bundle
* refactor: Add the Thread Panel's Reads, Writes and Layout to the Subagents Host
* refactor: Read the Subagent Thread Panel's App Capabilities Through the Subagents Host
* fix: Hand the Thread Panel the Query's Own Stable Refetch
* refactor: Read Subagent Conversation Data Through the Subagents Host
* refactor: Move Subagent Conversation and Shared Activity Dialog Into @librechat/chat
* test: Spec the Subagent Conversation and Shared Dialog Against Fake Hosts
* fix: Keep the Panel Selection Atom Out of the Components Entry
* test: Open a Shared Child Run in Its Activity Dialog
* fix: Style the Moved Subagent Dialog With Variants and Static Classes
* test: Pin That a Shared Child Run Card Stays Closed
* chore: Retest Against Current Dev
* refactor: Derive a Send's Code Decision Inside @librechat/chat
TurnServices.resolveCode computed the code workspace and approval a send
carries in the app. It becomes readCodeInputs, a storage read of the raw values,
and the package derives the decision through resolveTurnCode. The read goes
through a ref updated each render, so a captured adapter still reads the newest
render's values.
* test: Close Mocked Readers Over Each Render in the Freshness Spec
* test: Close the Mobile Drawer Through the Race-Tolerant Helper in Two Agent Specs
Two specs closed the drawer after selecting an agent with a bare click on
Close sidebar. The drawer closes itself as the selection lands, so the click
waited on a button that stopped being visible and ran into the 120 s test
timeout on phones. closeMobileDrawer, which #17764 added for this, handles that
race and keeps the inert check.
* 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.
* fix: Let Native Azure Deployments Declare Their Reasoning Efforts
The composer effort control needs explicit capability evidence on Azure,
because a deployment name does not identify its model, but the native
Azure config had no way to supply any, so the control could never appear.
Add an optional per-model reasoningEfforts list to Azure groups. The
endpoints config serves only model names and efforts, and the composer,
the submit check and the server override validation all resolve them
through getReasoningParamDefinitions. Undeclared deployments stay without
a control and model spec locks still apply.
* test: Assert Auto as the Reset Button in the Azure Effort Scenario
* test: Ignore Looping Animations When the Memory Alert Settles
The spec waited for every animation in the document to finish. A looping one
never does, so it hung whenever earlier specs in its shard left a chat list
long enough to show pulsing skeleton rows. Adding any spec can move it there:
the shard planner places it in shard 9 instead of 6 with this branch.
* refactor: Move the Context Usage Popover Pieces Into @librechat/chat
* test: Cover the Context Usage Pieces in the Chat Package
* fix: Ship the Collapsible Animations With the Shared Tailwind Preset
* test: Keep the Expanded Breakdown Choice Across Remounts
* test: Assert the Absent Compaction Hint by Its Fixed Copy
* refactor: Give Collapsible and HoverCard the Breakdown Disclosure Styles
* test: Cover the Breakdown Roll and Remembered Choice in the Browser
* chore: Retest Against Current Dev
* refactor: Move the Messages View Provider Into @librechat/chat
* refactor: Render the Package Message List by Default in ChatScreen
* fix: Drop the Rail's IntersectionObserver Guard for a Package Spec Stub
Nothing renders the rail without a browser: its observer starts in an effect, which never runs in a server render. The guard existed only because jsdom lacks the API, so jsdom now gets inert observers and matchMedia from the package's jest setup, and the spec's own stubs, which no longer matched the DOM lib's IntersectionObserver type, are gone.
* test: Scroll a Sidebar Row Into View Before Dragging It
A row under the fold has no pixel the mouse can press, so the drag selected text instead. Whether a run hit it depended on which earlier specs shared its shard and left chats in the Running and Finished sections.
* test: Give the Client Specs an Inert IntersectionObserver
With the rail's guard gone, a client spec that renders the message list reaches the observer jsdom lacks. The shared setup provides an inert one, as the package's jest setup does, and the child-thread spec's partial client mock gains the rem scale hook the rail reads.
* chore: Retest Against Current Dev
* test: Give the Test Messages Host the Row Hook Members
The messages host gained the assistant, added-conversation, streamed-attachment and feedback hooks when the row hooks moved into the package, so the shared test host supplies them too.
* 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
* 💬 feat: Show Ask-User Questions Inline in the Chat Instead of Over the Composer
A live ask_user_question pause now starts in its chat card, in thread order and at the thread's width, instead of a popover over the composer that covered most of the screen on phones. The card's chevron still moves a question into the composer popover, and the popover's chevron moves it back.
The shared atom flips from the questions moved to the chat (collapsedAskActionsAtom) to the questions moved to the composer (expandedAskActionsAtom), so the card is the default surface.
* 🔁 fix: Restore Saved Ask Answers in the Inline Card and Focus a Batch Only on Screen
A pending single question's answer is saved under its own draft key, which autosave restores only into the composer. With the chat card as the default surface, a reload showed an empty answer there; the card now reads that saved draft when no in-memory answer exists.
A batch arriving below a reader who has scrolled up took focus on a control out of view. Arrival focus now waits for the step to be on screen (re-measured against the viewport and scroll containers on each IntersectionObserver notification), and still only takes focus when focus is idle. The visibility measurement moves from Thinking.tsx to utils/viewport.ts so both share it.
* 🧷 fix: Keep a Restored Ask Answer When Draft Saving Is Turned Off
The answer restored from a pending question's saved draft lived only in the render-time fallback, so turning Save drafts off while the card was open recomputed it to empty and cleared the visible answer. It is now copied into the in-memory answers once restored, so later preference changes leave it in place, as they do for the composer.
* 🎯 fix: Clear Answered Ask Drafts and Focus the Popover on Handoff
A pending single question's answer is saved under its own draft key. Answered from the composer, autosave cleared it along with the composer; answered from the chat card, which is now the default, nothing cleared it, so every answered question left its text in localStorage. The key is now cleared as soon as the answer is accepted (even after navigating away) and when the question expires, so a saved answer lives exactly as long as its question.
Moving a question from the card into the composer left focus on the card's now-removed button. A single question now focuses the draft, its answer box, and a batch focuses its active step through a new focusOnHandoff prop that is not limited to the first arrival.
* ⌨️ fix: Focus a Single Question on Arrival and Always Focus a Batch Handoff
With the popover gone as the default, a single question arrived with no focus cue: keys typed next in the composer went out as an ordinary mid-run message instead of answering it. The single card now takes arrival focus like a batch does, on its first option or else its answer field, once per question, only once it is on screen and only when focus is idle (nowhere, or the empty composer that sent the turn). Both cards share a new useArrivalFocus hook for the on-screen wait.
A batch moved into the composer popover now takes focus unconditionally: the handoff is the user's own action, and Safari leaves focus on the previous owner of a clicked button, which can be the hidden chat card.
The deferred-tools HITL e2e scenario read its terminal line once as soon as it appeared, while the slow echo was still streaming into it; it now waits for the full text.