* 📏 fix: Keep the Context Gauge's Used Count Above Its Own Breakdown
* 📏 fix: Include summary tokens in context gauge breakdown floor
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🪁 fix: Prioritize Running Chats in Sidebar History
* 🪁 perf: Reuse Date Groups Across Active-Job Polls
* 🪁 perf: Avoid Allocating a Set on Every Sidebar Render
---------
Co-authored-by: Lia <lia@librechat.ai>
* perf: Collapse Settled Reasoning Text in AnimatedText
AnimatedText re-split and re-classified the entire accumulated reasoning
string on every streamed token and rendered one element per word, making
a long reasoning stream quadratic. Classification is now append-only: the
leading run of words that finished fading is committed as a single text
node and never re-split, and only the unsettled tail is classified.
* perf: Probe the Settled Reasoning Prefix Instead of Rescanning It
The append check compared the whole settled prefix on every token, which
kept the stream quadratic in character comparisons. It now probes the
prefix head and the region at its boundary, and the settled region is
rendered from the current text so a rewrite can never show stale
characters. Adds a long reasoning stream scenario to the mock harness.
* perf: Settle Spaceless Reasoning Runs Before Their Final Segment
A CJK or Thai reasoning stream never reaches whitespace, so the settled
prefix could not advance and the whole run was re-segmented per token.
Inside a spaceless last word everything before its final segment is now
treated as stable; re-segmenting there only changes fade granularity.
* perf: Bound the Unsettled Reasoning Tail by Length
Settling at part boundaries left any run that never reaches whitespace
(unspaced Hangul, a spaceless script without Intl.Segmenter, long URLs)
in the tail, re-classified on every token. The unsettled region is now
capped at 64 characters regardless of segmentation, replacing the
spaceless-specific rule; only non-animated text is ever cut, so a cut
inside a part is invisible. Tests measure the classified length per
render instead of the DOM shape.
* fix: Keep the Settled Reasoning Cut on a Glyph Boundary
The length cap could cut inside a surrogate pair or a combining or ZWJ
sequence, splitting one glyph across two text nodes. The cut now steps
back past continuation code units.
* fix: Cut the Settled Reasoning Prefix at Grapheme Boundaries
Code-unit rules missed emoji modifiers and regional-indicator flags. The
cut now takes the last grapheme boundary from Intl.Segmenter over the
unsettled tail, which starts at a committed cluster boundary and is
bounded by the cap; the code-unit rule remains as the fallback.
* fix: Skip the Reasoning Tail Cap Without a Grapheme Segmenter
The code-unit fallback could still split emoji modifiers and flags. With
no Intl.Segmenter there is no safe cut, so the cap is not applied and the
tail stops at the last word, as it did before.
---------
Co-authored-by: Lia <lia@librechat.ai>
* 💭 feat: Bring the Streaming Thought Peek Back Under a Collapsed Live Card
#14546 previewed streaming reasoning as its trailing sentences in a short
fading window under the thought's header. The live fold (#16118) put that
thought inside a collapsed card, which unmounts its rows, so the peek went
with them and one throttled sentence on the header stood for a paragraph
of live reasoning.
A collapsed live card whose tail is a streaming thought now renders the
same peek under its header, outside the fold, in the cursor's place. It
gives way to the rows when the card opens and to the cursor when a call,
not a thought, is at the tail.
* 🧪 test: Watch Live Reasoning Stream Through the Real App
A mock-lane scenario streams three sentences of reasoning at a readable
pace; the spec samples the collapsed card's header and asserts every line
was the generic one or a whole sentence, sees the thought peek under the
card, opens the card mid-stream and checks the header became a title, then
checks the settled thought's header sits at the shared row scale.
The peek strips the thought's tags itself: handed the stream straight from
a live card, it had shown a literal `<think>` before the first words.
* 🎨 style: Sort Activity Phase Imports After Branch Rewrite
---------
Co-authored-by: Lia <lia@librechat.ai>
An open card whose label has not landed yet kept the live line, so its
sticky header quoted the sentence the reader could already see streaming in
the rows beneath it. Open, the header now names the span by its newest
label: a thought's generated label or the generic thinking line, a batch
label, a call's own line. Reasoning sentences and prose commentary are for
the collapsed header, which stands in for rows the reader cannot see.
The live header previewed the sentence the model was still writing, word
by word, so it read as fragments ("This is a simple greeting, not") that
changed before they made sense and were replaced by the next fragment. It
now shows the last sentence that ENDED, holds it for at least a second, and
keeps its generic line until the first sentence finishes. A Latin mark
closes a sentence only before whitespace or the end of the text, so
decimals and version numbers stay whole; CJK marks need no space.
The measurement that let short sentences stream freely until they filled
the row (a ResizeObserver and a per-paint scroll-width read) goes with it:
the line no longer changes per word, so there is nothing to meter.
The standalone thinking disclosure and its non-interactive marker were the
one activity row sized to the reader's body text (`fontSize`, 16px at the
default), while tool calls, grouped thoughts and phase summaries all sit at
`tool-status-text` (0.9× the markdown size, 14.4px). The same thought read
at two sizes depending on which surface held it, and at larger settings the
header outgrew the message heading beside it.
Both headers now take `tool-status-text` and the medium weight every other
row label carries. The thought body keeps the body size, as prose should.
* 🪜 feat: Title an Open Activity Fold and Reach Failed Calls in One Click
An open phase or tool group now reads as the title of the rows under it:
the header steps up to primary semibold, pins the stable label instead of
the live line, and sticks to the top while its rows scroll. Rows step in
24px under a hairline rail hung from the header glyph, one level per fold.
A failure is one click away from anywhere. A "N failed" pill beside the
header opens the fold and every failed row's output; a collapsed card peeks
its first failed call and error line under the header; the failed row
carries a red stripe, the error's first line as its subtitle, and names its
subject by the model's intent as the live header and peek already do.
The reveal travels down a FailedRevealContext counter that a group relays to
its own rows only once they have mounted, so a request made on a closed
card reaches a row three lazy disclosures below it.
* 🧪 test: Drive the Activity Fold Through the Real App and Fix What It Showed
A mock-lane spec runs a phase whose middle batch holds a call that failed
schema validation beside a slow one, watches the fold stream, then reaches
the error from the peek, from the pill, and again after a reload, in both
themes, with no console or page errors.
Three things the real app showed that the harness had not:
- The client counted only two of the server's three failed-output shapes,
so a schema-validation failure that the server labelled `partial` rendered
as a completed card with no pill. `isError` now mirrors
`completedToolExecutionStatus`.
- A row's label lost its last letters to an ellipsis whenever its subtitle
overflowed: the weighted shrink left the label a fraction of a pixel short.
The subtitle now takes all of the shrink and the label caps at the row.
- The peek named an MCP call by its server while the row named the tool.
Both now name it the way the row does, and the error line drops its bare
`Error:` prefix the red glyph already speaks for.
* 🎯 fix: Answer a Failed-Call Reveal From Every Card's Disclosure Control
The reveal was consumed by the generic ToolCall row alone, so a failed
bash, code, memory, file or skill card, each rendered through its own
component, opened its group and stopped. The consumer now lives in
ProgressText, the disclosure control every card renders: a failed, openable,
closed row opens through the card's own toggle, and the one row the request
lets take focus lands the reader on its labeled button rather than on an
unnamed wrapper. The request carries a one-shot focus claim, relayed
through nested providers, so a phase with several failures opens all of
them and focuses only the first in document order, the one its peek named.
Also from the same review: an error line is derived only from output that
is an error, so a step failed by its run status or a status attachment no
longer shows ordinary output in red; a standalone group shows its failure
count once, on the pill, keeping the text for the accessible name; and the
label and subtitle share one shrinking box so the verdict, duration and
chevron after them never lose width.
* 🎯 fix: Make Failed Activity Cards Reachable From Fold Controls
* 🛡️ fix: Keep Legacy Search Errors Hidden Outside Failure Summaries
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🛬 fix: Settle Background Tool Results Before the Server Shuts Down
* 🛬 fix: Preserve Background Shutdown Results Through Fallback
* 🧪 test: Match Formatted Cluster Shutdown Wiring
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🧨 fix: Reject Invalid AES Credentials Before Startup
* 🎯 test: Format Credential Validation Cases
* 🧪 test: Use Valid AES Credentials in API Fixtures
---------
Co-authored-by: Lia <lia@librechat.ai>
* 📬 fix: Show Background Results Still Waiting for the Agent
The chat header listed a background task as completed as soon as its tool
finished, while its result could still be queued behind a busy turn and
arrive minutes later as a new agent turn. The header also read only the
process-local registry, so tasks on another replica were invisible.
The task index now reads the durable delivery store the agent's
check_background_task already uses: each finished task carries
delivery pending, delivered or failed, and finished results known only to
the store are listed too. The header marks results still on their way,
keeps them ahead of delivered ones, and polls them every 10 s.
* fix: Retain And Index Background Result Delivery States
* fix: Pass Background Delivery CI Checks
---------
Co-authored-by: Lia <lia@librechat.ai>
* feat: Attach or leave a workspace on a saved chat
A saved chat that recorded running without an attached environment could
never take one: `without_attached` is sealed for the life of the chat, and
the only transition was a move between attached environments. Switching an
existing chat to a coding agent therefore ended in a composer that could
send but never reach files or commands. A chat sealed to a machine that went
offline had the opposite dead end: Send stayed disabled with nothing on
offer but a reconnect hint, and the "Move the chat to continue without it"
copy promised a request the server rejected as `invalid`.
One transition mechanism now covers all three directions. `from` still
repeats the persisted decision, so a stale view cannot replace a decision it
has not seen, and only a decision the chat actually recorded can move:
- attach, from a recorded `without_attached` onto the environments its
agents use, with each target workspace revalidated on its worker;
- detach, an empty `to`, which clears the selections without polling the
machine the chat is leaving;
- move, unchanged, including its refusal to switch the workspace of an
environment the decision already covers.
The composer keeps the control visible while a chat runs without a
workspace, so that state is named and reversible, and offers "Continue
without workspace" whenever a sealed machine stops being usable. History is
untouched and no file is copied.
A send now also records the decision it was submitted under on its own
conversation. The server seals that pair for the rest of the chat, so a chat
that became saved mid-run held none while the stored one was already sealed:
the composer re-derived an agent default the seal refuses and reported
"Choose workspace" with Send disabled until the page was reloaded.
* 🎨 style: Format the Workspace Transition Hook Tests
* fix: Never seal a partial workspace decision, and gate the new directions
Two review findings on the transition mechanism.
A transition replaces the sealed decision whole, and the next turn resolves
every environment or none. The move path could not truncate before, because it
was offered only in `choose` state, which `aggregateState` reaches only when no
environment is unavailable, unsupported or missing: every environment was then
either carried over or selectable. Widening the gate to `!canSubmit` so an
unreachable machine could be left behind broke that invariant, and an
environment nothing can cover would have been dropped from a decision the
composer then sealed, blocking the next send and needing a second transition to
escape. A nonempty transition now requires every environment to be retained or
selectable; when one cannot be, only leaving attached execution is offered,
which is the escape.
The move protocol version becomes 2. Attach and detach travel on the same
owner-authorized endpoint as the move, so a client built against this change
would otherwise offer both to a deployment that only implements moves, where an
attach comes back `locked` and an empty target set `invalid`. The client already
compares the advertised number against the constant, so the bump is the gate.
`conversationMoves.enabled` still decides whether an owner may replace a sealed
decision at all.
* fix: Keep v1 moves working, and take the conversation updater from its owner
Two review findings on the previous head.
Bumping the move protocol wholesale made the client's exact-version check treat
a replica still advertising 1 as supporting nothing, so an attached chat whose
agent moved to another machine lost the relocation that replica already served
-- the previous head's own compatibility test pinned that regression. The
protocol is now two constants: version 1 is the move between attached
environments, version 2 adds attaching an environment to a chat that recorded
running without one and leaving attached execution behind. The server
advertises the highest it implements and the client keeps every lower
capability, so a v1 replica keeps its move while attach and detach wait for the
version that serves them. Where an environment cannot be covered and leaving is
not served either, no transition is offered and the composer reports the state.
Recording the submitted decision had made this hook a second Recoil writer of
the conversation atom, widening the surface that migration has to convert. The
host that owns the atom already holds its setter, so the hook receives it
instead of reaching through `~/store`.
* fix: Advertise attach and detach beside the move instead of above it
Raising the move protocol to 2 kept a client and server of the same build in
agreement, but not the two builds a rollout actually runs at once. The deployed
client compares the advertised number for equality against its own constant of
1, so a server advertising 2 tells every client already loaded in a browser that
moves are unsupported, and an attached chat whose agent changed machines loses
its relocation until that tab reloads.
The move version therefore stays 1, exactly as before this branch, and the two
new directions are advertised on their own field:
codeEnvironmentMoveVersion: 1 // move between attached environments
codeEnvironmentTransitionVersion: 2 // attach an environment, or leave one
Both come from `conversationMoves.enabled`, since all three are one owner
replacing one sealed decision. A client that predates this capability reads only
the move version and keeps working; a client that has it offers attach and
detach only where the second field appears, so it never sends a replica an
attach it refuses as `locked` or an empty target set it calls `invalid`.
* fix: Hold a send while a workspace decision is being replaced
Confirming an attach left Send enabled. The composer disables only the
workspace menu while the request is in flight, so a turn submitted right after
the confirmation started under the decision being replaced: it ran without the
workspace its owner had just chosen, and the replacement still landed, because
the stored decision the compare-and-swap expects was unchanged. The chat then
reported an environment its last turn never used, and nothing said so.
The server's own check has the same shape. It reads the conversation's
generation state, then revalidates each target workspace over the network, then
swaps; a turn that starts during that round trip is invisible to the check that
already ran. It now re-reads the generation state immediately before the swap,
leaving only the instant the compare-and-swap itself covers, which closes the
window for every client rather than just this one.
On the client the submission resolver refuses while a replacement is pending,
so the same signal disables the Send button and makes a programmatic send
return false. The workspace control stays reachable, so the state a chat is in
remains visible while it settles.
* fix: Fence Workspace Transitions and Reconcile Rejected Choices
Advance a private conversation revision after publishing an active generation and before reading its authoritative workspace decision. Transition CAS writes compare that revision, covering admission during the final idle-check window without expiring locks. Preserve tenant middleware and exclude private counter writes from chat activity and indexing.
Default existing undecided chats to no workspace, reconcile failed submissions from the server, scope pending guards to the affected chat, compare selection tuples without delimiter collisions, and opt attach/detach into deployment policy independently of existing moves. Retain legacy selection-only choices through first-send events.
* fix: Retain Failed Workspace Recovery and Skip Disabled Fences
Keep unconfirmed code-environment decisions in conversation-scoped Jotai state after authoritative reads fail, mutation observers reset, or navigation unmounts them. Expose a retry action and release submission only after a matching successful read. Ignore stale completions and reject mismatched conversation responses.
Reuse the owner-scoped conversation already loaded by each ingress when effective conversation moves are disabled. Retain the admitted revision fence for enabled moves, including move-only deployments. Cover failure/retry lifecycle and both policy branches at the helper and ingress levels.
* fix: Reuse the Atomic Admitted Snapshot Through Recovery
Return the admission revision and persisted decision from one Mongo findOneAndUpdate. Skip content indexing per internal query while retaining tenant middleware, private projection, and timestamps. Carry the returned snapshot through web and API initialization instead of validating against a stale pre-admission selection.
Keep first-send workspace choices in both the recovery preset and conversation template, and reconcile using the generated conversation ID from error or message data rather than requiring a saved submission snapshot. Cover single-query storage, indexing isolation, moved-machine validation, and first-send error recovery.
* fix: Reconcile Cancelled Turns and Keep Detach Reachable
Reconcile the submitted code decision before the local cancellation path finalizes streamed content or recovers a minimal submission. A cancel that beats the server rejection must not leave the attempted choice sealed locally; navigation must not update a different conversation.
Offer the authorized detach-only transition when a sealed conversation no longer has any attached agents, while ordinary chat stays sendable. Keep the selector visible for that transition and retain existing policy gates. Cover cancellation branches, no-attached-agent states, managed-only agents and the detach action.
* fix: Recover Workspace Transitions Across Navigation
* test: Verify Saved Workspace Transitions Against Current Dev
* test: Assert Explicit No-Workspace State in Native Journey
* test: Await Browser Settlement Before Switching Native Agents
* test: Settle URL Agent Selection Before Native Chat
* test: Wait for Worker Lease Expiry Before Offline Detach
---------
Co-authored-by: Lia <lia@librechat.ai>
Co-authored-by: Danny Avila <danny@librechat.ai>
* 📮 fix: Count Undelivered Background Results as Outstanding
* fix: Reconcile delivered tasks, discard exactly, and count pending subagent results
* fix: Settle manually claimed remote deliveries and keep pending controls while wake-ups drain
* fix: Report dead-lettered deliveries as failed and read subagent wake-ups from the durable store
* fix: List restored dead letters and retire deliveries on local durable claims
* 🐢 fix: Back Off Waiting Completion Wake-ups and Deliver Them When Ready
* fix: Signal every readiness path and make the completion wait cap configurable
* 🧷 fix: Wait for Long Dispatch Turns Before Giving Up Background Code Results
* fix: Mark held completion deliveries instead of pipeline expedite, and announce store-won approval expiry
* fix: Keep code tasks protected and wait without a fixed cutoff
* fix: Scope settle expedites to the resumed conversation and close the remaining signal gaps
* style: Format the settlement waiter
* fix: Announce a won approval expiry once and release subagent wake-up registrations
* fix: Outlast terminal persistence before giving up an unanchored code result
* fix: Anchor code results the moment their dispatch turn settles
* fix: Scope harvest epoch pinning to the owning stream
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🐢 fix: Back Off Waiting Completion Wake-ups and Deliver Them When Ready
* fix: Signal every readiness path and make the completion wait cap configurable
* fix: Mark held completion deliveries instead of pipeline expedite, and announce store-won approval expiry
* fix: Scope settle expedites to the resumed conversation and close the remaining signal gaps
* fix: Announce a won approval expiry once and release subagent wake-up registrations
* 🧪 ci: Count System Instructions in Mock Model Usage (#16350)
The e2e fake model reported input tokens for the chat messages alone, because the SDK hands a test override model the pruned messages without the systemRunnable pipe. Once #16301 gave every memory-enabled chat a system prompt, the calibrated context snapshot put used tokens below the instructions and the gauge dropped its Messages row. Count input over the complete prompt, as a real provider bills it.
---------
Co-authored-by: Lia <lia@librechat.ai>
The e2e fake model reported input tokens for the chat messages alone, because the SDK hands a test override model the pruned messages without the systemRunnable pipe. Once #16301 gave every memory-enabled chat a system prompt, the calibrated context snapshot put used tokens below the instructions and the gauge dropped its Messages row. Count input over the complete prompt, as a real provider bills it.
Tokenize budgeting inputs in bounded chunks instead of charging a token per UTF-8 byte above 4 KiB. Subdivide long whitespace/non-whitespace runs to bound BPE merge work and preserve surrogate pairs. Keep strict provider-accounting counts and unavailable-tokenizer fallbacks separate.
Cover both encodings, SDK slice composition, programmatic tool prompts, summarization, real overflow, cache reuse, and failure recovery. Related to #16278.
Co-authored-by: Lia <lia@librechat.ai>
* 🦉 fix: Quiet Idle Subagent Discovery While Preserving Child Wakeups
* 🐣 fix: Wake Saved Parent Index During First-Run Events
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🔕 perf: Back Off Idle Durable Agent Recovery Polls
* 🎛️ style: Format Queued-Turn Recovery Test
* fix: Preserve Durable Recovery Wakeups and Discovery Invariants
---------
Co-authored-by: Lia <lia@librechat.ai>
* fix: Surface Persistent Memory Before First Save
* fix: Distinguish Unreadable Memory From Empty Memory
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🐤 docs: Clarify Maintainer-Directed Canary Pull Requests
* 🐤 docs: Link Issues on Dev and Canary PRs
---------
Co-authored-by: Lia <lia@librechat.ai>
Update package repository and bugs URLs, GitHub links in docs, templates and comments, and image references (compose files, deployed-update, Helm values and renovate hints) from danny-avila to LibreChat-AI / librechat-ai. Covers the rag-api repository and its images, which moved to the organization. Sponsor links and the sealed star-history chart are unchanged.