LibreChat/client
Danny Avila f0dfeed2b0
🐝 fix: Keep Polling for Owed Agent Successors (#15537)
* 🎯 fix: Ask Because a Successor Is Owed, Not Because One Might Be

The handover window guessed at how long admission takes. For a queued turn it
never had to: the backend reports the turn as `queued` or `claimed`, which is
positive evidence that a run is coming and that this client will not be the one
to start it. Declare that outright and keep the active-job list live for
exactly as long as it holds.

Read from the server's receipts rather than the chip projection, so admission
semantics stay in one place — `shouldPollAgentQueuedTurns`, shared with the
queue itself — instead of being restated here and drifting. `useSteering` owns
that fetch; subscribing with `enabled: false` observes its cache without
competing for it, and an unpopulated cache falls back to the window. It also
keeps this off Recoil, which the client is migrating away from.

The window stays for successors nothing local predicts — a background-tool
continuation has no receipt to report itself — and is now documented as the
fallback rather than the mechanism.

* 🔗 fix: Carry the Owed Successor Across the Receipt Handover

Codex found the gap in the deterministic path: the receipt that announces a
queued turn reports `admitted` for one fetch at most and is then dropped from
the projection — before the active-job list has necessarily observed the run
it started. If admission outlasted the handover window, the wall-clock
fallback was already spent, and a pane keyed on the receipt alone stopped
listening in exactly the window that mattered.

Two structural changes, so this is not another edge patched.

Owed is held, not read. Once a successor is known to be owed it stays owed
until it is delivered — this pane attaches, or the list names the conversation.
A bounded expiry backstops the case where neither ever happens, and it starts
only once the receipt has gone quiet, so a long wait behind an unadmitted turn
does not burn the window before the handover begins. `admitted` now counts as
owed: the receipt poll stops there because nothing is left to wait for, but an
unattached pane is in the opposite position, and it is the strongest evidence
that pane will get.

The receipt arms on its own. The arm had one announcement source, the list,
which can miss a run that starts and finishes between two polls. An owed turn
is a second source, and the status read the arm enables is the authoritative
answer either way: active attaches, inactive means the history refetch the arm
already performs is the repair. Neither source has to wait on the other.

* 🧹 chore: Sort Imports in useResumeOnLoad

* 🧭 fix: Deliver an Owed Successor Only When the Successor Itself Is Seen

Codex: the latch treated the pane's own live attachment as delivery of the
owed successor. But the successor is usually announced while its predecessor is
still attached — the turn was queued behind it — so the latch was cleared, or
never recorded, in exactly the window it exists for. Once that predecessor
closed and the receipt was dropped, a successor that started and finished
between two list polls was never seen.

Remember which generation was live when the turn became owed. Delivery is then
attachment to a different generation, or the list naming the conversation while
nothing of ours is live. The predecessor no longer counts.

Each half is proved against its own defect: reverting to the old predicate
fails the predecessor-attached case; dropping the generation-aware attach fails
the different-epoch case; and forgetting which generation was the predecessor
livelocks — the latch is set, "delivered" by the very generation it should have
excluded, cleared, and set again.

* 🧷 fix: Judge Successor Delivery by Generation, Re-Arm on Transitions, Expire Off-Screen

Three codex findings on the owed-successor latch, each a way the latch could
be cleared, never recorded, or held too long.

Delivery by generation only. The active-job list carries no generation
identity, so "the conversation is listed" was satisfying delivery while the
listed run was the predecessor — running elsewhere, unattached here — and the
latch was never recorded. The receipt knows the predecessor better than this
pane does: `expectedPredecessorCreatedAt` is stamped from the live epoch at
enqueue and `effectivePredecessorCreatedAt` is the boundary admission actually
consumed. Delivery is now attachment to a generation other than that boundary;
a turn still owed cannot have started, so a generation live when it is first
seen is its predecessor and refines the boundary rather than delivering.

Re-arm on transitions, not heartbeats. A `queued` receipt is refetched every
two seconds during a long wait and advances `dataUpdatedAt` without changing,
and the arm was keyed on that stamp — after the throttle it invalidated status
and history again and again while nothing had happened. It now keys on a
signature of receipt ids and statuses, and refetches history only when a run
is listed or the receipts actually transitioned.

Expire on an absolute window, off-screen too. The expiry effect skipped when
the latched conversation was not the one on screen, so navigating away held
the latch indefinitely and returning later reopened a fresh window. The window
now starts from `quietSince` — set when the receipt stops reporting or the
conversation leaves the screen — and is never pushed back by a remount.

Each change is proved against its own defect: re-adding list-based delivery
fails the listed-predecessor case; removing the transition gate fails the
heartbeat case; skipping expiry off-screen fails the absolute-window case; and
forgetting to learn a live predecessor livelocks the latch.

* 🧽 test: Restore the Admin Allowlist Override This Spec Leaks Into the Shard

The spec writes a per-user `mcpSettings.allowedDomains` override for the shared
primary user and never removes it. The list holds only its own fixture's
origin, and allowlist matching is protocol- and port-inclusive, so for the rest
of the shard every other MCP fixture is blocked: `e2e-oauth` fails inspection,
and an agent expecting its tools initializes into
AGENT_EXPECTED_MCP_TOOLS_UNAVAILABLE (503) instead of producing its OAuth
prompt.

Whether that bites depends only on which specs the shard runs afterwards, so it
surfaces as a deterministic failure in an unrelated spec — `mcp-oauth-resume`
failing an assertion that fires before any resume happens — which passes
whenever it runs first. A client-only PR whose path selection reordered the
shard hit it three times across two heads.

Delete the override in a `finally`, and confirm against the stored config
rather than by re-running `reinitialize`: the connection this test established
stays live, so reinitialize keeps succeeding once the allowlist is gone.

* 🩹 test: Read the Config Wrapper and Treat 404 as Cleared in the Override Teardown

`GET /api/admin/config/:principalType/:principalId` returns `{ config }`, and
deleting the last override removes the document, so the follow-up read is a
404 — the cleared state, not a read failure. The poll treated both as
unreadable and timed out.

* 🧷 fix: Remember Delivered Receipts, Restart the Grace on Delivery, Gate Reopening on Newer Data

Three more codex findings on the owed-successor latch.

Delivered receipts are remembered. An `admitted` receipt stays in the cache for
a fetch after the successor attaches, and it still counts as owed — so the
latch cleared on attachment and was re-recorded from the same receipt on the
next render, synchronously, until the cache moved on. That is React's
maximum-update-depth failure, reachable in the ordinary queued-turn handoff.
The receipt signature that delivered is recorded, and a receipt set with that
signature neither latches nor counts as owing a run; a genuinely new turn can.

Delivery restarts the fallback grace. The list may never have seen the run a
queued turn produced — it can start and finish between two polls — so its own
"recently active" clock is stale, and clearing the latch would have removed
the only reason left to poll. An unpredicted continuation after that run (a
background-tool dispatch finishing) would then go unnoticed until a focus or
reload. Observing the successor live now restarts the handover window.

The window reopens only on newer evidence. Returning to a conversation first
exposes the receipt cached before the turn went quiet, while the authoritative
refetch is still in flight; treating that as "still reporting" reset the
start of an expiry meant to be absolute, so repeated navigation could extend
it indefinitely. Only a server observation newer than the window's start
counts, for reopening and for the reporting check alike.

Each is proved against its defect: forgetting delivered receipts livelocks the
handoff test; skipping the grace restart fails its assertion; reopening on any
report fails the stale-remount case.

* 🧷 fix: Track Delivery Per Turn, Ratchet the Boundary, Keep One Latch Per Conversation

Three more codex findings on the owed-successor latch, plus a bug the second
one's regression test exposed.

Delivery is tracked per queued turn. Two turns queued behind the same
generation deliver one at a time; marking the whole receipt set on the first
would let the still-attached first successor pass as delivery of the second.
While any owed turn is still waiting, nothing is delivered at all — a waiting
turn cannot have produced the live run, so that run is its predecessor.

The boundary ratchets forward. A receipt can name the chain's root long after
a sibling's successor became the link the turn actually waits behind, and the
latch learns that link while the turn waits. Taking the receipt's boundary
first would have "delivered" the second turn on its own predecessor. The
predecessor is the latest link known: the max of what the receipt says, what
the latch learned, and, while waiting, what is live. With no boundary known at
all, a live generation is not delivery; the bounded expiry is the fallback.

Latches are keyed by conversation. Navigating to a conversation that also owes
a run replaced the previous one's latch, cancelling its expiry and the history
repair it performs. Every latch keeps its own absolute window now, and expiry
runs for all of them regardless of which conversation is on screen.

The cherry-picked allowlist-override teardown is synced to its final form
(see #15543): cleanup always runs, only definitive answers end its poll, and
`reinitialize` is no longer used as the reverted signal.

Proofs: marking the whole receipt set is indistinguishable only because the
waiting rule already blocks it; forgetting to learn the live link, or letting
the receipt's root outrank it, both fail the two-turn case; a single-slot latch
fails the two-conversation case; delivering without a boundary fails its case.
2026-09-03 13:23:19 -04:00
..
public 🪢 feat: Langfuse Fanout Connection Setting (#14108) 2026-07-29 18:33:10 -04:00
scripts
src 🐝 fix: Keep Polling for Owed Agent Successors (#15537) 2026-09-03 13:23:19 -04:00
sw
test 🔌 refactor: Give the Subagent Surface a Host Seam and Its Own Jotai State (#15455) 2026-09-01 11:15:42 -04:00
babel.config.cjs
check_updates.sh
index.html
jest.config.cjs ✨ v0.8.8-rc2 (#14845) 2026-09-02 22:18:48 -04:00
jest.resolver.cjs
nginx.conf
package.json ✨ v0.8.8-rc2 (#14845) 2026-09-02 22:18:48 -04:00
postcss.config.cjs
tailwind.config.cjs ✨ feat: Context Gauge Hover Reveal and Breakdown Motion Polish (#15038) 2026-08-21 11:34:36 -04:00
tsconfig.json
vite.config.ts 🪛 chore: Align Vite Build Config With Native ESM (#15495) 2026-09-01 22:22:28 -04:00