maxpool 1.19.2 → 1.19.4

package/package.json

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

@@ -1,4 +1,5 @@
 import http from 'node:http';
+import { ThreadOwners, readThreadIntent, threadRefusalBody } from './thread-gate.js';
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { modelFamily } from './oauth.js';
@@ -586,6 +587,24 @@ async function forwardRequest(
   const method = req.method;
   const upstreamBody = rewriteBodyForAccount(body, account);
 
+  // A threaded follow-up routed to an account that does not hold the thread cannot be
+  // served by it: a different Anthropic account 404s, a provider rejects the truncated
+  // transcript. Hand the client the signal it already knows how to act on — it resends
+  // the turn stateless and stops threading for the session — instead of letting the
+  // upstream produce an error the user sees.
+  const threadIntent = THREAD_GATE_ENABLED ? readThreadIntent(body) : { kind: 'none' };
+  if (THREAD_GATE_ENABLED && threadOwners.shouldRefuse(requestInfo.sessionKey, account.name, threadIntent)) {
+    threadOwners.noteRefused(requestInfo.sessionKey);
+    accountManager.releaseAccount(lease, { neutral: true });
+    console.log(`[Maxpool] thread not held by "${account.name}" — asking the client to resend this turn stateless [sess ${String(requestInfo.sessionKey || '?').slice(0, 8)}]`);
+    ctx.status = 400;
+    sendErrorResponse(res, requestInfo, 400, threadRefusalBody(account.name));
+    return;
+  }
+  // This account is about to serve the turn, so it holds the thread from here on.
+  // Recorded optimistically: if the turn fails, the next one is refused anyway.
+  if (THREAD_GATE_ENABLED) threadOwners.noteServed(requestInfo.sessionKey, account.name, threadIntent);
+
   // Build log sections
   const logSections = [];
   if (logDir) {
@@ -991,6 +1010,9 @@ async function forwardRequest(
       // 262144". Detect it ONLY on a provider (a Claude account's context-length 400 is
       // terminal — nothing bigger to fall to) so we can pin the session to Claude.
       const providerTooSmall = account.type === 'provider' && isContextLengthError(errorBody);
+      // Same shape as providerTooSmall: the PROVIDER cannot take this body, Claude can.
+      const providerRejectedShape = account.type === 'provider'
+        && !providerTooSmall && isProviderParamRejection(errorBody);
       // DETERMINISTIC signature rejection (exact Anthropic wording) — the only trigger
       // for the strip-and-recover retry below. Deliberately NOT the fuzzy
       // isAnthropicIncompatBody heuristic, so a merely malformed request can never cause
@@ -1016,11 +1038,16 @@ async function forwardRequest(
           try { return JSON.parse(errorBody)?.error?.message || errorBody; } catch { return errorBody; }
         })();
         console.log(`[Maxpool] ${upstreamRes.status} from "${account.name}": ${String(why).slice(0, 300)}`);
+        // Providers answer with a code and no field name, so record what WE sent.
+        if (account.type === 'provider') {
+          console.log(`[Maxpool]   request shape: ${describeBodyShape(upstreamBody || body).slice(0, 600)}`);
+        }
       }
       const errorType = errorBody.includes('Invalid `signature` in `thinking` block')
         ? 'invalid_thinking_signature'
         : anthropicIncompat ? 'anthropic_incompatible_transcript'
         : providerTooSmall ? 'provider_context_too_small'
+        : providerRejectedShape ? 'provider_rejected_request_shape'
         : `HTTP ${upstreamRes.status}`;
       const effortMode = classifyEffortRejection(errorBody);
       // A rejected effort level is a REQUEST-shaped fault, not an account-health signal —
@@ -1195,6 +1222,23 @@ async function forwardRequest(
         );
       }
 
+      // A provider that will not take this body: retry on Claude instead of handing the
+      // user an opaque provider code. Unlike the context-too-small case this does NOT
+      // latch the session — the fault is one request's shape, not a durable property of
+      // the conversation, and latching would evict a session from GLM on a single blip.
+      if (providerRejectedShape && claudeAvailable
+        && canRetryBufferedBody && retryCount + 1 < maxAttempts && !res.headersSent) {
+        for (const a of (accountManager.accounts || [])) {
+          if (a.type === 'provider') excludedIndexes.add(a.index);
+        }
+        console.log(`[Maxpool] Provider "${account.name}" rejected this request's shape (${String(errorBody).slice(0, 120)}); retrying on Claude`);
+        return forwardRequest(
+          req, res, body, accountManager, upstream, retryCount + 1, hooks, reqId, ctx, logDir,
+          retryConfig, queueConfig, requestInfo,
+          canRetryBufferedBody, canQueueBufferedBody, excludedIndexes,
+        );
+      }
+
       // Nothing could heal it — replace the cryptic upstream 400 with the real cause and
       // the actual way out. This is what the user saw for hours as a bare
       // "400 messages.51.content.8: Invalid `signature` in `thinking` block".
@@ -1660,12 +1704,30 @@ function unavailableMessage(accountManager, requestInfo = {}, retryAfter, willRe
 // phrasings, NOT a bare "token limit" which a rate-limit body also carries) so the
 // pin-to-Claude heal only fires on a genuine size overflow, not any 400. Rate-limit
 // 429s are intercepted earlier (classifyRateLimit) and never reach this check.
+/** A PROVIDER rejecting the request shape with a code and no field name.
+ *
+ *  z.ai answers `[1210][Invalid API parameter, please check the documentation.]` —
+ *  a code family, not one fault: probing it on 2026-09-09 showed `max_tokens` too
+ *  large gets its own 1210 text, while other members return only the generic line.
+ *  Claude Code does not emit malformed requests, so on a provider this means "this
+ *  provider will not take a body Anthropic accepts", which is the same class as
+ *  `isContextLengthError` — repairable by moving the request to Claude, not by
+ *  surfacing a 400 the user can do nothing with.
+ *
+ *  Matched by CODE, never by prose: an error whose message names its field (Anthropic's
+ *  own 400s do) is a real client fault and keeps its own clear message.
+ */
+function isProviderParamRejection(errorBody) {
+  if (!errorBody) return false;
+  return /\[1210\]|"code"\s*:\s*"?1210"?/.test(errorBody);
+}
+
 function isContextLengthError(errorBody) {
   if (!errorBody) return false;
   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 = { reanchorOrphanedSystemMessages, unavailableMessage, computeQueueWindowMs, isRetriableUpstreamStatus, classifyEffortRejection, repairEffort, isCapacitySignalStatus, isStrippableThinkingBlock, stripForeignThinkingBlocks, parseRejectedBlockPath, stripRejectedBlockClass, peekRejectedBlockType, describeRejectedBlock, headerValue, getMaxpoolProfile, ensureQueueHeartbeat, clearQueueHeartbeat, commitStreamGraceHeartbeat, describeRequest, classifyRateLimit, detectTranscriptOrigin, isAnthropicIncompatBody, isContextLengthError, streamResponse, startIdleRequestReaper, normalizeModelEcho };
+export const __serverTest = { reanchorOrphanedSystemMessages, unavailableMessage, computeQueueWindowMs, isRetriableUpstreamStatus, classifyEffortRejection, repairEffort, isCapacitySignalStatus, isStrippableThinkingBlock, stripForeignThinkingBlocks, parseRejectedBlockPath, stripRejectedBlockClass, peekRejectedBlockType, describeRejectedBlock, headerValue, getMaxpoolProfile, ensureQueueHeartbeat, clearQueueHeartbeat, commitStreamGraceHeartbeat, describeRequest, classifyRateLimit, detectTranscriptOrigin, isAnthropicIncompatBody, isContextLengthError, isProviderParamRejection, describeBodyShape, streamResponse, startIdleRequestReaper, normalizeModelEcho };
 
 async function readErrorBody(upstreamRes, limitBytes = 64 * 1024) {
   if (!upstreamRes.body) return '';
@@ -2800,6 +2862,70 @@ function trimTrailingSlash(value) {
   return String(value).replace(/\/+$/, '');
 }
 
+/** Compact, CONTENT-FREE shape of a request body, for diagnosing a provider 4xx.
+ *  Carries no message text, tool input, or system prompt — only structure: which
+ *  fields were sent and how large they were.
+ *
+ *  WHY (2026-09-09): z.ai answers a bad request with `[1210][Invalid API parameter,
+ *  please check the documentation.]` and does NOT name the field. Two of those reached
+ *  a session on 09-09 and nothing on disk could say which parameter was at fault —
+ *  `config.logDir` writes the whole body, so it stays off, and the log line recorded
+ *  only the provider's own unhelpful message. Probing z.ai showed 1210 is a FAMILY
+ *  (`max_tokens` illegal is one member, each with its own text), so the field has to
+ *  come from our side of the call.
+ */
+function describeBodyShape(buf) {
+  try {
+    const j = JSON.parse(buf.toString('utf8'));
+    if (!j || typeof j !== 'object') return 'non-object body';
+    const parts = [];
+    parts.push(`bytes=${buf.length}`);
+    parts.push(`keys=[${Object.keys(j).sort().join(',')}]`);
+    if (j.model) parts.push(`model=${j.model}`);
+    if (j.max_tokens !== undefined) parts.push(`max_tokens=${j.max_tokens}`);
+    if (j.stream !== undefined) parts.push(`stream=${j.stream}`);
+    if (j.thinking) parts.push(`thinking=${j.thinking.type}/${j.thinking.budget_tokens}`);
+    if (j.system !== undefined) {
+      parts.push(Array.isArray(j.system)
+        ? `system=blocks(${j.system.length})`
+        : `system=str(${String(j.system).length})`);
+    }
+    if (Array.isArray(j.tools)) parts.push(`tools=${j.tools.length}`);
+    if (j.tool_choice) parts.push(`tool_choice=${j.tool_choice.type}`);
+    let cacheMarks = 0, emptyBlocks = 0;
+    if (Array.isArray(j.messages)) {
+      const shapes = j.messages.map(m => {
+        const c = m?.content;
+        if (typeof c === 'string') { if (!c.length) emptyBlocks++; return `${m.role}:str(${c.length})`; }
+        if (!Array.isArray(c)) return `${m.role}:?`;
+        if (!c.length) emptyBlocks++;
+        const types = {};
+        for (const b of c) {
+          const t = b?.type || '?';
+          types[t] = (types[t] || 0) + 1;
+          if (b?.cache_control) cacheMarks++;
+          if (t === 'text' && !String(b.text || '').length) emptyBlocks++;
+        }
+        return `${m.role}:${Object.entries(types).map(([t, n]) => n > 1 ? `${t}x${n}` : t).join('+')}`;
+      });
+      parts.push(`msgs=${j.messages.length}`);
+      // Only the tail: a long transcript's head is never the new thing that broke.
+      parts.push(`tail=[${shapes.slice(-4).join(' ')}]`);
+    }
+    if (cacheMarks) parts.push(`cache_control=${cacheMarks}`);
+    if (emptyBlocks) parts.push(`EMPTY_BLOCKS=${emptyBlocks}`);
+    return parts.join(' ');
+  } catch {
+    return 'unparseable body';
+  }
+}
+
+// THREAD GATE (2026-09-11). Runs AFTER routing has chosen, so it never influences the
+// choice — it only decides what to say to the account that was picked. See
+// src/thread-gate.js for why this replaces rebuilding the transcript.
+const threadOwners = new ThreadOwners();
+const THREAD_GATE_ENABLED = process.env.MAXPOOL_THREAD_GATE !== '0';
+
 function rewriteBodyForAccount(body, account) {
   if (!body.length || (!account.model && !account.modelMap)) return body;
 

package/src/thread-gate.js

@@ -0,0 +1,107 @@
+// Thread gate — let Claude Code fall back to stateless when maxpool routed a threaded
+// turn somewhere that cannot serve it.
+//
+// WHY (2026-09-10). Claude Code >= 2.1.265 keeps the conversation on Anthropic's servers
+// and sends only the tail plus `thread:{type:"continue", previous_message_id}`. That
+// removed the self-containment every maxpool routing capability rests on: a different
+// Anthropic account 404s ("No thread state was found"), and GLM/Kimi reject a transcript
+// that opens mid-tool-call (z.ai `[1214]`). Measured: 10 of 12 live requests carry it.
+//
+// HOW. We do NOT rebuild the transcript. The client already knows how to fall back, and
+// Anthropic built the signal for exactly this case — a proxy that cannot honour threads.
+// A 400 carrying `error.details.error_code = "thread_unsupported_request"` makes the
+// client resend that turn stateless AND stop using threads for that agent+model for the
+// rest of the session. So the client replays with the transcript it already holds; we
+// never reuse a thread reference and therefore can never serve a stale conversation.
+//
+// Routing is NOT consulted or constrained. This runs after the account has been chosen;
+// it only decides what to say to it.
+
+export const THREAD_UNSUPPORTED_CODE = 'thread_unsupported_request';
+
+/** What kind of thread intent a request body carries. Cheap: only the head of the body
+ *  is JSON-parsed, and a non-JSON body is simply 'none'. */
+export function readThreadIntent(body) {
+  try {
+    const j = JSON.parse(body.toString('utf8'));
+    const t = j?.thread;
+    if (!t || typeof t !== 'object') {
+      // `previous_message_id` can also ride in `diagnostics`; that alone is not a thread.
+      return { kind: 'none' };
+    }
+    if (t.type === 'continue') return { kind: 'continue', previousMessageId: t.previous_message_id || null };
+    if (t.type === 'create') return { kind: 'create' };
+    return { kind: 'none' };
+  } catch {
+    return { kind: 'none' };
+  }
+}
+
+/** The exact body the client's classifier reads. `details.error_code` is the field it
+ *  keys on; the message is free text and is never shown to a person. */
+export function threadRefusalBody(accountName) {
+  return {
+    type: 'error',
+    error: {
+      type: 'invalid_request_error',
+      message: `maxpool routed this turn to "${accountName}", which does not hold this thread. Resend it stateless.`,
+      details: { error_code: THREAD_UNSUPPORTED_CODE },
+    },
+  };
+}
+
+// Sessions whose last threaded turn we served, and how many times we have refused them.
+// Two short strings per entry; bounded and LRU-evicted.
+const MAX_SESSIONS = 500;
+// A session that keeps sending threaded turns after being refused is one whose client
+// did NOT take the downgrade (a different agent id, a model switch, an older build).
+// Refusing forever would double its request volume, so stop and forward instead.
+const MAX_CONSECUTIVE_REFUSALS = 2;
+
+export class ThreadOwners {
+  constructor({ maxSessions = MAX_SESSIONS, maxRefusals = MAX_CONSECUTIVE_REFUSALS } = {}) {
+    this.map = new Map();          // sessionKey -> { owner, refusals }
+    this.maxSessions = maxSessions;
+    this.maxRefusals = maxRefusals;
+  }
+
+  _touch(key) {
+    const v = this.map.get(key);
+    if (v !== undefined) { this.map.delete(key); this.map.set(key, v); }   // LRU bump
+    return v;
+  }
+
+  _set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, value);
+    while (this.map.size > this.maxSessions) this.map.delete(this.map.keys().next().value);
+  }
+
+  /** Decide AFTER routing has chosen. Returns true only for a `continue` turn that the
+   *  chosen account cannot serve, and only while refusals are still under the bound. */
+  shouldRefuse(sessionKey, accountName, intent) {
+    if (!sessionKey || !accountName) return false;
+    if (intent?.kind !== 'continue') return false;          // `create` carries the full transcript
+    const entry = this._touch(sessionKey);
+    if (entry && entry.owner === accountName) return false; // the account that holds it
+    if (entry && entry.refusals >= this.maxRefusals) return false;  // bounded fail-open
+    return true;
+  }
+
+  /** Record a refusal we are about to emit. */
+  noteRefused(sessionKey) {
+    if (!sessionKey) return;
+    const entry = this._touch(sessionKey) || { owner: null, refusals: 0 };
+    this._set(sessionKey, { owner: entry.owner, refusals: entry.refusals + 1 });
+  }
+
+  /** Record that `accountName` served a threaded turn for this session — it now holds
+   *  the thread. Any refusal streak ends here. */
+  noteServed(sessionKey, accountName, intent) {
+    if (!sessionKey || !accountName) return;
+    if (intent?.kind !== 'create' && intent?.kind !== 'continue') return;
+    this._set(sessionKey, { owner: accountName, refusals: 0 });
+  }
+
+  get size() { return this.map.size; }
+}