billion-context 0.1.56 → 0.1.57-pr.261.129

package/dist/index.js

@@ -43649,7 +43649,7 @@ function formatRanges(compressible, protectedRanges) {
   if (compressible.length === 0 && protectedRanges.length === 0) {
     return "[No specific ranges detected \u2014 compress any consumed content.]";
   }
-  const refNum2 = (ref) => {
+  const refNum3 = (ref) => {
     const m2 = ref.match(/\d+/);
     return m2 ? parseInt(m2[0], 10) : 0;
   };
@@ -43658,8 +43658,8 @@ function formatRanges(compressible, protectedRanges) {
     entries.push({
       startRef: r.startRef,
       endRef: r.endRef,
-      startNum: refNum2(r.startRef),
-      endNum: refNum2(r.endRef),
+      startNum: refNum3(r.startRef),
+      endNum: refNum3(r.endRef),
       count: r.count,
       tokens: r.tokens,
       toolPct: r.toolPct,
@@ -43676,8 +43676,8 @@ function formatRanges(compressible, protectedRanges) {
     entries.push({
       startRef: r.startRef,
       endRef: r.endRef,
-      startNum: refNum2(r.startRef),
-      endNum: refNum2(r.endRef),
+      startNum: refNum3(r.startRef),
+      endNum: refNum3(r.endRef),
       count: r.count,
       tokens: r.tokens,
       toolPct: 0,
@@ -46427,13 +46427,13 @@ function renderUncompressedRanges(visible) {
     lines.push("  (no uncompressed messages)");
     return lines.join("\n");
   }
-  const refNum2 = (ref) => {
+  const refNum22 = (ref) => {
     const m2 = ref.match(/\d+/);
     return m2 ? parseInt(m2[0], 10) : 0;
   };
   const merged = [];
   for (const m2 of visible) {
-    const num3 = refNum2(m2.ref);
+    const num3 = refNum22(m2.ref);
     const last = merged[merged.length - 1];
     if (last && num3 === last.startNum + last.count) {
       last.endRef = m2.ref;
@@ -49919,6 +49919,213 @@ function rewriteJsonResponse(body, ctx) {
   return body;
 }
 
+// src/preflight.ts
+var MAX_PREFLIGHT_ROUNDS = 8;
+var CHUNK_FRACTION = 0.6;
+var MIN_CHUNK_TOKENS = 2e3;
+var MIN_SUMMARY_CHARS = 50;
+var MAX_SUMMARY_OUTPUT_TOKENS = 8192;
+function refMaps(messages, state) {
+  const refToIdx = /* @__PURE__ */ new Map();
+  const idxToRef = /* @__PURE__ */ new Map();
+  const byRaw = state.messageRefs?.byRaw ?? {};
+  messages.forEach((m2, i) => {
+    const ref = byRaw[m2.id];
+    if (!ref) return;
+    if (!refToIdx.has(ref)) refToIdx.set(ref, i);
+    idxToRef.set(i, ref);
+  });
+  return { refToIdx, idxToRef };
+}
+function refNum2(ref) {
+  return Number(ref.replace(/\D/g, "")) || 0;
+}
+function estimateCoreMessages(messages) {
+  let tokens = 0;
+  for (const m2 of messages) tokens += defaultCountTokens(m2.text ?? "");
+  return tokens;
+}
+function rangeChars2(messages, startIdx, endIdx) {
+  let chars = 0;
+  for (let i = startIdx; i <= endIdx && i < messages.length; i++) {
+    chars += (messages[i].text ?? "").length;
+  }
+  return chars;
+}
+function renderRange(messages, startIdx, endIdx) {
+  const parts = [];
+  for (let i = startIdx; i <= endIdx && i < messages.length; i++) {
+    const m2 = messages[i];
+    const text = (m2.text ?? "").trim();
+    if (!text) continue;
+    const label = m2.contentType === "tool-call" ? `assistant tool-call ${m2.toolName ?? "?"}` : m2.contentType === "tool-result" ? `tool result ${m2.toolName ?? "?"}` : m2.contentType === "reasoning" ? "assistant reasoning" : m2.role;
+    parts.push(`[${label}]
+${text}`);
+  }
+  return parts.join("\n\n");
+}
+function splitChunks(messages, startIdx, endIdx, budgetTokens) {
+  const chunks = [];
+  let cur = startIdx;
+  while (cur <= endIdx) {
+    let tokens = 0;
+    let last = cur;
+    for (let i = cur; i <= endIdx; i++) {
+      const t = defaultCountTokens(messages[i].text ?? "");
+      if (tokens + t > budgetTokens && i > cur) break;
+      tokens += t;
+      last = i;
+    }
+    chunks.push([cur, last]);
+    cur = last + 1;
+  }
+  return chunks;
+}
+function summaryPayload(protocol, model, system, content) {
+  if (protocol === "anthropic") {
+    return { model, max_tokens: MAX_SUMMARY_OUTPUT_TOKENS, system, messages: [{ role: "user", content }], stream: false };
+  }
+  if (protocol === "openai") {
+    return { model, max_tokens: MAX_SUMMARY_OUTPUT_TOKENS, messages: [{ role: "system", content: system }, { role: "user", content }], stream: false };
+  }
+  return { model, max_output_tokens: MAX_SUMMARY_OUTPUT_TOKENS, instructions: system, input: [{ role: "user", content }], stream: false };
+}
+function extractSummaryText(protocol, json) {
+  if (protocol === "anthropic") {
+    const content = json.content;
+    if (!Array.isArray(content)) return "";
+    return content.map((c) => c && typeof c === "object" && c.type === "text" && typeof c.text === "string" ? c.text : "").join("");
+  }
+  if (protocol === "openai") {
+    const choices = json.choices;
+    if (!Array.isArray(choices) || choices.length === 0) return "";
+    const msg = choices[0].message;
+    if (!msg || typeof msg !== "object") return "";
+    const c = msg.content;
+    if (typeof c === "string") return c;
+    if (Array.isArray(c)) {
+      return c.map((p2) => p2 && typeof p2 === "object" && typeof p2.text === "string" ? p2.text : "").join("");
+    }
+    return "";
+  }
+  if (typeof json.output_text === "string") return json.output_text;
+  const output = json.output;
+  if (!Array.isArray(output)) return "";
+  return output.map((o) => o && typeof o === "object" ? o.content : void 0).filter((c) => Array.isArray(c)).flatMap((c) => c).map((p2) => p2 && typeof p2 === "object" && typeof p2.text === "string" ? p2.text : "").join("");
+}
+async function summarizeRange(deps, content, startRef, endRef) {
+  const system = buildCompressSystemPrompt(deps.prompts) + `
+
+TASK: The conversation segment below (messages ${startRef}\u2013${endRef}) must be compressed because the session context exceeds the current model's window. Write a tier-1 compression summary of the segment following every rule above. Output ONLY the summary text \u2014 no preamble, no closing remarks, no tool calls.`;
+  const { response, clearTimer } = await fetchWithRetry(
+    deps.url,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json", ...deps.headers },
+      body: JSON.stringify(summaryPayload(deps.protocol, deps.model, system, content)),
+      dispatcher: proxyDispatcher(deps.proxyUrl)
+    },
+    void 0,
+    deps.signal,
+    (info) => deps.log("warn", `[preflight] summary attempt ${info.attempt} got HTTP ${info.status}; retrying in ${info.delayMs}ms`)
+  );
+  try {
+    const text = await response.text();
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      deps.log("warn", `[preflight] summary response was not JSON: ${text.slice(0, 200)}`);
+      return null;
+    }
+    if (!json || typeof json !== "object") return null;
+    const summary = extractSummaryText(deps.protocol, json).trim();
+    if (summary.length < MIN_SUMMARY_CHARS) {
+      deps.log("warn", `[preflight] summary too short (${summary.length} chars); skipping range`);
+      return null;
+    }
+    return summary;
+  } finally {
+    clearTimer();
+  }
+}
+async function preflightCompress(deps, messages) {
+  const limit = deps.config.modelContextLimit;
+  const result = { compressedRanges: 0, savedTokens: 0 };
+  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;
+  for (let round = 0; round < MAX_PREFLIGHT_ROUNDS; round++) {
+    if (deps.signal?.aborted) break;
+    const turn = deps.core.processTurn({
+      messages,
+      state: deps.session.state,
+      config: deps.config,
+      tokenCount: currentTokens,
+      renderTags: "text-only"
+    });
+    deps.session.state = turn.state;
+    currentTokens = Math.max(deps.session.stats.lastInputTokens, estimateCoreMessages(turn.messages));
+    if (startTokens < 0) startTokens = currentTokens;
+    if (currentTokens < limit) break;
+    const ranges = viableRanges(turn.nudge?.compressibleRanges ?? []);
+    if (ranges.length === 0) 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;
+    let appliedThisRound = 0;
+    for (const [cs2, ce2] of splitChunks(messages, startIdx, endIdx, budget)) {
+      if (currentTokens < limit) break;
+      if (deps.signal?.aborted) break;
+      const maps = refMaps(messages, deps.session.state);
+      const startRef = maps.idxToRef.get(cs2);
+      const endRef = maps.idxToRef.get(ce2);
+      if (!startRef || !endRef) continue;
+      if (rangeChars2(messages, cs2, ce2) < minChars) continue;
+      const content = renderRange(messages, cs2, ce2);
+      if (content.length === 0) continue;
+      let summary;
+      try {
+        summary = await summarizeRange(deps, content, startRef, endRef);
+      } catch (err2) {
+        if (err2 instanceof UpstreamHttpError) {
+          deps.log("warn", `[preflight] summarization failed: HTTP ${err2.status} ${err2.body.slice(0, 200)}`);
+        } else {
+          deps.log("warn", `[preflight] summarization failed: ${String(err2)}`);
+        }
+        break;
+      }
+      if (!summary) continue;
+      const ctx = {
+        core: deps.core,
+        config: deps.config,
+        messages,
+        session: deps.session,
+        log: (msg) => deps.log("info", msg)
+      };
+      const creditBefore = deps.session.stats.compressCreditTokens;
+      const applied = applyRanges(parseCompressInput({ content: [{ startId: startRef, endId: endRef, summary, topic: "preflight overflow compress" }] }), ctx);
+      if (applied.startsWith("[Compression FAILED")) {
+        deps.log("warn", `[preflight] ${applied}`);
+        continue;
+      }
+      const compressed = deps.session.stats.compressCreditTokens - creditBefore;
+      currentTokens = Math.max(0, currentTokens - compressed + defaultCountTokens(summary));
+      deps.session.stats.lastInputTokens += defaultCountTokens(summary);
+      appliedThisRound += 1;
+      result.compressedRanges += 1;
+    }
+    if (appliedThisRound === 0) break;
+  }
+  if (result.compressedRanges > 0) deps.session.stats.lastInputTokens = currentTokens;
+  result.savedTokens = Math.max(0, startTokens - currentTokens);
+  return result;
+}
+
 // src/web/index.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { dirname as dirname4, join as join3 } from "path";
@@ -50212,6 +50419,10 @@ ${icon} [ACP] ${inner}
 
 // src/loop/core.ts
 var MAX_LOOP_ROUNDS = 10;
+function maxTruncationRetries() {
+  const raw = Number(process.env.BILI_TRUNCATION_RETRY_MAX);
+  return Number.isInteger(raw) && raw >= 0 ? raw : 2;
+}
 function isLoopThinking(m2) {
   return m2.contentType === "reasoning" && typeof m2.id === "string" && m2.id.startsWith("acp_loop_");
 }
@@ -50292,6 +50503,7 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
   let currentUpstream = upstream;
   const coreMessages = [...ctx.messages];
   let degradedRetried = false;
+  let truncationRetries = 0;
   try {
     for (let round = 1; round <= MAX_LOOP_ROUNDS; round++) {
       if (signal?.aborted) break;
@@ -50461,7 +50673,9 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
         yield adapter.emitToolCall(tc);
       }
       const reRequest = proxyResults.length > 0 && realCalls === 0;
-      if (!reRequest) {
+      const zeroContent = assistantText.length === 0 && assistantReasoning.length === 0;
+      const canRetryTruncation = !sawDone && zeroContent && realCalls === 0 && round < MAX_LOOP_ROUNDS && truncationRetries < maxTruncationRetries();
+      if (!reRequest && !canRetryTruncation) {
         if (!sawDone) {
           const partialText = assistantText.length;
           const partialReasoning = assistantReasoning.length;
@@ -50482,7 +50696,14 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
         yield adapter.emitCompletion({ finishReason: "length", usage });
         return;
       }
-      ctx.log(`[acp-loop] round ${round}: proxy tool executed; re-requesting so the model sees the result`);
+      if (canRetryTruncation && !reRequest) {
+        truncationRetries += 1;
+        const max = maxTruncationRetries();
+        ctx.log(`[acp-loop] round ${round}: upstream truncated with no content; auto-retrying (attempt ${truncationRetries}/${max})`);
+        log("warn", `[acp-loop] upstream stream truncated with no content (round ${round}); auto-retrying (attempt ${truncationRetries}/${max})`);
+      } else {
+        ctx.log(`[acp-loop] round ${round}: proxy tool executed; re-requesting so the model sees the result`);
+      }
       if (signal?.aborted) break;
       const fetchUpstream = (body) => fetchWithRetry(
         requestOptions.url,
@@ -50628,6 +50849,20 @@ function shouldReserveOutputHeadroom(protocol) {
 
 // src/loop/adapter-responses.ts
 var RESPONSES_ITEM_ID_MAX = 64;
+function normalizeResponsesMessageItems(input) {
+  if (!Array.isArray(input)) return 0;
+  let typed = 0;
+  for (const item of input) {
+    if (typeof item !== "object" || item === null) continue;
+    const rec = item;
+    if (rec["type"] !== void 0) continue;
+    if (rec["role"] !== "user" && rec["role"] !== "assistant") continue;
+    if (rec["content"] === void 0) continue;
+    rec["type"] = "message";
+    typed++;
+  }
+  return typed;
+}
 function sanitizeResponsesInputIds(input) {
   if (!Array.isArray(input)) return;
   for (const item of input) {
@@ -52469,7 +52704,10 @@ function takePendingPluginRegister() {
 var registeredIds = /* @__PURE__ */ new Map();
 function consumePluginRegisterFor(conversationId2) {
   const agent = registeredIds.get(conversationId2);
-  if (agent !== void 0) registeredIds.delete(conversationId2);
+  if (agent !== void 0) {
+    registeredIds.delete(conversationId2);
+    registeredIds.set(conversationId2, agent);
+  }
   return agent;
 }
 function handlePluginRegister(payload, res) {
@@ -54789,17 +55027,23 @@ ${bodyBuffer.toString("utf8")}`);
       conversationIdentityResponses(parsed, convHeader),
       parsed
     ) : void 0;
-    const conversation = protocol === "anthropic" ? conversationSignalAnthropic(parsed, convHeader) : protocol === "openai" ? conversationSignalOpenai(parsed, convHeader) : subagentNamespace(
+    const openaiSignal = protocol === "openai" ? conversationSignalOpenai(parsed, convHeader) : "";
+    const openaiIdentity = protocol === "openai" ? preferPromptCacheKeyIdentity(
+      convHeader ? { value: openaiSignal, source: "header", clientProvided: true } : { value: openaiSignal, source: "content-fingerprint", clientProvided: false },
+      parsed
+    ) : void 0;
+    const conversation = protocol === "anthropic" ? conversationSignalAnthropic(parsed, convHeader) : protocol === "openai" ? openaiIdentity?.value ?? openaiSignal : subagentNamespace(
       responsesIdentity?.value ?? conversationSignalResponses(parsed, convHeader),
       parsed.instructions
     );
     const sessionId = deriveSessionId(req.headers, protocol, upstreamOrigin, conversation);
-    const affinity = affinityToken(responsesIdentity ?? {
+    const bodyIdentity = responsesIdentity ?? openaiIdentity;
+    const affinity = affinityToken(bodyIdentity ?? {
       value: clientConv ?? conversation,
       source: clientConv ? "header" : "generated",
       clientProvided: !!clientConv
     });
-    const clientLabel = responsesIdentity?.clientProvided ? responsesIdentity.value : clientConversationHeader(req.headers);
+    const clientLabel = bodyIdentity?.clientProvided ? bodyIdentity.value : clientConversationHeader(req.headers);
     const session = getSession(sessionId, { protocol, upstreamOrigin, label: clientLabel ?? void 0 });
     if (!pluginAgent) {
       const identityAgent = consumePluginRegisterFor(clientConv ?? conversation);
@@ -54822,7 +55066,7 @@ ${bodyBuffer.toString("utf8")}`);
       session.metadata.effectiveContextLimit = reqConfig.modelContextLimit;
       recordPluginSession(pluginConversation ?? conversation, session.id);
     }
-    if (protocol === "responses") {
+    if (protocol === "responses" || protocol === "openai") {
       const pck = parsed.prompt_cache_key;
       if (typeof pck === "string" && pck.trim().length > 0) {
         recordPluginSession(pck.trim(), session.id);
@@ -54847,7 +55091,23 @@ ${bodyBuffer.toString("utf8")}`);
     acquireInFlight(session);
     try {
       await withSessionLock(session, async () => {
-        prepared = 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);
+        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);
+        prepared = runPrepare();
+        if (!countTokens && !responsesCompact) {
+          prepared = await preflightCompressIfNeeded(
+            prepared,
+            runPrepare,
+            req,
+            res,
+            opts,
+            core,
+            reqConfig,
+            parsed.model,
+            route,
+            affinity,
+            log2
+          );
+        }
         await forward(req, res, opts, prepared.body, prepared, core, reqConfig, log2, route, affinity);
         if (prepared) {
           rememberPluginMessages(sessionId, prepared.processedMessages, prepared.originalMessages, prepared.nudge);
@@ -54865,8 +55125,15 @@ ${bodyBuffer.toString("utf8")}`);
   }
 }
 var ACP_TAG_MARK = "<acp ";
-function stripKernelSummaries(messages) {
-  return messages.filter((m2) => !(m2.id ?? "").startsWith("acp_summary_"));
+function stripKernelSummaries(messages, state) {
+  const carried = /* @__PURE__ */ new Set();
+  for (const b2 of state.blocks) {
+    if (!b2.active || !b2.compressCallId) continue;
+    if (messages.some((m2) => m2.contentType === "tool-call" && m2.toolCallId === b2.compressCallId)) {
+      carried.add(`acp_summary_${b2.blockId}`);
+    }
+  }
+  return messages.filter((m2) => !(m2.id ?? "").startsWith("acp_summary_") || !carried.has(m2.id));
 }
 function diagTagSummary(messages, sessionId, strategy) {
   let textTagged = 0;
@@ -54921,7 +55188,7 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
     }
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model));
-    processedMessages = stripKernelSummaries(turn.messages);
+    processedMessages = stripKernelSummaries(turn.messages, turn.state);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToAnthropic(processedMessages, cacheControls);
     systemOut = injectSystem(parsed, opts, prompts);
@@ -54977,7 +55244,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     }
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model));
-    processedMessages = stripKernelSummaries(turn.messages);
+    processedMessages = stripKernelSummaries(turn.messages, turn.state);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToOpenai(processedMessages);
     const sysParts = [];
@@ -55021,6 +55288,10 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
   let responsesProjection;
   let rebuiltInput = parsed.input;
   let toolsOut = parsed.tools;
+  const typedItems = normalizeResponsesMessageItems(parsed.input);
+  if (typedItems > 0) {
+    log2("info", `[${sessionId}] stamped type:"message" on ${typedItems} type-less input item(s) before projection (omp wire form)`);
+  }
   sanitizeResponsesInputIds(parsed.input);
   const droppedEmpty = dropWhitespaceResponsesMessages(parsed.input);
   if (droppedEmpty > 0) {
@@ -55050,7 +55321,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     }
     log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
     log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit, parsed.model));
-    processedMessages = stripKernelSummaries(turn.messages);
+    processedMessages = stripKernelSummaries(turn.messages, turn.state);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltInput = patchResponsesInput(projection, processedMessages);
     if (shouldInject && !process.env.ACP_NO_COMPRESS_PROMPT) {
@@ -55121,7 +55392,7 @@ function prepareCountTokens(parsed, core, config, log2, session) {
   try {
     const { msgs, cacheControls } = anthropicToCore(parsed);
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount: session.stats.lastInputTokens, renderTags: "text-only" });
-    const stripped = stripKernelSummaries(turn.messages);
+    const stripped = stripKernelSummaries(turn.messages, turn.state);
     const rebuiltMessages = coreToAnthropic(stripped, cacheControls);
     log2("info", `[${sessionId}] count_tokens pruned: ${msgs.length} \u2192 ${stripped.length} msgs`);
     return {
@@ -55208,11 +55479,71 @@ function injectResponsesTool(tools, toolsToAdd = ACP_TOOLS_RESPONSES) {
   const additions = toolsToAdd.filter((t) => !present.has(t.name));
   return [...tools, ...additions];
 }
-async function forward(req, res, opts, body, prepared, core, config, log2, route, affinity) {
+function buildForwardTarget(req, opts, route, affinity) {
   const reqUrl = req.url ?? "";
   const isAbsoluteUrl = /^https?:\/\//i.test(reqUrl);
   const rewritten = route ? route.rewrittenUrl : isAbsoluteUrl ? reqUrl : opts.upstream + reqUrl;
   const upstreamUrl = rewritten.replace(/^mitm:\/\//, "https://");
+  const headers = {};
+  const reqConnNamed = connectionNamedHeaders(req.headers["connection"]);
+  for (const [k2, v2] of Object.entries(req.headers)) {
+    const lower = k2.toLowerCase();
+    if (UPSTREAM_HOP_HEADERS.has(lower) || reqConnNamed.has(lower) || v2 === void 0) continue;
+    headers[k2] = Array.isArray(v2) ? v2.join(", ") : v2;
+  }
+  headers["host"] = new URL(upstreamUrl).host;
+  const betaKey = Object.keys(headers).find((h) => h.toLowerCase() === "x-codex-beta-features");
+  if (betaKey) {
+    const kept = headers[betaKey].split(",").map((s3) => s3.trim()).filter((f2) => f2 && f2 !== "remote_compaction_v2");
+    if (kept.length > 0) headers[betaKey] = kept.join(",");
+    else delete headers[betaKey];
+  }
+  if (affinity && !clientConversationHeader(req.headers)) {
+    headers["x-session-id"] = 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) {
+  const session = prepared.session;
+  const limit = config.modelContextLimit;
+  const tokenCount = Math.max(session.stats.lastInputTokens, estimateCoreMessages(prepared.processedMessages));
+  if (limit <= 0 || !model || tokenCount < limit) return prepared;
+  if ((prepared.nudge?.compressibleRanges ?? []).length === 0) return prepared;
+  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 clientAbort = new AbortController();
+  res.on("close", () => {
+    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
+    },
+    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;
+  }
+  log2("warn", `[${session.id}] preflight could not compress enough (~${result.savedTokens} tokens saved); forwarding as-is`);
+  return prepared;
+}
+async function forward(req, res, opts, body, prepared, core, config, log2, route, affinity) {
+  const { upstreamUrl, headers, proxyUrl } = buildForwardTarget(req, opts, route, affinity);
   log2("info", `forward ${req.method} \u2192 ${upstreamUrl}`);
   if (process.env.ACP_DEBUG && prepared) {
     const sid = prepared.session.id;
@@ -55254,24 +55585,6 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
     } catch {
     }
   }
-  const headers = {};
-  const reqConnNamed = connectionNamedHeaders(req.headers["connection"]);
-  for (const [k2, v2] of Object.entries(req.headers)) {
-    const lower = k2.toLowerCase();
-    if (UPSTREAM_HOP_HEADERS.has(lower) || reqConnNamed.has(lower) || v2 === void 0) continue;
-    headers[k2] = Array.isArray(v2) ? v2.join(", ") : v2;
-  }
-  headers["host"] = new URL(upstreamUrl).host;
-  const betaKey = Object.keys(headers).find((h) => h.toLowerCase() === "x-codex-beta-features");
-  if (betaKey) {
-    const kept = headers[betaKey].split(",").map((s3) => s3.trim()).filter((f2) => f2 && f2 !== "remote_compaction_v2");
-    if (kept.length > 0) headers[betaKey] = kept.join(",");
-    else delete headers[betaKey];
-  }
-  if (affinity && !clientConversationHeader(req.headers)) {
-    headers["x-session-id"] = affinity;
-  }
-  const proxyUrl = resolveProxy(opts.routes, opts.proxy, route?.rewrittenUrl ?? upstreamUrl, opts.proxyFallback);
   if (opts.debug) {
     const hdrLog = {};
     for (const [hk, hv] of Object.entries(headers)) {