Commit graph

1769 commits

Author SHA1 Message Date
Danny Avila
5ca1093ed9
🛫 feat: Enable Full Access for BYOM Coding (#15718)
* feat: Enable Full Access for BYOM Coding 🛫

* test: Preserve endpoint policy under Full Access

* fix: Gate Full Access on expected root agent metadata
2026-09-07 22:46:01 -04:00
Danny Avila
6f05678bfc
🧐 feat: Restore Interactive Tool Approval Review (#15717)
* 🧐 feat: Review Pending Tool Actions in the Composer (#15714)

* feat: add interactive approval review to the composer

* fix: Harden interactive approval boundaries

* fix: Bound every approval display label

* test: exercise composer approval review in BYOM acceptance

* fix: reveal all directional approval controls

* fix: canonicalize code approval targets across replicas

* style: sort resumable approval test imports

* test: Exercise Coexisting Approval Surfaces

* Revert "🧐 feat: Review Pending Tool Actions in the Composer (#15714)"

This reverts commit 5f79ded9553405b697e837e1976a70accbfc3fc3.

* Reapply "🧐 feat: Review Pending Tool Actions in the Composer (#15714)"

This reverts commit 52c7d9c7453da0168338bcf79494927f561a92a0.

* chore: bump agents sdk to v3.8.2
2026-09-07 22:02:56 -04:00
Danny Avila
3e2a6f333b
🪗 feat: Compact Context in a Summarize-Only Turn (#15690)
* 🗜️ feat: Manual Context Compaction as a Summarize-Only Turn

Adds a user-triggered "Compact context" action that summarizes the active
branch on demand. The compaction is an ordinary agent turn: the client
submits it through the normal chat pipeline with `compact: true`, the
controller hangs it off the branch's leaf instead of creating a user
message, and the agent client runs the graph summarize-only (the SDK's new
`summarizeOnly` input), so the summary streams into the response
placeholder under the leaf exactly like the automatic detour's and is
persisted as the boundary every later turn starts from.

Nothing new is needed for job registration, billing, abort, persistence,
or the usage snapshot: the run emits the same summary step and post-summary
context snapshot the automatic path already emits, and the response message
carries the summary part plus the `summaryUsedTokens` baseline the gauge
reads. The controller validates the request (existing conversation, a real
leaf, summarization enabled, no edit/regenerate/continue combination) and
answers 409 when the leaf is already a bare summary.

Client-side the submission borrows the regenerate shape — no new user
bubble, the placeholder parents onto the leaf — while the wire payload
drops `isRegenerate` so the server never treats it as a regenerated user
turn. The action sits in the context-usage popover, gated by the same
`summarization.enabled` switch as the automatic detour.

* 🗜️ fix: Localize a Compaction That Cannot Run

A compaction the graph could not attempt (summarization disabled, the
instructions already exceeding the budget, or an explicit recency window
covering the whole conversation) rejects with the SDK's
`ManualSummarizationSkippedError`, which rendered as the generic admin
error. It now maps to a typed `compaction_skipped` payload with the reason,
and a run that ends with neither a summary nor a recorded error fails as
`compaction_failed`; the Error component localizes both. A run that already
recorded why it stopped keeps that error part instead of failing twice.

* 🗜️ fix: Anchor a Compaction on the Leaf Everywhere It Is Read

Review round 1.

- The client sent the leaf's parent as `parentMessageId`, which the
  controller treats as the anchor, so the summary would have skipped the
  latest reply and landed as its sibling. The leaf's own id is now both the
  placeholder's parent and the server-side anchor.
- A compaction has no user message of its own, and every consumer of the
  job's user-message slot now knows it: the error path parents its row on
  the loaded anchor and never upserts the leaf, and the job records the
  regenerate shape so a reconnecting client rebuilds the turn under the
  leaf instead of recreating it as a user message.
- The controller no longer reads the anchor before the branch is loaded;
  `BaseClient` validates it against the history it loads anyway and
  answers 404 for a missing leaf or a typed `nothing_to_summarize` for a
  finished compaction. That predicate is shared through the data provider
  and ignores a summary still streaming or one that failed, so an
  interrupted compaction can be retried.
- A compaction never consumes files staged in the composer, the action is
  shown only when the server advertises `compactionEnabled`, and the
  in-flight marker is feature-local Jotai state rather than a read of the
  Recoil submission store.

* 🗜️ fix: Keep a Compaction Turn to Its Summary

Review round 2, plus the class it belongs to. A compaction submits no user
turn, so nothing that keys off one may run: the memory pass no longer runs
over the history (it would have spent a model call and could repeat memory
writes), and skill primes are no longer injected into the transcript the
run is about to summarize.

The client's in-flight marker is also reconciled on mount: a compaction
that finished while the view was away left the marker set, and the next
ordinary turn in that conversation would have shown as compacting.

* 🧹 chore: Sort Imports in the Compaction Hook Spec

* 🔧 chore: Update @librechat/agents dependency to version 3.8.1 in package-lock.json and package.json files
2026-09-07 21:51:54 -04:00
Danny Avila
21c03b7c92
🕓 style: Move the Queued-Message Hint Into a Hover Tooltip on the Clock Icon (#15706)
* 🕓 style: Move the Queued-Message Hint Into a Hover Tooltip on the Clock Icon

"Sends when this response finishes" rendered as a caption row under the
queued chips for as long as a run was pending, costing composer height
for a single reassurance. The clock icon of each queued row now carries
that sentence as a hover tooltip and as its accessible name, and the
caption row is gone. Nothing else about the row changes: warning states
keep their triangle, and the hint disappears with the run as before.

* ⌨️ fix: Give the Queued-Hint Clock an Explicit Tab Stop and Focus Ring

The tooltip anchor was already focusable through Ariakit's Focusable
default, and opens on focus-visible, but nothing said so and no ring
showed where focus was. Make the tab stop explicit, add the same
focus-visible ring the row's buttons use, and prove the keyboard path
with a test. The hover test now allows for Ariakit's show timer on a
loaded CI shard, which is what failed the first run. Codex round 1 (P2)
on #15706.

* 🧪 test: Move the Pointer Between Coordinates Before Expecting the Queued Hint Tooltip

Ariakit's hover detector treats a pointer as moving only when consecutive
mousemove events differ in screen coordinates; its NODE_ENV=test shortcut
does not apply under the CI runner's NODE_ENV, which is why the hover test
passed locally and failed in the shard. Two moves at distinct coordinates
make the test environment-independent; the keyboard test was already
deterministic.
2026-09-07 12:45:30 -04:00
Danny Avila
4b3a6eaf0e
🪧 feat: Surface Conversation Code Approval Modes (#15703)
* feat: Add conversation code approval modes

* refactor: Reuse shared code approval types

* fix: Scope approval selector to stateful agents

* fix: harden code approval state propagation

* fix: fail closed during approval discovery

* test: cover approval mode acceptance

* test: use visible approval mode label

* test: drive approval menu by keyboard

* test: expose accept edits in BYOM acceptance

* fix: read approval mode atomically on send

* fix: align code modes with endpoint policy

* fix: initialize code limiters at startup
2026-09-07 12:24:29 -04:00
Danny Avila
b5c5624f13
🕹 fix: Keep Composer Focus Off Clicked Controls So Menus Can Close (#15669)
Some checks are pending
Docker Dev Images Build / publish (push) Waiting to run
Sync Helm Chart Tags / Ignore non-main push (push) Waiting to run
Sync Helm Chart Tags / Sync chart tags (push) Waiting to run
* fix: dismiss menus when composer focus changes

* 🎯 fix: Keep Composer Focus Off Clicked Controls So Menus Can Close

Ariakit records document.activeElement at open time as a menu's disclosure.
The composer surface focused the textarea on every bubbled click, including
the click that opened the Tools or attach menu, so the textarea became the
disclosure and the menu ignored every later textarea interaction. The Tools
menu went from modal to non-modal in #14979 (v0.8.8-rc2), which removed the
backdrop that had been closing it anyway.

Hoists the interactive-target selector, adds label to it, documents the
mechanism at the guard, and gives the composer surface a stable test id so
the empty-space focus test no longer depends on a utility class. Adds a test
that opens a menu and proves a textarea click closes it.

Closes #15624

* 🎯 fix: Restore Textarea Focus After Send, Steer and Stop Controls

The interactive-target guard also skipped the bubbled click that used to
return focus to the textarea after a mouse click on send. The send button
is then disabled or swapped for the stop control, leaving focus on body.
Route that refocus through a shared helper called from the form submit,
the during-run consume callbacks, and the stop button, keeping the
touchscreen exception. Adds a test that a mouse click on send leaves the
textarea focused; it fails without the submit refocus.

* 🎯 refactor: Exempt Only Focus-Owning Targets From the Composer Refocus

The blanket 'button' exemption inverted the surface's long-standing
behavior for every control, so each control that relied on the bubbled
refocus (send, stop, steer, badge toggles) became its own regression.
State the rule the other way round: the surface refocuses the textarea
after any click except on a target that owns focus itself (links, form
fields, labels) or opens or belongs to a popup (aria-haspopup disclosures
and menu/listbox/dialog content, which React bubbles through portals).
Matches that contain the surface itself are ignored so a host dialog can
never disable the refocus. Drops the explicit refocus calls, which plain
buttons no longer need.

* 🎯 fix: Restore Textarea Focus From Popup Actions That Consume the Composer

The during-run alternate actions live in an Ariakit hovercard, which is
portaled dialog content and therefore exempt from the surface's bubbled
refocus. Choosing Steer or Queue there consumed the text and unmounted
both the button and the hovercard, leaving focus on body. Actions that
consume the composer from inside a popup now restore focus themselves
through a shared consume callback. Adds a ChatForm test that opens the
real hovercard with screen-coordinate mouse travel, chooses Queue, and
asserts the textarea is focused; it fails without the refocus.

* 🧪 test: Expect Escape to Return Focus to the Quote Pill

The quotes e2e asserted that Escape on the selections popover focused
the textarea. That held only through the bug this branch fixes: Enter on
the pill fired a click that bubbled to the composer surface, the textarea
took focus mid-open and was recorded as the popover's disclosure, and
Ariakit then 'restored' focus to it on hide. With the surface no longer
stealing focus from a popup disclosure, the pill is the disclosure and
Escape returns focus to it, as PendingQuoteChips documents. The guard
against focus landing on body is unchanged.

* 🎯 fix: Restore Focus When Removing a Quote From the Selections Popup

The remove buttons in the selections popup are popup content, so the
surface no longer refocuses the textarea for them, and the clicked
button unmounts with its row. Removing the second-to-last quote also
unmounts the popup and its pill, so Ariakit has nothing to restore focus
to and it fell to body. The chip now restores focus itself: to the
textarea when the popup collapses, otherwise to the popup so keyboard
users stay inside it. Adds tests for both, plus one proving the primary
during-run submit still refocuses through the surface (the hovercard
anchor carries no popup attributes, so it bubbles like any button).

* ♿ fix: Keep Quote Removal Focus Guarded and on a Visible Control

Route the chip's collapse refocus through the composer's guarded helper
so a tap on a touchscreen does not raise the keyboard, and after removing
one of several quotes focus the remove button now at the same row (or
the last one) once React has re-rendered the list, instead of the
outline-less popup container. Tests pin both; each fails without its fix.

* test: make quote popup focus checks deterministic

---------

Co-authored-by: Jackson Riding <99007683+jacksonriding@users.noreply.github.com>
2026-09-06 17:31:16 -04:00
aeyeopsdev
bfaecf131b
🫸 fix: Stop OAuth Sign-In After Binding Failure (#15652)
Co-authored-by: aeyeopsdev <275853971+aeyeopsdev@users.noreply.github.com>
2026-09-06 17:26:11 -04:00
aeyeopsdev
abdb8f34e4
📣 fix: Surface Skill Creation Feedback (#15649)
* fix: show inline skill creation errors and progress

* fix: address skill creation review findings

* style: flatten skill error selection

---------

Co-authored-by: aeyeopsdev <275853971+aeyeopsdev@users.noreply.github.com>
Co-authored-by: Danny Avila <danny@librechat.ai>
2026-09-06 17:24:37 -04:00
Marco Beretta
dcf417efec
📏 style: Put the Grouped Thought on the Row Rail (#15674)
* style(client): put the grouped thought on the row rail

Auditing every label row under a message header against dev's rail left
one outlier, and it is the row this feature adds. The phase header takes
`ROW_GLYPH_SLOT` through `PhaseGlyph`, the group header takes it on both
glyph branches, the standalone thought takes it through `ThinkingButton`
and the projection marker through `ThinkingLabel` — but `ReasoningCompact`
drew a bare 16px bulb, so a grouped thought sat on the pre-rail axis with
its label 8px left of the tool rows around it. Most visibly: an
unavailable thought, which renders as `ThinkingLabel` inside the same
group body, sat on a different left edge than an available one.

* style(client): drop the duplicated glyph-slot narration

`ROW_GLYPH_SLOT` documents the rail where it is defined; restating it at
the one call site this change adds is a second explanation to keep in
sync.
2026-09-06 17:23:36 -04:00
Danny Avila
deb3dad265
🫳 fix: Let the Composer Column Shrink Below a Queued Row's Text (#15665)
A queued follow-up or failed steer row longer than the composer widened
the whole composer column to the text's own length instead of truncating:
the row's controls left the viewport, the composer ran under the side
panel, and the chat pane grew a horizontal scrollbar.

The row's text is `nowrap` with `min-w-0 flex-1 truncate`, but nothing
caps its width, so its min-content width propagates up through the chips
column and the composer surface to the form's `flex-1` child. That child
is a flex item with `min-width: auto`, so its automatic minimum becomes
the text's width and the form cannot shrink it. The quote and skill chips
beside it never trigger this only because each carries a fixed `max-w-`.

`min-w-0` on that column wrapper lets it shrink to the form again;
everything below it is already `w-full` or `overflow-hidden`, so the text
truncates where it was meant to. The queue e2e test now queues a paragraph
wider than the composer and asserts the row ends inside the form with its
remove button fully in the viewport; it fails on the previous build by
2119px and passes on this one.
2026-09-06 15:32:01 -04:00
Danny Avila
deda142d58
🗓️ fix: Refresh the Sidebar When a Scheduled Run Fires or Settles (#15631)
* 🗓️ fix: Refresh the Sidebar When a Scheduled Run Fires or Settles

An automatic occurrence is the one generation nothing in the client starts,
so no submission, stream or event handler tells the sidebar its chat exists,
and the conversation list's five-minute staleness leaves it out of a tab
that stays focused.

The schedules panel is already polling for its cards, and `lastRun` moves at
exactly the two moments the list should be re-read — a fire adds a chat, a
settlement retitles and reorders it — so read the refresh out of that poll
rather than adding one. Only transitions refresh; a schedule first seen is
recorded in silence, so a panel opened long after a run does not refetch a
list that has held its chat all along.

This also settles the row Run Now seeds: the schedule's own completion is
what replaces the schedule name with the generated title.

* 🗓️ fix: Name the Running Occurrence's Chat So the Sidebar Can Fetch It

Four review rounds each found a new way the schedule projection diverges
from the run it stands in for: `lastRun` is not written at fire, `nextRunAt`
moves before the conversation exists, and an edit mid-flight fences the
terminal write so `lastRun` never changes at settlement. Nothing on a
schedule document means "this run's chat is listable now", so every signal
read from one was too early or too late.

Stop inferring. The list handler already reads the user's schedules and
limits in parallel; read their active run rows alongside — one user-scoped
query, joined by schedule id — and project the running occurrence's
conversation id as `activeRun`. It comes from the run's own row, so the
configRevision fence on the schedule projection cannot hide it, and it is
absent until dispatch has actually reserved a conversation.

The panel hook then hands every id the list names to the same admission
watch Run Now uses, which probes until the server has the chat and adds the
server's own row: one mechanism for both paths, idempotent per id. A run
leaving the list has settled, and the list is re-read once for the order
its settlement changed.

* 🗓️ fix: Fetch Every Chat the Schedule List Names, and Scope the Run Read

Three from codex on the rebuilt design.

A run short enough to start and settle between two polls is never seen
running, and most scheduled chats are short. The list also names the chat
the last occurrence produced, so the panel now fetches every chat the list
names that it has not seen — active or settled — through the same admission
watch. The first observation still fetches only runs in flight: a panel
opened long after a run must not go and fetch history.

Project every running occurrence rather than the latest. A `requires_action`
pause does not block the next occurrence, so a schedule can hold two, and
reducing to one hid the pause's settlement. This also deletes the picker.

The single-schedule route's run read started before ownership was known and
was scoped only by schedule id. The response was gated, but a speculative
read must stay scoped to the caller: use the user-bound query the list uses
and narrow it, rather than touch rows the caller may not own.

* 🗓️ fix: Let One Layer Decide What to Watch, and Say Which Runs Are Generating

Two from codex on the previous round.

The admission watch forgets a run whose delivery outlasted its budget so a
later announcement can retry, but the panel kept its own permanent record of
every id it had handed over and never announced one twice — so that retry
could never happen. Drop the panel's record: every chat the list names is
handed to the watch on every observation, and the watch is the one place
that decides whether an id is landed, in flight, or worth trying again.

The one thing the panel still must not do is fetch history. Opening it used
to start a watch per active occurrence, and a run parked on an approval can
sit there indefinitely and accumulate, its chat listed long ago. Carry each
occurrence's status on the wire, and on the first observation treat only a
generating occurrence as in flight; a settled one and a paused one are
history, and a pause resolving later still re-reads the list.

* 🗓️ fix: Read Only Generating Runs for the List, and Hand Over Only Those

Three from codex, and this round removes more than it adds.

The list's run read returned every paused row, unbounded, on each poll.
`ScheduleRun` is indexed by status rather than by user, `requires_action`
rows accumulate for as long as their approvals wait, and `started` rows are
bounded globally by the capacity slots — so the read now asks for `started`
alone, through an optional status narrowing on the existing method. A pause
resolving is still seen through `lastRun`; what this gives up is only the
corner where that projection is fenced by a mid-flight edit.

A run that failed during initialization settles with its reserved id but
never writes a conversation, so its route answers 404 for good — and handing
settled ids to the watch meant re-probing it every poll, forever. The watch
only ever needed generating runs: a settled one is already covered by the
list re-read its settlement triggers, which brings the server's own row.

A deleted schedule leaves the list, and comparing only the schedules still
present missed the abort-and-settle that deletion performs on its run. A
schedule vanishing now counts as its state moving.

* 🗓️ fix: Compare a New Schedule Against Idle, and Bound the Landed-Run Record

Two from codex on the head GitHub replayed onto dev.

A schedule created in another tab can arrive in this client's list with its
first run already settled, and a comparison that walks only the schedules
seen before never looked at it. Compare a newcomer against the idle state:
one that arrives with a run behind it is news the list should hear, one
that arrives with no run yet is not.

The watch remembers every run it landed so a later announcement is a no-op,
and a panel that stays mounted sees a new id per occurrence for as long as
schedules keep firing. Keep the most recent 256: a run is announced only
while in flight, and none is still in flight by the time that many have
started after it, so the oldest can go without a watch ever running twice.

* 🗓️ fix: Re-read on First Sight Only When a Run Outran the Sidebar, and Never Evict a Live Watch

Two from codex.

"The first observation is silent" assumed the sidebar's lists had been read
after any run they should hold, and that is not guaranteed: open the panel
after a run fired and finished with it closed, and the card says the run
succeeded while the sidebar was read before it ever fired. The first
observation has no earlier one to compare against, so compare against the
sidebar instead — re-read only if some run fired after the lists were last
read, which is precisely the case where they lack its chat, and stay silent
otherwise.

The landed-run cap assumed fewer than 256 generations could be in flight at
once, and the config schema bounds neither maxPerUser nor fireConcurrency.
Keep in-flight watches in their own set, bounded by real concurrency and
never evicted — a second watch for a run still being watched is the one
thing that set exists to prevent — and cap only the landed record, where a
forgotten id costs at most one extra probe.

* 🗓️ fix: Re-read on First Sight When Anything Has Run, Release Runs the List Drops, Observe Every Poll

Three from codex, each a defect in an earlier fix, and each answered by
removing something.

Comparing a run's fire time against the list cache's `dataUpdatedAt` was
measuring cache writes, not server reads: a foreground chat inserted after
the run advanced the stamp without adding the scheduled chat. There is no
timestamp for "last read from the server", so stop guessing — the first
observation re-reads if any schedule has run at all, and one refetch on
opening the panel is the honest price.

A run can be landed and still generating for minutes, announced on every
poll; a count cap evicted it and restarted its probes. The hook is the one
place that sees an occurrence leave the list, so it releases the id then,
and the watch remembers a run exactly as long as something can announce it.
No cap.

React Query hands back the same array for a deep-equal poll, so an effect
keyed on the data never ran again while a run stayed in flight — and a watch
that gave up was never asked to try again. Key on the poll's timestamp.

* fix: Release Scheduled Run Retention Across Admission and Unmount 🧹
2026-09-06 15:28:11 -04:00
Marco Beretta
c9d208ad3b
🧰 feat: Unify Tool Activity, Reasoning, Search, and Agent Workflows (#14546)
* feat: Group Reasoning with Tool Calls and Polish Activity UI

- Treat reasoning (Thoughts) as transparent to tool grouping so interleaved
  thoughts fold into the tool group instead of splitting it
- Group a lone tool call that has reasoning (e.g. a skill) so it gets the
  same collapsible chrome as multi-tool groups
- Count only real tool calls for the group header; add a reasoning indicator
  and a singular 'Used 1 tool' label
- Rework the in-group Thoughts panel: tool-row sizing, rounded content,
  header copy button, and a floating collapse/copy bar
- Round the floating thinking-bar buttons
- Refine the agent handoff row and instructions panel with consistent
  spacing and a copy affordance

* feat: Move subagent runs to an artifacts-style side panel and polish reasoning UI

- Replace the subagent dialog with a right-side panel that shares the
  artifacts slot (currentSubagentRunId + subagentPanelVisibility atoms,
  a subagentRunsState registry, and a useOpenRightPanel cross-clear so the
  two panels are mutually exclusive)
- Rebuild the inline subagent card to be tool-consistent, preview a single
  live/result line, and open the panel (auto-focusing on stream arrival)
- Relocate the originating prompt to a collapsed, smoothly-animated
  disclosure under the panel header
- Gate the Thoughts copy button to expanded state and move the floating
  bar to a scroll-out reveal, matching the code-block pattern
- Fix the reasoning expand/collapse jump by animating the trailing gap
  inside the grid track instead of an expand-only margin

* fix(client): handle singular grouped tool labels

* refactor(client): unify tool row disclosure styling in a shared module

Extract the hover-reveal chevron and expanded panel spacing into
disclosure.ts and align every tool activity row on the same layout:
h-5 header, my-1 rhythm, full-width click target, and a 200ms chevron
rotation. Rows rendered through ProgressText now stretch across the
message column (the absolute content layer was shrink-wrapping to the
text), and the copy buttons in thinking and output panels anchor to
the row instead of the panel corner.

* fix(client): friendly labels and correct arg parsing for native tools

Map skill, read_file, create_file, edit_file, set_memory, and
delete_memory to localized display names so summaries stop showing raw
tool ids, and give the memory tools the Brain icon the Memories panel
already uses. read_file and skill rows parse the arg the backend
schemas actually emit (path, with file_path as a legacy fallback;
skillName) and fall back to a generic noun instead of rendering an
empty name in their labels.

* feat(client): outcome-based tool group summaries

Group headers now describe the activity performed: homogeneous search
groups read "Searched the web" or "Searched web and files", mixed
groups read "Ran N actions" with per-label repeat counts (Create File
x2) and a failure tally in the detail line. Generic tool rows resolve
their label through getToolDisplayLabel, the OAuth trust warning moved
into a shared ToolAuthWarning that a group renders once instead of per
call, and the group body is a flex column so row margins stop
collapsing unevenly between rows.

* feat(client): render file edits as a structured diff view

Replace the highlighted-text diff in file authoring output with a
line-based renderer: red and green tinted rows with +/- gutters,
old/new line numbers when hunk headers carry them, and diff noise
stripped (file headers, streamed old_text/new_text markers, bare @@
separators become dividers). The code window header shows the file
name with +N/-N change stats next to Copy Code, and file authoring
rows adopt the path-first arg parsing and shared panel spacing.

* refactor(client): align memory updates with the standard tool row

Rebuild MemoryArtifacts on the shared disclosure row (useExpandCollapse
grid animation, hover-reveal chevron, h-5 header) in place of its
bespoke ResizeObserver height animation, and simplify the expanded
panel: section headings dropped in favor of bold memory keys, a single
p-3 inset instead of double padding, and the now-unused heading
translation keys removed.

* fix(client): gate retrieval expansion on renderable results

The row offered an expand affordance whenever raw output existed even
when no sources parsed, opening an empty panel. Expansion now keys off
parsed results, which also covers attachment-only sources that arrive
without text output, and collapses if results disappear.

* style(client): soften the message nav hover tooltip

Rounder corners and the light border weight to match the rest of the
floating surfaces.

* fix(client): compact single-number gutter in diff view

The dual old/new gutters left one column blank on every add or delete
row, reading as a stray number floating far from its marker. Each row
now shows the one relevant line number (old for removals, new
otherwise) right beside the +/- marker, and the scroll container is
vertical-only since lines wrap.

* feat(client): dedicated card for memory tool calls

set_memory and delete_memory rendered through the generic tool card,
reading "Ran Save Memory" with raw parameter chips like an unknown MCP
tool. A new MemoryCall part gives them first-class rows: "Saved
memory" / "Deleted memory" with the key as a quiet subtitle, the
Brain icon, and an expanded panel that mirrors the memory attachment
display (bold uppercase key over the stored value, or a deletion note),
with error output shown inline when a write fails.

* style(client): gap between the web search row and its source list

The expanded source panel sat flush against the 22px favicon stack,
which overflows the 20px row. The panel now opens with a 6px top
margin while the row keeps the shared my-1 rhythm.

* feat(client): richer web search source list

The panel only showed favicon, title, and domain while the search
artifact carries much more. Source rows now include the result snippet
(clamped to two lines) and date under the domain, and a Serper answer
box renders as a lead card above the list with its title and snippet.
Streaming behavior is unchanged; the answer box is attachment-only
since it never carries citation anchors.

* refactor(client): move web search answer box into a details hover card

The inline answer card read as assistant prose sitting inside the
source list. The panel is back to sources only; an Info trigger at the
right edge of the row (hover-revealed like the chevron, focus-openable
for keyboard) opens a hover card with the search query, the source
count, and the provider answer box when present. WebSearch now
receives the tool call args to surface the query.

* feat(client): image, shopping, and place verticals in web search results

Serper vertical results were parsed into the artifact and dropped.
The expanded panel now renders them when present: an image strip of
rounded thumbnails at true aspect ratios (sized from thumbnail
dimensions, no layout shift), a shopping card carousel with product
image, title, price and store, delivery note, and star rating, and a
place list with name, category, address, and rating. All link out,
use semantic lists with localized labels, and cap item counts.
Expansion now keys off any renderable content, so a verticals-only
search still opens.

* style(client): help cursor on the retrieval relevance badge

The badge sits inside a clickable row, so it inherited the pointer
cursor while only offering an explanatory tooltip.

* style(client): strip link underlines in web search verticals

The image and shopping anchors sit inside the markdown prose scope, so
every label rendered with the blue link underline.

* feat(client): surface search verticals outside tool disclosures

Image, shopping, and place results were only visible after expanding
the web search row, and disappeared entirely inside a collapsed tool
group. The strips moved into a shared verticals module that renders
in two spots following the attachment pattern: always below the row
for an ungrouped search, and hoisted below the group (visible while
collapsed) for grouped calls, where the row suppresses its own copy
via hideAttachments. The disclosure panel is back to sources only.

* feat(client): platform-native map links on place results

Place rows were the only vertical without a destination. Each row now
links out to the user's native maps app: Apple devices (detected via
the existing isMacPlatform check) get maps.apple.com with the query
and coordinates, everything else gets a Google Maps search link. Both
are keyless https links that degrade to a web map, so a misdetected
platform still lands somewhere useful. Rows pick up the same hover
treatment as the other linked results.

* fix(client): pin the bash copy button while the command scrolls

The button lived inside the scroll container with sticky/float
positioning, so horizontal scrolling dragged it through the command
text. It now sits absolutely in a non-scrolling wrapper around the
scroller and stays in the corner on both axes.

* feat(client): add view-transition morph helper for composer surfaces

Wrap a state update in startViewTransition (with a synchronous flush) so
elements sharing a view-transition-name animate their position, size and
shape between two states instead of swapping.

The composer band gets its own named, opaque snapshot group stacked above
the morphing element: without it a surface travelling between the thread
and the composer paints over the input and bleeds through the strip below
it. Falls back to a plain update where the API is unavailable and for
reduced-motion users.

* style(client): rebuild the ask question surfaces on shared option rows

The popover and the chat card rendered the same question two different
ways: numbered rows in one, wrapped chip buttons in the other, and the
panel was painted with hardcoded white/gray instead of theme tokens.

Both surfaces now render one AskOptions list, so numbering, check badges,
rounding and hover states match wherever a question appears. The card
groups its prompt with the description, styles the answer box like the
composer, and gains a Skip button beside Submit so declining does not
require the popover. While the popover holds the question the card keeps
a hidden copy of itself in the thread, reserving the exact space the card
will need so nothing reflows when the question moves back.

* refactor(client): make one control move a question between chat and composer

The popover carried both a chevron and a close button. Both left the
question pending and both moved it into the chat, so their only real
difference was invisible: the chevron kept the composer wired up as the
answer box while the close button released it. Two icons for one visible
outcome, with the meaning hidden in a placeholder change somewhere else.

Collapsing now does both jobs at once. Moving a question to the chat hands
the composer back for normal messages, and the card's chevron re-arms it,
so the popover's visibility and the composer's role can never disagree.
Escape maps to the same path and the dismissed-ids state is gone. Both
chevrons get a tooltip and a matching label, since no glyph conveys this.

Also fixes two behaviours found along the way: the card's Skip was a
silent no-op once the question left the popover, because it routed through
a helper gated on answer mode instead of the live pause, and clicking a
multi-select row moved the keyboard highlight, leaving a row painted as
selected after it was unchecked.

* style(client): fix changed-file lint formatting

* style(client): align tool call import order

* fix(client): render handoff instructions as readable context

* test: stabilize full test suite

* test(e2e): align assertions with action groups

* fix: preserve tool run and answer state

* fix: sync subagent and answer handoffs

* fix(client): keep summary parts stable through failed summarize rounds

Failed summarize completions spliced the in-flight summary part out of the
content array, remounting every later index-keyed part (collapsing whatever
the user had expanded mid-stream) and breaking the content-position ==
step-index invariant that streaming writes rely on. Finalize the part in
place instead and scope completion to the owning step's slot so
back-to-back rounds cannot clobber a newer in-flight part.

* fix(api): disable summarization below a viable context budget

A tiny user-set maxContextTokens re-triggers summarization on every graph
step (the summary allocation rounds to nothing and history still
overflows), burning dozens of LLM calls until the recursion limit aborts
the run with an opaque LangGraph error. Fall back to plain pruning under a
1024-token floor so the run either fits or fails fast with the actionable
empty_messages breakdown.

* feat(client): render context budget errors with readable copy

empty_messages and final_context_overflow are structured errors thrown by
the agents SDK, but they were missing from the typed-error dispatch table
and surfaced as raw JSON inside the generic failure text. Map both to
localized copy: empty_messages keeps its token budget breakdown in a
details block, final_context_overflow interpolates the projected and
available token counts.

* Fix ask answer handoff and OAuth warnings

* fix(client): address Codex review findings

* fix(client): address Codex review findings on tool group and summary UI

Replace the raw green/red diff palette in DiffView and CodeWindowHeader with
the existing status-success/status-error semantic roles, so a customized or
versioned theme moves the diff colors with it.

Compose the shared Button primitive in the ask option rows instead of
recreating hover, focus-visible and disabled appearance locally, and swap the
raw text-white on the checked badge for text-on-status.

Prefer a THINK part's generated reasoning_label in the grouped rendering path,
matching the standalone Reasoning path, with the generic Thinking/Thoughts text
only as a fallback.

Derive grouped tool completion and failure from the run step's terminal status
through the shared resolveToolCallPhase helper, so a step the run closed as
failed with empty or benign output no longer reads as running and then reports
success while the card beside it shows a failure.

Carry an explicit failed flag on a summarize round that ended in error, so the
partial deltas already streamed into the slot are no longer presented under the
"Conversation summarized" label.

Also drop seven orphaned English locale keys this branch left unused, which
were failing the unused-i18n static check.

* fix(client): address second round of Codex review findings

Reuse the shared Button primitive for the three question move controls (the
chat card's chevron and both popover chevrons), which each repeated the same
hover, focus-ring, color and rounding recipe locally. Only the icon geometry
stays local.

Drop provider image results that carry neither thumbnailUrl nor imageUrl.
Both are optional in the ImageResult contract, and an unusable entry still
made images.length nonzero, so the card rendered an anchor and img with
undefined destinations instead of omitting the result.

Gate the memory deletion confirmation on a completed phase. The panel opens as
soon as the key streams in and the phase can still settle as cancelled, so
"Memory deleted" was claiming a removal that never happened while the header
correctly read Cancelled.

Key pending answer drafts by action id instead of a single shared slot. With
Save drafts disabled, editing a collapsed question in one conversation and
then editing another paused conversation's question overwrote the only slot,
and the action-scoped reader then showed the first card an empty box with its
unsent answer unrecoverable. Entries are dropped once answered.

* fix(client): address third round of Codex review findings

Reuse the shared CopyButton for the handoff instruction copy control, which
recreated hover, focus-ring, opacity, rounding and copied-state appearance
locally. The icon crossfade and tooltip now come from the shared primitive and
only the reveal-on-hover behavior stays local.

Keep unlabeled commentary out of collapsing tool groups. An unlabeled group
auto-collapses once complete, so folding commentary in hid the assistant's
prose behind a generic action header. The flush now splits the block at
commentary and groups each surrounding run on its own, restoring the shape the
previous fallback had while keeping reasoning folded in.

Drop shopping results without a link and places with nothing to name, for the
same reason the image results are filtered: every provider field is optional,
and an unusable entry still made the array nonempty, so the card rendered an
anchor with no destination that looked actionable but could not be opened.

* fix(client): address fourth round of Codex review findings

Move the disclosure chevron appearance into @librechat/client as
disclosureChevronVariants, owning the hover/focus reveal, the motion and the
open rotation. The four tool, search, memory and reasoning surfaces now pass
their expanded state and keep only icon geometry local, so a change to the
shared behavior reaches all of them. Panel spacing stays feature-local, being
genuine layout.

Require a navigation target on image results, not just an image source: a
thumbnail-only entry passed the previous guard and then rendered a styled
anchor with an undefined href, looking actionable but opening nothing.

Exclude closed run steps from the pending-auth predicate. ToolCall already
hides the sign-in button on a terminal status, so a persisted OAuth call whose
progress never reached 1 left the group showing a trust warning with no
authentication action behind it.

Copy handoff instructions through copy-to-clipboard, as the sibling
message-content controls do. navigator.clipboard is undefined on a non-secure
origin, where dereferencing it threw before the rejection handler could run and
the button silently did nothing.

* fix(client): address fifth round of Codex review findings

Compose the shared Button through HoverCardTrigger's asChild for the web search
details trigger, which recreated rounding, hover colors, focus ring and motion
locally. This also replaces Radix's default anchor with a real button. Only the
hover-card reveal and the icon geometry stay local.

Copy compact reasoning through copy-to-clipboard for the same reason as the
handoff control: navigator.clipboard is undefined on a non-secure origin, where
dereferencing it threw before anything was copied.

Document the streaming-peek fade as a narrowly scoped custom-CSS exception. It
is a mask-image stencil rather than paint, so only its alpha channel is read
and no theme role could meaningfully restyle it.

* fix(client): address sixth round of Codex review findings

Recognize the batched-edit separator pair for every edit in a diff preview.
formatEditPreview writes a `--- old_text N` / `+++ new_text N` pair before each
edit's `@@`, but the parser gated on `inHunk`, which is never reset, so only
the first pair was skipped and every later one was counted as a deletion plus
an addition and rendered as a marker row. Matched by name instead, which leaves
content lines that merely begin with `-` or `+` alone.

Compose the shared Button for the popover's type-below hint, suppressing only
the fill the way Summary's quiet text buttons already do, so the focus ring and
disabled handling come from the shared recipe.

Render an answer box that carries only snippetHighlighted. It is independently
optional from snippet, and the details card opens for any answer box, so such a
result previously showed a heading with an empty body.

* fix(client): match synthetic edit headers only in separator position

Matching the marker names alone was wrong: deleting a real `-- old_text`
comment line, as SQL and Lua use, is prefixed to exactly `--- old_text`, so the
previous guard discarded a genuine changed line from both the preview and the
statistics. The pair is now skipped only in separator position, adjacent and
immediately followed by a hunk header, which no run of genuine content
satisfies. Covered by a test asserting such a pair inside a hunk survives as
content.

Also drops the em dashes from the comments added over this review pass.

* fix(client): address eighth round of Codex review findings

Compose the shared Button for the compact reasoning disclosure, keeping only
the row geometry local so the focus ring and disabled handling come from the
shared recipe.

Lazy-mount the compact reasoning body with useLazyCollapseBody, as the
standalone panel already does. Collapsed is the default whenever thoughts are
hidden, and a streaming THINK part re-renders on every delta, so the full text
was being mounted and laid out behind an invisible panel.

Classify grouped memory failures with isMemoryFailureOutput. Those tools report
failure in prose that generic isError parsing does not recognize, so a
persisted call with no terminal status showed a failed card inside a group
reporting success with no failure count.

Announce the diff statistics to assistive technology. The +/- glyphs carry
their meaning through color and sign, so aria-hidden left screen-reader users
without the change summary; the counts are now also exposed as localized
screen-reader text.

* fix: persist failed summaries and stop double-rendering memory mutations

Stamp the failed marker on the aggregated summary part server-side, mirroring
how ON_RUN_STEP_CLOSED already stamps runStepStatus. The SDK aggregator ignores
a complete event that carries no summary, so an errored round's partial deltas
were saved unmarked and a reload re-rendered the truncated text under
"Conversation summarized".

Skip memory attachments that carry a toolCallId in the message-level
MemoryArtifacts decoration. Those calls already render inline as a MemoryCall
card with the same key, value and outcome, so one mutation appeared twice.
Attachments with no originating call keep the decoration as their only surface.

Keep a reasoning-bearing group expanded when Open Thinking Dropdowns by Default
is on. The folded-in THINK part only renders inside the group body, which is
not even mounted while collapsed, so the preference had no visible effect until
the action group was opened by hand.

Give same-named place results unique keys. Several branches of one chain share
a name and often carry no identifier, so rows whose address, rating and map
target all differ collided on one React key.

* fix: adopt the shared code surface and count background task failures

Register surface-code in the versioned theme registry and use it for the diff
preview. The token, its light and dark CSS values and its Tailwind mapping were
already in place and already consumed by CodeBar, CodeBlock and ResultSwitcher;
only the three theme interfaces, the two bundled themes and DiffView were
missing. DiffView no longer coordinates two unrelated surface roles through a
dark: override, and a custom theme can restyle the code surface centrally.

Include background-task failures in grouped outcomes. A backgrounded bash or
code task reports its verdict through a background_task_status attachment
rather than its output, and its dispatch step keeps a benign handle and usually
closes as completed, so the group reported no failed action beside a card
showing failure. Group metadata now derives that signal with the same helpers
the child card uses, correlated per part so a handoff response repeating a
provider tool-call id across agents still routes correctly.

Require a title on shopping results. A link-only card had no accessible name
and no visible identity: the anchor carried no label, its image is decorative
and the title span rendered empty.

* fix(client): compose shared buttons for two disclosures and seed re-enabled ask drafts

Compose the shared Button for the memory-artifacts and web-search disclosure
rows, keeping only their geometry local. The web-search row keeps its instant
hover by suppressing the recipe's color transition, since the chevron beside it
reveals without a fade and the existing test pins that.

Seed the ask-specific draft when Save drafts is re-enabled. An answer captured
while saving was off has no persisted ask draft for autosave to restore, so
expanding opened an empty composer and the next collapse read that empty value
back over the in-memory answer.

* fix(client): surface cancelled actions and protect the released composer

Track cancellation separately from failure in grouped tool metadata and name it
in the group header. A stopped step is settled and not an error, so the group
auto-collapsed under a success-sounding header with the only cancellation
notice hidden inside the panel it had just closed.

Preserve an ordinary unsent message across an ask handoff. With Save drafts
off, collapsing a question releases the composer; typing there and then moving
the question back overwrote that text with the answer and lost it. The released
text is now stashed per pending action and handed back on the next collapse.

Skip the named view transition for batched questions. Only the single-question
surfaces declare view-transition-name: ask-question, so wrapping a batch
handoff gave the browser nothing to pair and it cross-faded the whole root
instead of morphing the question.

* fix(client): restore the released composer text after answering

Submitting an answer from the expanded card never goes through collapse, so the
ordinary unsent message stashed when the question was moved back was never
handed over and its entry leaked. The resume success path now restores it in
place of the reset when one is stashed, and drops the entry either way. Read
through a ref because the callback settles long after the render that armed it.

* fix(client): stop stacking search snapshots and fix three identity defects

Upsert re-emitted web-search attachments instead of appending them. The search
helper rewrites and re-emits the entire payload after every highlight update,
keeping the same type, toolCallId and turn, and those attachments carry no
file_id so the existing upsert never saw them. Each snapshot was appended, so
collectSearchVerticals concatenated one copy of every image, product and place
per update. Keyed by type, tool call and turn, replacing wholesale since the
incoming payload is complete.

Preserve MCP identity in the tool-call label. function_name has already had the
MCP delimiter and server stripped, so re-parsing it classified an MCP function
sharing a built-in's name as that native tool and both showed and announced an
unrelated label.

Qualify grouped tool identity by agent. Provider tool-call ids repeat across
agents in a handoff transcript, and a lone tool with reasoning now groups too,
so two sibling groups shared one React key and one expansion override.

Compose the shared Button for the handoff disclosure, keeping only its geometry
local.

* refactor(client): build edit previews structurally instead of round-tripping diff text

The args preview was formatted into unified-diff text purely so parseUnifiedDiff
could read it back, and the separators that round trip needed between batched
edits are byte-identical to a real changed line: deleting a source line
`-- old_text` prefixes to exactly `--- old_text`. Neither the marker names nor
their position could tell the two apart, so the parser either inflated the
statistics or dropped a genuine edit.

buildEditPreviewDiff now constructs the preview's lines from the structured
edits, so edit boundaries are structural and no separator is ever emitted.
parseUnifiedDiff is back to parsing only real tool output, where `--- ` and
`+++ ` are genuine file headers, and it no longer special-cases synthetic
markers at all. Copy text comes from a one-way serializer.

Also include agent identity in the web-search snapshot key: handoff agents
repeat provider tool-call ids, so without it one agent's search results
replaced another's.

* fix(client): stop counting empty edit sides as changed lines

A pure deletion (`new_text: ""`) rendered a blank green row and reported one
addition, because `''.split('\n')` yields one element. A trailing newline did
the same at the end of either side. Both sides now go through one helper that
treats an empty side as no rows and a trailing newline as a terminator. The
defect predates the structural builder; it was carried over from the string
preview it replaced.

* fix(client): restore the released text for non-text answers too

Only the free-text path sets consumedComposerText, so gating the restore on it
discarded the stashed ordinary message whenever the user answered by clicking an
option or skipping, while the deletion below ran regardless. The stash is now
restored whenever one exists, independently of the reset condition, and it
outranks whatever the composer holds since that is the answer draft the
submission just consumed.

* fix(client): make group identities collision-proof and localize handoff labels

Disambiguate duplicate tool-group identities by how many earlier groups already
claimed the same provider tool-call id. Those ids repeat across agents in a
handoff transcript and restart per turn within one agent, and a lone tool with
reasoning now groups too, so sibling groups could share a React key and one
expansion override. Occurrence order is stable because groups are append-only,
and the first occurrence keeps the bare id, so an id that never repeats is
unchanged and still survives a content-index shift.

Restore a stashed ask message regardless of the current Save drafts setting. The
stash is only ever created while saving is off, so it never reached the
conversation draft; gating the restore on the setting dropped it whenever the
user enabled saving between expanding and collapsing.

Localize the handoff field labels the SDK defines (instruction, instructions,
context). Any other key is an admin-authored promptKey from the agent graph, so
it stays as written, like an agent's own name.

* fix(client): reject unsafe vertical links and scope group identity message-wide

Filter provider-supplied vertical URLs through the markdown allowlist. Search
result payloads are copied into the attachment without validation, so an image
or shopping target could be `javascript:` or another non-network scheme and the
card handed it straight to href. The same helpers are used when admitting a
result and when rendering it, so the two cannot disagree.

Derive tool-group identity from a message-wide occurrence ordinal instead of a
per-instance counter. Phase slices render through separate nested ContentParts
that share the expansion map, so a per-instance count restarted and let a later
slice inherit an earlier group's override. The ordinal is stable under
content-index shifts, and ordinal 0 keeps the bare id, so a group keeps its
identity when a completing phase moves it into a slice.

Build group attachments as a union. Repeated provider ids inside one group
resolve to the same bucket, so appending per part rendered each file and search
snapshot once per repeated call.

* fix(client): let an output diff supersede a create preview, and guard two edges

A diff in the output now supersedes everything, including a create's authored
content. `create_file` overwriting an existing file returns a summary plus a
unified diff, and preferring the authored content there rendered that diff
twice: once through DiffView and again verbatim as the raw output section. This
restores the precedence the string-preview version had.

Give image tiles distinct React keys. Syndicated images reuse one thumbnail
across results that link to different pages, and grouped searches merge
attachments, so the source alone collided.

Require the composer to still hold the submitted text before restoring the
stashed ask message. The textarea stays editable while the resume is in flight,
so anything typed since is newer than both the stash and the answer.

* fix: address remaining Codex findings after dev rebase

Stamp agent ownership on streaming and final search snapshots. Compose the shared floating thought button. Preserve rebased group behavior, correct stale test selectors, and keep expansion callbacks outside state updaters.

* Resolve follow-up review findings

* Scope grouped background verdicts by execution step

* Fix canonical artifact ownership and frontend review regressions

* Fix terminal answer handoff and encoded edit previews

* style(client): keep the search rows on dev's glyph rail

The rebase onto dev landed both halves of #15643's row rail except in
`WebSearch`, whose completed row had since moved its glyph into a shared
`Button` and whose streaming row kept a 10px gap. Restore the shared
`ROW_GLYPH_SLOT` around the completed row's favicon stack or globe and
drop the streaming row's gap to 8px, so both search rows put their glyph
on the avatar's axis and their text where the header's name starts.

* fix(client): pass the thinking preference into ReasoningCompact

`showThinking` is an app-global display preference the group only reads,
and `ToolCallGroup` already receives it from its host. `ReasoningCompact`
still reached for `showThinkingAtom` itself, coupling a grouped thought
to `~/store` and blocking the move to a feature-owned workspace. It
takes the preference as a required prop now, from the value the group
already holds.

* test(client): pin both web-search rows to the shared glyph rail

The rebase onto dev silently dropped `ROW_GLYPH_SLOT` from the completed
row — its glyph had since moved inside a shared `Button` — and left the
streaming row on a 10px gap, so nothing caught either. `Part.tsx` routes
web search past `ProgressText`, so this renderer owns its glyph and has
to take the slot itself; the test fails on both regressions.

* fix(client): keep grouped markers and folded search media visible

Two things a fold could swallow.

A detached-subagent projection is an empty THINK part flagged
`reasoning_unavailable`, which `Part` renders as a `ReasoningMarker`.
`ToolCallGroup` sent every THINK part to `ReasoningCompact`, which has
no text to show and returns null, so the marker disappeared the moment
its call joined a group. Those parts go back through the standalone
renderer.

A phase hoists its span's media out of the fold, and the nested segment
renders with `hideAttachments` so a `WebSearch` row inside it stands
down for that hoist. The hoist was `AttachmentGroup` alone, which drops
`web_search` attachments outright, so a folded search lost its images,
products and places instead of lifting them out. The card renders
`SearchVerticals` beside the attachment row, mirroring `ToolCallGroup`.

* fix(client): recover a released composer stash on revisit

Recovery of the ordinary unsent message stashed while the card owns the
composer was gated on `lastAnswerableRef` — what this hook happened to
observe. Navigating away mid-resume clears that ref while the stash
rightly stays put, so a resume that succeeded or expired while the user
was elsewhere left nobody to hand the message back: returning to the
conversation found `answerable === false` with no ref, exited early, and
the text sat unreachable in `releasedComposerTextAtom` for the session.

The stash carries its conversation now, and recovery keys on that, so a
revisit is a hand-back like any other exit. Only the exit this hook
armed knows what the composer held when the resume started; on a revisit
an empty composer is the only target that cannot overwrite something
newer, and either way the entry is dropped.
2026-09-06 14:56:50 -04:00
Danny Avila
a5932cb039
🎖️ perf: Promote Flat Thread Rendering to Default (#15660)
* 🧵 feat(client): Make the Flat Thread Renderer the Default

The flat message-thread renderer becomes the default; the recursive
MultiMessage path stays reachable with VITE_FLAT_THREAD=false at build
time or LC_FLAT_THREAD=false in localStorage as an escape hatch.

* 🧪 test(e2e): Differential Check of the Two Thread Renderers

Builds one conversation through the real pipeline with the content shapes
the seeded benchmarks never produce (a regenerated branch, reasoning,
markdown with a table and code, a provider attachment) and one with
detached subagent activity, then renders each with the flat list and the
recursive tree in turn. Both must produce the same transcript, sibling
counters, attachments and activity groups, before and after cycling a
branch. Also adds a benchmark config that runs the tree lane against the
built client for production-minified numbers.
2026-09-06 18:31:08 +00:00
Danny Avila
422f3a6f8d
🧶 feat: Flatten Active Message Threads Behind a Flag (#15633)
* 🧵 feat(client): Flat Message Thread Renderer Behind a Flag

Adds a keyed thread index and an O(depth) visible-path resolver so the
message list can render as a flat, memoized list instead of one React
level per message. The recursive MultiMessage path stays the default;
the flat path is enabled per page with the LC_FLAT_THREAD localStorage
key or VITE_FLAT_THREAD at build time.

Also adds a react-scan/CDP benchmark lane (e2e/benchmarks-tree) that
A/Bs both render paths on a seeded 240-row thread, plus a parity config
that runs the branch-sensitive mock specs with the flat path on.

* 🙈 chore: Ignore the Tree Benchmark Output Directory

* 🪢 refactor(client): Move Sibling Selection to Feature-Owned Jotai State

Codex round 1 on #15633. The message thread's sibling selection moves out
of the Recoil store into a Jotai atom family owned by the thread feature,
shared by the recursive and flat renderers, the share view, and the focus,
resume and clear writers. Consumers that watch several branch points read
them through one derived atom via useSyncExternalStore, so a token-only
cache write costs no render.

Also keeps the raw cache object as a thread row's reuse identity (file
hydration now happens on the row, keyed on the file map), sets the flat
flag before the parity config snapshots the server env, and gives the
seeded alternate branch consistent turn numbers.

* 🧹 style: Sort Imports in the Thread Renderer Files

* 📏 chore(e2e): Sample Renderer CPU and Post-GC Heap in the Tree Benchmark

Adds a CDP resource probe to each phase: renderer-process CPU time (all
threads), JS heap after a forced GC (retained memory rather than allocation
churn), DOM node and listener counts. Also lets TREE_PARITY_MATCH pick
which mock specs the parity config runs, and derives the deep-switch
phase label from the seeded thread size.
2026-09-06 14:30:50 -04:00
Danny Avila
d812e2f98f
📏 style: Center Every Row Glyph on the Avatar's Axis (#15643)
* 📏 style: Center Every Row Glyph on the Avatar's Axis

Two rails were in use under a message header. `AgentHandoff` and `AgentUpdate`
gave their glyph a 24px slot — the width of the header avatar — so the glyph
centered on the avatar's axis and the text started where the name does. Every
other row used a 16px (thinking: 18px) slot: tool cards through `ProgressText`,
`ToolCallGroup` headers, the phase card's check, and the streaming cursor a
folded card renders beneath itself. Measured in Chromium against the avatar's
left edge: avatar center 12, those glyphs 8–9, and their text at 24–26 against
the name's 32. The cursor was also 5px low, because `.result-thinking` hangs
its dot 11px above a text line's box, which is right for the streaming
markdown cursor and wrong for a row.

`ROW_GLYPH_SLOT` in `rows.ts` is the one definition: a 24px, centered slot
(`min-w` rather than `w`, so a stacked icon strip can run wider). It is taken
by `ProgressText`'s icon, both `ToolCallGroup` glyph branches, the phase
check, the thinking button, and the cursor; `AgentHandoff`'s gap drops from
2.5 to 2 so its text meets the name too. The cursor stops borrowing
`EmptyText` and draws the dot through `.result-thinking-inline`, a variant
that puts the same pseudo-element in flow so the slot can center it.

After: every glyph at 12, every text edge at 32, the dot centered in its row.

* 📏 fix: Keep the Glyph Slot Inside the Row and the Dot Override Local

Review follow-ups on the row rail.

- The slot was 24px tall inside a 20px row. `ProgressText` positions its
  content absolutely at the row's top, so a taller slot could not be centered
  by the row and carried every call card's glyph and label 2px low. The slot
  keeps its 24px width and takes the row's 20px height.
- The pending skill row rendered its icon straight into the gap; the real
  `SkillCall` that replaces it in place used the slot, so the swap moved the
  glyph 4px and the text 8px. Both rows share the slot now.
- The cursor's in-flow dot no longer needs a global selector: `after:!static`
  on the element puts the one pseudo-element back in flow, and the `!` is what
  outranks the dot rule's three-class selector. The thinking button takes the
  shared slot instead of its own 24px square.
- A `span` wrapped `StackedToolIcons`, which renders a `div` for a strip; the
  wrapper is a `div` now.

* 📏 fix: Give ThinkingLabel the Shared Glyph Slot

`ThinkingLabel` exists to keep the reasoning-unavailable row identical to the
`ThinkingButton` row it stands in for, and the previous commit moved only the
button onto the shared slot — a detached subagent projection would have kept
its glyph at 9px and its text at 24px next to rows at 12px and 32px.

* 📏 fix: Put the Image-Gen and Web-Search Glyphs in the Shared Slot

`Part.tsx` routes image generation and web search to renderers that draw
their own glyph instead of going through `ProgressText`, so the slot the
previous commits gave every other row skipped them: their 16px icons and the
favicon stack still sat on the old axis, and a labeled phase containing either
call would have shifted sideways as it folded into the updated header. Both
rows take `ROW_GLYPH_SLOT`; the web-search streaming row's gap drops from 2.5
to 2 so its text meets the name's edge like the rest.
2026-09-06 11:31:35 -04:00
Danny Avila
aeac7a2065
🪪 feat: Add Per-Agent Git Identity (#15628)
* feat: Add per-agent Git identity

* fix: annotate git identity schema

* fix: complete git identity controls

* fix: clear git identity on version restore

* fix: Require a complete agent Git identity

* fix: Complete Git Identity Across Bash And Form Validation

* fix: Discard Incomplete Hidden Git Identity Edits

* fix: validate Git identity across panel lifecycle

* fix: preserve saved Git identity when discarding drafts
2026-09-05 23:56:23 -04:00
Marco Beretta
971e076015
🎛 refactor: Replace Agent Skills Toggles With a Three-Way Mode Control (#15520)
* refactor: replace agent skills toggles with a three-way mode control

The Skills section in the agent builder exposed one dependent choice as two
peer switches. "Use all skills" only meant anything while "Enable skills" was
on, and turning it on hid the skill list, so the user could not see what "all"
covered. Two Add affordances competed for the same action and both labels
leaned on a tooltip to explain themselves.

Replace both switches with a single segmented control over the SkillsScope
enum that already existed. Off, All, and Selected now write skills_enabled and
skills_scope outright, so the mode is the only source of truth for catalog
exposure and the allowlist survives a round trip through All.

Extract the section into SkillsSection. That drops the badgeText, showAdd,
showBody, and children props SelectedSection only carried to bend the tools
layout into a skills layout, and it retires skillsSelectionTransition, which
inferred the capability flags from the allowlist length and flipped skills off
whenever the last skill was removed.

All mode reports how many skills the deployment exposes and expands a
read-only list, so the catalog is never hidden. Selected mode keeps one Add
affordance: the dashed card while nothing is chosen, a header button once rows
exist.

Legacy agents keep loading through resolveAgentSkillsScope. The one ambiguous
persisted shape, skills_enabled with no explicit scope, is normalized on load
without dirtying the form so the next save records the mode explicitly.

Also give the shared Radio the roving tabindex and arrow key handling a
radiogroup owes its users; every segment was previously its own tab stop with
no way to change the selection from the keyboard.

* chore: add temporary PR comparison screenshots

* chore: drop temporary PR comparison screenshots

* fix: address PR review bot findings on the skills mode control

Codex (P1):
- Compare the resolved mode, not the raw persisted scope, before treating a
  segment click as a no-op. An agent left with `skills_enabled: false` and a
  retained `skills_scope` renders as Off, so matching on the raw field
  swallowed the click that re-enables it while the shared Radio moved its own
  selection, leaving the form clean and the disabled state persisted.
- Exempt explicit scopes from the legacy allowlist normalization in
  AgentSelect. Off deliberately keeps the allowlist so returning to Selected
  restores it, and flipping `skills_enabled` there persisted skills-enabled on
  an agent shown as Off, which skillDeps reads as permission to inject the
  skill-authoring tools.

Codex (P2):
- Report a failed catalog request instead of rendering it as an empty catalog.
  All mode showed "0 skills available" over an empty list when /api/skills
  failed; it now renders the picker's alert with a retry.
- Stop paging the whole catalog before the list is opened. Merely viewing an
  All-scoped agent walked every cursor at 100 records a page and retained each
  summary. Pagination now waits for the expansion, and the header reports the
  loaded count as a floor while more pages remain.
- Honor an explicit `skills_scope` in both skill cleanup paths. Deleting the
  last allowlisted skill, or pruning a dangling id on save, forced
  `skills_enabled` to false without consulting the scope, so an All-scoped
  agent that had once picked a single skill was silently switched off. The
  fail-closed inference now applies only to legacy agents that persist no
  scope at all.

Copilot:
- Skip the onChange when Home or End lands on the already-checked segment.
  Focus still follows the key; only a selection that does not move stops
  firing a form write.

* fix: address second round of PR review bot findings

Codex (P1):
- Normalize authoring left on under a resolved Off. An agent carrying
  `skills_enabled: false` with `skill_authoring_enabled: true` renders as Off,
  yet skillDeps enables the skill-authoring tools for either flag, so it ran
  with skills the section reported as disabled. Clicking the already-selected
  Off segment is a no-op, so nothing ever cleared it. The section now clears
  the flag on load without dirtying the form, matching what selecting Off
  already writes.

Codex (P2):
- Apply the scope-aware pruning in createAgent and revertAgentVersion too, not
  only updateAgent. Restoring an All-scoped version whose skills have since
  been deleted silently came back as Off, and createAgent had the same
  unconditional branch for ids that go stale before the write lands.
- Collapse the duplicate first-page skills request. ToolsSection listed skills
  through useListSkillsQuery while the section and the picker used
  useSkillsInfiniteQuery, so the same endpoint was fetched under two React
  Query keys and could not be deduplicated. All three consumers now share the
  infinite query, which leaves one cache entry instead of two.

Also sorts the imports the repo's checker flagged in SkillsSection,
ToolsSection and the section's spec.

* fix: clear the skills master flag under a resolved Off

`skills_enabled: true` with `skills_scope: none` is a shape the API accepts,
and the resolver reports it as Off. `skillDeps` reads the master flag on its
own as permission to expose the skill-authoring tools, so the agent ran with a
capability the section said was disabled, and because clicking the
already-selected Off segment is a no-op there was no way to clear it without
cycling through another mode.

The normalization that already cleared `skill_authoring_enabled` now clears
both flags whenever the resolved mode is Off, still without dirtying the form.
Neither write fires while a catalog mode is active.

* fix: disable skills for an explicit none scope in allowlist cleanup

The scope-aware fail-closed rule exempted every explicit scope, which spared
one shape it should not have: `skills_enabled: true` with `skills_scope: none`.
The API accepts that combination, the builder renders it as Off, and skillDeps
reads the master flag on its own as permission to expose the skill-authoring
tools. Cleanup runs server side without the builder mounted, so the frontend
normalization cannot repair it.

Only `all` and `selected` opt out now, since each already defines what an
empty allowlist means. The three self-heal paths in agent.ts share a
`requiresSkillsDisable` predicate, and the Mongo filter in skill.ts uses
`$nin: [all, selected]`, which still matches an absent field for legacy
agents.

* test: align the skills e2e spec with the explicit-mode contract

Three assertions still encoded the removed toggle behavior:

- The remove button is labelled `Remove {name}` in the new section, not
  `Remove from agent`, so both removal steps waited 180s for a button that no
  longer exists. That was the timeout, not a failed expectation.
- Emptying the allowlist no longer infers Off. The save writes `skills: []`
  and leaves the mode at Selected, which resolves to no skills at runtime, so
  the spec now asserts `skills_enabled: true` with `skills_scope: 'selected'`
  and keeps the existing proof that the picker and the run expose nothing.
- All leaves `skills` untouched, so a fresh agent serializes no allowlist at
  all rather than an empty one: `composeAgentUpdatePayload` always carries the
  four skill fields and `JSON.stringify` drops the undefined ones. Create and
  Off now assert `skills_scope` instead of an empty array.

Adds `skills_scope` to the spec's payload and detail types.

* fix: address third round of PR review bot findings

All three are P2 accuracy and cost issues in All mode:

- Count only the skills the runtime would inject. The list endpoint returns
  every skill the user can VIEW, while catalog resolution filters each through
  `resolveSkillActive`, so a shared skill left inactive was counted and listed
  as available even though the agent never receives it. The section now shares
  the `isActive` predicate the chat-side picker already filters on, so the
  count cannot promise more than the runtime delivers.
- Report loading instead of an empty catalog. With a cold query `data` is
  undefined and the count derived to "0 skills available", presenting an empty
  deployment while it was merely loading.
- Skip the allowlist lookups outside Selected. `useResolvedSkills` issues one
  `getSkill` per allowlisted id missing from the first catalog page, and since
  All now retains previous picks, merely viewing such an agent could fire
  hundreds of requests for rows that mode never renders. The fallback is gated
  on Selected, where the rows exist.

* fix: gate the All catalog on resolved skill states

`useSkillActiveState` substitutes an empty override map while its own request
is in flight and after it fails, so `isActive` reports every skill active in
both states. The section consumed the predicate but discarded the status, so a
deliberately deactivated owned or deployment skill was counted and listed as
available: briefly during load, and permanently after an error.

The count now waits for both requests, and a failure in either renders the
alert instead of a count the runtime would not honor. Retry refetches both,
which needed the hook to expose its `refetch`.

* fix: resolve the config behind defaultActiveOnShare before filtering

`useSkillActiveState` reads `defaultActiveOnShare` from the interface config
and falls back to `false` while that request is pending or after it fails, so
a deployment configured with `true` had its shared skills filtered out of the
All count until the config landed, and permanently on error. The section only
gated on the skills and skill-states queries.

Both dependencies feed `isActive`, so the hook now reports them as one
signal: `isLoading` and `isError` cover the override map and the config
alike, and `refetch` retries both. A consumer gating on the pair can no
longer miss a dependency, which is how the previous gap arose. The section is
the only consumer of those flags.

Also composes the retry from the shared `Button` (`outline`, `sm`), matching
the picker's own retry instead of a feature-local recipe.

* fix: report what the All catalog loaded, not a lower bound

`hasNextPage` tracks raw pagination while the rows are filtered to the
runtime-active skills, so the two disagree: 30 active skills followed only by
deactivated ones made the header read "30+ skills available" when 30 was the
true total, and it stayed wrong until the user expanded the list and finished
paging.

While pages remain the header now describes what has been loaded rather than
claiming a floor on what is available, so it cannot overstate the catalog. The
exact "N skills available" phrasing still lands once the catalog is complete.
`com_ui_skills_available_count_more` is replaced by singular and plural loaded
keys.
2026-09-06 03:32:56 +02:00
Marco Beretta
8144574b43
♿ feat: High Contrast Light and Dark Appearance Modes (#15178)
Some checks are pending
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
Sync Locize Translations & Create Translation PR / Sync Translation Keys with Locize (push) Waiting to run
Sync Locize Translations & Create Translation PR / Create Translation PR on Version Published (push) Blocked by required conditions
* refactor: read status fill labels from the theme token

Feature call sites paint the label on bg-surface-destructive,
bg-surface-submit and the bg-status-*-strong fills with the raw
text-white utility, while the shared Button, IconButton and Toast
primitives already use text-text-on-status. The token exists so the
label colour can differ per theme mode, and hard-coding white pins it.

Point every call site at text-text-on-status, and compose
DeleteIconButton onto the Button destructive variant rather than
re-declaring the fill classes. Five call sites paired a status fill with
the wrong token entirely (text-text-secondary, text-text-inverted) or
used the non-strong hue as a solid fill; those move to the -strong fill
with the on-status label. Tooltip.css and the app stylesheet copy of the
same rule read colour from --text-primary instead of literal black and
white, and the dead outline: var(--bg-surface-hover) in Dropdown.css
becomes a real 2px token outline, since that variable is not declared
anywhere and the focus ring never rendered.

--text-on-status is 255 255 255 in both shipped themes, so this is a
no-op for the light and dark palettes.

* feat: add high contrast light and dark appearance modes

Adds two appearance modes to the theme setting for users who need more
than the standard palettes, plus contrast resolution for the system mode.

The palettes are complete IThemeRGB maps rather than partial overrides,
because a token left to fall back to defaultTheme or darkTheme would
reintroduce a mid-grey the mode exists to eliminate. They resolve as a
built-in ThemeDefinition that outranks a deployment's custom theme, since
a contrast choice is an accessibility need rather than a branding
preference.

Text clears WCAG AAA on every surface it can render on, including the
hover and active fills. Borders, rings and series marks clear the 3:1
non-text floor. Solid fills clear AAA against both their label and the
page, which is what the per-mode text-on-status token buys: each mode
paints its fills on the far side of its own canvas, dark fills under a
white label on white and bright fills under a black label on black, so
the two ratios coincide instead of pulling apart.

The system mode now follows prefers-contrast the same way it already
follows prefers-color-scheme, so a user who has switched on Increase
contrast or Contrast themes gets the accessible palette without first
finding this setting. isDark reports high-contrast-dark as dark;
isHighContrast answers what the user picked, which is what the theme
toggle preserves when it flips the scheme; resolvesToHighContrast answers
whether the palette applies.

The icon toggle keeps a contrast choice when it flips the scheme, and
announces which of the four states it landed in.

* feat: cover the non-tokenized chrome in high contrast

The token layer reaches every IThemeRGB surface, but a good deal of the
stylesheet predates it and holds literals the palette cannot move. Under
html.high-contrast:

The typography variable block is 32 hard-coded hex values, and message
content carries prose dark:prose-invert, so the invert half is what dark
mode reads. Both halves now resolve from tokens: prose links were 3.77:1
on a black canvas and 5.40:1 on a white one, and every rule and border in
the set sat below the 3:1 non-text floor in one mode or the other.

The highlight.js palette is raw hex and tops out at AA, worst cases
4.84:1 for dark attributes and 5.32:1 for the alpha-blended dark comment;
these reuse the palette's own hues at AAA on each canvas.

Focus perimeters go to 3px and read the ink token rather than literal
black and white. Selection was left to UA system colours and is now an
explicit inversion. Ring opacity is pinned at full strength for the
controls that halve their own. Popover and tooltip elevation trades a
black shadow, which separates against nothing on a black surface, for a
token border. Prose links carry an underline so they are not distinguished
by colour alone. The switch track, the scrollbar thumb and track, the
markdown structure borders and the body background that .dark pins to
#212121 all move onto tokens.

* feat: draw panel and dialog edges in high contrast

Adds a high-contrast: Tailwind variant to the shared preset, so styling
can be scoped to the contrast modes the way dark: is scoped to the dark
class. Deliberately not named contrast-more, which Tailwind already ships
as the raw prefers-contrast media query: this follows the resolved app
mode, so it covers an explicit choice as well as the OS preference.

Two surfaces rely on a colour step that high contrast removes. The
sidebar's right edge is a resize separator that is transparent until
hovered, which is fine where surface-primary-alt carries the boundary but
leaves no edge at all when both sides are the same pure white or black.
Dialogs are borderless and lean on a black shadow, which separates
against nothing on a black canvas.

Both now draw a real edge in the contrast modes only. The dialog change
sits in the Radix content primitives and the two shared templates so the
feature dialogs inherit it, plus the settings panel, which is Headless UI
and bypasses them. OGDialogTemplate carries border-none, so the variant
restores the border style as well as the width.

* fix: address PR review bot findings

chatgpt-codex-connector:

Move the syntax palette into semantic theme tokens. The highlight.js
colours were raw hex in style.css, so a palette change had to be made
twice and neither copy was covered by the registry's completeness check
or any contrast test. They are eight rgb-syntax-* tokens now, declared
across all four theme maps and consumed as CSS variables, which lets the
whole high-contrast block for highlight.js go away. Two guardrails come
with them: the contrast modes assert AAA for every syntax role on the
code surface, and the stylesheet is pinned to the runtime themes with no
hard-coded hex allowed in an .hljs rule.

Two values could not be carried over literally: the dark comment and meta
colours were alpha-blended whites, so they are stored as the flattened
equivalents over the #212121 code surface. Everything else, including the
dark code text, renders byte-identical to before.

Declare Tailwind as a preset dependency. The preset ships as a raw file
through the ./tailwind-preset export while tailwindcss is only a
devDependency, so require('tailwindcss/plugin') could fail to resolve for
a consumer under pnpm or Yarn PnP. Dropped the require instead of adding
a peer dependency, since Tailwind accepts a plain function in plugins and
the wrapper only adds option handling this variant does not use.

Route remaining solid controls through semantic status roles. The
assistant builder kept bg-red-600/bg-red-700 and bg-green-500 with
text-white, which the built-in palette cannot reach, leaving them below
the mode's contract at roughly 2.28:1 for the green controls. All five
now use the destructive and submit surfaces with the on-status label, and
the two that also suppressed their focus ring get a semantic one.

* fix: address second round of PR review bot findings

chatgpt-codex-connector:

Migrate the builder submit to semantic status colors. AssistantPanel's
submit button kept btn-primary, which hardcodes #10a37f and white in
style.css, alongside a raw green hover and focus border. It uses the
submit surface with the on-status label now, and drops btn-primary rather
than fighting its specificity. Left .btn-primary itself alone: restyling
every primary button in the app is not this PR's business.

Give provider avatars contrast-safe brand colors. The white glyph sat at
2.30:1 on OpenAI green, 2.45:1 on Anthropic tan and 3.41:1 on GPT-4
purple. brands was a single theme-wide set, and a brand fill has to carry
a glyph and stand out from the canvas, both of which flip between modes,
so one set cannot serve both at enhanced contrast. ThemeModeDefinition
takes an optional brands block now, resolved after the theme-wide set, and
high contrast declares dark tints under a white glyph for light and bright
tints under a black glyph for dark. Worst pair is 8.76:1 for both the
glyph and the silhouette, with provider hues still recognisable. Brand
validation is shared between the two levels rather than duplicated.

Raise active-surface contrast against the canvas. The active fills sat at
1.48:1 and 1.98:1 on white, 1.93:1 and 2.91:1 on black, and since every
ink token collapses to one colour here, dozens of call sites were left
conveying the selected state with a sub-3:1 fill alone. The fills now
clear 1.4.11 at 3.14:1 to 4.29:1.

That costs the AAA label on those two fills, and the trade is unavoidable:
above the luminance where a fill clears the 3:1 state floor, its own label
cannot reach 7:1, and below it the state disappears. No integer grey
satisfies both. 1.4.11 is Level AA and 1.4.6 is Level AAA, so the state
wins and the labels land at 4.89:1 to 6.69:1. The spec now separates
canvas and hover surfaces, which keep AAA, from the active fills, which
assert the state floor and an AA label.

* fix: address third round of PR review bot findings

chatgpt-codex-connector:

Drop the overriding btn-primary class from Select. My previous round
assumed Tailwind utilities would win here by source order; they do not.
In the built stylesheet .btn-primary sits at byte 136886 and
.bg-surface-submit at 69233, equal specificity, so the hardcoded green won
and that button had never followed the palette. Removed btn-primary, the
same way as the submit button beside it.

Preserve contrast mode when theming Mermaid output. isDark collapses a
contrast mode onto the same boolean, so the cache key was unchanged across
light to high-contrast light and an already-rendered diagram survived the
switch untouched. Both diagram paths take the resolved contrast now: the
cache key gains a suffix, and the config carries themeVariables built from
the contrast palette, since Mermaid's own neutral and dark themes hold a
palette no theme token can reach. Diagrams render on the canvas with ink
nodes, ink edges and ink labels, which is 21:1 for every mark and label.

Artifact diagrams go through the same helper: getMermaidFiles takes the
flag, switches the generated document to Mermaid's base theme, which is
the only built-in that honours themeVariables, and paints the page with
the contrast canvas instead of the fixed #212121 or #FFFFFF. The helper
returns undefined outside the contrast modes, so standard themes keep
their current rendering exactly.

* fix: publish resolved contrast through theme context

chatgpt-codex-connector: notify consumers when system contrast changes.

Under `system` the contrast comes from a media query, so `theme` stays
`system` when the OS preference flips and React has nothing to rerender
on. The listener I added last round only touched the root element, which
is enough for CSS but not for anything computing from the resolved value:
the Mermaid cache key and the artifact files would have kept the old
palette while the rest of the app switched.

ThemeContext exposes `highContrast` now, held as state and set wherever
the mode is applied, which covers both an explicit choice and a media
change. `useMermaid` and `useArtifactProps` read it from context instead
of deriving it locally. `resolvesToHighContrast` stays exported as the
predicate the provider itself resolves with.

The existing media-change test now also asserts the context value moves,
not just the class on the root, since the DOM assertion alone passed
before this fix.

* fix: publish the resolved scheme through theme context too

chatgpt-codex-connector: publish resolved scheme changes through context.

Same staleness as the contrast case, one field over. With the mode at
`system` and contrast already on, an OS colour-scheme change reapplied the
DOM palette but `setHighContrast(true)` was a no-op and `theme` stayed
`system`, so no consumer rerendered and the diagram hooks kept the
previous `isDark` result. This half predates the PR: those hooks derived
the scheme from `theme` before it too, so a scheme flip under `system` has
never reached them.

ThemeContext exposes `resolvedMode` alongside `highContrast`, both set
wherever the mode is applied. The two diagram hooks read the scheme from
context instead of calling isDark themselves.

The other isDark call sites are left alone: none of them cache, so they
recompute whenever something else rerenders them, and sweeping every
consumer onto the context value is a wider change than this PR should
carry.

* fix: address sixth round of PR review bot findings

chatgpt-codex-connector:

Restore a visible focus cue for dropdown options. `.select-item` blanks
its own outline with `outline: none !important`, so the contrast focus
rule never landed and the navigated option was marked only by a
surface-hover fill at 1.48:1 on white and 1.93:1 on black. Hover stays
deliberately soft in these palettes, since it is transient and can afford
an AAA label, so the cue has to be a perimeter: a 3px inset outline on
the active and focused option, matching the !important it has to beat.
Verified with real keyboard navigation that the outline resolves to the
ink colour in both modes.

Apply contrast tokens to artifact controls. getMermaidFiles took the
contrast flag last round but still built its controls from the standard
palettes, whose fixed greys leave the zoom label below AAA and whose
10%-alpha border and divider sit below the 3:1 non-text floor against a
pure canvas. The controls now come from the same tokens as the diagram:
canvas fill, ink border and label, the active surface for hover, and no
shadow, since a black shadow separates against nothing there.

* fix: ignore undefined brand overrides when resolving a theme

chatgpt-codex-connector: ignore undefined mode brand overrides.

Partial<IThemeBrands> lets a key be present with undefined, and the brand
validator accepts it, so spreading a mode block over the inherited set
could overwrite a brand with nothing. Colors survive this because
mapColors skips undefined, but every brand token is written to the DOM
unconditionally, so the avatar would have lost its fill instead of falling
back the way a partial theme promises.

Both spreads now drop undefined entries, which covers the theme-wide set
as well as the mode block, and keeps ResolvedThemeDefinition.brands honest
about being fully populated.

* fix: address eighth round of PR review bot findings

chatgpt-codex-connector:

Guard media queries during server rendering. The state initializers I
added read prefers-color-scheme and prefers-contrast synchronously during
render, so a server-rendered provider threw before producing markup. That
was a regression: nothing in the provider read a media query during render
before. Both reads go through a helper that returns false without a
window, the way the storage helpers already tolerate its absence, so the
server renders the light palette with no contrast override and hydration
applies the real values. The subscription effect is guarded too, which
also covers a host that has no matchMedia at all.

Keep Mermaid pie slices distinct in contrast mode. My own regression: the
contrast variables set primaryColor, secondaryColor and tertiaryColor to
the canvas, and mermaid derives pie1 through pie3 from those, so every
slice collapsed into the background and into its neighbours. The pie slots
come from the palette's series ramp now, which is the categorical scale
already built to clear the mark floor on that canvas and stay separable
under simulated deuteranopia. Twelve slots wrap over seven, as mermaid's
own palettes do.

Remove the raw white override from bookmark submit. The save button passed
text-white into the shared submit variant, which tailwind-merge resolved
in favour of the local class, leaving white on the bright submit fill at
1.40:1. Dropped the override so the variant's token applies.

Preserve the high-contrast canvas in screenshot exports. The export chose
between two fixed colours, so a contrast export was filled with #171717
instead of the mode's canvas. It reads the resolved canvas token now, with
the old pair as the fallback.

Theme markdown artifact previews in contrast modes. useArtifactProps
forwarded the appearance only to the mermaid branch. getMarkdownFiles
takes it now and appends a contrast block derived from the palette; being
unconditional it also outranks the sheet's own prefers-color-scheme query,
so an explicit contrast choice is honoured whatever the OS reports.

* fix: migrate agent version controls to semantic status roles

chatgpt-codex-connector: migrate agent-version controls to semantic status
roles.

The active-version marker and the Restore action used raw green fills with
text-white, about 2.28:1 and 3.30:1, and the built-in palette cannot reach
either. The marker takes the strong success fill with the on-status label,
and Restore takes the submit surface, matching the assistant builder
migration.

Also finished the rest of that component's active-version treatment rather
than leaving it half migrated: the card border and tint, the title, and
the Current chip now use the success subtle, border and strong roles. The
same indicator was expressing one state through both raw and semantic
colour otherwise.

ToolCard's native badge and selected tick were the same shape, raw emerald
under white, so they move to the strong success fill too.

Left alone: the HTTP method badges in ActionsTable/Columns.tsx, the
tool-kind colours in items/icons.ts, and CategoryFilter's active border.
Those are categorical identity rather than status, so mapping them onto
status roles would be wrong; they need the treatment provider brands got,
which is its own change.

* fix: address tenth round of PR review bot findings

chatgpt-codex-connector:

Use opposing ink for pie-section labels. My own regression from the slice
fix: the series ramp deliberately sits on the far side of the canvas so
slices are visible, which makes the canvas ink the wrong colour for a
label drawn inside one. Section labels take the on-status ink now, the
same colour the palette uses for a label on any solid fill, while the
title and legend keep the canvas ink because they are drawn on the canvas.

Preserve the blue initializing status in standard themes. Also mine, from
the first round: I moved this dot to bg-status-info-strong, and the strong
info slot is a neutral grey in both standard palettes, so a blue
indicator turned grey. Back on bg-status-info, with the pulse taking the
on-status ink so it inverts with the fill rather than being a fixed white.

Route action method badges through contrast tokens. I declined this last
round as categorical identity rather than status; the reviewer's framing
is better. The series ramp is precisely the home for categorical identity,
it is contrast-checked per mode, and its slots are separable under
simulated deuteranopia, so the verbs map onto it while staying close to
their conventional colours. `delete` keeps a red by taking the error role,
since destructive genuinely is a status.

* fix: seed published theme values without reading a media query

chatgpt-codex-connector: defer media-query resolution until after
hydration.

Guarding window stopped the crash but left the server and the first client
render disagreeing: the server produced light and false while the client
resolved the OS preferences during that same first render, so any child
reading the published values hydrated against different context.

Both are seeded from the mode string alone now. An explicit mode needs no
query, so it publishes immediately and stays consistent with isDark; only
system starts at the light palette with no contrast override, on both
sides, and applyThemeMode publishes the resolved values from its effect
after hydration.

The pre-existing localStorage read in getInitialTheme has the same shape
of problem for `theme` itself, but changing where the stored mode is read
is a wider change than this and belongs on its own.

* fix: address eleventh round of PR review bot findings

chatgpt-codex-connector:
- keep the active version timeline rail opaque so it clears the 3:1 mark
  floor in both high contrast modes instead of compositing to ~2:1
- balance the dark success fill (#088759) so the selected-tool marker,
  the timeline rail and the prompt-version chip keep a visible silhouette
  on the #212121 panel while the white label stays at WCAG AA
- include the resolved scheme and contrast in the mermaid cache key even
  when a custom theme is supplied, so a contrast switch re-renders

* fix: address twelfth round of PR review bot findings

chatgpt-codex-connector:
- select mermaid's base theme ahead of a caller-supplied theme in the
  contrast modes, after the config spread, so the contrast variables
  actually reach the diagram
- ship the tooltip and popover contrast edges in the package stylesheets
  they belong to, so a consumer importing @librechat/client gets them

* chore: sort imports in the theme registry, provider and specs

* fix: override the markdown preview table header in contrast modes

The appended contrast block answered the ink, the canvas and the cell
borders but not the thead tint, so an explicit contrast choice on the
opposite OS scheme left white text on #f6f8fa or black text on #161b22.
The header now takes the palette canvas and reads through its bold cells
and border, and a new guardrail asserts every colour the base sheet sets
inside prefers-color-scheme is answered by the override.

* fix: address thirteenth round of PR review bot findings

chatgpt-codex-connector:
- keep an OS-requested contrast when the scheme toggle runs under the
  system mode, by reading the resolved contrast rather than the stored
  appearance name
- move the unchecked switch track into the theme token registry so the
  shared Switch keeps its track for consumers of @librechat/client, and
  drop the SPA-only high-contrast overrides it no longer needs

* fix: address fourteenth round of PR review bot findings

chatgpt-codex-connector:
- migrate agent and assistant validation states off raw red utilities and
  onto the destructive text and border roles, so the messages, the field
  outlines and the required markers follow the contrast palettes
- theme the file-source badges with series slots and the status label ink
  instead of fixed blue and yellow fills behind an alpha

* fix: paint the loading canvas from the resolved appearance

The bootstrap in index.html read the stored mode's scheme but not the OS
contrast, so system plus prefers-contrast: more flashed the standard-dark
#0d0d0d behind the pure-black palette for the whole application load. An
unset mode also painted white on a dark OS, though getInitialTheme
resolves it as system. Both branches now resolve the same way the theme
provider does, and a new spec runs the shipped script to prove it.

* fix: theme the markdown renderer failure message

The notice painted when the marked CDN does not load carried an inline
color:#e53e3e, the one colour the appended contrast block could not
reach, leaving it at 4.13:1 on the high-contrast light canvas. It is a
.markdown-error rule now, which the base sheet declares with the current
red and the contrast block overrides with the palette's destructive ink.

* fix: address PR review bot findings

chatgpt-codex-connector:

- Route shortcut, steer, warning, and help-link states through semantic theme roles.
- Add contrast-safe Mermaid Gantt variables for task, status, section, grid, and label states.
- Theme Mermaid artifact render failures with destructive text colors.
- Apply native color-scheme behavior through ThemeProvider and restore host values.

* fix: address follow-up PR review findings

chatgpt-codex-connector:

- Route conflicting shortcuts through the semantic warning border.
- Give checked composer capabilities opaque semantic series borders.
- Move search results and their fade onto the presentation token.
- Restore a visible semantic focus ring on the virtualized results list.

* fix: address third-round review findings

* fix: address fourth-round review findings

* fix: align accessibility theme after dev rebase

* fix: address PR review bot findings

chatgpt-codex-connector:
- Route the steer and queue identities through semantic `status-warning` /
  `status-info` roles in `Chat/Steering/identity.ts`, so the receipt label,
  its pulse dot and every Zap/Clock mark move with the theme instead of
  staying pinned to amber-500/600 and cyan-500. Fixes the high-contrast
  light failures (3.19:1 label text, 1.97:1 and 2.43:1 marks) and the
  default light label, which was also below the 4.5:1 text floor.
- Pair each Monaco theme with the canvas it paints in `ArtifactCodeEditor`,
  so the transparent `@monaco-editor/react` loading view no longer flashes
  the light `surface-code` fill before the `vs-dark` editor mounts outside
  high contrast.

* fix: declare the new dev theme tokens in the high contrast palettes

dev added rgb-text-muted and the two chart widget tokens after this branch
last rebased. The high contrast palettes did not name them, so the widget
canvas and muted text fell back to the standard themes' greys, which the
palette coverage spec caught. Both modes now take the plain canvas, pure
ink and a pure-ink edge, and the contrast tables cover the new tokens.

* style: sort imports in the specs this branch touched

The added imports put ArtifactCodeEditor, ShortcutRecorder and OptionToggle
out of the repo's import order, which the static-checks import-sort gate
rejected.

* fix: address fifth-round review findings

chatgpt-codex-connector:
- Preserve the pressed treatment on a disabled OptionToggle, so a tool made
  programmatic-only keeps showing the Intent state aria-pressed still reports.
- Expose high contrast from the auth appearance control: the scheme toggle
  preserves contrast but never introduces it, so a logged-out user had no way
  to reach the palette. Adds a contrast toggle beside it, and the scheme toggle
  now shows the scheme rather than duplicating the contrast glyph.
- Resolve system contrast from prefers-contrast: custom and forced-colors:
  active as well as more, since a Windows Contrast Theme never reports more.
  Mirrored in the index.html loading bootstrap and the theme README.
- Route the remaining raw palette utilities through theme roles: agent success
  checks (Action, AdvancedPanel, ToolSection) to status-success, the favorited
  tool star to series-4, the orchestration Beta pill to brand-purple, the
  temporary-composer accent to series-6, and the pending quote marks to
  status-info.
- Override the legacy btn-neutral chrome in the contrast block, whose
  hard-coded edge and hover fill sat at 1.1:1 and 2.09:1 on the new canvases.

Rebased onto dev.

* fix: mark the selected tab and theme placeholder ink in contrast modes

Two states rendered invisibly under the high contrast palettes, both verified
in a browser before and after:

- Radix tab triggers mark selection with `surface-tertiary`, which is the plain
  canvas here, so the selected Settings section computed to the same
  rgb(0 0 0) fill as every unselected sibling. Give it the same inset perimeter
  `.select-item` already uses for its navigated option.
- Tailwind preflight paints `::placeholder` with the raw gray-400 #999696, and
  a field that omits a `placeholder:` utility inherits it: the Custom
  Instructions textarea measured 4.06:1 on the black canvas and 3.08:1 on the
  white one, both under the 1.4.3 floor for what is ordinary text. Route it
  through `text-secondary`, which is pure ink in both palettes.

* fix: mark selection with a perimeter and lighten the contrast selected fills

The selected fill was carrying WCAG 1.4.11 on its own, which forced it dark
enough (#8c8c8c light, #5c5c5c dark) that its own label capped at 6.25:1 and
6.69:1 — under the AAA these modes exist for, and visibly heavy on the light
canvas. The `.select-item` rule already showed the better answer: mark the
state with a `text-primary` perimeter at 21:1 and let the fill stay light.

Generalise that rule to the two families it missed — every other Ariakit menu,
whose navigated row carried only a `surface-hover` fill at 1.48:1 on white, and
any row painted with the selected-surface role — then lighten the fills behind
it: #e3e3e3 / #d4d4d4 light and #2b2b2b / #3d3d3d dark, all four AAA under
their label. `-alt` meets `surface-hover`, as it does in the standard palettes.
Inline `span` is excluded so a highlighted citation passage is not boxed per
wrapped fragment.

The palette contract moves with it: `activeFills` is now held to an AAA label
rather than to 3:1 against the canvas, which the perimeter discharges.

* fix: address sixth-round review findings

chatgpt-codex-connector:
- Ship the selected-state contrast with the package. The lightened
  `surface-active` fills only work because a perimeter marks the selection, and
  that perimeter lived in the SPA stylesheet, which `tsdown` never publishes —
  so `TimePicker`, `SelectDropDown`, `MultiSelect`, `InputWithDropDown`, `Badge`
  and `DataTable` gave an external consumer a 1.28:1 fill and nothing else. The
  perimeters and the placeholder ink now live in
  `packages/client/src/theme/highContrast.css`, imported by `ThemeProvider`;
  `style.css` keeps only what is genuinely SPA-only. The Ariakit selector also
  widened from four menu roles to `[data-active-item]`, and picked up
  `[data-state='selected']` for package data-table rows.
- Give Monaco selections a contrast-safe highlight: a focused selection now
  inverts the canvas (`text-primary` on `surface-primary`), matching
  `::selection`, because Monaco draws no perimeter. Weaker emphases share
  `surface-hover-alt` behind the ink find-match border.
- Populate Mermaid's separate `git0`-`git7` branch palette from the series ramp.
  Eight slots against a seven-slot ramp, so the last takes the ink rather than
  repeating branch one; labels take the canvas, since the ramp sits on its far
  side.
- Debounce the two appearance controls separately. They are independent
  settings, so light -> high-contrast dark is one flip of each, and the shared
  500ms window swallowed the second click.
- Route sharing principal badges (USER/GROUP/ROLE) through series-1/7/6.
- Apply the selected contrast mode to Office artifacts. The backend document
  picks its palette from `prefers-color-scheme` alone, so an explicit mode
  inverted whenever the OS disagreed. `withOfficeContrast` re-declares its
  `:root` tokens and pins `color-scheme` from inside the head.

* fix: address seventh-round review findings

chatgpt-codex-connector:
- Restore the citation highlight. The perimeter rule skips `span` so a wrapped
  passage is not boxed per fragment, which left the inline highlight on the
  lightened fill alone. It inverts now instead — the same treatment the mode
  gives `::selection`, 21:1 and with no geometry to wrap.
- Underline non-prose links. The 1.4.1 rule only reached `.markdown` and
  `.prose`, so the auth resend actions and in-dialog help links were colour-only
  against ink that is under 3:1 from them. It now also covers the shared
  `text-link` role, including the ones rendered as a `button`, and moved to the
  package stylesheet since that role is shared. MCP server descriptions style
  their anchors through an `[&_a]` variant rather than a class of their own, so
  they get the underline at the call site — running text, so it applies in every
  theme, not just the contrast ones.
- Route the selected tool card through `status-success` instead of
  `emerald-500/60` over a 6% fill, which composited to about 1.7:1 and left a
  selected card with a weaker edge than an unselected one.

* fix: keep helper hints opaque in the contrast modes

chatgpt-codex-connector: the `opacity-40` default-value hints composite pure
ink to about #999 on the white canvas (2.85:1) and #666 on the black one
(3.66:1), so small active labels missed even AA under a palette that contracts
for AAA. They take `high-contrast:opacity-100` now — the variant this branch
already added and `MessageNav` already uses — rather than a new token: every
text role is the same pure ink in these palettes, so there is no muted colour
to fall back to and the hierarchy is carried by size and the parentheses.

The mobile artifact drag handle gets the same treatment: it is a control, so
1.4.11 applies, and a 40% ink bar does not clear 3:1. The two remaining
`opacity-40` sites are left alone deliberately — `AssistantTool` dims a
disabled row, which WCAG exempts, and the `MarketplaceCatalog` empty-state
glyph is `aria-hidden` decoration.

* style: sort imports in the two parameter controls this branch touched

* fix: soften the temporary-chat accent outside the contrast modes

Moving the accent to `series-6` swapped a 60%-alpha `violet-800` edge for a
full-strength one, and series-6 is a saturated #7e23cd on the light palette and
#ab68fe on the dark one — the composer read as a warning rather than a quiet
mode hint. Half alpha in the standard palettes, opaque only under
`high-contrast:`, which is the one place the edge has to clear the 3:1
non-text floor.
2026-09-05 22:20:33 +02:00
Marco Beretta
1c115cdebf
🐛 fix: improve sidebar title clarity and hover scrolling (#15644)
* fix: improve sidebar title clarity and hover scrolling

* fix: address PR review bot findings

Copilot:
- Drive the title fade from CSS so autoprefixer emits -webkit-mask-size for
  WebKit; Web Animations silently drops prefixed keyframe properties.
- Guard MediaQueryList subscription so legacy addListener/removeListener
  engines neither miss the change handler nor throw during cleanup.
2026-09-05 19:27:54 +02:00
Danny Avila
a9da01fbe7
📐 fix: Keep the Live Slot Under a Phase Card One Row Tall (#15639)
Some checks are pending
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
Sync Locize Translations & Create Translation PR / Sync Translation Keys with Locize (push) Waiting to run
Sync Locize Translations & Create Translation PR / Create Translation PR on Version Published (push) Blocked by required conditions
* ♻️ refactor: Share the Tool Row Box Across Call Cards

Eight call cards carried the same literal for their header row's box —
`relative my-1.5 flex h-5 shrink-0 items-center gap-2.5` — one per card kind.
It is one design decision (a 20px line with 6px above and below), and the
next commit needs a ninth element to match it exactly, so it becomes
`TOOL_ROW_CLASSES` in `rows.ts`. No rendered output changes.

* 📐 fix: Keep the Live Slot Under a Phase Card One Row Tall

While a run streams, the slot beneath a collapsed synthesized phase card
alternates between two things: the streaming cursor, rendered the moment a
label fills and its row folds into the card, and the next call's row, rendered
the moment that call starts. Replaying a real export through `ContentParts`
step by step showed those two boxes differ: the cursor sat in a bare
`Container` (20px, no margins) while every call row is `my-1.5 h-5` (32px).
Everything beneath the card therefore stepped up on each absorb and back down
on each call — measured at 6px in Chromium with the app's generated CSS, and
larger in the live column where the row's bottom margin cannot collapse.

The cursor now takes `TOOL_ROW_CLASSES`, the exact box of the row it stands
in for, so the swap is height-neutral; a 2px inset centers the 12px dot on
the 16px glyph rail. The test asserts the cursor carries every token of the
row box, and fails against the previous container.
2026-09-05 08:47:19 -04:00
Marco Beretta
f174da6159
📋 feat: Copy Messages as Rich Text (#15087)
* feat: copy messages as rich text

Adds an opt-in setting that places a rendered HTML flavor on the
clipboard next to the markdown, so pasting an assistant response into an
app that does not understand Markdown (Teams, Outlook, Word) keeps its
headings, lists, tables and code formatting.

The HTML is serialized from the same mdast pipeline the message renderer
already uses, with inline styles because those paste targets strip
stylesheets. Raw HTML in a message is escaped rather than passed
through, matching the renderer, and link and image URLs go through the
existing isSafeUrl allowlist.

The plain copies (share links, API keys, OAuth callback URLs) keep using
the base hook, so they are never wrapped in markup. The setting is off by
default: markdown-aware targets prefer the HTML flavor when it is
present, so making it unconditional would regress them.

Closes #13973

* fix: address review feedback on rich text clipboard copy

Mirror the renderer's `singleDollarTextMath: false` so paired currency
such as "$5 to $10" is not read as math and stripped of its dollar
signs in the HTML flavor.

Pair every background the serializer sets with its own foreground, and
let blockquotes and table cells inherit the destination's colors. The
paste target's theme is unknowable, so a lone light background could
land under a dark editor's light text.

Resolve reference-style links and images against their definitions
rather than dropping the hyperlink.

Skip the HTML flavor for user messages while `enableUserMsgMarkdown` is
off. Those render as literal text on screen, so formatting them on paste
would not match what was copied.

* fix: mirror the message renderers more closely in rich text copies

Apply the same `remarkApproxTilde` and `remark-supersub` transforms the
renderers apply to the parsed tree, so `x^2^` arrives as a superscript
instead of literal markers.

Select the renderer to mirror per message: `Markdown` (assistant) enables
directives, `MarkdownLite` (user) does not, so a user message showing
literal `:::` markers keeps them in the HTML flavor.

Resolve path-relative URLs against the app's base URI. A generated file
or image link resolves against LibreChat on screen but against the
destination document once pasted. Absolute URLs are passed through
verbatim rather than normalized.

Serialize each text content part as its own document. Each part renders
through its own Markdown instance on screen, so a construct must not span
two of them; a private-use sentinel carries the boundary through citation
processing, which only touches its own markers.

* fix: match the renderer on line breaks, relative URLs and LaTeX

Message text renders under white-space: pre-wrap, so a soft line break is
a visible line on screen. Emit those as <br /> instead of a raw newline,
which every HTML paste target would collapse to a space.

Screen URLs through react-markdown's own transform rather than the
artifact template's isSafeUrl, which rejected bare relative targets like
docs/guide.html and dropped links the conversation shows as working.
Everything relative is then resolved against the app's base URI.

Apply preprocessLaTeX to assistant segments when LaTeXParsing is on, as
the assistant renderer does, so single-dollar math is read as math rather
than left as literal dollar signs.

* fix: align rich text copies with directives, footnotes and search rendering

Show an inline directive by name, as the artifact plugin displays it,
rather than dropping the marker and keeping only its children.

Number footnotes by the order their references appear and omit a
definition nothing references, matching what the renderer displays
instead of emitting the source label.

Keep a generated citation marker from resolving against a reference
definition that happens to share its number, which linked the citation to
the wrong URL. An unresolved reference now falls back to its own source
form, as remark-rehype reverts one.

Let a caller state the renderer its row was displayed with. SearchContent
falls back to MarkdownLite for a message without content parts whatever
its author, so search results and shared links pass that through.

Replace the part-boundary sentinel with a citation processor that carries
its numbering across parts, so each part is formatted on its own without
a private-use character that message text could itself contain.

* fix: close remaining gaps between rich text copies and the rendered message

Route rooted /images/ sources through apiBaseUrl the way the renderer's
image component does, so a subdirectory deployment's images survive the
paste instead of losing the base path to the leading slash.

Show an artifact directive by its title, which is what its button
displays, rather than pasting the implementation the conversation hides.

Gather footnote definitions into a footer ordered by first reference,
matching where and in what order the renderer shows them.

Keep a loose list's paragraph wrappers. mdast records looseness on the
list, not on every item, so the parent decides whether an item is tight.

Emit the citation footer as its own segment. Appended to a segment ending
in an unclosed fence, the sources were swallowed into the code block.

Pass the search results MessageParts already loads into useMessageHelpers,
which was copying assistant responses with their citation markers stripped
and no sources appended.

* fix: transform MCP markers and default an untitled artifact

Run mcpUIResourcePlugin over assistant segments as the full renderer
does, so a UI resource marker leaves as nothing rather than pasting the
protocol text. An embedded interactive resource has no static form, and
MarkdownLite does not transform the markers, so user turns keep them
literal exactly as they are displayed.

Fall back to the Artifact component's own default title when a directive
carries none, instead of dropping the artifact from the copy.

* fix: honor definition precedence, file link rewrites and error rows

Keep the first of two reference definitions sharing a label, as
CommonMark does, instead of letting the last one win.

Route a user's own generated-file links through the app's file endpoint
the way the anchor component does, so a pasted link points where the one
in the conversation points rather than at the provider URL.

Skip the HTML flavor for an errored row. ErrorMessage renders those, so
serializing the raw payload as markdown would paste something the
conversation never showed.

Scope reserved citation labels to the segment that generated them. Each
part is its own document, so a legitimate reference in one part is no
longer suppressed by a citation numbered the same in another.

* fix: resolve file citations against the references collection

File-search sources live under references, as useCitation reads them,
but the clipboard's type map had no entry for file. Their markers were
therefore stripped without a source, so a citation visible in the
response went missing from the copy.
2026-09-05 13:36:07 +02:00
Ravi Kumar L
000349681e
🩻 feat(insights): Scope Insights to Authorized Agents (#15549)
Some checks failed
Docker Dev Images Build / publish (push) Has been cancelled
Sync Helm Chart Tags / Ignore non-main push (push) Has been cancelled
Sync Helm Chart Tags / Sync chart tags (push) Has been cancelled
* feat(insights): add agent-scoped access

* fix(insights): exclude unattributed assistant messages

* fix(sharing): key role insight toggles by principal

* fix(sharing): preserve insight grant snapshot

* fix(permissions): preserve insight bits atomically

* fix(permissions): guard insight audit rollback

* fix(insights): keep admin grant controls accessible

* fix(permissions): reconcile duplicate principal updates

* fix(insights): show automatic admin access

* fix(permissions): harden insights access updates

* fix(insights): simplify authorization and preserve client state
2026-09-04 20:16:58 -04:00
Danny Avila
3d085b227d
🛰️ feat: Show BYOM Worker Readiness (#15618)
* feat: Show BYOM worker readiness

* test: Exercise approved BYOM commands end to end

* test: Wait for BYOM worker readiness
2026-09-04 19:02:35 -04:00
Danny Avila
d9dfdeb643
💫 style: Align the Phase Summary Rail and Simplify its Fold (#15619)
Some checks are pending
Backend Unit Tests / Build packages (push) Waiting to run
Backend Unit Tests / Codegraph select (push) Waiting to run
Backend Unit Tests / TypeScript type checks (push) Blocked by required conditions
Backend Unit Tests / Circular dependency checks (push) Waiting to run
Backend Unit Tests / Tests: api (shard 1/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / publish (push) Waiting to run
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
Sync Locize Translations & Create Translation PR / Sync Translation Keys with Locize (push) Waiting to run
Sync Locize Translations & Create Translation PR / Create Translation PR on Version Published (push) Blocked by required conditions
* 💫 style: Align the Phase Summary Rail and Simplify its Fold

A phase summary was the only row in a transcript with no icon rail, so its
text sat at 13px while the tool rows it stood for sat at 24px and the rows it
swallowed moved out to 37px behind the card's `px-3` — three left edges in one
block, with every folded row stepping 13px sideways as the box materialized.

- The header takes the same 16px glyph slot every tool row has (`Check`, or
  `TriangleAlert` when the phase failed), which lands its text on the one rail.
- The card chrome is gone: border, background, radius, body padding and
  divider. The summary is a row among rows, so nothing moves horizontally when
  it forms, and the entrance is the two grid rows trading places rather than
  four properties resolving at once.
- The label is a ticker. A synthesized card re-titles itself every time it
  absorbs another finished block, and swapping that text instantly is what made
  the absorbed row look like it simply vanished; the retired summary now rises
  out of the clipped row while the new one comes up from below.
- The label uses `tool-status-text`, so a summary scales with the reader's
  font-size setting like the rows around it instead of sitting at a fixed 14px.

`ToolCallGroup`'s category glyph was a fourth rail at 28px (`h-5 w-5`); it now
matches `ToolIcon` at `size-4`.

`ease-[cubic-bezier(0.16,1,0.3,1)]` emitted nothing: `tailwindcss-animate`
registers its own `ease` utility for `animation-timing-function` alongside
Tailwind's `transition-timing-function` one, an arbitrary value matches both,
and Tailwind resolves that ambiguity by dropping the class. The curve had never
reached the chrome — the two-easings problem the comment warns about, caused by
its own fix. It is written as an arbitrary property now, and it was the only
such usage in the repo.

* 🩹 fix: Settle the Phase Label in One Commit and Drop a Duplicate Media Query

Review follow-ups on the phase ticker.

- `useSmoothStreaming` already resolves to `smoothStreaming && !reducedMotion`;
  subscribing to the same media query again installed one `matchMedia` listener
  per phase card without changing the answer.
- The label copied `text` into state from a passive effect, so a swap with no
  animation could paint the previous summary for a frame while the button's
  `aria-label` already carried the new one. It is adjusted during render now,
  which settles both paths in the same commit.
- The incoming line kept its `animate-in` class only while the retired line
  existed, so clearing that line on its `animationend` could strip the class
  from a slide still in flight. The class now rides its own flag.
- The test's label factory no longer needs `as unknown as`: every field on the
  ACTIVITY_LABEL part but `type` is optional, and the double cast was only
  there because a computed key widens to `string`.

* ♿ fix: State the Phase Header's Inset Focus Ring Locally

The header sits inside a permanent `overflow-hidden` wrapper — the 0fr/1fr
grid needs it — so its focus ring has to be inset or it is drawn outside the
border box and clipped away. That holds today only because the shared ghost
variant supplies `ring-inset`; a change in `packages/client` could remove the
indicator from here with no signal. It is declared on the element now, with a
test that asserts both the clip and the inset ring.
2026-09-04 17:44:23 -04:00
Danny Avila
c302ae6f35
🪁 fix: Honor Endpoint Drop Params in Parameter Panels (#15610)
* Remove parameters from UI when parameter is dropped through dropParams

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Addressed copilot and codex review suggestions

* 1. Normalize drop parameter names in client/src/components/SidePanel/Parameters/Panel.tsx
  Admin-configured dropParams for Azure/OpenAI-compatible custom endpoints use the effective backend field names (maxTokens, topP, frequencyPenalty, presencePenalty), but the panel's filter compared them against the UI's
  snake_case keys (max_tokens, top_p, etc.), so the controls stayed visible and silently discarded whatever the user set. Added a dropParamsBackendToUIKey map (in packages/data-provider/src/parameterSettings.ts) and normalize
  each dropParams entry through it before filtering.

  2. Apply the same drop-parameter filtering in client/src/components/SidePanel/Agents/ModelPanel.tsx
  The Agent builder's model panel built its parameter list independently and never consulted endpointsDropParamsMap at all, so it kept offering controls for Azure/custom providers whose values the backend drops. Reused the
  same resolution logic (including the new backend→UI key normalization) there, sourced from useGetStartupConfig.

  3. Remove any escapes from Azure fixtures in packages/api/src/app/config.test.ts
  Three tests built azure groupMap/modelGroupMap fixtures via ... as any as AppConfig['endpoints'], bypassing type checking for that shape. Replaced them with two typed helpers, createAzureGroupMap and createAzureConfig, built
  from the existing TAzureConfig/TAzureGroupMap/TAzureModelGroupMap types, so the fixtures are now fully type-checked with no any.

* HAL-1081 Deploy librechat open

  1. Gate the backend-name alias to OpenAI-compatible parameter sets (packages/data-provider/src/parameterSettings.ts)
  dropParamsBackendToUIKey had been applied unconditionally, rewriting a dropped topP to top_p even for a custom endpoint whose defaultParamsEndpoint is anthropic/google (or
  a native bedrock-* endpoint) — where topP is the UI key, so the rewrite broke hiding the control. Replaced the plain map with resolveDropParamsUIKeys(dropParams,
  endpointKey), which only aliases backend names for OpenAI-compatible endpoint keys (openAI, azureOpenAI, custom, openRouter) and passes native-provider keys through
  unchanged otherwise. Updated both Panel.tsx and ModelPanel.tsx to call it with overriddenEndpointKey, and added a resolveDropParamsUIKeys test suite in
  parameterSettings.spec.ts.

  2. Prune stale model_parameters when a control becomes hidden (client/src/components/SidePanel/Agents/ModelPanel.tsx)
  When a parameter an agent already had set gets added to its endpoint's dropParams, the control disappeared but the value stayed in model_parameters and was saved unchanged
  by composeAgentUpdatePayload — invisible to the user and silently reactivated if the endpoint later stopped dropping it. Added a useEffect, mirroring the conversation
  panel's existing pruning effect, that strips any model_parameters key no longer present in the currently-visible parameters list. Also fixed a pre-existing test regression
  (missing useGetStartupConfig mock) and added two tests covering pruning-on-drop and value retention when the control stays visible.

* fix: Preserve parameters for unknown agent providers

* fix: Sanitize agent parameters on submission

* fix: Preserve agent model overrides during pruning

---------

Co-authored-by: Marc Amick <MarcAmick@jhu.edu>
Co-authored-by: MarcAmick <5194465+MarcAmick@users.noreply.github.com>
Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
2026-09-04 13:52:23 -04:00
Daniel Xavier
d07527ff93
style(insights): give panels their own surface in dark mode (#15552)
* style(insights): give panels the Click UI chartWidget surface in dark mode

In dark mode the panels drew the shared `surface-primary` (#0d0d0d) against a
page of the same colour, so the cards read as one flat sheet with only a faint
border separating them. Click UI treats a dashboard widget as its own surface,
a step lighter than the page behind it.

Add the `dashboards.chartWidget` surface and stroke as theme tokens and apply
them to the Insights panels under `dark:` only, so light mode keeps the shared
surface/border tokens untouched:

  dark   #282828 surface / #323232 stroke
  light  #ffffff surface / #e6e7e9 stroke  (defined for completeness; unused)

`Panel` is local to InsightsView, so this cannot leak into other pages -- all
six panels (the four KPI tiles, both user tables, the conversation list, and
the loading/error cards) pick it up from the one definition.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(theme): register muted text role

* fix(theme): register chart widget colors

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Co-authored-by: Ravi Kumar L <ravi.lazar@clickhouse.com>
2026-09-04 18:17:48 +02:00
Daniel Xavier
d21bffa4c6
fix(insights): stop the KPI grid orphaning a card on its own row (#15553)
* fix(insights): stop the KPI grid orphaning a card on its own row

`repeat(auto-fit, minmax(min(100%, 220px), 1fr))` packs as many 220px tracks as
will fit, so every width between three and four tracks rendered three cards in
the top row and left the fourth alone underneath.

Four tiles divide evenly by two and by four, so those are the only counts that
leave no hole. Pin the grid to two columns, widening to four at `xl`.

Viewport breakpoints are sound here because `UnifiedSidebar` forces the panel
collapsed on the Insights route (`panelExpanded = expanded && !isInsightsRoute`),
so the content width is a fixed function of the viewport: `vw - 52 - 64`. At the
`xl` boundary that leaves 1164px, or 282px per tile.

Swept 640/768/900/1024/1100/1279/1280/1440/1600/1920/2560: every width renders
either 4x1 or 2x2, never 3+1.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(insights): restore mobile KPI column

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Co-authored-by: Ravi Kumar L <ravi.lazar@clickhouse.com>
2026-09-04 18:17:30 +02:00
Daniel Xavier
2656f44c03
style(insights): use Click UI muted token for KPI labels and 32/12 page spacing (#15551)
The KPI tile labels were 18px (`text-lg`) in `text-secondary`. Click UI sizes a
muted label at `400 0.875rem/1.5` -- 14px -- so the label now uses `text-sm`
with a matching muted colour.

None of the existing text tokens carried Click UI's muted value: `text-secondary`
(#424242) and `text-tertiary` (#595959) are both darker and warmer than Click
UI's #696e79. Rather than hardcode a hex in the component, add `--text-muted`
alongside the other text tokens in all four theme blocks and register it in
`createTailwindColors`, so it themes and takes opacity modifiers like its
neighbours:

  light  #696e79  (Click UI global.color.text.muted / bigStat.color.label.muted)
  dark   #b3b6bd

The content column also drops its responsive padding ramp for a flat 32px on
left/top/right and a 12px row gap, matching the 12px the inner grids already
used so horizontal and vertical spacing agree. Bottom padding is left at 16px.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-09-04 17:38:04 +02:00
Danny Avila
e795f0ca3b
🏕️ feat: Provision Native Code Workers (#15587)
* 🧭 feat: Guide Native BYOM Worker Setup

* fix(code): harden worker onboarding options

* test(code): align native worker onboarding checks
2026-09-04 11:22:31 -04:00
Marco Beretta
10c5c91594
🎨 feat: Theme-Adaptive SVG Support for Custom MCP and Group Icons (#13817)
* feat: theme-adaptive SVG support for custom MCP and group icons

Custom icons (MCP server iconPath, model spec groupIcon) were rendered as
plain <img>, so monochrome SVGs kept fixed dark colors and were nearly
invisible in dark theme.

Introduce a shared CustomIcon component that detects monochrome SVG glyphs
and tints them with currentColor so they follow the active theme, while
multi-color SVG logos and raster images keep their original colors. The
monochrome decision parses the SVG's color tokens; content is fetched once,
cached, and any failure falls back to the original image. Monochrome SVGs
render via CSS mask, never inlined, so no SVG markup reaches the DOM.

Apply across all custom-icon surfaces: MCP settings cards, the chat MCP
dropdown, stacked MCP icons, tool-call headers, and model group icons.

Also support SVG in the MCP avatar uploader: add SVG to the accepted file
types and sanitize uploaded SVGs with DOMPurify before storing them, and
make the dialog preview theme-adaptive via the same component.

Add unit tests for SVG detection, monochrome analysis, sanitization, and
CustomIcon rendering.

* fix: reset adaptive icon tint state when the source changes

A reused CustomIcon instance kept the monochrome verdict from a previous
source until its effect re-ran, so switching to a raster image or a new
multi-color SVG could briefly render it as a currentColor silhouette.

Key the resolved verdict to the current source and reset it synchronously
during render (seeding from cache when available), so a stale verdict can
never tint a different icon. Add hook tests covering the source change.

* fix: do not tint custom SVGs that have an opaque background

A grayscale SVG with an opaque full-canvas background (for example an
exported logo with a white background rect and a black glyph) passed the
monochrome check and was drawn through a CSS mask. Masks key off the alpha
channel, so the opaque background filled the whole area with the tint color
and the icon collapsed into a solid block.

Detect a full-canvas opaque background rect and exclude such SVGs from
tinting, rendering them with their own colors instead. Transparent
single-color and multi-shade glyphs remain tintable. Add tests for the
background cases.

* fix: detect opaque SVG backgrounds without a viewBox

Opaque background detection only read canvas dimensions from the viewBox, so
an SVG that declares width and height on the root element but omits the
viewBox slipped through and was tinted into a solid block.

Fall back to the root svg width and height when no viewBox is present, and
match attribute names exactly so stroke-width is not mistaken for the canvas
width. Add tests for the no-viewBox cases.

* fix: parse comma-separated SVG viewBox values

The viewBox regex only accepted whitespace between values, so a valid
viewBox like "0,0,24,24" failed to parse and an opaque background went
undetected, tinting the icon into a solid block. Accept commas and
whitespace as separators. Add a test for the comma-separated case.

* refactor: detect SVG tintability with DOMParser instead of regexes

The monochrome/tintable decision scraped SVG markup with regexes, which kept
missing edge cases (opaque backgrounds, missing or comma-separated viewBox,
stroke-width vs canvas width, embedded raster images).

Parse the SVG once with DOMParser and inspect real elements and attributes:
reject embedded <image>/<foreignObject> content, detect a full-canvas opaque
background rect, read the canvas size from the viewBox or root width/height,
and gather paint colors from attributes, inline styles, and <style> blocks.
Unparseable input is treated as not tintable. Tests cover these cases.

* fix: only tint single-tone grayscale SVGs

A grayscale SVG can draw its background as a full-canvas path (not just a
rect), e.g. a white background path plus a black glyph. The rect-only
background check missed that, and the icon flattened to a solid currentColor
block under the CSS mask.

Tint only when the SVG resolves to a single grayscale tone. Any second tone
(a background shape drawn as a path or rect, an accent, or a second shade)
now preserves the icon's own colors, which covers full-canvas path
backgrounds without per-shape geometry parsing.

* fix: count default black fill when detecting tintable SVGs

* fix: treat currentColor as a tone and stroked closed shapes as filled

* fix: ignore non-rendering template paint and count filled open paths

* fix: scan defs and symbol paint rendered through use references

* fix: resolve currentColor against fixed color and match style fills for default paint

* fix: treat alpha-zero fills as transparent in SVG tint detection

* fix: resolve inherited and CSS fill for backgrounds and default paint

* fix: resolve CSS currentColor and default-black use instances

* fix: count default-filled polylines when detecting tintable SVGs

* fix: resolve inherited fill and style/CSS opacity in SVG tint detection

* fix: ignore display:none shapes and stop counting CSS color as paint

* fix: only count CSS paints that match rendered elements

* fix: match root for CSS currentColor and skip unreferenced defs tones

* fix: count paint only on rendered shapes and filter hidden CSS currentColor

* fix: resolve use-instance currentColor and skip hidden use default fills

* fix: resolve CSS paints onto rendered painters and skip overridden use fills

* fix: keep checking ancestor opacity after resolving paint opacity

* fix: resolve CSS paints by specificity and skip transparent default fills

* fix: apply CSS over presentation attributes and follow nested use targets

* fix: strip CSS comments, honor visibility, and inherit paint through nested use

* fix: skip transparent svg use references

* Account for SVG filter colors

* fix: propagate outer use color through nested currentColor references

* fix: preserve url() id casing and record every nested use chain

* fix: preserve SVGs whose filters recolor the source

* refactor: detect monochrome icons via canvas pixel sampling

Replace the SVG source parser with offscreen-canvas pixel sampling: draw the icon, read pixel data, and treat it as monochrome only when every non-transparent pixel is grayscale within tolerance and the image has some transparency (a fully opaque image would mask to a solid block). Verdicts are cached per src.

An explicit monochrome flag on CustomIcon skips detection; sampling is the fallback. Image load failures and canvas taint from non-CORS cross-origin icons fall back to untinted rendering instead of throwing.

* harden custom SVG icon handling across security, a11y, and perf

Sanitize user-provided MCP iconPath server-side; the client-side
DOMPurify pass was bypassable by posting iconPath straight to the API.
Adds sanitizeMcpIconPath in @librechat/api (allowlist SVG sanitizer that
preserves case-sensitive names) and runs it in the create/update
controllers, plus a length cap on iconPath in the shared schema.

- gate theme detection to same-origin/data sources so a remote icon is
  no longer auto-fetched from every viewer's browser
- restore forced-colors (High Contrast) visibility and the broken-icon
  onError fallback for tinted icons
- mark redundant icons decorative to avoid screen-reader double reads
- base64-encode inlined SVG data URIs and bound the verdict cache
- harden the client SVG sanitizer and guard FileReader failures
- cover the tinted render branch, sanitizer allowlist, and edge cases

* fix: preserve local SVG references while stripping external hrefs

The hardened sanitizers dropped <use> and every href outright, blanking
self-contained exporter output like <defs><path id="p"/></defs>
<use href="#p"/> and gradients inheriting stops via href="#g".

Re-allow <use> and href/xlink:href on both sanitizers, restricted to
same-document fragments: the client uses a dedicated DOMPurify instance
with an afterSanitizeAttributes hook (kept off the shared default
instance), and the server mirrors the rule with a sanitize-html tag
transform plus an empty allowedSchemes list as a second layer. External,
protocol-relative, relative-path, and javascript: hrefs are still
stripped, leaving the element inert.

* fix: keep xlink namespace and safe filters in the server icon sanitizer

The server allowlist stripped xmlns:xlink from the root while keeping
xlink:href, leaving an unbound prefix that is a parse error once the
icon is stored as an image/svg+xml data URI, so SVG 1.1 exporter output
went blank after save. It also dropped <filter>/fe* primitives that the
client sanitizer's svgFilters profile allows, so icons relying on
effects like feDropShadow lost them between preview and reload.

Allow xmlns:xlink and mirror the client's filter allowlist (elements
plus their presentation attributes); feImage passes through the existing
fragment-only href transform, so external references are still stripped.

* fix: require empty pixels for tinting and block external url() references

Two issues from review of the icon sanitizer and monochrome detector:

- scanMonochrome flagged any pixel below full opacity as transparency,
  so an SVG that fills the whole canvas with a semi-transparent grayscale
  wash was tinted and rendered as a solid currentColor block. Require a
  genuinely empty pixel (alpha at or below the paint threshold) instead.

- The fragment-only reference rule only covered href/xlink:href, so a
  url() in filter/fill/mask/clip-path/style kept external targets like
  filter="url(https://evil/f.svg#f)". Both sanitizers now strip any
  attribute carrying a non-fragment url(), preserving local url(#id).

* fix: preserve internal SVG stylesheets while scrubbing their references

Exporter SVGs that store multi-color paint in an internal <style> block
(e.g. .red{fill:#e00} with class="red") lost all styling because the
sanitizers dropped <style> outright, so multi-color logos rendered with
default paints after upload.

Re-allow <style> on both sanitizers and scrub its CSS: strip comments
and @import at-rules and rewrite any non-fragment url() to none, keeping
local url(#id) paints. These icons only render in inert <img>/CSS-mask
contexts isolated from the host page (no script, and no subresource
loads once external refs are scrubbed), so a script-free stylesheet is
safe to keep; a premature </style> close still has its trailing markup
re-sanitized by the parser.

* fix: normalize icon value before deciding it is not an SVG data URI

A posted iconPath with leading whitespace or C0 controls (e.g.
"\n data:image/svg+xml,...") slipped past the anchored data-URI check,
so sanitizeMcpIconPath returned it raw while a browser trims the prefix
and still renders the SVG, keeping its external <image>/url() and other
stripped content. Normalize the value the way URL parsing does, trimming
leading/trailing C0 controls and spaces and removing embedded
tab/newline, before the SVG check so these variants are sanitized too.

* fix: cap sanitized icon length and re-encode as compact base64

The schema length check ran on the input, but sanitizeMcpIconPath then
re-encoded the markup with encodeURIComponent, which expands SVG by well
over the base64 input size (a 235KB base64 icon became a 374KB percent
string). create stored that over-limit value, and editing the server
resubmitted the prefilled value and failed MCPServerUserInputSchema.

Re-encode the sanitized SVG as base64 (far more compact for angle-heavy
markup, which sanitizing can itself grow via explicit close tags) and
drop anything still over MAX_MCP_ICON_PATH_LENGTH, so a stored icon can
never exceed the cap that a later edit re-validates against.

* fix: resolve CSS escapes before stripping external SVG references

A literal url(/@import matcher missed CSS-escaped references: a value
like style="fill:u\72l(https://attacker/x)" or an escaped @import
survived sanitization because the browser un-escapes \72 to r at
tokenization time while the regex never saw a url(...). The external
reference was then persisted and served to other clients.

Un-escape CSS the way a browser does (single pass over \hex and
\char escapes) before the url()/@import matchers run, on both the client
and server sanitizers. Also scrub the multi-declaration style attribute
in place instead of dropping it, so co-located local paint rules survive
while escaped external references are neutralized.

* fix: re-sanitize after scrubbing style blocks to block markup reintroduction

scrubStyleBlocks runs after sanitizeHtml and splices un-escaped CSS back
as raw markup, so an escaped sequence like \3c/style\3e\3cimage/\3e
(inert text during the first pass) became a real </style><image href>
element after unescaping, past the allowlist. Re-run the allowlist over
the scrubbed result whenever a <style> block was rewritten, stripping any
element the un-escaping surfaced while leaving legit local rules intact.

The client sanitizer is unaffected: it sets the scrubbed CSS as a DOM
text node, which serializes with < and > escaped, so no element is
reintroduced. Added a regression test pinning that behavior too.

* fix: make forced-colors icon tint override the inline background color

The forced-colors rule for .custom-icon-tint had no !important, so it
lost the cascade to the element's inline `background-color: currentColor`
and the masked glyph still blanked out in Windows High Contrast — the
exact regression the rule was meant to prevent. Verified in a real
forced-colors render: without !important the tinted icon is invisible;
with it the glyph paints in CanvasText and stays visible.

* fix: enforce icon length cap in the sanitizer, not the schema

The schema `.max()` on iconPath rejected the whole update at parse time.
A server whose stored icon predates the cap (previous versions allowed
large data-URI images) re-submits that value from the edit dialog, so
the user was locked out of changing any field or clearing the bad icon.

Drop the schema `.max()` and enforce MAX_MCP_ICON_PATH_LENGTH in
sanitizeMcpIconPath for every value type: an over-cap SVG is compacted
or dropped, an over-cap raster/URL is dropped. Editing a server with a
pre-existing oversized icon now succeeds and clears the icon instead of
failing validation.

* fix: decode XML entities and parse quoted URLs in SVG CSS scrubbing

Two more bypasses of the CSS reference scrubber, both live once the
stored image/svg+xml is parsed by a viewer:

- A <style> block reaches the scrubber as raw text, so an entity-encoded
  reference like &#64;import (or &#x40;import) was never seen as @import;
  the browser decodes it at render time. Decode XML character references
  (numeric + the five predefined named) before the matchers run.
- The url() regex excluded ')' even inside quotes, so a valid quoted URL
  like url("https://x/a)b") slipped through. Parse quoted and unquoted
  URL tokens separately so a ')' inside quotes stays part of the target.

Applied to both the server (sanitizeMcpIconPath) and client (sanitizeSvg)
scrubbers. Entity decoding also catches an entity-encoded </style> markup
breakout, which the re-sanitize pass then strips.

* fix: close custom icon review threads

* fix: transpile sanitize-html's ESM dependency chain in api jest runs

* fix: preserve marker definitions and fragment-only marker references

* fix: keep object-cover sizing when tinting masked icons

* fix: preserve textPath labels and currentColor color scopes in icon sanitizer

* fix: preserve pattern coordinate-system attributes in icon sanitizer

Keep patternUnits, patternContentUnits, and patternTransform so patterned
SVGs do not fall back to objectBoundingBox after server-side sanitize.

* refactor: sanitize icons with one shared DOMPurify policy

The server re-implemented DOMPurify's SVG profiles as two hand-written
sanitize-html allowlists, so every element and attribute the client kept had to
be transcribed by hand, and each miss surfaced as an icon that previewed
correctly and then lost its markers, patterns, filters, or xlink binding once
stored. Run DOMPurify on jsdom instead and share the config and reference hook
with the client, which drops both allowlists.

Restrict url() values to same-document fragments on every attribute rather than
on the marker properties alone, so external references in fill, stroke, filter,
mask, and clip-path are stripped as well.

Restore feDropShadow casing after sanitizing. DOMPurify has to parse as HTML,
its XML mode drops filter primitives and gradients, and the HTML tag-name
adjustment table predates that primitive, so it survived lowercased and left its
filter empty once the stored icon was re-parsed as image/svg+xml.

* fix: defer jsdom load until MCP icon sanitization

jsdom and dompurify were imported at module scope, so every
require('@librechat/api') paid their startup cost. Load them on first
SVG sanitize instead.

* fix: sort type import in MCP icon sanitizer

The static-check import sorter wants value imports before type-only
imports. Moving the DOMPurify type import after librechat-data-provider
clears the drift.

* fix: address PR review bot findings

chatgpt-codex-connector:
- Resolve icon URLs through new URL() instead of trusting a leading slash, so
  /\attacker.example/icon.svg is no longer treated as same-origin
- Check every url() token in an SVG attribute rather than only the first, and
  reject values carrying a CSS escape that would decode into one
- Forbid animateTransform, animateMotion, animateColor, and mpath, which the
  SVG profile admitted despite the policy intending to remove animation
- Preserve the radial-gradient fr attribute the profile omits
- Reject multi-tone grayscale in scanMonochrome, which a mask would flatten
- Sample at 128px so a small chromatic accent is not averaged away
- Settle a stalled icon load after 10s so its in-flight entry is released
- Bound the decoded SVG before building a jsdom tree for it
- Reject an oversized icon upload with a visible error instead of accepting it
  and silently clearing it on save

* fix: address Codex findings and trim icon sanitizer comments

- Bound icon files by size before reading or sanitizing them
- Track tone spread across every painted pixel, not only solid ones
- Settle monochrome detection on any sampling throw
- Use named DOMPurify/JSDOM types and shorten PR comments

* fix: percent-decode SVG data URI bodies before base64 decoding

* fix: declare the SVG namespace on sanitized icons and keep icon rejections out of form validity
2026-09-04 10:49:43 -04:00
Danny Avila
b76b02062a
🔬 test: Make the Paste Action's Hover-Gate Guard Actually Guard (#15589)
* 🔬 test: Make the Paste Action's Hover-Gate Guard Actually Guard

Review follow-up to #15588, and a correction: the guard it shipped could not
fail against the markup it exists to reject.

Two independent reasons, each enough on its own.

`toHaveTextContent` is a SUBSTRING match. #15588 adopted it over exact
`textContent` equality to shed whitespace brittleness and, in doing so, dropped
the only assertion in this test that was catching anything. The swap kept both
labels mounted and hid one in CSS, so the control read
"PlainMove back into message" — which a substring match accepts. Anchored now,
which keeps the whitespace normalisation that motivated the change.

The token sweep read `control.className`. The gate lived on the child spans and
never on the button, so it was scanning an element that never carried what it
was looking for. It sweeps the control's subtree now.

Verified by restoring the pre-#15586 component and re-running: the guard fails
against it, where both of the shipped forms passed.

* 🧪 test: State the Hover-Gate Invariant Instead of Listing Its Spellings

Codex P2 on the previous commit: the sweep named `group-hover`,
`group-focus-within` and `[@media(hover:none)]` — the three spellings this bug
happened to use — so the next spelling of the same idea walks past it.
`invisible hover:visible` on the control, or `hidden focus:block` on a
descendant, leaves the label absent at rest with the anchored text still
matching, because in jsdom the text is mounted either way.

Replaced with the rule the list was standing in for. A Tailwind token is
`variant:utility`; the utility is what follows the last colon, which holds for
bracketed variants too. Both halves of a gate are then rejectable on meaning
rather than on spelling: no utility may hide the label at rest, and no utility
under a hover or focus variant may reveal or hide it. Colour under those
variants stays permitted — that parity is asserted separately, and banning
`hover:` wholesale would contradict it.

Verified against all three spellings by patching the component: the historical
two-span swap, a direct gate on the control, and a direct gate on a descendant.
Each fails the guard.

* 🔭 test: Narrow the Hover-Gate Guard to What jsdom Can Decide

Codex found four ways past the previous commit's sweep, and two ways it
misfired. Bypasses: `text-transparent hover:text-text-secondary`, `opacity-[0]`,
Tailwind 3's `!hidden`, and a gate moved onto an ANCESTOR, which the traversal
never looked at. Misfires: `hover:inline-flex` is layout, not concealment, and
would be rejected; and a classed SVG descendant returns an `SVGAnimatedString`
from `.className`, so the sweep would throw before asserting anything.

Failing in both directions at once is the signal that the approach was wrong
rather than incomplete. Deciding whether a mounted node is visually hidden
needs a cascade, and jsdom loads no stylesheet — so every version of this was a
denylist wearing the language of an invariant, and a fourth would have invited
a fifth bypass.

Narrowed to the half that holds: the control's text is exactly the label, which
catches the swap that actually shipped, since it kept both labels mounted and
the control read "PlainMove back into message". The unobservable half is
written down as unobservable, with a pointer at where a real assertion belongs
— `toBeVisible()` in a browser, which `e2e/` has no composer-paste spec for.
2026-09-04 09:19:33 -04:00
Danny Avila
bd83da552d
👓 fix: Match Pasted Text Focus Feedback (#15588)
Review follow-up. The label's colour shift answered the pointer only. The focus
ring already announces focus, so this is parity rather than a missing indicator
— but two input modes getting different feedback for the same state was a
difference with nothing behind it.

The hover-gate guard keeps asserting class tokens, brittle as that is. jsdom
loads no stylesheet, so a hover gate has no effect on the DOM under test and a
presence check cannot see one: the swap this replaced kept both labels mounted,
which is why the spec it replaced asserted both were in the document at once.
Recorded the reasoning where the next reader will meet it.
2026-09-04 00:07:08 -04:00
Danny Avila
374ed8df14
🧶 fix: Render Solo Agent Groups as Sequential Content (#15574)
* 🛤️ fix: Render a Single-Agent Group as Sequential Content

A multi-agent graph assigns a parallel group id to every starting node
(`MultiAgentGraph.computeParallelCapability`), so an ordinary agent that
merely has other agents loaded carries a `groupId` on its OWN run steps
and on every content part built from them. `groupId` is not evidence of
parallel execution.

The client treated `groupId != null` as parallel content in four places,
so an ordinary turn:

- rendered inside a `SiblingHeader` lane box, restating the message's own
  sender and adding a redundant branch control
- lost tool grouping, activity-label headers and client-synthesized phase
  folds, because lanes render raw parts
- widened the message row for columns that never arrive
- rendered the one group repeatedly when phase markers split it, since
  each segment runs its own `ParallelContentRenderer`

`~/utils/lanes.ts` adds `hasParallelLanes` / `MIN_PARALLEL_LANES`: a group
backed by one agent is not a comparison, so it renders exactly like content
with no group id at all. `groupParallelContent` demotes such a group into
the sequential flow, and `ContentParts`, `useContentMetadata`,
`MultiMessage` and `groupActivityPhases`'s `foldable` all ask the shared
predicate. Fixing it client-side repairs persisted history too.

Two adjacent bugs the demotion exposed in `ParallelContentRenderer`:
a sequential part landing between the lanes' first and last index was
dropped from the message entirely, and a section holding only placeholders
rendered every part twice.

Five existing fixtures asserted the parallel path with a single agent
(some with a string `groupId` that never matched `groupId?: number`);
they now carry a second agent so they keep testing lanes.

* 🧹 refactor: Narrow the Lane Part Instead of Asserting Its Shape

`TMessageContentParts` already carries `agentId`, so the assertion was
only standing in for the undefined check the optional chain now does.

* 🧵 fix: Keep Lane Identity and Transcript Order Across Sections

Two P2s from review, both about content that a lane group does not own.

**Lane cardinality belongs to the message, not the slice.** A completed
server phase marker partitions the transcript, and `renderSegment` hands
each slice to its own `ContentPartsBody`. A slice can hold one agent of a
genuine two-agent group while its sibling slice holds the other, so
counting agents locally demoted both and dropped the `SiblingHeader` that
told the reader which agent produced which answer. `parallelLaneGroups`
resolves the group ids once over the whole message; every slice and
`groupParallelContent` now ask that verdict instead of recounting.

**Sequential content between two sections rendered after both.** The
before/after split was global: with group 1, an ordinary part, then group
2, the part fell into `after` and the transcript read group 1, group 2,
part. Sequential parts are now laid out around EACH section, so the part
renders in place. A part landing inside a section's own index range still
falls to the next block — it has no column and no slot inside one, which
is the tradeoff the earlier `>= minParallelIdx` bound already made to stop
dropping it entirely.

* 🔢 fix: Count Only Attributed Lanes, and Scan for Them Once

Round 2 of review, two findings.

**An unattributed part is not a second agent.** `agentId` and `groupId` are
independently optional on a run step — `getStepMetadata` builds both from
whatever the step carries and the writer sets each only when present — so a
group can hold a part the server never attributed. It shares the `unknown`
sentinel column, and counting that sentinel let one agent plus one
metadata-less part pass the two-lane threshold, leaving exactly the
single-agent turn this branch exists to demote in the parallel UI.
`attributedLaneCount` discounts the sentinel, `groupParallelContent` counts
claimed columns the same way, and the sentinel is now one exported constant
instead of a literal on each side.

**One lane scan per render, not two.** `groupActivityPhases` was scanning
the whole message for lanes to decide `foldable` while `ContentParts` was
scanning it again for `parallelLaneGroups`, on a path that re-runs for
every streamed delta. The scan is now computed once and handed down; a set
built from the same content answers `foldable` by its size.

* 🧮 fix: Ignore Handoff Markers in Lanes, and Scan a Message Once

Round 3 of review, two findings.

**A handoff marker is not a second lane.** `useStepHandler` stamps an
`AGENT_UPDATE` part with `{ agentId: <destination>, groupId: 1 }` even
though the destination's own run steps carry no group id, so a single-lane
graph that later hands off held two agent ids in one group: the run's
output became one column and the marker became the other, at the exact
point the handoff happened. `isLaneMarkerPart` keeps a marker from claiming
a lane, and `groupParallelContent` mirrors it — a column claims its lane
only when it holds output, except a placeholder column, which claims with
no parts at all so a dual run shows both agents from the first render.

**One scan per message, not three.** `MultiMessage`, `useContentMetadata`
and `ContentParts` each traverse the same array in a single render pass,
allocating a map and a set per call, and `content` is rebuilt on every
streamed delta. `laneAgentsByGroup` now memoizes on the content array
itself: the three callers collapse to one traversal, and the cache is
exactly as fresh as the render, since a delta that kept the array identity
would not re-render either. Entries die with the array that keys them.
2026-09-03 23:46:25 -04:00
Danny Avila
fde46a62f9
🔙 refactor: Keep Pasted Text Return Action Visible (#15586)
The chip generated from a long paste offers returning its text to the composer
on the subtitle line, but the label only swapped in on `group-hover` /
`group-focus-within`. At rest the chip read as an inert "Plain Text" subtitle,
so the affordance went unfound — and touch devices have no pointer to find it
with, which the `[@media(hover:none)]` override was already conceding.

The label is now the subtitle: stated at rest, underlined so a permanent line
of secondary text reads as a control rather than as a caption. The `aria-label`
that shadowed the visible text goes with the swap it existed for, leaving the
accessible name equal to what the label says.
2026-09-03 23:41:25 -04:00
Marco Beretta
bd31ecd129
✨ feat: add morphing state icons across the client (#14697)
* feat(client-ui): add morphing icon support

* feat(client-ui): morph shared state icons

* feat(chat-ui): morph chat action icons

* feat(client-ui): morph remaining action icons

* fix(client-ui): type morph icon test factory

* test(client): type agent detail fixture

* test(client-ui): guard morph icon accessibility defaults

* test(chat-ui): assert mermaid view toggle via morph icon

* style(chat-ui): sort mermaid header imports

* test(api): wait for rebuilt MCP session to finish connecting

The SSE conflict recovery test treated a new session id as a finished
reconnect. initialize assigns that id before connectClient emits
connected, so isConnected() can still be false. Wait for a live
connection on the rebuilt session instead.

* fix(client): clean up rebase fallout
2026-09-04 03:27:14 +02:00
Danny Avila
ac55b5fad4
🧼 fix: Clear Model Spec Fields on Configured Selections (#15544) 2026-09-03 09:46:15 -04:00
Danny Avila
1c7a172321
🕹️ feat: Configure BYOM Tool Permissions (#15504)
* feat: add configurable BYOM permissions

* test: cover BYOM permission settings live

* fix: harden BYOM permission settings

* perf: reuse principals for environment discovery

* chore: normalize BYOM settings style

* fix: Align BYOM Discovery and Admission

* fix: Harden BYOM Permission Boundaries

* fix: Align BYOM Skill Approval Routing

* fix: Preserve Lazy BYOM Approval Capabilities

* perf: Parallelize Cached Environment Reads
2026-09-02 10:38:00 -04:00
Danny Avila
29e9d08163
🪛 chore: Align Vite Build Config With Native ESM (#15495)
* fix: Resolve Vite build warnings

* style: Sort token usage transition classes
2026-09-01 22:22:28 -04:00
Marco Beretta
2cf1007f3c
🧺 feat: Preserve Partial Work at Tool Call Limits (#15486)
* feat: Handle reaching the agent tool-call limit gracefully

When the graph exhausts its per-turn step budget, persist the turn as
unfinished with finish_reason tool_call_limit instead of a red error.
Warn the model as the budget runs low, and offer Keep going or Answer now.

* docs: Add screenshots of the tool-call-limit notice

Light and dark captures of the unfinished-turn card for the PR description.

* style: Tighten the tool-call-limit notice card

Pin dismiss to the top-right with uniform rounding, use a slightly
smaller hit target, and round the card to xl. Refresh the PR screenshots.

* fix: Address Copilot review findings on the step-budget path

Skip empty and subagent-scoped PostToolBatch events when counting
rounds. Drop the double-cast in the notice test helper and coerce the
tool-call-limit finish reason in the Continue-gate spec.

* fix: Address Codex review findings on budget and dismiss

Pass the resolved recursion limit into the OpenAI-compatible
processStream path so the step-budget hook matches the graph.
Reset the notice dismiss state when the displayed message id changes.

* fix: Unblock CI typecheck and import sorting

Declare recursion_limit on the OpenAI service agent type, sort that
file's local imports, and route the notice test context through unknown
so tsc accepts the partial ChatContext fixture.

* fix: Sort remaining PR imports for static checks

* chore: Remove tool-call-limit notice screenshots

* fix: Keep recovery actions from consuming composer drafts

Pass empty file, skill, and quote overrides on Keep going and Answer
now so a staged compose is not attached or drained.
2026-09-01 21:38:02 -04:00
Danny Avila
164f146bdf
🛞 feat: Manage Personal Code Environment Lifecycles (#15369)
* feat: add self-service code worker pairing

* fix: enforce code worker principal boundaries

* fix: separate pairing control planes from execution

* fix: preserve principal worker routing

* fix: pin artifact traffic to code workers

* fix: authenticate code worker selection

* test: mock worker-aware artifact headers

* fix: harden self-service code worker routing

* fix: fail closed for principal code pairing

* feat: manage personal code environments

* fix: harden personal code environment lifecycle

* fix: satisfy backend lifecycle types

* fix: harden principal environment lifecycle and quotas

* fix: fence environment lifecycle races

* fix: reconcile code environment stack

* style: format code execution headers

* fix: reconcile code environment lifecycle

* fix: close self-service pairing gaps

* fix: close code environment reconciliation gaps

* fix: close code environment UI review findings

* fix: satisfy code environment type checks

* fix: route code priming to selected worker

* fix: harden code environment lifecycle fences

* fix: type lease renewal interval

* fix: harden environment lifecycle recovery

* fix: close lifecycle recovery races

* fix: type compensated agent timestamps

* fix: fence lifecycle cleanup by tenant and revision

* fix: scope environment revision fencing
2026-09-01 21:10:05 -04:00
Danny Avila
aa7539909b
🪶 feat: Enable Standalone Skill Authoring (#15480)
* feat: enable standalone skill authoring

* test: align skill e2e flow with enable toggle

* fix: preserve legacy skill state on version restore
2026-09-01 18:39:05 -04:00
Danny Avila
5b75c79831
🫥 fix: Clear Hidden MCP Chat Selections (#14159)
* 🫥 fix: Clear Hidden MCP Chat Selections

A server hidden with `chatMenu: false` stayed active in chat when it had been
selected while still visible. The selection persists to localStorage, and the
guard that clears stale selections tested the *filtered* server list — which is
empty precisely when every configured server is hidden, so the guard could never
fire and the selection survived every reload.

Gate the prune on the unfiltered catalog instead. It is non-empty in exactly the
case the old guard missed, and it stays a guard rather than a load flag so an
empty catalog — still loading, or a degraded read — is never mistaken for "the
admin removed everything" and used to wipe a selection irrecoverably.

Clear the ephemeral agent alongside the atom: it is what carries the selection to
the server, so a hidden name has to leave it too, not just the dropdown's state.

Also label the dropdown badge from the servers the menu actually offers. It
counted the raw selection, so a hidden server rendered as "Server Four" or
"2 selected" above an empty menu — the symptom that reads as a server you cannot
turn off.

* 🔧 fix: Keep Spec-Assigned MCP Servers Out of the Hidden-Server Prune

A model spec may deliberately assign a server the chat menu hides, and
`applyModelSpecEphemeralAgent` seeds it straight into `ephemeralAgent.mcp`. The
prune could not tell that apart from a stale selection, so activating such a spec
dropped its server — and because the same function re-reads `LAST_MCP_` for
existing conversations, the loss persisted across navigation.

Exempt whatever the active spec pins. `chatMenu` hides a picker entry; it does
not override an admin's spec assignment.

* 🔒 fix: Confine the MCP Selection Prune to the Hook Instance That Owns It

`useMCPServerManager` has seven call sites, and only `BadgeRowContext` reads the
chat selection — the rest mount it for the catalog, the server actions, or the
status icons. Every instance keyed to the same conversation shares one atom and
one ephemeral agent, so those six were all running the prune too, and the
always-mounted `useSideNavLinks` has no spec context to exempt from: it would
rewrite the selection the picker's own instance was deliberately keeping.

Make managing the selection opt-in, off by default at both layers, and let the
badge row alone opt in. The six catalog consumers stop touching chat selection
state entirely, which is what they should have been doing all along.

Tests now state whether they own the selection rather than inheriting it from a
default, so each one exercises the same configuration as the instance it models.

* 🔁 fix: Mirror the MCP Selection Everywhere, Prune It Only in the Owner

Gating the whole ephemeral-agent sync on selection ownership was too broad. The
action paths — `initializeServer`'s OAuth success, the revoke handler — build
their next selection from `mcpValues` and write it back through `setMCPValues`,
which also rewrites the shared ephemeral agent. An unmirrored instance therefore
wrote a stale list: authenticating server B could drop an existing selection of
server A, leaving only B.

Mirroring and pruning are separate concerns. Every instance mirrors, so each one
builds on the current selection; only the owner prunes, because only it knows
which servers a spec pins.
2026-09-01 18:38:14 -04:00
Danny Avila
537ddba6bb
🫴 fix: Hand Composer Focus Back After Upload Dialogs (#15469)
Typing a message, pasting an image, then pressing Enter did nothing: the
composer held the full draft, the send button was enabled, and Enter was
inert until the user clicked back into the textarea — which reads as
"the textarea needs a text change before it will submit".

The send gating was never at fault. Radix's modal `DialogContent` always
cancels its default close-focus restore and focuses
`context.triggerRef.current` instead. `DragDropModal` — the "Select Upload
Type" dialog a paste or a drop opens — is opened programmatically and so has
no `Dialog.Trigger`, leaving that ref null: nothing is focused and focus
falls to `document.body` when the dialog unmounts. Enter-to-send is a
keydown handler on the textarea, so from `body` it is never reached.

`UploadModalProvider` now records the element the upload was started from,
captured in `openModal` before the dialog mounts (an effect runs too late —
Radix has already moved focus), and restores it once the dialog closes,
queued behind Radix's own deferred restore. This covers every close path:
picking a destination, Cancel, Escape, and dismissing the overlay.

`OGDialog`'s existing `triggerRef` seam does not reach this case, since it
only fires through Radix's `onOpenChange` and choosing an upload destination
calls `closeModal()` directly.
2026-09-01 12:56:03 -04:00
Danny Avila
c3beae1e18
🔌 refactor: Give the Subagent Surface a Host Seam and Its Own Jotai State (#15455)
* 📐 docs: Record Who Owns Which Piece of Client State

* 🔌 refactor: Give the Subagent Surface a Host Seam and Its Own Jotai State

The subagent chat surface reached up into seven application atoms and could
not be lifted anywhere, and the six atoms it owns were still Recoil while its
sibling stores had already moved to Jotai.

Feature-owned state converts to Jotai and stays where it is: the selection,
per-task control receipts, live progress and the parent-stream fence. The
control atom keeps its session-storage retry — restored per store rather than
per family member, so a reload still sees what the last one persisted.

App-global state now arrives through one `ChatSurface` value the host supplies:
`enterToSend`, `maximizeChatSpace`, `showScrollButton`, the reader's composer
bindings, a `claimForeground` command for the slot the panel and the artifacts
panel share, and `handOffComposerText` for a continuation's unsent words. Two
hosts mount the same adapter — the conversation view and the shared-link view.

Opening the panel was three copies of "clear the artifacts slot, then select";
that is now `useOpenSubagentPanel`, and the three call sites say what they mean.

Nothing under `Chat/Subagents/**` imports `~/store` or `recoil` any more, and
its whole suite runs with no `RecoilRoot` at all.

* 🧹 refactor: Move Subagent State Into the Feature and Free Its Drained Atoms

Two review findings, both fair.

The selection atom still lived in `~/store`, which handed the supposedly
liftable surface an implicit dependency on the application store alongside its
declared host interface — and contradicted the ownership rule this branch
added to CLAUDE.md two commits ago. The module moves to
`components/Chat/Subagents/state.ts`; the hosts that write it (the SSE step
handler, the message renderers) now import from the feature, which is the
direction that survives an extraction.

The conversation-switch drain blanked its two atom-family members but left
them cached. Every invocation key is unique, so a long-lived tab accumulated
two atom configurations per subagent call it ever saw — exactly what the
comment at that boundary says it exists to prevent. `removeSubagentProgressAtoms`
releases them after the values are cleared, mirroring `removeUsageAtoms`. The
new test fails without the release.

* 🔎 fix: Let a Subagent Card Render Where There Is No Panel to Open

Search results render the same card through `Part`, and that route is not
beneath either chat surface — so a search hit containing a subagent tool call
threw on `useChatSurface()` before it could render at all.

Rendering the card and opening a panel are different requirements. The host
stays required for the panel, the activity view and the event group, all of
which only ever mount inside one. `useOpenSubagentPanel` reads the context
optionally instead and answers `null` where there is no host, which is also
the honest answer for search: there is no panel on that route to open, so the
card renders with its details control disabled.

The new test renders the card with no surface at all, and throws with the
reported error when the hook is put back the way it was.

* 🧮 fix: Enrol Read-Created Progress Atoms in the Drain Registry

The read is what creates a family member, and only the streaming paths were
registering their keys. A card rendering a conversation that finished
streaming long ago — or a search result that never streams at all — created
one the navigation drain could not see, so browsing history accumulated an
atom configuration per card for the life of the tab.

`useSubagentProgress` does both halves: it reads the invocation's progress and
enrols its key, so every route into the family shares the one cleanup
boundary. The panel and the parent card both read through it now.

* 🧽 fix: Free a Read-Created Progress Atom at Its Own Card's Unmount

Enrolling read-created keys in the drain registry only helps where something
runs the drain, and `/search` is a standalone route that never mounts the chat
event handlers. Scrolling a virtualised result list therefore kept minting
members nothing would ever free.

`useSubagentProgress` cleans up after itself instead: on unmount it frees the
family members when the read is the only reason they exist. Two guards keep
that from taking live history with it — a key the stream registered belongs to
the drain, and a member holding folded activity is the record of what the child
did, so reopening its card still shows it.

* 🔗 fix: Free a Progress Atom Only After Its Last Reader Lets Go

Opening a foreground panel before the first event gives one still-empty member
two readers: the card that spawned the child and the panel showing it. Closing
the panel freed it while the card was still subscribed — and a subscriber does
not re-render just because its atom left the family, so the first SSE update
landed on the replacement member and the card's ticker stayed dead.

`useSubagentProgress` counts its mounted readers and frees only when the last
one lets go, alongside the two claims that already blocked it: a key the stream
registered, and a member holding folded activity.
2026-09-01 11:15:42 -04:00
Danny Avila
09722f4b16
✔️ style: Anchor the Applied Steer Receipt and Name Tool Calls in Its Interrupt Copy (#15450)
* ✔️ style: Anchor the Applied Steer Receipt at the Row's Trailing Edge

* 💬 style: Say Tool Calls Are Not Interrupted Either
2026-09-01 00:53:24 -04:00
Danny Avila
1ff4a44b61
🩹 fix: Stop the Subagent Composer Unmounting, and Give It Main Chat's Shape (#15448)
* 🩹 fix: Stop the Subagent Composer Unmounting, and Give It Main Chat's Shape

Measured with react-scan and a DOM presence probe against the live panel:
every external delivery unmounted and remounted the composer inside 10ms,
taking focus and any half-typed steer with it.

- The composer stays mounted across a delivery. A delivery re-keys the
  thread query to its new task and the task view blanks for the render or
  two that takes — deliberately, so task-scoped fields are never
  misattributed — but presence followed it down. The last mode the thread
  showed now carries the surface across that gap, holding submission until
  the new task's own view lands. `dispatched` also counts as live, so a run
  that has only just started no longer withdraws the field either.
- One control, not three labels. Submitting IS the steer; with nothing to
  send the send button becomes main chat's Stop, which cancels the task.
  Queue and interrupt keep the chords main chat gives them
  (⌘/Ctrl+Enter, ⌥/Alt+Enter) instead of spelling themselves out beside
  the field, and every control says what it is through its tooltip and
  accessible name rather than a word label.
- The two composers line up. The field takes `ChatForm`'s own metrics and
  the footer clears the viewport floor by the height of main chat's
  disclaimer, so both textareas now measure top 805 / height 52 and both
  surfaces end at 910 in a 950px viewport.
- The header is main chat's header: a 52px bar that floats over the thread
  and fades into it, so the conversation scrolls under it instead of
  starting below a solid bordered bar.

Residual re-renders are the per-second timestamp and elapsed tickers plus
the 2s poll both queries run while a child is live — shared with main chat,
about 2ms of render time across a 14s window, and left alone.

* 🎛️ fix: Bind the Chord to Its Own Submission, and Keep Queue Reachable

Codex and Copilot, round one.

- A refused chord no longer decides a later click. `Composer` hands the
  submitting event to its host, and the panel keeps the resolved control
  bound to THAT event — a ⌘/Ctrl or ⌥ chord the composer then refuses
  (empty field, settling, a command in flight) leaves nothing behind for
  the next pointer submission to pick up.
- The control comes from the reader's own key policy, not from raw
  modifiers. With Enter-to-send off, ⌘/Ctrl+Enter IS the submit chord, so
  reading modifiers directly made steering unreachable; the verdict from
  `resolveComposerKeyDown` decides instead.
- Queue and interrupt keep a pointer. Chords alone stranded touch readers,
  and anyone whose shortcuts are disabled, rebound, or yielded. They are
  back as icon-only controls that say what they are through their tooltip
  and accessible name rather than a word label.
- Stop cannot render unlabelled. Handler and label travel as one value
  (`ComposerStopProps`), so the type refuses a Stop without a name.

* 🔗 refactor: Hang the Panel's Alternate Submissions Off One Shared Send Control

Queue and interrupt had no pointer, then briefly had controls of their own
beside the field — which repeats what submitting already does. Main chat
never did that: it hangs its during-run actions off the send button.

- `SendActions` moves to `@librechat/client`: the hovercard, the rows, the
  chord chips and their classes, lifted out of `DuringRunSendButton`
  unchanged. Each host passes its own anchor whole, so main chat keeps its
  ref (Enter's synthetic click routes through it), its submit type, and its
  identifying attributes. Its 13 existing tests still cover the rows.
- The panel offers steer, queue and interrupt from that same control, and
  advertises a chord only while it still reaches its action — each hint is
  read from the decision table that will execute it, so a rebound, yielded
  or disabled chord advertises nothing.
- The send control names what IT does (`com_ui_steer_send`) as distinct
  from the `Steer` row it offers, exactly as main chat pairs them.

Two hosts now share one implementation, which is what the seam wanted.

* 🧹 chore: Sort Panel Imports and Drop an Unrelated Reorder

The import sort ran before the last edits to this file. Also reverts a
Tailwind class reorder `eslint --fix` made to `MultiSearch`, which this
change has no business touching.

* 🛡️ fix: Only Offer Controls a Dispatched Task Can Actually Take

Codex, round two.

- A dispatched task is controllable only once the server can address it.
  `control.ts` answers 404 when the task has no durable input row and no
  live lease, which this panel reads as an inaccessible task and closes its
  controls for good — so treating every dispatched task as controllable
  could brick them. The field still stays (withdrawing it as a run starts
  is the swap this panel exists to avoid); submission waits for evidence.
  A task whose controls are definitively closed holds nothing.
- Semantic status roles replace `text-amber-500`, `text-cyan-500` and
  `text-red-500` in the action rows — in main chat's list too, since both
  now render through the same module.
- One popup over the send control. With actions to offer, the tooltip is
  withheld: both attached to the same button, opened on the same focus,
  above the same point, and the tooltip's higher z-index covered the list.
- Where the pointer cannot hover, the alternate submissions are controls of
  their own: a tap on the hovercard anchor submits, so touch readers could
  not reach queue or interrupt at all.

* 🚪 fix: Send Every Control Through the Same Addressability Gate

Codex, round three — both findings were doors around the gate added last
round.

- Stop and the inline actions now answer to `controlAvailable`, not just to
  `composerMode`. A retained surface over a dispatched task the server
  cannot address yet still offered Stop, and the touch-side queue and
  interrupt buttons were live too; each is a command, and each 404 closes
  this task's controls for good.
- A trapped panel keeps its actions inside itself. At mobile width with a
  hover-capable pointer the list still hung off the send control, portaled
  outside the `aside` the focus trap knows — so Tab never reached it. The
  actions come inline whenever the panel is a modal, hover or not.
2026-09-01 00:29:22 -04:00
Danny Avila
283aae49b3
🖼️ fix: Give a Phase's Files Their Own Media Row (#15435)
Some checks failed
Backend Unit Tests / Tests: api (shard 2/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: api (shard 3/3) (push) Blocked by required conditions
Backend Unit Tests / Tests: data-provider (push) Blocked by required conditions
Backend Unit Tests / Tests: data-schemas (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 1/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 2/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 3/4) (push) Blocked by required conditions
Backend Unit Tests / Tests: @librechat/api (shard 4/4) (push) Blocked by required conditions
Codegraph E2E Votes / vote (full suite) (push) Waiting to run
Docker Dev Branch Images Build / Build lc-dev (linux/amd64) (push) Waiting to run
Docker Dev Branch Images Build / Build lc-dev-api (linux/amd64) (push) Waiting to run
Docker Dev Branch Images Build / Build lc-dev (linux/arm64) (push) Waiting to run
Docker Dev Branch Images Build / Build lc-dev-api (linux/arm64) (push) Waiting to run
Docker Dev Branch Images Build / Merge manifests (lc-dev) (push) Blocked by required conditions
Docker Dev Branch Images Build / Merge manifests (lc-dev-api) (push) Blocked by required conditions
Frontend Unit Tests / Codegraph select (push) Waiting to run
Frontend Unit Tests / Build packages (push) Waiting to run
Frontend Unit Tests / TypeScript type checks (client) (push) Blocked by required conditions
Frontend Unit Tests / Tests: @librechat/client (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 1/2) (push) Blocked by required conditions
Frontend Unit Tests / Tests: Ubuntu (shard 2/2) (push) Blocked by required conditions
Frontend Unit Tests / Vite build verification (push) Blocked by required conditions
Sync Locize Translations & Create Translation PR / Sync Translation Keys with Locize (push) Waiting to run
Sync Locize Translations & Create Translation PR / Create Translation PR on Version Published (push) Blocked by required conditions
Docker Dev Images Build / build (Dockerfile, librechat-dev, node) (push) Waiting to run
Docker Dev Images Build / build (Dockerfile.multi, librechat-dev-api, api-build) (push) Waiting to run
Sync Helm Chart Tags / Ignore non-main push (push) Waiting to run
Sync Helm Chart Tags / Sync chart tags (push) Waiting to run
Publish `@librechat/client` to NPM / pack (push) Has been cancelled
Publish `@librechat/client` to NPM / publish-npm (push) Has been cancelled
* 🖼️ fix: Give a Phase's Files Their Own Media Row

* ✂️ refactor: Drop the Inline-Media Dedup

Six review rounds produced thirteen findings. The media row accounts for
one and inline resolution for five, all fixed — both reason about
attachments, and both converged. The dedup accounts for seven, arriving at
roughly one per round (code fences, backtick spans of two widths, escapes,
indented blocks, invalid title syntax, and raw HTML blocks), because it is
the only part that has to know what markdown RENDERS. Each miss claimed a
file nothing displayed and took it out of the row, so the standing cost of
keeping it was a recurring way to hide content, in exchange for avoiding a
duplicate.

So it goes. `collectInlineMediaNames`, the fence tracking, the standalone
image-line whitelist, and the claim wiring in `ContentParts` are deleted,
along with the raw-HTML finding, which no longer has anything to apply to.

Both reported problems still ship. The phase card's files ride their own
row outside the fold, and a bare `![DTI](5_dti.png)` still resolves to the
file the run produced. The only loss is that a chart the model inlines now
appears twice — once in the row, once where the model put it — which is
noise rather than a defect, and cheap next to a file that appears nowhere.

What remains reasons only about attachments: which stored file a name
refers to, whether that name is ambiguous, and which paths this app
serves.

* 🧹 style: Restore import order after the media context import shortened

* 🪞 fix: Address Codex Round 7 — Latest Record and Dimension-Free Fallbacks

The name map kept the FIRST record of a file while `collectPhaseAttachments`
had been changed to keep the latest — the row and the inline reference
disagreeing about which record of one file is current. A tool rewriting a
path reuses its `file_id` and the later record carries the newer URL, so
the inline reference resolved to a stale one. Both surfaces now take the
latest, matching the attachment renderer.

Resolution was gated on `isImageAttachment`, which additionally demands
width and height. Those exist so `<Image>` can reserve layout space; a
markdown `<img>` needs neither. The download fallback an oversized output
produces carries an image name and a working URL and displays perfectly
well, and requiring dimensions dropped it — leaving `![chart](chart.png)`
broken for exactly the outputs big enough to matter. The gate is now what
an `<img>` actually requires: an image extension and a fetchable path.

That predicate also moves INSIDE `buildAttachmentsByName`, where the
contract belongs, rather than being a filter the one caller had to
remember. Reusing `isImageAttachment` was the wrong kind of DRY — it
answers a different question than the one asked here.

* 🧬 fix: Address Codex Round 8 — Run-Step Identity and the Recovery Renderer

Two of three; the artifact-panel one is deliberately left, see the PR
thread.

The row's dedup key omitted `stepId`, but `filterAttachmentsForPart`
routes records to their owning part BY run step — so two executions that
reuse a provider tool-call id and claim the same `file_id` are two
artifacts, and collapsing them dropped one from the row that, once the
fold hides the parts' own copies, is the only place it appears.
`attachmentRenderKey` adds that dimension on top of `attachmentIdentity`
rather than changing it: the merge in `useAttachments` reconciles DB rows
against live records whose `stepId` may not have arrived, so it must stay
tolerant of a field one side can lack. A step-less legacy row keeps the
plain identity and never splits from itself.

`MarkdownErrorBoundary`'s fallback renderer omitted the attachment-aware
`img`, so a generated reference reverted to a page-relative URL precisely
in the recovery path — where the media context still holds the file and a
broken image is least welcome.
2026-08-31 22:05:27 -04:00
Danny Avila
bd24e45489
🧵 refactor: Give the Subagent Panel One Composer and Main Chat's Metrics (#15436)
* 🧵 refactor: Give the Subagent Panel One Composer and Main Chat's Metrics

The panel drifted from main chat in the small measurements a reader
notices side by side, and its footer swapped controls under the pointer
every time a run settled.

- One persistent composer. `@librechat/client` gains a `Composer`: the
  shared composer surface with a field, a height-holding action row, and
  the main chat send affordance. The panel renders it for the whole life
  of a run — Enter steers while the child is live, and continues the
  thread once it has settled — instead of replacing the input with a
  "Continue this chat" button at completion. Its placeholder is the
  main chat one (`Message {agent}`), not bespoke guidance copy.
- Continuations carry the draft. Child threads are view-only server-side
  (`CHILD_THREAD_READ_ONLY_ERROR`), so continuing forks into a real
  conversation; what the reader typed rides along through the same
  per-conversation draft store the composer restores from, and comes
  back in the panel if the fork fails.
- Main chat's footer metrics. Turn footers use `messageFooterClasses`
  and hold their height, so the elapsed timer is sized by the `text-xs`
  its main chat counterpart inherits rather than the panel's body size,
  and the reading leaving at completion no longer steps the thread.
- The author column matches. Turns render `MessageIcon` unconditionally,
  and the streaming dot is inset onto the header icon's axis with
  `underHeaderIcon`, as main chat insets it.
- Status indicators pin their color. Label first, dot last, so a longer
  status grows inboard and the color lands on one column in every row; a
  live row shimmers its label the way a running tool call does, and the
  dot no longer pulses against it.
- The actor picker is the agent builder's. `ControlCombobox` with agent
  avatars and search, replacing a bespoke bare `Select`.

* 🧷 fix: Keep Enter Off an Empty Field and Drop Dead Actor Rows

- The shared `Composer` never submits an empty field on Enter. Continuing
  a settled thread needs no text, so its send button stays live — but a
  stray Enter must not navigate the reader out of the panel.
- The actor picker lists only actors with a task to open. Its list has no
  disabled state, so a child without one was a row that silently did
  nothing; the selected thread stays listed regardless.
- The header glyph loses its plate, like the `MessageRow` author slot, so
  an agent avatar reads as an avatar rather than an inset badge. The send
  glyph matches main chat's at 24px.

* 🎚️ fix: Hand Continuation Text Over in Memory, Not Through Saved Drafts

Codex review of the first pass, all three findings.

- The continuation's text no longer goes through the composer draft store.
  Draft restoration is gated on the Save Drafts preference, so with drafts
  off the forked chat opened empty and the words were left sitting in local
  storage the reader had asked not to use. A new transient
  `pendingComposerTextByConvoId` carries them in memory instead, keyed by
  conversation so the handoff survives a navigation that resolves its
  record before moving the route; `useTextarea` drains it once, after the
  autosave restore it must not lose a race with.
- The draft is read when the fork lands, not when it was requested, so
  anything typed while the request was in flight travels too.
- Actors whose task id has not arrived are left out of the picker rather
  than offered as rows that cannot open anything (already in the previous
  commit; the filter keeps the selected thread listed regardless).

* ⌨️ fix: Give the Panel Composer Main Chat's Keyboard Contract

Codex round two.

- The composer honors "Press Enter to send". With the preference off a bare
  Enter is a line break and never reaches the field's action, so reaching
  for one cannot steer a live run or leave for a continued chat; ⌘/Ctrl+Enter
  submits there instead.
- The IME guard covers Safari. `isComposing` is already false on the very
  Enter that commits a candidate there, so tracked composition state and the
  legacy `Process`/229 signals stand in for it, as the main chat composer's
  own guard does.
- The actor picker renders in the panel rather than a portal. On mobile the
  panel is a modal whose focus trap only knows its own descendants, so a
  portaled search field let Tab escape to the page behind it.

* 🧭 fix: Bind the Continuation Draft, Contain Escape, Defer to the Key Policy

Codex round three.

- The continuation draft is bound to the selection that asked for it. The
  composer is shared across selections, so a fork that lands after the
  reader moved on was handing over the words now in front of them and
  clearing the composer they belong to. The live field is still preferred,
  but only while it is still that continuation's own.
- Escape is handled on the panel element instead of through the focus
  trap's callback. That callback runs on a native listener on the aside,
  so it fired BEFORE any React handler inside it and closed the whole
  panel — taking the composer's text — when a nested popover meant to
  dismiss only itself. As a React handler it bubbles in DOM order, so the
  actor picker can contain its own Escape; `ControlCombobox` gained an
  `onOpenChange` so the panel knows when that is.
- The composer defers to the host's key policy. `Composer` takes an
  optional `resolveKeyVerdict`, and the panel routes it through the same
  `resolveComposerKeyDown`/`useComposerBindings` the main chat form uses,
  so a rebound or unbound submit shortcut behaves identically here and
  chords claimed by global shortcuts are left for the window handler.

* 🔑 fix: Stop the Trap Eating Escape, Freeze the Actor Mid-Continuation

Codex round four.

- `useFocusTrap` only consumes Escape when it actually answers it. Its
  listener is native and sits on the container, so it runs before every
  React handler inside — and by calling `preventDefault` with no callback
  it swallowed the key from the host that had taken Escape back, leaving
  the panel unclosable. Both other callers pass a handler, so nothing else
  changes. The panel suite now runs the REAL trap: stubbing it is what let
  the previous Escape assertions pass in both directions.
- Nothing swaps the composer while a continuation is out. The panel holds
  the draft that travels with the fork, so the actor picker is frozen and
  the newest-task advance defers until the request settles, rather than
  leaving another actor's words to be discarded with the panel.
- The 4 KiB cap applies only in control mode. It bounds a subagent control
  command's payload; a continuation is ordinary chat text bound for a
  composer that caps nothing.

* 🪢 fix: Hold the Selection While a Failed Continuation's Words Survive

Codex round five.

The newest-task advance deferred while a continuation was in flight, but
the error path released that hold at once — so the advance fired, the
control identity changed, and the identity effect wiped the composer. The
panel stays open after a failed continuation precisely so the reader can
retry with those words, and this threw them away.

The hold now covers a failed continuation for as long as its draft is
still in the box, and releases itself the moment the draft is sent or
cleared. The test asserts both halves, and fails if the hold narrows back
to the in-flight case.

* 🧹 fix: Hold for Any Unsent Draft, and Let a Cleared One Stay Cleared

Codex round six.

- Unsent words hold the selection wherever they came from. Protecting the
  draft only once a request had started or failed left the plainest case
  open: type a continuation, let a newer task arrive, and the advance
  changed the control identity and emptied the composer. The hold is now
  `continuationPending || draft is non-empty`, which subsumes the failed
  case and lets the extra flag go.
- Emptying the field after asking to continue is the reader withdrawing
  the words. While the composer still belongs to that continuation it IS
  the draft, verbatim, so the destination no longer reinstates text they
  deleted; only a composer that has moved to another selection falls back
  to what was captured at submission.
2026-08-31 21:46:58 -04:00
Danny Avila
47dbcb4910
🎯 fix: Keep the Thinking Label on the Lightbulb's Axis While Shimmering (#15437)
The shimmer PR (#15431) nested the label inside a span carrying `.shimmer`,
which is `display: inline-block`, alongside `truncate`. An inline-block whose
overflow is not visible takes its baseline from its bottom margin edge rather
than from its last line box, so the label row's line box grew from 18px to 23px
and the text lifted 2px while the lightbulb — pinned to the row's 30px centre by
the copy button — stayed put. Every streaming reasoning header sat off its own
icon's axis until the label settled back to "Thoughts".

The sweep now rides the label row itself. That row is a flex item, so
`.shimmer`'s `inline-block` is blockified away and the text lands exactly where
the un-shimmered label lands: measured against the real component, both states
report an 18px box and the same text centre, where the nested form reported
23px and a 2px offset.

The nested span survives only for the generated-label entrance, which cannot
share an element with the sweep because both drive `animation-name`. It keeps
the entrance outside — the clipped element paints the glyphs itself, so a
descendant's opacity cannot fade them — and takes `align-top` so the baseline
rule above cannot reopen the gap there.

Found by rendering the real component in a browser; a hand-built reproduction of
the same classes did not show it, and neither did the DOM assertions, which is
why the regression shipped.
2026-08-31 21:15:28 -04:00
Danny Avila
cceb936655
🪗 feat: Fold a Live Run's Tool-Call Groups Into the Phase Card (#15434)
* 🪗 feat: Fold a live run's tool-call groups into one phase card

A long agent run renders one row per labeled tool block, so a turn that
takes twenty steps pushes twenty disclosure rows between the reader and
the answer. The parent phase card already solves this — it just does not
exist until the server has summarized the phase, which is after the run.

Give `groupActivityPhases` the whole partition instead of only the part
the server has claimed: an unclaimed run of two or more labeled activity
blocks becomes a phase segment with a client-built header. `ContentParts`
renders `ActivityPhaseGroup` for it exactly as it does for a real phase,
so both cards share one definition of the chrome, the fold animation, the
lazy body, and the approval retention — change the styling once and both
move.

The header carries the newest filled child label, which makes the
collapsed row a ticker: it reads as the line that would have been at the
bottom of the unfolded list, and the generated summary replaces it
verbatim when the marker lands. The fold ends at that newest label, so
the reasoning and tool call still streaming stay outside the card where
they can be watched, and join on the commit their own label fills.

Boundaries mirror the server's own phase rule (steer, existing marker,
substantial prose) so the synthesized span and the phase card that
replaces it cover the same content. Answer text is always a boundary —
`groupSequentialToolCalls` absorbs only `commentary`, and nothing the
reader came for may end up behind a disclosure.

Toggle memory moves into the message-wide map both cards now share with
`ToolCallGroup`, keyed on the span rather than either header, so opening
the ticker to watch survives the swap to the summary.

The rule is content-derived, so history and a live run partition
identically and nothing unfolds at settle — `activityPhaseLabel` is
opt-in, and a deployment with child labels but no phase summaries would
otherwise drop the whole list back open at the end of every turn.

Parallel content stands down: those columns own their layout and a
synthesized card would pull them onto the phase path.

* 🎞️ fix: Do not replay the entrance fold when a summary claims a fold

A server marker landing on a span a synthesized card already covers was
reading as an arrival, so the real phase card mounted with the entrance
animation — which mounts a card OPEN and folds it shut over the next two
painted frames. On a span the reader had already watched fold, that
flashes every sub-group back onto the screen before collapsing again.

Record the content indices sitting behind a synthesized card and suppress
the entrance when the marker's span overlaps them. Indices rather than
keys, so a start boundary the server resolves slightly differently from
the client still counts as the same span.

* 🙋 fix: Never fold a span holding an unresolved approval

A fold summarizes work that is done. An approval waiting on the reader is
the opposite: the run is blocked until they answer, and burying the
request behind a disclosure they have to discover strands the turn.

A server marker cannot reach this state — it is emitted after the batch
resolves — but a subagent nested inside an already-labeled group can
raise an approval long after its parent's label filled, which puts it
inside a synthesized span. Render that span exactly as it would render
without the feature until the approval clears, then fold.

* 🧪 test: Assert the fold header ticks forward without re-opening

* 🧷 fix: Tighten what a synthesized fold may claim and hide

Four issues from review, each now pinned by a test that fails without its
fix.

An error, an image, or a summary between two labeled blocks was joining
the run and disappearing into the card. Membership is now the allowlist
`groupSequentialToolCalls` uses — tool calls, reasoning, commentary,
labels — plus AGENT_UPDATE, which the server deliberately keeps inside a
phase because a transfer card cannot join a tool group. Anything else is
content in its own right and ends the fold.

Orphan labels were counting as activities. A label that claims nothing
heads no group and renders as a standalone line, so two of them are not
two activities — folding them hid the first behind a card whose body was
just the pair of lines. Labels now count only when they claim a non-empty
block, with the claim closing at every label (blank reservations
included) exactly as `claimStart` does, and handoff calls claiming
nothing.

Card identity was anchored to the span's first part, so it moved when the
server extended a phase back across short unphased text the client treats
as a boundary — dropping the reader's open card on the swap the shared
identity exists to survive. It is an ordinal now: phase cards only ever
append in content order.

The synthesized entrance is gone. It mounts a card OPEN and folds it
shut, and this component remounts mid-run — `messageId` is in the key and
changes when the placeholder hydrates to the server id, and a reconnect
mounts straight onto existing labeled content — so it would flash the
whole fold back open partway through a run. Fold GROWTH was never
animated, so formation matching it is the consistent behavior.

* 🔑 fix: Key a phase card by its span so the summary reconciles in place

Two more from review, and the first one condemns the mechanism rather
than the instance.

Ordinal card identity was not stable: an earlier server phase can hold a
pending marker that yields no segment yet — its activities are handoffs,
or no child label has filled — so a later fold takes `phase:1` and is
pushed to `phase:2` when that marker fills, handing the reader's override
to a card they never opened. Any counter has this shape, so the transfer
map is gone entirely.

What replaces it needs no state to hand over. Both card kinds now render
under one key anchored to the SPAN, so the card that carries the summary
is the same element as the fold it replaces and React reconciles it in
place — the reader's open card simply stays open. A phase with no
children has no span and keeps its marker key. `ActivityPhaseGroup` is
byte-identical to dev again: the shared component needed nothing.

The honest limit, now pinned by a test: when the server extends its span
back across short unphased text the client treats as a boundary, the two
spans differ, and a card covering different content is keyed and mounted
as a different card. The toggle does not carry there. Keeping the
stricter boundary is deliberate — `phase` is only stamped by providers
that expose it, so matching the server would let a short final answer
hide inside a fold.

Second: `tool → transfer_to_* → label` was counting as a claimed batch,
while the grouping flushes the block at the non-groupable transfer and
then drops the label through `coversTransferCall`. Two such batches built
a card over labels that render nowhere. The claim now resets at any part
the block cannot hold, matching the flush.

* 🗝️ fix: Drop messageId from the card key and let a grown span animate

Two more from review; the second deletes a mechanism the span-keying had
already made redundant.

The assistant streams under a synthetic `${userMessage.messageId}_` for
the WHOLE run and only takes its server id at `finalHandler`, so a key
carrying `messageId` remounted every phase card at settle and dropped
whatever the reader had open — a guaranteed loss at the end of every
turn, not a narrow window. The card key is the span alone now, which is
how `ToolCallGroup` has always keyed for the same reason.

`replacesFold` suppressed the entrance whenever a marker's span merely
OVERLAPPED a previous fold. When the server extends its span back across
short unphased text the two spans differ, the card is genuinely a new
one, and suppressing the entrance made the text the reader was looking at
blink out of existence instead of being folded in. The suppression is
gone: a same-span replacement is now reconciled rather than remounted, so
it cannot animate anyway, and that was the only case worth suppressing.

With it goes the `folded` index tracking it was the sole reader of.
Anchoring identity to the span turned out to subsume both the expansion
map and this set — the diff is smaller than it was two rounds ago.

* 👥 fix: Separate a sibling switch from a message taking its server id

Dropping messageId from the card key fixed settle but opened the case it
had been guarding: MultiMessage renders siblings without a key and reuses
this instance, so an index-anchored card carried one response's open
state into an unrelated one.

Neither prop tells the two apart on its own — setIsSubmitting(false) is
batched with the final message swap, so that commit looks exactly like a
sibling switch by message identity. `siblingIdx` does: it moves when the
reader pages to another response and holds still when the same response
takes its real id.

* 🪪 fix: Pair the card's position with its first provider id

`siblingIdx` was the wrong discriminator. MultiMessage recomputes the
viewed response's positional index whenever a sibling is added or dropped
around it — its own docblock calls this out — so a key carrying it
remounted the card during churn that deliberately PRESERVES the response
the reader is on. Its docblock also records why no message id works
either: messageId and parentMessageId both move through the SSE
lifecycle, which is exactly why that component reconciles positionally.

The span's own position was never the problem — it is content-derived, so
churn cannot touch it. It only failed to separate two siblings whose
cards start at the same index. Pairing it with the first tool call's
provider id fixes that and nothing else: settle and churn leave both
halves alone, and the pair also keeps repeated provider ids in one
message apart, which a bare id would have collided on — the existing
`counts repeated legacy provider-id groups` case proved that immediately.

* 🧲 fix: Anchor the card to its first tool call and spare hoisted output

Anchoring the key to the span's first PART broke at settle whenever a
phase opened with an empty TEXT or THINK: preserveStreamedContentIdentity
drops those slots and stamps the survivor, so the anchor moved and the
card remounted exactly when the run finished. `getToolGroupId` already
records the answer — the tool calls themselves do not move — so the
anchor is the first tool call's own position now, with its provider id
still alongside to keep repeated ids apart.

That also closes the limitation this PR had been documenting. A phase the
server extends back across short unphased text still shares its first
tool call with the fold, so the two now reconcile and the reader's open
card rides through. The test that pinned the old degradation asserts the
better behavior instead.

Second: `ToolCallGroup` renders `groupAttachments` OUTSIDE its own panel
so a generated image or file survives collapsing the group. Folding that
group into a card put the hoist back inside a disclosure and the output
disappeared. These attachments are message-level and never appear in
`segment.content`, so the visible-part allowlist could not catch them —
a span carrying any takes the same escape as an unresolved approval and
renders unfolded. Hoisting them to the card would be better and would fix
the same hole for server phases on dev; it is not this PR.

* 🎯 fix: Give id-less spans a scope and stop the second streaming cursor

Two from review.

The card key's no-provider-id fallback was a bare position, which cannot
separate two siblings whose cards start at the same index — the exact
hole the provider id had just closed, reopened for id-less legacy calls.
That branch carries the message-change counter now, which is what
`getToolGroupId` does for its own id-less fallback, and it accepts the
same tradeoff: the counter advances at settle, so those cards remount
then. Spans that have a provider id are unaffected.

`showEmptyCursor` never consulted `isLast`, so a trailing empty provider
slot rendered the initial waiting state from inside its own segment even
though a card was already carrying the cursor — two dots at once. Reusing
`isLast` would have been wrong: it means "leaf of the tree", and the
existing thinking-dot tests legitimately leave it false while submitting.
The phase branch now computes which card owns the cursor and passes that
down, alongside the other internal segment signals. It covers real phase
markers too, which had the same duplication.
2026-08-31 21:14:20 -04:00