maxpool 1.5.14 → 1.5.15

package/README.md

@@ -192,7 +192,9 @@ The proxy also understands an optional internal header profile:
 
 Provider fallback credentials can be supplied per Claude Code process with `ANTHROPIC_CUSTOM_HEADERS`. Maxpool strips all `x-maxpool-*` headers before forwarding upstream.
 
-`x-maxpool-session: <id>` enables session affinity. With this header, the first request for a Claude Code process is routed by the adaptive load balancer, then later requests from the same process keep using that home account while it remains available. If the home account is rate-limited, exhausted, in cooldown, or removed, the session temporarily uses another eligible route. When the home account becomes available again, the session returns to it. For the `all` profile, fallback priority still wins: a session that had to use GLM or Kimi can move back to Claude when a Claude account becomes available again.
+`x-maxpool-session: <id>` enables session affinity. With this header, the first request for a Claude Code process is routed by the adaptive load balancer, then later requests from the same process keep using that home account while it remains available. If the home account is rate-limited, exhausted, in cooldown, or removed, the session temporarily uses another eligible route. When the home account becomes available again, the session returns to it. For the `all` profile, a Claude session that had to spill onto GLM/Kimi moves back to Claude once a Claude account frees up — **as long as it produced no provider-format tool calls while there**.
+
+**Cross-provider session pinning (`all` profile).** Maxpool classifies each session's home provider from its transcript: Anthropic tool-use ids are `toolu_`/`srvtoolu_`, GLM (z.ai) emits `call_`, Kimi (Moonshot) emits `tool_`. A session whose replayed history contains any non-Anthropic tool-use id (e.g. resuming a `cc glm` session under `cc all`) is **pinned to GLM/Kimi** and never routed to a Claude account — Anthropic rejects a non-`srvtoolu_` `server_tool_use.id` with a 400, so that direction is a hard incompatibility, not a preference. The reverse (a Claude session spilling onto GLM/Kimi) is safe. This is governed by `scheduler.crossProviderFallbackPolicy` (`never` | `when-exhausted` (default) | `always`), cyclable live in the TUI Routing menu (`m` → `f`): `never` = strict same-family pin, `when-exhausted` = cross only once the home family is exhausted, `always` = providers peer with Claude for a Claude session. A GLM/Kimi-origin session is never sent to Claude under any policy. (Note: Claude Code itself may warn that a resumed `glm-*` model "could not be restored" and fall back to `claude-opus-4-8`; that is a client-side session-store message — Maxpool still routes the session to GLM/Kimi correctly by its transcript.)
 
 Provider rows do not use Claude Max session/week bars unless the provider returns compatible quota headers. For GLM/Kimi, Maxpool always tracks operational telemetry (`Act`, `OK`, `Fail`, `Last`) and also parses common `x-ratelimit-*` / `ratelimit-*` headers if present.
 

package/package.json

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

package/src/account-manager.js

@@ -83,6 +83,20 @@ const DEFAULT_SCHEDULER = {
   // makes this safe even if Anthropic ever account-binds signatures — a rejected
   // replay self-heals to the issuer instead of poisoning the session.
   crossAccountThinkingMigration: true,
+  // Cross-PROVIDER fallback policy for 'cc all' (profile=all), i.e. whether a session
+  // may be served by a provider FAMILY other than its home (Claude ↔ GLM ↔ Kimi).
+  //   'never'         — strict pin: a Claude session uses Claude only; a GLM session
+  //                     uses GLM only; a Kimi session uses Kimi only.
+  //   'when-exhausted'— (default) home family preferred; a Claude session falls back
+  //                     to GLM/Kimi only once all Claude accounts are unavailable
+  //                     (providers are already lower-priority fallback), and a GLM
+  //                     session may fall to Kimi once GLM is exhausted.
+  //   'always'        — providers peer with Claude for a Claude/unknown session
+  //                     (load-balanced, not last-resort).
+  // INVARIANT (all policies): a GLM/Kimi-origin session NEVER routes to an Anthropic
+  // account — Anthropic 400s on a non-`srvtoolu_` server_tool_use id; that direction
+  // is unfixable, not policy-tunable.
+  crossProviderFallbackPolicy: 'when-exhausted',
 };
 const LOAD_EVENT_MAX_AGE_MS = 60 * 60 * 1000;
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
@@ -1020,6 +1034,10 @@ export class AccountManager {
   _migrationSafeForRequest(requestInfo = {}) {
     // Fail closed on any body we couldn't fully scan (non-JSON / parse error).
     if (requestInfo.bodyThinkingScanned !== true) return false;
+    // A foreign (GLM/Kimi) session is provider-pinned; the only cross it could make
+    // is GLM↔Kimi, whose mismatched thinking formats risk a reasoning-loop — keep it
+    // on its bound provider rather than rebalancing.
+    if (this._effectiveOrigin(requestInfo).class === 'foreign') return false;
     // A signed-thinking request is migration-safe when cross-account thinking
     // migration is enabled: the signature is content/model integrity, not account-
     // bound, and the rebalance candidate filter (_matchesRequest → _isRequestCompatible)
@@ -1266,7 +1284,7 @@ export class AccountManager {
         if (!this._matchesRequest(account, profile, requestInfo)) continue;
         if (!this._isAvailable(account, { ...weeklyOptions, model: requestInfo.model })) continue;
 
-        const priority = Number.isFinite(account.priority) ? account.priority : 0;
+        const priority = this._effectivePriority(account, requestInfo);
         const score = this._scoreAccount(account, requestInfo, scoringCtx);
         if (priority < bestPriority || (priority === bestPriority && score < bestScore)) {
           bestPriority = priority;
@@ -1461,15 +1479,107 @@ export class AccountManager {
     return true;
   }
 
+  _crossProviderFallbackPolicy() {
+    const p = this.scheduler.crossProviderFallbackPolicy;
+    return (p === 'never' || p === 'always') ? p : 'when-exhausted';
+  }
+
+  // Selection priority with the 'always' cross-provider policy applied: a provider
+  // account peers with oauth (priority 0) for an Anthropic/unknown session so a
+  // Claude session load-balances across Claude+GLM+Kimi rather than using providers
+  // only as last-resort. 'never'/'when-exhausted' keep the provider's own priority
+  // (10/20) → fallback-only. A foreign session is provider-only regardless.
+  _effectivePriority(account, requestInfo = {}) {
+    const base = Number.isFinite(account.priority) ? account.priority : 0;
+    if (account.type === 'provider'
+        && this._crossProviderFallbackPolicy() === 'always'
+        && this._effectiveOrigin(requestInfo).class !== 'foreign') {
+      return 0;
+    }
+    return base;
+  }
+
+  setCrossProviderFallbackPolicy(policy) {
+    if (!['never', 'when-exhausted', 'always'].includes(policy)) return false;
+    this.scheduler.crossProviderFallbackPolicy = policy;
+    console.log(`[Maxpool] Cross-provider fallback policy set to "${policy}"`);
+    return true;
+  }
+
+  // Effective home-provider origin for a request: the request's own transcript
+  // classification, OR a sticky 'foreign' latch on the session (which never
+  // downgrades — once a GLM/Kimi tool-use id is seen, later no-tool follow-up turns
+  // of that session stay provider-pinned). Both the selector AND the retry oracle
+  // read this so they never disagree (foreign-barred here == foreign-barred there).
+  _effectiveOrigin(requestInfo = {}) {
+    const sticky = requestInfo.sessionKey ? this.sessionPolicies.get(requestInfo.sessionKey) : null;
+    if (sticky?.originClass === 'foreign') {
+      return { class: 'foreign', provider: sticky.originProvider || requestInfo.originProvider || null };
+    }
+    if (requestInfo.originClass === 'foreign') {
+      return { class: 'foreign', provider: requestInfo.originProvider || null };
+    }
+    return {
+      class: requestInfo.originClass || sticky?.originClass || null,
+      provider: requestInfo.originProvider || sticky?.originProvider || null,
+    };
+  }
+
   _isRequestCompatible(account, profile, requestInfo = {}) {
     if (!this._matchesProfile(account, profile)) return false;
-    if (account.type === 'provider' && this._requiresAnthropicThinkingIntegrity(requestInfo)) return false;
+
+    const origin = this._effectiveOrigin(requestInfo);
+
+    if (origin.class === 'foreign') {
+      // HARD, policy-INDEPENDENT: a GLM/Kimi transcript can never replay to an
+      // Anthropic account (400 on the non-`srvtoolu_` id). Provider accounts only.
+      // This branch also SUPERSEDES the Anthropic-thinking bar below — a foreign
+      // session's (unsigned) thinking must go BACK to its provider, never be
+      // force-pinned to Claude (the misroute that caused the reported 400).
+      if (account.type !== 'provider') return false;
+      // 'never' pins to the ORIGIN provider family when known (GLM→GLM, Kimi→Kimi).
+      // 'when-exhausted'/'always' let the sibling provider serve too (priority 10<20
+      // keeps it a fallback). Unknown origin provider ⇒ any provider allowed.
+      if (this._crossProviderFallbackPolicy() === 'never'
+          && origin.provider && account.provider !== origin.provider) return false;
+      return true;
+    }
+
+    // Anthropic-origin or unknown: oauth (Claude) is always eligible. Provider
+    // fallback (Claude→GLM/Kimi, the SAFE direction) is policy-gated and still
+    // barred for signed thinking (an Anthropic signature can't be validated by a
+    // provider). 'never' = Claude session uses Claude only.
+    if (account.type === 'provider') {
+      if (this._crossProviderFallbackPolicy() === 'never') return false;
+      if (this._requiresAnthropicThinkingIntegrity(requestInfo)) return false;
+    }
     return true;
   }
 
   _noteRequestPolicy(requestInfo = {}) {
-    if (!requestInfo.sessionKey || !requestInfo.requiresAnthropicThinkingIntegrity) return;
-    this.markSessionThinkingProtected(requestInfo.sessionKey, requestInfo.model);
+    if (!requestInfo.sessionKey) return;
+    if (requestInfo.requiresAnthropicThinkingIntegrity) {
+      this.markSessionThinkingProtected(requestInfo.sessionKey, requestInfo.model);
+    }
+    if (requestInfo.originClass === 'foreign') {
+      this.markSessionOrigin(requestInfo.sessionKey, 'foreign', requestInfo.originProvider);
+    }
+  }
+
+  // Latch a session's foreign (GLM/Kimi) origin. Only 'foreign' is sticky — an
+  // Anthropic classification never bars anything, and never-downgrade keeps a
+  // provider-pinned session correct across a later no-tool follow-up turn.
+  markSessionOrigin(sessionKey, originClass, originProvider = null) {
+    if (!sessionKey || originClass !== 'foreign') return;
+    const existing = this.sessionPolicies.get(sessionKey) || {};
+    if (existing.originClass !== 'foreign') {
+      console.log(`[Maxpool] Session "${sessionKey}" is ${originProvider || 'provider'}-origin (foreign transcript) — pinned to provider accounts`);
+    }
+    this.sessionPolicies.set(sessionKey, {
+      ...existing,
+      originClass: 'foreign',
+      originProvider: existing.originProvider || originProvider || null,
+    });
   }
 
   markSessionThinkingProtected(sessionKey, model = null) {
@@ -2236,6 +2346,7 @@ export class AccountManager {
       routing: {
         mode: this.routingMode,
         preferredAccount: this.preferredAccountName,
+        crossProviderFallbackPolicy: this._crossProviderFallbackPolicy(),
       },
       accounts: this.accounts.map(a => ({
         name: a.name,
@@ -2305,6 +2416,7 @@ export class AccountManager {
       sessions: {
         stickyBindings: this.sessionBindings.size,
         thinkingProtected: [...this.sessionPolicies.values()].filter(p => p.requiresAnthropicThinkingIntegrity).length,
+        foreignPinned: [...this.sessionPolicies.values()].filter(p => p.originClass === 'foreign').length,
       },
     };
   }

package/src/config.js

@@ -91,6 +91,17 @@ export function createDefaultConfig() {
       weeklyReserveThreshold: 0.85,
       weeklyCriticalThreshold: 0.95,
       weeklyExhaustedThreshold: 0.985,
+      // Cross-PROVIDER fallback policy for 'cc all' (profile=all): whether a session
+      // may be served by a provider family other than its home (Claude ↔ GLM ↔ Kimi).
+      //   'never'         — strict pin (Claude→Claude, GLM→GLM, Kimi→Kimi).
+      //   'when-exhausted'— (default) home family preferred; cross only once it's
+      //                     exhausted (a Claude session falls to GLM/Kimi when all
+      //                     Claude accounts are unavailable).
+      //   'always'        — providers peer with Claude for a Claude/unknown session.
+      // A GLM/Kimi-origin session NEVER routes to Anthropic under ANY policy — that
+      // direction 400s on the non-`srvtoolu_` tool-use id and is unfixable. Toggle
+      // live in the TUI (Routing sub-mode, 'f' key).
+      crossProviderFallbackPolicy: 'when-exhausted',
     },
     retry: {
       maxAttemptsPerRequest: 0,

package/src/index.js

@@ -850,6 +850,16 @@ async function serverWorkerCommand() {
           mode: config.routing?.mode || 'automatic',
           preferredAccount: config.routing?.preferredAccount || null,
         };
+        // Persist live-toggled scheduler policy (e.g. the cross-provider fallback
+        // policy cycled with the TUI 'f' key). Without this, the toggle takes effect
+        // in memory but silently reverts on the next config write / restart. Merge
+        // onto the existing disk scheduler block so other scheduler keys survive.
+        if (config.scheduler?.crossProviderFallbackPolicy) {
+          diskConfig.scheduler = {
+            ...diskConfig.scheduler,
+            crossProviderFallbackPolicy: config.scheduler.crossProviderFallbackPolicy,
+          };
+        }
         // Write in-memory accounts as the authoritative state, preserving
         // extra disk-only fields (e.g. importFrom) where the account still exists.
         // Use live tokens from AccountManager (not the stale config.accounts copy).

package/src/server.js

@@ -987,6 +987,17 @@ function computeQueueWindowMs({
 }
 
 function unavailableMessage(accountManager, requestInfo = {}, retryAfter, willRecoverSoon = true) {
+  const origin = accountManager._effectiveOrigin?.(requestInfo) || { class: null, provider: null };
+
+  // A foreign (GLM/Kimi)-origin session is pinned to provider accounts — Anthropic
+  // would 400 on its tool-use ids. "All Claude at limit" would be the wrong story
+  // (the Claude accounts are irrelevant to it); say what actually blocks it.
+  if (origin.class === 'foreign') {
+    const fam = origin.provider === 'zai' ? 'GLM' : origin.provider === 'kimi' ? 'Kimi' : 'GLM/Kimi';
+    const eta = Number.isFinite(retryAfter) && retryAfter > 0 ? ` Retry in ${retryAfter}s.` : '';
+    return `This session started on ${fam}, so only GLM/Kimi can serve it (a GLM/Kimi transcript can't run on Claude — Anthropic rejects its tool-call ids). No GLM/Kimi provider is available right now.${eta} Check the x-maxpool-zai-token / x-maxpool-kimi-token headers, or resume this session with 'cc glm'/'cc kimi'.`;
+  }
+
   const thinking = requestInfo.requiresAnthropicThinkingIntegrity
     || accountManager._requiresAnthropicThinkingIntegrity?.(requestInfo);
   const n = accountManager.accounts.length;
@@ -1010,7 +1021,7 @@ function unavailableMessage(accountManager, requestInfo = {}, retryAfter, willRe
   return `All ${n} accounts exhausted. Retry in ${retryAfter}s.`;
 }
 
-export const __serverTest = { unavailableMessage, computeQueueWindowMs, isRetriableUpstreamStatus, headerValue, getMaxpoolProfile, ensureQueueHeartbeat, clearQueueHeartbeat, describeRequest, classifyRateLimit };
+export const __serverTest = { unavailableMessage, computeQueueWindowMs, isRetriableUpstreamStatus, headerValue, getMaxpoolProfile, ensureQueueHeartbeat, clearQueueHeartbeat, describeRequest, classifyRateLimit, detectTranscriptOrigin };
 
 async function readErrorBody(upstreamRes, limitBytes = 64 * 1024) {
   if (!upstreamRes.body) return '';
@@ -1478,6 +1489,15 @@ function describeRequest(req, body) {
     // rebalancing); an unparsed body leaves this false → treated as NOT safe
     // (fail-closed) so we never replay a signed thinking block to a new account.
     info.bodyThinkingScanned = true;
+    // Home-provider origin of the resumed transcript (from tool-use id shapes).
+    // A 'foreign' (GLM/Kimi) session can NEVER be replayed to an Anthropic account
+    // (Anthropic 400s on a non-srvtoolu_ server_tool_use id) — routing pins it to
+    // provider accounts. A missing originClass = no tool blocks yet (ambiguous) OR
+    // an unparsed body; both fail OPEN in routing (never stranded), and stickiness
+    // (once a foreign id is seen) keeps a latched session pinned regardless.
+    const origin = detectTranscriptOrigin(json);
+    if (origin.class) info.originClass = origin.class;
+    if (origin.provider) info.originProvider = origin.provider;
   } catch {
     // Non-JSON requests are rare; body size still gives a useful load signal.
   }
@@ -1491,6 +1511,47 @@ function requiresAnthropicThinkingIntegrity(json) {
   return containsThinkingBlock(json.messages);
 }
 
+// Anthropic tool-use ids: client tool_use is 'toolu_…', server_tool_use is 'srvtoolu_…'
+// (the latter is REQUIRED — Anthropic 400s on replay of any other shape). GLM (z.ai)
+// emits OpenAI-style 'call_…'; Kimi (moonshot) emits 'tool_…'. Allowlist, not denylist:
+// anything NOT matching this is treated as foreign (fail-closed classification).
+const ANTHROPIC_TOOL_ID = /^(toolu|srvtoolu)_/;
+
+// Classify a resumed transcript's HOME PROVIDER from the tool-use id shapes in its
+// replayed `messages`. Returns { class: 'foreign' | 'anthropic' | null, provider:
+// 'zai' | 'kimi' | null }. ANY non-Anthropic tool-use / server_tool_use / tool_result
+// id ⇒ 'foreign' (that session can never be replayed to Anthropic). 'anthropic' if
+// only Anthropic ids seen; null if no tool blocks at all (ambiguous — a fresh session
+// with no incompatible history yet). The request MODEL is NOT used — Claude Code
+// rewrites it to claude-opus-4-8 on resume, so only the transcript is trustworthy.
+function detectTranscriptOrigin(json) {
+  if (!json || typeof json !== 'object') return { class: null, provider: null };
+  let sawAnthropic = false;
+  let foreignProvider = null; // 'zai' | 'kimi' | 'foreign'
+  const classifyForeign = id =>
+    id.startsWith('call_') ? 'zai' : id.startsWith('tool_') ? 'kimi' : 'foreign';
+  const visit = value => {
+    if (foreignProvider) return; // one foreign id is decisive — early-exit the walk
+    if (Array.isArray(value)) { for (const v of value) { visit(v); if (foreignProvider) return; } return; }
+    if (!value || typeof value !== 'object') return;
+    const t = value.type;
+    if ((t === 'tool_use' || t === 'server_tool_use') && typeof value.id === 'string') {
+      if (ANTHROPIC_TOOL_ID.test(value.id)) sawAnthropic = true;
+      else { foreignProvider = classifyForeign(value.id); return; }
+    }
+    if (t === 'tool_result' && typeof value.tool_use_id === 'string') {
+      if (ANTHROPIC_TOOL_ID.test(value.tool_use_id)) sawAnthropic = true;
+      else { foreignProvider = classifyForeign(value.tool_use_id); return; }
+    }
+    if (value.content) visit(value.content);
+    if (value.messages) visit(value.messages);
+  };
+  visit(json.messages);
+  if (foreignProvider) return { class: 'foreign', provider: foreignProvider === 'foreign' ? null : foreignProvider };
+  if (sawAnthropic) return { class: 'anthropic', provider: null };
+  return { class: null, provider: null };
+}
+
 function containsThinkingBlock(value) {
   if (!value) return false;
   if (Array.isArray(value)) return value.some(containsThinkingBlock);

package/src/tui.js

@@ -415,11 +415,25 @@ export class TUI {
       );
     } else if (k === 'p' && this.am.accounts.some(account => account.type !== 'provider')) {
       this._startSelection('prefer');
+    } else if (k === 'f') {
+      // Cycle the cross-provider fallback policy in place — reversible + non-destructive,
+      // so no confirm dialog (unlike restart/delete).
+      this._cycleCrossProviderPolicy();
     } else if (k === 'esc' || k === 'q') {
       this.mode = 'normal';
     }
   }
 
+  async _cycleCrossProviderPolicy() {
+    const order = ['never', 'when-exhausted', 'always'];
+    const cur = this.am._crossProviderFallbackPolicy();
+    const next = order[(order.indexOf(cur) + 1) % order.length];
+    this.am.setCrossProviderFallbackPolicy(next);
+    this.config.scheduler = { ...(this.config.scheduler || {}), crossProviderFallbackPolicy: next };
+    await this.saveConfig(this.config);
+    this._addLog(`Cross-provider fallback: ${next}`);
+  }
+
   _keySelect(k) {
     const selectable = this._selectableIndexes(this.selAction);
     const position = Math.max(0, selectable.indexOf(this.selIdx));
@@ -820,7 +834,17 @@ export class TUI {
     const routing = this.am.routingMode === 'preferred'
       ? `Manual preference: ${this.am.preferredAccountName} (automatic failover)`
       : 'Automatic load balancing';
-    lines.push(` Routing  ${cyan(routing)}`);
+    // Cross-provider fallback policy — only meaningful when GLM/Kimi providers are in
+    // the pool (profile=all). never=strict pin (yellow), when-exhausted=default (cyan),
+    // always=peer (green).
+    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}`;
+    }
+    lines.push(` Routing  ${cyan(routing)}${xpText}`);
     const queuedCount = this.am.queueState?.waiting?.length || 0;
     if (this.am._isUpstreamThrottleBlocking?.() || queuedCount) {
       const throttle = this.am.upstreamThrottle;
@@ -1034,7 +1058,7 @@ export class TUI {
       case 'accounts':
         return ` ${bold('l')} Login (browser)  ${bold('k')} API key  ${bold('n')} Rename  ${bold('t')} Enable/disable  ${bold('d')} Delete  ${bold('Esc')} Back`;
       case 'routing':
-        return ` ${bold('a')} Automatic  ${bold('p')} Manual preference  ${bold('Esc')} Back`;
+        return ` ${bold('a')} Automatic  ${bold('p')} Manual preference  ${bold('f')} Cross-provider fallback  ${bold('Esc')} Back`;
       case 'select': {
         const act = this.selAction === 'prefer'
           ? 'prefer'