maxpool 1.19.0 → 1.19.2

package/package.json

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

@@ -1355,8 +1355,16 @@ async function forwardRequest(
           res.end();
         }
       } else {
-        if (!res.headersSent) res.writeHead(upstreamRes.status, responseHeaders);
-        res.end(buf);
+        // MODEL ECHO: rewrite the provider's model id back to the client's before the
+        // body reaches Claude Code. Computed BEFORE writeHead so a length change lands
+        // in the SAME header block — setting content-length after writeHead is a no-op
+        // and would ship a body/length mismatch (the client then hangs or truncates).
+        const outBuf = normalizeModelEcho(buf, requestInfo.model);
+        const outHeaders = outBuf === buf
+          ? responseHeaders
+          : { ...responseHeaders, 'content-length': String(outBuf.length) };
+        if (!res.headersSent) res.writeHead(upstreamRes.status, outHeaders);
+        res.end(outBuf);
       }
     }
   } catch (err) {
@@ -1657,7 +1665,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 = { 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 };
+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 };
 
 async function readErrorBody(upstreamRes, limitBytes = 64 * 1024) {
   if (!upstreamRes.body) return '';
@@ -2856,6 +2864,41 @@ function startIdleRequestReaper(res, reqId, idleMs, { now = Date.now, setInterva
   return timer;
 }
 
+
+/** Rewrite a non-streaming JSON body's `model` back to the CLIENT'S requested model.
+ *  Twin of the SSE model-echo normalization in streamResponse: provider upstreams
+ *  (z.ai/GLM, Kimi) echo their own id, Claude Code persists it, and a resumed session
+ *  then prints "Session model glm-5.3 could not be restored". The streaming half
+ *  shipped in v1.19.1; this covers the buffered path, which is where the remaining
+ *  5,719 contaminated turns came from (measured 2026-09-02). No-op when the ids
+ *  already match, when the body is not JSON, or when no client model is known. */
+function normalizeModelEcho(buf, clientModel) {
+  if (!clientModel || !buf?.length) return buf;
+  try {
+    const json = JSON.parse(buf.toString('utf8'));
+    if (!json || typeof json !== 'object' || typeof json.model !== 'string') return buf;
+    if (json.model === clientModel) return buf;
+    json.model = clientModel;
+    return Buffer.from(JSON.stringify(json), 'utf8');
+  } catch {
+    return buf;  // non-JSON (or truncated) body — forward untouched
+  }
+}
+
+function concatUint8(chunks) {
+  let n = 0;
+  for (const c of chunks) n += c.length;
+  const out = new Uint8Array(n);
+  let o = 0;
+  for (const c of chunks) { out.set(c, o); o += c.length; }
+  return out;
+}
+function totalLen(chunks) {
+  let n = 0;
+  for (const c of chunks) n += c.length;
+  return n;
+}
+
 async function streamResponse(webStream, res, status, responseHeaders, accountIndex, accountManager, streamLog, requestInfo = {}, idleMs = STREAM_IDLE_MS) {
   const reader = webStream.getReader();
   const decoder = new TextDecoder();
@@ -2880,6 +2923,10 @@ async function streamResponse(webStream, res, status, responseHeaders, accountIn
   const onClose = () => { reader.cancel().catch(() => {}); };
   res.once('close', onClose);
 
+  // MODEL ECHO NORMALIZATION state (rationale at the write site).
+  let modelEchoPending = true;
+  let modelEchoBuffer = null;
+
   try {
     while (true) {
       // Idle guard: a half-open upstream (headers, then silence, never closes) would
@@ -2915,10 +2962,44 @@ async function streamResponse(webStream, res, status, responseHeaders, accountIn
         committed = true;
       }
 
+      // MODEL ECHO NORMALIZATION (2026-08-31): provider upstreams echo their own model
+      // id ("glm-5.3", kimi-*) in message_start, and Claude Code persists that id into
+      // the session transcript — on resume the id fails model-family resolution and the
+      // session prints "Session model ... could not be restored (not a model this
+      // version of Claude Code recognizes)" (278 sessions affected, measured).
+      // Rewrite the model field back to the CLIENT'S requested model (requestInfo.model,
+      // captured before the per-account rewrite) inside the first complete SSE event
+      // carrying a "model" key; afterwards chunks pass through untouched. ReadableStream
+      // chunks are Uint8Array — Buffer.concat/toString would yield comma-joined byte
+      // numbers (caught by the normalization tests), so hold an array of chunks and
+      // concat with decoder-safe helpers.
+      let out = value;
+      if (requestInfo?.model && modelEchoPending) {
+        modelEchoBuffer = modelEchoBuffer ? [...modelEchoBuffer, value] : [value];
+        const s = decoder.decode(concatUint8(modelEchoBuffer));
+        if (s.includes('"model"') && s.includes('\n\n')) {
+          const normalized = s.replace(
+            /("model":")[^"]+(")/,
+            `$1${requestInfo.model.replace(/["\\]/g, '\\$&')}$2`,
+          );
+          out = Buffer.from(normalized, 'utf8');
+          modelEchoBuffer = null;
+          modelEchoPending = false;
+        } else if (totalLen(modelEchoBuffer) > 64 * 1024) {
+          // Pathological upstream: 64KB with no complete model-bearing event. Flush
+          // verbatim — the warning is the worst outcome of a missed rewrite.
+          out = Buffer.from(concatUint8(modelEchoBuffer));
+          modelEchoBuffer = null;
+          modelEchoPending = false;
+        } else {
+          continue; // hold until the model-bearing event is complete
+        }
+      }
+
       // Forward chunk immediately
-      const ok = res.write(value);
+      const ok = res.write(out);
 
-      const text = decoder.decode(value, { stream: true });
+      const text = decoder.decode(out, { stream: true });
 
       // Capture for logging
       if (streamLog) streamLog.push(text);
@@ -2974,6 +3055,25 @@ async function streamResponse(webStream, res, status, responseHeaders, accountIn
     readFailed = true;
     throw err;
   } finally {
+    // MODEL ECHO NORMALIZATION last-resort flush: the read loop can exit via done,
+    // error, or client disconnect while chunks are still HELD for the rewrite.
+    // Whatever the exit path, deliver the held bytes and accrue their usage — a
+    // mid-flight death must not swallow delivered tokens (H4) nor truncate the
+    // body (empty '' responses, C1).
+    if (modelEchoBuffer) {
+      const held = Buffer.from(concatUint8(modelEchoBuffer));
+      modelEchoBuffer = null;
+      try {
+        if (!readFailed && !res.destroyed) res.write(held);
+      } catch { /* client already gone */ }
+      const heldText = held.toString('utf8');
+      if (streamLog) streamLog.push(heldText);
+      sseBuffer += heldText;
+      for (const ev of sseBuffer.split('\n\n')) {
+        if (ev.trim()) parseSSEEvent(ev, accountIndex, accountManager, requestInfo);
+      }
+      sseBuffer = '';
+    }
     res.off('close', onClose);
     // Cancel upstream reader to stop consuming data nobody needs
     reader.cancel().catch(() => {});