billion-context 0.1.59 → 0.1.60-pr.306.164

package/dist/index.js

@@ -30021,9 +30021,9 @@ var require_sha256 = __commonJS({
     var forge2 = require_forge();
     require_md();
     require_util7();
-    var sha256 = module.exports = forge2.sha256 = forge2.sha256 || {};
-    forge2.md.sha256 = forge2.md.algorithms.sha256 = sha256;
-    sha256.create = function() {
+    var sha2562 = module.exports = forge2.sha256 = forge2.sha256 || {};
+    forge2.md.sha256 = forge2.md.algorithms.sha256 = sha2562;
+    sha2562.create = function() {
       if (!_initialized) {
         _init();
       }
@@ -47852,6 +47852,7 @@ function rejectLegacyRoute(key, value) {
 // src/server.ts
 import http from "http";
 import fs6 from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/compress-settings.ts
 function resolveContextLimitValue(raw, nativeLimit) {
@@ -49830,15 +49831,17 @@ function normalizeSseLineEndings(buf) {
 }
 
 // src/loop/tag-echo-filter.ts
-var PAIRED = /\x3cacp\s[^<>]*>([^<>]{0,64})<\/acp>/;
-var LONE = /<\/?acp(?=[\s>])[^<>]*>/;
+var PAIRED = /\x3cacp\s[^<>]{0,256}>([^<>]{0,64})<\/acp>/;
+var LONE_OPEN = /\x3cacp(?:\s[^<>]{0,256})?>/;
+var LONE_CLOSE = /<\/acp(?=[\s>])[^<>]{0,32}>/;
 var PARTIAL_TAIL = /(\x3cacp\s[^<>]*|<\/?a?c?p?)$/;
-var TRUNCATED_TAG = /\x3cacp\s[^<>]*tokens\s*=\s*"[^<>"]*"[^<>]*$/;
+var TRUNC_OPEN = /\x3cacp\s[^<>]*$/;
 var CLOSE_TAG = "</acp";
 var HOLD_LIMIT = 128;
+var TAG_OPEN_CAP = 4096;
 var SWALLOW_CAP = 80;
 function stripAcpTags(text) {
-  return text.replace(new RegExp(PAIRED.source, "g"), "").replace(new RegExp(LONE.source, "g"), "").replace(new RegExp(TRUNCATED_TAG.source), "");
+  return text.replace(new RegExp(PAIRED.source, "g"), "").replace(new RegExp(LONE_OPEN.source, "g"), "").replace(new RegExp(LONE_CLOSE.source, "g"), "").replace(new RegExp(TRUNC_OPEN.source), "");
 }
 function containsRenderTagText(s3) {
   return /\x3c\/?acp(?=[\s>])/.test(s3) || /\\u003c\/?acp(?=[\s>\\])/.test(s3);
@@ -49881,15 +49884,26 @@ function createTagEchoFilter(onDrop) {
         return out;
       }
       const p2 = PAIRED.exec(buf);
-      const l = LONE.exec(buf);
-      let m2;
-      if (p2 && l) m2 = p2.index <= l.index ? p2 : l;
-      else m2 = p2 ?? l;
+      const o = LONE_OPEN.exec(buf);
+      const c = LONE_CLOSE.exec(buf);
+      let m2 = null;
+      for (const cand of [p2, o, c]) {
+        if (cand && (m2 === null || cand.index < m2.index)) m2 = cand;
+      }
       if (!m2) {
         const t = PARTIAL_TAIL.exec(buf);
-        if (t && t[0].length <= HOLD_LIMIT) {
-          held = t[0];
-          out += buf.slice(0, buf.length - t[0].length);
+        if (t) {
+          const definite = /^\x3cacp\s/.test(t[0]);
+          const cap = definite ? TAG_OPEN_CAP : HOLD_LIMIT;
+          if (t[0].length <= cap) {
+            held = t[0];
+            out += buf.slice(0, buf.length - t[0].length);
+          } else if (definite) {
+            drop(t[0]);
+            out += buf.slice(0, buf.length - t[0].length);
+          } else {
+            out += buf;
+          }
         } else {
           out += buf;
         }
@@ -49898,8 +49912,7 @@ function createTagEchoFilter(onDrop) {
       drop(m2[0]);
       out += buf.slice(0, m2.index);
       buf = buf.slice(m2.index + m2[0].length);
-      const wasPaired = m2 === p2;
-      if (!wasPaired && /^\x3cacp\s/.test(m2[0])) {
+      if (m2 === o && /^\x3cacp\s/.test(m2[0])) {
         swallowUntilClose = true;
         swallowed = "";
       }
@@ -49913,14 +49926,19 @@ function createTagEchoFilter(onDrop) {
       return process2(chunk);
     },
     flush() {
-      let rest = swallowed + held;
+      const rest = swallowed + held;
+      const wasSwallowing = swallowUntilClose;
       swallowed = "";
       held = "";
       swallowUntilClose = false;
-      const t = new RegExp(TRUNCATED_TAG.source).exec(rest);
+      if (wasSwallowing) {
+        if (rest.length > 0) drop(rest);
+        return "";
+      }
+      const t = new RegExp(TRUNC_OPEN.source).exec(rest);
       if (t) {
         drop(t[0]);
-        rest = rest.slice(0, t.index);
+        return rest.slice(0, t.index);
       }
       return rest;
     },
@@ -50210,16 +50228,21 @@ TASK: The conversation segment below (messages ${startRef}\u2013${endRef}) must
     clearTimer();
   }
 }
+var ABORTED_FAILURE = { kind: "aborted", detail: "the client disconnected during preflight compression" };
 async function preflightCompress(deps, messages) {
   const limit = deps.config.modelContextLimit;
-  const result = { compressedRanges: 0, savedTokens: 0 };
+  const result = { compressedRanges: 0, savedTokens: 0, payloadEstimate: estimateCoreMessages(messages) };
   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;
   let startTokens = -1;
+  let failure;
   for (let round = 0; round < MAX_PREFLIGHT_ROUNDS; round++) {
-    if (deps.signal?.aborted) break;
+    if (deps.signal?.aborted) {
+      failure = ABORTED_FAILURE;
+      break;
+    }
     const turn = deps.core.processTurn({
       messages,
       state: deps.session.state,
@@ -50229,19 +50252,29 @@ async function preflightCompress(deps, messages) {
     });
     deps.session.state = turn.state;
     currentTokens = Math.max(deps.session.stats.lastInputTokens, estimateCoreMessages(turn.messages));
+    result.payloadEstimate = estimateCoreMessages(turn.messages);
     if (startTokens < 0) startTokens = currentTokens;
     if (currentTokens < limit) break;
     const ranges = viableRanges(turn.nudge?.compressibleRanges ?? []);
-    if (ranges.length === 0) break;
+    if (ranges.length === 0) {
+      failure = { kind: "exhausted", detail: "no compressible ranges remain in the conversation" };
+      break;
+    }
     const range = [...ranges].sort((a, b2) => refNum2(a.startRef) - refNum2(b2.startRef))[0];
     const { refToIdx } = refMaps(messages, deps.session.state);
     const startIdx = refToIdx.get(range.startRef);
     const endIdx = refToIdx.get(range.endRef);
-    if (startIdx === void 0 || endIdx === void 0 || startIdx > endIdx) break;
+    if (startIdx === void 0 || endIdx === void 0 || startIdx > endIdx) {
+      failure = { kind: "exhausted", detail: "the compressible range no longer resolves to payload messages" };
+      break;
+    }
     let appliedThisRound = 0;
     for (const [cs2, ce2] of splitChunks(messages, startIdx, endIdx, budget)) {
       if (currentTokens < limit) break;
-      if (deps.signal?.aborted) break;
+      if (deps.signal?.aborted) {
+        failure = ABORTED_FAILURE;
+        break;
+      }
       const maps = refMaps(messages, deps.session.state);
       const startRef = maps.idxToRef.get(cs2);
       const endRef = maps.idxToRef.get(ce2);
@@ -50254,8 +50287,17 @@ async function preflightCompress(deps, messages) {
         summary = await summarizeRange(deps, content, startRef, endRef);
       } catch (err2) {
         if (err2 instanceof UpstreamHttpError) {
+          failure = {
+            kind: "upstream",
+            status: err2.status,
+            detail: err2.status === 429 ? `the summarization call was rate-limited by the upstream (HTTP 429)` : `the summarization call was rejected by the upstream (HTTP ${err2.status})`
+          };
           deps.log("warn", `[preflight] summarization failed: HTTP ${err2.status} ${err2.body.slice(0, 200)}`);
+        } else if (deps.signal?.aborted) {
+          failure = ABORTED_FAILURE;
+          deps.log("warn", `[preflight] summarization aborted: client disconnected`);
         } else {
+          failure = { kind: "upstream", detail: `the summarization call failed: ${String(err2)}` };
           deps.log("warn", `[preflight] summarization failed: ${String(err2)}`);
         }
         break;
@@ -50280,10 +50322,19 @@ async function preflightCompress(deps, messages) {
       appliedThisRound += 1;
       result.compressedRanges += 1;
     }
-    if (appliedThisRound === 0) break;
+    if (appliedThisRound === 0) {
+      if (!failure) {
+        failure = { kind: "exhausted", detail: "no range could be compressed (chunks below minCompressRange or the summarization responses were unusable)" };
+      }
+      break;
+    }
+  }
+  if (!failure && currentTokens >= limit) {
+    failure = { kind: "exhausted", detail: `the compress budget was exhausted after ${MAX_PREFLIGHT_ROUNDS} rounds` };
   }
   if (result.compressedRanges > 0) deps.session.stats.lastInputTokens = currentTokens;
   result.savedTokens = Math.max(0, startTokens - currentTokens);
+  if (currentTokens >= limit) result.failure = failure;
   return result;
 }
 
@@ -52129,8 +52180,15 @@ ${systemPrompt}` : systemPrompt;
         } else if (type === "message_delta") {
           const u2 = data.usage ?? {};
           if (typeof u2.output_tokens === "number") roundOutput = u2.output_tokens;
-          if (typeof u2.input_tokens === "number" && u2.input_tokens > 0) roundInput = u2.input_tokens;
-          if (typeof u2.cache_read_input_tokens === "number" && u2.cache_read_input_tokens > 0) roundCached = u2.cache_read_input_tokens;
+          const input = typeof u2.input_tokens === "number" ? u2.input_tokens : void 0;
+          const cached = typeof u2.cache_read_input_tokens === "number" ? u2.cache_read_input_tokens : void 0;
+          if (input !== void 0 && input > 0 && cached !== void 0) {
+            roundInput = input;
+            roundCached = cached;
+          } else {
+            if (input !== void 0 && input > 0) roundInput = input;
+            if (cached !== void 0 && cached > 0) roundCached = cached;
+          }
           const d = data.delta ?? {};
           if (typeof d.stop_reason === "string") stopReason = d.stop_reason;
           if (!usageYielded) {
@@ -52566,6 +52624,102 @@ function preferPromptCacheKeyIdentity(identity, body) {
   return { ...identity, value: pck, source: "prompt-cache-key", clientProvided: true };
 }
 
+// src/prefix-affinity.ts
+import { createHash as createHash5 } from "crypto";
+var MIN_CANONICAL_BYTES = 24;
+var MAX_TRACKED_SESSIONS = 256;
+var TTL_MS2 = 7 * 24 * 60 * 60 * 1e3;
+function stableStringify(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const record = value;
+    const out = {};
+    for (const key of Object.keys(record).sort()) out[key] = sortKeys(record[key]);
+    return out;
+  }
+  return value;
+}
+function sha256(text) {
+  return createHash5("sha256").update(text, "utf8").digest("hex");
+}
+function hasUserMessage(messages) {
+  return messages.some((m2) => !!m2 && typeof m2 === "object" && m2.role === "user");
+}
+function chainHashes(messages) {
+  const hashes = [];
+  let prev = "";
+  let bytes = 0;
+  for (const message of messages) {
+    const canonical = stableStringify(message);
+    bytes += canonical.length;
+    prev = sha256(`${prev}\0${canonical}`);
+    hashes.push(prev);
+  }
+  return bytes >= MIN_CANONICAL_BYTES ? hashes : [];
+}
+var PrefixAffinityResolver = class {
+  trackedChains = /* @__PURE__ */ new Map();
+  /**
+   * Resolve an anonymous request to a session id.
+   * Returns null when the request carries no usable conversation signal
+   * (caller keeps the #286 explicit 400).
+   */
+  resolve(messages) {
+    const hashes = chainHashes(messages);
+    if (hashes.length === 0 || !hasUserMessage(messages)) return null;
+    const tailHash = hashes[hashes.length - 1];
+    const tracked = this.trackedChains;
+    this.expire(tracked);
+    let best;
+    for (const entry of tracked.values()) {
+      if (entry.depth > hashes.length) continue;
+      if (hashes[entry.depth - 1] !== entry.tailHash) continue;
+      if (!best || entry.depth > best.depth || entry.depth === best.depth && entry.lastSeen > best.lastSeen) best = entry;
+    }
+    if (best) {
+      return {
+        sessionId: best.sessionId,
+        matchedDepth: best.depth,
+        storedDepth: best.depth,
+        incomingDepth: hashes.length,
+        tailHash
+      };
+    }
+    const sessionId = `pfa-${sha256(`${tailHash}\0${hashes.length}`).slice(0, 16)}`;
+    return { sessionId, matchedDepth: 0, storedDepth: 0, incomingDepth: hashes.length, tailHash };
+  }
+  /** Record the chain of a session (on creation and after every anonymous
+   *  request — the incoming history is the truth, appends extend it). */
+  note(sessionId, depth, tailHash) {
+    const tracked = this.trackedChains;
+    tracked.delete(sessionId);
+    tracked.set(sessionId, { sessionId, depth, tailHash, lastSeen: Date.now() });
+    while (tracked.size > MAX_TRACKED_SESSIONS) {
+      const oldest = [...tracked.values()].sort((a, b2) => a.lastSeen - b2.lastSeen)[0];
+      if (!oldest) break;
+      tracked.delete(oldest.sessionId);
+    }
+  }
+  /** Drop tracking for a removed session. */
+  forget(sessionId) {
+    this.trackedChains.delete(sessionId);
+  }
+  trackedSessionIds() {
+    return [...this.trackedChains.keys()];
+  }
+  expire(tracked) {
+    if (tracked.size === 0) return;
+    const now = Date.now();
+    for (const [id, entry] of tracked) {
+      if (now - entry.lastSeen > TTL_MS2) tracked.delete(id);
+    }
+  }
+};
+var prefixAffinity = new PrefixAffinityResolver();
+
 // node_modules/acp-kernel/dist/panel/index.js
 function topicFallback(summary) {
   const first = summary.split(/[.\n]/)[0] ?? "";
@@ -53791,7 +53945,7 @@ function collectModelWindows(config) {
 }
 
 // src/discover.ts
-var TTL_MS2 = 2e3;
+var TTL_MS3 = 2e3;
 function unwrapUpstream(url) {
   const idx = url.indexOf("/bili/");
   return idx >= 0 ? url.slice(idx + "/bili/".length) : url;
@@ -53859,7 +54013,7 @@ function mtimesEqual(a, b2) {
 var cache3 = null;
 function discoverMitmDomains(env = process.env) {
   const now = Date.now();
-  if (cache3 && now - cache3.checkedAt < TTL_MS2) {
+  if (cache3 && now - cache3.checkedAt < TTL_MS3) {
     return cache3.domains;
   }
   const paths = configFilePaths(env);
@@ -54721,6 +54875,7 @@ async function decodeRequestBody(contentEncoding, input, maxOutputBytes) {
 function bodyDumpEnabled() {
   return process.env.ACP_DUMP_BODY === "1";
 }
+var BILI_HOP_HEADER = "x-bili-hop";
 function parseLauncherModelWindows(raw) {
   if (!raw) return {};
   try {
@@ -54739,10 +54894,25 @@ var LAUNCHER_MODEL_WINDOWS = parseLauncherModelWindows(process.env.BILI_LAUNCHER
 function launcherContextWindow(model) {
   return LAUNCHER_MODEL_WINDOWS[model];
 }
+function anthropicBetaContextWindow(headers) {
+  const raw = headers["anthropic-beta"];
+  if (raw === void 0) return void 0;
+  const list = Array.isArray(raw) ? raw.join(",") : raw;
+  let best;
+  for (const part of list.split(",")) {
+    const m2 = /^context-(\d+)m\b/.exec(part.trim().toLowerCase());
+    if (!m2) continue;
+    const n = Number.parseInt(m2[1], 10);
+    if (!Number.isFinite(n) || n <= 0) continue;
+    const w2 = n * 1e6;
+    if (best === void 0 || w2 > best) best = w2;
+  }
+  return best;
+}
 function safeSessionId(id) {
   return (id ?? "unknown").replace(/[^a-zA-Z0-9._-]/g, "_");
 }
-var NO_IDENTITY_MESSAGE = "Missing stable conversation identity. Send one of the headers: x-session-id, x-session-affinity, x-acp-session, x-opencode-session, x-claude-code-session-id, session-id \u2014 or body session_id / prompt_cache_key (responses/openai). Content-fingerprint sessions are disabled (#286).";
+var NO_IDENTITY_MESSAGE = "Missing stable conversation identity. Send one of the headers: x-session-id, x-session-affinity, x-acp-session, x-opencode-session, x-claude-code-session-id, session-id \u2014 or body session_id / prompt_cache_key (responses/openai). Requests replaying a conversation history are matched by content prefix affinity (#309); this one carries no usable history signal.";
 var UPSTREAM_HOP_HEADERS = /* @__PURE__ */ new Set([
   "host",
   "content-length",
@@ -54816,6 +54986,7 @@ async function startServer(opts) {
   const core = createCore();
   const config = opts.kernelConfig;
   const log2 = (level, msg) => logMsg(opts, level, msg);
+  const instanceId = randomUUID2();
   await initSessions();
   loadConversations();
   log2("info", `[persist] ${getStore().enabled ? "enabled" : "disabled"}`);
@@ -54825,7 +54996,7 @@ async function startServer(opts) {
   void loadRegistry();
   const server = http.createServer(async (req, res) => {
     try {
-      await handle(req, res, opts, core, config, log2);
+      await handle(req, res, opts, core, config, log2, instanceId);
     } catch (err2) {
       const msg = String(err2);
       log2("error", msg);
@@ -54950,7 +55121,7 @@ function adminTrustedHosts(bindHost, port) {
   }
   return set;
 }
-async function handle(req, res, opts, core, config, log2) {
+async function handle(req, res, opts, core, config, log2, instanceId) {
   const isAdminPath = req.url === "/__bili/" || req.url?.startsWith("/__bili/") || req.url === "/__acp/" || req.url?.startsWith("/__acp/");
   if (isAdminPath && !isLoopbackAddress(req.socket.remoteAddress)) {
     res.writeHead(403, { "content-type": "application/json" });
@@ -55111,6 +55282,11 @@ async function handle(req, res, opts, core, config, log2) {
     res.end(JSON.stringify({ error: { type: "invalid_request", message: String(err2) } }));
     return;
   }
+  const hopMarker = headerValue2(req, BILI_HOP_HEADER);
+  if (hopMarker !== void 0) {
+    const selfLoop = hopMarker === instanceId;
+    log2("warn", selfLoop ? `[chain] inbound request carries THIS instance's ${BILI_HOP_HEADER} marker (${hopMarker}) \u2014 self-loop detected. Passing through without processing; check your upstream config (it may point back to this instance).` : `[chain] inbound request carries ${BILI_HOP_HEADER} from another bili instance (${hopMarker}) \u2014 bili\u2192bili chain detected. Passing through without processing to avoid double compression; keep only one bili instance in the chain.`);
+  }
   const countTokens = isCountTokensRequest(req.method ?? "GET", urlPath, bodyBuffer.length > 0);
   let parsed = null;
   if (protocol && bodyBuffer.length > 0) {
@@ -55158,13 +55334,14 @@ ${bodyBuffer.toString("utf8")}`);
           return void 0;
         }
       })();
+      const betaWindow = anthropicBetaContextWindow(req.headers);
       const pluginWindow = pluginReportedContextWindow(req.headers);
       const launcherWindow = launcherContextWindow(model);
       const peekWindow = host ? peekRegistryContext(model, host) : void 0;
       const configuredWindow = resolveConfiguredContextLimit(opts.routes, embeddedUrl, model);
-      let native = pluginWindow ?? launcherWindow ?? peekWindow ?? configuredWindow ?? lookupContextLimit(model);
+      let native = betaWindow ?? pluginWindow ?? launcherWindow ?? peekWindow ?? configuredWindow ?? lookupContextLimit(model);
       const operatorWindowTuned = resolveCompress(opts.routes, embeddedUrl, model, opts.compress).modelContextLimit !== void 0;
-      nativeFromFallback = !pluginWindow && !launcherWindow && !peekWindow && !configuredWindow && !operatorWindowTuned;
+      nativeFromFallback = !betaWindow && !pluginWindow && !launcherWindow && !peekWindow && !configuredWindow && !operatorWindowTuned;
       if (!native && host) {
         native = await contextFromRegistry(model, host);
         if (native) nativeFromFallback = false;
@@ -55174,7 +55351,7 @@ ${bodyBuffer.toString("utf8")}`);
     }
   }
   let prepared = null;
-  if (!opts.passthrough && protocol && parsed && typeof parsed === "object") {
+  if (!opts.passthrough && hopMarker === void 0 && protocol && parsed && typeof parsed === "object") {
     const sessionHeader = headerValue2(req, opts.sessionHeader);
     let pluginAgent = pluginAgentHeader(req.headers);
     let pluginConversation = pluginConversationHeader(req.headers);
@@ -55194,13 +55371,25 @@ ${bodyBuffer.toString("utf8")}`);
       parsed.instructions
     );
     const clientProvided = protocol === "responses" ? responsesIdentity?.clientProvided ?? false : protocol === "openai" ? openaiIdentity?.clientProvided ?? false : !!convHeader;
+    let anonAffinity = null;
     if (!clientProvided) {
-      log2("warn", `400: no stable conversation identity on ${protocol} request \u2192 ${upstreamOrigin}; refusing to create a content-fingerprint session (#286)`);
-      res.writeHead(400, { "content-type": "application/json" });
-      res.end(JSON.stringify(protocol === "anthropic" ? { type: "error", error: { type: "invalid_request_error", message: NO_IDENTITY_MESSAGE } } : { error: { type: "invalid_request_error", message: NO_IDENTITY_MESSAGE } }));
-      return;
+      const anonMessages = protocol === "responses" ? parsed.input ?? [] : parsed.messages ?? [];
+      anonAffinity = prefixAffinity.resolve(Array.isArray(anonMessages) ? anonMessages : []);
+      if (!anonAffinity) {
+        log2("warn", `400: no stable conversation identity on ${protocol} request \u2192 ${upstreamOrigin}; refusing to create a content-fingerprint session (#286)`);
+        res.writeHead(400, { "content-type": "application/json" });
+        res.end(JSON.stringify(protocol === "anthropic" ? { type: "error", error: { type: "invalid_request_error", message: NO_IDENTITY_MESSAGE } } : { error: { type: "invalid_request_error", message: NO_IDENTITY_MESSAGE } }));
+        return;
+      }
+      if (anonAffinity.matchedDepth > 0) {
+        log2("info", `[prefix-affinity] anonymous ${protocol} request \u2192 session ${anonAffinity.sessionId} (prefix match depth=${anonAffinity.matchedDepth}/${anonAffinity.incomingDepth}, tail=${anonAffinity.tailHash.slice(0, 8)}; fork semantics: diverged histories split on their next request)`);
+        log("info", `[prefix-affinity] session ${anonAffinity.sessionId} matched at depth ${anonAffinity.matchedDepth}/${anonAffinity.incomingDepth} (tail=${anonAffinity.tailHash.slice(0, 8)})`);
+      } else {
+        log2("info", `[prefix-affinity] new anonymous session ${anonAffinity.sessionId} (depth=${anonAffinity.incomingDepth}, tail=${anonAffinity.tailHash.slice(0, 8)})`);
+        log("info", `[prefix-affinity] new session ${anonAffinity.sessionId} at depth ${anonAffinity.incomingDepth} (tail=${anonAffinity.tailHash.slice(0, 8)})`);
+      }
     }
-    const sessionId = conversation;
+    const sessionId = anonAffinity ? anonAffinity.sessionId : conversation;
     const bodyIdentity = responsesIdentity ?? openaiIdentity;
     const affinity = affinityToken(bodyIdentity ?? {
       value: clientConv ?? conversation,
@@ -55208,8 +55397,15 @@ ${bodyBuffer.toString("utf8")}`);
       clientProvided: !!clientConv
     });
     const clientLabel = bodyIdentity?.clientProvided ? bodyIdentity.value : clientConversationHeader(req.headers);
-    const session = getSession(sessionId, { protocol, upstreamOrigin, label: clientLabel ?? void 0 });
-    if (!pluginAgent) {
+    const session = getSession(sessionId, { protocol, upstreamOrigin, label: clientLabel ?? (anonAffinity ? "prefix-affinity" : void 0) });
+    if (anonAffinity) {
+      prefixAffinity.note(sessionId, anonAffinity.incomingDepth, anonAffinity.tailHash);
+      session.metadata.anonymousPrefixAffinity = {
+        depth: anonAffinity.incomingDepth,
+        tailHash: anonAffinity.tailHash
+      };
+    }
+    if (!pluginAgent && !anonAffinity) {
       const identityAgent = consumePluginRegisterFor(clientConv ?? conversation);
       if (identityAgent) {
         pluginAgent = identityAgent;
@@ -55263,7 +55459,7 @@ ${bodyBuffer.toString("utf8")}`);
         const runPrepare = () => countTokens ? prepareCountTokens(parsed, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session) : prepareResponses(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity, pluginMode, upstreamOrigin);
         prepared = runPrepare();
         if (!countTokens && !responsesCompact) {
-          prepared = await preflightCompressIfNeeded(
+          const outcome = await preflightCompressIfNeeded(
             prepared,
             runPrepare,
             req,
@@ -55274,10 +55470,29 @@ ${bodyBuffer.toString("utf8")}`);
             parsed.model,
             route,
             affinity,
-            log2
+            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
+                }
+              }));
+            }
+            return;
+          }
+          prepared = outcome;
         }
-        await forward(req, res, opts, prepared.body, prepared, core, reqConfig, log2, route, affinity);
+        await forward(req, res, opts, prepared.body, prepared, core, reqConfig, log2, route, instanceId, affinity);
         if (prepared) {
           rememberPluginMessages(sessionId, prepared.processedMessages, prepared.originalMessages, prepared.nudge);
         }
@@ -55290,7 +55505,7 @@ ${bodyBuffer.toString("utf8")}`);
     if (protocol === null && !opts.passthrough) {
       log2("warn", `unrecognized path ${maskUrlsInText(req.url ?? "")} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses, /responses/compact); forwarding unchanged`);
     }
-    await forward(req, res, opts, bodyBuffer, null, core, reqConfig, log2, route, void 0);
+    await forward(req, res, opts, bodyBuffer, null, core, reqConfig, log2, route, instanceId, void 0);
   }
 }
 var ACP_TAG_MARK = "<acp ";
@@ -55651,7 +55866,7 @@ function injectResponsesTool(tools, toolsToAdd = ACP_TOOLS_RESPONSES) {
   const additions = toolsToAdd.filter((t) => !present.has(t.name));
   return [...tools, ...additions];
 }
-function buildForwardTarget(req, opts, route, affinity) {
+function buildForwardTarget(req, opts, route, affinity, hopMarker) {
   const reqUrl = req.url ?? "";
   const isAbsoluteUrl = /^https?:\/\//i.test(reqUrl);
   const rewritten = route ? route.rewrittenUrl : isAbsoluteUrl ? reqUrl : opts.upstream + reqUrl;
@@ -55663,6 +55878,7 @@ function buildForwardTarget(req, opts, route, affinity) {
     if (UPSTREAM_HOP_HEADERS.has(lower) || reqConnNamed.has(lower) || v2 === void 0) continue;
     headers[k2] = Array.isArray(v2) ? v2.join(", ") : v2;
   }
+  if (hopMarker !== void 0) headers[BILI_HOP_HEADER] = hopMarker;
   headers["host"] = new URL(upstreamUrl).host;
   const betaKey = Object.keys(headers).find((h) => h.toLowerCase() === "x-codex-beta-features");
   if (betaKey) {
@@ -55676,14 +55892,29 @@ function buildForwardTarget(req, opts, route, affinity) {
   const proxyUrl = resolveProxy(opts.routes, opts.proxy, route?.rewrittenUrl ?? upstreamUrl, opts.proxyFallback);
   return { upstreamUrl, headers, proxyUrl };
 }
-async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, core, config, model, route, affinity, log2) {
+function isPreflightFailFast(outcome) {
+  return "failFast" in outcome;
+}
+async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, core, config, model, route, affinity, log2, instanceId) {
   const session = prepared.session;
   const limit = config.modelContextLimit;
-  const tokenCount = Math.max(session.stats.lastInputTokens, estimateCoreMessages(prepared.processedMessages));
+  const payloadEstimate = estimateCoreMessages(prepared.processedMessages);
+  const tokenCount = Math.max(session.stats.lastInputTokens, payloadEstimate);
   if (limit <= 0 || !model || tokenCount < limit) return prepared;
-  if ((prepared.nudge?.compressibleRanges ?? []).length === 0) return prepared;
+  const failFast = (status2, detail, retryable) => {
+    const message = `context ~${tokenCount} tokens exceeds the model window ${limit} (model=${model}) and preflight compression could not bring it under: ${detail}. The over-window payload was NOT forwarded.`;
+    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) {
+    if (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;
+    }
+    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);
+  const { upstreamUrl, headers, proxyUrl } = buildForwardTarget(req, opts, route, affinity, instanceId);
   const clientAbort = new AbortController();
   res.on("close", () => {
     if (!res.writableEnded) clientAbort.abort();
@@ -55705,17 +55936,26 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
     },
     prepared.originalMessages
   );
-  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;
-    return rebuilt;
+  if (result.payloadEstimate < limit) {
+    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;
+      return rebuilt;
+    }
+    log2("warn", `[${session.id}] preflight made no progress but the payload fits (~${result.payloadEstimate}/${limit}); forwarding as-is`);
+    return prepared;
   }
-  log2("warn", `[${session.id}] preflight could not compress enough (~${result.savedTokens} tokens saved); forwarding as-is`);
-  return prepared;
+  const f2 = result.failure;
+  if (f2?.kind === "aborted") {
+    log2("warn", `[${session.id}] preflight aborted (${f2.detail}); not forwarding`);
+    return { failFast: true, status: 0, message: f2.detail, retryable: false, respond: false };
+  }
+  const status = f2?.kind === "upstream" && f2.status === 429 ? 503 : 502;
+  return failFast(status, f2?.detail ?? "unknown reason", status === 503);
 }
-async function forward(req, res, opts, body, prepared, core, config, log2, route, affinity) {
-  const { upstreamUrl, headers, proxyUrl } = buildForwardTarget(req, opts, route, affinity);
+async function forward(req, res, opts, body, prepared, core, config, log2, route, instanceId, affinity) {
+  const { upstreamUrl, headers, proxyUrl } = buildForwardTarget(req, opts, route, affinity, prepared !== null ? instanceId : void 0);
   log2("info", `forward ${req.method} \u2192 ${maskUrlForLog(upstreamUrl)}`);
   if (process.env.ACP_DEBUG && prepared) {
     const sid = prepared.session.id;
@@ -60055,7 +60295,7 @@ function pluginStatusAll() {
 }
 
 // src/launcher.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import fs10 from "fs";
 import net2 from "net";
 import os5 from "os";
@@ -61035,7 +61275,7 @@ async function runLaunch(params, deps = {}) {
     const dshAcpPatch = writeDshAcpPatch(dshHomeDir);
     if (dshAcpPatch) clientArgs = dshArgsWithPatch(clientArgs, dshAcpPatch);
   } else if (base === "codex") {
-    const codexConversationId = injectMcp ? randomUUID2() : void 0;
+    const codexConversationId = injectMcp ? randomUUID3() : void 0;
     if (directUrl) {
       env = { ...process.env, BILLION_CONTEXT_PROXY: origin };
       if (codexConversationId) clientArgs = [...buildCodexMcpArgs(origin, codexConversationId), ...clientArgs];