billion-context 0.1.88 → 0.1.89

package/dist/index.js

@@ -47935,6 +47935,19 @@ function detectRoleRejection(status, bodyText) {
   }
   return null;
 }
+function detectSystemPlacementError(status, bodyText) {
+  if (status !== 400) return false;
+  const head = bodyText.slice(0, 4096);
+  if (!/system/i.test(head)) return false;
+  const norm = head.replace(/['"`[\](){}]/g, " ");
+  const PLACEMENT_MARKERS = [
+    /\b(multiple|more\s+than\s+one|exactly\s+one|only\s+one|single|another|second|third)\s+system/i,
+    /\b[2-9]\d*\s+system\s+messages?\b/i,
+    /system\s+messages?\b[^.\n]{0,50}\bindex\s*\d+\b/i,
+    /(system\s+messages?|system\s+roles?)\b[^.\n]{0,50}\b(beginning|start|front|first\s+message|must\s+be\s+first)/i
+  ];
+  return PLACEMENT_MARKERS.some((re2) => re2.test(norm));
+}
 function applyCompatRoles(body, protocol, roles) {
   if (Object.keys(roles).length === 0) return { body, rewritten: 0 };
   let parsed;
@@ -51147,6 +51160,11 @@ function estimateRawBodyTokens(parsed) {
   walk(parsed);
   return tokens;
 }
+function estimateCoreMessagesUpper(messages) {
+  let chars = 0;
+  for (const m2 of messages) chars += (m2.text ?? "").length;
+  return chars;
+}
 function rangeChars2(messages, startIdx, endIdx) {
   let chars = 0;
   for (let i = startIdx; i <= endIdx && i < messages.length; i++) {
@@ -51166,16 +51184,16 @@ ${text}`);
   }
   return parts.join("\n\n");
 }
-function splitChunks(messages, startIdx, endIdx, budgetTokens) {
+function splitChunks(messages, startIdx, endIdx, budget, minUnits, countText = defaultCountTokens) {
   const chunks = [];
   let cur = startIdx;
   while (cur <= endIdx) {
-    let tokens = 0;
+    let total = 0;
     let last = cur;
     for (let i = cur; i <= endIdx; i++) {
-      const t = defaultCountTokens(messages[i].text ?? "");
-      if (tokens + t > budgetTokens && i > cur) break;
-      tokens += t;
+      const t = countText(messages[i].text ?? "");
+      if (total + t > budget && i > cur && (minUnits <= 0 || total >= minUnits)) break;
+      total += t;
       last = i;
     }
     chunks.push([cur, last]);
@@ -51262,11 +51280,14 @@ function noEmergencyTruncate(config) {
 }
 async function preflightCompress(deps, messages) {
   const limit = deps.config.modelContextLimit;
-  const result = { compressedRanges: 0, savedTokens: 0, payloadEstimate: estimateCoreMessages(messages) + (deps.imageFloor ?? 0) + (deps.wireOverhead ?? 0) };
+  const result = { compressedRanges: 0, savedTokens: 0, payloadEstimate: estimateCoreMessages(messages) + (deps.imageFloor ?? 0) + (deps.wireOverhead ?? 0), fitsWindow: true };
   if (limit <= 0) return result;
   const budget = Math.max(MIN_CHUNK_TOKENS, Math.floor(limit * CHUNK_FRACTION));
   const minChars = deps.config.compress.minCompressRange;
-  let currentTokens = deps.session.stats.lastInputTokens;
+  const baselineKnown = deps.unknownBaseline !== true;
+  const countText = baselineKnown ? defaultCountTokens : (text) => text.length;
+  let currentTokens = baselineKnown ? deps.session.stats.lastInputTokens : estimateCoreMessagesUpper(messages);
+  let finalUpper = baselineKnown ? 0 : estimateCoreMessagesUpper(messages);
   let startTokens = -1;
   let failure;
   let activeConfig = deps.config;
@@ -51290,6 +51311,10 @@ async function preflightCompress(deps, messages) {
     });
     deps.session.state = turn.state;
     currentTokens = Math.max(deps.session.stats.lastInputTokens, estimateCoreMessages(turn.messages) + (deps.imageFloor ?? 0) + (deps.wireOverhead ?? 0));
+    if (!baselineKnown) {
+      finalUpper = estimateCoreMessagesUpper(turn.messages) + (deps.imageFloor ?? 0) + (deps.wireOverhead ?? 0);
+      currentTokens = Math.max(currentTokens, finalUpper);
+    }
     result.payloadEstimate = estimateCoreMessages(turn.messages) + (deps.imageFloor ?? 0) + (deps.wireOverhead ?? 0);
     if (startTokens < 0) startTokens = currentTokens;
     if (currentTokens < limit) break;
@@ -51325,7 +51350,7 @@ async function preflightCompress(deps, messages) {
         continue;
       }
       rangesTried += 1;
-      for (const [cs2, ce2] of splitChunks(messages, startIdx, endIdx, budget)) {
+      for (const [cs2, ce2] of splitChunks(messages, startIdx, endIdx, budget, baselineKnown ? 0 : minChars, countText)) {
         if (currentTokens < limit) break;
         if (deps.signal?.aborted) {
           failure = ABORTED_FAILURE;
@@ -51384,7 +51409,8 @@ async function preflightCompress(deps, messages) {
           break;
         }
         const compressed = deps.session.stats.compressCreditTokens - creditBefore;
-        currentTokens = Math.max(0, currentTokens - compressed + defaultCountTokens(summary));
+        const folded = baselineKnown ? compressed : rangeChars2(messages, cs2, ce2);
+        currentTokens = Math.max(0, currentTokens - folded + countText(summary));
         deps.session.stats.lastInputTokens += defaultCountTokens(summary);
         appliedThisRound += 1;
         result.compressedRanges += 1;
@@ -51409,6 +51435,7 @@ async function preflightCompress(deps, messages) {
   if (result.compressedRanges > 0) deps.session.stats.lastInputTokens = currentTokens;
   result.savedTokens = Math.max(0, startTokens - currentTokens);
   if (currentTokens >= limit) result.failure = failure;
+  result.fitsWindow = baselineKnown ? result.payloadEstimate < limit : finalUpper < limit;
   return result;
 }
 
@@ -52154,17 +52181,65 @@ var MIN_USAGE = 0.9;
 var WINDOW_MS = 15 * 60 * 1e3;
 var MIN_EVENTS = 3;
 var MAX_TRACKED_SESSIONS = 512;
+var RETRACT_MARGIN_PCT = 0.03;
+var RETRACT_MIN_DELTA = 256;
 var states = /* @__PURE__ */ new Map();
-function resolvedWindow2(session) {
+function resolveConfirmedLimit(session, model) {
+  const md = session.metadata ?? {};
+  const map = md.confirmedContextLimits;
+  return (model ? map?.[model] : void 0) ?? md.confirmedContextLimit;
+}
+function resolveSpeculativeLimit(session, model) {
+  const md = session.metadata ?? {};
+  const map = md.learnedContextLimits;
+  return (model ? map?.[model] : void 0) ?? md.learnedContextLimit;
+}
+function resolveLearnedLimit(session, model) {
+  const perModel = model ? resolveConfirmedLimit(session, model) ?? resolveSpeculativeLimit(session, model) : void 0;
+  return perModel ?? resolveConfirmedLimit(session) ?? resolveSpeculativeLimit(session);
+}
+function retractStaleLearnedLimits(session, model) {
+  const x = session.stats?.lastInputTokens ?? 0;
+  if (!(x > 0)) return false;
+  const stale = (v2) => typeof v2 === "number" && v2 > 0 && x - v2 >= Math.max(RETRACT_MIN_DELTA, v2 * RETRACT_MARGIN_PCT);
+  const md = session.metadata ?? {};
+  const removed = [];
+  const cm = md.confirmedContextLimits;
+  const lm = md.learnedContextLimits;
+  if (model) {
+    if (cm && stale(cm[model])) {
+      removed.push(`confirmed ${cm[model]}`);
+      delete cm[model];
+    }
+    if (lm && stale(lm[model])) {
+      removed.push(`learned ${lm[model]}`);
+      delete lm[model];
+    }
+  }
+  if (stale(md.confirmedContextLimit)) {
+    removed.push(`confirmed ${String(md.confirmedContextLimit)}`);
+    delete md.confirmedContextLimit;
+  }
+  if (stale(md.learnedContextLimit)) {
+    removed.push(`learned ${String(md.learnedContextLimit)}`);
+    delete md.learnedContextLimit;
+  }
+  if (removed.length === 0) return false;
+  session.metadata = md;
+  log("warn", `[${session.id}] retracted stale context window(s) [${removed.join(", ")}] for ${model ?? "(unknown model)"} \u2014 a later turn succeeded at ${x} input tokens above them; using the configured window again`);
+  markDirty(session);
+  return true;
+}
+function resolvedWindow2(session, model) {
   const md = session.metadata ?? {};
-  const learned = md.learnedContextLimit;
+  const learned = resolveLearnedLimit(session, model);
   const effective = md.effectiveContextLimit;
   const candidates = [learned, effective].filter((v2) => typeof v2 === "number" && v2 > 0);
   if (candidates.length === 0) return 0;
   return Math.min(...candidates);
 }
 function noteWeakOverflow(session, opts) {
-  const window2 = resolvedWindow2(session);
+  const window2 = resolvedWindow2(session, opts.model);
   if (window2 <= 0) return;
   const input = opts.inputTokens && opts.inputTokens > 0 ? opts.inputTokens : session.stats?.lastInputTokens ?? 0;
   if (input <= 0) return;
@@ -52184,20 +52259,26 @@ function noteWeakOverflow(session, opts) {
   }
   states.delete(session.id);
   const md = session.metadata ?? {};
-  if (md.learnedContextLimits === void 0) md.learnedContextLimits = {};
-  const learnedMap = md.learnedContextLimits;
   const reqModel = opts.model;
-  const prev = (reqModel ? learnedMap[reqModel] : void 0) ?? md.learnedContextLimit;
-  if (prev === void 0 || input < prev) {
-    if (reqModel) learnedMap[reqModel] = input;
-    else md.learnedContextLimit = input;
-    session.metadata = md;
-    log("warn", `[${session.id}] weak overflow confirmed (${MIN_EVENTS}\xD7 high-usage failures, ${opts.reason}) \u2014 learned conservative window ${input} for ${reqModel ?? "(unknown model)"} (was ${prev ?? "unset"}); arming emergency shrink`);
+  const confirmed = resolveConfirmedLimit(session, reqModel);
+  const armInput = confirmed !== void 0 && confirmed > 0 ? Math.min(input, confirmed) : input;
+  if (confirmed !== void 0 && confirmed > 0) {
+    log("warn", `[${session.id}] weak overflow confirmed (${MIN_EVENTS}\xD7 high-usage failures, ${opts.reason}) \u2014 confirmed window ${confirmed} governs (failing input ${input}); arming emergency shrink only, learned window untouched`);
   } else {
-    log("warn", `[${session.id}] weak overflow confirmed (${MIN_EVENTS}\xD7 high-usage failures, ${opts.reason}) \u2014 conservative window ${input} not below learned ${prev}; arming emergency shrink only`);
+    if (md.learnedContextLimits === void 0) md.learnedContextLimits = {};
+    const learnedMap = md.learnedContextLimits;
+    const prev = (reqModel ? learnedMap[reqModel] : void 0) ?? md.learnedContextLimit;
+    if (prev === void 0 || input < prev) {
+      if (reqModel) learnedMap[reqModel] = input;
+      else md.learnedContextLimit = input;
+      session.metadata = md;
+      log("warn", `[${session.id}] weak overflow confirmed (${MIN_EVENTS}\xD7 high-usage failures, ${opts.reason}) \u2014 learned conservative window ${input} for ${reqModel ?? "(unknown model)"} (was ${prev ?? "unset"}); arming emergency shrink`);
+    } else {
+      log("warn", `[${session.id}] weak overflow confirmed (${MIN_EVENTS}\xD7 high-usage failures, ${opts.reason}) \u2014 conservative window ${input} not below learned ${prev}; arming emergency shrink only`);
+    }
   }
-  if (!session.stats) session.stats = { lastInputTokens: input };
-  else session.stats.lastInputTokens = Math.max(session.stats.lastInputTokens, input);
+  if (!session.stats) session.stats = { lastInputTokens: armInput };
+  else session.stats.lastInputTokens = Math.max(session.stats.lastInputTokens, armInput);
   markDirty(session);
 }
 
@@ -52310,6 +52391,7 @@ var CONTEXT_OVERFLOW_PATTERNS = [
   /token limit exceeded/i,
   // #554: llama.cpp-family "exceed_context_size_error (A / B > W)" — carried by
   // side requests that bypass preflight; without it the learned channel learns nothing.
+  // #570: its body also carries the real window, see parseOverflowWindow.
   /exceed[_\s]?context[_\s]?size/i
 ];
 function toTokenNumber(s3) {
@@ -53065,15 +53147,17 @@ data: ${JSON.stringify({ type: "response.created", response: { id: createdRespId
         }
       };
       for await (const eventStr of iterSseEvents(upstream)) {
-        const type = extractEventType(eventStr);
+        const explicitType = extractEventType(eventStr);
         const dataLine = extractDataLine(eventStr);
-        if (!type || !dataLine) continue;
+        if (!dataLine) continue;
         let obj;
         try {
           obj = JSON.parse(dataLine);
         } catch {
           continue;
         }
+        const type = explicitType ?? (typeof obj.type === "string" ? obj.type : null);
+        if (!type) continue;
         const rawBuf = Buffer.from(eventStr + "\n\n", "utf8");
         if (round === 1 && typeof obj.output_index === "number") {
           outputIndex = Math.max(outputIndex, obj.output_index + 1);
@@ -53417,6 +53501,23 @@ function stripFinishReasonChunk(buf) {
     return buf;
   }
 }
+function patchUsageChunk(eventStr, parsed, u2, hostCredit) {
+  const pu = typeof u2.prompt_tokens === "number" ? u2.prompt_tokens : void 0;
+  const tu = typeof u2.total_tokens === "number" ? u2.total_tokens : void 0;
+  if (hostCredit > 0 && (pu !== void 0 || tu !== void 0)) {
+    const patched = {
+      ...parsed,
+      usage: {
+        ...u2,
+        ...pu !== void 0 ? { prompt_tokens: pu + hostCredit } : {},
+        ...tu !== void 0 ? { total_tokens: tu + hostCredit } : {}
+      }
+    };
+    const out = eventStr.split("\n").map((l) => l.startsWith("data:") ? `data: ${JSON.stringify(patched)}` : l).join("\n");
+    return Buffer.from(out + "\n\n", "utf8");
+  }
+  return Buffer.from(eventStr + "\n\n", "utf8");
+}
 function createOpenaiAdapter(requestBody, clientSystem, hostCredit = 0) {
   const model = requestBody.model ?? "unknown";
   let responseId = `chatcmpl-proxy-${Date.now()}`;
@@ -53593,6 +53694,9 @@ function createOpenaiAdapter(requestBody, clientSystem, hostCredit = 0) {
               outputTokens: typeof u2.completion_tokens === "number" ? u2.completion_tokens : void 0,
               cachedTokens: typeof pd?.cached_tokens === "number" ? pd.cached_tokens : void 0
             };
+            if (sawRealToolCall) {
+              yield { kind: "meta", chunk: patchUsageChunk(eventStr, parsed, u2, hostCredit) };
+            }
           }
           continue;
         }
@@ -53611,23 +53715,7 @@ function createOpenaiAdapter(requestBody, clientSystem, hostCredit = 0) {
             cachedTokens: typeof pd?.cached_tokens === "number" ? pd.cached_tokens : void 0
           };
           if (sawRealToolCall) {
-            let chunk = rawBuf;
-            if (hostCredit > 0 && u2) {
-              const pu = typeof u2.prompt_tokens === "number" ? u2.prompt_tokens : void 0;
-              const tu = typeof u2.total_tokens === "number" ? u2.total_tokens : void 0;
-              if (pu !== void 0 || tu !== void 0) {
-                const patched = {
-                  ...parsed,
-                  usage: {
-                    ...u2,
-                    ...pu !== void 0 ? { prompt_tokens: pu + hostCredit } : {},
-                    ...tu !== void 0 ? { total_tokens: tu + hostCredit } : {}
-                  }
-                };
-                const out = eventStr.split("\n").map((l) => l.startsWith("data:") ? `data: ${JSON.stringify(patched)}` : l).join("\n");
-                chunk = Buffer.from(out + "\n\n", "utf8");
-              }
-            }
+            const chunk = patchUsageChunk(eventStr, parsed, u2 ?? {}, hostCredit);
             yield { kind: "meta", chunk };
             yield { kind: "done", finishReason, suppressCompletion: true };
             continue;
@@ -54703,6 +54791,35 @@ data: ${JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn"
       safeWrite(res, `event: message_stop
 data: ${JSON.stringify({ type: "message_stop" })}
 
+`);
+    }
+  } catch {
+  } finally {
+    try {
+      res.end();
+    } catch {
+    }
+  }
+}
+function emitPreflightError(res, protocol, error, log2) {
+  const err2 = { type: "server_error", code: "preflight_compress_failed", message: error.message, retryable: error.retryable };
+  log2?.(`[acp-proxy: preflight failed after early response commit \u2014 delivering in-band: ${error.message}]`);
+  try {
+    if (protocol === "openai") {
+      safeWrite(res, `data: ${JSON.stringify({ error: err2 })}
+
+data: [DONE]
+
+`);
+    } else if (protocol === "responses") {
+      safeWrite(res, `event: error
+data: ${JSON.stringify({ type: "error", code: err2.code, message: err2.message })}
+
+`);
+    } else {
+      safeWrite(res, `event: error
+data: ${JSON.stringify({ type: "error", error: { type: "server_error", code: err2.code, message: err2.message } })}
+
 `);
     }
   } catch {
@@ -58239,8 +58356,7 @@ ${bodyBuffer.toString("utf8")}`);
     restoreOutputBudget(parsed, session, log2);
     if (!countTokens && !responsesCompact && protocol !== null && isSideRequest(parsed)) {
       const reqModel2 = parsed.model;
-      const learnedMap2 = session.metadata.learnedContextLimits;
-      const learnedLimit2 = (reqModel2 && learnedMap2 ? learnedMap2[reqModel2] : void 0) ?? session.metadata.learnedContextLimit;
+      const learnedLimit2 = resolveLearnedLimit(session, reqModel2);
       const guard = sideRequestGuard(parsed, protocol, reqConfig.modelContextLimit, learnedLimit2);
       if (guard.blocked) {
         log2("warn", `[${session.id}] side request (~${guard.estimate} tokens) \u2265 effective window ${guard.limit} (model=${reqModel2 ?? "?"}) \u2014 NOT forwarded: guaranteed upstream 400 (side requests bypass preflight by design, #388)`);
@@ -58272,23 +58388,24 @@ ${bodyBuffer.toString("utf8")}`);
       return;
     }
     const reqModel = parsed.model;
-    const learnedMap = session.metadata.learnedContextLimits;
-    const learnedLimit = (reqModel && learnedMap ? learnedMap[reqModel] : void 0) ?? session.metadata.learnedContextLimit;
+    retractStaleLearnedLimits(session, reqModel);
+    const confirmedLimit = resolveConfirmedLimit(session, reqModel);
+    const learnedLimit = confirmedLimit ?? resolveSpeculativeLimit(session, reqModel);
     if (learnedLimit && learnedLimit > 0 && learnedLimit < reqConfig.modelContextLimit) {
       const resolved = reqConfig.modelContextLimit;
       reqConfig = { ...reqConfig, modelContextLimit: learnedLimit };
       nativeFromFallback = false;
-      log2("info", `[${session.id}] self-healed context window: ${resolved} \u2192 ${learnedLimit} (learned from an upstream overflow)`);
+      log2("info", `[${session.id}] self-healed context window: ${resolved} \u2192 ${learnedLimit} (${confirmedLimit !== void 0 ? "confirmed by an upstream overflow error" : "weak-overflow heuristic"})`);
     } else if (nativeFromFallback && reqModel) {
       const prevInput = session.stats.lastInputTokens ?? 0;
       const prevWindow = session.metadata.lastTurnWindow;
       const resolved = reqConfig.modelContextLimit;
       if (prevWindow !== void 0 && prevInput > prevWindow && prevInput > resolved && prevInput >= 1e3) {
-        const map = session.metadata.learnedContextLimits ?? {};
+        const map = session.metadata.confirmedContextLimits ?? {};
         const prev = map[reqModel];
         if (prev === void 0 || prevInput > prev) {
           map[reqModel] = prevInput;
-          session.metadata.learnedContextLimits = map;
+          session.metadata.confirmedContextLimits = map;
           markDirty(session);
         }
         reqConfig = { ...reqConfig, modelContextLimit: prevInput };
@@ -58342,23 +58459,42 @@ ${bodyBuffer.toString("utf8")}`);
             parsed.model,
             route,
             affinity,
+            anonAffinity !== null,
             log2,
             instanceId
           );
           if (isPreflightFailFast(outcome)) {
-            if (outcome.respond && !res.headersSent && !res.destroyed) {
-              res.writeHead(outcome.status, {
-                "content-type": "application/json",
-                ...outcome.status === 503 ? { "retry-after": "30" } : {}
-              });
-              res.end(JSON.stringify({
-                error: {
-                  type: "server_error",
-                  code: "preflight_compress_failed",
-                  message: outcome.message,
-                  retryable: outcome.retryable
+            if (outcome.respond && !res.destroyed) {
+              if (res.headersSent) {
+                if (prepared.stream) {
+                  emitPreflightError(res, prepared.protocol, { message: outcome.message, retryable: outcome.retryable }, (m2) => log2("warn", m2));
+                } else {
+                  try {
+                    res.end(JSON.stringify({
+                      error: {
+                        type: "server_error",
+                        code: "preflight_compress_failed",
+                        message: outcome.message,
+                        retryable: outcome.retryable
+                      }
+                    }));
+                  } catch {
+                  }
                 }
-              }));
+              } else {
+                res.writeHead(outcome.status, {
+                  "content-type": "application/json",
+                  ...outcome.status === 503 ? { "retry-after": "30" } : {}
+                });
+                res.end(JSON.stringify({
+                  error: {
+                    type: "server_error",
+                    code: "preflight_compress_failed",
+                    message: outcome.message,
+                    retryable: outcome.retryable
+                  }
+                }));
+              }
             }
             return;
           }
@@ -58477,6 +58613,11 @@ function armHostUsageCredit(session, originalMessages, processedMessages, log2)
     log2("info", `[${session.id}] host usage backfill armed: +${session.hostCreditTokens} tok (forwarded view is folded); host usage will report the uncompressed baseline`);
   }
 }
+function effectiveTokenCount(session, msgs) {
+  if (session.stats.lastInputTokens > 0) return session.stats.lastInputTokens;
+  if (!session.metadata.anonymousPrefixAffinity) return 0;
+  return estimateCoreMessagesUpper(msgs);
+}
 function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, session, pluginMode) {
   const sessionId = session.id;
   const stream2 = parsed.stream === true;
@@ -58501,7 +58642,7 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
     const { msgs, cacheControls } = anthropicToCore(parsed);
     originalMessages = msgs;
     extractSystem(parsed.system);
-    const tokenCount = session.stats.lastInputTokens;
+    const tokenCount = effectiveTokenCount(session, msgs);
     const activeBefore = new Set(session.state.blocks.filter((b2) => b2.active).map((b2) => b2.blockId));
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
@@ -58622,7 +58763,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     const { msgs, systemText } = openaiToCore(parsed);
     openaiSystemText = systemText;
     originalMessages = msgs;
-    const tokenCount = session.stats.lastInputTokens;
+    const tokenCount = effectiveTokenCount(session, msgs);
     const activeBefore = new Set(session.state.blocks.filter((b2) => b2.active).map((b2) => b2.blockId));
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
@@ -58727,7 +58868,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     if (process.env.ACP_DEBUG) {
       log2("info", `[${sessionId}] input items: ${Array.isArray(parsed.input) ? parsed.input.map((i) => i.type).join(",") : "(string)"}`);
     }
-    const tokenCount = session.stats.lastInputTokens;
+    const tokenCount = effectiveTokenCount(session, msgs);
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags });
     session.state = turn.state;
     session.stats.compressCreditTokens = 0;
@@ -59025,17 +59166,57 @@ function buildForwardTarget(req, opts, route, affinity, hopMarker) {
 function isPreflightFailFast(outcome) {
   return "failFast" in outcome;
 }
-async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, core, config, model, route, affinity, log2, instanceId) {
+var PREFLIGHT_HOLD_GRACE_DEFAULT_MS = 3e4;
+var PREFLIGHT_KEEPALIVE_MS = 15e3;
+function preflightHoldGraceMs() {
+  const raw = process.env.BILI_PREFLIGHT_HOLD_MS;
+  if (!raw) return PREFLIGHT_HOLD_GRACE_DEFAULT_MS;
+  const v2 = Number(raw);
+  return Number.isFinite(v2) && v2 >= 0 ? Math.floor(v2) : PREFLIGHT_HOLD_GRACE_DEFAULT_MS;
+}
+function beginPreflightHold(res, prepared, log2) {
+  if (res.headersSent || res.destroyed || res.writableEnded) return void 0;
+  const sid = prepared.session.id;
+  const keepAlive = prepared.stream ? ": bili-preflight\n\n" : " ";
+  try {
+    if (prepared.stream) {
+      res.writeHead(200, {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        "x-accel-buffering": "no",
+        "x-bili-preflight": "compressing"
+      });
+    } else {
+      res.writeHead(200, { "content-type": "application/json", "x-bili-preflight": "compressing" });
+    }
+  } catch {
+    return void 0;
+  }
+  log2("info", `[${sid}] preflight still running after ${preflightHoldGraceMs()}ms grace \u2014 committed early ${prepared.stream ? "SSE" : "JSON"} headers + keep-alive to hold the client (#568)`);
+  try {
+    res.write(keepAlive);
+  } catch {
+  }
+  const iv = setInterval(() => {
+    try {
+      res.write(keepAlive);
+    } catch {
+      clearInterval(iv);
+    }
+  }, PREFLIGHT_KEEPALIVE_MS);
+  return () => clearInterval(iv);
+}
+async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, core, config, model, route, affinity, anonymous, log2, instanceId) {
   const session = prepared.session;
   const limit = config.modelContextLimit;
   const imageTokens = imageTokensInRawBody(prepared.protocol, prepared.body);
   const textEstimate = estimateCoreMessages(prepared.processedMessages);
   const overheadEstimate = estimateWireOverhead(prepared.protocol, prepared.body);
   const payloadEstimate = textEstimate + overheadEstimate + imageTokens;
-  const tokenCount = Math.max(session.stats.lastInputTokens, payloadEstimate);
+  const unknownBaseline = anonymous && session.stats.lastInputTokens <= 0;
+  const tokenCount = unknownBaseline ? estimateCoreMessagesUpper(prepared.processedMessages) + overheadEstimate + imageTokens : Math.max(session.stats.lastInputTokens, payloadEstimate);
   if (limit <= 0 || !model || tokenCount < limit) return prepared;
-  const learnedMap = session.metadata.learnedContextLimits;
-  const learnedLimit = (model ? learnedMap?.[model] : void 0) ?? session.metadata.learnedContextLimit;
+  const learnedLimit = resolveLearnedLimit(session, model);
   const noOverflowEvidence = session.stats.lastInputTokens < limit && learnedLimit === void 0;
   if (imageTokens > 0 && textEstimate < limit && noOverflowEvidence) {
     log2("warn", `[${session.id}] image-dominated payload (~${textEstimate} text + ~${imageTokens} image tokens) exceeds window ${limit} by estimate only, no upstream overflow evidence \u2014 forwarding once so the upstream arbitrates billing (#496)`);
@@ -59047,9 +59228,14 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
     log2("error", `[${session.id}] preflight fail-fast ${status2} (retryable=${retryable}): ${message}`);
     return { failFast: true, status: status2, message, retryable, respond: !res.writableEnded };
   };
-  if ((prepared.nudge?.compressibleRanges ?? []).length === 0 && payloadEstimate < limit) {
-    log2("warn", `[${session.id}] preflight trigger fired on a stale baseline (~${tokenCount}) but the payload fits (~${payloadEstimate}/${limit}); forwarding as-is`);
-    return prepared;
+  if ((prepared.nudge?.compressibleRanges ?? []).length === 0) {
+    if (!unknownBaseline && payloadEstimate < limit) {
+      log2("warn", `[${session.id}] preflight trigger fired on a stale baseline (~${tokenCount}) but the payload fits (~${payloadEstimate}/${limit}); forwarding as-is`);
+      return prepared;
+    }
+    if (unknownBaseline) {
+      return failFast(502, "no part of the conversation is compressible (nothing left to fold)", false);
+    }
   }
   log2("warn", `[${session.id}] context ${tokenCount} tokens exceeds model window ${limit} (model=${model}); preflight compressing before forward`);
   const { upstreamUrl, headers, proxyUrl } = buildForwardTarget(req, opts, route, affinity, instanceId);
@@ -59058,30 +59244,43 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
     if (!res.writableEnded) clientAbort.abort();
   });
   const started = Date.now();
-  const result = await preflightCompress(
-    {
-      core,
-      session,
-      config,
-      prompts: prepared.prompts ?? defaultPrompts,
-      protocol: prepared.protocol,
-      url: upstreamUrl,
-      headers,
-      model,
-      proxyUrl,
-      signal: clientAbort.signal,
-      log: log2,
-      imageFloor: imageTokens,
-      wireOverhead: overheadEstimate
-    },
-    prepared.originalMessages
-  );
+  let stopHold;
+  const holdTimer = setTimeout(() => {
+    stopHold = beginPreflightHold(res, prepared, log2);
+  }, preflightHoldGraceMs());
+  holdTimer.unref();
+  let result;
+  try {
+    result = await preflightCompress(
+      {
+        core,
+        session,
+        config,
+        prompts: prepared.prompts ?? defaultPrompts,
+        protocol: prepared.protocol,
+        url: upstreamUrl,
+        headers,
+        model,
+        proxyUrl,
+        signal: clientAbort.signal,
+        log: log2,
+        imageFloor: imageTokens,
+        wireOverhead: overheadEstimate,
+        unknownBaseline
+      },
+      prepared.originalMessages
+    );
+  } finally {
+    clearTimeout(holdTimer);
+    stopHold?.();
+  }
   if (result.compressedRanges > 0) {
     log2("info", `[${session.id}] preflight compressed ${result.compressedRanges} range(s), ~${result.savedTokens} tokens saved (${tokenCount} \u2192 ${session.stats.lastInputTokens}) in ${Date.now() - started}ms; rebuilding payload`);
     const rebuilt = runPrepare();
     session.stats.requests -= 1;
-    if (estimateCoreMessages(rebuilt.processedMessages) + overheadEstimate + imageTokens < limit) return rebuilt;
-  } else if (estimateCoreMessages(prepared.processedMessages) + overheadEstimate + imageTokens < limit) {
+    const fits = unknownBaseline ? result.fitsWindow : estimateCoreMessages(rebuilt.processedMessages) + overheadEstimate + imageTokens < limit;
+    if (fits) return rebuilt;
+  } else if (unknownBaseline ? result.fitsWindow : estimateCoreMessages(prepared.processedMessages) + overheadEstimate + imageTokens < limit) {
     log2("warn", `[${session.id}] preflight made no progress but the payload fits; forwarding as-is`);
     return prepared;
   }
@@ -59096,7 +59295,7 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
 async function forward(req, res, opts, body, prepared, core, config, log2, route, instanceId, affinity) {
   if (prepared?.codexForge) {
     log2("info", `[${prepared.session.id}] codex compact served locally (${prepared.codexForge.kind}); upstream not contacted`);
-    res.writeHead(200, { "content-type": prepared.codexForge.contentType });
+    if (!res.headersSent) res.writeHead(200, { "content-type": prepared.codexForge.contentType });
     res.end(prepared.codexForge.body);
     return;
   }
@@ -59238,28 +59437,46 @@ ${bodyText}`);
       };
       const rejection = detectRoleRejection(upstreamResult.response.status, roleErrText);
       if (rejection && rejection.role !== "system") {
-        const fixed = applyCompatRoles(wireBody, compatProtocol, { [rejection.role]: "system" });
-        if (fixed.rewritten > 0) {
+        const cp2 = compatProtocol;
+        const wb = wireBody;
+        const remember = (target, rewritten) => {
+          const s3 = prepared?.session;
+          if (s3) {
+            const prev = s3.metadata.learnedCompatRoles ?? {};
+            s3.metadata.learnedCompatRoles = { ...prev, [rejection.role]: target };
+            markDirty(s3);
+          }
+          compatRoles = { ...compatRoles, [rejection.role]: target };
+          const providerKey = new URL(upstreamUrl).origin;
+          log2("info", `[${prepared?.session.id ?? "passthrough"}] [compat] upstream rejected role "${rejection.role}" \u2014 auto-rewrote ${rewritten} message role(s) to "${target}", retry OK (remembered for this session only). To make permanent, add: {"providers":{"${providerKey}":{"compat":{"roles":{"${rejection.role}":"${target}"}}}}`);
+        };
+        const hop = async (target) => {
+          const fixed = applyCompatRoles(wb, cp2, { [rejection.role]: target });
+          if (fixed.rewritten === 0) return "other";
+          let r;
           try {
-            const retry = await fetchWithTimeout(upstreamUrl, { ...init, body: fixed.body }, void 0, clientAbort.signal);
-            if (retry.response.ok) {
-              upstreamResult.clearTimer();
-              const s3 = prepared?.session;
-              if (s3) {
-                const prev = s3.metadata.learnedCompatRoles ?? {};
-                s3.metadata.learnedCompatRoles = { ...prev, [rejection.role]: "system" };
-                markDirty(s3);
-              }
-              compatRoles = { ...compatRoles, [rejection.role]: "system" };
-              const providerKey = new URL(upstreamUrl).origin;
-              log2("info", `[${prepared?.session.id ?? "passthrough"}] [compat] upstream rejected role "${rejection.role}" \u2014 auto-rewrote ${fixed.rewritten} message role(s) to "system", retry OK (remembered for this session only). To make permanent, add: {"providers":{"${providerKey}":{"compat":{"roles":{"${rejection.role}":"system"}}}}`);
-              upstreamResult = retry;
-            } else {
-              retry.clearTimer();
-            }
+            r = await fetchWithTimeout(upstreamUrl, { ...init, body: fixed.body }, void 0, clientAbort.signal);
           } catch {
+            return "other";
           }
-        }
+          if (r.response.ok) {
+            upstreamResult.clearTimer();
+            remember(target, fixed.rewritten);
+            upstreamResult = r;
+            return "ok";
+          }
+          let errText2 = null;
+          if (r.response.body) {
+            try {
+              errText2 = (await readStreamToBuffer(r.response.body)).toString("utf8");
+            } catch {
+              errText2 = null;
+            }
+          }
+          r.clearTimer();
+          return errText2 !== null && detectSystemPlacementError(r.response.status, errText2) ? "placement-400" : "other";
+        };
+        if (await hop("system") === "placement-400") await hop("user");
       }
     }
   }
@@ -59317,27 +59534,31 @@ ${hdrText}
         } catch {
           reqModel = void 0;
         }
-        const learnedMap = s3.metadata.learnedContextLimits ?? {};
+        const confirmedMap = s3.metadata.confirmedContextLimits ?? {};
         if (info.window) {
-          const prev = (reqModel ? learnedMap[reqModel] : void 0) ?? s3.metadata.learnedContextLimit;
-          if (reqModel) learnedMap[reqModel] = info.window;
-          else s3.metadata.learnedContextLimit = info.window;
-          s3.metadata.learnedContextLimits = learnedMap;
+          const prev = (reqModel ? confirmedMap[reqModel] : void 0) ?? s3.metadata.confirmedContextLimit;
+          if (reqModel) confirmedMap[reqModel] = info.window;
+          else s3.metadata.confirmedContextLimit = info.window;
+          s3.metadata.confirmedContextLimits = confirmedMap;
           log2("warn", `[${s3.id}] upstream context overflow \u2014 learned real window ${info.window} for ${reqModel ?? "(unknown model)"} (was ${prev ?? "unset"}); arming emergency shrink`);
         } else {
           const payloadEstimate = (prepared.processedMessages.length > 0 ? estimateCoreMessages(prepared.processedMessages) : estimateRawBodyTokens(parsedBody)) + rejectedImageTokens;
-          const prev = (reqModel ? learnedMap[reqModel] : void 0) ?? s3.metadata.learnedContextLimit;
+          const prev = (reqModel ? confirmedMap[reqModel] : void 0) ?? s3.metadata.confirmedContextLimit;
           if (payloadEstimate >= 1e3 && (prev === void 0 || payloadEstimate < prev)) {
-            if (reqModel) learnedMap[reqModel] = payloadEstimate;
-            else s3.metadata.learnedContextLimit = payloadEstimate;
-            s3.metadata.learnedContextLimits = learnedMap;
+            if (reqModel) confirmedMap[reqModel] = payloadEstimate;
+            else s3.metadata.confirmedContextLimit = payloadEstimate;
+            s3.metadata.confirmedContextLimits = confirmedMap;
             log2("warn", `[${s3.id}] upstream context overflow (window not parseable) \u2014 learned conservative window ${payloadEstimate} for ${reqModel ?? "(unknown model)"} from rejected payload size (was ${prev ?? "unset"}); arming emergency shrink`);
           } else {
             log2("warn", `[${s3.id}] upstream context overflow (window not parseable): ${info.message}`);
           }
         }
-        const floor = info.window ?? (reqModel ? learnedMap[reqModel] : void 0) ?? s3.metadata.learnedContextLimit ?? s3.metadata.effectiveContextLimit ?? 0;
-        if (floor > 0) s3.stats.lastInputTokens = Math.max(s3.stats.lastInputTokens, floor);
+        if (info.window) {
+          s3.stats.lastInputTokens = info.window;
+        } else {
+          const floor = (reqModel ? confirmedMap[reqModel] : void 0) ?? s3.metadata.confirmedContextLimit ?? s3.metadata.effectiveContextLimit ?? 0;
+          if (floor > 0) s3.stats.lastInputTokens = Math.max(s3.stats.lastInputTokens, floor);
+        }
         markDirty(s3);
       }
     }
@@ -59349,6 +59570,18 @@ ${hdrText}
     if (bodyText.length > 600) snippet += " \u2026";
     if (!snippet) snippet = "(no body)";
     log("warn", `[${errSid}] \u2190 upstream ${upstream.status}${reqIdText}: ${snippet}`);
+    if (res.headersSent) {
+      if (prepared?.stream) {
+        emitStreamError(res, prepared.protocol, `upstream HTTP ${upstream.status}: ${snippet}`, (m2) => log("info", m2));
+      } else {
+        try {
+          res.end(errBody ?? void 0);
+        } catch {
+        }
+      }
+      clearUpstreamTimer();
+      return;
+    }
     const errHeaders = { ...respHeaders };
     delete errHeaders["content-length"];
     delete errHeaders["transfer-encoding"];
@@ -59357,7 +59590,7 @@ ${hdrText}
     clearUpstreamTimer();
     return;
   }
-  res.writeHead(upstream.status, respHeaders);
+  if (!res.headersSent) res.writeHead(upstream.status, respHeaders);
   if (!upstream.body) {
     res.end();
     clearUpstreamTimer();