maxpool 1.5.45 → 1.5.46

package/package.json

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

@@ -1334,7 +1334,7 @@ function isContextLengthError(errorBody) {
   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);
 }
 
-export const __serverTest = { unavailableMessage, computeQueueWindowMs, isRetriableUpstreamStatus, isCapacitySignalStatus, isForeignThinkingSignature, stripForeignThinkingBlocks, headerValue, getMaxpoolProfile, ensureQueueHeartbeat, clearQueueHeartbeat, commitStreamGraceHeartbeat, describeRequest, classifyRateLimit, detectTranscriptOrigin, isAnthropicIncompatBody, isContextLengthError, streamResponse, startIdleRequestReaper };
+export const __serverTest = { unavailableMessage, computeQueueWindowMs, isRetriableUpstreamStatus, isCapacitySignalStatus, isStrippableThinkingBlock, stripForeignThinkingBlocks, headerValue, getMaxpoolProfile, ensureQueueHeartbeat, clearQueueHeartbeat, commitStreamGraceHeartbeat, describeRequest, classifyRateLimit, detectTranscriptOrigin, isAnthropicIncompatBody, isContextLengthError, streamResponse, startIdleRequestReaper };
 
 async function readErrorBody(upstreamRes, limitBytes = 64 * 1024) {
   if (!upstreamRes.body) return '';
@@ -1510,17 +1510,16 @@ function secondsUntilParsedTime(value) {
   return null;
 }
 
-// An Anthropic thinking `signature` is a long base64 protobuf blob (200+ chars, e.g.
-// "Eo8DCpQBCBAYAipAqutr+oAB…"). GLM's Anthropic-compatible endpoint emits a SHORT hex
-// digest instead (verified 2026-07-25: "8f8840affff743118e1f569d", 24 hex chars) — which
-// Anthropic rejects with `Invalid \`signature\` in \`thinking\` block`, permanently
-// bricking any session that took even ONE provider turn. Detect the foreign shape
-// conservatively: only a missing / short / pure-hex signature counts, so a genuine
-// Anthropic block is never stripped.
-function isForeignThinkingSignature(sig) {
-  if (typeof sig !== 'string' || sig.length === 0) return true;
-  if (sig.length < 60) return true;
-  return /^[0-9a-f]+$/i.test(sig);
+// Provider thinking signatures CANNOT be told apart from Anthropic's by shape — measured
+// against the live APIs 2026-07-25: Anthropic ~200-400 char base64, GLM a 24-char hex
+// digest, Kimi(K3) a 12,946-char base64 blob. A shape heuristic tuned to GLM silently
+// missed Kimi entirely. So the repair below does NOT guess: it strips EVERY `thinking`
+// block. That is safe precisely because it only ever runs in response to Anthropic's own
+// signature-rejection 400 — a healthy Claude-only session never reaches it — and a history
+// with thinking removed is accepted (200 OK, verified, incl. tool_use → tool_result).
+// `redacted_thinking` is never touched: it legitimately carries `data` and no signature.
+function isStrippableThinkingBlock(block) {
+  return block?.type === 'thinking';
 }
 
 /**
@@ -1546,12 +1545,7 @@ function stripForeignThinkingBlocks(body) {
       if (msg?.role !== 'assistant' || !Array.isArray(msg.content)) { messages.push(msg); continue; }
       let localRemoved = 0;
       const kept = msg.content.filter(block => {
-        // ONLY `thinking`. NEVER `redacted_thinking`: a genuine one carries `data` and
-        // legitimately has NO signature, so signature-based judging would strip 100% of
-        // them (verified against the live API). GLM's contamination is always a
-        // `thinking` block with a hex signature.
-        if (block?.type !== 'thinking') return true;
-        if (!isForeignThinkingSignature(block.signature)) return true;
+        if (!isStrippableThinkingBlock(block)) return true;
         localRemoved++;
         return false;
       });

package/src/tui.js

@@ -253,6 +253,7 @@ export class TUI {
     // Set by index.js after construction (a deferred closure, not a constructor literal —
     // avoids the const TDZ on applyUpdateIfReady, which is defined after `new TUI`).
     this.checkNow = null;
+    this.updateBusy = null;   // live progress text while an update check/apply runs
 
     this.log = [];           // completed activity entries
     this.active = new Map(); // in-flight requests
@@ -456,10 +457,20 @@ export class TUI {
   _keyUpdates(k) {
     if (k === 'c') {
       // Check & apply now — the dance-killer: pull the latest + seamless-reload in place,
-      // no quit/relaunch. index.js wires this.checkNow (applies regardless of autoApply).
-      this.mode = 'normal';
-      if (this.checkNow) this.checkNow();
-      else this._addLog('Update check unavailable on this worker');
+      // no quit/relaunch. STAY on this screen and show live progress: bouncing straight
+      // back to the dashboard was indistinguishable from "nothing happened".
+      if (!this.checkNow) { this._addLog('Update check unavailable on this worker'); return; }
+      if (this.updateBusy) return;                       // already running
+      this.updateBusy = 'Checking npm…';
+      this.render();
+      Promise.resolve(this.checkNow())
+        .catch(() => {})
+        .finally(() => {
+          // If an update was found+applied, the seamless reload replaces this worker and
+          // this never renders. Otherwise report the outcome in place.
+          this.updateBusy = null;
+          if (this.mode === 'updates') this.render();
+        });
     } else if (k === 't') {
       this._toggleAutoUpdate();
     } else if (k === 'esc' || k === 'q') {
@@ -467,6 +478,29 @@ 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. */
+  _renderUpdatesDetail() {
+    const v = this.am.versionInfo;
+    const running = v?.current ? `v${v.current}` : 'unknown';
+    const auto = this._autoUpdateOn();
+    const out = [];
+    out.push(` ${bold('Updates')}`);
+    if (!v) {
+      out.push(` ${dim('Running')} ${running}   ${dim('· checking npm for a newer version…')}`);
+    } else if (v.hasUpdate && v.latest) {
+      out.push(` ${dim('Running')} ${running}   ${yellow(`v${v.latest} is available`)}`);
+      out.push(auto
+        ? ` ${dim('It installs itself automatically. Press')} ${bold('c')} ${dim('to get it right now.')}`
+        : ` ${dim('Automatic updates are off. Press')} ${bold('c')} ${dim('to install it now, or')} ${bold('t')} ${dim('to turn automatic on.')}`);
+    } else {
+      out.push(` ${dim('Running')} ${running}   ${green('up to date')}`);
+      out.push(` ${dim(auto ? 'New versions install themselves.' : 'Automatic updates are off — press t to turn them on.')}`);
+    }
+    if (this.updateBusy) out.push(` ${cyan(SPINNER[this.frame])} ${dim(this.updateBusy)}`);
+    return out;
+  }
+
   async _toggleAutoUpdate() {
     const turnOn = !this._autoUpdateOn();
     // ON = the full hands-free chain; OFF = keep checking (banner still shows) but never
@@ -1158,7 +1192,10 @@ export class TUI {
     }
 
     // Completed log
-    const footerH = this.mode === 'confirm' ? 3 : 2;
+    // 2 = separator + footer; confirm adds its detail line; updates adds its detail block.
+    const footerH = this.mode === 'confirm' ? 3
+      : this.mode === 'updates' ? 2 + this._renderUpdatesDetail().length
+      : 2;
     const space = Math.max(0, H - lines.length - footerH);
     for (let i = 0; i < space && i < this.log.length; i++) {
       lines.push(`   ${gray(this.log[i].t)}  ${this.log[i].msg}`);
@@ -1170,6 +1207,10 @@ export class TUI {
     // ── Footer
     lines.push(' ' + dim('─'.repeat(W - 2)));
     if (this.mode === 'confirm') lines.push(` ${this.confirmDetail}`);
+    // Updates DETAIL — without this, pressing 'u' changed only the one-line footer at the
+    // very bottom of a busy screen, which reads as "nothing happened" (reported twice).
+    // Every other mode draws something visible; this one must too.
+    if (this.mode === 'updates') lines.push(...this._renderUpdatesDetail());
     lines.push(this._renderFooter());
 
     // Write buffer