Skip to content

The agent that grows with you

fix(tui): a refused MCP reload revision backs off instead of retrying every poll

Tekniumde0b2d4a12e0
diff --git a/ui-tui/src/__tests__/useConfigSync.test.ts b/ui-tui/src/__tests__/useConfigSync.test.ts
index 49a14e4e3e0..c39fd57d650 100644
--- a/ui-tui/src/__tests__/useConfigSync.test.ts
+++ b/ui-tui/src/__tests__/useConfigSync.test.ts
@@ -373,13 +373,34 @@ describe('syncMcpReload (revision-aware ack)', () => {
expect(state.inFlight).toBe(false)
expect(onReloaded).not.toHaveBeenCalled()
- // Next poll tick: the server recovered — the SAME revision goes through.
+ // A later poll tick past the backoff: the server recovered — the SAME revision goes through.
gw.request = vi.fn(() => Promise.resolve({ status: 'reloaded', loaded_rev: 'rev-b' }))
- await syncMcpReload(gw, 's1', 'rev-b', state, onReloaded)
+ await syncMcpReload(gw, 's1', 'rev-b', state, onReloaded, () => Date.now() + 60_000)
expect(state.accepted).toBe('rev-b')
expect(onReloaded).toHaveBeenCalledTimes(1)
})
+ // #141769: a refused revision (one parked MCP server) was re-sent every 5 s poll forever.
+ it('backs off a refused revision instead of retrying it every poll tick', async () => {
+ const gw = { request: vi.fn(() => Promise.reject(new Error('mcp_servers_unavailable'))), on: vi.fn(), off: vi.fn() } as any
+ const state = freshState()
+ let clock = 0
+ const now = () => clock
+
+ // 30 minutes of 5 s poll ticks.
+ for (; clock < 30 * 60_000; clock += 5000) {
+ await syncMcpReload(gw, 's1', 'rev-b', state, undefined, now)
+ }
+
+ // Doubling to a 5-minute cap: a handful of retries, not 360.
+ expect(gw.request.mock.calls.length).toBeLessThan(12)
+ expect(state.accepted).toBe('rev-a')
+
+ // A NEW revision is not held behind the old one's backoff.
+ await syncMcpReload(gw, 's1', 'rev-c', state, undefined, now)
+ expect(gw.request.mock.calls.at(-1)).toEqual(['reload.mcp', { confirm: true, rev: 'rev-c', session_id: 's1' }])
+ })
+
it('does not advance on confirm_required (reload did not happen)', async () => {
const gw = gwOk({ message: 'confirm first', status: 'confirm_required' })
const state = freshState()
diff --git a/ui-tui/src/app/useConfigSync.ts b/ui-tui/src/app/useConfigSync.ts
index f9ae2eed842..da16f2c57d8 100644
--- a/ui-tui/src/app/useConfigSync.ts
+++ b/ui-tui/src/app/useConfigSync.ts
@@ -154,14 +154,23 @@ const quietRpc = async <T extends Record<string, any> = Record<string, any>>(
// an unrelated MCP edit. So `accepted` only moves on a confirmed reload —
// to the server's loaded_rev (what discovery actually read), falling back
// to the requested rev for older gateways. Retries are decoupled from
-// mtime: every poll re-compares, so a transiently broken server heals on
-// the next tick.
+// mtime: every poll re-compares, so a transiently broken server heals.
+//
+// A refused revision backs off (doubling up to MCP_RETRY_MAX_MS) instead of
+// retrying at poll rate: one parked MCP server made every open TUI re-send
+// reload.mcp every 5 s forever, each a gateway WARNING and a full reconcile
+// (#141769). A new revision retries at once.
+
+const MCP_RETRY_BASE_MS = 5000
+const MCP_RETRY_MAX_MS = 5 * 60_000
export interface McpRevState {
/** Last revision the server CONFIRMED it loaded (or boot baseline). */
accepted: string
/** A reload RPC is outstanding — don't stack another every poll tick. */
inFlight: boolean
+ /** The revision whose reload was last refused, its consecutive refusals, and when it may retry. */
+ refused?: { failures: number; rev: string; retryAt: number }
}
export const syncMcpReload = async (
@@ -169,12 +178,19 @@ export const syncMcpReload = async (
sid: string,
nextMcpRev: string,
state: McpRevState,
- onReloaded?: () => void
+ onReloaded?: () => void,
+ now: () => number = Date.now
): Promise<void> => {
if (!nextMcpRev || nextMcpRev === state.accepted || state.inFlight) {
return
}
+ const refused = state.refused?.rev === nextMcpRev ? state.refused : undefined
+
+ if (refused && now() < refused.retryAt) {
+ return
+ }
+
state.inFlight = true
try {
@@ -186,10 +202,19 @@ export const syncMcpReload = async (
if (r?.status === 'reloaded') {
state.accepted = String(r.loaded_rev || nextMcpRev)
+ state.refused = undefined
onReloaded?.()
+ } else {
+ // Failure (null) or confirm_required: leave `accepted` unchanged so the
+ // same revision retries, after a backoff.
+ const failures = (refused?.failures ?? 0) + 1
+
+ state.refused = {
+ failures,
+ rev: nextMcpRev,
+ retryAt: now() + Math.min(MCP_RETRY_BASE_MS * 2 ** failures, MCP_RETRY_MAX_MS)
+ }
}
- // Failure (null) or confirm_required: leave `accepted` unchanged so the
- // next poll tick retries the same revision.
} finally {
state.inFlight = false
}