* 🧱 fix: Bound Attachment Reads and Keep Bedrock's Document Limit
`getFileStream` buffered a stored object in full for every provider and every
kind of attachment, and the Bedrock document limit was `configured ??
provider`. The merged file config always carries a size limit (512 MB by
default), so with any `fileConfig` section Bedrock's 4.5 MB limit never
applied: an 8 MiB CSV was downloaded, decoded and serialized before Bedrock
refused it.
The shared reader takes a byte limit and stops at the first chunk past it. A
Bedrock document is refused from its recorded size before storage is opened,
read under that limit so an object larger than its record cannot reach memory
either, and reported as a 413 attachment error. A configured limit can lower
Bedrock's limit and no longer raise it.
* fix: Let a Set Limit Override Bedrock's, Keep Replay Tolerant
A limit the operator set overrides Bedrock's own, up or down, as it does for
other providers. What no longer counts is the 512 MB the merge fills in for
every endpoint, which is how the provider limit was lost whenever a
`fileConfig` section existed.
Replayed history skips the recorded-size refusal so an object that is gone is
still reported missing and left out; the bounded read refuses one that is
present. The client shows the size refusal under its attachment-limit
headline, not as a provider failure.
* 🔆 feat: Add GPT-6.2 Sol Support
* test: Correct Sol Request Helper Types
* fix: Apply Sol Constraints at Final Request Boundaries
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🪟 feat: Open a Conversation Beside the Chat From Its Menu
A conversation's menu in the sidebar offers to open it as a side chat
beside the chat on screen. The item appears only where there is a chat
to sit beside and side chats are on, and not for the chat on screen or
an archived one. The conversation's full record is read first, since a
side chat builds its turns from it.
* 🪟 fix: Give a Side Chat the Panel Slot It Was Asked For, Beside the Chat It Was Asked Beside
A side chat opened while an artifact or a child's activity is showing
now takes their place, as each of them takes its. A record lookup that
finishes after the reader has moved to another chat, or to the very
conversation asked for, opens nothing.
* 🪟 fix: Let the Newest Side Chat Request Win, and Test the Real Menu
An older Open beside chat whose record arrives late no longer replaces
the reader's newer choice, or a side chat opened another way meanwhile.
The item's tests now drive the production menu, hooks and strings, and
replace only the request for the conversation's record.
* 🪟 fix: Withdraw a Pending Side Chat for a Newer Panel, and Open It Clear of the Drawer
A side chat still being fetched no longer arrives over an artifact or a
child's activity opened after it was asked for. On a small screen the
sidebar drawer leaves first, the way it does when a conversation is
selected, so the side chat is not opened behind it. Once its
conversation is in, focus moves to its composer.
* 🪟 fix: Ask Again Whether a Side Chat Is Still Wanted Once the Drawer Has Left
The drawer takes a few frames to leave, and the checks that a side chat
was still the reader's newest ask ran before that. The request now
stays theirs until the side chat is written, and is asked about again
at that point.
* 🧪 test: Answer the Real Config Query in the Presentation's Side Chat Tests
* 🗝️ feat: Store an API Key's MCP Grants on the Key, One per Agent
* 🧬 refactor: Let the Consent Service and Enforcement Act for Any Grant Subject
* 🗝️ feat: Check an API Key Run's MCP Calls Against the Key's Grant for the Agent
* 🗝️ feat: Put Remote API Runs Under Their Key's Grant, Behind a Config Switch
* 🩹 fix: Export the Key Grant Storage the Server Wiring Loads
* 🔌 feat: Let an Owner Grant an API Key Its MCP Access From Settings
* 🗝️ fix: Decide Key Grant Access, Mode and Kind of Key in the TypeScript Host
The agent-access check and the grant-mode lookup lived in the legacy route and service
files. The host now builds the check from an injected agent reader and permission
reader, and the key handlers resolve the mode from an injected configuration reader.
Each authorized call read the owner three times and their configuration twice. The host
now reads both once per call and shares them between the access check, the limits and
the offer; nothing is kept between calls.
A background worker rebuilds its request from the admitted record, which names the key
but not its kind, so a key issued to an integration lost its exemption and its channel
runs were refused. The host asks the key store when the request carries no key itself.
* 🔌 fix: Say When a Key Grant's Agent List Is Loading, Failed or Empty
The key grant dialog turned a failed or pending agent list into an empty picker with an
instruction to choose from it. It now shows a spinner while the list loads, an error
with a retry when it could not be read and nothing is cached, and a plain statement when
the owner has no agent the key could run.
* 🧪 test: Hold the Pin Fences on an API Key's Per-Agent Grants
* 🔌 fix: Offer a Key Grant for the Agents the Key Can Run, and Only for Personal Keys
The grant dialog's picker read the app's agent catalog, which lists agents the owner can
view. Running an agent with a key follows another rule: the agent is shared with the
owner for remote use, or is theirs to share. An agent shared only for remote use could be
run but not granted. A new list, GET /api/api-keys/agents, applies that rule to all
agents, and the picker reads it.
A key issued to an integration holds no grants but showed the MCP access button. The key
list now marks such a key, and the button is not shown for it.
* 🙋 feat: Let a Schedule's Owner Approve a Tool Before Each Use
* 🧪 test: Drive a Real Run Through a Schedule's Approval Pause and Resume
* 🙋 fix: Keep a Stored Ask-First Choice When a Run Can No Longer Pause
Where pausing became unavailable, the dialog hid the ask-first boxes and renewed the
grant without them, so a tool the owner approved each time started running unattended.
The dialog now starts from the stored choice either way and always sends it. Where a run
cannot pause it shows only the stored questions, with a note that those tools are refused
for now, and the owner can keep or drop them but add none. The server keeps the stored
questions for tools still allowed when a confirmation says nothing about asking, and
refuses only a new question where a run cannot pause.
* 🙋 fix: Say Why a Schedule Asks for Approval in the Reader's Language
The approval card showed an English sentence sent by the server as the request's
description. The server now sends a code, and the card maps it to a localized string.
Any other description is shown as sent.
* 🙋 fix: Never Offer Always Allow for a Tool a Schedule Asks About Each Use
Where the endpoint enables Always allow, a schedule's approval card offered it for a tool
the owner approves on each use. Choosing it stored a conversation allow the schedule
still overrode at the next use. The offer and the recheck at resume now take a predicate
for anything beyond the policy that asks on every use, and the schedule's grant supplies
it, so such a tool is neither offered nor stored.
* 🙋 fix: Let the Owner Ask First About as Many Tools as They Can Allow
The confirmation accepted up to 25,600 allowed tools per server but only 256 to ask
about, so a large grant could not be confirmed with every tool set to ask first.
* 🙋 fix: Keep a Tool Asking First When the Owner Allows Its Changed Definition
The dialog derived the ask-first boxes from the ticked tools. A tool whose definition
changed starts unticked, so its stored question was dropped, and ticking the tool again
confirmed it as unattended. The ask-first selection is now kept apart from the ticks,
starts from the stored grant, and is narrowed to the ticked tools only when the
confirmation is sent. The owner's edits to it hold only for the grant they were made
against, so a question added to a grant confirmed elsewhere is not dropped unseen.
* 🪟 feat: Continue a Subagent's Thread as a Chat Beside the Conversation
* 🪟 fix: Take a Side Chat's Streamed Attachments Where Main Chat's Go
What a tool hands back while a side chat's generation runs (search
sources, a generated file) reached no handler, so it was missing from
the rows and from the app's file, memory and preview caches. The side
chat's stream now uses the app's attachment handler.
* 📜 fix: Read a Child Thread's Messages a Page at a Time
The child messages route read a thread's whole stored history, and a
card previewing a running child triggers that read without anyone
asking. Every read is now one page (50 rows or 2 MiB, newest first)
with a cursor for the page before it, the followed pane keeps the pages
it has read and offers the earlier ones, and a client or server that
predates paging still gets a list.
* 📜 fix: Start a New Follower From Its Own Newest Page
A follower recreated over rows another one left in the cache kept them
without knowing where they began, so the earlier-messages control was
gone. It now places its first page itself and takes that page's
cursor.
* 📌 feat: Pin an Allowed Schedule Tool to the Definition It First Ran With
* 📌 fix: Bind a Confirmation to the Changed Tools the Owner Was Shown
* 📌 fix: Untick a Tool Marked as Changed While the Owner Is Choosing
The dialog reads the offer again while it is open. A tool marked as changed after the
owner's last tick kept its tick, so confirming would have allowed the new definition
without the warning having been in view when the box was ticked. The edit now records
which tools were marked when it was made, and a tool marked since then is unticked
until the owner ticks it again.
* 📌 fix: Check Pins and Marks in the Writes That Admit, Confirm and Revoke
A use read the grant, then was admitted by a write that looked at neither the marks nor
the pins. A mark or a first pin stored in between did not stop it. Admission now carries
the definitions in use and refuses, in the same write, a tool that is marked or pinned to
another digest. A use refused this way marks the tool when the stored pin disagrees with
what it saw.
A confirmation and a revocation replace the grant whole, built from an earlier read. A
pin or mark a run added in between was dropped, so the next use could pin a different
definition unnoticed. Both writes now refuse when either list has grown since the read:
the confirmation reports the offer as changed, and the revocation reads again.
* 📌 fix: Tie a Tick on a Changed Tool to the Grant That Marked It
The dialog remembered which tools were marked when the owner last ticked a box, by name
only. If the grant was replaced elsewhere and a run marked the same tool again, the old
tick stood and confirming accepted a change the owner had not looked at. The edit now
records the grant revision, and a tool marked under another revision is unticked until
the owner ticks it again.
* 🪟 feat: Show a Running Subagent's Current Row on Its Card
* 🪟 fix: Draw the Card's Row Live and Skip Label Reservations That Draw Nothing
* 🪟 fix: Show a Card's Row Only While Its Thread Is Followed, and Throttle a Detached Row Too
* 🪟 chore: Sort the Card Spec's Imports
* 🪟 fix: Draw the Card's Row as a Picture That Registers, Claims and Reveals Nothing
* 🪟 test: Give the Artifact Preview Test the Props Its Type Requires
* 🪟 refactor: Keep the Shared Follower Registry in Provider-Scoped Jotai Atoms
* 👀 fix: Look Again for a Run the Caller Knows Of Before Taking It to Have No Stream
* 🗳️ feat: Let a Schedule's Owner Choose Which MCP Tools It May Use
An enrolled scheduled chat could call an MCP tool only when an operator had
listed it in config as read-only, pinned to a hash of its definition. Whether
a tool is safe to run with nobody watching is the owner's call, and read-only
is a poor proxy for it.
The consent offer now lists every MCP tool the agent graph selects on servers
whose recipient the operator declared. The owner ticks servers and tools, and
the grant stores only those. A tool is allowed at run time when the grant
lists it for the calling agent and that agent still selects it; anything else
is refused. Selecting another tool later no longer invalidates the grant.
The operator `mcpConsent.readOnlyPolicy` list is retired: the loader warns
when it is still configured. The stored grant keeps its shape.
* 🗳️ fix: Check the Server Box Only When Every Tool Is Allowed
The shared Checkbox has no partly-selected appearance, so a server with some
tools ticked showed its "allow all" box as checked.
* 🧪 test: Check the Live Catalog at the Manager Boundary Without the Retired Pin
* 🧭 fix: Check Readiness Against What the Owner Allowed, Not What the Agents Select
* 🧭 fix: Turn Away a Tool the Owner Left Out Without Failing the Run
* 🧭 fix: Load Only the MCP Tools the Owner Allowed in a Scheduled Run
* 🧵 feat: Open a Background Subagent's Thread as a Conversation in the Panel
* 🧵 test: Keep the Subagents Host Spec and Add the Follow Cases Beside It
* 🧵 fix: Give the Followed Thread Its Panel Gutter and Assert It in the Browser Specs
* 🧵 test: Do Not Wait on a History Fold That Closed Before It Was Clicked
* 🧵 test: Draw a Steer the Child Took Before the Panel Opened Where It Was Taken
* 🧵 fix: Fall Back to the Durable View Only on a Confirmed Missing Stream or History
* ↩️ feat: Show Guidance a Followed Subagent Has Not Taken Yet, With Its Withdraw
* 🗓️ feat: Align Balance Resets to Fixed Calendar Boundaries
Add balance.refillAnchor, an ISO timestamp with a fixed offset that periods align to: a refill or reset is due at the first anchor-plus-whole-intervals boundary after the last one, so every user resets at the same moment (e.g. each Monday at 00:00 UTC, or the 1st of each month). Omitted, periods keep running from each user's last refill. The gauge names the reset date for anchored periods.
* 🧭 fix: Clear a Removed Reset Anchor During Admission and Shape Balance Responses in TS
A policy built without a record now always carries refillAnchor, null when unset, so removing the setting clears a stored anchor instead of looping admission until its retry bound throws. Balance response shaping moves to toBalanceResponse in packages/api; the CJS controller delegates to it.
* feat: Add Gemini Hydrogen Model Support
* fix: Restore Google History For Reachable Agents
* fix: Preserve Mixed Google Signature History
* refactor: Inject Google billing configuration at application boundary
* fix: Preserve Call Signatures From Unsupported Google Output
* chore: Use Released Agents SDK 4.2.5
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🪟 perf: Skip Thread Rows Far From the Viewport
Opening or closing the sidebar beside a long thread laid out and painted
every row of it on every frame of the 300 ms slide, because the slide
changes the chat pane's width. In a 246-row thread that was 17 ms of main
thread per frame, 55 ms on a CPU four times slower, where the slide ran at
about a dozen frames a second with tasks over 100 ms.
A row more than a screen from the thread's viewport is now skipped by the
browser (`content-visibility: auto`), so a change that touches the whole
thread costs only the rows near the reader. Rows within a screen are left
exactly as they were: none of them gains the clipping and containment that
skipping implies. A skipped row keeps the size it was last laid out at, so
the scrollbar, the navigation rail and the mount anchor see the same
thread, and it stays reachable by find-in-page, focus and anchors.
The skip sits on the row element the rail and the mount anchor measure:
reading the box of an element inside a skipped row makes the browser lay
that row out again. Screenshot export lays every row out before it clones
the thread, since a clone has no remembered size.
The navigation rail measured every row on each frame of a width change.
It now waits for the width to hold still and measures once; a height
change, which is what a streaming reply is, is still followed frame by
frame. Alone that saved nothing, because its reads forced a layout the
frame needed anyway; with rows skipped it is a fifth of what remains.
* 🧮 fix: Keep Rows Laid Out Until Every Overlapping Capture Is Done
`revealOffscreenRows` handed each caller the thread's `watch` function as
its resume. Two captures that overlap (a second screenshot export started
before the first finished) each got one: the first to finish resumed
skipping while the second was still cloning the thread, and the second
then created another observer without disconnecting the first, which no
cleanup released. A resume called after the thread had unmounted created
an observer for a thread that was gone.
Each thread now counts its outstanding reveals. Skipping resumes when the
last one is done, a resume counts once however often it is called, and
does nothing once the thread has unmounted.
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.
Move grouped tool rows and compact reasoning into the props-only ToolGroupBody component in @librechat/chat, retaining app-owned expansion, approval lifetime and attachment behavior.
Select mock model options by exact descendant text so mobile Pin controls do not change the match.
Related to berry-13/LibreChat#463.
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.
Each assistant row mounts a hidden `<audio autoplay>` for its read-aloud
button and passed it `src={audioRef.current?.src}`. An element with no
source reports `''`, so the row's second render wrote an empty `src`, and
its third wrote that back as the document's base URL. Both start a media
load: the first fails at once, the second fetches the app's HTML and fails
to decode it. A thread of 250 rows did that twice per row each time the
thread was opened and a run began.
The player assigns the source itself when speech starts, so the prop
carried nothing. Without it React never touches the attribute.
The live-run benchmarks ran with read-aloud off and so never mounted these
elements. They now leave it on, as the app does, and `speech.perf.spec.ts`
counts the media errors and requests the rows make.
- 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
* perf: Load Search, Share, Trace and Composer Popovers on Demand
The search, share, response-review and marketplace routes, the trace
viewer and the composer's popovers (mention, prompts, skills, ask, tool
dialogs, code approval and workspace menus) were statically imported by
the chat, so every visit downloaded them, and the search and share routes
pulled most of the message renderer into boot. Routes load through route
loaders, the trace viewer behind a loading state, and the composer
pieces under null Suspense boundaries, since they render nothing until
triggered.
* test: Cover Surfaces That Load on Demand
* test: Wait for the Composer Popovers Instead of Network Idle
* fix: Let a Loading Trace Be Closed
While the trace viewer's chunk downloaded, its fallback covered an inert
chat with no way out: the close button and Escape live in the viewer.
The fallback now keeps the viewer's header with a focused close button
and dismisses on Escape.
* test: Close a Trace Whose Download Stalls
* fix: Return Focus to the Trace Opener Across the Loading State
The loading fallback took focus before the viewer mounted, so the viewer
recorded the fallback as its opener and closing left focus on the page.
The surface now records the opener when the trace opens, passes it to
the viewer and returns focus there when either closes.
* test: Assert Focus Returns to the Trace Button
* fix: Hold the Viewer Theme Back While a Shared Link's Code Loads