* 🔱 feat: Simplify Steering Controls to Three Modes
* Preserve Admitted Artifacts During Interrupts
* Preserve Result Admission Across Interrupts
* Gate Interrupt for Provider-Hosted Tools
* Match Interrupt Hints to Availability
---------
Co-authored-by: Lia <lia@librechat.ai>
* 💳 feat: Show Balance in the Context Gauge as Credits, Currency, or Percent
Move the balance out of the account menu into the composer's context gauge,
below the context window, and add `balance.display` (credits | currency |
percent, default credits) to choose how it reads. Currency reuses
`interface.currency` at 1,000,000 credits per USD; percent shows only the
share of the period's allotment spent.
Settings > Account > Billing renders the same summary from the same hook, so
both surfaces show identical figures, bar and refill timing in every mode.
* 🧭 fix: Normalize the Balance Display Mode and Reuse a Fresh Reading on Hover
Admin overrides reach the client without schema validation, so an unknown
`balance.display` now reads as credits instead of being typed as a mode it is
not. Hovering the gauge mounts the balance reader each time the card opens; a
30 s stale window stops every hover from refetching, while the explicit
refetch after each turn still bypasses it.
* 🩹 fix: Restore Gauge Popover Fixes and Tighten Balance States
The popover extraction was written from a pre-sync read of TokenUsage, so it
dropped dev's viewport caps and scrolling, the hideOnInteractOutside close fix,
the Tailwind v4 outline-hidden rename, and the card's max-w-full; restore them.
Refill copy now says when a refill becomes available rather than promising a
deposit, since one lands only once the interval has passed and a charge would
exhaust the balance. An empty balance reads as fully used even without an
allotment, percent mode without one says usage is unavailable instead of
leaving the figure blank, the balance-only ring takes the balance tone (amber
until empty) and is a meter only once it has a value.
* 🪙 fix: Read a Non-Positive Refill Amount as No Auto-Refill in Settings
The server never refills when the amount is not positive, and the balance
summary already says so; Settings showed its load error instead.
* 💸 fix: Show the Insufficient-Funds Error in the Balance Display Mode
The token-balance error still printed raw credit figures, so `percent` leaked
the numbers it hides and `currency` mixed units with the gauge. It now reads
the same display mode and formatter as the balance summary: credits as before,
money in currency mode, no figures in percent mode.
The auto-refill settings row also renders its own loading and failure states,
since settings search can show it without the balance row beside it.
* 🎚️ fix: Keep Fractional Credits and Drop the Moved Popover's Suppression
Credit amounts keep up to two decimals, so an insufficient-funds message no
longer reads 100.4 against 100.3 as 100 against 100; whole amounts still print
without decimals.
The design-rule backlog may not follow code into a new file, so the extracted
popover uses the standard `transition` utility instead of the arbitrary
`transition-[opacity,transform]` (which also misses Tailwind v4's separate
`translate` and `scale` properties) and its suppression is removed. The
composer geometry spec now reads the classes from `Popover.tsx`, where the
gauge button lives.
* 🧭 feat: Let a Parent Choose Its Subagent's Code Machine Per Call
A parent agent can now pass optional `machine` / `workspace` arguments on a
subagent call to pick where the child runs, using the host-argument
extension point added to @librechat/agents.
- Each lazy child declares enums built only from machines it may reach:
admitted in the conversation's sealed codeWorkspaces, on its default or
allowlist, in the requesting principal's tenant-scoped list, and served by
a ready worker. A child the conversation pinned to a machine offers only
that machine; a child with no reachable machine declares nothing.
- On use, a request-scoped routing session in packages/api re-validates the
choice against the current request and live worker status and refuses an
invalid one with a typed, model-visible error instead of falling back. A
routed child is pinned to the chosen machine at every routing site,
overriding parent inheritance.
- Omitted arguments keep inherit-by-default routing, extended so a child
follows the machine a per-call-routed parent runs on (passing through
agents without code). A subagent keeps one machine for the whole request.
- A child whose default workspace is unavailable stays guarded unless it has
per-call choices; then it stays callable and its description asks the
parent to pick a listed machine.
- Routed children keep their tool context per execution for tool loading,
provisioning and artifact handling.
- Paused-approval bindings, the attached-machine policy hook, skill-file
priming and tool-output references account for per-call choices.
The declarations are gated on the installed SDK exporting
SubagentHostArgumentError, so this change is inert until LibreChat depends on
an @librechat/agents release that includes it.
* 🧭 fix: Reserve Default Routes Early and Route a Routed Subagent's Graph Members
- Reserve a subagent's default machine when it is placed, as
initializeAgent will resolve it (including parent inheritance), so a
concurrent call cannot claim another machine during initialization.
- Graph members spawned by a per-call-routed subagent follow its machine
when they may, unless they already initialized on their own route this
request.
* 🧭 fix: Settle Concurrent Inherited Routes and Register Routed Graph Members
- Re-read a subagent's inherited route after resolving targets, so two
concurrent calls from differently routed parents settle on one machine.
- Attribute a workspace-only conflict to the workspace argument.
- Register graph members a routed subagent initialized, so each gets the
attached-machine policy of the machine it actually runs on.
* 🧭 fix: Re-read Inherited Routes After Resolving Subagent Targets
- Re-read a subagent's inherited route after the target resolution await,
so two concurrent omitted-machine calls from differently routed parents
settle on one machine.
- Attribute a workspace-only conflict to the workspace argument.
* 🧪 test: Prove a Routed Graph Member Takes Its Machine's Policy Through createRun
- Register a resolved child's graph members inline in the lazy resolver
instead of through an exported generic helper whose test did not
typecheck.
- Drive the check through createRun's real PreToolUse hook: a member
routed to a deny machine flips from its metadata machine's allow to deny
once its parent resolves.
* 🧭 fix: Hold a Lazily Loaded Graph Member's Default Machine While It Initializes
- Pass a graph member's code flags when it initializes on its default
route, so the routing session reserves that machine before the
asynchronous initialization instead of only after it, and a concurrent
call cannot place the same agent on another machine meanwhile.
* 🧭 fix: Validate the Approval Mode Against Every Machine a Subagent May Use
- Collect each agent's default attached route and each attached machine a
parent may route it to per call, and validate the requested approval
mode against that set in createRun and both client checks.
- A child whose default is unavailable but whose per-call machine permits
accept edits no longer fails run creation; full access still requires
every such machine to permit it.
* 🧭 fix: Admit, Prime, and Cancel Per-Call Subagent Routes Conservatively
- Build scheduled pause admission from every attached machine a parent
may route an agent to, so a permissive default does not hide a
per-call machine that asks.
- Walk lazy graph-member metadata when collecting execution routes, so
historical skill files are primed for every machine such a member may
run on.
- Stop placing a canceled call after its target resolution resolves, so
it never claims a machine for an execution that will not initialize.
* 🧭 fix: Release Unused Route Claims and Scope Per-Call Machines to Their Run
- Hold a subagent's route claim per placement: a failed or canceled
initialization gives the machine back unless another execution still
holds it, and a claim is permanent once a child on it attaches.
- Fold an agent's default route into its per-call choice digest, so each
agent contributes at most one paused-approval binding target.
- Use only an agent's route policies for pause admission when it has
them, so a missing default does not make a decided route look asking.
- Drop a routable child's provisional attached-machine membership when it
resolves off attached machines.
- Offer and accept no attached machine per call while run files are
shared, since shared children must run on managed code.
* 🧭 fix: Give Back a Route When Its Placement Verification Fails
- Release a placement's hold when attach finds the child initialized on a
different machine than the one it was routed to, so a retry that
follows the unavailable-machine guidance may name another machine.
* 🧭 fix: Commit a Lazy Child's Routes Only When Its Whole Resolution Succeeds
- Keep the routes a lazy child and its routed graph members hold pending
through the child's entire resolution (settleExecution), committing them
on success and giving them back on failure or cancellation unless
another execution still holds them.
- Placements outside any call (shared graph members) still commit when
they attach.
* 🧭 fix: Drop a Failed Lazy Resolution's Config from the Graph Cache
- When a lazy child's graph resolution fails or is canceled after its
config was cached for graph reuse, remove that entry with its route, so
a later graph never reuses a config for a machine the child gave back.
* 🧭 fix: Follow a Routed Agent Through Self-Spawned Runs and Scope Routed Member Configs
- A call whose parent run was never placed (an allowSelf spawn reuses its
routed inputs) inherits the routed claim of its parent agent, which keeps
one machine per request.
- Never share a graph member initialized for a routed parent's execution
through the graph-member cache, so a failed resolution leaves no config
behind for a route it gave back.
- Race lazy target discovery with the request signal.
* 🧭 fix: Pass a Machine On Through Self-Spawned Runs of Agents Without Code
- Record the machine each agent without stateful code passes on, and let a
call from that agent's unplaced run (an allowSelf spawn) follow it when
the agent passed on exactly one machine this request.
* 🧭 fix: Keep a Pass-Through Route Only When Its Resolution Succeeds
- Record the machine an agent without code passes on with the rest of its
call's routing state: kept when the resolution deciding it succeeds,
dropped when it fails, so a self-spawn never follows a failed attempt.
* 🧭 fix: Settle a Lazy Child's Routing State at the SDK Handoff
- Wrap the run's whole lazy resolution, through the inputs handed to the
SDK, in the descriptor's settle hook, so a cancel after the host
resolver returns still gives the call's routes back.
- Roll back the per-agent tool context a pending placement set (restoring
the entry it replaced) when its resolution fails, so a retry on another
machine seeds its own context.
- Drop a failed call's shared config from the graph cache through the
same settle hook.
* 🧭 fix: Keep Per-Agent Tool Contexts on Live Placements and Queue Target Probes
- Track every pending placement that uses an agent's per-agent tool
context: a committed one sets it, a failed one hands it to a surviving
placement, and only the last failure restores the earlier entry.
- Let an unplaced run of an agent (an allowSelf spawn) defer to the routed
run of the same agent that encloses it when looking up tool contexts.
- Queue live target probes at eight in flight, below the shared status
poller's ceiling, so concurrent descriptors never misreport a healthy
machine as unavailable.
* 🧭 refactor: Load Routed Graph Members Through a packages/api Service
- Move the routed graph-member load (shared reuse, skip list, view check,
execution identity, failure policy) into createRoutedGraphMemberLoader;
the initializer only injects its dependencies.
- Thread the request and call signals into target resolution so queued
probes are skipped once canceled.
- Probe nothing in shared-file runs, where every per-call target is
attached and unusable.
- Retire pending tool-context ownership when a committed placement
installs the per-agent entry.
* 🧭 fix: Share a Lazy Child's Config with Later Graphs Only After It Commits
- Publish a default-placed lazy child's config to the shared graph cache
from the settle hook's commit, so no concurrent graph can borrow a config
whose route may still be given back.
- Resolve a child's own appearance in its graph to the child config itself.
* fix: separate subagents and handoffs into native tools
* test: reselect the saved agent after browser reload
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🧬 fix: Default Subagents to Their Parent's Code Machine and Workspace
A subagent resolved its code machine from its own saved fields only, so
when a chat routed the parent to an allowlisted machine the subagent fell
back to its own default and whatever workspace the conversation had
selected there, or failed the parent's whole turn when none existed.
Subagents now inherit the parent's resolved attached machine when it is
their own default or on their allowlist where per-chat choice applies,
the principal can use it, the sealed decision already selected it, and no
selection names the subagent as an explicit owner. Inheritance is derived
per request from the sealed decision and current agent configuration and
fed to every routing site; it is never persisted, so existing chats and
older clients get it without a decision change. The composer mirrors it.
A subagent whose machine has no usable workspace is advertised to the
parent as unavailable instead of failing the turn; a locked decision
stays fatal.
* fix: Inherit Across Every Spawning Path, Graph Members and Deferred Code Tools
A subagent now inherits only when every agent that can spawn it, at any
depth, runs on the same machine; spawn cycles keep their own routes.
Subagent graph members inherit like explicit subagents. The deferred
execute_code loader passes inheritance to its fallback resolver. Subagent
reads and VIEW checks move to a packages/api loader shared by inheritance,
lazy descriptors and graph members. The composer lets a draft's subagent
follow its parent's machine before a workspace is picked, and keeps an
inheriting subagent's former selection without asking for a move.
* fix: Prune Spawn Back-Edges, Gate the Composer on an Inheritance Capability
Spawning parents follow the run's path semantics, so a back-edge the
descriptor tree prunes no longer blocks inheritance, and agents that spawn
each other follow their single outside parent machine when it routes them
all there. Only admitted subagents count toward the walk's node limit.
Graph members re-read and re-check VIEW when they initialize. The composer
echoes an inheriting subagent's former selection without gating on that
machine, and mirrors inheritance only when the API advertises
codeWorkspaceInheritanceVersion; approval modes keep intersecting every
machine an agent could use.
* fix: Settle Each Mutually Spawning Group on Its Own
Independent spawn cycles no longer merge into one group, so a pair under
one parent follows that parent even when another pair follows a different
machine. Also types the data-provider spec for its ES5 target.
* fix: Bound the Inheritance Walk, Normalize Parallel Roots, Move Subagent Availability to TS
The walk reads in batches no larger than the remaining node budget, stops
once the limit is reached, and runs through the run's subagent load limiter.
Roots are keyed by saved agent ID, so a parallel root such as id____1 can
never receive an inheritance entry. Resolving a lazy subagent's code route,
reporting it unavailable, and guarding its descriptor now live in
packages/api (resolveSubagentCodeAvailability, guardUnavailableSubagent).
* fix: Keep Missing Subagent Loads Parallel Near the Node Limit
Batches never shrink below eight IDs, so missing or unviewable subagents
near the limit still load in parallel under the injected limiter, and at
most a handful of reads land past the limit.
`mistral-large-2512` (and `mistral-large-latest`, which now points to it)
had no dedicated entry and fell back to the generic `mistral-large` key,
billing at Mistral Large 2 rates ($2 / $6), 4x the actual price.
- Add `mistral-large-2512` and `mistral-large-3` at $0.50 / $1.50
- Point the generic `mistral-large` fallback to the current model's price
- Pin `mistral-large-2411` to its $2 / $6 rate
- Drop the stale Sonnet 5 "revert after 2026-08-31" comments: Anthropic
made the $2 / $10 pricing standard, so the scheduled increase won't happen
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
* 🔗 feat(agents): use LibreChat prompt groups as agent instructions
Agents can link a prompt group revision or Production as their instructions. The link resolves at the start of each turn through a cached resolver. The cache clears on promote and delete. Editors without VIEW on the group see a restricted placeholder.
* fix: remove duplicate logger import from agent initialization tests
* fix: honor prompt management capabilities for linked agent instructions
* test: seed prompt manager capabilities in authorization fixtures
* fix: clear acknowledged linked prompt edits before version restore
* test: adapt merged chain coverage to prompt-aware payload helper
---------
Co-authored-by: Lia <lia@librechat.ai>
* fix: Sync Spinner Rotation Phase Across Instances
* test: Colocate Spinner Spec In __tests__
* fix: Address Review Findings on Spinner Phase Pinning
* fix: Fall Back To Legacy Media Query Listeners In Spinner
* fix: Repin Recreated Spinner Rotations And Defer Without queueMicrotask
* feat: add app-wide UI scale setting
* test: align dev's new header, drawer and combobox specs with the scaled shell
* fix: keep design-recorded arbitrary values off the same-count swap
* fix: scale composer and reasoning spacing on the spacing scale
* test: reach scaled rows and wait on the composer under the unpainted drawer
* test: cover the scaled composer at both ends of the range
* test: reload the composer scenario at each scale from the live page
* fix: leave the root style untouched at the default scale
* test: align dev's tool output and subagent inset specs with the rem classes
* fix: scale a caller's combobox height cap with its rows
* fix: size the conversation list's row estimate on the scaled drawer breakpoint
* test: align dev's conversation row status spec with the scaled drawer breakpoint
* style: sort the settings dialog imports after the dialog layer merge
* fix: scale the collapsed combobox's fallback popover width
* fix: size the upload glyph on both axes so it grows with the scale
* perf: Cache package builds and make client coverage opt-in
* perf: Add a cached turbo test:ci task and a parallel test:turbo script
* perf: Hash default turbo inputs and live-test env for cached tasks
* perf: Hash live-test credentials in the turbo test cache key
* perf: Hash the ignored backend test env file in the turbo test cache key
* perf: Order test tasks after consumed builds and hash cross-workspace test imports
* test: Cover the cached test runner's keys, build order and client coverage toggle
* perf: Hash the root env file the live responses suite loads
* perf: Stop caching test results and hash the client package's baked env
* fix: Pass every caller variable to test runs and include the shared client suite
* perf: Async Local File Saves and Compile Hot-Path Regexes Once
* perf: Check Closing Code Fences Without a Per-Length Regex Cache
* test: Build the Delivery Route Config Before Routing Instead of Mutating It
mergeFileConfig now memoizes by config identity, so the CSV fallback tests
must set textFallbackWithoutTools when they build the request config rather
than mutate the object after the agent's routing already merged it.
* fix: Write Local Buffers Atomically So Concurrent Saves Cannot Interleave
Async writeFile calls to one deterministic path (OpenID and SAML avatars)
could truncate and interleave each other. Write through a temp file and a
rename instead, and add scenario specs for local saves and longer closing
fences.
* refactor: Move Local Save Logic Into packages/api
saveLocalBuffer, the temp-upload move and the atomic directory writes now live
in packages/api/src/storage/local.ts and receive their paths from the caller;
the Local strategy in /api keeps its logging and calls through. The traversal
check now runs before any directory is created.
* fix: Copy Moved Uploads Through a Temp File and Rename Into Place
Concurrent async copies to one destination could interleave just like direct
writes, so moveLocalFile now fills a sibling temp file and renames it.
* fix: Contain Every Local Write and Move Inside Its Target Directory
The traversal check that guarded saveLocalBuffer now runs in writeLocalFile
and moveLocalFile too, before any directory is created, and the buffer
save accepts only the images and uploads base paths.
* test: Define the Success Assertion Inside the Local File Saves Scenario
* fix: Give Atomic Write Temp Files a Fixed-Length Name So Long Targets Still Fit
* test: Send Image Dimensions and Read the Message Array in the Local Saves Scenarios
* feat: Return a Navigable Progress Tree When Checking a Running Subagent
check_background_task on a running or finished-but-undelivered subagent now
returns an activity digest: the child's turns, tool calls, and replies folded
to one line each and addressed by stable positional paths. Callers expand one
node or range with expand, and page with since against a settled-node cursor.
The owning process folds the child's update stream into a bounded tree that
keeps only tool names, the model-authored intent label, the tool-authored
outcome label, statuses, timings, and sizes. Routed claims carry the tree to a
poll on any replica, lists carry counts and the node in flight, and a finished
child whose owner is gone is rebuilt from its durable public projection.
The background-task card renders the digest as a foldable tree and links the
existing subagent activity panel.
* fix: Tighten Progress Digest Verdicts, Overflow Bounds, and Rebuilt Trees
Failed reply steps and schema-rejected calls now record as errors, and an
overflowed call is counted once without retaining it in the lookup maps.
A tree rebuilt from the durable projection re-checks completed calls with the
shared failure verdict, carries the projection's truncation, and tells the
caller its paths are a reconstruction. The card localizes folded summaries
instead of rendering the server's English tally.
* fix: Measure Single-Part Message Deltas in the Progress Digest
* fix: Scope Nested Progress Ownership by Run and Count Overflow Once
Nested runs now attach to the call recorded by their own spawning run, since
provider call ids repeat across runs. Only the step that announces a call can
count it as overflow, so later sightings of an unretained or evicted call never
re-count it or reopen history. A zero-valued since cursor is rejected, and the
card labels MCP tools with the configured server names.
* 🫗 perf: Release Message Histories of Conversations the User Has Left
Long agent conversations hold 12-18 MB of message JSON each in the React Query cache, and the default 5-minute cacheTime kept every conversation visited in that window. Switching between a few of them on mobile Safari grew the JS heap past 300 MB and crashed the tab.
retainMessages tracks when each per-conversation history loses its last observer and releases it once it has no observers, is not fetching, is not pinned, and is either older than 60 s or beyond the single most recently left conversation. The routed conversation, conversations with a running job, and conversations awaiting an approval decision stay pinned; releases wait while any mutation is pending. Returning to a released conversation refetches its history.
* 🫗 fix: Own History Collection, Configure the Grace, and Pin by Server State
Per-conversation histories get an infinite cacheTime while retention runs, so React Query's own five-minute collection can no longer drop a history a running job still pins; newly seeded histories schedule a pass; the grace and recent count come from interface.historyCacheTtlMs and interface.historyCacheRecent; the approval pin is replaced by the active-jobs set, which already lists jobs paused for a live approval; and Assistants histories stay pinned because deletion reads their thread id from the cache.
* 🫗 fix: Re-arm Collection for Histories Already Counting Down and Recheck Pins Promptly
A history left before retention started still had React Query's five-minute GC timer; a momentary observer now re-arms it under the infinite cacheTime. Histories kept only because they are pinned or fetching are judged again after 5 s instead of a full TTL, so a run that ends releases its transcript promptly.
* 🫗 fix: Exempt Assistants Histories Without Polling and Leave Fetching Histories Alone
Assistants histories are now exempt rather than pinned, so they are kept without a recurring recheck timer. The startup re-arm skips histories with a fetch in flight, since detaching a momentary last observer would cancel the request; settling the fetch re-arms collection on its own.
deleteCodeEnvFile rethrew every error except 404. A deployment that only serves
the stateful profile answers a default-profile delete with 409
execution_profile_mismatch on every retry, so the file landed in failedFileIds,
its record and agent references stayed, and agents holding it aborted every code
turn with "Failed to provision N file(s) to the code environment". The mismatch
is now handled like an absent object: logged, and the delete proceeds. Other
409s, 5xx, auth and network errors still fail the delete.
* feat: Add Lia's Behavior Engine
A framework-free engine that plays Lia's actions step by step, moves her along a platform, and lets her choose her own activities. An attention budget keeps her quiet while the user types and saves bigger routines for when they step away. The catalog holds feelings, speech, gestures, dances, travel, small routines and page reactions.
* fix: Let a Click Wake Lia From a Nap and Run One Animation Loop
* fix: Keep Lia Stopped When Stopped Mid-Frame and Snap Walks Under Reduced Motion
* fix: Wake Lia When Typing Interrupts a Nap and Keep Her Walks on the Current Platform
* test: Drive Lia's Engine on Real Animation Frames in a Browser
* fix: Keep One Animation Loop Across a Mid-Frame Restart and Place Lia Before Her First Move
* fix: Play Every Step of an Action the Host Chains From onAction
* test: Require Lia's Reduced-Motion Chooser to Pick Something
* fix: Keep Lia Free to Act Before the First Keystroke and Skip Pointer Walks Without a Pointer
* fix: Hold Lia's Step While She Has No Layout and Replace Actions Without a Gap
* fix: Keep the Walk of an Action Started When the Previous One Ends
* fix: Wake Lia From a Nap Played Above Reaction Priority
* fix: Pause Lia's Screen and Face Clocks Along With Her Step
* fix: Stop Lia's Own Clock While She Has No Layout and Ignore Empty Obstacles
* 🪜 feat: Light the Fold Path to the Hovered Activity Row
- Every fold that holds the hovered row lights its rail from its header down to that row; the innermost turns into the row with an elbow, so depth reads as the number of lit rails.
- One pointer listener on the outermost fold writes the path onto the rails directly (a data attribute and a length variable), coalesced to one frame: hovering repaints rails, never rows.
- Rows are found by the shared glyph slot every row line starts with, so no row component marks itself.
- The path clears over a rail (which shows its own collapse hover), on touch, on a press and when the pointer leaves.
* fix: Invalidate Fold Hover Paths and Reuse Glyph Lists
* fix: Scope Fold Paths to Agent Lanes and Register Subagent Glyphs
* fix: Re-Hit-Test Queued Fold Paths After Scroll
* fix: Clear Fold Paths After Ancestor Layout Shifts
---------
Co-authored-by: Lia <lia@librechat.ai>
* 🔭 feat: Recover Stale Chunks Without the Error Page and Ship Client Logs to RUM
Stale chunks: a tab left open across a deploy that opens a code-split panel
requests a hashed chunk the new deploy removed. Vite's preload handler hands
the failure to the stale-asset recovery, which reloads, but the import then
resolves to `undefined` and `React.lazy` throws a TypeError into the route
error boundary, so the error page flashes before the reload. Lazy imports now
go through `lazyWithRecovery`/`importWithRecovery`, which turn that result into
a `ChunkLoadError`; the route boundary recognizes chunk failures (and any error
while a recovery reload is underway), asks the page recovery once, and renders
a localized "Updating to the latest version…" status. When the loop guard
declines, the normal error page with its reload action shows instead. The
page recovery is now idempotent within a page, so concurrent callers join the
in-flight reload rather than tripping the guard.
Client logs: with RUM in proxy mode, the client logger's warn/error calls,
error-boundary catches and stale-asset recovery events are exported as OTLP
log records through the authenticated `/api/rum/v1/logs` proxy. Records carry
allowlisted, scrubbed fields only, follow RUM session sampling, dedupe repeats
with a count, are budgeted per minute and per page, batch with backoff, flush
with keepalive on page hide, and stop after persistent failures. The proxy
now refuses non-OTLP content types and applies a per-user rate limit.
`RUM_CLIENT_LOGS=false` turns the export off.
* 🔒 fix: Keep Client Logs Opt-In and Drop Application Error Messages
- RUM_CLIENT_LOGS now defaults to off, like console capture, so enabling
RUM proxy mode never starts a new log stream on its own.
- Error messages are exported only for engine, browser and library
generated types (TypeError, SyntaxError, DOMException, AxiosError,
chunk failures); application errors keep type, status and stack only,
since their messages can echo prompt or response text. All quoted
fragments are now redacted.
- Batches are measured in encoded UTF-8 bytes of the exact request body,
and page hide drains every queued record that fits the keepalive quota.
- Queued stale-asset events are delivered as soon as the log exporter
starts, independent of the RUM SDK loading, and marked so they are
never logged twice.
* 🔒 fix: Export Only Known Generated Error Messages and Ack Queued Events
- Error messages are exported only when the whole text matches a known
engine, browser or library message shape (property access on
undefined, "x is not a function", fetch/abort/axios status, chunk and
CSS preload failures). The error class alone no longer qualifies, since
any code can throw a TypeError carrying arbitrary text.
- Queued stale-asset events are marked logged only after the collector
accepts the record carrying them, so an undelivered event replays on the
next page; in-flight events are skipped by the SDK path.
- A fractional RUM_PROXY_USER_MAX below one falls back to the default
instead of flooring to a limit of zero.
* 🔒 fix: Hold Unacknowledged Asset Events, Re-send In-Flight Logs on Hide
- The RUM SDK flush no longer drops queued stale-asset events whose client
log record is still unacknowledged: they stay queued and persisted,
flagged so their SDK action is not repeated, and leave the queue once
the collector accepts the record.
- Page hide re-sends the records of an unanswered regular request with
keepalive; each record belongs to the latest request carrying it, so a
late response to the original request neither marks nor requeues it.
- Client-log export stops when the authenticated layout unmounts.
- The proxy refuses /v1/logs while client logs, console capture and replay
are all off, so turning RUM_CLIENT_LOGS off also stops tabs that still
hold an older startup config.
* 🔒 fix: Export Only Complete Stack Frames, Never the Message Header
Stack reduction now strips the V8 `name: message` header (including every
line of a multi-line message) and keeps only lines with a complete V8,
Gecko or WebKit frame shape that ends in a URL or absolute path with a
line number. A message ending in a source-position-like suffix can no
longer pass as a frame.
* fix: centralize RUM delivery and asset recovery lifecycle
* fix: preserve RUM page lifetime and collector acknowledgements
* fix: retain page transport quotas and recover functional chunks
* fix: scope RUM client sessions to authenticated identity
---------
Co-authored-by: Lia <lia@librechat.ai>
* fix: Separate workspace admission and transport budgets
* fix: Validate workspace run reserves and retry test types
---------
Co-authored-by: Lia <lia@librechat.ai>
Each mirrored skill now records a sync fingerprint in its sourceMetadata, hashing the mapping version, the upstream identity (source coordinates, skill path and SKILL.md blob id) and the stored definition. When a later run finds the fingerprint still matching and the stored files matching the discovered blobs, it neither downloads SKILL.md nor re-reads and updates the skill; the public viewer grant, name-conflict cleanup, stale-skill reconciliation and status counts run as before. Mirrors without a fingerprint take the full path once and record it.