maxpool 1.5.59 → 1.5.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maxpool",
-  "version": "1.5.59",
+  "version": "1.5.61",
   "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

@@ -33,6 +33,10 @@ const NETWORK_ERROR_CODES = new Set([
   'ENOTFOUND', 'EAI_AGAIN', 'EPIPE', 'ECONNABORTED', 'UND_ERR_SOCKET', 'UND_ERR_HEADERS_TIMEOUT',
 ]);
 const isNetworkCode = c => Boolean(c) && NETWORK_ERROR_CODES.has(c);
+// How long a NON-STREAMING request may soak through a network blip. Short by construction:
+// with no keepalive the client's hard 300s floor applies, so we must error first.
+const NETWORK_SOAK_NONSTREAM_MS = Math.max(5_000,
+  Number(process.env.MAXPOOL_NETWORK_SOAK_NONSTREAM_MS) || 45_000);
 const QUEUE_KEEPALIVE = 'event: ping\ndata: {}\n\n';
 // 240s, strictly BELOW Claude Code's hard 300s stall floor. At the old 300_000 the two
 // timers were a dead heat and the client always won — maxpool's clock starts when a chunk
@@ -1958,7 +1962,26 @@ async function queueAndRetry(
   // a real outage doesn't spin. A non-streaming network failure (no keepalive) still
   // fails fast — it would die on the client's own timeout anyway.
   if (cause === 'proxy') return false;
-  if (cause === 'network' && (!requestInfo.stream || !canQueueBufferedBody)) return false;
+  if (cause === 'network' && !canQueueBufferedBody) return false;
+  // NETWORK SOAK, hard-bounded. A brief connectivity blip should not throw away a turn —
+  // but an unbounded soak is worse than a fast error (it presents as a hang, which is the
+  // failure mode the user explicitly fears). So a network-caused hold carries its OWN
+  // absolute deadline, stamped once and NEVER reset by a re-queue, independent of the
+  // per-attempt queue window. Past it, we stop soaking and return the honest error.
+  //
+  // Non-streaming gets a short budget: it has no keepalive, so the client's hard 300s
+  // floor applies with nothing resetting it — we must give up well before that so the user
+  // sees a real message instead of a client-side timeout.
+  if (cause === 'network') {
+    const budgetMs = requestInfo.stream
+      ? Math.max(60_000, Number(queueConfig.networkMaxWaitMs) || 120_000)
+      : NETWORK_SOAK_NONSTREAM_MS;
+    requestInfo.networkSoakDeadline ||= Date.now() + budgetMs;
+    if (Date.now() >= requestInfo.networkSoakDeadline) {
+      console.log(`[Maxpool] Network soak budget spent (${Math.round(budgetMs / 1000)}s) — returning the connection error instead of holding longer`);
+      return false;
+    }
+  }
 
   const maxWaitMs = Math.max(0, Number(queueConfig.maxWaitMs) || 0);
   const autoMaxWaitMs = queueConfig.autoMaxWaitMs == null

package/src/tui.js

@@ -480,6 +480,38 @@ export class TUI {
 
   /** The visible Updates panel. Answers, at a glance: what am I running, is anything
    *  newer, is it automatic, and what is happening right now. */
+  /** The Routing header line. Split out so a test can assert the RENDERED string —
+   *  matching source text is how a header that contradicted routing survived review. */
+  /** The "Cross-provider: …" fragment. Its own method so a test can assert what the user
+   *  actually sees without needing a TTY — the previous version read a superseded global
+   *  and contradicted routing, and only a source-text test would have "passed" on it. */
+  _crossProviderText() {
+    // Show the EFFECTIVE policy, i.e. what actually governs routing. Since per-provider
+    // settings were added, `_claudeFallbackFor(provider)` decides — and the legacy global
+    // knob this used to read is only its fallback when a provider has no entry of its own.
+    // Reading the global made the header contradict both the footer and reality: it said
+    // "when-exhausted" while GLM and Kimi were each set to "always" and routing agreed
+    // with the footer, not the header.
+    const provs = this.am.accounts.filter(a => a.type === 'provider');
+    if (!provs.length) return '';   // no GLM/Kimi in this pool — the whole line is meaningless
+    const eff = [...new Set(provs.map(a => this.am._claudeFallbackFor?.(a.provider)
+      || this.am._crossProviderFallbackPolicy?.() || 'when-exhausted'))];
+    const colour = v => (v === 'never' ? yellow(v) : v === 'always' ? green(v) : cyan(v));
+    if (eff.length === 1) {
+      return `  ${dim('·')}  ${dim('Cross-provider:')} ${colour(eff[0])}`;
+    } else {
+      // Providers disagree — naming each is the only honest summary; a single word here
+      // would misdescribe at least one of them.
+      const parts = provs.map(a => `${a.provider === 'zai' ? 'GLM' : a.provider === 'kimi' ? 'Kimi' : a.provider}: `
+        + colour(this.am._claudeFallbackFor?.(a.provider) || 'never'));
+      return `  ${dim('·')}  ${dim('Cross-provider:')} ${parts.join(dim(' / '))}`;
+    }
+  }
+
+  _routingLine(routing, xpText) {
+    return ` Routing  ${cyan(routing)}${xpText}`;
+  }
+
   _renderUpdatesDetail() {
     const v = this.am.versionInfo;
     const running = v?.current ? `v${v.current}` : 'unknown';
@@ -1137,9 +1169,7 @@ export class TUI {
     const hasProviders = this.am.accounts.some(a => a.type === 'provider');
     let xpText = '';
     if (hasProviders) {
-      const p = this.am._crossProviderFallbackPolicy?.() || 'when-exhausted';
-      const pc = p === 'never' ? yellow(p) : p === 'always' ? green(p) : cyan(p);
-      xpText = `  ${dim('·')}  ${dim('Cross-provider:')} ${pc}`;
+      xpText = this._crossProviderText();
       // Overflow visibility: when GLM/Kimi actually served requests recently, surface the
       // volume so provider traffic isn't a mystery — it's overflow that spilled here while
       // OAuth was saturated. Reuses the SAME 15m load window as the per-row "15m Nr" column.
@@ -1150,7 +1180,7 @@ export class TUI {
       }
       if (provReq > 0) xpText += `  ${dim('·')}  ${yellow(`providers: ${provReq} req/15m`)}`;
     }
-    lines.push(` Routing  ${cyan(routing)}${xpText}`);
+    lines.push(this._routingLine(routing, xpText));
     const queuedCount = this.am.queueState?.waiting?.length || 0;
     // Throttle and WAITING are different things and used to share one line labelled
     // "Anthropic upstream throttled" — so a request parked purely because every account