* 💬 refactor: ChatForm UI redesign with unified palette Replace the scattered composer controls (badge row, tools dropdown, attach menu, floating steer chips) with one system: a searchable palette with favourites, a composer bar holding active tools plus effort and speech controls, a tray staging files and manual context, and a queue rail that buffers messages while a reply is running. Collapses the 94 development and review-fix commits of PR #14473 into one commit so the branch could be rebased onto dev once; the upstream merge of this pull request is a squash merge either way. The pre-rebase history is kept locally at tag prerebase-backup (afde3e4b9a). * fix: finish the dev rebase of the composer redesign The rebase onto dev left four defects the merge itself produced, plus one review finding the branch had never answered: - ChatForm's `min-w-0` JSX comment lost its closing brace, so the file did not parse at all. - `useSteering` carried both dev's local draft consumer and the host-injected one under the same name; the host's `consumeDraft` owns the storage key autosave actually parked on, so the local copy is gone. - `useUploadOptions` kept dev's `awaitingAgentProvider` gate after the merge replaced the block that derived `isSavedAgent`; the predicate is back, from the same `isEphemeralAgentId` the shared allowance helper uses. - `MessagesView` still reserved a band for the in-flight steer overlay and read `steerOverlayHeightFamily`, which nothing writes now that pending steers render inside the streaming reply. The reservation is gone and `ScrollButton`'s lift is optional; composer panels keep standing the button down through `composerOverlayCountFamily`. - The aggregate MCP chip keyed on `mcp:pinned`, which a server literally named `pinned` also produces (`mcp:${serverName}`), so both entries shared one React key and one packing slot. It uses a key outside that namespace. Also drops the locale keys whose only consumers the redesign deleted, ports dev's extracted-text delivery path into `useAttachExisting` (every attach-existing surface routes through it now), repoints the mock e2e built-in helpers at the palette, and repairs test fixtures the merge left stale (a query mock that blanked agent metadata, a Jotai store mismatch, an ambiguous tray query, an ephemeral-agent fixture standing in for a saved one). * test: cover the composer redesign's acceptance scenarios end to end Twelve mock-harness scenarios, one `@scenario:` tagged test each, over the behaviours this change is accountable for: the single searchable palette (open, search, favourite across a reload, keyboard-only operation), the composer bar and tray (active tool chip, a staged file riding with the message, a per-turn thinking level that applies to the next turn only), the queue rail (Enter buffers during a run and drains after it, keyboard reorder changes the send order, the draft survives run completion), and the composer's portaled surfaces (Stop reaches the run from inside a portal, a pending tool approval in the bar resumes the run). Two contract scenarios are deliberately absent, with reasons: split-pane Stop isolation is not runtime-reachable because `ChatRoute` mounts one pane, and code-approval mode mid-run needs an attached stateful code environment the mock lab does not configure, so dev's `ChatForm.approvalMode` unit spec stays its coverage. * fix: make the composer's acceptance run and the whole client suite green The first verification run of the twelve scenarios passed six and failed six, and the full client jest suite (which CI runs sharded, unlike the diff-scoped local precheck) failed fourteen tests. One of each group was a real defect; the rest were queries and fixtures still aimed at surfaces the redesign replaced. Defects: - `useQueueDrain` held its send lock after a revealed queued turn settled, so the next server-owned row could never be selected. The reveal path now owns its own lock and releases it when the revealed turn clears. - `ChatForm` recomputed the during-run slot without `consumeComposer` in its dependency list, and still carried a landing flag the host prop replaced. Tests and lab: - The five `ChatForm.attachments` focus cases now drive the palette dialog and the tray's quote chips instead of the deleted attach menu and quote popup, with the same strict focus assertions; the harness gains the `main` landmark the palette portals into, and the touch fixture a complete `matchMedia`. - `Palette.spec` no longer closes a hoisted `jest.mock` factory over a later `const`; `useSteering.spec` follows dev's toast wording. - The six failing scenarios were repointed at what this lab actually renders: uploads go through the palette's local-computer row, the reasoning control needs `interface.parameters`, the queued-row contract is the row and its drain rather than a control the submit consumes, the palette's keyboard path uses a built-in the lab grants, the slow-reply wait uses the fixture's chunk marker, and the approval scenario selects its agent through the builder flow the passing approval specs use. * fix: close the eight findings Codex raised on the rebased head Codex reviewed the rebased heads and reported eight issues; all eight were real. Two of them concern code this session added. Behaviour: - A custom or OpenRouter endpoint that declares neither `paramDefinitions` nor a `reasoningFormat` no longer gets a reasoning control inferred from the generic settings list. Capability now has to be declared (a reasoning-key parameter definition, a non-disabled `reasoningFormat`, or a known reasoning provider as the default params endpoint); a `disabled` format always resolves nothing, and every consumer — the composer control, the pre-send validation and the server — asks the same resolver, so a gateway backed by a non-reasoning model can no longer offer a level the turn would fail on. - Restoring a queued attachment keeps its `llmDeliveryPath`, so an extracted document is routed as its text rather than as raw provider content. - The placeholder-to-durable reasoning migration now requires this pane's own live submission, so opening another conversation from a new chat no longer carries the pending level into it. The created/sync case it was written for still carries. - The queue rail treats an acknowledged server-owned row as an ordering boundary: local rows still reorder among themselves, a server-owned row cannot move, and a move that would cross one is refused out loud — the queued-turn API has enqueue, list and cancel only, so a client-side reorder across that boundary could not be made authoritative. - The palette resolves an agent's skill scope with `resolveAgentSkillsScope` instead of treating an empty list as an open catalog, and the attach target resolves `useResponsesApi` with `resolveUseResponsesApi`, matching what the run will actually do. Policy: - The reasoning-override behaviour moved out of the CJS middleware into `packages/api/src/modelSpecs/reasoningOverride.ts`, which returns a discriminated result; the middleware is wiring again, and the behavioural cases moved with it. - `showComposerTips` and `showFilesDialog` are Jotai atoms now, the tips preference keeping its storage key and reaching the composer as a prop. * fix: make the redesigned composer reachable from the mock e2e helpers CI's Playwright shard failed four `file-provisioning` tests on this branch because the shared upload helpers still clicked `#attach-file-menu-button` and `#attach-file-button`, entry points the redesign removed — attaching now goes through the palette, which also owns the file input. Both helpers drive the palette now, `uploadViaLegacyOption` mapping its two destination names onto the palette rows that route to the code environment and the vector store, and the specs that drove the old surfaces directly (`code-upload`, `thread-renderers`, `unified-upload`) follow. Also closes the last client/server disagreement the acceptance run exposed: a custom endpoint that declares a reasoning key in `paramDefinitions` had that declaration merged into the provider defaults and then discarded by model-name inference, so the composer offered a level for `mock-model-a` that the server rejected with "Invalid reasoning override". An explicitly declared key now selects the merged setting before inference, while an undeclared generic custom or OpenRouter target still resolves nothing. The twelfth acceptance scenario is rescoped: a paused approval keeps the composer usable and resumes to completion, but the composer-hosted approval panel and chip are not asserted, because the pending action is keyed by the stream's conversation id while the composer stays bound to the new-chat sentinel — in code byte-identical to dev, and mirroring the write onto the sentinel did not surface the panel. Tracked at berry-13/LibreChat#39. * test: finish the acceptance run and keep the client typecheck green - The thinking scenario read `reasoningOverride` from a `userMessage` wrapper the chat request does not have; the trace shows the request carrying `{ key: 'effort', value: 'max' }` at the root, so the assertion reads it there. Source behaviour was already correct. - The approval scenario timed out on mobile because the Agent Builder drawer stayed open after selecting the agent and swallowed the pointer events meant for the composer; it now closes the sidebar and waits for the drawer to go inert before sending. - Two specs typed a named custom endpoint's label as an `EModelEndpoint`, which CI's client typecheck rejects (the label is exactly what the case is about). All twelve acceptance scenarios now pass in desktop light, desktop dark and mobile emulation. * fix: close the nine findings Codex raised on the verified head Two were defects in code this session added while closing earlier findings: - A reasoning key declared in `paramDefinitions` but absent from the generic settings list was accepted as capability and then never inserted, so the resolver exposed and validated the generic `reasoning_effort` instead. A declared key is now appended to the effective settings and resolved before any fallback, for `effort`, `thinkingLevel` and `thinkingBudget` alike. - The queue's reorder guard validated from the destination row's own index, so `target === index` rejected every pointer drag and only keyboard reordering worked. It validates the dragged row's identity now; the server-owned boundary, its announcement and the disabled grips are unchanged. The rest: - Stop no longer falls through to the document-wide control once a focused pane has been resolved: focus in an idle pane while another generates used to abort the other pane's run. - `PendingSteers` is mounted once in `MessagesView`, above the renderer switch, so a sent or failed steer keeps its in-flight, retry and send-as-new surface with `FLAT_THREAD` off, where the recursive renderer had none and the composer no longer carries a fallback. - The file-list policy moved out of the CJS route into `packages/api/src/files/list.ts`, and its cap is `interface`-level config (`fileListLimit`, default 100) instead of a literal in the route. - The steer-arm confirmation window is `interface.steerArmConfirmationTimeoutMs` with its current 10s as the default, travelling the same path as the other client-consumed timings. - The pause predicates judge the active branch's tail rather than the last assistant in array order, so an inactive sibling branch can no longer enable or disable the inline escalation control. * fix: move persisted reasoning validation into api package * fix: restore composer entry points and defaults * style: normalize reasoning helper formatting * test: open mobile sidebar before account menu * test: use settled sidebar layout for mobile account menu * test: handle empty mobile sidebar in account scenario * test: target account menu in mobile drawer * fix: keep composer surfaces and mobile drawer reachable * fix: let thread approvals receive pointer events * fix: stabilize composer steering and shortcuts * fix: commit queue drags and centralize file modal * fix: return a canceled steer's text to the composer Canceling a pending steer dropped the words the user had written: the bubble disappeared and nothing carried the text back, so a reclaim that the server confirmed still lost the message. Hand the reclaimed text to `pendingComposerTextByConvoId`, which the composer already drains on its first render, and append rather than overwrite when the composer holds a draft the user typed while the cancel request was in flight. * fix: close the six findings Codex raised on the pre-rebase head Pending steers keyed off the Recoil conversation id, which lags the route during warm-cache navigation, so the surface could sit at the destination thread's tail while its Cancel and Escalate acted on the source run. It now keys off the rendered tree, as the mount window already does. Arming a steer removes the control that was activated, dropping keyboard focus on the document body. `useSteerEscalate` already exposes `onArmed` for exactly that; the bubble now passes one that moves focus to the row's Cancel action. Opening the file manager from the account menu left its dialog with no opener: the modal rejects an active element inside a menu, and nothing supplied a fallback, so closing it returned focus to the body. The opener is published alongside the open flag and cleared on close, which keeps the shortcut path's composer-focus behaviour intact. A steer the server rejected was swept into the queue with no marking, and the run-end drain then sent those words as a fresh turn without the user touching Retry or Send as new. Converted failures now carry `needsExplicitSend`, which the drain skips the same way it skips a row the rail is mid-edit on. The queued-turn reconciliation window was a hard-coded 60s, unreachable by an operator behind a slow proxy or a delayed read replica. It ships as `interface.queuedTurnReconciliationTimeoutMs` with that value as default, beside the steer arm timeout it belongs with. Reasoning-override shape validation moved to `parseReasoningOverrideRequest` in packages/api, leaving the middleware to map a rejection onto its own error response. * fix: keep the composer's reasoning level in step with the parameters panel `stableConversation` memoized the conversation without any reasoning field in its key, so editing the level in the Parameters panel produced a new conversation object that every listed dependency ignored. The composer went on showing the old level while the next ordinary send already used the new one. * test: stop the sidebar helper waiting for a drawer desktop never renders `ensureSidebarOnScreen` measured `#mobile-drawer` whenever the sidebar had no Pinned region. Desktop renders no drawer, and `boundingBox()` on a locator that matches nothing waits for it, so every scenario that reached that branch at a desktop viewport timed out instead of continuing. Check for the drawer's absence rather than measuring it. * test: open the mobile drawer from its inert state, not its geometry A closed drawer stays mounted and keeps its layout box, so measuring the Pinned region reported it on screen while every control inside was still untappable. `inert` is the state the component actually sets when it closes, so the helper reads that and clicks the header opener before anything else measures. * fix: return a canceled steer whole, through one recovery boundary A steer that stops being a steer was handed back three different ways, and each one lost something. The immediate cancel wrote `steer.text` into the composer handoff atom, dropping the attachments, quoted excerpts, manual skill picks and reasoning override that `settleReclaimed` then deleted with the pending object. The cancel that won its race against its own POST cleared the pending marker and restored nothing at all, so those words disappeared. A definitively rejected steer could only be resent unchanged, because the row offering to edit it was gone. Give the recovery one boundary. `useSteerRehome` hands the whole steer to the composer through the guarded restore the queue rail already uses, and converts it into an ordinary queued follow-up when the composer refuses: a draft in the box, another chat on screen, a paused question, or a composer that unmounted while the reclaim was in flight. The chip goes either way, since a pending row claiming the server still holds the words is a lie once they live somewhere else. The composer is a sibling of the message list rather than its ancestor, so the thread had no way to reach that restore. The pane's host now holds the reference and both sides read it there, which also means a reclaim resolving after the composer is gone refuses instead of writing into a dead form. Because the restore refuses rather than overwrites, a draft typed while a cancel is in flight is no longer glued to the returned steer; the steer becomes its own queued message and the draft is left as typed. * test: drive the surfaces these scenarios actually reach Four scenarios were failing against surfaces the user never touches. The approval scenario clicked Approve on the thread's copy of the pending card. The composer's review panel floats over the tail of the thread and owns the batch submit, so that copy sits behind it and the click retried until the test timed out. Drive the panel instead; the thread card stays asserted as the record of the request. The palette scenario counted rows the moment the dialog painted, then expected clearing the filter to restore that number. The catalog arrives in waves: the MCP server list is released by the app-wide warmup timer and the skills catalog only starts fetching once the dialog's open effect has run, so the count kept climbing under the test. Wait for the last wave and for the count to hold still, then snapshot. The sidebar helper opened the mobile drawer twice through two signals that disagree. It waited for `inert` to clear, which happens on a state commit several frames ahead of the slide, then fell through to a bounding box still reading off-screen and clicked the opener again, into a machine already opening. One open, through `inert`, then wait for the drawer to settle in the viewport. Splitting the cancel scenario follows the recovery change: an empty composer takes the steer back, and a staged draft keeps the box while the steer becomes a queued message of its own. * fix: hold a server-rejected steer for an explicit send Editing a definitively failed steer falls back to the queue when the composer will not take it. Queued like any other follow-up, the run-end drain would send it the moment the reply finished, which turns the server's refusal into an automatic new turn carrying the payload it refused. Mark that fallback the way the rest of the rejected-steer path is marked, so the row waits for the user to send it. * test: restore two assertions this branch broke while rewriting specs Both specs were updated for the redesigned surfaces and both lost a step they needed, and both fail deterministically in CI as a result. thread-fold pressed Enter mid-run and waited for a queued row, under a comment claiming Enter queues by default. It does not: the default during-run action is steer, so Enter produced a pending steer and the queued row the next line waits for could never appear. Ctrl/Cmd+Enter is what takes the other action, which is the one this test needs. mcp-oauth-readiness asserted on the server card's Cancel button straight after clicking Connect. Connect opens the OAuth dialog over the panel, and it is modal, so while it is open the card underneath is marked aria-hidden and Cancel is not in the accessibility tree at all, which is why the failure reads "element(s) not found" rather than "not visible". The rewrite dropped the dismissal the previous flow performed; restore it as a helper both call sites share. * test: reach the account menu without the pinned section The two account-menu tests borrowed `ensureSidebarOnScreen`, which also settles the Pinned section's placement for the pinned specs. They never touch that region, and on a run where an earlier test left a pinned conversation the section exists but has not been laid out yet, so both tests spent fifteen seconds polling it and failed on the wait rather than on anything they assert. Give them a helper that does only what they need: open the mobile drawer from `inert`, the one signal that distinguishes a closed drawer from an open one while it stays mounted, then wait for the slide to reach the viewport. Desktop renders no drawer and needs nothing. * test: open the drawer by what it shows, not one early read The helper decided once, from a single read of `inert` taken right after navigation. On a fresh mobile load the drawer can still be mounting, so that read reports a state the app has not settled into, the helper returns believing the drawer is open, and the account menu inside it is never shown. Retry against the thing the caller actually needs, the account menu being visible, re-checking before each attempt. While the drawer is open its control is labelled "Close sidebar", so the retry cannot toggle it shut. * fix: keep the composer observing MCP authorization where its tools apply The old badge row mounted its provider with observeToolAuthorization set whenever the composer showed ephemeral tools, so on a plain endpoint the chat kept MCP connection status and discovered tools in the query cache. The redesigned composer mounts the same provider without the prop, so it defaults to off and nothing on the chat side loads that state any more. The Agent Builder's tool library reads that cache. With it empty, every server reads as Unknown with no tools, and clicking one opens its detail dialog offering to connect instead of adding it to the agent. Pass the same gate the badge row used: showTools is the old showEphemeralBadges expression. * test: let the palette close before reopening it, and name what is asserted enableBuiltinTool pressed Escape and returned while the palette was still animating out. A caller that reopened it straight away resumed the same popover, scroll offset included, so the Attach rows at the top sat outside the virtualized window and upload helpers timed out looking for them. Wait for the dialog to be gone before returning. The staged-file assertions matched the bare file name, which the palette now also lists under recent uploads while it closes; scope them to the tray they are about. The OAuth dialog dismissal waited for a title built from the server's display name, but the dialog is titled with the server name. * feat: make the queued-send lock expiry configurable The per-pane lock that stops the run-end drain and an explicit Send now from submitting the same queued message twice gives up a broken claim after a fixed 60 seconds. Until then every drain and every Send now for that pane is refused, and a deployment had no way to tune that window. Expose it as interface.queuedSendLockTimeoutMs beside the queued-turn reconciliation timeout, defaulting to the same 60 seconds so nothing changes unless an operator sets it. The interface loader copies each field explicitly, so the value is added there too; without that line a configured value would never reach the client. * fix: decline interrupt-and-steer while reasoning is staged With a reasoning choice staged, the Interrupt & steer row is disabled, but its keyboard chord still reached interruptSteer, which fell back to interruptAndSend: it aborted the run and threw away the partial answer the action promises to keep. A staged reasoning choice belongs to a new generation that a steer into the live one cannot carry, so decline the chord exactly as the row does, the same way the function already declines while paused on an approval. The words stay in the composer, where Enter queues them as a turn of their own. * fix: wake the queue drain when a late steer retry is queued Retry marks a failed steer sending, and a sending steer is kept out of the run-end sweep so its own POST settles it. When the run finishes while that POST is in flight, the drain spends its one-shot signal on a queue the steer is not in yet; the late ack or NO_ACTIVE_RUN then moves it into the queue, where it sat until the user sent it by hand or another run ended. Every other late conversion re-posts the last completed run end through the composer's rewakeDrain. The retry lives in the thread, so the composer now publishes that function through the same host it already uses to hand a reclaimed steer back to the draft, and the retry calls it after converting. It stays a no-op unless the run completed cleanly and no newer signal is armed, or when no composer is mounted. * fix: honour thinking-budget ranges wider than 200,000 The request-scoped reasoning override capped thinkingBudget at 200,000 in the shared schema. An operator's paramDefinitions may advertise a wider range, and the composer renders it, but every value above the cap was dropped by the control's parse and rejected by the server's before the range-aware check could run. That check already exists: resolveReasoningOverride validates the value against the endpoint's resolved range. Drop the fixed ceiling so the resolved range is the bound, keeping the integer and lower-bound rules. The new case covers both directions on a custom endpoint whose range goes to 500,000. * refactor: persist the preliminary reasoning override through the shared helper The agents controller validated the request's reasoning override with the schema itself before writing the preliminary user message. That is behavior in the CJS layer, and it duplicated resolvePersistedReasoningOverride, which @librechat/api already exports and BaseClient already uses for the same field. Call the helper instead. A preliminary message is always a fresh turn, so it is never an edit or a compaction. The two controller specs that replace @librechat/api with a hand-built mock now take the real helper. * fix: clear the file manager's state at the session boundary The file manager's open flag and its opener live in Jotai's default store, which outlives the authenticated route. A file manager left open at logout reopened for the next account, still holding a ref to the previous session's unmounted opener. Reset both in useClearStates, next to the other composer state this branch already clears there. * fix: decline interrupt-and-steer on the first turn while reasoning is staged * test: read the phone layout from the viewport and keep the drawer open * fix: name both reasons a queued message cannot be edited yet * test: reuse a published file through the composer palette * style: move the composer onto the design-system rules * style: move the file row's new layout styles into classes * fix: keep the composer's reused thumbnails, focus ring and disabled dimming intact * fix: bring a steer back when its deferred cancel does not remove it * fix: treat a run as over only when every pane holding it is idle * refactor: pass enter-to-send into the composer from its host * feat: make the palette's recent-file count configurable * fix: let a file already in the composer be reattached at the limit * test: hide the chip before replaying a deferred cancel * refactor: restore the resume request through one packages/api facade * fix: keep a conversation's staged reasoning across a visit to another model * fix: keep a connected MCP server's variables configurable from the palette * fix: resolve every pane-scoped shortcut through the pane holding focus * refactor: keep every reasoning-override decision out of the /api wiring * perf: skip paging the skill catalog for an agent that can show no skill * test: type the reasoning snapshot the override helper records * test: pin the applied budget and the untouched parameters in the override specs * style: give the stop button the send button's shared submit recipe * fix: name only the newline key when no chord sends * fix: name the stop key only once the stop control can act * fix: clear every staged reasoning selection at sign-out * fix: stop advertising send-now while staged reasoning forces a queue * fix: resolve the reasoning target of an ephemeral agent in the composer and the request * test: type the staged reasoning the sign-out spec seeds * fix: check the composer will take a queued row before discarding its parked copy * style: carry the composer's classes onto Tailwind v4 * style: sort the composer's classes in Tailwind v4 order * fix: return a refused queued row to the durable queue instead of memory * i18n: localize the whole attachment-limit message * refactor: validate the reasoning override inside the packages/api facade * style: give the composer's submit slot its own IconButton variant * test: pin the submit slot to IconButton's submit variant * test: stub the seen-state hook the rebased MessagesView now calls * fix: turn file search on for an embedded file attached through the shared hook * chore: record the composer's design-rule counts against the rebased base * fix: keep the composer's container query inert under Tailwind v4 * test: point the v4 focus scenarios at the redesigned composer's controls * fix: keep a re-queued row on its own lineage after the run ends * test: assert a re-queued row carries its lineage * refactor: pass the dictation preferences into the composer from its host * test: read the usage atom from the store the ask hook renders under * fix: read a pending steer's pause from its own pane's branch * a11y: keep focus on the quote chips until the last one is removed * fix: keep staged reasoning for the next message across a manual compaction * test: expect focus on the remaining quote chip after removing one of two * style: sort the imports the canary rebase merged * refactor: remove the side-panel files table the account menu replaced * fix: settle a retried steer's late ack against a racing cancel A cancel clicked while the retry POST was in flight left the optimistic marker unread: the ack re-minted a live chip and injected words the user had asked back, and a failed retry after that cancel lost them entirely, because the failure path maps chips the optimistic cancel had removed. The ack path now defers to the marker the way the composer's does, the failure path re-adds the chip before settling it, and the queued row a late ack produces binds its recovery identity only under protocol v2, the same default the composer's degradation path trusts. * fix: strip a replayed reasoning override that no longer validates on resume A paused turn's reasoning override is replayed onto its resume request and then validated as if it were fresh client input, so an operator changing the endpoint's reasoning config between pause and approve made the checkpoint permanently unresumable with a 400. The replay now marks the request, and a replayed override that fails validation is stripped so the resume proceeds on defaults; a fresh override that fails is still rejected. * refactor: derive the enforced spec fields inside the modelSpecs facade The set of keys an enforced model spec locks is the input contract of the reasoning-override refusal rule, and deriving it in the route middleware left the policy untestable from packages/api and free to diverge from the facade that owns the rest of the preset application. applyModelSpecPreset now returns the enforced fields beside the private ones it applies, and the middleware consumes them. * fix: restore the pre-override parameters when a resume degrades Stripping a replayed reasoning override that no longer validates removed only the metadata field, while the resume had already replayed the paused turn's model parameters with the override applied into the endpoint option, so the provider still received what validation had refused. The strip now inverts the application from the replayed base: the recorded pre-override value returns and the thinking flag the override forced on comes off. * fix: resolve the effective responses route for upload targets The attach target returned the conversation or agent's saved useResponsesApi flag, so an Azure chat auto-routed to the Responses API by responsesApiRouting preflighted its uploads against the chat completions route and lost provider-document uploads. The resolver now applies resolveEffectiveUseResponsesApi with the endpoint, model, web-search state and routing policy, the same resolution the during-run upload target makes. * fix: name the interrupt chord in the hint only while it still interrupts The during-run hint advertised Alt+Enter Interrupt & send even when the chord had been claimed: a submitMessage rebound to Alt+Enter, a chord yielded to a global shortcut, or shortcuts disabled altogether each make the keydown resolver return something else. The hint now reads the same resolver verdict the during-run send button does and omits the chord it no longer owns. * test: assert the unseen count the scenario adds rather than a zero baseline The tab title counts every unseen conversation, and a shared verification run leaves legitimately-unseen conversations from earlier scenarios behind, so the three title-count scenarios failed on other scenarios' leftovers instead of the behavior they seed. Each now reads its baseline and asserts the count it adds and clears. * test: hold the unseen count to its direction on the mobile project The away poll that lights a dot also discovers conversations the client had not counted yet, so on the mobile project the title count can jump past any baseline taken mid-test. Opening still has to clear this conversation's contribution and an away reply still has to raise the count, which is what the assertions now hold. * test: enable the MCP Apps server through the redesigned palette The MCP Apps integration spec still drove the old composer's MCP Servers menu, which the redesign replaced with toggleable rows in the attach-and-tools palette; the lane failed on the missing menu on every run. The helper now opens the palette, waits for the server wave, and flips the row's pressed state. * fix: preserve numeric reasoning defaults on blur * test: reopen persisted code cards before checking highlights * test: follow the current file manager navigation * fix: offer only reasoning options a request override can carry * fix: keep the favorited copy when skills share a name * fix: restore composer focus by the interaction that closed the palette * test: expect a keyboard close to refocus the composer on every project * chore: re-record the design-rule backlog on the rebased composer * chore: drop the files table and label the rebase brought back * test: tolerate other projects' unseen conversations when marking one unread * test: open the file table header scenario from the account menu * fix: let the stop shortcut reach a hidden stop control from a dialog * fix: keep staged reasoning out of tool-limit recovery and MCP App turns * fix: degrade a queued turn's stale reasoning override instead of dead-lettering it * fix: refresh the attach target when web search changes the route * fix: re-arm the run-end drain after moving a steer to the queue * test: hover the MCP row before reaching its revealed Connect action * test: pick the parts scenario's MCP server from the tools palette * fix: cancel a recovered row's parked steer only after the composer takes it A recovered row's only durable copy is the steer parked on the server, and once its run has ended nothing can re-create it, so a composer that refused the row after the cancel left the words in memory until the next reload. The composer now takes the words first; a cancel that then fails holds the row out of the run-end drain instead of sending it a second time. * fix: name only the idle composer affordances that act * fix: keep steer escalation off until the pane owns the rendered conversation The branch tail that decides whether a run is paused is keyed by the pane's conversation, which can still name the previous chat while a cached one renders. Until the pane catches up, a pause on any cached branch now keeps Escalate disabled instead of reading a missing or foreign tail as unpaused. * fix: route the host's Enter and auto-send preferences into the composer's nested hooks ChatForm takes enterToSend and autoSendText from its host, but useTextarea, DuringRunSendButton and both speech engines still read the store atoms, so a host whose values differ advertised one behavior while the handlers ran another. Pass the host values through instead. * fix: settle a browser dictation take only after its final transcript lands stopListening resolves on the recognizer's end event, after the final result reached useSpeechRecognition's reducer but before React committed it, so the take settled while the composer still held the interim text. Settle from an effect declared after the transcript effect, off a state update queued behind the result. * fix: drop a restored reasoning override the current setting no longer offers The staged override was only checked for a matching parameter key, so a value restored after a capability change on the same target stayed staged, blocked live steering, and was dropped at send time. Validate it against the setting's options and range. * test: scan the attach and tools palette for accessibility The a11y suite still opened the removed tools dropdown. Open the palette instead, and add a scenario that runs Axe over the open palette. * fix: make the palette's virtualized list the grid that owns its rows The rows sat under a wrapper grid behind react-virtualized's scroller, which always renders aria-label and aria-readonly and so could not be made presentational. Axe reported both the disallowed attribute and the grid's invalid child. The scroller is now the labelled grid, with a rowgroup holding the rows. * fix: state the palette grid's row total and each row's position Only the rows in view are mounted, so without aria-rowcount and aria-rowindex assistive technology reads the rendered window as the whole grid. * fix: key an empty destination's pending steers to the route An empty tree has no message naming its conversation, so the pending-steer surface fell back to the chat context, which still names the source chat during warm navigation, and its controls acted on the source run. Fall back to the chat's messages key, which follows the route. * fix: keep assistant uploads available when the file config fails Assistants upload directly and never needed the destination policy, which is why the replaced AttachFileChat rendered their uploader outside the policy gate. Restore that exception so a failed or paused file config request does not remove every attachment entry. |
||
|---|---|---|
| .. | ||
| benchmarks | ||
| benchmarks-mobile-chat | ||
| benchmarks-navigation | ||
| benchmarks-reasoning | ||
| benchmarks-tree | ||
| bombadil | ||
| byom | ||
| config | ||
| fixtures | ||
| lighthouse | ||
| mcp-apps | ||
| perf | ||
| recordings | ||
| screenshots | ||
| setup | ||
| specs | ||
| client-build.test.mjs | ||
| config.local.example.ts | ||
| jestSetup.js | ||
| playwright.config.a11y.ts | ||
| playwright.config.benchmark.ts | ||
| playwright.config.bombadil.ts | ||
| playwright.config.deployed.ts | ||
| playwright.config.email.ts | ||
| playwright.config.lighthouse.ts | ||
| playwright.config.local.ts | ||
| playwright.config.mcp-apps.ts | ||
| playwright.config.mermaid.ts | ||
| playwright.config.mobile-chat-perf.ts | ||
| playwright.config.mock.ts | ||
| playwright.config.navigation-perf.ts | ||
| playwright.config.real.ts | ||
| playwright.config.reasoning-perf.ts | ||
| playwright.config.redis.ts | ||
| playwright.config.tree-parity.ts | ||
| playwright.config.tree-perf-prod.ts | ||
| playwright.config.tree-perf.ts | ||
| playwright.config.ts | ||
| README.md | ||
| types.ts | ||
LibreChat e2e
The mock e2e profile is the safest default for generated tests. It starts LibreChat with e2e/config/librechat.e2e.yaml, injects an in-process fake LLM (via LIBRECHAT_TEST_RUN_HOOK), creates an authenticated e2e user, and avoids real provider credentials.
Deployed-instance smoke test
The deployed profile exercises an existing LibreChat deployment without starting another app or database. It uses the deployment's configured model provider and persists a real conversation, so run it only with a dedicated test account in an environment where that traffic is expected.
First, create Playwright storage state by signing in through the deployment's normal login flow:
npx playwright codegen \
--save-storage=e2e/storageState.json \
https://librechat.example.com/c/new
Close codegen after sign-in, then run the smoke test:
E2E_BASE_URL=https://librechat.example.com \
npm run e2e:deployed
The storage-state file contains session credentials. The default path is ignored by Git; do not commit it or include it in test artifacts.
Set E2E_STORAGE_STATE when the auth file is mounted elsewhere. If the account has no default
model, set E2E_DEPLOYED_MODEL to the exact configured model label. E2E_DEPLOYED_PROMPT can
replace the short default prompt, and E2E_IGNORE_HTTPS_ERRORS=true supports deployments using a
self-signed certificate.
The profile deliberately has no global setup, database access, or web server. It verifies the authenticated shell, sends one real prompt, reloads the resulting conversation, and deletes only the conversation created by that run through LibreChat's authenticated API. Keep deterministic provider behavior and destructive database fixtures in the mock profile instead.
Email Delivery
The registered-email flow has a dedicated profile because enabling SMTP changes registration into a verification-required workflow. It starts a disposable local SMTP mailbox, verifies the setup account from the delivered message, and then tests the Settings → Account email change, verification link, notifications to both addresses, and login with the new address:
npm run e2e:email-change
The disabled-mode profile verifies that ALLOW_EMAIL_CHANGE=false hides the Account control,
rejects both request and confirmation endpoints, and sends no email:
npm run e2e:email-change:disabled
Override E2E_SMTP_PORT or E2E_MAILBOX_PORT if ports 1025 or 8025 are already in use. The mailbox binds only to 127.0.0.1 and is discarded with the test process.
Stream Stores and Shards
The mock profile uses the in-memory generation stream store by default. To exercise the same browser scenarios through a real Redis job store and pub/sub transport, start Redis on port 6379 and run:
npm run e2e:mock:redis
Memory mode explicitly disables Redis. Redis mode defaults to database 15 with a LibreChatE2E key prefix, and fails closed: the test server pings Redis and verifies that the generation job manager did not silently fall back to memory. Override REDIS_URI or E2E_REDIS_KEY_PREFIX when needed.
Pull request CI runs the complete mock suite in memory mode across three shards, plus a focused Redis transport suite. The Redis suite covers streaming fidelity, steering, interrupts, resumptions, HITL approvals, completion, thread folding, model icons, and usage:
npx playwright test --config=e2e/playwright.config.mock.ts --shard=1/3
npm run e2e:mock:redis:transport
The nightly schedule and manual workflow dispatch run the complete mock suite in both stream modes across two shards per mode. Every shard keeps one worker so tests do not contend for its authenticated user and database.
Property-based browser testing
Bombadil explores randomized sequences across the core chat loop, message branches, parallel multi-conversation responses, model changes, reloads, and sidebar conversation lifecycle operations:
npm run e2e:bombadil
Set BOMBADIL_TIME_LIMIT for longer local or scheduled runs. Failures leave a
reproducible trace under e2e/.generated/bombadil-output; rerun it with:
BOMBADIL_REPRODUCE=e2e/.generated/bombadil-output npm run e2e:bombadil:run
Reproducing a real violation is expected to fail the Playwright test. Before a
new run overwrites the active output, the harness archives it under
e2e/.generated/bombadil-history/. Reproduction can diverge when streaming
timing changes; Bombadil reports that explicitly.
The harness uses the credential-free mock-LLM profile, so exploration never sends billable provider requests.
CI runs the broad property exploration for five minutes in the non-blocking
Bombadil Property Exploration workflow. If a property fails, download the
bombadil-reproduction-* artifact into
e2e/.generated/bombadil-output/, then reproduce it locally:
BOMBADIL_REPRODUCE=e2e/.generated/bombadil-output npm run e2e:bombadil:run
The accompanying bombadil-diagnostics-* artifact contains the captured CI log,
Playwright HTML report, and Playwright test results. A Bombadil failure produces
a workflow warning but does not block merge.
The default instruments inline JavaScript only because instrumenting LibreChat's
full Vite bundle can exceed Bombadil's driver timeout during stateful runs. Set
BOMBADIL_INSTRUMENT_JAVASCRIPT=files,inline for shorter coverage-guided
experiments.
The branch reload, fork submission, model/conversation, HITL pause/resume, and mid-run steering lifecycle properties can be run independently:
npm run e2e:bombadil:branch-reload
npm run e2e:bombadil:fork-lifecycle
npm run e2e:bombadil:model-lifecycle
npm run e2e:bombadil:hitl
npm run e2e:bombadil:steering
These focused commands are diagnostic properties: they exit nonzero when they
reproduce a product invariant violation. Reproduce a focused trace with its
matching :run script and output directory, for example:
BOMBADIL_REPRODUCE=e2e/.generated/bombadil-output-hitl npm run e2e:bombadil:hitl:run
HITL drives a real ask_user_question checkpoint through the answer/resume
controller, reloads while the question is paused, answers it once, and reloads
the completed conversation. Steering submits an in-flight steer during a slow
MCP-backed run, checks that it moves exactly once from the composer anchor into
the response at the tool boundary, and reloads the applied state. The model
lifecycle property is the passing control. The branch reload and fork
properties preserve their minimal failing traces.
Recording Tests
Use Playwright codegen when you want to turn an exploratory browser session into a draft test:
npm run e2e:record
That command builds the app, starts the LibreChat test server (with an in-process fake LLM) when needed, writes e2e/storageState.json, and opens Playwright codegen at /c/new. The npm script uses http://localhost:3333 so it does not collide with a normal dev server on 3080. Raw recordings are written to e2e/recordings/ and ignored by git.
For a real local LibreChat config instead of the mock profile:
npm run e2e:record:local
Useful direct options:
node e2e/setup/record.js --url=http://localhost:3080/c/new
node e2e/setup/record.js --profile=local --no-output
node e2e/setup/record.js --auth-only
node e2e/setup/record.js --output=e2e/recordings/settings-draft.spec.ts
LLM-Assisted Loop
- Start
npm run e2e:record. - Let the LLM use Computer Use to operate the headed Playwright browser.
- Stop codegen after the workflow is captured.
- Move the useful parts from
e2e/recordings/into a committed spec undere2e/specs/mock/. - Replace brittle generated selectors with role, label, text, or
data-testidlocators. - Add assertions that prove the behavior, not just the clicked path.
- Run the finished spec with
npm run e2e:mock -- <spec name>.
Generated recordings are a draft, not the final test. The committed version should use the shared helpers in e2e/specs/mock/helpers.ts where possible, wait on network or visible UI state instead of fixed sleeps, and keep test data deterministic.
PR screenshot pilot
e2e/screenshots/playwright.config.ts is an opt-in evidence capture lane, not a pixel-baseline suite. It runs the real app with the mock profile and a private ephemeral MongoDB, then captures welcome screens at desktop/mobile sizes in both themes. Desktop captures also include temporary chat and the settings dialog. No model request is made. Motion is reduced, so these stills do not prove transitions or streaming behavior.
Build and run each revision in its own clean worktree with its own locked install:
npm ci
npm run frontend
npx playwright install chromium
E2E_CAPTURE_SHA=$(git rev-parse HEAD) \
E2E_CAPTURE_DIR="$PWD/e2e/.generated/evidence-before" \
E2E_USE_MEMORY_MONGO=true \
E2E_BASE_URL=http://127.0.0.1:3333 \
npx playwright test --config=e2e/screenshots/playwright.config.ts
For a historical revision without this lane, copy the two e2e/screenshots/*.ts files into its worktree, leaving its application code and lockfile unchanged. Run the same scenario source on both revisions. Use a new output directory for every attempt: existing images are never overwritten. Run revisions sequentially, or give every fixture service its own port using the mock profile's E2E_*_PORT settings. Do not reuse a running development server or a real user's database.
Each PNG has a JSON sidecar containing the revision, browser version, viewport, theme, scenario hash, lockfile hash, built HTML hash, and image hash. Visible images must decode, fonts must finish loading, greeting springs must settle, and consecutive captures must match. A passing run and human inspection are both required before treating the pair as reviewed evidence; sidecars from a failed run are not complete evidence. Compare matching filenames between revisions. Pin the browser and font environment as well as the app revisions.
Keep storage state, traces, logs, and session data private. Check that the PNGs contain only intended synthetic test data before uploading with the attachment-capable gh described in the PR template, then read back the PR body to verify real asset URLs. Mark any pending visual review explicitly. Do not commit the images. A new surface has no before state; label it accordingly rather than substituting another screen.