maxpool 1.24.19 → 1.24.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxpool",
-  "version": "1.24.19",
+  "version": "1.24.21",
   "description": "Multi-account Claude Code proxy with adaptive, rate-aware load balancing across Claude accounts",
   "type": "module",
   "main": "src/index.js",

package/src/server.js

@@ -507,7 +507,19 @@ async function forwardRequest(
     ctx.account = '(none available)';
     const retryPlan = accountManager.nextRetryForRequest?.(requestInfo, new Set()) || {};
     const willRecoverSoon = Number.isFinite(retryPlan.retryAfterMs);
-    const retryAfter = willRecoverSoon ? Math.max(1, Math.ceil(retryPlan.retryAfterMs / 1000)) : 60;
+    // CLI-RETRIABLE CAP (2026-10-11 "bricked sessions"). The real soonest reset can
+    // be hours out; sending `retry-after: 10800` makes Claude Code's SDK treat the
+    // 429 as terminal (binary-verified 2.1.296: a plain rate_limit 429 whose
+    // retry-after exceeds 60s + 25% headroom aborts with tengu_api_retry_after_too_long
+    // — it neither sleeps nor retries; the turn dies and the session looks dead).
+    // The pool has ALREADY decided not to hold this request, so the honest and
+    // useful header is "retry soon": every SDK retries ≤60s values with backoff,
+    // and the pool answers again immediately with a fresh estimate. The body text
+    // still carries the real wait.
+    const RETRY_AFTER_RETRIABLE_S = 60;
+    const retryAfter = willRecoverSoon
+      ? Math.min(Math.max(1, Math.ceil(retryPlan.retryAfterMs / 1000)), RETRY_AFTER_RETRIABLE_S)
+      : 60;
     // Surface the routing decision (logs go to the TUI; this is the only record
     // of WHY a request was rejected rather than queued).
     console.log(`[Maxpool] No route for request — returning 429 (cause: ${retryPlan.cause || 'unavailable'}, recovers-soon: ${willRecoverSoon})`);
@@ -2702,7 +2714,25 @@ async function queueAndRetry(
   // (all accounts logged out, the only healthy account removed, etc.).
   const retryAfterMs = retryPlan.retryAfterMs;
   if (!Number.isFinite(retryAfterMs) || retryAfterMs > queueWindowMs) {
-    return finishQueuedStreamIfNeeded(res, requestInfo, honestMessage);
+    // FINITE-but-BEYOND-WINDOW (2026-10-12, "they should have just waited"): a
+    // STREAMING request with a known reset 1h out used to instant-429 here for the
+    // whole wait (measured 75 min, 08:13–09:34Z) while sessions burned their CLI
+    // retry budgets and some died entirely. Hold the stream for the window with
+    // the heartbeat keeping the client alive, then end with the retriable error —
+    // the client re-enters and the hold chains window-by-window until the reset
+    // lands. Non-streaming requests keep the fast error (no heartbeat = the hold
+    // would die on the client's idle timeout anyway).
+    // Capacity-class causes (concurrency cap, momentary saturation) are NOT
+    // chained: their "reset" is a re-poll guess, not a scheduled quota reset, and
+    // the capacity window exists precisely to shed that load (the soft-deadlock
+    // guard — pinned at cap forever must 429 within the window, never spin).
+    // Only quota-class resets (a scheduled 5h/weekly rollover) chain.
+    if (requestInfo.stream && queueWindowMs > 0 && Number.isFinite(retryAfterMs)
+        && retryPlan.cause !== 'concurrency_cap' && cause !== 'capacity') {
+      requestInfo.queueHoldChain = true;
+    } else {
+      return finishQueuedStreamIfNeeded(res, requestInfo, honestMessage);
+    }
   }
 
   requestInfo.queueStartedAt ||= Date.now();
@@ -2729,12 +2759,14 @@ async function queueAndRetry(
 
   ctx.account = '(queued)';
   hooks.onRequestRouted?.(reqId, { account: '(queued)' });
-  console.log(`[Maxpool] ${reason}; queueing request for up to ${Math.ceil(remaining / 1000)}s (cause: ${cause}, retry: ${retryPlan.cause})`);
+  // Hold-chain note: when this hold expires still-full (queueHoldChain), the
+  // finishQueuedStreamIfNeeded below ends the stream with the retriable error and
+  // the client re-enters — the log line makes the chaining visible.
+  console.log(`[Maxpool] ${reason}; queueing request for up to ${Math.ceil(remaining / 1000)}s (cause: ${cause}, retry: ${retryPlan.cause}${requestInfo.queueHoldChain ? ', hold-chain: reset beyond window' : ''})`);
   ensureQueueHeartbeat(res, requestInfo, queueConfig, accountManager);
 
   const available = await waitForAvailableRoute(req, res, accountManager, requestInfo, queueConfig, remaining);
   if (!available) {
-    if (res.destroyed || req.destroyed) return true;
     accountManager.removeQueuedRequest?.(requestInfo);
     return finishQueuedStreamIfNeeded(res, requestInfo, honestMessage);
   }