billion-context 0.1.92-pr.622.446 → 0.1.92

package/dist/index.js

@@ -5632,7 +5632,7 @@ var require_util2 = __commonJS({
         callback();
       }
     };
-    function createInflate2(zlibOptions) {
+    function createInflate(zlibOptions) {
       return new InflateStream(zlibOptions);
     }
     function extractMimeType(headers) {
@@ -5764,7 +5764,7 @@ var require_util2 = __commonJS({
       readAllBytes,
       simpleRangeHeaderValue,
       buildContentRange,
-      createInflate: createInflate2,
+      createInflate,
       extractMimeType,
       getDecodeSplit,
       environmentSettingsObject,
@@ -13122,7 +13122,7 @@ var require_mock_interceptor = __commonJS({
 var require_mock_client = __commonJS({
   "node_modules/undici/lib/mock/mock-client.js"(exports, module) {
     "use strict";
-    var { promisify } = __require("util");
+    var { promisify: promisify2 } = __require("util");
     var Client = require_client();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -13170,7 +13170,7 @@ var require_mock_client = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify(this[kOriginalClose])();
+        await promisify2(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -13383,7 +13383,7 @@ var require_mock_call_history = __commonJS({
 var require_mock_pool = __commonJS({
   "node_modules/undici/lib/mock/mock-pool.js"(exports, module) {
     "use strict";
-    var { promisify } = __require("util");
+    var { promisify: promisify2 } = __require("util");
     var Pool2 = require_pool();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -13431,7 +13431,7 @@ var require_mock_pool = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify(this[kOriginalClose])();
+        await promisify2(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -17545,17 +17545,17 @@ var require_cache2 = __commonJS({
 var require_decompress = __commonJS({
   "node_modules/undici/lib/interceptor/decompress.js"(exports, module) {
     "use strict";
-    var { createInflate: createInflate2, createGunzip: createGunzip2, createBrotliDecompress: createBrotliDecompress2, createZstdDecompress } = __require("zlib");
+    var { createInflate, createGunzip, createBrotliDecompress, createZstdDecompress } = __require("zlib");
     var { pipeline } = __require("stream");
     var DecoratorHandler = require_decorator_handler();
     var { runtimeFeatures } = require_runtime_features();
     var supportedEncodings = {
-      gzip: createGunzip2,
-      "x-gzip": createGunzip2,
-      br: createBrotliDecompress2,
-      deflate: createInflate2,
-      compress: createInflate2,
-      "x-compress": createInflate2,
+      gzip: createGunzip,
+      "x-gzip": createGunzip,
+      br: createBrotliDecompress,
+      deflate: createInflate,
+      compress: createInflate,
+      "x-compress": createInflate,
       ...runtimeFeatures.has("zstd") ? { zstd: createZstdDecompress } : {}
     };
     var defaultSkipStatusCodes = (
@@ -20384,7 +20384,7 @@ var require_fetch = __commonJS({
       clampAndCoarsenConnectionTimingInfo,
       simpleRangeHeaderValue,
       buildContentRange,
-      createInflate: createInflate2,
+      createInflate,
       extractMimeType,
       hasAuthenticationEntry,
       includesCredentials,
@@ -21366,7 +21366,7 @@ var require_fetch = __commonJS({
                       finishFlush: zlib.constants.Z_SYNC_FLUSH
                     }));
                   } else if (coding === "deflate") {
-                    decoders.push(createInflate2({
+                    decoders.push(createInflate({
                       flush: zlib.constants.Z_SYNC_FLUSH,
                       finishFlush: zlib.constants.Z_SYNC_FLUSH
                     }));
@@ -23432,7 +23432,7 @@ var require_connection = __commonJS({
 var require_permessage_deflate = __commonJS({
   "node_modules/undici/lib/web/websocket/permessage-deflate.js"(exports, module) {
     "use strict";
-    var { createInflateRaw: createInflateRaw2, Z_DEFAULT_WINDOWBITS } = __require("zlib");
+    var { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __require("zlib");
     var { isValidClientWindowBits } = require_util5();
     var { MessageSizeExceededError } = require_errors();
     var tail = Buffer.from([0, 0, 255, 255]);
@@ -23468,7 +23468,7 @@ var require_permessage_deflate = __commonJS({
             windowBits = Number.parseInt(this.#options.serverMaxWindowBits);
           }
           try {
-            this.#inflate = createInflateRaw2({ windowBits });
+            this.#inflate = createInflateRaw({ windowBits });
           } catch (err2) {
             callback(err2);
             return;
@@ -38339,7 +38339,7 @@ var require_tls = __commonJS({
       }
       return rval;
     };
-    var inflate = function(c, record, s3) {
+    var inflate2 = function(c, record, s3) {
       var rval = false;
       try {
         var bytes = c.inflate(record.fragment.getBytes());
@@ -39484,7 +39484,7 @@ var require_tls = __commonJS({
           case tls4.CompressionMethod.none:
             break;
           case tls4.CompressionMethod.deflate:
-            state.read.compressFunction = inflate;
+            state.read.compressFunction = inflate2;
             state.write.compressFunction = deflate;
             break;
           default:
@@ -43476,6 +43476,10 @@ function defaultCountTokens(text) {
   const cjkCount = cjk?.length ?? 0;
   return cjkCount + Math.ceil((text.length - cjkCount) / 4);
 }
+function estimateTokensFast(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}
 var COMPRESS_PHILOSOPHY = `Compression Philosophy:
 - All compression serves the primary task, but be frugal.
 - Context capacity is precious. Save context by compressing consumed outputs, not by avoiding tools.
@@ -44917,6 +44921,11 @@ function formatTokenCount(tokens) {
 function buildAbsorbPrompt(ref, tokens, toolName = ABSORB_TOOL_NAME) {
   return `${ABSORB_PROMPT_MARKER} This tool result (~${formatTokenCount(tokens)} tokens) will be REMOVED from context. Your IMMEDIATE next action: call ${toolName}({ ref: "${ref}", summary: "..." }) \u2014 summary = distilled essentials only (outcome, key values, exact paths:lines, error text verbatim, decisions). Afterwards work from your summary; do NOT re-run this tool. If the result contains nothing you need, call ${toolName} with summary "(nothing needed)".`;
 }
+function buildAbsorbSystemPrompt(toolName = ABSORB_TOOL_NAME) {
+  return `INSTANT TOOL-RESULT ABSORPTION (${toolName})
+
+Some tool results end with a ${ABSORB_PROMPT_MARKER} instruction. When you see one, your IMMEDIATE next action must be calling ${toolName}({ ref, summary }) \u2014 distill that tool result's essentials into summary: outcome, key values, exact paths:lines, error text verbatim, decisions. The original output is then removed from context; your ${toolName} summary becomes the only durable record of it, so distill carefully. Never call another tool or answer the user before absorbing a marked result. Do not re-run the original tool afterwards \u2014 work from your summary. ${toolName} calls are ordinary context: the regular compression system may fold them later like any other message.`;
+}
 function isAcpOrConfiguredTool(toolName, cfg) {
   if (!toolName) return false;
   if (toolName === cfg.toolName) return true;
@@ -48104,6 +48113,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;
@@ -48575,6 +48597,69 @@ function resolveRequestConfig(base, routes, embeddedUrl, model, native, globalCo
   return applyCompressSettings(base, limit, compress);
 }
 
+// src/strip-images.ts
+var DEFAULT_STRIP_IMAGES_KEEP_RECENT = 5;
+var IMAGE_PLACEHOLDER = "[image]";
+function isObj(v2) {
+  return typeof v2 === "object" && v2 !== null;
+}
+function isImagePart(protocol, part) {
+  if (!isObj(part)) return false;
+  if (protocol === "responses") return part.type === "input_image";
+  if (protocol === "openai") return part.type === "image_url";
+  return part.type === "image";
+}
+function placeholderContent(protocol) {
+  const type = protocol === "responses" ? "input_text" : "text";
+  return [{ type, text: IMAGE_PLACEHOLDER }];
+}
+function stripHistoricalImages(body, protocol, keepRecent) {
+  if (!protocol || !isObj(body)) return { body, removed: 0 };
+  const recentCount = Math.max(0, Math.floor(keepRecent));
+  if (protocol === "responses") {
+    const input = body.input;
+    if (!Array.isArray(input)) return { body, removed: 0 };
+    const cutoff2 = input.length - recentCount;
+    let removed2 = 0;
+    let touched2 = false;
+    const nextInput = input.map((item, i) => {
+      if (i < cutoff2 && isObj(item) && Array.isArray(item.content)) {
+        const content = item.content;
+        const imgs = content.filter((p2) => isImagePart("responses", p2)).length;
+        if (imgs > 0) {
+          removed2 += imgs;
+          touched2 = true;
+          const kept = content.filter((p2) => !isImagePart("responses", p2));
+          return { ...item, content: kept.length > 0 ? kept : placeholderContent("responses") };
+        }
+      }
+      return item;
+    });
+    if (!touched2) return { body, removed: 0 };
+    return { body: { ...body, input: nextInput }, removed: removed2 };
+  }
+  const messages = body.messages;
+  if (!Array.isArray(messages)) return { body, removed: 0 };
+  const cutoff = messages.length - recentCount;
+  let removed = 0;
+  let touched = false;
+  const nextMessages = messages.map((m2, i) => {
+    if (i < cutoff && isObj(m2) && Array.isArray(m2.content)) {
+      const content = m2.content;
+      const imgs = content.filter((p2) => isImagePart(protocol, p2)).length;
+      if (imgs > 0) {
+        removed += imgs;
+        touched = true;
+        const kept = content.filter((p2) => !isImagePart(protocol, p2));
+        return { ...m2, content: kept.length > 0 ? kept : placeholderContent(protocol) };
+      }
+    }
+    return m2;
+  });
+  if (!touched) return { body, removed: 0 };
+  return { body: { ...body, messages: nextMessages }, removed };
+}
+
 // src/registry.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { existsSync as existsSync2, statSync as statSync2 } from "fs";
@@ -50964,52 +51049,14 @@ function withStagedCompressGuidance(text) {
   return text + STAGED_COMPRESS_GUIDANCE;
 }
 
-// src/acp-status.ts
-function handleAcpStatus(args, ctx) {
-  const scope = typeof args.scope === "string" ? args.scope : void 0;
-  const view = typeof args.view === "string" ? args.view : void 0;
-  const tool = typeof args.tool === "string" ? args.tool : void 0;
-  const sort = typeof args.sort === "string" ? args.sort : void 0;
-  const limit = typeof args.limit === "number" ? args.limit : void 0;
-  const base = buildStatusReport(ctx.session.state, ctx.messages, defaultCountTokens, { scope, view, tool, sort, limit });
-  if (scope) return base;
-  const extra = [];
-  try {
-    const turn = ctx.core.processTurn({
-      messages: ctx.messages,
-      state: ctx.session.state,
-      config: ctx.config,
-      tokenCount: ctx.session.stats.lastInputTokens,
-      renderTags: "none"
-    });
-    const nudge = turn.nudge;
-    if (nudge) {
-      extra.push("");
-      extra.push(nudge.shouldInject ? `Nudge: ACTIVE \u2014 ${nudge.reason}` : `Nudge: idle \u2014 ${nudge.reason}`);
-      const ranges = viableRanges(nudge.compressibleRanges);
-      const protectedRanges = nudge.protectedRanges ?? [];
-      if (ranges.length > 0 || protectedRanges.length > 0) {
-        extra.push("");
-        extra.push(formatRanges(ranges, protectedRanges));
-      }
-    }
-  } catch {
-  }
-  const archive = preCompactionArchiveOf(ctx.session);
-  const archivedIds = Object.keys(archive);
-  if (archivedIds.length > 0) {
-    extra.push("");
-    extra.push(`PRE-COMPACTION ARCHIVE \u2014 ${archivedIds.length} block(s): content was replaced by the client's native compaction summary, so it is no longer in the session history and decompress is unavailable.`);
-    for (const id of archivedIds) {
-      extra.push(`  ${id} \u2014 ${archive[id].reason}`);
-    }
-  }
-  return extra.length > 0 ? `${base}
-${extra.join("\n")}` : base;
-}
-
 // src/absorb.ts
 var EFFECTIVE_ABSORB_KEY = "effectiveAbsorb";
+function absorbEnabled(config) {
+  return config.absorb?.enabled === true;
+}
+function absorbToolName(config) {
+  return config.absorb?.toolName ?? ABSORB_TOOL_NAME;
+}
 function effectiveAbsorbConfig(session, fallback) {
   const meta = session?.metadata[EFFECTIVE_ABSORB_KEY];
   if (meta && typeof meta === "object" && typeof meta.enabled === "boolean") {
@@ -51017,6 +51064,9 @@ function effectiveAbsorbConfig(session, fallback) {
   }
   return fallback.absorb;
 }
+function storeEffectiveAbsorb(session, config) {
+  session.metadata[EFFECTIVE_ABSORB_KEY] = config.absorb ?? null;
+}
 function isProxyToolFor(name, session, config) {
   if (ACP_TOOL_NAMES.has(name)) return true;
   const absorb = effectiveAbsorbConfig(session, config);
@@ -51065,6 +51115,50 @@ function executeAbsorb(args, callId, absorb, ctx) {
   return outcome.resultText;
 }
 
+// src/acp-status.ts
+function handleAcpStatus(args, ctx) {
+  const scope = typeof args.scope === "string" ? args.scope : void 0;
+  const view = typeof args.view === "string" ? args.view : void 0;
+  const tool = typeof args.tool === "string" ? args.tool : void 0;
+  const sort = typeof args.sort === "string" ? args.sort : void 0;
+  const limit = typeof args.limit === "number" ? args.limit : void 0;
+  const base = buildStatusReport(ctx.session.state, ctx.messages, defaultCountTokens, { scope, view, tool, sort, limit });
+  if (scope) return base;
+  const extra = [];
+  try {
+    const turn = ctx.core.processTurn({
+      messages: ctx.messages,
+      state: ctx.session.state,
+      config: ctx.config,
+      tokenCount: ctx.session.stats.lastInputTokens,
+      renderTags: "none"
+    });
+    const nudge = turn.nudge;
+    if (nudge) {
+      extra.push("");
+      extra.push(nudge.shouldInject ? `Nudge: ACTIVE \u2014 ${nudge.reason}` : `Nudge: idle \u2014 ${nudge.reason}`);
+      const ranges = viableRanges(nudge.compressibleRanges);
+      const protectedRanges = nudge.protectedRanges ?? [];
+      if (ranges.length > 0 || protectedRanges.length > 0) {
+        extra.push("");
+        extra.push(formatRanges(ranges, protectedRanges));
+      }
+    }
+  } catch {
+  }
+  const archive = preCompactionArchiveOf(ctx.session);
+  const archivedIds = Object.keys(archive);
+  if (archivedIds.length > 0) {
+    extra.push("");
+    extra.push(`PRE-COMPACTION ARCHIVE \u2014 ${archivedIds.length} block(s): content was replaced by the client's native compaction summary, so it is no longer in the session history and decompress is unavailable.`);
+    for (const id of archivedIds) {
+      extra.push(`  ${id} \u2014 ${archive[id].reason}`);
+    }
+  }
+  return extra.length > 0 ? `${base}
+${extra.join("\n")}` : base;
+}
+
 // src/decompress-shared.ts
 import { mkdirSync as mkdirSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname2, join as join2 } from "path";
@@ -51885,24 +51979,24 @@ function costForUrl(url) {
   }
   return applyCap(REMOTE_IMAGE_TOKENS);
 }
-function isObj(v2) {
+function isObj2(v2) {
   return typeof v2 === "object" && v2 !== null;
 }
 function urlOf(v2) {
   if (typeof v2 === "string") return v2;
-  if (isObj(v2) && typeof v2.url === "string") return v2.url;
+  if (isObj2(v2) && typeof v2.url === "string") return v2.url;
   return void 0;
 }
 function imageTokensInParsedBody(protocol, body) {
-  if (!isObj(body)) return 0;
+  if (!isObj2(body)) return 0;
   let total = 0;
   if (protocol === "responses") {
     const input = body.input;
     if (!Array.isArray(input)) return 0;
     for (const item of input) {
-      if (!isObj(item) || !Array.isArray(item.content)) continue;
+      if (!isObj2(item) || !Array.isArray(item.content)) continue;
       for (const part of item.content) {
-        if (!isObj(part) || part.type !== "input_image") continue;
+        if (!isObj2(part) || part.type !== "input_image") continue;
         const url = urlOf(part.image_url);
         if (url) total += costForUrl(url);
       }
@@ -51912,9 +52006,9 @@ function imageTokensInParsedBody(protocol, body) {
   const messages = body.messages;
   if (!Array.isArray(messages)) return 0;
   for (const m2 of messages) {
-    if (!isObj(m2) || !Array.isArray(m2.content)) continue;
+    if (!isObj2(m2) || !Array.isArray(m2.content)) continue;
     for (const part of m2.content) {
-      if (!isObj(part)) continue;
+      if (!isObj2(part)) continue;
       if (protocol === "openai") {
         if (part.type !== "image_url") continue;
         const url = urlOf(part.image_url);
@@ -51922,8 +52016,8 @@ function imageTokensInParsedBody(protocol, body) {
       } else {
         if (part.type !== "image") continue;
         const src = part.source;
-        if (isObj(src) && src.type === "base64" && typeof src.data === "string") total += applyCap(Math.ceil(src.data.length / 4));
-        else if (isObj(src) && src.type === "url" && typeof src.url === "string") total += costForUrl(src.url);
+        if (isObj2(src) && src.type === "base64" && typeof src.data === "string") total += applyCap(Math.ceil(src.data.length / 4));
+        else if (isObj2(src) && src.type === "url" && typeof src.url === "string") total += costForUrl(src.url);
       }
     }
   }
@@ -52611,6 +52705,8 @@ 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 resolveConfirmedLimit(session, model) {
   const md = session.metadata ?? {};
@@ -52626,6 +52722,38 @@ 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 = resolveLearnedLimit(session, model);
@@ -55195,6 +55323,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 {
@@ -57259,7 +57416,8 @@ function tunnelAllowlistFromEnv(env = process.env) {
 }
 
 // src/content-encoding.ts
-import { createBrotliDecompress, createGunzip, createInflate, createInflateRaw } from "zlib";
+import { promisify } from "util";
+import { brotliDecompress, gunzip, inflate, inflateRaw } from "zlib";
 
 // node_modules/fzstd/esm/index.mjs
 var ab = ArrayBuffer;
@@ -57932,54 +58090,31 @@ var Decompress = /* @__PURE__ */ (function() {
 })();
 
 // src/content-encoding.ts
-var DecompressedTooLargeError = class extends Error {
-  constructor(limit) {
-    super(`decompressed request exceeds ${limit} bytes`);
-    this.limit = limit;
-    this.name = "DecompressedTooLargeError";
-  }
-  limit;
-};
-function streamDecode(factory, input, max) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    let size = 0;
-    const decoder = factory();
-    decoder.on("data", (chunk) => {
-      size += chunk.length;
-      if (size > max) {
-        decoder.destroy();
-        reject(new DecompressedTooLargeError(max));
-        return;
-      }
-      chunks.push(chunk);
-    });
-    decoder.on("end", () => resolve(Buffer.concat(chunks, size)));
-    decoder.on("error", (err2) => reject(err2));
-    decoder.end(input);
-  });
-}
-async function decodeZstd(input, max) {
+var gunzipAsync = promisify(gunzip);
+var inflateAsync = promisify(inflate);
+var inflateRawAsync = promisify(inflateRaw);
+var brotliAsync = promisify(brotliDecompress);
+async function decodeZstd(input, maxOutputBytes) {
   const chunks = [];
   let size = 0;
   const decoder = new Decompress((chunk) => {
     size += chunk.byteLength;
-    if (size > max) throw new DecompressedTooLargeError(max);
+    if (size > maxOutputBytes) throw new Error(`decompressed request exceeds ${maxOutputBytes} bytes`);
     chunks.push(Buffer.from(chunk));
   });
   decoder.push(input, true);
   return Buffer.concat(chunks, size);
 }
-async function decodeOne(coding, input, max) {
-  if (coding === "gzip" || coding === "x-gzip") return streamDecode(createGunzip, input, max);
-  if (coding === "br") return streamDecode(createBrotliDecompress, input, max);
-  if (coding === "zstd") return decodeZstd(input, max);
+async function decodeOne(coding, input, maxOutputBytes) {
+  const options = { maxOutputLength: maxOutputBytes };
+  if (coding === "gzip" || coding === "x-gzip") return gunzipAsync(input, options);
+  if (coding === "br") return brotliAsync(input, options);
+  if (coding === "zstd") return decodeZstd(input, maxOutputBytes);
   if (coding === "deflate") {
     try {
-      return await streamDecode(createInflate, input, max);
-    } catch (err2) {
-      if (err2 instanceof DecompressedTooLargeError) throw err2;
-      return streamDecode(createInflateRaw, input, max);
+      return await inflateAsync(input, options);
+    } catch {
+      return inflateRawAsync(input, options);
     }
   }
   throw new Error(`unsupported request content-encoding: ${coding}`);
@@ -57990,7 +58125,9 @@ async function decodeRequestBody(contentEncoding, input, maxOutputBytes) {
   let body = input;
   for (const coding of codings.reverse()) {
     body = await decodeOne(coding, body, maxOutputBytes);
-    if (body.byteLength > maxOutputBytes) throw new DecompressedTooLargeError(maxOutputBytes);
+    if (body.byteLength > maxOutputBytes) {
+      throw new Error(`decompressed request exceeds ${maxOutputBytes} bytes`);
+    }
   }
   return { body, decoded: true };
 }
@@ -58043,6 +58180,7 @@ var LAUNCHER_MODEL_WINDOWS = parseLauncherModelWindows(process.env.BILI_LAUNCHER
 function launcherContextWindow(model) {
   return LAUNCHER_MODEL_WINDOWS[model];
 }
+var windowSourceLogged = /* @__PURE__ */ new Set();
 function anthropicBetaContextWindow(headers) {
   const raw = headers["anthropic-beta"];
   if (raw === void 0) return void 0;
@@ -58569,24 +58707,18 @@ async function handle(req, res, opts, core, config, log2, instanceId, instanceSt
     upstreamOrigin = route ? route.upstream : /^https?:\/\//i.test(url) ? new URL(url).origin : opts.upstream;
     protocol = route?.explicitProtocol ?? (req.method === "POST" && bodyBuffer.length > 0 ? urlPath.endsWith("/chat/completions") ? "openai" : urlPath.endsWith("/v1/messages") || urlPath.endsWith("/messages") ? "anthropic" : urlPath.endsWith("/responses") || responsesCompact ? "responses" : null : null);
     if (protocol !== null && bodyBuffer.length > 0) {
-      try {
-        const decoded = await decodeRequestBody(headerValue2(req, "content-encoding"), bodyBuffer, MAX_REQUEST_BYTES);
-        bodyBuffer = decoded.body;
-        if (decoded.decoded) delete req.headers["content-encoding"];
-      } catch (decErr) {
-        if (decErr instanceof DecompressedTooLargeError) throw decErr;
-        protocol = null;
-        log2("warn", `decode body failed (${String(decErr)}) - forwarding raw body verbatim to ${upstreamOrigin}`);
-      }
+      const decoded = await decodeRequestBody(headerValue2(req, "content-encoding"), bodyBuffer, MAX_REQUEST_BYTES);
+      bodyBuffer = decoded.body;
+      if (decoded.decoded) delete req.headers["content-encoding"];
     }
   } catch (err2) {
-    if (err2 instanceof BodyTooLargeError || err2 instanceof DecompressedTooLargeError) {
+    if (err2 instanceof BodyTooLargeError) {
       log2("warn", `413: request body exceeds ${err2.limit} bytes`);
       res.writeHead(413, { "content-type": "application/json" });
       res.end(JSON.stringify({ error: { type: "request_too_large", message: err2.message } }));
       return;
     }
-    log2("warn", `failed to prepare inbound request (${String(err2)}) - 400`);
+    log2("warn", `read/decode body failed: ${String(err2)}`);
     res.writeHead(400, { "content-type": "application/json" });
     res.end(JSON.stringify({ error: { type: "invalid_request", message: String(err2) } }));
     return;
@@ -58657,6 +58789,13 @@ ${bodyBuffer.toString("utf8")}`);
         if (native) nativeFromFallback = false;
       }
       reqConfig = resolveRequestConfig(config, opts.routes, embeddedUrl, model, native, opts.compress);
+      {
+        if (!windowSourceLogged.has(model)) {
+          windowSourceLogged.add(model);
+          const wsSource = betaWindow ? "anthropic-beta" : pluginWindow ? "plugin" : launcherWindow ? "launcher" : configuredWindow ? "configured" : peekWindow ? "registry-peek" : native ? "table-or-registry" : "default";
+          log2("info", `[window] model=${model} source=${wsSource} native=${native ?? "none"} effective=${reqConfig.modelContextLimit} launcher=${launcherWindow ?? "none"} configured=${configuredWindow ?? "none"} peek=${peekWindow ?? "none"} fallback=${nativeFromFallback}`);
+        }
+      }
       const aligned = operatorWindowTuned ? { limit: reqConfig.modelContextLimit, clamped: false } : codexAlignedWindow(reqConfig.modelContextLimit, model, req.headers);
       if (aligned.clamped) {
         const before = reqConfig.modelContextLimit;
@@ -58765,8 +58904,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)`);
@@ -58798,23 +58936,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 };
@@ -58839,7 +58978,16 @@ ${bodyBuffer.toString("utf8")}`);
     acquireInFlight(session);
     try {
       await withSessionLock(session, async () => {
-        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, nativeWindow) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session, req, core, reqConfig, log2) : prepareResponses(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity, pluginMode, upstreamOrigin, nativeWindow);
+        const runPrepare = () => {
+          const cs2 = resolveCompress(opts.routes, route?.rewrittenUrl, parsed.model, opts.compress);
+          const keepRecent = cs2.stripImagesKeepRecent ?? DEFAULT_STRIP_IMAGES_KEEP_RECENT;
+          const stripped = cs2.stripImages ? stripHistoricalImages(parsed, protocol, keepRecent) : { body: parsed, removed: 0 };
+          if (opts.debug && stripped.removed > 0) {
+            log2("info", `[debug] strip-images: dropped ${stripped.removed} historical image part(s), kept last ${keepRecent} (session=${session.id})`);
+          }
+          const work = stripped.body;
+          return countTokens ? prepareCountTokens(work, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(work, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : protocol === "openai" ? prepareOpenai(work, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode, nativeWindow) : responsesCompact ? prepareResponsesCompact(stripped.removed > 0 ? Buffer.from(JSON.stringify(work)) : bodyBuffer, work, session, req, core, reqConfig, log2) : prepareResponses(work, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity, pluginMode, upstreamOrigin, nativeWindow);
+        };
         const isCodexCompactTrigger = protocol === "responses" && !responsesCompact && isCodexClient(req.headers) && hasCompactionTrigger(parsed.input);
         if (isCodexCompactTrigger) {
           const mode = codexCompactMode();
@@ -58868,23 +59016,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;
           }
@@ -58997,12 +59164,17 @@ function diagNudge(turn, sessionId, tokenCount, limit, model, willInject) {
 }
 function armHostUsageCredit(session, originalMessages, processedMessages, log2) {
   session.hostCreditTokens = 0;
-  if (session.metadata.pluginAgent === "pi") return;
+  if (session.metadata.pluginAgent === "pi" || session.metadata.pluginAgent === "omp") return;
   session.hostCreditTokens = processedMessages.length > 0 ? Math.max(0, estimateCoreMessages(originalMessages) - estimateCoreMessages(processedMessages)) : 0;
   if (session.hostCreditTokens > 0) {
     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;
@@ -59027,11 +59199,15 @@ 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" });
+    const absorbActive = absorbEnabled(config) && opts.compress.injectTool;
+    const loopConfig = absorbActive ? config : { ...config, absorb: void 0 };
+    const turn = core.processTurn({ messages: msgs, state: session.state, config: loopConfig, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
     session.stats.compressCreditTokens = 0;
+    storeEffectiveAbsorb(session, loopConfig);
+    turn.messages = applyAbsorbView(turn.messages, session.state, loopConfig, tokenCount);
     if (turn.nudge) turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
     nudge = turn.nudge;
     session.stats.contextTokens = tokenCount;
@@ -59046,9 +59222,9 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
     applyCompactionArchive(session, activeBefore, new Set(msgs.map((m2) => m2.id)), log2);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToAnthropic(processedMessages, cacheControls);
-    systemOut = injectSystem(parsed, opts, prompts);
+    systemOut = injectSystem(parsed, opts, prompts, loopConfig);
     if (injectTools) {
-      toolsOut = injectTool(parsed.tools);
+      toolsOut = injectTool(parsed.tools, absorbActive ? ABSORB_TOOL : void 0);
     }
     if (willInjectNudge && turn.nudge) {
       try {
@@ -59148,11 +59324,15 @@ 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" });
+    const absorbActive = absorbEnabled(config) && shouldInject;
+    const loopConfig = absorbActive ? config : { ...config, absorb: void 0 };
+    const turn = core.processTurn({ messages: msgs, state: session.state, config: loopConfig, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
     session.stats.compressCreditTokens = 0;
+    storeEffectiveAbsorb(session, loopConfig);
+    turn.messages = applyAbsorbView(turn.messages, session.state, loopConfig, tokenCount);
     if (turn.nudge) turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
     nudge = turn.nudge;
     session.stats.contextTokens = tokenCount;
@@ -59170,10 +59350,11 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     const sysParts = [];
     if (systemText) sysParts.push(systemText);
     if (shouldInject) sysParts.push(buildCompressSystemPrompt(prompts));
+    if (absorbActive) sysParts.push(buildAbsorbSystemPrompt(absorbToolName(config)));
     rebuiltMessages = injectOpenaiSystem(rebuiltMessages, sysParts);
     openaiOutboundSystem = sysParts.join("\n\n");
     if (injectTools) {
-      toolsOut = injectOpenaiTool(parsed.tools);
+      toolsOut = injectOpenaiTool(parsed.tools, absorbActive ? ABSORB_TOOL_OPENAI : void 0);
     }
     if (willInjectNudge && turn.nudge) {
       try {
@@ -59253,10 +59434,14 @@ 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 turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags });
+    const tokenCount = effectiveTokenCount(session, msgs);
+    const absorbActive = absorbEnabled(config) && shouldInject && !isCompactionTrigger && !responsesTextProtocol;
+    const loopConfig = absorbActive ? config : { ...config, absorb: void 0 };
+    const turn = core.processTurn({ messages: msgs, state: session.state, config: loopConfig, tokenCount, renderTags });
     session.state = turn.state;
     session.stats.compressCreditTokens = 0;
+    storeEffectiveAbsorb(session, loopConfig);
+    turn.messages = applyAbsorbView(turn.messages, session.state, loopConfig, tokenCount);
     if (turn.nudge) turn.nudge.compressibleRanges = viableRanges(turn.nudge.compressibleRanges);
     nudge = turn.nudge;
     session.stats.contextTokens = tokenCount;
@@ -59273,11 +59458,13 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     const forgedSummaries = echoReplaced ? [] : session.metadata.codexForgedSummaries ?? [];
     if (shouldInject && !isCompactionTrigger && !process.env.ACP_NO_COMPRESS_PROMPT) {
       const prompt = responsesTextProtocol ? buildCompressHybridSystemPrompt(prompts) : buildCompressSystemPrompt(prompts);
-      const devContent = [...projection.systemParts, ...forgedSummaries, prompt].join("\n\n---\n\n");
+      const devParts = [...projection.systemParts, ...forgedSummaries, prompt];
+      if (absorbActive) devParts.push(buildAbsorbSystemPrompt(absorbToolName(config)));
+      const devContent = devParts.join("\n\n---\n\n");
       responsesDevContent = devContent;
       rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, devContent);
       if (!process.env.ACP_NO_INJECT_TOOL && injectTools) {
-        toolsOut = responsesTextProtocol ? injectResponsesTool(parsed.tools, ACP_READONLY_TOOLS_RESPONSES) : injectResponsesTool(parsed.tools);
+        toolsOut = responsesTextProtocol ? injectResponsesTool(parsed.tools, ACP_READONLY_TOOLS_RESPONSES) : injectResponsesTool(parsed.tools, absorbActive ? [...ACP_TOOLS_RESPONSES, ABSORB_TOOL_RESPONSES] : ACP_TOOLS_RESPONSES);
       }
     } else if (projection.systemParts.length > 0 || forgedSummaries.length > 0) {
       const devContent = [...projection.systemParts, ...forgedSummaries].join("\n\n---\n\n");
@@ -59422,14 +59609,16 @@ function prepareResponsesCompact(body, parsed, session, req, core, config, log2)
   let transformOk = false;
   try {
     const projection = responsesToCore(forgeBody);
-    const turn = core.processTurn({ messages: projection.msgs, state: session.state, config, tokenCount: session.stats.lastInputTokens, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
+    const compactConfig = { ...config, absorb: void 0 };
+    const turn = core.processTurn({ messages: projection.msgs, state: session.state, config: compactConfig, tokenCount: session.stats.lastInputTokens, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
     session.state = turn.state;
     transformOk = true;
     if (!codexCompactGate(session, config.modelContextLimit, transformOk)) {
       session.state = prevState;
       return base;
     }
-    const processed = repairResponsesAssistantOrdering(stripKernelSummaries(turn.messages, turn.state), projection.msgs);
+    const viewed = applyAbsorbView(turn.messages, turn.state, compactConfig, session.stats.lastInputTokens);
+    const processed = repairResponsesAssistantOrdering(stripKernelSummaries(viewed, turn.state), projection.msgs);
     const output = patchResponsesInput(projection, processed);
     if (typeof output === "string") {
       session.state = prevState;
@@ -59465,10 +59654,11 @@ function isAutoModeClassifier(parsed) {
   if (!Array.isArray(stops)) return false;
   return stops.some((s3) => typeof s3 === "string" && AUTO_MODE_CLASSIFIER_STOPS.has(s3));
 }
-function injectSystem(parsed, opts, prompts = defaultPrompts) {
+function injectSystem(parsed, opts, prompts = defaultPrompts, config) {
   const baseText = extractSystem(parsed.system);
   const parts = [];
   if (opts.compress.injectTool) parts.push(buildCompressSystemPrompt(prompts));
+  if (opts.compress.injectTool && absorbEnabled(config)) parts.push(buildAbsorbSystemPrompt(absorbToolName(config)));
   if (parts.length === 0) return parsed.system;
   const full = baseText ? `${baseText}
 
@@ -59477,19 +59667,23 @@ function injectSystem(parsed, opts, prompts = defaultPrompts) {
 ${parts.join("\n\n")}` : parts.join("\n\n");
   return buildSystem(full, parsed.system);
 }
-function injectTool(tools) {
-  if (!Array.isArray(tools)) return [...ACP_TOOLS_ANTHROPIC];
+function injectTool(tools, extra) {
+  if (!Array.isArray(tools)) return extra ? [...ACP_TOOLS_ANTHROPIC, extra] : [...ACP_TOOLS_ANTHROPIC];
   const names = new Set(tools.map((t) => t?.name));
   const missing = ACP_TOOLS_ANTHROPIC.filter((t) => !names.has(t.name));
-  return missing.length === 0 ? tools : [...tools, ...missing];
+  const extraMissing = extra && !names.has(extra.name);
+  if (missing.length === 0 && !extraMissing) return tools;
+  return [...tools, ...missing, ...extraMissing ? [extra] : []];
 }
-function injectOpenaiTool(tools) {
-  if (!Array.isArray(tools)) return [...ACP_TOOLS_OPENAI];
+function injectOpenaiTool(tools, extra) {
+  if (!Array.isArray(tools)) return extra ? [...ACP_TOOLS_OPENAI, extra] : [...ACP_TOOLS_OPENAI];
   const present = new Set(
     tools.map((t) => t?.function?.name).filter((n) => typeof n === "string")
   );
   const additions = ACP_TOOLS_OPENAI.filter((t) => !present.has(t.function.name));
-  return [...tools, ...additions];
+  const out = [...tools, ...additions];
+  if (extra && !out.some((t) => t?.function?.name === extra.function?.name)) out.push(extra);
+  return out;
 }
 var FORCE_TEXT_PROTOCOL = process.env.ACP_COMPRESS_PROTOCOL === "text";
 function injectResponsesTool(tools, toolsToAdd = ACP_TOOLS_RESPONSES) {
@@ -59551,17 +59745,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)`);
@@ -59573,9 +59807,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);
@@ -59584,30 +59823,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;
   }
@@ -59619,10 +59871,26 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
   const status = f2?.kind === "upstream" && f2.status === 429 ? 503 : 502;
   return failFast(status, f2?.detail ?? "the payload still exceeds the window after preflight compression", status === 503);
 }
+function armFailureShrink(prepared, log2, reason) {
+  const s3 = prepared.session;
+  let est;
+  try {
+    const text = typeof prepared.body === "string" ? prepared.body : prepared.body.toString("utf8");
+    est = estimateTokensFast(text);
+  } catch {
+    return;
+  }
+  if (!Number.isFinite(est) || est <= 0) return;
+  if (est > s3.stats.lastInputTokens) {
+    s3.stats.lastInputTokens = est;
+    markDirty(s3);
+    log2("warn", `[${s3.id}] ${reason} with no usage report \u2014 armed emergency shrink with local estimate ${est} tokens`);
+  }
+}
 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;
   }
@@ -59744,6 +60012,7 @@ ${bodyText}`);
     recordUpstreamConnection(upstreamUrl, proxyUrl);
   } catch (error) {
     recordUpstreamConnection(upstreamUrl, proxyUrl, error);
+    if (prepared && req.method !== "GET" && req.method !== "HEAD") armFailureShrink(prepared, log2, "network failure");
     throw new Error(`upstream request failed: ${formatUpstreamError(error, upstreamUrl, proxyUrl)}`, { cause: error });
   }
   if (compatProtocol && typeof wireBody === "string" && upstreamResult.response.status === 400 && upstreamResult.response.body) {
@@ -59764,28 +60033,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");
       }
     }
   }
@@ -59843,30 +60130,37 @@ ${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);
       }
     }
+    if (prepared?.session && upstream.status >= 500) {
+      armFailureShrink(prepared, log2, `upstream ${upstream.status}`);
+    }
     const errSid = prepared?.session.id ?? "unknown";
     const reqId = upstream.headers.get("x-request-id") ?? upstream.headers.get("request-id");
     const reqIdText = reqId ? ` request-id=${reqId}` : "";
@@ -59875,6 +60169,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"];
@@ -59883,7 +60189,7 @@ ${hdrText}
     clearUpstreamTimer();
     return;
   }
-  res.writeHead(upstream.status, respHeaders);
+  if (!res.headersSent) res.writeHead(upstream.status, respHeaders);
   if (!upstream.body) {
     res.end();
     clearUpstreamTimer();
@@ -59990,19 +60296,27 @@ ${hdrText}
         const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
         const reqHeaders = buildForwardHeaders(headers);
         const textProtocol = prepared.protocol === "responses" && !!prepared.responsesTextProtocol;
-        const systemPrompt = textProtocol ? buildCompressHybridSystemPrompt(prepared.prompts ?? defaultPrompts) : buildCompressSystemPrompt(prepared.prompts ?? defaultPrompts);
-        const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem, prepared.openaiSystemText, prepared.session.hostCreditTokens ?? 0);
+        const absorbActive = absorbEnabled(config) && opts.compress.injectTool && !textProtocol;
+        const loopConfig = absorbActive ? config : { ...config, absorb: void 0 };
+        const absorbSection = absorbActive ? `
+
+---
+
+${buildAbsorbSystemPrompt(absorbToolName(loopConfig))}` : "";
+        const systemPrompt = (textProtocol ? buildCompressHybridSystemPrompt(prepared.prompts ?? defaultPrompts) : buildCompressSystemPrompt(prepared.prompts ?? defaultPrompts)) + absorbSection;
+        const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem, prepared.openaiSystemText, prepared.session.hostCreditTokens ?? 0, absorbActive ? absorbToolName(loopConfig) : void 0);
         const refreshFolded = (current) => {
           const turn = core.processTurn({
             messages: prepared.originalMessages,
             state: prepared.session.state,
-            config,
+            config: loopConfig,
             tokenCount: prepared.session.stats.lastInputTokens,
             renderTags: prepared.renderTags ?? "text-only"
           });
           prepared.session.state = turn.state;
+          const viewed = applyAbsorbView(turn.messages, turn.state, loopConfig, prepared.session.stats.lastInputTokens);
           const records = current.filter((m2) => typeof m2.id === "string" && m2.id.startsWith("acp_loop_"));
-          return repairResponsesAssistantOrdering(stripKernelSummaries([...turn.messages, ...records], turn.state), prepared.originalMessages);
+          return repairResponsesAssistantOrdering(stripKernelSummaries([...viewed, ...records], turn.state), prepared.originalMessages);
         };
         const loop = runCompressLoop(
           streamToRead,