* fix(langfuse): disable central fanout media uploads
* test(langfuse): cover fanout media policy in run config
* chore(deps): bump agents for Langfuse media policy
* chore(deps): bump agents to 3.3.13
* fix(langfuse): gate central fanout media uploads
* feat: add allowedAddresses exemption to speech (STT/TTS) and OCR config schemas
Add the existing allowedAddressesSchema as an optional field on sttSchema,
ttsSchema, and ocrSchema, reusing the schema already attached to endpoints,
mcpSettings, and actions so port scoping and normalization stay identical.
STT and TTS resolve a single provider by counting non-empty section keys, so
exclude the allowedAddresses key from that scan. Without the exclusion a
configured exemption list would be counted as a second provider and trip the
"Multiple providers are set" guard. The field is inert on its own: nothing
reads it for SSRF yet, and provider detection now ignores it.
* fix: preserve allowedAddresses through the OCR config loaders
loadOCRConfig rebuilt the ocr config with only apiKey, baseURL,
mistralModel, and strategy, dropping allowedAddresses before it reached
req.config.ocr. Pass it through in both the AppService loader
(packages/data-schemas/src/app/ocr.ts) and the duplicate at
packages/api/src/files/ocr.ts so the exemption survives config load.
* 🛡️ fix: Run message-filter PII patterns on a linear-time regex engine
The messageFilter.pii middleware compiled admin-configured customPatterns with the native RegExp engine and ran them synchronously against every message on the shared event loop, so a catastrophic-backtracking pattern such as (a+)+$ could stall the entire process (native RegExp takes tens of seconds at roughly 32 characters) and take the instance down for every user.
Compile these patterns with RE2JS, a linear-time RE2 port with no native addon, so catastrophic backtracking is impossible regardless of the pattern rather than something the code tries to detect. Patterns using features RE2 does not support, such as backreferences, fail to compile and are dropped and logged exactly as an invalid pattern already is. The filter only tests for a match, so this is a drop-in engine swap with no behavior change for valid patterns.
* 🛡️ fix: Reject RE2-incompatible messageFilter patterns at config load
The customPatterns regex was validated with native RegExp at config load, but the runtime now compiles it with a linear-time engine (RE2) that does not support backreferences or lookaround. Such a pattern passed validation, then failed to compile and was silently dropped at request time, quietly removing PII protection after upgrade.
Reject backreferences and lookaround during config validation with an explicit message, and document RE2 syntax in the example config instead of "JavaScript-flavor". The runtime engine remains the authoritative boundary and still drops-and-logs anything this load-time check misses.
* 🧹 test: Use direct MessageFilterPiiConfig annotations in the PII specs
The added ReDoS cases satisfy the exported MessageFilterPiiConfig type directly, so the `as unknown as` assertions were unnecessary. Annotate the config objects directly, matching the repo's type-safety guidance.
* 🧹 fix: Reject named backreferences in messageFilter patterns at config load
Extend the config-load check to also reject named backreferences (\k<name>), which are valid JavaScript regex but unsupported by the linear-time runtime engine, so they surface at load rather than being dropped at request time. Together with the existing numeric-backreference and lookaround checks this covers the RE2-incompatible construct set; the runtime engine remains authoritative.
* 🛡️ fix: Preserve Unicode whitespace matching in messageFilter starter patterns
RE2's \s is ASCII-only, so after the engine swap the built-in api-key and Bearer starters no
longer matched a secret separated by non-ASCII whitespace (e.g. a non-breaking space), which
native RegExp did match. Broaden the whitespace classes to [\s\p{Zs}] so those patterns keep
their original coverage, and add a regression test for a non-breaking-space separator.
* 🛡️ fix: Validate messageFilter patterns with the RE2 engine at config load
Replace the syntax blacklist (numeric/named backreferences, lookaround) with authoritative
validation: config load now compiles each custom pattern with the same linear-time engine the
runtime uses, so any RE2-incompatible construct (including control escapes like \cA) is rejected
at load with a clear error instead of being silently dropped at request time.
The validator is swappable and defaults to native RegExp so browser builds add no engine; the
server wires the RE2-backed check at startup via configureMessageFilterRegexValidator in both
entry points.
* 🛡️ fix: Match the full whitespace set in messageFilter starter patterns
RE2's `\s` omits the vertical tab and `\p{Zs}` omits U+2028, U+2029, and
U+FEFF, so a separator built from one of those characters slipped past the
`api-key` and `Bearer` starter patterns and reached the model. Broaden the
starter whitespace class to the full JavaScript whitespace set so those
separators are covered again.
* fix: fail closed when messageFilter.pii compiles to zero patterns
DB and admin config overrides bypass the RE2 schema validation (it only
runs at YAML load), so an override whose only pattern is RE2-incompatible
was dropped at compile time, left zero patterns, and let the request
through. compile() now returns a failClosed flag when a config declared
patterns but every one failed to compile; the middleware returns 400 and
findPiiMatchInMessages returns a distinct misconfigured match that the
OpenAI and Responses controllers surface with an admin-facing message.
* 🛡️ fix: Fail closed when any messageFilter.pii custom pattern drops
compile() previously set failClosed only when every pattern dropped (patterns.length === 0 && dropped > 0). With the default starters present, a single RE2-incompatible custom override incremented dropped but left patterns.length > 0, so the filter silently enforced only the surviving subset and text matching only the dropped rule passed.
failClosed now keys off dropped > 0, so any dropped custom pattern blocks with the misconfigured 400. YAML patterns are RE2-validated at load, so dropped stays 0 for valid configs and only unvalidated DB or admin overrides can trip it. Reframed the two keeps-others-active specs to assert fail-closed and added a default-starters partial-drop regression.
* 🧹 fix: Correct the misconfigured JSDoc and drop redundant casts in the PII specs
The misconfigured flag now means any configured custom pattern failed to compile, not that every pattern failed, so its JSDoc on PiiMatch is updated to match. The partial-drop regressions now use direct MessageFilterPiiConfig annotations instead of as-unknown-as casts, keeping the specs type-checked, consistent with the rest of the suite.
* ⚡ feat: Coalesce Redis Streaming Delta Publications into Windowed Batches
Every streamed delta currently costs two Redis EVALs (durable append + sequence-allocating publish), and the publish round trip is awaited inside the provider-stream consumption loop. Behind STREAM_DELTA_COALESCE_MS (default off), message/reasoning/run-step deltas now buffer for a small window and flush as one CHUNK_BATCH frame: a single INCRBY reserves consecutive per-event sequences and one EVAL publishes the batch, while a matching batched XADD keeps the durable chunk log on the same cadence so the resume frontier's log-vs-counter timing assumptions hold. Subscribers unpack batch frames at ingress into individually sequenced chunks, so the reorder buffer, duplicate drop, and force-flush behavior are unchanged. Durable, steer-receipt, created, and terminal emissions stay on the awaited per-event path and act as ordering barriers that flush any pending window first; terminal claims flush both sides before the status CAS so a warm tail cannot fence against its own completion.
Benchmarked on local Redis (per-scenario RESETSTAT, INFO cpu/commandstats): at 100-200 ev/s a 25ms window cuts EVAL calls 67-82% and Redis engine CPU 52-70%; at the incident's 40 ev/s it halves EVALs while a 20ms window batches nothing (avg 1.0/frame). Producer await stall drops from ~0.9ms/delta to ~0.05ms/delta, matching the previously measured 16-18% USE_REDIS_STREAMS wall-time overhead. Delivery p95 stays under one window (27-28ms at 25ms).
* 📝 docs: Document STREAM_DELTA_COALESCE_MS in .env.example
* 🚧 fix: Drain Coalesced Windows Before Abort and Shutdown Terminal CAS
abortJob and the graceful-shutdown finalizer claim terminal state through their own CAS calls rather than claimTerminalJob, so the pre-CAS coalescer flush did not cover them: a window tail buffered at abort time flushed against the already-aborted status, fenced (-1), and the false receipts retired the healthy runtime and error-closed subscribers before the abort FINAL frame. Extract the flush into flushCoalescedStreamBuffers and call it from all three terminal paths that can interrupt a live emitter (claim, abort, shutdown); the abort call sits ahead of the content snapshot so a chunk-log reconstruction also observes the flushed tail. Regression test aborts mid-window and asserts the tail is delivered with no subscriber error (fails without the fix). Paused-state terminals (approval expiry, pause-persistence timeout) need no flush: the pause's durable barrier already drained the window and nothing streams while paused.
* 🛡️ fix: Keep Fence Retire a Lost-Signal Backstop on Aborted Runtimes
A cross-replica abort claims its terminal CAS on the aborting replica, so the owner cannot drain its coalesced window pre-CAS; the window flush then fences against the aborted status. When the flush timer lands in the CAS-to-FINAL gap, the false receipts retired the owner runtime and detached its SSE handlers, so the abort FINAL published moments later was dropped and attached clients hung until client-side reconnect. The stop signal reaching the owner (~1ms pub/sub) is proof the abort/replacement flow owns terminal delivery and cleanup, so retireRuntimeAfterDurableFence now returns early for runtimes whose abort signal already landed. The forced teardown remains exactly for its original purpose: a fence observed by a NOT-yet-aborted owner, which is the lost-signal case. Regression test pins the race deterministically via the abort beforePublish hook (which runs between the CAS and the FINAL), forcing the owner flush there: without the guard the FINAL is dropped and the subscriber never completes; with it the FINAL delivers cleanly.
* 🧰 fix: Gate, Isolate, and Bound the Coalesced Delta Path
Three hardening fixes for the coalescing prototype. The manager now enables the fire-and-forget delta path only when the configured services actually batch — presence of flushPendingChunks/flushPendingAppends is the advertisement — so a custom transport that only implements emitChunk keeps the awaited per-event ordering contract even with STREAM_DELTA_COALESCE_MS set, and a batching transport is never paired with a per-event store (which would let the durable log trail the sequence counter by a full window). Batch unpack isolates each event: a throwing subscriber callback now degrades exactly like a lost individual frame (that sequence stalls until the reorder force-flush) instead of discarding the batch tail whose sequences were already reserved. And the emitter tracks outstanding coalesced receipts per stream, awaiting one once 256 accumulate: healthy settlement is a window plus a round trip so the count sits in single digits and the await never runs, while a stalled Redis now paces the producer exactly like the flag-off awaited path instead of accumulating batches, resolver closures, and queued commands without bound.
Unit tests cover the capability gate (hint shape and await behavior for capable, incapable, and window-off configurations) and the backpressure threshold; an integration test pins the unpack isolation (fails without it: the batch tail vanishes instead of recovering via force-flush). Benchmark re-run confirms the counter and gate cost nothing measurable: identical EVAL counts and the serial drain still enqueue-bound.
* 🎛️ fix: Make STREAM_DELTA_COALESCE_MS the Single Coalescing Switch
The per-instance coalesceWindowMs constructor overrides could disagree with the environment the manager reads: overrides without the env silently did nothing, and an enabled env with an override of 0 selected the un-awaited manager path while both services published and appended per-event. Nothing in the repo passed these options, so remove them — the transport, the job store, and the manager now read STREAM_DELTA_COALESCE_MS through one resolver, making a half-enabled process unrepresentable rather than documented against. The capability-presence gate remains for services that do not implement batching at all.
* 🧪 fix: Observe Abort Tail Delivery Before Terminal Teardown in Test
The same-replica abort test waited for the coalesced tail only after abortJob returned, but abortJob's finally-block cleanup tears down local subscription state and publish receipts acknowledge Redis execution, not subscriber delivery. Single-node pub/sub delivers sub-millisecond so the frames always won locally; under the CI Redis Cluster they cross the cluster bus and lost the race, timing out the assertion. Await delivery concurrently with the abort instead — the pre-CAS flush publishes the tail several round trips before the teardown, so observing during the call is deterministic in both topologies. Test-only change.
* fix: improve accessibility with semantic HTML and keyboard support
* fix: preserve focus on attachments and stop CSS leaking into label text
Passing `Wrapper` to FileRow as an inline arrow made it a new component type on
every render, so React remounted the whole file row. A keyboard user who tabbed
to an attachment thumbnail lost focus to <body> the moment the upload settled.
Hoist the wrappers to module scope so their identity is stable.
BlinkAnimation rendered a <style> tag into the DOM; stylesheet text becomes part
of the ancestor's textContent and leaks raw CSS into label readouts. Move the
keyframes into the tailwind config, named logo-blink to avoid colliding with the
existing `blink` keyframes in style.css, and honour prefers-reduced-motion.
* fix: make preset row actions reachable by keyboard
The pin, edit and delete buttons on a preset row were hidden with `invisible`,
which sets visibility: hidden and removes them from the tab order entirely. The
`group-focus-within` variant meant to reveal them never fired, because nothing
inside the row ever receives DOM focus during keyboard navigation. Verified in a
browser: arrowing and tabbing through the presets menu skipped the row and the
buttons reported focusable: false, while hovering made them focusable.
Hide them with opacity instead, which keeps them in the tab order, and reveal on
focus as well as hover. At rest they still compute to opacity 0, so there is no
visual change.
* fix: harden a11y heading, Space activation, and preset hit targets
Gate the page heading on a title that matches the routed conversation so
stale Recoil state is not announced during navigation. Ignore key-repeat
on role=button TooltipAnchor activation while still blocking Space scroll.
Disable pointer events on transparent preset actions until hover or focus.
* fix: address a11y review follow-ups and eslint formatting
Use the shared layout test harness for ChatView heading tests, default
role=button TooltipAnchors into the tab order, ship spinner keyframes in
package CSS, and let native preset buttons handle activation once.
* 🚦 feat: Configurable Circuit Breakers for Runaway Streamed Tool Args
* docs: forewarn create_file about the streamed tool-argument limit
The breaker failing a near-limit write should not be the model's first
exposure to the bound. Both create_file variants now state the default
64 KB per-call limit and the incremental pattern (create the first
section, extend with edit_file) in the tool description and the content
parameter description.
* fix: keep skill create_file description under the provider advisory cap
The limit-guidance paragraph pushed the skill-aware description to 1169
chars, past the 1024-char advisory bound where providers may truncate.
The skill variant now carries the guidance only in its content parameter
description, which sits closest to the generated payload and is not at
truncation risk; the shorter code-sandbox variant keeps the full
paragraph.
* 🚦 feat: per-tool streamed-arg limits with a create_file default
Thirty days of production data show create_file is the only tool class
with legitimate near-limit arguments (p99 80.6 KiB; every other tool
p99 under 10 KiB). Rather than loosening the global 64 KiB cap for all
tools, the yaml gains maxToolCallArgBytesByTool (per-tool overrides,
keyed by model-facing tool name, 0 disables that tool's guard) and
LibreChat ships { create_file: 131072 } by default; yaml entries merge
over and can replace it. Pairs with maxToolCallArgBytesByTool support
in the agents SDK and stays inert until the dependency bump.
* test: pass per-tool spec configs as plain Partial literals
The as-TAgentsEndpoint casts fail TS2352 for object-valued fields:
comparability does not grant nested literals the implicit index
signature that plain assignability does, so casts carrying
maxToolCallArgBytesByTool never sufficiently overlap. The mapper
already accepts Partial<TAgentsEndpoint>, so the new cases pass
uncast literals instead.
* chore(deps): bump @librechat/agents to 3.3.12
* 📉 perf: Bound Early Event Buffering for Detached Generations
A generation streaming with no attached subscriber re-entered buffering
mode on every disconnect and retained each emitted event in
earlyEventBuffer for its remaining duration. A single 26-minute detached
run (~58,800 tool-argument deltas) grew the heap past 2 GiB with GC cost
climbing alongside it, while client reconnects always resume from
durable state and discard that local buffer anyway.
- Close the early buffer after the first attachment drains it in Redis
mode; the durable chunk log and pub/sub own recovery from then on,
matching how cross-replica subscribers already attach.
- Enforce hard bounds (5,000 events / 8 MB estimated) in both modes; on
overflow the buffer is discarded and closed, with recovery falling back
to the durable chunk log (Redis) or resume snapshot (in-memory).
- Add a generation_stream_early_buffer_overflows_total counter and
earlyBufferedEvents/Bytes gauges on getRuntimeStats() for visibility.
- Add incident-shaped regression tests and update specs that pinned the
old post-disconnect re-buffering contract.
* fix: redirect post-overflow first attachments to resume recovery
A buffer discarded by the overflow guard left the initial non-resume
SSE attachment with nothing to replay, silently omitting pre-attach
output until the final event. Track the overflow on the runtime and
close such attachments with the existing reconnect signal instead: the
client already re-attaches with resume=true on transport failure and
its sync frame reconstructs the discarded output from durable/snapshot
state. Adds no per-event work; the check is one boolean per attachment.
* fix: enforce buffer bounds when restoring canceled resume captures
Captured emissions restored by a resume canceled before activation
bypassed the early-buffer hard cap, so one oversized restoration could
persist past the limits with no later emission to trip the guard.
Restoration now applies the same overflow-and-close behavior through a
shared helper, and the restore-cap spec fails before this change
(5 events / ~10MB retained) and passes after.
* chore: add Redis management scripts and update package.json for Redis commands
Skill priming fanned out one unbounded batch upload per cold skill,
bursting through codeapi's per-user upload limiter (30 per 5 min).
Failures degraded silently: nothing persisted, every turn re-burned
budget, and handle_skill reported success with no files mounted.
- Bound batch uploads to 3 process-wide slots across both prime paths
- Single-flight primeSkillFiles per (skill id, version)
- Retry a 429 once per Retry-After, capped at 15s, fresh streams
- handle_skill now tells the model when bundled files are unavailable
- Warn on fulfilled-null primes in primeInvokedSkills
* 🪺 fix: Keep Preempt-Abandoned Siblings Nested, Make Message Tree Order-Robust
* 🔗 fix: Sever Cycle Back-Edges So the Returned Message Tree Is Acyclic
* 🧪 fix: Satisfy TFile in buildTree Spec fileMap Fixture
* 🌲 fix: Assert Repaired Trees in convoStructure Specs, Uncharge Self-Parent Edges
* 📌 feat: Identity-Stable Sibling Selection Across Background Tree Churn
* 🎭 test: E2E Coverage for Thread Fold and Sibling Selection Invariants
* 🔑 fix: Treat Newest-Sibling Re-Key as Hydration, Not a New Branch
* 🧭 fix: Rebind Sibling Selection Per Parent, Detect Appends by Membership
Atomic file claiming (#11675) added a unique partial index on
(filename, conversationId, context, tenantId) for execute_code outputs.
Records written before it inserted a new document per regeneration, so
any deployment that re-ran a cell producing the same filename carries
duplicates the index cannot span: Mongo aborts the build with E11000 and
the constraint is silently absent — the claim path still works, but
without its database-level guard against concurrent inserts.
Adds config/migrate-code-file-duplicates.js to normalize that legacy
data, following the existing migration conventions (dry-run default,
--batch-size, runAsSystem for cross-tenant scans).
Renames rather than deletes: each duplicate is a distinct stored object,
typically still referenced by a message attachment, so removing one
would strip a real artifact from a user's history. The newest record
keeps the canonical name — matching the claim path's latest-write-wins
behavior — and older copies gain a ' (n)' suffix that skips names
already taken in the conversation. Attachments embed their own filename,
so rendered history is unchanged.
After a successful apply the script builds the index directly (targeted
createIndex, not syncIndexes) so the operator learns immediately whether
the constraint is now in place.
* 🔒 fix: Single-Flight MCP OAuth Token Refresh per User/Server
Concurrent refresh-token redemptions (tool-call 401, ping, reconnect
retries, expired-token reads) each replayed the same stored refresh
token at the OAuth token endpoint. RFC 9700 reuse detection treats the
replay as theft and revokes the entire grant family, forcing manual
re-consent every access-token expiry.
MCPTokenStorage.forceRefreshTokens is the choke point every refresh
path converges on; it now single-flights redemptions per
(tenantId, userId, serverName) so concurrent callers share one wire
call and receive the same rotated result. The refresh token is re-read
from storage inside the locked execution — never from a caller
snapshot — so a redemption starting after another refresh completed
uses the rotated token instead of replaying the consumed one.
Fixes#14583
* 🧪 test: Isolate Single-Flight Keys per Test via Unique Server Names
* 🔒 fix: Evict Stalled Refresh Slots, Decouple Waiter Aborts from Shared Redemption
Codex review round 1:
- A redemption that never settles no longer wedges the single-flight
slot until process restart: a stale-entry timer evicts the map entry
so later refreshes start fresh, while existing waiters keep their
promise.
- Caller AbortSignals no longer thread into the shared redemption. An
impatient waiter (silent refresh's short timeout) resolves its own
wait with null via a per-waiter race; the shared wire call proceeds
for everyone else, bounded by transport timeouts plus eviction.
* 🔒 fix: Abort Stalled Refreshes Before Slot Release, Hook Cache Invalidation to Redemption
Codex review round 2:
- The stale timer now aborts the wedged execution instead of deleting
its slot; the slot frees only once the execution has settled, and an
abort guard before the token-endpoint call stops a woken pre-wire
stall from replaying a refresh token a successor already rotated.
- New onRefreshSuccess hook runs inside the shared redemption after
rotated tokens persist, so the silent-refresh path's mcp_get_tokens
cache invalidation fires even when the initiating waiter timed out
before the redemption completed.
* 📝 docs: Record Post-Dispatch Abort Recovery Rationale on Stale-Refresh Valve
Unresolved {{LIBRECHAT_USER_*}} header templates leaked literally to
upstream providers when user context was missing at resolution time
(e.g. async title generation racing client disposal), letting a gateway
trust LibreChat's own template syntax as an account identity.
resolveHeaders now takes an opt-in stripUnresolved flag that blanks any
resolvable-but-unresolved LIBRECHAT_USER/BODY/OPENID placeholder, enabled
at every final resolution boundary (resolveConfigHeaders, model fetches,
Google init, summarization overrides, azureAssistants init). Staged
passes that resolve again later with more context are left untouched, as
is the async-resolved {{LIBRECHAT_GRAPH_ACCESS_TOKEN}} and unknown names.
titleConvo now resolves headers from the req captured at entry instead of
re-reading this.options.req, which disposeClient nulls concurrently.
Fixes#14580
The lazy BookmarkNav's Suspense resolution commits during waitFor's
polling, outside any act scope, so its follow-up render work lands in
React's real scheduler as a macrotask. The single empty async act added
in #14071 only drains microtasks and the act queue, so on slow Windows
shards that work can still be pending when baselines are captured. The
next act flushes pending root work wholesale, so the first stream tick
carries the leftover pass and inflates the tag counter (Expected: 1,
Received: 2). Flush full event-loop turns inside act until two
consecutive turns add no renders, then capture baselines.
* 💬 feat: Interim Progress Card for Streaming ask_user_question Calls
* 🔍 fix: Match Progress Card Against Every Live Ask Pause, Not Newest Only
* ⏳ feat: Hold Streaming Cursor Under Answered Question While Resume Is In Flight
* 📦 chore: Upgrade react-router-dom to v7.18.2 (security)
Fixes GHSA-wrjc-x8rr-h8h6 (open redirect via backslash in Link/useNavigate,
CVE-2025-68470 bypass) and GHSA-337j-9hxr-rhxg (deserializeErrors constructor
injection). Neither has a 6.x patch; v7's react-router-dom is a shim
re-exporting react-router, so all existing imports work unchanged.
- vite manualChunks: match react-router so the routing chunk still captures
the router (v7 moves all code out of the react-router-dom package)
- jest: add test/polyfills.js (TextEncoder/TextDecoder + minimal Request);
v7's CJS bundle constructs TextEncoder at module scope and builds a Request
per navigation, neither exists in jsdom
- auth specs: v7 types drop the synthetic default export; use a namespace
import and mark the mock factory __esModule so the useOutletContext spy
patches the object components actually read
- isSafeRedirect: reject backslashes as defense in depth for the same
open-redirect class the router patch addresses
* 📦 chore: Regenerate stale bun.lock
bun.lock predated months of package.json drift and still pinned
react-router 6.30.3. Regenerated with bun install --lockfile-only so bun
installs match current manifests, including react-router 7.18.2.
* 🗂️ fix: Commit project-chip URL updates synchronously under router v7
v7 wraps router state updates in React.startTransition unconditionally, so
the chip's paired updates tear: the conversation draft (Recoil) commits
synchronously while the ?projectId removal defers. ChatRoute's
draftProjectMismatch re-init sees draft != URL in that window and restores
the removed project. The flushSync navigate option commits both in one pass,
matching v6 ordering. Caught by the projects e2e specs.
* 🧹 chore: Drop unused banner-query spy variable in Registration spec
Pre-existing warning, but the changed-files eslint gate runs with
--max-warnings=0 so it blocks this PR. The spy call stays; only the
never-read variable goes.
* 🔗 fix: Normalize MCP Tool Keys at Every Producer, Resolve Raw Names via Aliases
Tool keys had two spellings that could diverge for any server whose name
contains characters outside [a-zA-Z0-9_.-]: the tool cache (and registry
inspector) built keys with the RAW server name, while runtime instances
are named with normalizeServerName(serverName). Three code comments
already asserted "tool keys embed the normalized server name" - no
producer honored it. For a special-character server that meant:
- definitions-only mode shipped raw def names the model echoed back,
but the executor's tool map held the normalized instance name, so
every call failed with "Tool not found";
- per-tool tool_options (defer_loading / allowed_callers /
run_in_background / describe_intent) were persisted under raw keys
that never matched the definition names the option passes resolve
against, so builder settings were silently inert;
- tool-key parsing against normalized candidate lists silently fell
back to last-delimiter splitting, which mis-parses delimiter-bearing
tool names.
The reconciliation is one contract enforced in three moves:
1. PRODUCERS NORMALIZE. The tool cache (packages/api/src/mcp/tools.ts)
and the registry inspector build keys with the normalized server
name, matching the instance names MCP.js has always assigned. The
builder's tool ids, agent.tools entries, tool_options keys, and
definition names all flow from these keys, so every model-facing
name now agrees. The cache STORE stays keyed by the raw config name.
2. CONFIG LOOKUPS RESOLVE ALIASES. New shared helpers in data-provider
(buildServerNameAliases, normalizeMCPToolKey) map a parsed
normalized name back to the raw config name that the registry,
config maps, tool cache, and plugin-auth rows are keyed by. Applied
in the definitions loader closure, handleTools grouping,
createMCPTool's parsing fallback, getUserMCPAuthMap, and the MCP
tools endpoint - matching both spellings so legacy raw keys keep
resolving.
3. LEGACY DATA HEALS AT ONE BOUNDARY. initializeAgent rewrites
raw-keyed agent.tools entries and tool_options keys to the
normalized form (normalizeAgentToolKeys) before anything consumes
them, so agents persisted under the old convention load their tools
AND have all four per-tool options honored. Placeholder and
server-pin tokens stay raw - they are config-identity references,
not model-facing names.
Servers whose names are already in the safe character set (the common
case) produce byte-identical keys before and after; the fast path
allocates nothing. Stale Redis-cached raw keys self-heal via the
existing reconnect-on-missing path within one cache cycle.
* 🧯 fix: Deterministic Alias Collisions + Raw Names in Definition Metadata
Two review findings on the normalization contract:
- Two configured server names that normalize to the same segment (e.g.
'Sales Force' and 'Sales:Force' -> 'Sales_Force') produce inherently
ambiguous tool keys; the alias map silently resolved last-wins, so a
tool selected from one server could execute against the other's
config. buildServerNameAliases now resolves collisions to the FIRST
configured name deterministically, and resolveMCPServerContext warns
once per colliding pair per process so the operator can rename one
server. A collision-resistant identifier would change every existing
tool key, so detection + stable routing is the right treatment here;
startup-time config validation can follow separately.
- The definitions loader resolved parsed (normalized) server names to
raw only inside the ToolService closure, while the definition
metadata (serverName -> mcpRawServerName) kept the normalized value.
Server instructions are keyed by raw config names, so a
special-character server's instructions were silently omitted in
definitions-only mode. loadToolDefinitions now takes rawServerNames,
resolves the boundary against both spellings, and stores the RAW
name in definition metadata - consistent with the instance path.
* 🧯 fix: Heal Stale Caches, Skill Allowed-Tools, and Builder Selectors
Three review findings on the normalization rollout, all in the
transition class:
- Stale cache entries (P1): the definitions-only loader treats the
per-server tool map as authoritative and never reconnects on a
per-key miss, so a pre-change raw-keyed Redis entry would make a
special-character server's tools vanish for up to the cache TTL.
getMCPServerTools now heals legacy raw-keyed entries to the
normalized format at read time (keys and function names), covering
every consumer with no coordinated invalidation; safe names return
the map untouched.
- Skill allowed-tools: a skill declaring a raw MCP key in
allowed-tools bypassed the initialize-boundary heal (the union runs
after it) and would neither dedupe against healed agent tools nor
match the normalized tool map. The primes' allowedTools now pass
through the same normalizeAgentToolKeys heal before unioning.
- Builder selectors: matchesMcpServer and useVisibleTools parsed tool
ids against raw server names only, so an attached special-character
server rendered as an unselected orphan card. Both now accept the
normalized spelling and resolve it back to the raw map key, keeping
legacy raw ids working.
* 🧯 fix: Fail Closed on Normalized Server-Name Collisions
Escalation of the collision finding: a deterministic first-wins alias
plus a warning still let the tools listing publish BOTH colliding
servers, so a tool selected under the shadowed second server would
silently execute against the first server's configuration (their
model-facing keys are identical, so routing cannot ever distinguish
them).
- findShadowedServerNames identifies later-configured names whose
normalized form an earlier different name claimed.
- getMCPTools excludes shadowed servers from the published listing
entirely (with a warn naming the collision), so their tools are
never selectable - nothing ambiguous can be picked.
- Server creation reserves both spellings: a generated slug may not
collide with a raw config name OR the normalized form its tool keys
would carry.
Collision-resistant model-facing IDs remain out of scope: changing
normalizeServerName's output would rewrite every existing tool key
(agent documents, caches, instance names) for ALL servers to handle a
misconfiguration that is now blocked from exposure instead.
* ✅ fix: Dedupe Reserved Server-Name Spellings at Creation
The reservation list appended normalized forms unconditionally, which
duplicated every safe name (raw === normalized) and broke the
route-level contract test pinning the exact list. Dedupe via a Set so
safe names contribute one entry, while special-character names still
reserve both spellings; adds the special-character reservation case.
* 🧯 fix: Never Heal a Shadowed Server's Keys; Align Authorization Tie-Break
Persisted references were the remaining collision vector: an agent or
skill saved with the shadowed later server's raw key was HEALED into
the shared normalized key, authorized through a last-wins map, and
routed first-wins - authorized as one server, executed as another.
- normalizeAgentToolKeys now refuses to rewrite keys of shadowed
servers (findShadowedServerNames): rewriting would produce exactly
the first server's key. Left raw, the key cannot match the
normalized-keyed tool map and the tool fails visibly - broken beats
misrouted. Covers agent.tools, tool_options, and skill
allowed-tools through the shared heal.
- filterAuthorizedTools (agents/v1.js) builds its normalized-to-raw
map via the shared buildServerNameAliases instead of a last-wins
Map constructor, so authorization resolves a colliding key to the
SAME first server execution routes to.
* 🧯 fix: Direct Identity Wins Over Aliases; Heal Client Forms and Degraded Contexts
Four review findings on the normalization edges:
- Alias hijack (P1): a user-DB server named exactly like an operator
server's normalized form ('foo' vs YAML 'foo!') had its tools
rerouted to the operator server by unconditional alias resolution.
Resolution is now DIRECT-FIRST everywhere: the parsed name is tried
as-is, and only when nothing resolves is it treated as a normalized
spelling (definitions loader, handleTools grouping, createMCPTool
fallback). buildServerNameAliases seats identity entries before
derived ones so a literal name owns its slot regardless of config
order, findShadowedServerNames and the collision warning derive from
the same construction, and getUserMCPAuthMap fetches auth under both
spellings so either owner finds its rows.
- Builder double-match: a normalized name containing the delimiter
('foo mcp bar' -> 'foo_mcp_bar') also suffix-matched a server named
'bar', selecting both cards and making removal strip the wrong tool.
matchesMcpServer now resolves the token ONCE against the full
configured list (longest boundary, both spellings) when the caller
supplies it; selection and removal share the resolution.
- Builder legacy ids: an agent saved with raw-keyed ids showed its
tools unchecked while the runtime heal kept them active, and
selection updates never replaced the legacy entries. McpSection maps
legacy raw ids to their current normalized ids when deriving and
rewriting this server's selection.
- Degraded context: a transient ensureConfigServers failure returned
an entirely empty context, leaving normalized keys unresolvable for
the request. resolveMCPServerContext now keeps the name lists (they
derive from the config snapshot alone) and degrades only the
lazy-init configs.
* 🧯 fix: Collision Detection Sees Accessible Servers; Shadowed Refs Fail Closed End to End
Round follow-ups on the collision design, all in the
DB-server-visibility class:
- The legacy-key heal detected collisions against operator-config
names only, so healing could still produce a key that direct-first
resolution routes to an invisible user-DB server. initializeAgent
gains an optional getAccessibleMcpServerNames dep (wired through
ToolService for controllers that mock it, directly elsewhere),
consulted ONLY when a configured name needs normalization - zero
cost for safe-name deployments. The heal then sees the full
accessible set and skips shadowed servers' keys.
- Wildcard and legacy raw tokens bypassed catalog filtering, letting a
shadowed server's instances join a run under the same normalized
names as the winner's. filterAuthorizedTools rejects tools of
shadowed servers at authorization (its merged map sees DB + config),
and handleTools skips them at execution.
- The builder migrated only tool selection, not tool_options: legacy
raw option keys showed disabled while the runtime honored them, and
toggles could not clear them. McpSection now migrates option keys to
the current normalized ids (existing normalized entries win).
- A transient ensureConfigServers failure degraded to an EMPTY server
context, leaving normalized keys unresolvable for the request.
resolveMCPServerContext keeps the name lists (derived from the
config snapshot alone) and degrades only the lazy-init configs.
* 🧯 fix: Complete the Collision Audit at Every Gate; Safer Heal Semantics
Round follow-ups hardening the collision audit:
- Execution guards now consult the FULL accessible set: the caller's
heal threads its already-fetched names through loadTools, and
handleTools fetches them itself when a configured name needs
normalization (never for safe-name deployments) - so a cross-tier
collision (user-DB 'foo' vs operator 'foo!') fails closed at eager
execution instead of joining the run under one normalized name.
- Healing is SKIPPED when the collision audit cannot complete
(transient lookup failure, or no dep): un-healed raw keys still
resolve through the direct-first candidates, so skipping is safe
while rewriting against an incomplete audit is not.
- The audit lookup is gated on the agent actually carrying
delimiter-bearing keys (tools, tool_options, or skill
allowed-tools), so non-MCP agents never pay a registry round-trip
even on specially named deployments.
- normalizeAgentToolKeys gives the CURRENT (normalized) entry
precedence when both spellings carry options, matching the builder's
migration semantics instead of letting insertion order decide.
- The builder's toCurrentToolId resolves entries boundary-exactly
against every configured server (longest match, both spellings), so
a raw suffix shared with a LONGER server name can no longer reassign
that server's selection or options while another dialog is open.
* 🧯 fix: Shared Collision Audit for Definitions Loading; Fail Closed on Audit Failure
Round follow-ups closing the remaining audit gaps:
- The definitions-only loader now consumes the same collision audit as
eager loading: shadowed servers' entries (wildcards included) are
dropped before definitions are emitted, so the default execution
path can never resolve a shadowed server's normalized function name
to another server. The audit names thread from initializeAgent's
heal; the loader self-fetches only when a configured name needs
normalization.
- resolveCollisionAuditNames centralizes the audit-resolution policy
(threaded set > self-fetch when needed > incomplete on failure), and
BOTH loaders now fail closed under an incomplete audit: any
normalization-sensitive reference (its own name needs normalizing,
or it equals the normalized form of a configured special-character
name) is skipped with a warning instead of being audited against
operator names alone. isNormalizationSensitiveName lives in
packages/api as a pure helper so test mocks use the real predicate.
- normalizeAgentToolKeys collapses duplicate ids after healing
(order-preserving): a document carrying both spellings converges on
one key, never two instances with the same function name.
* 🧯 fix: Thread the Audit Everywhere; Identity-Aware Alias Fallback
Round follow-ups on audit plumbing:
- The OpenAI-compatible and Responses tool loaders now forward the
already-resolved accessibleMcpServerNames instead of discarding it,
so the definitions loader neither repeats the registry lookup nor
fails closed on a transient second lookup after the first succeeded.
- The skill-only path threads its audit: when the baseline agent has
no MCP keys but a primed skill's allowed-tools fetched the complete
set, that set (not the operator-only list) reaches the loader, so
the collision remains visible and the shadowed reference stays
rejected end to end.
- OAuth discovery iterates the collision-FILTERED tool list, so a
request can no longer emit an OAuth prompt, wait out the connection
timeout, and reconnect a server whose definitions were deliberately
rejected.
- The definitions loader's alias fallback is identity-aware: when the
parsed name IS a known accessible server, a null tool fetch means
temporarily unavailable (OAuth pending, missing user variables,
disconnected) and no longer reroutes to the raw alias - previously
the aliased operator server's definitions could be emitted under the
unavailable DB server's names.
* 🧯 fix: Legacy-Key Definition Lookup; Retain Audit for Deferred Execution
- createMCPTool resolves tool definitions by BOTH spellings: the key as
persisted plus the canonical normalized key built from the resolved
server name. Assistants and direct tool calls persisted before the
rollout bypass the agent-boundary heal and arrive with raw keys, while
availableTools is now indexed canonically - previously every such call
missed the index, burned a reconnect, and returned the unavailable
stub permanently via the negative cache.
- The initialized agent retains accessibleMcpServerNames (the COMPLETE
collision audit this initialization resolved), buildAgentToolContext
copies it into every per-agent tool context, and loadToolsForExecution
threads it into the eager loader as bare options. Deferred/event-driven
execution therefore reuses the snapshot instead of repeating the merged
registry read - a transient failure there could fail-closed a tool the
same turn already advertised from the successful first audit.
- MCP.spec.js keeps @librechat/api pure helpers REAL (requireActual
spread) so normalization paths are exercised rather than mirrored.
* 🧯 fix: Parse Legacy Keys Against Both Server-Name Spellings
createMCPTool's boundary candidates were normalized-only, so a legacy
raw key whose server name contains the delimiter (foo_mcp_bar!) missed
the suffix match and fell to the generic last-delimiter split - the
canonical rebuild then produced a key that could never hit the index
and the persisted call stubbed out. The candidate list now carries the
RAW resolved name (and raw config names on the parse-only path) next
to the normalized spellings.
* 🧯 fix: Honest Audit Completeness; Shadowed-Server Form-Key Guard
- resolveAllMcpConfigs tolerates ensureConfigServers failures, so the
merged registry read can silently omit config-only servers while the
audit still reported complete: true - a foo/foo! collision would go
unseen and a persisted key could route to the wrong server. Both
audit consumers now union the snapshot-derived raw config names back
in (resolveCollisionAuditNames unions the caller's rawServerNames;
the initializeAgent heal unions configRawServerNames), keeping the
completeness label honest without an extra read: operator names come
from the registry-independent config snapshot, user-DB names from the
merged read that fails loudly into the existing incomplete path.
- The client tool_options migration now mirrors the runtime heal's
fail-closed rule for SHADOWED servers: when the dialog's server has
lost its normalized slot to another catalog name, legacy raw keys
stay raw instead of being rewritten onto the winning server's key,
where a later save would apply the wrong server's per-tool settings.
The dialog's own server joins the alias construction so a stale
catalog map can't misread as a collision.
* 🧯 fix: Heal Legacy Assistant MCP Tool Names on Save
The assistants create/update controllers look tools up in the cached
definitions by exact key, and the cache is now normalized-keyed - an
assistant saved before the convention resubmits its raw-suffixed MCP
name on every edit, so any save silently removed the tool.
healMcpToolNames pre-heals the payload's tool list: a delimiter-bearing
string that misses the cache resolves through the configured raw names
(longest-suffix, boundary-exact) and rewrites to the normalized key
only when that key actually exists in the cache. SHADOWED raw names
stay raw and fail closed, mirroring the runtime heal; the config read
happens only when a delimiter-bearing name actually misses, and read
failures propagate (write path) rather than silently dropping tools.
v2's update loop also stops re-reading the tool cache per iteration.
* 🧯 fix: Full-Audit Shadow Set + Dedupe in the Assistant Key Heal
- The assistant-save heal built its shadow set from operator config
names alone, so a cross-tier collision (user-DB `foo` owning the
normalized slot of operator `foo!`) looked unshadowed and the legacy
key healed into the shared normalized name - which direct-first
execution then binds to the DB server. The shadow set now comes from
resolveCollisionAuditNames' full accessible audit, and an incomplete
audit skips healing outright (every rewrite candidate is
normalization-sensitive by construction, so raw-and-fail-closed is
the only safe answer).
- Healed string entries dedupe order-preserving: a payload carrying
both spellings of the same tool collapses to one entry instead of
expanding into duplicate function definitions the provider rejects.
* feat: surface interrupt-steer escalation on waiting messages
The interrupt & steer feature shipped reachable only through the
composer chord, the send-button hovercard, and the composer button; a
message already waiting (queued for after the run, or steered and
parked at the next tool boundary) had no path to it. Both waiting
surfaces now carry one:
- Queued rows get an icon-only ZapOff escalation button beside the
existing Steer primary. It routes through sendQueuedNow, which now
takes a preempt option on its live-run path. The tooltip teaches the
composer chord, derived through resolveComposerKeyDown so a rebound
or yielded chord is never advertised.
- In-flight steer bubbles get an "Interrupt now" overflow entry with
the same race rules as Edit: reclaim first, and only a `reclaimed`
outcome resubmits (via retrySteer with preempt, swapping the chip
for an interrupting one). `applied` and run-ended-mid-reclaim
outcomes stop at the existing informational toasts, so the words can
never land twice. Not offered on a steer already preempting.
- Every during-run overflow menu gains an "Always interrupt instead"
toggle for steerInterruptsByDefault, next to the existing steer/queue
default toggle. MenuEntry supports disabled for the new entries.
Only one interrupt can be unresolved at a time: while one preempt is
pending (or the run is paused on approval, where the server 409s),
every escalation control disables instead of racing the same seal.
Ten new tests across both surfaces; 381 green in the affected suites.
* fix: lock escalation across its reclaim window, keep the paused control visible, label as steer
Codex round 1, all three findings.
P2, escalation race. The single-interrupt invariant had a window between
clicking "Interrupt now" and the reclaim resolving, where no preempt
chip existed for the chip-derived gate to see: two bubbles escalated
back-to-back could both resubmit. A shared escalating flag (Jotai,
per-conversation) now covers the window and disables every escalation
control on both surfaces, and a fresh recheck before resubmitting
catches an interrupt armed elsewhere meanwhile (composer chord, queued
row); those words re-home to the queue with an informational toast
instead of breaking the invariant.
P2, unreachable paused state. canSteer is defined as
hasRealConvoId && !pausedOnApproval, so gating the button on canSteer
removed it exactly when it was meant to render disabled; the test only
passed on an impossible stub combination. The render gate is now
duringRunActive && (canSteer || pausedOnApproval), and the test uses the
real invariant.
P2, label semantics. "Interrupt & send now" borrowed the name of the
hard-abort action; this one preserves the partial answer and steers.
Renamed to "Interrupt & steer now" (com_ui_interrupt_steer_now).
Both behavior fixes counterfactually verified; 384 tests green across
the affected suites.
* fix: disable bubble escalation while the run cannot accept a steer
Codex round 2, one P2. Answer mode (ask_user_question) sets
duringRunActive false while pausedOnApproval stays false, since that
flag only detects approval-bearing tool calls. The bubble's escalation
entry stayed enabled there, so clicking it cancelled a healthy waiting
steer and the preempt resubmission bounced off RUN_PAUSED, degrading
the words to the queue. The entry now also disables on
!duringRunActive, matching the queued-row control's gate.
Counterfactually verified: reverting the gate fails the new
answer-mode test.
* fix: recheck live run state after the reclaim, not just at the click
Codex round 3, one P2, and it is the round-1 recheck principle applied
one level deeper: the entry-time disable cannot see a run that pauses
(tool approval, answer mode) while the reclaim round-trip is in flight,
and the .then closure held the render's stale steering controls, so the
resubmit would fire into a RUN_PAUSED rejection after the reclaim had
already surrendered the steer's boundary slot.
The escalation continuation now reads the LIVE controls through a
latest-ref: if the run can no longer accept a steer, the words re-home
to the queue with an informational toast instead of resubmitting, and
the resubmit itself also goes through the live controls.
Counterfactually verified: reading the stale closure instead of the ref
fails the new mid-reclaim pause test.
* refactor: make escalation one atomic server-side arm, in place
Codex round 4: four P2s, every one an interleaving of the same window —
escalation as reclaim-then-repost is a compound, non-atomic operation
whose continuation must revalidate the world (FIFO position lost, ref
assigned too late, no run fence, competing bubble actions). Rounds 1-3
patched that window with a lock and rechecks; round 4 shows the window
itself is the defect, so this removes it instead of guarding it again.
Escalation is now POST /chat/steer/arm: the server flips preempt on the
EXISTING queued item in one atomic store op (new IJobStore.armSteer; a
decode-patch-encode LSET Lua on Redis, an in-place mutation in memory),
fenced to the validated generation and refused once the queue closes.
The handler mirrors the steer POST's preempt contract exactly: durable
flag gated on the owner's recorded capability, volatile requestPreempt
fire-and-forget because the durable flag is the truth resume/handover
re-arm from.
By construction this resolves all four findings: FIFO survives (the
item never moves; the whole queue still drains in instruction order at
the seal), there is no continuation to hold stale controls, the store
op is fenced to the original run, and a competing Edit/Queue/Cancel
either beats the arm (armed:false, chip untouched) or operates on the
armed item, whose cancel already disarms.
The client escalation entry becomes one mutation: armed:true relabels
the chip in place (same steerId, same position), PREEMPT_UNSUPPORTED
and lost races toast honestly, and the round 1-3 machinery — the
escalating lock atom, the latest-ref, the post-reclaim rechecks and
their two toast strings — is deleted rather than extended.
Verified: 7 new handler tests on the real in-memory manager (including
FIFO preservation and the stale-generation fence), 2 Redis integration
tests against real Redis (in-place arm keeps order and every field;
missing/stale/closed all refuse), client suites 396 green.
* fix: decide capability inside the atomic arm, neutralize the lost-race toast
Codex round 5, both findings, both edges of the new arm design rather
than its mechanism.
P2, capability TOCTOU. A HITL resume on a rolling deploy rewrites
preemptCapable for the SAME generation, so the handler's read could go
stale between validation and the flag flip, arming a steer the live
owner cannot seal. armSteer now returns armed | missing | incapable,
with the owner's live capability part of the same atomic predicate as
the generation fence (HGET preemptCapable inside the Lua; the flat job
field, not a metadata blob — the in-memory store reads the same field).
The handler's pre-check is deleted rather than kept alongside; the
store predicate is the single source. New handler test rewrites the
capability after queueing and expects PREEMPT_UNSUPPORTED with the item
left unflagged; the Redis guards test now asserts the incapable refusal
against real Redis.
P2, ambiguous toast. armed:false covers injected, cancelled, re-homed,
and run-over alike, so telling the user the message "already reached
the agent" claimed one specific outcome. The lost-race branch now uses
a neutral message (com_ui_steer_arm_lost_race) and defers to the events
for what actually happened.
* fix: flip the escalation lock synchronously before the arm request
Codex round 6, one P2. Round 4 deleted the escalating flag along with
the reclaim continuation it guarded, but that left the one-interrupt
gate blind during the arm request's own round trip: the chip-derived
check cannot see an arm until its response relabels the chip, so on a
slow connection two bubbles could both arm before either response
landed. Double-arm is harmless server-side now (the run seals once and
drains the whole queue in order), but every escalation control
advertises "one interrupt at a time" by disabling, and the controls
must tell the truth.
The per-conversation escalating flag returns as a pure UX gate: set
synchronously at click, before the mutation, cleared on settlement, and
folded into interruptPending on both surfaces. Unlike its round 1-3
ancestor there is no continuation behind it to guard and no recheck to
pair with it.
Counterfactually verified: without the synchronous set, the two-bubble
race test arms twice. 207 tests green across the Chat Input suites.
* test(e2e): cover escalation of waiting messages through the real seal
Three mock-harness tests on E2E_SLOW_REPLY, a 160-chunk stream with no
tool boundary, so an in-thread steer part can ONLY come from a genuine
mid-stream seal — which makes each test a behavioral proof rather than
a UI check:
- Queued row escalation: the ZapOff button turns a waiting queued
message into a preempt-armed steer (202 echoes preempt: true) that
seals and injects, where the sibling steering.spec test proves the
unescalated path waits for run end instead.
- Bubble in-place arm: an ordinary steer (202 with no preempt echo)
waits as a bubble, POST /chat/steer/arm answers armed: true, the
bubble relabels in place (same single bubble, same text, escalation
no longer offered on reopen), and the armed steer seals mid-stream.
- Always-interrupt toggle: flipped from a waiting row's overflow menu,
plain Enter now produces a preempt: true steer that seals in the SAME
run, and the menu offers the way back. An afterEach clears the
localStorage preference so a mid-test failure cannot leak
preempt-by-default into the rest of the serial suite.
All three verified locally through the full harness (real backend, mock
LLM, seeded DB): 3 passed in 27s.
* feat: dedicated escalation arrow + shortcut, menu split into actions and preferences
The escalation was still half-hidden: the bubble only offered it inside
the overflow menu, and the tooltip taught the composer chord, which does
a different thing (interrupts with typed text, not this chip). Three
changes make it a first-class command:
- A shared EscalateNowButton (circular arrow, ghost-bordered like the
composer's interrupt control) is always visible on BOTH surfaces:
beside each queued row's Steer primary and on every waiting steer
bubble next to its menu. It disappears once a steer is interrupting.
- A dedicated registry shortcut, escalateSteer (Cmd/Ctrl+Shift+.),
editing-allowed and rebindable like every other action. Deliberately
NOT an Enter chord: the composer owns every Enter chord, and the
yield design rests on no default binding using Enter besides submit.
Its handler clicks the newest enabled arrow control (bubbles beat
queued rows), so the shortcut can never diverge from the button, and
the arrow's tooltip teaches THIS command via the registry display.
- The overflow menus separate one-off actions from sticky behavior
changes: Edit, Cancel, Queue, then a smaller "Preferences" section
holding the queueing and always-interrupt toggles, each with the
standard InfoHoverCard reusing the Settings panel's descriptions.
"Interrupt & steer now" leaves the menu entirely.
386 client tests green, including a menu-structure test locking the
order and the absence of the escalation entry; bubble escalation tests
drive the visible arrow. The e2e spec's bubble test now clicks the
arrow, and a fourth test drives the dedicated shortcut end to end
through a real mid-stream seal.
* style: bind the escalation arrow to its message (variant A anatomy)
Two same-weight circles in a row read as one control group, leaving the
arrow's ownership ambiguous, and a floating arrow stops meaning anything
once several messages stack. The shared control now carries variant A's
anatomy: a thin divider binds a small SOLID arrow (filled, inverted) to
the message region on its left, and the menu ellipsis stays a bare
glyph, so the two affordances can no longer blur together — and the
divider+arrow pairing repeats cleanly per chip at N messages.
* chore: drop the unused within import CI lint caught
* fix: advertise the escalation shortcut only while the control is live
Codex on the e2e head, one P2: the tooltip appended the chord hint even
while the button was disabled, advertising a shortcut that does nothing
during an approval pause. The flagged control (InterruptNowButton) was
since replaced by the shared EscalateNowButton, which inherited the
pattern; the successor now omits the chord whenever the control is
disabled, matching the rule the during-run hovercard already follows.
* fix: harden steer escalation lifecycle and recovery
* test(e2e): disambiguate accessible steer preferences
* test: align abort persistence coverage with prerequisites
* chore(i18n): remove obsolete steer race message
* chore: normalize imports across steering changes
* test: exercise stream integration on Redis Cluster
* test: scope HITL checkpoints to generation
* test: fix cluster cleanup and locale policy
* fix: keep escalation visible during ask pauses
* fix: fence recovery downgrade and stale predecessors
* fix: require generation owner abort acknowledgement
* fix: validate delayed preempt arms
* test: align final escalation fixtures
* fix: preserve in-memory predecessor abort handoff
* fix: restore controls for recovered queued messages
* test: cover recovered queue controls
* fix: close final steering review gaps
* 🧹 fix: Clean Up MCP OAuth State Mappings on Uninstall + Reject Superseded Callbacks
Disconnecting an OAuth MCP server deleted its mcp_oauth flows but left the
mcp_oauth_state:{state} mappings behind for the full TTL. Because flow ids
are deterministic (userId:serverName) and the CSRF token is HMAC(flowId), a
stale browser tab's callback could resolve its orphaned state to the NEXT
flow for the same server, pass CSRF, burn the fresh flow's one-shot CSRF
cookie, and fail the PKCE exchange, sabotaging the legitimate retry.
- Add MCPOAuthHandler.deleteFlowAndStateMapping: reads the flow's stored
state and deletes the mapping before the flow (mapping-first so a crash
between deletes fails closed instead of recreating the orphan)
- Route mcp_oauth deletions in clearStoredMCPOAuthState through the helper
for both tenant-scoped and legacy flow ids
- Reject callbacks whose state does not match the resolved flow's stored
state: the only control distinguishing a superseded attempt from the
current one on a deterministic flow id
Fixes#14534
* fix: gate failFlow on state match in the OAuth error branch (Codex P1)
The provider-error branch failed the resolved flow on CSRF/session alone,
so a superseded error callback resolved through an orphaned mapping could
mark the current flow FAILED. Apply the same stored-state equality gate
before failFlow.
* fix: leave the flow in place when the state-mapping delete fails (Codex P2)
deleteFlow swallows storage errors and returns false, and
deleteStateMapping discarded that result, so a failed mapping delete
followed by a successful flow delete would silently recreate the orphan.
Surface the boolean from deleteStateMapping and throw from
deleteFlowAndStateMapping before touching the flow, so the caller's
allSettled warn branch fires and the next replacement retries both.
* fix: restore the state mapping when the flow delete fails (Codex P2)
The inverse partial failure of the round-3 fix: a successful mapping
delete followed by a silently failed flow delete left a PENDING flow
whose reused authorization URL could never resolve, dead-ending every
callback in invalid_state until the flow went stale. Check deleteFlow's
result, re-store the mapping on failure, and throw so the caller's
allSettled warn branch fires.
* fix: never leave a callback-capable flow behind on uninstall (Codex round 6)
Teardown runs after the server's tokens are deleted, so a preserved
flow+mapping pair (the round-3 early-throw path) let a lingering consent
tab complete the callback and recreate credentials post-uninstall. Now
that both callback branches gate on stored-state equality, an orphaned
mapping is the benign failure mode, so invert the order: delete the flow
first, attempt the mapping delete regardless, and reject when either
reports a storage failure. This supersedes the round-4 mapping restore,
which also preserved a callback-capable pair.
* fix: delete the flow even when its metadata read fails (Codex round 7)
A storage error on the initial getFlowState aborted teardown before any
delete ran, preserving the callback-capable flow after token deletion.
Tolerate the read failure, delete the flow blindly, skip the mapping it
could not identify (the callback gates neutralize the possible orphan),
and reject so the caller's warn branch fires.
* 🎯 feat: Per-Tool Intent Label Toggles in the Agent Builder
Saved agents have had per-tool intent control on the backend since the
capability landed (tool_options[name].describe_intent, consumed by
applyIntentLabels), but the builder offered no way to set it - the
capability was invisible to saved agents on MCP tools, which default
off. This is the deferred UI slice.
The MCP tools panel gains a fourth per-tool option toggle (Captions
icon, teal) next to defer / programmatic / background, plus the
matching section-header bulk toggle, gated on the tool_intents
capability. The toggle writes describe_intent: true through the same
withBooleanOption path the sibling flags use, so an opt-in composes
with existing entries and clearing the last flag drops the tool's
entry entirely.
No backend changes: the agent CRUD schema already validates
describe_intent and initialization already consumes it.
* 🧯 fix: Keep the Intent Toggle Truthful for Programmatic-Only Tools
A tool marked Programmatic in the builder gets allowed_callers:
['code_execution'], and the backend's canInjectIntentParam deliberately
skips non-direct tools (no card renders for calls made from code), so
an intent opt-in on such a tool is guaranteed inert. The UI could
nevertheless show both settings active.
The intent toggle now mirrors the runtime gate: isToolProgrammaticOnly
(allowed_callers set and missing 'direct', the exact backend predicate)
renders the per-row toggle inert with a tooltip explaining why, shows
it unpressed regardless of any stored flag, and the bulk toggle and its
all-state consider only tools the label can actually reach. The stored
describe_intent value is preserved, so unmarking Programmatic restores
the user's earlier choice instead of destroying it.
OptionToggle gains a disabled state (dimmed, non-interactive, tooltip
kept) shared by the row and bulk variants.
The ask_user_question pause/answer stamps (server pause-time args stamp,
resume-time answer stamp, and the client mirror) targeted the newest
unanswered ask part by position. When a model emits several ask calls in
one turn, the interrupt's question and the user's answer land on the
wrong card.
@librechat/agents > 3.3.8 surfaces the interrupting call's tool_call_id
on the ask interrupt payload. All three stamps now target that id
exactly when present, keeping the positional fallback for older
payloads. The tool body passes config.toolCall.id through to
askUserQuestion via a typed alias that is a no-op on the pinned SDK and
lights up on the next dependency bump.
Companion to danny-avila/agents#366, which also fixes the underlying
dangling tool_use 400 (INVALID_TOOL_RESULTS) when one of the parallel
ask calls streams malformed args.
Anthropic's Messages API only accepts application/pdf for base64 document
sources, but encodeAndFormatDocuments sent every allowlisted file (docx,
xlsx, csv, html) through the base64 branch unfiltered. The provider 400
recurs on every retry because attachments are re-encoded each request,
permanently breaking the conversation.
- Add isAnthropicDocumentType / isAnthropicTextDocumentType to
data-provider, mirroring isBedrockDocumentType
- Filter unsupported types before encoding (matching Bedrock semantics)
and log the skipped attachments
- Send textual types as plain-text document sources (source.type 'text'),
which Anthropic accepts and supports citations for, instead of invalid
base64 blocks
Fixes#14485
* 🔒 fix: Remove Owner Email from Agent `owner_contact` Fallback
The owner-contact fallback for agents without an explicit support_contact
exposed the owner's private account email to any VIEW-level caller via
GET /agents/:id and GET /agents. The fallback now resolves a display name
only (name/username/authorName): the User query no longer projects email,
the resolver never returns one, and the shared AgentOwnerContact type drops
the field. Emails are only served when the owner opts in via support_contact.
* 🔒 fix: Reject Email-Shaped Owner Display Names in Contact Fallback
OpenID and SAML strategies fall back to the account email for the user's
name and username when no display-name claims exist, so the name-only
owner fallback could still surface the email through those fields. The
resolver now rejects email-shaped display-name candidates entirely.
* 🔒 fix: Treat Any @-Containing Display Name as Email-Derived
RFC-5321 quoted local parts may contain whitespace and the User schema
email validator is an unanchored substring match, so such addresses can
reach the name/username fields via SSO fallbacks. Rejecting on '@'
presence covers every legal email form without re-fetching the account
email.
