maxpool 1.24.15 → 1.24.17

package/package.json

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

@@ -4375,8 +4375,12 @@ export class AccountManager {
     const configTokens = new Set(
       entries.map(e => e.token).filter(Boolean),
     );
+    // Same rule for a provider KIND config already covers: a header-derived fallback
+    // of that kind is a duplicate login even when its token differs (a pre-rotation key).
+    const configKinds = new Set(entries.filter(e => e.token).map(e => e.provider).filter(Boolean));
     for (const a of [...this.accounts]) {
-      if (!a.configSourced && a.type === 'provider' && a.credential && configTokens.has(a.credential)) {
+      if (!a.configSourced && a.type === 'provider' && a.credential
+          && (configTokens.has(a.credential) || (a.runtime && configKinds.has(a.provider)))) {
         const idx = this.accounts.indexOf(a);
         if (idx >= 0 && this.accounts[idx].inFlight === 0) this.removeAccount(idx);
       }

package/src/index.js

@@ -777,6 +777,15 @@ async function serverWorkerCommand() {
       }, 5 * 60_000);
       secretTimer.unref?.();
     }
+    // Key rotation: a new secret version reaches the live pool within 30 min.
+    const { refreshRotatedProviders } = await import('./secret-resolver.js');
+    const rotateTimer = setInterval(async () => {
+      try {
+        const n = await refreshRotatedProviders(accountManager.accounts);
+        if (n) console.log(`[Maxpool] Key rotation: ${n} provider key(s) updated from Secret Manager`);
+      } catch { /* next tick */ }
+    }, 30 * 60_000);
+    rotateTimer.unref?.();
   }
 
   // Seed the running version immediately so the TUI header always shows it, even

package/src/secret-resolver.js

@@ -199,6 +199,28 @@ export function pendingProviders(accounts) {
   return accounts.filter(a => a.configSourced && a.type === 'provider' && a.secretName && !a.credential);
 }
 
+/**
+ * Pick up ROTATED keys. A key resolves once at startup, so a new secret version (a
+ * key swap in Secret Manager) stayed invisible until the next restart — the pool kept
+ * calling with the old key (2026-10-09: all six z.ai keys moved to the account's
+ * "zcode-api-key", which is the only key z.ai issues reset cards for). Re-reads every
+ * loaded provider's secret, bypassing the local cache, and swaps `credential` when the
+ * value changed. A failed read keeps the current key. Returns the number swapped.
+ */
+export async function refreshRotatedProviders(accounts, resolve = (names) => resolveSecrets(names, { useCache: false })) {
+  const loaded = accounts.filter(a => a.configSourced && a.type === 'provider' && a.secretName && a.credential);
+  if (!loaded.length) return 0;
+  const resolved = await resolve([...new Set(loaded.map(a => a.secretName))]);
+  let swapped = 0;
+  for (const a of loaded) {
+    const tok = resolved[a.secretName];
+    if (!tok || tok === a.credential) continue;
+    a.credential = tok;
+    swapped++;
+  }
+  return swapped;
+}
+
 export async function reresolveProviders(accounts, resolve = resolveSecrets) {
   const pending = pendingProviders(accounts);
   if (!pending.length) return 0;

package/src/server.js

@@ -1709,7 +1709,7 @@ function formatRetryDuration(seconds) {
 function computeQueueWindowMs({
   cause, stream, retryPlanCause,
   maxWaitMs, capacityMaxWaitMs, nonStreamMaxWaitMs, streamHoldMaxMs, streamClientToleranceMs,
-  isCountTokens, countTokensMaxWaitMs, networkMaxWaitMs,
+  isCountTokens, countTokensMaxWaitMs,
 }) {
   let windowMs;
   if (!stream) {
@@ -2649,9 +2649,6 @@ async function queueAndRetry(
   const streamClientToleranceMs = Number.isFinite(requestInfo.clientToleranceMs)
     ? requestInfo.clientToleranceMs
     : Math.max(0, Number(queueConfig.streamClientToleranceMs) || 0);
-  const networkMaxWaitMs = queueConfig.networkMaxWaitMs == null
-    ? 2 * 60 * 1000
-    : Math.max(0, Number(queueConfig.networkMaxWaitMs) || 0);
   const queueWindowMs = computeQueueWindowMs({
     cause,
     stream: Boolean(requestInfo.stream),
@@ -2659,7 +2656,6 @@ async function queueAndRetry(
     maxWaitMs,
     capacityMaxWaitMs,
     nonStreamMaxWaitMs,
-    networkMaxWaitMs,
     streamHoldMaxMs,
     streamClientToleranceMs,
     isCountTokens: Boolean(requestInfo.isCountTokens),
@@ -3019,9 +3015,29 @@ function prepareRuntimeProviders(accountManager, headers) {
       .filter(a => a.configSourced && a.credential)
       .map(a => a.credential),
   );
+  // THE PROXY OWNS THE KEYS (2026-10-10). When config already manages accounts of a
+  // provider kind, a session-supplied key for that kind is ignored outright. Dedup by
+  // token alone was not enough: a session launched before a key rotation keeps sending
+  // the OLD key for its whole life, and it surfaced as a duplicate "glm-fallback"
+  // account for the same z.ai login (1,578 requests on the old key in 2 days).
+  // A kind counts as proxy-managed only while at least one of its config accounts
+  // HOLDS a key: if every one is unresolved (the secret-unresolved outages of
+  // 2026-10-05/08) the session key still stands in as the safety net.
+  const configKinds = new Set(
+    (accountManager.accounts || []).filter(a => a.configSourced && a.credential).map(a => a.provider),
+  );
+  // Self-clean: a fallback created before the config keys loaded (or restored from
+  // state) is dropped as soon as it is idle — no restart, no waiting for old sessions.
+  // (removeAccount itself refuses an account with a request in flight.)
+  for (const a of [...(accountManager.accounts || [])]) {
+    if (a.runtime && !a.configSourced && a.type === 'provider' && configKinds.has(a.provider)
+        && accountManager.removeAccount(accountManager.accounts.indexOf(a))) {
+      console.log(`[Maxpool] Dropped session-supplied "${a.name}" — ${a.provider} keys are managed by the pool config`);
+    }
+  }
 
   const zaiToken = headerValue(headers, 'x-maxpool-zai-token');
-  if (zaiToken && !configTokens.has(zaiToken)) {
+  if (zaiToken && !configKinds.has('zai') && !configTokens.has(zaiToken)) {
     const opus = headerValue(headers, 'x-maxpool-zai-opus-model') || headerValue(headers, 'x-maxpool-zai-model') || 'glm-5.3';
     const sonnet = headerValue(headers, 'x-maxpool-zai-sonnet-model') || headerValue(headers, 'x-maxpool-zai-model') || opus;
     const haiku = headerValue(headers, 'x-maxpool-zai-haiku-model') || 'glm-5.3';
@@ -3040,7 +3056,7 @@ function prepareRuntimeProviders(accountManager, headers) {
   }
 
   const kimiToken = headerValue(headers, 'x-maxpool-kimi-token');
-  if (kimiToken && !configTokens.has(kimiToken)) {
+  if (kimiToken && !configKinds.has('kimi') && !configTokens.has(kimiToken)) {
     // Fallback only — `cc all` always sends x-maxpool-kimi-model from the llm_config SSOT,
     // so this is what a bare/older client gets. Kept current deliberately: it read
     // 'kimi-k2.7' while the fleet had moved to k3.
@@ -3656,3 +3672,6 @@ function computeRetryAfter(accountManager, requestInfo = {}) {
   const ms = accountManager.nextRetryForRequest?.(requestInfo, new Set())?.retryAfterMs ?? Infinity;
   return ms === Infinity ? 60 : Math.max(1, Math.ceil(ms / 1000));
 }
+
+// Test seam: prepareRuntimeProviders with a plain headers object.
+export const __test = { prepareRuntimeProviders };