* feat: resolve executing agent ids in MCP header templates
* test: preserve MCP config source literal types
* 🪪 feat: Forward the Active Agent Id in Request Header Placeholders
A gateway in front of LibreChat sees the user, the conversation and the
message, but not which agent is running — so it cannot attribute spend per
agent, apply per-agent limits, or tell agent traffic from plain chat. Adds
`{{LIBRECHAT_AGENT_ID}}` as its own namespace beside the user / body / OpenID
ones, resolving wherever the existing request placeholders already work.
The value is the primary agent's, derived once per run, so subagent steps and
auxiliary calls (summarization, titles, activity labels, memory extraction)
forward the id of the turn they belong to rather than their own. Only
persisted agents resolve: ephemeral ids embed user-authored preset text that
is unsafe in a header value, so ephemeral runs and non-agent requests resolve
to an empty value rather than forwarding literal template text.
No behaviour change unless the placeholder is configured. The MCP surface
(#14303) is not covered — its connection classification derives from
`ALLOWED_BODY_FIELDS`, so a new namespace needs a follow-up.
(cherry picked from commit 8a3f1016f0)
* test: cover shared provider and MCP agent header resolution
* docs: clarify absent agent placeholder resolution
* fix: preserve agent header boundaries across transport lifecycles
* fix: retain Google header provenance during agent resolution
---------
Co-authored-by: Jiří Krejčí <51734696+krejcji@users.noreply.github.com>
* perf: Paint the Loading Shell Before the Bundle Arrives
* fix: Name a Lost Connection Instead of Suggesting a Refresh
* fix: Give the Endpoint Key Button a Usable Touch Target
* test: Cover the Loading Shell, Offline Copy and Key Button Target
* fix: Announce the Loading Indicator in the User's Language
* test: Exercise the Key Button on a Plain Endpoint Row and the Localized Label
* test: Measure the Key Button's Layout Size, Not Its Animated Box
* fix: Keep the Key Button's Row Height on Fine Pointers Too
* fix: Ink the Loading Indicator in the Theme's Text Role
* fix: Draw the Loading Indicator With the Shared Spinner
* test: List the Loading Spinner Spec as an index.html Guard
* fix: Resolve the Loading Label's Language the Way the App Does
* test: Cover the Loading Label for an Automatic zh-TW Browser
- perf: Stop Shipping the Node Crypto Polyfill to the Browser
- perf: Keep the Query Devtools Out of the Boot Chunks
- perf: Load Side Panel Tabs When They Open
- perf: Keep the RE2 Engine Out of the Browser Bundle
- perf: Load KaTeX and highlight.js Only for Math and Code
- test: Cover Code That Loads on First Need
- fix: Apply Loaded Math and Highlighting Whatever the Load Trigger Matched
- test: Assert Rendered Formulas Without Assuming Display Math
- fix: Retry a Failed Math and Highlighting Load While Mounted
- fix: Always Load Highlighting Where the Language Is Guessed
- fix: Register the PII Sizer Wherever Config Loads
- fix: Load Preview Math From the Filled-In Prompt and Keep Dollar Signs Literal
- test: Register the PII Sizer Where the Filter Harness Validates Config
- test: Preserve Side Panel Layout During Lazy Loading
- Move the admin lockout guard into the shared AdminSettingsDialog so every feature with a USE permission gets it, including Marketplace
- Show the lockout warning only once the ADMIN USE switch is turned off, instead of permanently
- Gate Save behind an alert dialog that requires typing ADMIN before the change is submitted, with focus starting in the field
- Drop the Prompts-only confirm and the showAdminWarning, onPermissionConfirm, confirmPermissions and extraContent props
- Reword the warning so it does not assume access to librechat.yaml
- Run the jest spec on the real role selector, role menu and translations, mocking only the roles list request
- Cover the guard with mock e2e scenarios: warning before Save, typed confirmation by mouse and keyboard, Cancel and Escape, a rejected save, other roles, and the Prompts dialog
* feat: Redesign the Slack Channels Setup and Management UI
* test: Cover the Channels UI and Keep the Channel Lifecycle Specs on the New Copy
* fix: Keep the Agent Id on a Channel Link Whose Agent Cannot Be Read
* fix: Name Channel States That Need Action and Keep Link Recovery in the App
* test: Follow the Channel Library in the Workspace Agent Setup Spec
The organization workspace setup spec still pressed the removed Add Slack
channel button, timed out, and left its agent behind for the retry. It now
opens the Channel Library, reaches row actions by hover, gives each attempt
a unique agent name, and carries scenario tags so verify runs it.
* style: Polish the Agent Builder, Tools and Skills Panels
* fix: Keep the Catalog Search a Searchbox and Cover the Builder Polish in E2E
* test: Press the Memory Scope Card Instead of Its Hidden Radio
* test: Find the Skills Search by Its New Floating Label
* style: Restyle the Fork Popover and Calm the Feedback Hover
* fix: Follow the Stored Fork Mode and Update the Specs for the New Fork Popover
* test: Find the Fork Options Link by Both of Its Names
* feat: Add Choice Cards, Raised Radio Tone and Section Add Button
* fix: Size the Section Add Button From a Theme Role and Cover the Shared Controls in E2E
* test: Cover the New Shared Controls Under a Reference Theme
* test: List the Shared Controls Theme Spec in the Guard Manifest
* 🎚️ fix: Resolve Parameters for Bare Bedrock Claude Model IDs
A Bedrock model listed by a bare Claude ID, the form used when the model ID
maps to an inference profile, carries no `anthropic.` segment. `getModelKey`
read the provider only from the first two dot-separated segments, so the
settings key became `bedrock-<model>` and matched nothing: the Parameters
panel, the agent builder's model parameters and the composer's reasoning
control all came up empty.
Key a provider-less Bedrock ID that contains `claude` as Anthropic, the same
family test `bedrockInputParser` already applies. Provider-qualified IDs and
bare IDs of other families are keyed as before.
Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
* fix: Preserve Stored Bedrock Agent Request Fields
* test: Validate Bedrock Agent Request Round Trips
---------
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
Co-authored-by: Lia <lia@librechat.ai>
* fix: Submit Tool Approvals Without a Known Generation Epoch
The resume submit hook required the client-side generation epoch, so when
it was unavailable Submit returned before calling the mutation and the
approval card stayed pending with no error. The resume route validates
generationCreatedAt only when present and fences on the authoritative job
and actionId, so the epoch is now sent as an optional extra fence.
* test: Cover Approval Submit When the Status Omits the Generation Epoch
`TooltipAnchor` subscribed to its store's `anchorElement` and `open` to
resolve a physical `left`/`right` side against the anchor's direction.
`anchorElement` changes from null to the element as soon as the anchor
attaches, so every anchor rendered its provider tree a second time right
after mounting, and again on every open, even though the resolved side
only ever differs for a `left`/`right` side under RTL.
The anchor now selects the resolved side itself. Ariakit re-runs the
selector on every store change, so opening still re-resolves after a
language switch flips the direction without a remount, but the anchor
only re-renders when the answer changes. `resolveSide` also returns a
`top`/`bottom` side before reading the computed direction, since those
never mirror and the selector now runs on each store change.
Message rows mount hundreds of these anchors (copy, edit, fork,
regenerate, feedback). On the conversation-navigation benchmark's warm
switch this removes about 1,450 of 10,700 component renders.
The model selector applies its search query after a 200 ms debounce, and
until then the unfiltered menu is still rendered. openModelSearch waited only
for a visible option, which that unfiltered list satisfies, so the pin test
counted and arrowed through it. When the results replaced it mid-loop, the
active row unmounted and the remaining presses often ran out before reaching
a mock-model row. Wait for the results announcement, which only the search
results render, before navigating.
* 🧪 test: Read the Artifact Scrim's Blur From the Persistent Scrim
"a small blur surface still blurs by four pixels" read the backdrop filter
of `#artifact-viewer [role="status"]`.first() once, with a single evaluate.
The artifact panel's lazy tabs also render a `role="status"` loading
placeholder until their chunk arrives, and the panel re-renders while it
opens. A one-shot read that resolves the wrong status, or a node React has
just replaced, gets the computed style of a detached element: an empty
string instead of `blur(4px)`.
Select the always-mounted refresh scrim, the only status that carries
`aria-hidden`, and assert its filter with `toHaveCSS`, which re-resolves and
retries until the value settles.
Untraced, on two CPUs: 11 of 20 runs failed with `Received: ""` before,
20 of 20 pass after.
* ⚡ perf: Mount the Mobile Header Menu Only Once a Phone Layout Has Shown It
The chat header rendered both of its action surfaces on every load: the
desktop buttons and the mobile overflow menu, hidden with `className="hidden"`
on wide screens. The hidden menu still mounted its whole tree on desktop,
with its bookmark, export, share, temporary-chat and pull-request hooks and
its dialog providers.
Mount the overflow menu only while the drawer viewport is active, and keep
it mounted once it has been shown, so resizing back to desktop does not drop
a dialog opened from it.
Measured with a React DevTools hook counting component renders over a cold
desktop load of a saved conversation (7 warm navigations each, production
build): 1,313 component mounts before and 1,242 after, the overflow trigger
no longer in the DOM, and the median component re-renders over the load
5,835 before and 5,682 after.
`dropped-classes.spec.ts` read the overflow trigger's size on a desktop
viewport, where it was only attached; it now reads it at phone width, where
the trigger is visible.
* 🧲 fix: Settle a Pinned Row's Position on Drop, Not Only on Hover
A pinned row reorders in its `hover` callback, which judges the pointer
against the hovered row's midpoint using the offset react-dnd last recorded.
The HTML5 backend delivers hover once per animation frame, so a release that
lands in the same frame as the move across the midpoint is judged against the
offset from before it: the swap is refused and the drop keeps the old order.
A quick, deliberate drag is discarded.
The drop handler now runs the same placement against the final pointer offset
before returning its result, so `end` commits the order the pointer actually
ended on. Hovering is unchanged.
The new regression holds the hover frame and fires dragover/drop at a point
past the midpoint and at one short of it. On the previous handler the first
case keeps the old order; with this change both cases match the pointer.
In a real browser, with a drag that releases without waiting for a hover
frame: "a pinned chat cannot be dragged through a pinned model" kept the old
order in 4 of 15 untraced runs on the previous handler and 0 of 15 with this
one.
* 🧲 test: Release a Pinned Drag Without Waiting for a Hover Frame
The pinned drag helper waited for an animation frame after each settling
move, so react-dnd had delivered a hover at the final position before the
release. That kept the reorder scenario green while a release landing in the
same frame as its last move was discarded by the app.
The drop handler now settles the final pointer position itself, so that wait
no longer stands between the scenario and a failure; it only hides the
fast-release path. Release straight after the settling moves again, so the
scenario covers it.
Untraced, on two CPUs, with this helper: "a pinned chat cannot be dragged
through a pinned model" failed 4 of 15 runs against the previous drop handler
and passed 15 of 15 with the settled drop; the whole pinned-drag-rules file
passed 30 of 30.
* 🧪 test: Publish the Reaper Fixture's PID Only After It Is Written
Two reaper tests wait for a PID file to exist and then read it. The shell
creates the file when it opens the redirection and writes the PID a moment
later, so a read in between gets an empty file. `Number('')` is 0, and
`isGone(0)` reports true because there is no `/proc/0`: "escalates to
SIGKILL when the tree ignores SIGTERM" and "sweep reaps a group that
outlived a clean root exit" then fail their "still running" assertion.
Write the PID to a temporary file and rename it into place, so the file
appears only with its content. With a 0.3 s pause forced between the
redirection and the write, both tests fail on the old fixture and pass on
this one.
Also kill each spawned process group after every test, so a failing test
does not leave its trap-protected `sleep 30` behind, and read the process
state with `ps` where `/proc` does not exist.
* 🔦 test: Keep a Measured Trace and a Startup Profile When Lighthouse Fails
When the serial-latency audit fails a budget, the uploaded `.lighthouse/`
holds the JSON and HTML reports only. They name the slow metric but not the
main-thread work behind it, so a total-blocking-time failure cannot be traced
to the code that blocked without reproducing it locally.
- Run Lighthouse with `--save-assets`, keeping each run's measured
`lhr-*-0.trace.json` for Chrome's Performance panel. Its raw DevTools
network log is deleted; the trace is parsed and every string value has the
session cookie values redacted, so numeric timings and JSON structure
survive even for short cookie values. A trace that does not parse (an
interrupted run) is deleted rather than uploaded raw.
- After a failed audit, navigate once more with the CDP profiler running and
save `.lighthouse/startup.cpuprofile`, including three seconds after the
transcript appears so late catalog callbacks are sampled. This runs after
the measured audits, so it cannot change their numbers, and a profiling
error never replaces the original failure.
Budgets, runs and the workflow are unchanged; the workflow already uploads
`.lighthouse/`.
* 🔦 test: Keep Lighthouse Traces Only When the Audit Fails
Each saved trace is about 45 MB, so keeping all three on every run turned the
always-uploaded `lighthouse` artifact from about 2 MB into about 137 MB for
runs that pass and need no diagnosis. Delete the traces once the test's last
assertion has passed; a failing run still uploads them with its reports.
* 🧪 test: Read the Streaming Shimmer From the Live Footer
"an in-flight label sweeps, and high contrast holds both stops opaque" read
the stream-elapsed label's styles once through `locator.evaluate`. The label
lives in the streaming footer, which re-renders while the reply streams; when
the node the locator resolved was replaced before the evaluate ran, the read
came from a detached element or failed.
Assert the animation name and background clip with `toHaveCSS`, which
re-resolves and retries, and read the shimmer's dip alpha by querying the
current node inside the evaluate, polling until it settles.
Untraced, on two CPUs: 4 of 20 runs failed with `Received: ""` before,
20 of 20 pass after.
* 🧪 test: Click the Drawer's New Chat Link, Not Whichever One Is Exposed
"returns focus after right-clicking an unopened running menu on a small
screen" opens the mobile drawer and clicks
`getByRole('link', { name: 'New chat', exact: true })`. On a saved chat the
header row also offers a New chat link, and it hides only when the sidebar's
expanded state commits. On mobile that commit is deferred: the drawer starts
sliding first and the state flips a few frames later inside a transition,
which a streaming run keeps pushing back. The drawer's Close button is
already visible during the slide, so the test reaches the click while both
links are exposed and fails with a strict mode violation.
Scope the locator to `#mobile-drawer`, the link the test means.
Untraced, on two CPUs: 20 of 20 runs failed on the previous locator and 20
of 20 pass with this one.
---------
Co-authored-by: Dustin Healy <54083382+dustinhealy@users.noreply.github.com>
* 🧪 test: Measure Activity Fold Labels Once the Header Slide Lands
Opening a fold slides its header's new label in over the old one (300 ms).
The clean-phase test read the phase label's box right after opening the
group below it, still inside that slide, then compared it with the box after
a rail hover; the two differ by a fraction of a pixel. A traced attempt is
slow enough that the slide has landed first. Wait for the header's finite
animations to finish before taking the reference box.
* 🧪 test: Find the Mention Endpoint Row in the Mention List Alone
The drill-down test looked up `Mock Provider C` as any option on the page.
The setup picks Mock Provider A from the model menu just before, and that
menu keeps its options in the accessibility tree for about 100-160 ms while
it fades out, Mock Provider C among them, so an untraced attempt that types
the filter in that window hits a strict-mode violation. Look the row up in
the listbox the mention combobox controls.
* 🛋 fix: Preserve Queued URL Submissions Until Composer Release
Since #18060 a URL auto-submit on a new chat waits until the composer has dropped the run of the conversation it just left. That wait returned from `processSubmission` before the settings timer was cleared. When the URL also carried settings (an agent, a model) that had armed the three-second settings timer, the timer kept running after the settings had applied, then marked them failed and consumed `submit=true`. The composer going idle later found the submission already handled, so nothing was sent.
Reaching `processSubmission` means the requested settings are in place, so the settings timer now ends there, and the composer wait follows it the same way the history wait does. The timer also checks its own premise when it fires: settings that have applied by then continue to the submission instead of being reported as failed.
Settings that never apply still time out while the composer is busy, and leaving the route during the wait still cancels the request.
* 🧪 test: Pin Each Half of the URL Settings Wait Against Its Own Failure
The fix holds in two places, and the cases added with it pass with either one alone. Each now has a case that fails without it:
- Clearing the settings timer once the settings are ready: settings that applied and were then replaced during the composer wait get a full wait of their own, and still time out with nothing sent.
- The timer reading the settings again when it fires: a timer that elapses between the commit that applied the settings and that commit's effects sends once, with the composer idle or busy, instead of reporting a failure.
An existing conversation that receives a URL submission during its own run is also pinned to submit immediately, which is the behaviour #18060 kept for it.
The hook documents what the settings timer bounds and why it ends where it does.
---------
Co-authored-by: Lia <lia@librechat.ai>
* ⏱️ test: Let the Composer Palette Finish Closing Before the Tool Timer Freezes the Clock
`tool-timer.spec.ts` closes the composer palette with Escape and then calls
`page.clock.setFixedTime`, which installs Playwright's clock. From that point
every timer the page starts is run by the clock, one callback per task, and
the agent stream that follows queues a zero-delay timeout for each query-cache
notification, so the clock runs seconds behind.
The palette is still closing when the clock is installed. Its popover unmounts
from a 123 ms leave timer that is started two animation frames after Escape.
When the install lands inside those two frames the timer belongs to the clock
and waits behind the notification backlog: the popover stays mounted at zero
opacity over the transcript and takes the click meant for the tool disclosure
for the five seconds the tool runs. The disclosure then leaves with the tool
and the click waits out the test's 120 s timeout.
Wait for the palette dialog to unmount before reading the start time and
freezing the clock.
* 🧲 test: Deliver a Hover Frame Before a Pinned Row Drag Is Released
`dragRowOnto` sends its whole pointer path, release included, in about 25 ms.
react-dnd's HTML5 backend delivers hover to drop targets once per animation
frame, and a target's hover callback reads the pointer offset the previous
hover recorded, so a release is judged against where the pointer was when a
frame last ran. When no frame runs between the pointer crossing the hovered
row's midpoint and the release, the last recorded offset is the one from
entering the row, in its lower half: the swap is refused and the list keeps
its order.
Only the reorder in `a pinned chat cannot be dragged through a pinned model`
depends on that reading. The other drags in the file end in a drop handler
that reads no offset.
Wait for an animation frame after each of the three settling moves, so the
hover carrying the final position has been delivered before the release.
* 👁️ fix: Hold the Seen Check's History Refetch While a Run Streams
The seen check revalidates a conversation's history when the list reports a reply that no fetch has shown yet, and it asked for that refetch whenever the messages query was idle, including under a run the pane is attached to.
A resumed run writes its response into the cache from the stream's sync. A refetch that starts after that sync returns the stored row for the same message, and the cache takes it because both lists are the same length, so the live response is replaced by what was persisted when the run began until the stream's next event rewrites it. A manual compaction resumed after a reload shows it for as long as the summarizer takes: its stored row is an empty summary part with no running marker, so "Summarizing..." disappears and nothing stands in for it.
The refetch now waits while a run is in flight. The check already re-runs when the run ends, which is when revalidating is safe.
* 🧪 test: Wait for the Late Subagent File's Stream Before Reading Its Turn as Over
Stop is withheld between a turn's admission and its stream attaching: no generation epoch exists yet for it to stop. The scenario read Stop's absence right after the POST as the end of the turn, then asserted without waiting that its route had injected the late file into that stream. When the check ran inside that interval the stream had not been requested yet, so the assertion failed on a turn that went on to deliver the file.
It now waits for the reply only the stream carries, then for Stop to go.
* 🚇 fix: Preserve Exact Cyber Endpoint API Contracts
* refactor: Name the Exact Chat Completions Check
Move the exact-URL test into `isExactChatCompletionsURL`, which states the
rule once and tolerates an unparseable URL on its own rather than relying
on the native-host classification having parsed it first.
Keep the summary's custom endpoint lookup inside the native Cyber branch,
where it was, and pass `directEndpoint` to the request shaping from there,
so a gateway summary does not resolve endpoint secrets it never uses.
Collect the request URL in the SDK test and assert it afterwards: an
assertion thrown inside the transport callback reaches the SDK as a
connection error. Cover the default for exact `/responses` URLs, base URLs
and paths that only contain `/chat/completions`, and an OpenRouter exact
URL.
* fix: Keep an Endpoint's Responses API Drop for Cross-Provider Cyber Summaries
A summary that targets another custom endpoint resolves that endpoint
through `getOpenAIConfig`, which applies a `useResponsesApi` drop by
removing the field. The native Cyber shaping that follows read the missing
field as "unset" and defaulted to the Responses API again, unless the
summary ran on the agent's own provider. An Anthropic agent summarizing
with GPT-6 Cyber on an exact Chat Completions endpoint that also drops
`useResponsesApi` therefore still sent a Responses body to that URL.
Record the drop as an explicit `false` on the resolved overrides. An
explicit `useResponsesApi` in the summary's own parameters still wins.
Cover summaries from an Anthropic agent, a built-in OpenAI agent and the
endpoint's own agent, with and without the drop, and with the summary
provider inferred from the agent.
---------
Co-authored-by: Lia <lia@librechat.ai>
Playwright sends route.fetch(), the request fixture and page.request through one
keep-alive agent per worker with no idle timeout, and Node's agent ignores a
server's Keep-Alive hint without one. LibreChat and the fixture servers closed
idle sockets after 6 s, so a request reusing a socket at that moment was reset
(read ECONNRESET) or dropped (socket hang up): the remaining retried passes in
wrapping.spec.ts and thread-fold.spec.ts.
Run LibreChat with HTTP_KEEP_ALIVE_TIMEOUT_MS=0 and pass every fixture server
and the replica proxy through keepIdleConnections(), and check in
fixtures.spec.ts that each harness server answers without an idle deadline.
* 🚪 fix: Refuse Interactive MCP Sign-in on Remote Agent API Runs
A run started through the remote agent API (API key or OIDC bearer) has no
signed-in browser reading its response. When one of the agent's MCP servers
needed OAuth, the run still published LibreChat's sign-in prompt into the
OpenAI-compatible response and waited up to two minutes for a sign-in the
caller could not complete.
The remote auth middleware now marks the response it admits. The prompt
emitters refuse to write to a marked response, and tool loading skips the
turn-start wait when no reader exists. Background Responses keep their
prompts: those go to the generation stream the owner follows in LibreChat.
* 🧭 refactor: Pass the Unattended Fact Explicitly and Release Unattended Callers From Shared Sign-in
Review feedback on the first commit:
- The response registry coupled the auth middleware to MCP through module
state. The remote controllers now supply `unattended` as an argument
(chat completions always; Responses through the runtime's tool context,
foreground only) and it is passed through tool loading to the manager and
the prompt transports. The registry and the middleware side effect are gone.
- A remote run that reached a server while its owner had a sign-in open in a
browser joined that recovery and waited for the person. The manager now
guards an unattended caller at its two entry points: the first sign-in
prompt, from the caller's own flow or from a recovery it waits on, ends that
caller's wait with a typed error and leaves a shared recovery running for
its other waiters. A recovery announces a sign-in request so waiters that
registered no prompt handler are released too.
* 🧪 test: Cover Unattended Sign-in Through the Real MCP SDK
The shared-sign-in tests replaced the production OAuth handler with a
synthetic listener, so they did not exercise the SDK lifecycle whose
cancellation and shared-recovery behaviour the change depends on.
They now run against the real Streamable HTTP test server, the real
connection factory handler and the real flow manager: an unattended tool
call alone, alongside the owner's open sign-in, joining a recovery that
then stops being silent, recovering through a silent refresh, and opening
a connection that needs sign-in. The synthetic-handler versions are removed.
On 2026-11-11 the artifact service answered every request with an HTML
page. In Playwright run 43092661470 eight memory shards failed in
"Upload Playwright HTML report" after retrying for 9 to 10.5 minutes;
in six of them every test had passed.
Uploads that no job downloads (Playwright reports, traces and
screenshots, the Lighthouse report, the advisory quality reports) are
now `continue-on-error` with a three minute step timeout, so a failed
upload stays out of the job result and a stalled one cannot run the job
into its own timeout. The Jest result uploads were already
`continue-on-error` and gain the same bound. Build outputs and mutation
shards that a later job downloads stay fatal.
merge-gate.test.mjs holds the gated workflows to that split, and
workflow.test.mts holds Change Quality to it.
* 🦠 chore: Upgrade Node.js and Undici to Security Releases
* test: Wait for Restored Composer Readiness and Reuse Wrapping Config
---------
Co-authored-by: Lia <lia@librechat.ai>
* 👋 test: Wait for the Header Selector Before Counting Agent Names on the Greeting Landing
The greeting scenario read how many header controls named the agent with a
one-shot `count()` and then expected the same number of mentions inside
`main`. The header selector takes the agent's name after the welcome screen
paints, so when the name landed between those two reads the first said 0 and
the second saw the selector's own label, which sits inside `main`. When both
reads ran before the name landed the check passed without the selector ever
naming the agent.
Wait for the selector to show the name, then expect that label to be the only
mention inside `main`.
* 🗂️ test: Keep the Sidebar Open When Chat History Is Already Showing
On desktop `openChatHistory` clicked the Chat History rail button
unconditionally. The rail button of the panel already showing collapses the
sidebar, and Chat History is the panel every document starts on, so after the
reload in the subagent activity scenario the helper closed the conversation
list it was meant to show. The assertions that follow only passed while the
list was still mounted during the collapse.
Open the sidebar first on both layouts and press the rail button only when
another panel is showing, the guard `openPanel` already uses.
* 🚦 test: Hold the Mock Suite Until the Server Reports Ready
Playwright starts the suite once the base URL answers, which the server does
as soon as it listens. It keeps initializing after that and refuses chat
starts and schedule writes with a 503 until `/readyz` turns 200, so a spec
that runs first against a slow start got `SCHEDULES_NOT_READY`. The
two-replica wrapper already waits on `/readyz` before exposing its proxy; the
single-process server had no such gate.
Poll `/readyz` in global setup before authenticating.
* perf: Start Critical Chat Reads Before Discovery
* test: Use Complete Default Role Permissions in Startup Fixtures
* test: Complete the New Role Query Response Fixture
---------
Co-authored-by: Lia <lia@librechat.ai>
A route handler that calls `route.fetch()` can still be running when its test returns. Closing the browser context disposes the fetched response, the handler throws `Response has been disposed`, and Playwright reports that against a test whose assertions had all passed. With `failOnFlakyTests` on, that fails the shard.
Specs that answer requests through `route.fetch()` now take `test` from `e2e/specs/mock/fixtures.ts`. Its `context` fixture detaches the routes on the context and its pages with `unrouteAll({ behavior: 'ignoreErrors' })` before Playwright closes it; contexts a spec opens itself close through `closeContext`.
`ignoreErrors` rather than `wait`: a wait never ends for a handler parked on a promise the test leaves unsettled, and with two handlers in flight Playwright stops intercepting when the first finishes and continues the other request itself, so the second handler's `route.fulfill()` throws `Route is already handled!`.
* 🧪 test: Keep the Service Worker Out of Scenarios That Hold a Request After Load
The sidebar row scenarios and the streaming dot scenario install a route on a
page that has already loaded, to hold one request open. The PWA service worker
finishes installing and takes control of that page at about the same time, and
a route installed in the few milliseconds around that handover is never
consulted: the request goes straight to the server and Playwright stops seeing
the page's requests at all.
In the sidebar scenarios the archive completed while the test waited on a
promise only the route could resolve, so the test sat until its 60 second
timeout. In the streaming dot scenario the held turn simply finished and the
dot was gone. Both specs now block service workers, as the other specs that
depend on a route already do, and the archive wait fails with a named
expectation instead of running out the clock.
* 🧪 test: Wait for the Prompt Filter to Apply Before Opening Row Menus
The prompts panel applies a filter half a second after typing stops, and does
it by replacing the rows with the filtered request's answer. The scenario
opened a row's menu straight after typing, on a row that was about to unmount,
so when the swap landed between the menu opening and the test reading its
items the menu was gone and the test read an empty list.
Typing the filter now waits for the filtered request to finish, so the rows
the test opens are the ones the filter produced.
* 💭 fix: Settle a Grouped Thought Once the Run Has Moved Past It
A thought folded into a tool group decided it was still streaming by comparing
its index with the tail of the body it renders in. Every settled activity
phase renders in a body of its own and so has a tail too, which left the last
thought of a finished phase reading "Thinking..." with its live peek whenever
that body was on screen while the run went on. At the end of a run a summary
card folds in over the phase with its panel open, so the finished thought
flashed its peek for about a tenth of a second under the completed reply.
The group now applies the rule a lone thought already follows: only the body
that holds the message's cursor has a part still being written.
The scenario that guards this sampled the peek ten times a second and stopped
at the final text, so it saw the flash only when a sample happened to land in
it. The page now counts every appearance itself, through the end of the run.
* 🧪 test: Count Thought Peeks Inside the Conversation Only
The count the page keeps looked for the peek anywhere in the document, where
the samples it replaced looked inside the message view. It now matches them.
* 🧱 ci: Block the PWA Service Worker Across the Mock E2E Profiles
Every mock test opens a fresh browser context, so the app's service worker
installs and claims the page during each test's first load. A `page.route`
installed within a few milliseconds of that claim is never consulted: the
request it should hold goes to the server, and a test waiting on the route
times out. 113 mock spec files install routes and seven blocked the worker
themselves.
Set `serviceWorkers: 'block'` in the mock profile's shared `use`, which every
profile derived from it inherits. No spec asserts worker behavior; one that
does can opt back in with `test.use({ serviceWorkers: 'allow' })`.
* 🧪 test: Keep the Sandpack Preview Worker in the Plain Text Artifact Spec
`serviceWorkers: 'block'` stops every service worker in the browser context,
not only the app's. Sandpack's static template serves an artifact's files from
a service worker inside its preview iframe, so with the profile blocking
workers the preview stays empty and the spec that reads it fails every attempt.
Opt that one spec back in and say in the profile's comment that the setting
reaches third-party workers too.
* 🔑 fix: Replay a Request Rejected for a Superseded Bearer Instead of Refreshing Again
A burst of requests leaves with one bearer. The first 401 starts a refresh and the
rest share it only while it is in flight: a 401 delivered after the refresh settled
found no recovery running and started a second one, although the session had already
recovered and the response described a bearer that was no longer in use.
Compare the bearer the rejected request carried with the current one. When it has
been replaced and no recovery is running, replay the request with the current
bearer. A replay that is rejected again carries the current bearer, so it takes the
ordinary refresh path. The fetch transport follows the same rule.
This is what failed "recovers from an expired bearer during app bootstrap without
redirect looping": 9 of the 21 bootstrap 401s were delivered after the first
recovery finished, so the test counted a third refresh and a second recovery cycle.
* 🔊 test: Play Decodable Audio and Hold the Reply's Button in the Read-Aloud Replay Scenario
The fixture answered the speech request with four bytes the MP3 parser rejects, so
every playback failed. A failed playback cancels its request, and the audio is
cached only once the response has been read to the end, so the replay was served
from memory only when the response finished before the decoder gave up. When the
decoder won, the replay issued the second request the scenario forbids.
The test also located the button by its name. While a message is read aloud its
button is named "Stop", so the locator resolved to the user message's read-aloud
button: the wait for playback to end passed at once, and the second click could
land on a different message.
Serve a third of a second of silent MPEG frames so playback succeeds and ends on
its own, and locate the reply's button by its test id so the wait and the replay
address the same control.
* 📅 test: Wait for the Schedule Save to Land Before Reloading
The edit scenario clicked Save and reloaded the page in the next step. A reload
discards requests still in flight, so when it won the race the PATCH was cancelled
before the server answered and the edited schedule never appeared. Await the PATCH
response, and require it to succeed, before reloading.
* 🔗 fix: Grant a Legacy Shared Link's Permissions Once When Its First Views Race
The share page requests a link's config and its messages together, and each request
migrates a legacy link on the way in. Both find no grant and both write one. The
grant is an upsert matched on the principal and resource, which no unique index
covers, so the two writes inserted two rows: a second public entry, a second owner
entry, or both.
`grantPermission` now accepts the `_id` to give the entry if the grant creates it.
The migration derives that id from the link and the principal, so the second insert
collides on `_id` and is replayed as an update of the first entry. It holds across
processes because the database enforces it. Grants that pass no id are unchanged.
"manages a shared-link snapshot and preserves legacy public links through runtime
migration" asserts one public entry and saw two.
* 🔑 fix: Refresh When a Replayed Fetch Is Rejected With the Current Bearer
The fetch transport replayed a request whose bearer had been superseded and
returned whatever came back. A second 401 there means the current bearer is not
accepted either, which is the case the refresh exists for, and the axios path
already handles it that way. Replay first, then fall through to the ordinary
recovery when the replay is rejected too.
* 🔗 refactor: Derive a Unique Grant's Entry Id in the Data Layer
`AccessControlService.grantPermission` took the entry's `_id` as a Mongoose
`ObjectId`, which put a storage type in an exported `packages/api` signature. The
service now takes `uniqueEntry: true`, and `grantPermission` in data-schemas
derives the id from the principal and resource it already matches on. A caller can
no longer pass an id that names a different grant.
* 🪪 fix: Apply a Builder Agent Selection Before the Agents Catalog Loads
The agent builder's Select button starts a chat with the agent its form holds. `useSelectAgent` first looked that agent up in the agents map and returned silently when it was missing. Since #17692 the map is a deferred catalog, released on browser idle (at most about 2.75 s after first paint on a busy main thread), so a click that landed earlier did nothing and the next message went to whatever model was selected before.
An unloaded map now reads as unknown instead of as a missing agent: the builder already loaded the agent it offers, so only a loaded map can refuse the pick. Selecting also releases the agents catalog, which the header and composer need to name the agent.
This is what made `tool-approvals.spec.ts` and `run-files-lifecycle.spec.ts` pass only on a retry: in every recorded failure the builder click preceded the agents map request and the message was sent to the default model spec.
* 📡 test: Read the Subagent Activity Stream Without Depending on How It Closes
The shared-panel scenario waited for the activity stream's `requestfinished` event and then read the response body. Both need the server to close the stream first. The panel also closes it: it stops listening as soon as the durable thread reports the task terminal, and the server persists that status before it writes the stream's final frame. When a thread poll landed in between, the browser reported the request as aborted, `requestfinished` never fired and the body was no longer readable.
The scenario now counts the stream as ended on either event and reads what the stream delivered from the page's own request, so it asserts the same live updates whichever side closes first.
* 🚏 fix: Send a Queued Message Started in a New Chat After the Source Run Releases the Composer
"Start in a new chat" on a queued message navigates to `/c/new?prompt=…&submit=true` while the source conversation is still generating. The URL auto-submit could fire in the few tens of milliseconds between the composer dropping that run and the next commit: `ask` still saw the composer as submitting and refused, and the auto-submit, which is spent on its first attempt, cleared the URL with nothing sent. The row had already left the queue, so the message was gone from the page.
A new chat has no run of its own, so the auto-submit now waits there until an effect has observed the composer idle, then sends. Existing conversations keep the current behaviour: a prompt arriving during their own run stays in the composer.
"the ClickHouse theme paints its own link, code fill and QR backdrop" and "a theme that names only its link colours Markdown links in both modes and can recolour the QR backdrop" each failed a first attempt in 1 of 70 pull request runs on Nov 11 with "apiResponse.json: Response has been disposed", thrown from the `/api/config` route handler after every assertion had passed.
The app requests `/api/config` three times while it starts, the third about 90ms after the first two. Both tests end within a few milliseconds of that request, so it can still be inside `serveThemes` when the body returns: in one CI trace the handler's fetch starts 1ms before the last assertion and finishes 10ms after the context began closing. Closing the context disposes the fetched response, `response.json()` throws, and Playwright reports the handler's error against the finished test.
Every test in the file now waits for its route handlers to finish before the context is torn down. A handler that throws for any other reason is still reported; only the race against teardown is gone.