maxpool 1.24.90 → 1.24.92

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/server.js CHANGED
@@ -66,6 +66,120 @@ const isNetworkCode = c => Boolean(c) && NETWORK_ERROR_CODES.has(c);
66
66
  const NETWORK_SOAK_NONSTREAM_MS = Math.max(5_000,
67
67
  Number(process.env.MAXPOOL_NETWORK_SOAK_NONSTREAM_MS) || 45_000);
68
68
  const QUEUE_KEEPALIVE = 'event: ping\ndata: {}\n\n';
69
+
70
+ // PER-REQUEST DEADLINE, NON-STREAMING (release B, 2026-11-13). A non-streaming request has
71
+ // no keep-alive, so the CLIENT's own timer decides when it is abandoned. maxpool used to
72
+ // wait a flat 120s per hop and chain hops without limit, serving into sockets the client had
73
+ // already closed. When the client tells us how long it will wait (X-Stainless-Timeout, or the
74
+ // pool header from the Mac), every wait is bounded by ONE deadline anchored at arrival.
75
+ // A request with no usable patience header gets NO deadline: today's behaviour, never a new cut-off.
76
+ const NONSTREAM_HOP_CAP_MS = 290_000; // undici's own headers/body timeout is 300s: nothing waits past this
77
+ const NONSTREAM_FLOOR_PATIENCE_MS = 15_000; // usable patience is never below 15s once the margin is taken
78
+ const MAX_PATIENCE_MS = 3_600_000;
79
+ const posMsFromEnv = (name, dflt) => {
80
+ const n = Number(process.env[name]);
81
+ return Number.isFinite(n) && n > 0 ? n : dflt;
82
+ };
83
+ /** Live knob values (env read per call so a two-pool test can inject a small cap). */
84
+ function deadlineKnobs() {
85
+ return {
86
+ NONSTREAM_MARGIN_MS: posMsFromEnv('MAXPOOL_NONSTREAM_MARGIN_MS', 15_000), // client header: leave this much before its timer
87
+ POOL_TRANSIT_MARGIN_MS: 3_000, // pool header: the Mac already took its margin
88
+ NONSTREAM_MIN_MOVE_MS: posMsFromEnv('MAXPOOL_NONSTREAM_MIN_MOVE_MS', 60_000), // below this, never re-send to another account
89
+ LINK_RETURN_MARGIN_MS: posMsFromEnv('MAXPOOL_LINK_RETURN_MARGIN_MS', 10_000), // G: the cloud's answer must travel back inside the Mac's wait
90
+ LINK_HOP_CAP_MS: Math.min(posMsFromEnv('MAXPOOL_LINK_HOP_CAP_MS', NONSTREAM_HOP_CAP_MS), NONSTREAM_HOP_CAP_MS),
91
+ UPSTREAM_BODY_MS,
92
+ };
93
+ }
94
+ // A plain positive decimal. `Number('')` is 0, `Number('abc')` is NaN, `Number('Infinity')`
95
+ // is Infinity and `setTimeout(NaN)` fires in 1ms: every one of them must mean "no header".
96
+ const PLAIN_POSITIVE_NUMBER = /^(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
97
+ function parsePositiveHeader(raw) {
98
+ if (raw == null) return null;
99
+ const s = String(raw).trim();
100
+ if (!PLAIN_POSITIVE_NUMBER.test(s)) return null;
101
+ const n = Number(s);
102
+ return Number.isFinite(n) && n > 0 ? n : null;
103
+ }
104
+ /** The client's patience: first VALID of the pool header (ms) → X-Stainless-Timeout (s) →
105
+ * x-stainless-read-timeout (s). null = unknown, i.e. no deadline. */
106
+ function parsePatience(headers = {}) {
107
+ const k = deadlineKnobs();
108
+ const pool = parsePositiveHeader(headerValue(headers, 'x-maxpool-deadline-ms'));
109
+ if (pool != null) return { ms: Math.min(pool, MAX_PATIENCE_MS), source: 'pool', poolSupplied: true };
110
+ for (const [name, source] of [['x-stainless-timeout', 'stainless-timeout'], ['x-stainless-read-timeout', 'stainless-read-timeout']]) {
111
+ const secs = parsePositiveHeader(headerValue(headers, name));
112
+ if (secs == null) continue;
113
+ const floor = k.NONSTREAM_MARGIN_MS + NONSTREAM_FLOOR_PATIENCE_MS;
114
+ return { ms: Math.min(Math.max(secs * 1000, floor), MAX_PATIENCE_MS), source, poolSupplied: false };
115
+ }
116
+ return null;
117
+ }
118
+ /** deadlineAt for a request that arrived at `arrivedAt`; null when the client gave no usable patience. */
119
+ function computeDeadline(headers, arrivedAt) {
120
+ const p = parsePatience(headers);
121
+ if (!p) return null;
122
+ // F1 (mixed version): a request FORWARDED BY ANOTHER POOL (hop header) that carries no pool deadline header
123
+ // comes from an OLD Mac (v1.24.91). It forwards the client's x-stainless-timeout, but an old Mac books any
124
+ // 5xx it passes through as an account failure, so this pool must behave exactly as before: no deadline.
125
+ // (A new Mac always sends the pool header on a non-streaming link hop.)
126
+ if (!p.poolSupplied && headerValue(headers, HOP_HEADER) !== '') return null;
127
+ const k = deadlineKnobs();
128
+ const usableMs = p.poolSupplied
129
+ ? Math.max(p.ms - k.POOL_TRANSIT_MARGIN_MS, 1_000)
130
+ : p.ms - k.NONSTREAM_MARGIN_MS;
131
+ return { deadlineAt: arrivedAt + usableMs, patienceMs: p.ms, source: p.source, poolSupplied: p.poolSupplied };
132
+ }
133
+ /** Time left on a non-streaming request's deadline. Infinity = no deadline (streaming, or a header-less client). */
134
+ function nonStreamRemainingMs(requestInfo = {}) {
135
+ if (requestInfo.stream || requestInfo.deadlineAt == null) return Infinity;
136
+ return requestInfo.deadlineAt - Date.now();
137
+ }
138
+ /** First-byte wait for one DIRECT hop. WITH a deadline: min(remaining, hop cap) — the flat/scaled
139
+ * first-byte floor (120s) does NOT apply, because the client has said it will wait longer and a
140
+ * floor timeout would abandon an answer that still fits (F3). WITHOUT a deadline: `waitMs`, today's wait.
141
+ * The cap is the 290s undici bound (injectable lower via MAXPOOL_LINK_HOP_CAP_MS for scaled tests). */
142
+ function nonStreamFirstByteWait(requestInfo, waitMs) {
143
+ const remaining = nonStreamRemainingMs(requestInfo);
144
+ if (remaining === Infinity) return { ms: waitMs, deadlineBound: false };
145
+ const cap = deadlineKnobs().LINK_HOP_CAP_MS;
146
+ return remaining <= cap ? { ms: Math.max(1, Math.floor(remaining)), deadlineBound: true } : { ms: cap, deadlineBound: false };
147
+ }
148
+ /** Non-streaming body-read wait: min(UPSTREAM_BODY_MS, remaining). */
149
+ function nonStreamBodyWait(requestInfo, bodyMs) {
150
+ const remaining = nonStreamRemainingMs(requestInfo);
151
+ if (remaining === Infinity) return { ms: bodyMs, deadlineBound: false };
152
+ return remaining <= bodyMs ? { ms: Math.max(1, Math.floor(remaining)), deadlineBound: true } : { ms: bodyMs, deadlineBound: false };
153
+ }
154
+ /** ONE NUMBER for a link hop: linkWait = min(remaining − G, cap) (never below min(15s, remaining)),
155
+ * header = linkWait − G. So header + G ≤ linkWait always: the cloud's whole hop chain ends
156
+ * inside this ONE Mac link wait. null = no usable time left (never arm a 0ms timer). */
157
+ function computeLinkHop(remainingMs, { capMs, marginMs } = {}) {
158
+ const k = deadlineKnobs();
159
+ const G = marginMs ?? k.LINK_RETURN_MARGIN_MS;
160
+ const cap = capMs ?? k.LINK_HOP_CAP_MS;
161
+ if (!Number.isFinite(remainingMs) || remainingMs <= 0) return null;
162
+ const linkWaitMs = Math.floor(Math.min(cap, Math.max(remainingMs - G, Math.min(15_000, remainingMs))));
163
+ const headerMs = linkWaitMs - G;
164
+ if (headerMs < 1_000) return null;
165
+ return { linkWaitMs, headerMs, deadlineBound: remainingMs - G <= cap };
166
+ }
167
+ /** The answer for a request whose client patience ran out: retryable by every SDK (5xx). */
168
+ function deadlineErrorPayload() {
169
+ return {
170
+ type: 'error',
171
+ error: {
172
+ type: 'timeout_error',
173
+ message: 'This request ran out of time before Claude answered. Sending the message again normally works.',
174
+ },
175
+ };
176
+ }
177
+ /** 504 for a deadline expiry. The pool-only marker rides ONLY when the request itself carried the pool
178
+ * deadline header (an old Mac / header-less request keeps today's answer and never sees it). */
179
+ function sendDeadlineResponse(res, requestInfo) {
180
+ const headers = requestInfo.deadlinePoolSupplied ? { 'x-maxpool-request-scoped': '1' } : {};
181
+ sendErrorResponse(res, requestInfo, 504, deadlineErrorPayload(), headers);
182
+ }
69
183
  // Account screen shell (served keyless at /maxpool/screen; the page itself prompts
70
184
  // for a pool key and reads the key-gated /maxpool/status). Read once at boot.
71
185
  const SCREEN_HTML = (() => {
@@ -98,12 +212,16 @@ const REFUSAL_HOLD_MAX_MS = 30_000;
98
212
  // disabling it. Short (not reset-length) so a provider-pinned session's hold window
99
213
  // isn't blown, and a still-exhausted provider just re-benches on the next single retry.
100
214
  const PROVIDER_FORBIDDEN_COOLDOWN_SEC = Math.max(60, Number(process.env.MAXPOOL_PROVIDER_403_COOLDOWN_SEC) || 1800);
101
- // Backstop reaper idle ceiling. Floored WELL above the longest a legit NON-streaming
102
- // request can go silent (no heartbeat there): TTFB 120s + nonStreamMaxWaitMs 300s +
103
- // UPSTREAM_BODY_MS 300s ≈ 720s — so a slow-but-alive non-streaming request is never
104
- // reaped at completion. Streaming holds heartbeat, so they're safe at any ceiling.
215
+ // Backstop reaper idle ceiling. Floored WELL above the longest a legit header-less
216
+ // NON-streaming request can go silent (no heartbeat there): TTFB 120s + nonStreamMaxWaitMs
217
+ // 300s + UPSTREAM_BODY_MS 300s ≈ 720s — so a slow-but-alive non-streaming request is never
218
+ // reaped at completion. A request with a client-patience deadline can legitimately stay
219
+ // silent longer (290s hops, up to ~1470s inside a 1h patience); the reaper extends to
220
+ // deadlineAt + DEADLINE_REAP_GRACE_MS for those, since the deadline itself ends them.
221
+ // Streaming holds heartbeat, so they're safe at any ceiling.
105
222
  // Exported so index.js sizes RELOAD_DRAIN_MS off the SAME value (no drift).
106
223
  export const REQUEST_IDLE_MAX_MS = Math.max(900_000, Number(process.env.MAXPOOL_REQUEST_IDLE_MAX_MS) || 1_200_000);
224
+ const DEADLINE_REAP_GRACE_MS = 60_000;
107
225
 
108
226
  const DEFAULT_QUEUE = {
109
227
  enabled: true,
@@ -250,6 +368,8 @@ export function createProxyServer(accountManager, config, hooks = {}) {
250
368
  requestTimeout: Math.max(1_000, Number(process.env.MAXPOOL_REQUEST_TIMEOUT_MS) || 300_000),
251
369
  connectionsCheckingInterval: Math.max(100, Number(process.env.MAXPOOL_CONNECTIONS_CHECK_MS) || 30_000),
252
370
  }, async (req, res) => {
371
+ // B1: the deadline is anchored HERE, at the request event, before auth and body buffering.
372
+ const arrivedAt = Date.now();
253
373
  try {
254
374
  // Disable Nagle on the client socket: flush each SSE event immediately instead
255
375
  // of coalescing small writes into bursts. Smooths streaming cadence toward the
@@ -503,6 +623,15 @@ export function createProxyServer(accountManager, config, hooks = {}) {
503
623
  // THIS account, from lease.startedAt.) Was never set, so every direct-path
504
624
  // client-gone line read 0.0s.
505
625
  requestInfo.startedAt = Date.now();
626
+ // B1: non-streaming only; a request with no usable patience header gets NO deadline.
627
+ if (!requestInfo.stream) {
628
+ const dl = computeDeadline(req.headers, arrivedAt);
629
+ if (dl) {
630
+ requestInfo.deadlineAt = dl.deadlineAt;
631
+ requestInfo.deadlineSource = dl.source;
632
+ requestInfo.deadlinePoolSupplied = dl.poolSupplied;
633
+ }
634
+ }
506
635
  const maxQueuedBodyBytes = queueConfig.maxQueuedBodyBytes == null
507
636
  ? Infinity
508
637
  : Math.max(0, Number(queueConfig.maxQueuedBodyBytes) || 0);
@@ -579,6 +708,10 @@ export function createProxyServer(accountManager, config, hooks = {}) {
579
708
  // request's heartbeat commits writes LONG before upstream answers.
580
709
  firstUpstreamByteAt: requestInfo?._firstUpstreamByteAt ?? null,
581
710
  upstreamForwardStartAt: requestInfo?._upstreamForwardStartAt ?? null,
711
+ // B8: makes the non-streaming share measurable. null = no request shape was ever parsed.
712
+ // F9: only the message-creating call (POST /v1/messages) has a streaming shape — count_tokens and GETs
713
+ // must not read as "non-streaming" and swamp the share.
714
+ stream: requestInfo?.method === 'POST' && /^\/v1\/messages(?:\?|$)/.test(String(req.url || '')) ? Boolean(requestInfo.stream) : null,
582
715
  });
583
716
  }
584
717
  } catch (err) {
@@ -808,6 +941,7 @@ async function forwardRequest(
808
941
  // waiter instead of preferentially jumping ahead of the FIFO for the rest of
809
942
  // this request's failover chain.
810
943
  requestInfo.queueAdmitted = false;
944
+ requestInfo._clientRes = res; // B10: lets the shared chokepoints see the client socket
811
945
 
812
946
  // Abort the upstream fetch and release the lease if the CLIENT disconnects during
813
947
  // the pre-response window (token refresh + connect + waiting for the upstream's
@@ -935,6 +1069,7 @@ async function forwardRequest(
935
1069
  // locally went live remotely). The remote pool owns its own accounts.
936
1070
  if (/^x-maxpool-(zai|kimi)-/.test(lk)) continue;
937
1071
  if (lk === 'x-maxpool-pin-account') continue; // M4: only this pool sets a pin
1072
+ if (lk === 'x-maxpool-deadline-ms') continue; // B4: ONE number — this hop computes its own below
938
1073
  linkHeaders[k] = v;
939
1074
  }
940
1075
  linkHeaders[HOP_HEADER] = String(hop);
@@ -966,6 +1101,21 @@ async function forwardRequest(
966
1101
  if (linkDone) return; linkDone = true;
967
1102
  accountManager.releaseAccount(lease, outcome);
968
1103
  };
1104
+ // B4 (non-streaming with a deadline): linkWait = min(remaining − G, 290s); the cloud is told
1105
+ // linkWait − G, so its whole hop chain ends inside this ONE wait. No time left → 504, no call.
1106
+ let linkHop = null;
1107
+ if (!requestInfo.stream && requestInfo.deadlineAt != null) {
1108
+ linkHop = computeLinkHop(nonStreamRemainingMs(requestInfo));
1109
+ if (!linkHop) {
1110
+ finishLink({ neutral: true, error: 'deadline', kind: 'deadline' });
1111
+ detachLinkClose();
1112
+ ctx.status = 504;
1113
+ logFailedAttempt(account.name, 'deadline', 'no time left before the client gives up', 'surfaced');
1114
+ sendDeadlineResponse(res, requestInfo);
1115
+ return;
1116
+ }
1117
+ linkHeaders['x-maxpool-deadline-ms'] = String(linkHop.headerMs);
1118
+ }
969
1119
  try {
970
1120
  // P4a: a blackholed link must not hang the request (and hold a lease) for
971
1121
  // minutes — bound time-to-headers like the direct path's TTFB guard. GLM
@@ -977,7 +1127,7 @@ async function forwardRequest(
977
1127
  // clears this timer for every HEALTHY link, so a scaled wait only ever ran against
978
1128
  // a dead/blackholed tunnel — stretching its detection from 120s to minutes. The
979
1129
  // big-prompt first-byte timeouts measured were all on the direct path.
980
- const linkTtfbMs = Math.max(15_000, Number(process.env.MAXPOOL_LINK_TTFB_MS) || UPSTREAM_TTFB_MS);
1130
+ const linkTtfbMs = linkHop ? linkHop.linkWaitMs : Math.max(15_000, Number(process.env.MAXPOOL_LINK_TTFB_MS) || UPSTREAM_TTFB_MS);
981
1131
  const linkCtl = new AbortController();
982
1132
  const linkTtfb = setTimeout(() => linkCtl.abort(), linkTtfbMs);
983
1133
  // P2: the link path had NO pre-headers keep-alive — a streaming client sat on a
@@ -1050,6 +1200,22 @@ async function forwardRequest(
1050
1200
  sendErrorResponse(res, requestInfo, upRes.status, { type: 'error', error: { type: 'overloaded_error', message: `Team pool account "${account.name}" is at capacity` } });
1051
1201
  return;
1052
1202
  }
1203
+ // B7: the cloud ran out of the deadline THIS request gave it (504 + request-scoped). It says
1204
+ // nothing about the cloud row or the link: release NEUTRAL (no cooldownUntil, no failed count,
1205
+ // no streak) and treat it like any other request-scoped miss — try another route only if time remains.
1206
+ if (account.remote && upRes.status === 504 && upRes.headers.get('x-maxpool-request-scoped') === '1' && !clientHasRealBytes(res, requestInfo)) {
1207
+ const errorText = await readErrorBody(upRes);
1208
+ finishLink({ neutral: true, error: 'deadline', kind: 'deadline' });
1209
+ excludedIndexes.add(account.index);
1210
+ if (retryCount + 1 < maxAttempts && hasEligibleRoute(accountManager, requestInfo, excludedIndexes)) {
1211
+ logFailedAttempt(account.name, 'remote-504', 'linked pool ran out of the request deadline', 'moved');
1212
+ detachLinkClose();
1213
+ return forwardRequest(req, res, body, accountManager, upstream, retryCount + 1, hooks, reqId, ctx, logDir, retryConfig, queueConfig, requestInfo, canRetryBufferedBody, canQueueBufferedBody, excludedIndexes);
1214
+ }
1215
+ logFailedAttempt(account.name, 'remote-504', 'linked pool ran out of the request deadline; no time to move', 'surfaced');
1216
+ sendErrorBody(res, requestInfo, 504, errorText, upRes.headers);
1217
+ return;
1218
+ }
1053
1219
  // A request released from the queue already holds a committed keep-alive stream.
1054
1220
  // An error on it is framed as an SSE error; a 2xx keeps the heartbeat until the
1055
1221
  // first real chunk (below).
@@ -1137,6 +1303,17 @@ async function forwardRequest(
1137
1303
  logFailedAttempt(account.name, 'client_cancelled', `client left after ${heldS}s, nothing sent`, 'released-cancel');
1138
1304
  return;
1139
1305
  }
1306
+ // B12: the wait was cut by the CLIENT'S deadline (not the per-hop cap, not a dead link): neither an
1307
+ // account fault nor a link fault — release neutral, and answer a retryable 504 (nothing left to move on).
1308
+ // (A no-headers AbortError that is not a client leaving can only be this hop's timer.)
1309
+ if (linkHop?.deadlineBound && err?.name === 'AbortError' && !linkClientGone && linkStatus == null && !clientHasRealBytes(res, requestInfo)) {
1310
+ finishLink({ neutral: true, error: 'deadline', kind: 'deadline' });
1311
+ detachLinkClose();
1312
+ ctx.status = 504;
1313
+ logFailedAttempt(account.name, 'deadline', `no answer after ${heldS}s (client patience), non-streaming`, 'surfaced');
1314
+ sendDeadlineResponse(res, requestInfo);
1315
+ return;
1316
+ }
1140
1317
  // Everything that reaches this catch is request-scoped (D4): a remote 429/503 is
1141
1318
  // handled — account-scoped — by its own branch above before anything can throw, so
1142
1319
  // only a TTFB abort, a mid-stream cancel or an unknown link error lands here. It
@@ -1145,9 +1322,20 @@ async function forwardRequest(
1145
1322
  : err?.linkBody ? 'link_idle'
1146
1323
  : err?.name === 'AbortError' ? 'link_ttfb'
1147
1324
  : 'pool_link_unreachable';
1148
- finishLink({ status: 502, error: 'pool_link_unreachable', scope: 'request' });
1325
+ // D4 split (2026-11-12): a client leaving after output started says nothing about
1326
+ // the link either — neutral. A LINK-transport fault is booked as a link drop, not
1327
+ // a failure of the cloud row behind it.
1328
+ if (linkClientGone) {
1329
+ finishLink({ success: false, neutral: true, error: linkKind });
1330
+ } else {
1331
+ finishLink({ status: 502, error: linkKind, scope: 'request', linkFault: true });
1332
+ }
1149
1333
  excludedIndexes.add(account.index); // P4b: never re-pick a row that just failed
1150
- const linkDetail = `${linkStatus == null ? 'no answer' : `HTTP ${linkStatus}`} after ${heldS}s (${err?.message || err})`;
1334
+ const streamTag = requestInfo.stream ? 'streaming' : 'non-streaming';
1335
+ // A string code (UND_ERR_SOCKET, ECONNRESET) names the fault; DOMException
1336
+ // codes are numbers (AbortError = 20), so fall back to the cause, then the name.
1337
+ const errCode = (typeof err?.code === 'string' && err.code) || err?.cause?.code || err?.name || 'unknown';
1338
+ const linkDetail = `${linkStatus == null ? 'no answer' : `HTTP ${linkStatus}`} after ${heldS}s (${err?.message || err}) [${errCode}, ${streamTag}]`;
1151
1339
  if (!clientHasRealBytes(res, requestInfo)) {
1152
1340
  if (retryCount + 1 < maxAttempts && hasEligibleRoute(accountManager, requestInfo, excludedIndexes)) {
1153
1341
  logFailedAttempt(account.name, linkKind, linkDetail, 'moved');
@@ -1228,10 +1416,27 @@ async function forwardRequest(
1228
1416
  // this fixed clock, so a long healthy stream is never cut.
1229
1417
  const ttfbController = new AbortController();
1230
1418
  const ttfbCeilingMs = clientWaitCeilingMs(requestInfo, queueConfig);
1231
- const ttfbMs = scaledTtfbMs(UPSTREAM_TTFB_MS, TTFB_MS_PER_BYTE, requestInfo.bodyBytes, ttfbCeilingMs);
1419
+ let ttfbMs = scaledTtfbMs(UPSTREAM_TTFB_MS, TTFB_MS_PER_BYTE, requestInfo.bodyBytes, ttfbCeilingMs);
1420
+ // B2/N-3: a non-streaming request with a deadline never waits past it (nor past 290s, undici's own
1421
+ // bound), and with no time left never reaches upstream at all (never arm a 0ms timer).
1422
+ let ttfbDeadlineBound = false;
1423
+ if (!requestInfo.stream && requestInfo.deadlineAt != null) {
1424
+ if (nonStreamRemainingMs(requestInfo) <= 0) {
1425
+ res.off('close', onClientClose);
1426
+ accountManager.relinquishUpstreamProbe?.(lease);
1427
+ accountManager.releaseAccount(lease, { neutral: true, error: 'deadline', kind: 'deadline' });
1428
+ ctx.status = 504;
1429
+ logFailedAttempt(account.name, 'deadline', 'no time left before the client gives up', 'surfaced');
1430
+ sendDeadlineResponse(res, requestInfo);
1431
+ return;
1432
+ }
1433
+ const w = nonStreamFirstByteWait(requestInfo, ttfbMs);
1434
+ ttfbMs = w.ms;
1435
+ ttfbDeadlineBound = w.deadlineBound;
1436
+ }
1232
1437
  noteScaledTtfb(requestInfo, account.name, 'direct', ttfbMs, UPSTREAM_TTFB_MS, ttfbCeilingMs);
1233
1438
  const ttfbTimer = setTimeout(
1234
- () => ttfbController.abort(Object.assign(new Error('upstream TTFB timeout'), { code: 'UPSTREAM_TTFB' })),
1439
+ () => ttfbController.abort(Object.assign(new Error('upstream TTFB timeout'), { code: ttfbDeadlineBound ? 'UPSTREAM_DEADLINE' : 'UPSTREAM_TTFB' })),
1235
1440
  ttfbMs,
1236
1441
  );
1237
1442
  ttfbTimer.unref?.();
@@ -1655,7 +1860,8 @@ async function forwardRequest(
1655
1860
  logSections.push(`=== RESPONSE ${upstreamRes.status} — "${account.name}" cooling down, failing over ===\n${formatHeaders(upstreamRes.headers)}`);
1656
1861
  }
1657
1862
 
1658
- if (canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)) {
1863
+ if (canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)
1864
+ && hasEligibleRoute(accountManager, requestInfo, excludedIndexes)) {
1659
1865
  logFailedAttempt(account.name, `upstream_${upstreamRes.status}`, 'retriable upstream status, cooling down', 'moved');
1660
1866
  return forwardRequest(
1661
1867
  req, res, body, accountManager, upstream, retryCount + 1, hooks, reqId, ctx, logDir,
@@ -1814,7 +2020,8 @@ async function forwardRequest(
1814
2020
  : null;
1815
2021
  const issuerIsClaude = issuer && issuer.type !== 'provider';
1816
2022
  if (lease.migratedFromName && issuerIsClaude && requestInfo.sessionKey
1817
- && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)) {
2023
+ && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)
2024
+ && resendAllowed(requestInfo)) {
1818
2025
  accountManager.revertSessionBinding(requestInfo.sessionKey, lease.migratedFromName);
1819
2026
  excludedIndexes.add(account.index);
1820
2027
  console.log(`[Maxpool] Thinking-signature fail-safe: reverting session to issuer "${lease.migratedFromName}" and retrying`);
@@ -1830,7 +2037,8 @@ async function forwardRequest(
1830
2037
  // EFFORT REPAIR. A rejected output_config.effort is a hard failure of whatever the
1831
2038
  // client was doing (a web search, a tool call) — worth healing rather than surfacing.
1832
2039
  if (effortMode && !requestInfo.effortRepaired
1833
- && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)) {
2040
+ && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)
2041
+ && resendAllowed(requestInfo)) {
1834
2042
  const fix = repairEffort(body, effortMode, errorBody);
1835
2043
  if (fix.body) {
1836
2044
  // Latch it so LATER turns apply the working level up front: the client resends the
@@ -1874,7 +2082,7 @@ async function forwardRequest(
1874
2082
  const isDirectiveFormRejection = account.type !== 'provider'
1875
2083
  && upstreamRes.status === 400
1876
2084
  && /output_config[^:]*: *Extra inputs are not permitted/i.test(errorBody);
1877
- if (isDirectiveFormRejection && requestInfo.orderingRepaired && !requestInfo.orderingFallback && canRepairBody) {
2085
+ if (isDirectiveFormRejection && requestInfo.orderingRepaired && !requestInfo.orderingFallback && canRepairBody && resendAllowed(requestInfo)) {
1878
2086
  // Rewrite every directive-only system (the repair's own output) as a PLAIN
1879
2087
  // assistant turn carrying the directives text — ordinary history, accepted by
1880
2088
  // every validator, nothing dropped. A system ENDING the array stays legal
@@ -1898,7 +2106,7 @@ async function forwardRequest(
1898
2106
  );
1899
2107
  }
1900
2108
  }
1901
- if (isOrderingRejection && !requestInfo.orderingRepaired && canRepairBody) {
2109
+ if (isOrderingRejection && !requestInfo.orderingRepaired && canRepairBody && resendAllowed(requestInfo)) {
1902
2110
  const coord = /messages\.(\d+)/.exec(errorBody);
1903
2111
  const { messages: fixedMessages, converted } = directiveOnlySystemMessages(
1904
2112
  JSON.parse(body.toString('utf8')).messages ?? [],
@@ -1915,7 +2123,7 @@ async function forwardRequest(
1915
2123
  );
1916
2124
  }
1917
2125
  }
1918
- if (isSignatureRejection && !requestInfo.thinkingStripped && canRepairBody) {
2126
+ if (isSignatureRejection && !requestInfo.thinkingStripped && canRepairBody && resendAllowed(requestInfo)) {
1919
2127
  console.log(`[Maxpool] Anthropic rejected a block: ${describeRejectedBlock(body, errorBody)}`);
1920
2128
  const { body: cleanBody, removed, converted } = stripForeignThinkingBlocks(body);
1921
2129
  if (cleanBody) {
@@ -1940,7 +2148,7 @@ async function forwardRequest(
1940
2148
  // model. Its own flag, so it still fires on a request whose broad strip already ran.
1941
2149
  // Same reasoning as the broad strip above: a repair SHRINKS the body, so the
1942
2150
  // re-send limit must not bar it.
1943
- if (isSignatureRejection && !requestInfo.rejectedBlockStripped && canRepairBody) {
2151
+ if (isSignatureRejection && !requestInfo.rejectedBlockStripped && canRepairBody && resendAllowed(requestInfo)) {
1944
2152
  const { body: fixedBody, removed, type } = stripRejectedBlockClass(body, errorBody);
1945
2153
  if (fixedBody) {
1946
2154
  // Latch the session ONLY for the class the pre-strip can actually repair up
@@ -1987,7 +2195,8 @@ async function forwardRequest(
1987
2195
  || /mcp_tool_(use|result)/.test(errorBody)
1988
2196
  && /(does not match any of the expected tags|without a corresponding)/i.test(errorBody);
1989
2197
  if (anthropicIncompat && requestInfo.sessionKey && providerAvailable
1990
- && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)) {
2198
+ && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)
2199
+ && resendAllowed(requestInfo)) {
1991
2200
  accountManager.markSessionIncompatible?.(requestInfo.sessionKey, requestInfo.homeProvider);
1992
2201
  excludedIndexes.add(account.index);
1993
2202
  console.log(`[Maxpool] Anthropic rejected this transcript (server_tool_use/thinking); pinning session to GLM/Kimi and retrying`);
@@ -2009,7 +2218,8 @@ async function forwardRequest(
2009
2218
  // Claude account exists to serve it; with none, the 400 surfaces (nothing bigger).
2010
2219
  const claudeAvailable = accountManager.accounts?.some(a => a.type !== 'provider' && a.enabled !== false);
2011
2220
  if (providerTooSmall && requestInfo.sessionKey && claudeAvailable
2012
- && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)) {
2221
+ && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)
2222
+ && resendAllowed(requestInfo)) {
2013
2223
  accountManager.markSessionLargeContext?.(requestInfo.sessionKey);
2014
2224
  // Bench EVERY provider: today's GLM + Kimi coding legs both cap at ~256K, so once
2015
2225
  // one 400s on size the others can't hold it either. If a genuine 1M-context
@@ -2032,7 +2242,8 @@ async function forwardRequest(
2032
2242
  // latch the session — the fault is one request's shape, not a durable property of
2033
2243
  // the conversation, and latching would evict a session from GLM on a single blip.
2034
2244
  if (providerRejectedShape && claudeAvailable
2035
- && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)) {
2245
+ && canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)
2246
+ && resendAllowed(requestInfo)) {
2036
2247
  for (const a of (accountManager.accounts || [])) {
2037
2248
  if (a.type === 'provider') excludedIndexes.add(a.index);
2038
2249
  }
@@ -2174,21 +2385,51 @@ async function forwardRequest(
2174
2385
  } else { // Bound the non-streaming body read so a mid-body upstream stall can't hang
2175
2386
  // the request forever and leak the lease (same class as the streaming idle
2176
2387
  // guard). On timeout → UPSTREAM_BODY → the caller frees the lease.
2177
- const bodyP = upstreamRes.arrayBuffer();
2388
+ // F4: read through a reader we OWN so an abandoned read can really be cancelled — arrayBuffer() holds
2389
+ // the stream's lock, which made `body.cancel()` a no-op and left the orphaned read (and its socket) running.
2390
+ const bodyReader = upstreamRes.body?.getReader?.() ?? null;
2391
+ const bodyP = bodyReader
2392
+ ? (async () => {
2393
+ const chunks = [];
2394
+ for (;;) {
2395
+ const { done, value } = await bodyReader.read();
2396
+ if (done) return Buffer.concat(chunks);
2397
+ chunks.push(Buffer.from(value));
2398
+ }
2399
+ })()
2400
+ : upstreamRes.arrayBuffer();
2178
2401
  bodyP.catch(() => {});
2179
2402
  let bodyTimer;
2403
+ // B3: bounded by min(UPSTREAM_BODY_MS, remaining) when the request carries a deadline.
2404
+ const bodyWait = nonStreamBodyWait(requestInfo, UPSTREAM_BODY_MS);
2180
2405
  const bodyTimeout = new Promise((_, reject) => {
2181
2406
  bodyTimer = setTimeout(
2182
- () => reject(Object.assign(new Error('upstream body timeout'), { code: 'UPSTREAM_BODY' })),
2183
- UPSTREAM_BODY_MS,
2407
+ () => reject(Object.assign(new Error('upstream body timeout'), { code: bodyWait.deadlineBound ? 'UPSTREAM_DEADLINE' : 'UPSTREAM_BODY' })),
2408
+ bodyWait.ms,
2184
2409
  );
2185
2410
  bodyTimer.unref?.();
2186
2411
  });
2412
+ // B10: the pre-response close listener was dropped when the headers arrived, so during this
2413
+ // body read nobody watches the client. Without this, a client that left mid-read still gets
2414
+ // a second upstream call when the read fails (the move path re-sends for a dead socket).
2415
+ let onBodyClientClose;
2416
+ const clientLeft = new Promise((_, reject) => {
2417
+ const gone = () => reject(Object.assign(new Error('client closed during body read'), { code: 'CLIENT_GONE_BODY' }));
2418
+ if (res.destroyed || res.closed) { gone(); return; }
2419
+ onBodyClientClose = gone;
2420
+ res.once('close', onBodyClientClose);
2421
+ });
2422
+ clientLeft.catch(() => {});
2187
2423
  let arr;
2188
2424
  try {
2189
- arr = await Promise.race([bodyP, bodyTimeout]);
2425
+ arr = await Promise.race([bodyP, bodyTimeout, clientLeft]);
2426
+ } catch (e) {
2427
+ // Client gone / deadline / stalled body: stop the orphaned read and close the upstream socket now.
2428
+ try { await (bodyReader ? bodyReader.cancel() : upstreamRes.body?.cancel()); } catch { /* already closed */ }
2429
+ throw e;
2190
2430
  } finally {
2191
2431
  clearTimeout(bodyTimer);
2432
+ if (onBodyClientClose) res.off('close', onBodyClientClose);
2192
2433
  }
2193
2434
  const buf = Buffer.from(arr);
2194
2435
  extractUsageFromBody(buf, account.index, accountManager, requestInfo);
@@ -2268,6 +2509,32 @@ async function forwardRequest(
2268
2509
  releaseOnClientGone();
2269
2510
  return;
2270
2511
  }
2512
+ // B10: the client left during the non-streaming BODY read. Not an account fault, nothing to move,
2513
+ // nothing to write to: release neutral and stop (the move path below would fetch on a dead socket).
2514
+ if (err?.code === 'CLIENT_GONE_BODY') {
2515
+ const heldMs = Date.now() - (requestInfo.startedAt || Date.now());
2516
+ console.log(`[Maxpool] Client left after ${(heldMs / 1000).toFixed(1)}s on "${account.name}" (during the response body read) — released, not retried`);
2517
+ logFailedAttempt(account.name, 'client_cancelled', `client left after ${(heldMs / 1000).toFixed(1)}s (body read)`, 'released-cancel');
2518
+ accountManager.relinquishUpstreamProbe?.(lease);
2519
+ accountManager.releaseAccount(lease, { neutral: true, error: 'client_cancelled', kind: 'client_cancelled' });
2520
+ clearQueueHeartbeat(requestInfo);
2521
+ accountManager.removeQueuedRequest?.(requestInfo);
2522
+ return;
2523
+ }
2524
+ // B12: the wait was cut by the CLIENT'S deadline — neither an account fault (no markTransientFailure
2525
+ // streak) nor a link fault. Release neutral and answer a retryable 504; nothing is moved or re-sent.
2526
+ if (err.code === 'UPSTREAM_DEADLINE') {
2527
+ accountManager.relinquishUpstreamProbe?.(lease);
2528
+ accountManager.releaseAccount(lease, { neutral: true, error: 'deadline', kind: 'deadline' });
2529
+ ctx.status = 504;
2530
+ logFailedAttempt(account.name, 'deadline', `no answer after ${heldSeconds(lease)}s (client patience), non-streaming`, 'surfaced');
2531
+ if (logDir) {
2532
+ logSections.push(`=== DEADLINE ===\n${err.message}`);
2533
+ writeRequestLog(logDir, reqId, logSections);
2534
+ }
2535
+ sendDeadlineResponse(res, requestInfo);
2536
+ return;
2537
+ }
2271
2538
  // undici reports every socket/DNS/TLS failure as the bare string "fetch failed" and
2272
2539
  // hangs the REAL reason off err.cause. Logging err.message alone threw that away: 588
2273
2540
  // "fetch failed" lines and ZERO ECONNRESET/ENOTFOUND/UND_ERR in the whole log, leaving
@@ -2286,7 +2553,7 @@ async function forwardRequest(
2286
2553
  // would have seen before this feature existed.
2287
2554
  // !clientHasRealBytes, not !headersSent: a slow turn whose keep-alive committed
2288
2555
  // (pings only) is just as reroutable as a fast one (review r2 B).
2289
- if (err.code === 'REFUSAL_RETRY' && canRetryBufferedBody && !clientHasRealBytes(res, requestInfo)) {
2556
+ if (err.code === 'REFUSAL_RETRY' && canRetryBufferedBody && !clientHasRealBytes(res, requestInfo) && resendAllowed(requestInfo)) {
2290
2557
  const category = err.refusalCategory || 'unknown';
2291
2558
  const anthropicIndexes = accountManager.accounts
2292
2559
  .filter(a => a.type !== 'provider')
@@ -2377,6 +2644,15 @@ async function forwardRequest(
2377
2644
  { attempt: [account.name, transientKind, 'transient; no other route'] },
2378
2645
  );
2379
2646
  if (queued) return;
2647
+ // F3: a request with a deadline that ran out of routes on a first-byte timeout answers the request-scoped
2648
+ // 504 (the Mac books it neutral), never a bare 503 that cools its row and counts a failure. Direct
2649
+ // long-patience clients get the same answer (R2-2); an old Mac never has a deadline here (F1 gate).
2650
+ if (err.code === 'UPSTREAM_TTFB' && !requestInfo.stream && requestInfo.deadlineAt != null) {
2651
+ ctx.status = 504;
2652
+ logFailedAttempt(account.name, 'deadline', `no first byte after ${heldSeconds(lease)}s (hop cap), no route left`, 'surfaced');
2653
+ sendDeadlineResponse(res, requestInfo);
2654
+ return;
2655
+ }
2380
2656
  ctx.status = 503;
2381
2657
  // Record the user-facing failure explicitly so it's greppable in the event
2382
2658
  // log (the in-memory TUI feed scrolls away). `err` is the last network error.
@@ -2401,7 +2677,8 @@ async function forwardRequest(
2401
2677
  }
2402
2678
 
2403
2679
  accountManager.releaseAccount(lease, { error: err.message });
2404
- if (canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)) {
2680
+ if (canRetryBufferedBody && retryCount + 1 < maxAttempts && !clientHasRealBytes(res, requestInfo)
2681
+ && hasEligibleRoute(accountManager, requestInfo, excludedIndexes)) {
2405
2682
  account.status = 'error';
2406
2683
  excludedIndexes.add(account.index);
2407
2684
  logFailedAttempt(account.name, (err.code || err.message || 'error').toString().slice(0, 40), err.message, 'moved');
@@ -2464,6 +2741,9 @@ function noteScaledTtfb(requestInfo, accountName, path, waitMs, floorMs, ceiling
2464
2741
  * second wait can still end inside the client's patience. Direct path only.
2465
2742
  */
2466
2743
  function retrySameEligible(account, requestInfo, res, queueConfig = {}) {
2744
+ // B5: a non-streaming request is never retried on the same account — the second wait is a second
2745
+ // full hop of silence behind a client that cannot be told we are still working.
2746
+ if (!requestInfo.stream) return false;
2467
2747
  if (requestInfo.sameAccountRetried) return false;
2468
2748
  if ((requestInfo.bodyBytes || 0) < BIG_PROMPT_BYTES) return false;
2469
2749
  if (!account || account.status === 'throttled' || account.status === 'error'
@@ -2514,10 +2794,33 @@ function isProviderAuthStatus(status) {
2514
2794
  return status === 401 || status === 403;
2515
2795
  }
2516
2796
 
2797
+ /** F5: the re-send guard shared by EVERY site that sends a request upstream a second time (account moves
2798
+ * AND body-repair / pin re-sends, which need no route check because they are not a fresh placement):
2799
+ * B10 — never re-send for a client that left; B6 — a non-streaming request with under the minimum
2800
+ * time left is not re-sent (a fresh hop cannot finish). */
2801
+ function resendAllowed(requestInfo = {}) {
2802
+ if (clientAlreadyGone(requestInfo)) {
2803
+ if (!requestInfo._clientGoneLogged) {
2804
+ requestInfo._clientGoneLogged = true;
2805
+ console.log('[Maxpool] Client already left — not re-sending to another account');
2806
+ logFailedAttempt('-', 'client_cancelled', 'client left before a re-send', 'released-cancel');
2807
+ }
2808
+ return false;
2809
+ }
2810
+ return nonStreamRemainingMs(requestInfo) >= deadlineKnobs().NONSTREAM_MIN_MOVE_MS;
2811
+ }
2812
+
2517
2813
  function hasEligibleRoute(accountManager, requestInfo = {}, excludedIndexes = new Set()) {
2814
+ if (!resendAllowed(requestInfo)) return false;
2518
2815
  return accountManager.hasAvailableRoute?.(requestInfo, excludedIndexes) || false;
2519
2816
  }
2520
2817
 
2818
+ /** B10: has the client socket of this request closed? (requestInfo carries its res; set at forwardRequest entry.) */
2819
+ function clientAlreadyGone(requestInfo = {}) {
2820
+ const r = requestInfo._clientRes;
2821
+ return Boolean(r && (r.destroyed || r.closed));
2822
+ }
2823
+
2521
2824
  function formatRetryDuration(seconds) {
2522
2825
  const s = Math.max(0, Math.round(Number(seconds) || 0));
2523
2826
  if (s >= 86400) return `${Math.round(s / 86400)}d`;
@@ -2727,7 +3030,7 @@ function isContextLengthError(errorBody) {
2727
3030
  return /exceeded model token limit|maximum context length|context length exceeded|context window (?:size )?(?:exceeded|too)|prompt is too long|input is too long|reduce the length of|too many (?:input )?tokens|request too large/i.test(errorBody);
2728
3031
  }
2729
3032
 
2730
- export const __serverTest = { directiveOnlySystemMessages, rewriteBodyForAccount, sanitizeBlocksForProvider, reanchorOrphanedSystemMessages, unavailableMessage, computeQueueWindowMs, waitForAvailableRoute, isRetriableUpstreamStatus, classifyEffortRejection, repairEffort, isCapacitySignalStatus, isStrippableThinkingBlock, stripForeignThinkingBlocks, parseRejectedBlockPath, stripRejectedBlockClass, peekRejectedBlockType, describeRejectedBlock, headerValue, getMaxpoolProfile, ensureQueueHeartbeat, ensureQueueHeartbeatInterval, clearQueueHeartbeat, commitStreamGraceHeartbeat, describeRequest, classifyRateLimit, isRequestShapeRefusal, looksLikeClaudeCode, parseProviderRetryAfter, secondsUntilParsedTime, detectTranscriptOrigin, isAnthropicIncompatBody, isContextLengthError, isProviderParamRejection, describeBodyShape, logFailedAttempt, isRequestScopedTimeout, clientWaitCeilingMs, scaledTtfbMs, retrySameEligible, ttfbKnobs: () => ({ UPSTREAM_TTFB_MS, TTFB_MS_PER_BYTE, BIG_PROMPT_BYTES, CLI_STREAM_CEILING_MS }), streamResponse, startIdleRequestReaper, normalizeModelEcho, classifyHeldStreamPrefix };
3033
+ export const __serverTest = { hasEligibleRoute, resendAllowed, directiveOnlySystemMessages, rewriteBodyForAccount, sanitizeBlocksForProvider, reanchorOrphanedSystemMessages, unavailableMessage, computeQueueWindowMs, waitForAvailableRoute, isRetriableUpstreamStatus, classifyEffortRejection, repairEffort, isCapacitySignalStatus, isStrippableThinkingBlock, stripForeignThinkingBlocks, parseRejectedBlockPath, stripRejectedBlockClass, peekRejectedBlockType, describeRejectedBlock, headerValue, getMaxpoolProfile, ensureQueueHeartbeat, ensureQueueHeartbeatInterval, clearQueueHeartbeat, commitStreamGraceHeartbeat, describeRequest, classifyRateLimit, isRequestShapeRefusal, looksLikeClaudeCode, parseProviderRetryAfter, secondsUntilParsedTime, detectTranscriptOrigin, isAnthropicIncompatBody, isContextLengthError, isProviderParamRejection, describeBodyShape, logFailedAttempt, isRequestScopedTimeout, clientWaitCeilingMs, scaledTtfbMs, retrySameEligible, parsePatience, computeDeadline, computeLinkHop, nonStreamFirstByteWait, nonStreamBodyWait, nonStreamRemainingMs, deadlineKnobs, deadlineErrorPayload, ttfbKnobs: () => ({ UPSTREAM_TTFB_MS, TTFB_MS_PER_BYTE, BIG_PROMPT_BYTES, CLI_STREAM_CEILING_MS }), streamResponse, startIdleRequestReaper, normalizeModelEcho, classifyHeldStreamPrefix };
2731
3034
 
2732
3035
  async function readErrorBody(upstreamRes, limitBytes = 64 * 1024) {
2733
3036
  if (!upstreamRes.body) return '';
@@ -3471,7 +3774,7 @@ async function queueAndRetryInner(
3471
3774
  onGiveUp = null, onHold = null,
3472
3775
  ) {
3473
3776
  const giveUp = (msg) => { onGiveUp?.(); return finishQueuedStreamIfNeeded(res, requestInfo, msg); };
3474
- if (!queueConfig.enabled || !canQueueBufferedBody || (res.headersSent && !requestInfo.queueHeartbeatActive) || res.destroyed) {
3777
+ if (!queueConfig.enabled || !canQueueBufferedBody || (res.headersSent && !requestInfo.queueHeartbeatActive) || res.destroyed || res.closed) {
3475
3778
  if (queueConfig.enabled && !canQueueBufferedBody && requestInfo.queueBlockedReason) {
3476
3779
  console.log(`[Maxpool] Not queueing request: ${requestInfo.queueBlockedReason}`);
3477
3780
  }
@@ -3566,7 +3869,7 @@ async function queueAndRetryInner(
3566
3869
  const streamClientToleranceMs = Number.isFinite(requestInfo.clientToleranceMs)
3567
3870
  ? requestInfo.clientToleranceMs
3568
3871
  : Math.max(0, Number(queueConfig.streamClientToleranceMs) || 0);
3569
- const queueWindowMs = computeQueueWindowMs({
3872
+ let queueWindowMs = computeQueueWindowMs({
3570
3873
  cause,
3571
3874
  stream: Boolean(requestInfo.stream),
3572
3875
  retryPlanCause: retryPlan.cause,
@@ -3579,6 +3882,13 @@ async function queueAndRetryInner(
3579
3882
  countTokensMaxWaitMs,
3580
3883
  });
3581
3884
 
3885
+ // B6: a non-streaming hold is capped at the time the client still has; none left = give up now.
3886
+ const deadlineRemainingMs = nonStreamRemainingMs(requestInfo);
3887
+ if (deadlineRemainingMs !== Infinity) {
3888
+ if (deadlineRemainingMs <= 0) return giveUp(honestMessage);
3889
+ queueWindowMs = Math.min(queueWindowMs, deadlineRemainingMs);
3890
+ }
3891
+
3582
3892
  if (queueWindowMs <= 0) return giveUp(honestMessage);
3583
3893
 
3584
3894
  // HOLD-vs-ERROR oracle (from nextRetryForRequest): HOLD only when a TEMPORARY
@@ -4290,6 +4600,10 @@ function startIdleRequestReaper(res, reqId, idleMs, { now = Date.now, setInterva
4290
4600
  if (getRequestInfo?.()?.queueHeartbeatActive) { lastProgressAt = now(); return; }
4291
4601
  const bytes = res.socket?.bytesWritten ?? lastBytes;
4292
4602
  if (bytes !== lastBytes) { lastBytes = bytes; lastProgressAt = now(); return; }
4603
+ // R2-1: a non-streaming request with a deadline is bounded by that deadline (504 at
4604
+ // deadlineAt); never cut it before deadline + grace. Never SHORTENS the ceiling.
4605
+ const info = getRequestInfo?.();
4606
+ if (info && !info.stream && info.deadlineAt != null && now() < info.deadlineAt + DEADLINE_REAP_GRACE_MS) return;
4293
4607
  if (now() - lastProgressAt >= idleMs && !res.writableEnded && !res.destroyed) {
4294
4608
  console.error(`[Maxpool] Request ${reqId} — no write progress for ${Math.round(idleMs / 1000)}s (backstop reaper); force-aborting a stuck request to free its account slot`);
4295
4609
  res.destroy();
@@ -4347,9 +4661,29 @@ async function streamResponse(webStream, res, status, responseHeaders, accountIn
4347
4661
  // upstream headers and the first body chunk can still fail over (clientHasRealBytes
4348
4662
  // stays false) and the client's idle watchdog stays fed. realWrite stops it right
4349
4663
  // before the first real write, so no ping can land between live SSE events (Bug A).
4664
+ // B9: a SCRUBBED provider stream drops every thinking event, so a long GLM think leaves the client
4665
+ // (and a linked Mac's idle timer) with nothing for tens of seconds — Claude Code reads that as a
4666
+ // dead stream. Once the first real byte is out, and only while a scrubber is active, keep a
4667
+ // keep-alive ping flowing. Safe mid-stream: the scrubber hands realWrite WHOLE events only
4668
+ // (provider-thinking-scrub.js push/event), so a ping can only land between events. Never armed
4669
+ // before the first real write (the model-echo/refusal holds `continue` ahead of realWrite, and a
4670
+ // ping before writeHead would commit default headers).
4671
+ let scrubPingTimer = null;
4672
+ let scrubPingStopped = false;
4673
+ const armScrubPing = () => {
4674
+ if (!scrubber || scrubPingTimer || scrubPingStopped || res.destroyed) return;
4675
+ const ms = Math.max(100, Number(process.env.MAXPOOL_SCRUB_PING_MS) || 3000);
4676
+ scrubPingTimer = setInterval(() => {
4677
+ if (res.destroyed || res.writableEnded) return;
4678
+ try { res.write('event: ping\ndata: {"type":"ping"}\n\n'); } catch { /* client gone */ }
4679
+ }, ms);
4680
+ scrubPingTimer.unref?.();
4681
+ };
4350
4682
  const realWrite = (chunk) => {
4351
4683
  if (requestInfo.queueHeartbeatActive) clearQueueHeartbeat(requestInfo);
4352
- return res.write(chunk);
4684
+ const ok = res.write(chunk);
4685
+ armScrubPing();
4686
+ return ok;
4353
4687
  };
4354
4688
 
4355
4689
  // Client left mid-stream: the caller drops its disconnect-abort once headers
@@ -4562,6 +4896,9 @@ async function streamResponse(webStream, res, status, responseHeaders, accountIn
4562
4896
  if (err?.code === 'REFUSAL_RETRY') refusalRerouting = true;
4563
4897
  throw err;
4564
4898
  } finally {
4899
+ // B9: stop the keep-alive before anything else in the teardown, and never re-arm it.
4900
+ scrubPingStopped = true;
4901
+ if (scrubPingTimer) { clearInterval(scrubPingTimer); scrubPingTimer = null; }
4565
4902
  // SAFEGUARD-REFUSAL HOLD last-resort flush. A stream can end while the hold is
4566
4903
  // still undecided — a `usage`-only stream (message_delta with no content blocks
4567
4904
  // and no message_stop) reaches `done` having never produced a decisive event, and