billion-context 0.1.41 → 0.1.42

package/dist/index.js

@@ -13679,8 +13679,8 @@ var require_snapshot_utils = __commonJS({
         match: new Set(matchHeaders.map((header) => caseSensitive ? header : header.toLowerCase()))
       };
     }
-    var crypto = runtimeFeatures.has("crypto") ? __require("crypto") : null;
-    var hashId2 = crypto?.hash ? (value) => crypto.hash("sha256", value, "base64url") : (value) => Buffer.from(value).toString("base64url");
+    var crypto2 = runtimeFeatures.has("crypto") ? __require("crypto") : null;
+    var hashId2 = crypto2?.hash ? (value) => crypto2.hash("sha256", value, "base64url") : (value) => Buffer.from(value).toString("base64url");
     function isUndiciHeaders(headers) {
       return Array.isArray(headers) && (headers.length & 1) === 0;
     }
@@ -20209,10 +20209,10 @@ var require_subresource_integrity = __commonJS({
     var assert = __require("assert");
     var { runtimeFeatures } = require_runtime_features();
     var validSRIHashAlgorithmTokenSet = /* @__PURE__ */ new Map([["sha256", 0], ["sha384", 1], ["sha512", 2]]);
-    var crypto;
+    var crypto2;
     if (runtimeFeatures.has("crypto")) {
-      crypto = __require("crypto");
-      const cryptoHashes = crypto.getHashes();
+      crypto2 = __require("crypto");
+      const cryptoHashes = crypto2.getHashes();
       if (cryptoHashes.length === 0) {
         validSRIHashAlgorithmTokenSet.clear();
       }
@@ -20302,7 +20302,7 @@ var require_subresource_integrity = __commonJS({
       return result;
     }
     var applyAlgorithmToBytes = (algorithm, bytes) => {
-      return crypto.hash(algorithm, bytes, "base64");
+      return crypto2.hash(algorithm, bytes, "base64");
     };
     function caseSensitiveMatch(actualValue, expectedValue) {
       let actualValueLength = actualValue.length;
@@ -23285,7 +23285,7 @@ var require_connection = __commonJS({
     var { WebsocketFrameSend } = require_frame();
     var assert = __require("assert");
     var { runtimeFeatures } = require_runtime_features();
-    var crypto = runtimeFeatures.has("crypto") ? __require("crypto") : null;
+    var crypto2 = runtimeFeatures.has("crypto") ? __require("crypto") : null;
     var warningEmitted = false;
     function establishWebSocketConnection(url, protocols, client, handler, options) {
       const requestURL = url;
@@ -23305,7 +23305,7 @@ var require_connection = __commonJS({
         const headersList = getHeadersList(new Headers(options.headers));
         request.headersList = headersList;
       }
-      const keyValue = crypto.randomBytes(16).toString("base64");
+      const keyValue = crypto2.randomBytes(16).toString("base64");
       request.headersList.append("sec-websocket-key", keyValue, true);
       request.headersList.append("sec-websocket-version", "13", true);
       for (const protocol of protocols) {
@@ -23345,7 +23345,7 @@ var require_connection = __commonJS({
             return;
           }
           const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
-          const digest = crypto.hash("sha1", keyValue + uid, "base64");
+          const digest = crypto2.hash("sha1", keyValue + uid, "base64");
           if (secWSAccept !== digest) {
             failWebsocketConnection(handler, 1002, "Incorrect hash received in Sec-WebSocket-Accept header.");
             return;
@@ -29907,36 +29907,36 @@ var require_pbkdf2 = __commonJS({
     require_md();
     require_util7();
     var pkcs5 = forge2.pkcs5 = forge2.pkcs5 || {};
-    var crypto;
+    var crypto2;
     if (forge2.util.isNodejs && !forge2.options.usePureJavaScript) {
-      crypto = __require("crypto");
+      crypto2 = __require("crypto");
     }
     module.exports = forge2.pbkdf2 = pkcs5.pbkdf2 = function(p2, s3, c, dkLen, md, callback) {
       if (typeof md === "function") {
         callback = md;
         md = null;
       }
-      if (forge2.util.isNodejs && !forge2.options.usePureJavaScript && crypto.pbkdf2 && (md === null || typeof md !== "object") && (crypto.pbkdf2Sync.length > 4 || (!md || md === "sha1"))) {
+      if (forge2.util.isNodejs && !forge2.options.usePureJavaScript && crypto2.pbkdf2 && (md === null || typeof md !== "object") && (crypto2.pbkdf2Sync.length > 4 || (!md || md === "sha1"))) {
         if (typeof md !== "string") {
           md = "sha1";
         }
         p2 = Buffer.from(p2, "binary");
         s3 = Buffer.from(s3, "binary");
         if (!callback) {
-          if (crypto.pbkdf2Sync.length === 4) {
-            return crypto.pbkdf2Sync(p2, s3, c, dkLen).toString("binary");
+          if (crypto2.pbkdf2Sync.length === 4) {
+            return crypto2.pbkdf2Sync(p2, s3, c, dkLen).toString("binary");
           }
-          return crypto.pbkdf2Sync(p2, s3, c, dkLen, md).toString("binary");
+          return crypto2.pbkdf2Sync(p2, s3, c, dkLen, md).toString("binary");
         }
-        if (crypto.pbkdf2Sync.length === 4) {
-          return crypto.pbkdf2(p2, s3, c, dkLen, function(err3, key) {
+        if (crypto2.pbkdf2Sync.length === 4) {
+          return crypto2.pbkdf2(p2, s3, c, dkLen, function(err3, key) {
             if (err3) {
               return callback(err3);
             }
             callback(null, key.toString("binary"));
           });
         }
-        return crypto.pbkdf2(p2, s3, c, dkLen, md, function(err3, key) {
+        return crypto2.pbkdf2(p2, s3, c, dkLen, md, function(err3, key) {
           if (err3) {
             return callback(err3);
           }
@@ -43760,7 +43760,8 @@ function defaultConfig(modelContextLimit, overrides = {}) {
       growthCap: 5e4,
       minGrowthFloor: 2e4,
       minGrowthRatio: 0.45,
-      emergencyThresholdPct: 0.95
+      emergencyThresholdPct: 0.95,
+      tier2GrowthMultiplier: 1.5
     },
     promotionThreshold: 5,
     truncate: { threshold: 0.95 },
@@ -44485,6 +44486,44 @@ function buildCompressibleRanges(messages, state, config, protectedZoneRefs, cou
     protected: protectedRanges
   };
 }
+function mergeBatch(batch) {
+  const first = batch[0];
+  const last = batch[batch.length - 1];
+  const count = batch.reduce((s3, r) => s3 + r.count, 0);
+  const tokens = batch.reduce((s3, r) => s3 + r.tokens, 0);
+  const toolPct = Math.round(
+    batch.reduce((s3, r) => s3 + r.toolPct * r.count, 0) / count
+  );
+  const merged = {
+    startRef: first.startRef,
+    endRef: last.endRef,
+    count,
+    tokens,
+    toolPct,
+    textPct: 100 - toolPct
+  };
+  if (batch.some((r) => r.dangerous === true)) {
+    merged.dangerous = true;
+  }
+  return merged;
+}
+function mergeRangesToThreshold(ranges, minChars) {
+  if (minChars <= 0 || ranges.length === 0) return ranges;
+  const result = [];
+  let batch = [];
+  for (const r of ranges) {
+    batch.push(r);
+    const batchTokens = batch.reduce((s3, x) => s3 + x.tokens, 0);
+    if (batchTokens * 4 >= minChars) {
+      result.push(mergeBatch(batch));
+      batch = [];
+    }
+  }
+  if (batch.length > 0) {
+    result.push(mergeBatch(batch));
+  }
+  return result;
+}
 function runPipeline(nodes, initial, ctx) {
   let io2 = initial;
   for (const node of nodes) {
@@ -44764,7 +44803,10 @@ var recommendNode = {
     const nothingToCompress = contextRanges.compressible.length === 0;
     const recommendation = {
       contextRanges,
-      recommendedRanges: contextRanges.compressible,
+      recommendedRanges: mergeRangesToThreshold(
+        contextRanges.compressible,
+        ctx.config.compress.minCompressRange
+      ),
       nothingToCompress
     };
     return { ...io2, effects: { ...io2.effects, recommendation } };
@@ -44790,6 +44832,7 @@ var nudgeNode = {
     if (baseline > 0 && ctx.tokenCount < baseline - nudgeGrowthTokens) {
       stamped.lastPerMessageNudgeTokens = ctx.tokenCount;
       stamped.lastNudgeShownTokens = 0;
+      stamped.lastShownByTier = {};
     }
     if (stamped.lastPerMessageNudgeTokens === 0) {
       stamped.lastPerMessageNudgeTokens = ctx.tokenCount;
@@ -45058,10 +45101,11 @@ function resolveAdaptiveGrowth(modelContextLimit, nudge) {
     )
   );
 }
-function pendingByTier(state, recommendation, countTokens) {
+function pendingByTier(state, recommendation, countTokens, minCompressRange) {
   const out = {};
-  const compressible = recommendation?.contextRanges.compressible ?? [];
-  out[1] = { pending: compressible.reduce((s3, r) => s3 + r.tokens, 0), targetBlocks: [] };
+  const merged = recommendation?.recommendedRanges ?? [];
+  const effective = minCompressRange > 0 ? merged.filter((r) => r.tokens * 4 >= minCompressRange) : merged;
+  out[1] = { pending: effective.reduce((s3, r) => s3 + r.tokens, 0), targetBlocks: [] };
   const active = activeBlocks(state);
   const t1 = active.filter((b2) => b2.tier === 1);
   const t2 = active.filter((b2) => b2.tier === 2);
@@ -45076,6 +45120,7 @@ function decideNudge(input) {
   const nudgeGrowthTokens = resolveAdaptiveGrowth(limit, config.nudge);
   const overLimit = usage >= config.nudge.maxContextLimitPct;
   const emergencyOverride = usage >= config.nudge.emergencyThresholdPct;
+  const pressure = overLimit || emergencyOverride;
   const baseline = state.nudge.lastPerMessageNudgeTokens;
   const hadPendingNudge = state.nudge.lastNudgeShownTokens > 0;
   const hasPendingNudge = hadPendingNudge;
@@ -45087,44 +45132,67 @@ function decideNudge(input) {
   );
   const growthSinceReference = tokenCount - growthReference;
   const rec = recommendation;
-  const tiers = pendingByTier(state, rec, countTokens);
+  const tiers = pendingByTier(
+    state,
+    rec,
+    countTokens,
+    config.compress.minCompressRange
+  );
+  const tier2Threshold = Math.round(
+    nudgeGrowthTokens * (config.nudge.tier2GrowthMultiplier ?? 1.5)
+  );
   let injectedTier = null;
   let injectedReason = "";
   const growthReady = growthSinceReference >= growthFloor;
-  if (!overLimit && growthReady) {
-    for (const tier of [1, 2, 3]) {
-      if (!config.tiers.enabled && tier > 1) break;
-      const info = tiers[tier];
-      if (!info || info.pending < nudgeGrowthTokens) continue;
-      const lastShown = state.nudge.lastShownByTier[tier] ?? 0;
+  const t1Eff = tiers[1]?.pending ?? 0;
+  const t2Pen = tiers[2]?.pending ?? 0;
+  const t3Pen = tiers[3]?.pending ?? 0;
+  if (pressure) {
+    const candidates = [1];
+    if (config.tiers.enabled) {
+      candidates.push(2, 3);
+    }
+    let best = null;
+    let bestPending = 0;
+    for (const t of candidates) {
+      const p2 = tiers[t]?.pending ?? 0;
+      if (p2 > bestPending) {
+        bestPending = p2;
+        best = t;
+      }
+    }
+    if (best !== null && bestPending > 0) {
+      injectedTier = best;
+      const label = emergencyOverride ? "EMERGENCY" : "OVER-LIMIT";
+      injectedReason = best === 1 ? `${label} T1: max effective pending ${bestPending}, usage ${Math.round(usage * 100)}%` : `${label} T${best} distill: max pending ${bestPending} (T1 effective ${t1Eff}, T2 ${t2Pen}, T3 ${t3Pen}), usage ${Math.round(usage * 100)}%`;
+    }
+  } else if (growthReady) {
+    if (t1Eff >= nudgeGrowthTokens) {
+      injectedTier = 1;
+      injectedReason = `T1 effective ${t1Eff} >= ${nudgeGrowthTokens}, growth ${growthSinceReference}, usage ${Math.round(usage * 100)}%`;
+    } else if (config.tiers.enabled && t2Pen >= tier2Threshold && t2Pen > t1Eff) {
+      const lastShown = state.nudge.lastShownByTier[2] ?? 0;
       const cadenceMet = lastShown === 0 || tokenCount - lastShown >= growthFloor;
-      if (!cadenceMet) continue;
-      injectedTier = tier;
-      injectedReason = tier === 1 ? `T1 compressible ${info.pending} >= ${nudgeGrowthTokens}, growth ${growthSinceReference}, usage ${Math.round(usage * 100)}%` : `T${tier} distill ready: ${info.targetBlocks.length} tier-${tier - 1} blocks (${info.pending} tokens) >= ${nudgeGrowthTokens}, usage ${Math.round(usage * 100)}%`;
-      break;
-    }
-  } else if (overLimit) {
-    for (const tier of [1, 2, 3]) {
-      if (!config.tiers.enabled && tier > 1) break;
-      const info = tiers[tier];
-      if (!info || info.pending < config.compress.minCompressRange) continue;
-      injectedTier = tier;
-      injectedReason = emergencyOverride ? `EMERGENCY: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.emergencyThresholdPct * 100)}%, T${tier} pending ${info.pending}` : `OVER-LIMIT: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.maxContextLimitPct * 100)}%, T${tier} pending ${info.pending}`;
-      break;
+      if (cadenceMet) {
+        injectedTier = 2;
+        injectedReason = `T2 distill ready: ${tiers[2].targetBlocks.length} tier-1 blocks (${t2Pen} tokens) >= ${tier2Threshold} (1.5x) and > T1 effective ${t1Eff}, usage ${Math.round(usage * 100)}%`;
+      }
+    } else if (config.tiers.enabled && t3Pen >= tier2Threshold && t3Pen > t2Pen && t3Pen > t1Eff) {
+      const lastShown = state.nudge.lastShownByTier[3] ?? 0;
+      const cadenceMet = lastShown === 0 || tokenCount - lastShown >= growthFloor;
+      if (cadenceMet) {
+        injectedTier = 3;
+        injectedReason = `T3 condense ready: ${tiers[3].targetBlocks.length} tier-2 blocks (${t3Pen} tokens) >= ${tier2Threshold} (1.5x) and > T2 ${t2Pen} and > T1 effective ${t1Eff}, usage ${Math.round(usage * 100)}%`;
+      }
     }
   }
-  const shouldInject = injectedTier !== null || overLimit && (rec?.recommendedRanges?.length ?? 0) > 0;
+  const shouldInject = injectedTier !== null;
   let reason;
-  if (emergencyOverride && injectedTier !== null) {
-    reason = injectedReason;
-  } else if (emergencyOverride) {
-    reason = `EMERGENCY: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.emergencyThresholdPct * 100)}% (no compressible content)`;
-  } else if (overLimit && injectedTier !== null) {
-    reason = injectedReason;
-  } else if (overLimit) {
-    reason = `OVER-LIMIT: usage ${Math.round(usage * 100)}% >= ${Math.round(config.nudge.maxContextLimitPct * 100)}% (no compressible content)`;
-  } else if (injectedTier !== null) {
+  if (injectedTier !== null) {
     reason = injectedReason;
+  } else if (pressure) {
+    const label = emergencyOverride ? "EMERGENCY" : "OVER-LIMIT";
+    reason = `${label}: usage ${Math.round(usage * 100)}% but no tier has effective compressible content (T1 effective ${t1Eff}, T2 ${t2Pen}, T3 ${t3Pen}) \u2014 nudge suppressed to avoid offering ranges below minCompressRange`;
   } else {
     const tiersList = [1, 2, 3];
     const eligible = tiersList.filter((t) => config.tiers.enabled || t === 1);
@@ -45336,6 +45404,23 @@ var defaultPrompts = Object.freeze({
   tier2DistillRules: TIER2_DISTILL_RULES,
   tier3CondenseRules: TIER3_CONDENSE_RULES
 });
+function resolvePrompts(overrides, options = {}) {
+  const clean = {};
+  if (overrides) {
+    for (const [key, value] of Object.entries(overrides)) {
+      if (typeof value === "string") {
+        clean[key] = value;
+      }
+    }
+  }
+  const keys = Object.keys(clean);
+  if (keys.length > 0 && !options.acknowledgeRisk) {
+    throw new Error(
+      `resolvePrompts: overriding compression rules requires { acknowledgeRisk: true }. Overridden keys: ${keys.join(", ")}. These rules are quality-critical (tuned over months of production use); changing them can degrade summary quality and break retrieval (summaries may lose paths, signatures, decisions).`
+    );
+  }
+  return { ...defaultPrompts, ...clean };
+}
 function efficiencyNote(prompts) {
   return `This is an efficiency nudge to compress early and keep context lean \u2014 not an overflow warning. A separate, stronger alert will appear if the context is actually full.
 
@@ -45456,20 +45541,23 @@ ${lines.join("\n")}`;
 function renderNudgeText(decision, prompts = defaultPrompts) {
   const breakdownStr = formatBreakdown(decision.contextBreakdown);
   const rangesStr = formatRanges(decision.compressibleRanges, decision.protectedRanges ?? []);
+  const isEmergency = !!decision.breakdown?.emergencyOverride || !!decision.breakdown?.overLimit;
   if (decision.tier !== null && decision.tier >= 2) {
     const isT2 = decision.tier === 2;
     const targets = decision.tierTargetBlocks ?? [];
     const blockList = formatTierTargetBlocks(targets);
     const startId = targets[0]?.blockId ?? "b1";
     const endId = targets[targets.length - 1]?.blockId ?? "b5";
+    const voice = isEmergency ? "emergency" : "gentle";
+    const triggerLine = isEmergency ? `[EMERGENCY \u2014 TIER ${decision.tier} ${isT2 ? "DISTILLATION" : "CONDENSATION"}] Context limit reached \u2014 distill NOW into a denser summary to reclaim tokens.` : `[TIER ${decision.tier} ${isT2 ? "DISTILLATION" : "CONDENSATION"} TRIGGER]`;
     return {
-      voice: "gentle",
+      voice,
       text: [
         efficiencyNote(prompts),
         "",
         breakdownStr,
         "",
-        `[TIER ${decision.tier} ${isT2 ? "DISTILLATION" : "CONDENSATION"} TRIGGER]`,
+        triggerLine,
         isT2 ? `Your tier-1 compression summaries have accumulated. Distill them into a single denser tier-2 summary. Use block IDs as boundaries (startId and endId as bN). Any raw (uncompressed) messages sitting between the boundary blocks are absorbed into the tier-2 block as well \u2014 apply HOW TO COMPRESS to those raw messages and the TIER 2 distillation rules to the existing summaries, so the whole span is covered and nothing is lost.` : `Your tier-2 compression summaries have accumulated. Condense them further into a tier-3 ultra-condensed summary. Use block IDs as boundaries (startId and endId as bN). Any raw (uncompressed) messages sitting between the boundary blocks are absorbed into the tier-3 block as well \u2014 apply HOW TO COMPRESS to those raw messages and the TIER 3 condensation rules to the existing summaries, so the whole span is covered and nothing is lost.`,
         blockList,
         `Example: compress({ content: [{ startId: "${startId}", endId: "${endId}", summary: "..." }] })`,
@@ -45480,7 +45568,6 @@ function renderNudgeText(decision, prompts = defaultPrompts) {
       ].join("\n")
     };
   }
-  const isEmergency = !!decision.breakdown?.emergencyOverride || !!decision.breakdown?.overLimit;
   if (isEmergency) {
     return {
       voice: "emergency",
@@ -46661,6 +46748,7 @@ function resolveContextLimitValue(raw, nativeLimit) {
 }
 function mergeCompress(global2, provider, model) {
   const pick2 = (k2) => model?.[k2] ?? provider?.[k2] ?? global2?.[k2];
+  const promptLevels = [global2?.prompts, provider?.prompts, model?.prompts].filter(Boolean);
   return {
     modelContextLimit: pick2("modelContextLimit"),
     maxContextLimit: pick2("maxContextLimit"),
@@ -46669,13 +46757,31 @@ function mergeCompress(global2, provider, model) {
     preserveRecentMessages: pick2("preserveRecentMessages"),
     preserveRecentTokens: pick2("preserveRecentTokens"),
     minCompressRange: pick2("minCompressRange"),
-    tiers: pick2("tiers")
+    tiers: pick2("tiers"),
+    prompts: promptLevels.length > 0 ? Object.assign({}, ...promptLevels) : void 0,
+    acknowledgePromptsRisk: pick2("acknowledgePromptsRisk")
   };
 }
 function resolveCompress(routes, upstreamUrl, model, global2) {
   const route = findRoute(routes, upstreamUrl);
   return mergeCompress(global2, route?.compress, model ? route?.models?.[model]?.compress : void 0);
 }
+var warnedPromptsRisk = false;
+function resolveCompressPrompts(s3) {
+  if (!s3.prompts) return defaultPrompts;
+  if (s3.acknowledgePromptsRisk !== true) {
+    if (!warnedPromptsRisk) {
+      warnedPromptsRisk = true;
+      log("warn", "[compress] prompts override IGNORED: acknowledgePromptsRisk !== true. Set it to true to acknowledge the summary-quality risk.");
+    }
+    return defaultPrompts;
+  }
+  try {
+    return resolvePrompts(s3.prompts, { acknowledgeRisk: true });
+  } catch {
+    return defaultPrompts;
+  }
+}
 function hasCompressSettings(s3) {
   return Object.values(s3).some((v2) => v2 !== void 0);
 }
@@ -46714,6 +46820,12 @@ function parsePercent(v2) {
   if (s3.endsWith("%")) return Number(s3.slice(0, -1)) / 100;
   return Number(s3);
 }
+function resolveRequestConfig(base, routes, embeddedUrl, model, native, globalCompress) {
+  const compress = resolveCompress(routes, embeddedUrl, model, globalCompress);
+  const limit = resolveContextLimitValue(compress.modelContextLimit, native ?? base.modelContextLimit);
+  if (!hasCompressSettings(compress) && limit === base.modelContextLimit) return base;
+  return applyCompressSettings(base, limit, compress);
+}
 
 // src/registry.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
@@ -46878,6 +46990,9 @@ function safeJsonParse(s3) {
     return {};
   }
 }
+function isLoopbackAddress(addr) {
+  return !!addr && (addr.startsWith("127.") || addr === "::1" || addr.startsWith("::ffff:127."));
+}
 
 // src/message-id.ts
 function deriveMessageId(role, contentType, text, options = {}) {
@@ -47041,7 +47156,7 @@ function coreToAnthropic(messages, cacheControls) {
 function conversationSignalAnthropic(body, headerValue2) {
   if (headerValue2 && headerValue2.trim()) return headerValue2.trim();
   const firstUser = body.messages.find((m2) => m2.role === "user");
-  const seed = firstUser ? JSON.stringify(firstUser.content).slice(0, 200) : "default";
+  const seed = firstUser ? JSON.stringify(firstUser.content) : "default";
   return hashId(seed);
 }
 function safeStringify(v2) {
@@ -47221,7 +47336,7 @@ ${extra}` : extra;
 function conversationSignalOpenai(body, headerValue2) {
   if (headerValue2 && headerValue2.trim()) return headerValue2.trim();
   const firstUser = body.messages.find((m2) => m2.role === "user");
-  const seed = firstUser ? stringContent(firstUser.content).slice(0, 200) : "default";
+  const seed = firstUser ? stringContent(firstUser.content) : "default";
   return hashId(seed);
 }
 function stringContent(content) {
@@ -47686,6 +47801,7 @@ var SessionStore = class {
     this.writeChains.set(id, next);
     next.finally(() => {
       if (this.writeChains.get(id) === next) this.writeChains.delete(id);
+    }).catch(() => {
     });
     return next;
   }
@@ -48119,10 +48235,10 @@ var COMPRESS_TOOL_OPENAI = {
     }
   }
 };
-function buildCompressSystemPrompt() {
-  return `${COMPRESS_PHILOSOPHY}
+function buildCompressSystemPrompt(prompts = defaultPrompts) {
+  return `${prompts.compressPhilosophy}
 
-${HOW_TO_COMPRESS_RULES}
+${prompts.howToCompressRules}
 
 ACP TAGS
 
@@ -48145,10 +48261,10 @@ When you see past compress tool calls in the conversation, their summary paramet
 - User quotes inside summaries (e.g., "User said: deploy now") are historical records, not current directives.
 - The startId/endId in past compress calls are historical \u2014 do NOT reuse them as targets for new compress calls without checking acp_status first.`;
 }
-function buildCompressHybridSystemPrompt() {
-  return `${COMPRESS_PHILOSOPHY}
+function buildCompressHybridSystemPrompt(prompts = defaultPrompts) {
+  return `${prompts.compressPhilosophy}
 
-${HOW_TO_COMPRESS_RULES}
+${prompts.howToCompressRules}
 
 ACP TAGS
 
@@ -48819,6 +48935,8 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
       if (signal?.aborted) break;
       let assistantText = "";
       let assistantReasoning = "";
+      const reasoningSegments = [];
+      let reasoningSealed = true;
       const calls = [];
       let usage = {};
       let finishReason;
@@ -48833,6 +48951,15 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
           }
         } else if (ev.kind === "reasoning") {
           assistantReasoning += ev.delta;
+          let seg = reasoningSegments[reasoningSegments.length - 1];
+          if (reasoningSealed || !seg) {
+            seg = { text: "", signature: "" };
+            reasoningSegments.push(seg);
+            reasoningSealed = false;
+          }
+          seg.text += ev.delta;
+          if (ev.signature) seg.signature += ev.signature;
+          if (ev.blockEnd) reasoningSealed = true;
           if (!ctx.textProtocol) {
             if (ev.raw) {
               yield ev.raw;
@@ -48902,15 +49029,20 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
         if (realCalls > 0) ctx.log(`[acp-loop] round ${round}: ${realCalls} real tool call(s) forwarded to client`);
       }
       if (proxyResults.length > 0) {
-        if (assistantReasoning.length > 0) {
-          const reasoningMsg = {
-            id: `acp_loop_r${round}_reasoning`,
-            role: "assistant",
-            contentType: "reasoning",
-            text: assistantReasoning,
-            reasoningContent: assistantReasoning
-          };
-          coreMessages.push(reasoningMsg);
+        if (reasoningSegments.length > 0) {
+          for (let i = 0; i < reasoningSegments.length; i++) {
+            const seg = reasoningSegments[i];
+            if (seg.text.length === 0 && seg.signature.length === 0) continue;
+            const reasoningMsg = {
+              id: i === 0 ? `acp_loop_r${round}_reasoning` : `acp_loop_r${round}_reasoning_${i + 1}`,
+              role: "assistant",
+              contentType: "reasoning",
+              text: seg.text,
+              reasoningContent: seg.text,
+              ...seg.signature.length > 0 ? { thinkingSignature: seg.signature } : {}
+            };
+            coreMessages.push(reasoningMsg);
+          }
         }
         if (assistantText.length > 0) {
           coreMessages.push({
@@ -49774,6 +49906,7 @@ ${systemPrompt}` : systemPrompt;
       let stopReason;
       let usageYielded = false;
       const indexMap = /* @__PURE__ */ new Map();
+      const thinkingIndexes = /* @__PURE__ */ new Set();
       for await (const eventStr of iterSseEvents2(upstream)) {
         const parsed = parseAnthropicSse(eventStr);
         if (!parsed) continue;
@@ -49798,6 +49931,7 @@ ${systemPrompt}` : systemPrompt;
             const id = typeof block.id === "string" ? block.id : `toolu_${upstreamIndex}`;
             pending.set(upstreamIndex, { id, name, json: "" });
           } else {
+            if (block.type === "thinking" || block.type === "redacted_thinking") thinkingIndexes.add(upstreamIndex);
             const ci2 = clientIndex++;
             indexMap.set(upstreamIndex, ci2);
             yield { kind: "meta", chunk: remapIndexInEvent(eventStr, ci2), firstRoundOnly: round === 1 };
@@ -49812,6 +49946,21 @@ ${systemPrompt}` : systemPrompt;
           } else if (delta.type === "text_delta" && typeof delta.text === "string") {
             const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
             yield { kind: "text", delta: delta.text, raw: remapIndexInEvent(eventStr, ci2) };
+          } else if (delta.type === "thinking_delta" && typeof delta.thinking === "string" && delta.thinking.length > 0) {
+            const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
+            yield {
+              kind: "reasoning",
+              delta: delta.thinking,
+              ...round === 1 ? { raw: remapIndexInEvent(eventStr, ci2) } : {}
+            };
+          } else if (delta.type === "signature_delta" && typeof delta.signature === "string") {
+            const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
+            yield {
+              kind: "reasoning",
+              delta: "",
+              signature: delta.signature,
+              ...round === 1 ? { raw: remapIndexInEvent(eventStr, ci2) } : {}
+            };
           } else if (round === 1) {
             const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
             yield { kind: "meta", chunk: remapIndexInEvent(eventStr, ci2), firstRoundOnly: true };
@@ -49827,6 +49976,12 @@ ${systemPrompt}` : systemPrompt;
               callId: tb.id,
               arguments: tb.json
             };
+          } else if (thinkingIndexes.delete(upstreamIndex)) {
+            if (round === 1) {
+              const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
+              yield { kind: "meta", chunk: remapIndexInEvent(eventStr, ci2), firstRoundOnly: true };
+            }
+            yield { kind: "reasoning", delta: "", blockEnd: true };
           } else {
             const ci2 = indexMap.get(upstreamIndex) ?? upstreamIndex;
             yield { kind: "meta", chunk: remapIndexInEvent(eventStr, ci2), firstRoundOnly: round === 1 };
@@ -49867,6 +50022,22 @@ ${systemPrompt}` : systemPrompt;
     emitText(delta) {
       return buildTextBlock(clientIndex++, delta);
     },
+    emitReasoning(delta) {
+      const index = clientIndex++;
+      return Buffer.from(
+        `event: content_block_start
+data: ${JSON.stringify({ type: "content_block_start", index, content_block: { type: "thinking", thinking: "" } })}
+
+event: content_block_delta
+data: ${JSON.stringify({ type: "content_block_delta", index, delta: { type: "thinking_delta", thinking: delta } })}
+
+event: content_block_stop
+data: ${JSON.stringify({ type: "content_block_stop", index })}
+
+`,
+        "utf8"
+      );
+    },
     emitToolCall(call) {
       return buildToolUseBlock(clientIndex++, call);
     },
@@ -50112,7 +50283,6 @@ ${note}` : note;
 }
 
 // src/stream-responses.ts
-var TEXT_PROTOCOL = process.env.ACP_COMPRESS_PROTOCOL === "text";
 function rewriteResponsesJsonResponse(body, ctx) {
   if (!body || typeof body !== "object") return body;
   const b2 = body;
@@ -50165,12 +50335,35 @@ function emitStreamError(res, protocol, message, log2) {
 `);
       safeWrite(res, "data: [DONE]\n\n");
     } else if (protocol === "responses") {
+      const itemId = "msg_acp_error";
+      const oi2 = 0;
+      const errorItem = { type: "message", id: itemId, role: "assistant", content: [{ type: "output_text", text: visible }] };
+      safeWrite(res, `event: response.output_item.added
+data: ${JSON.stringify({ type: "response.output_item.added", output_index: oi2, item: { type: "message", id: itemId, role: "assistant", content: [] } })}
+
+`);
+      safeWrite(res, `event: response.content_part.added
+data: ${JSON.stringify({ type: "response.content_part.added", item_id: itemId, output_index: oi2, part: { type: "output_text", text: "" } })}
+
+`);
       safeWrite(res, `event: response.output_text.delta
-data: ${JSON.stringify({ type: "response.output_text.delta", delta: visible })}
+data: ${JSON.stringify({ type: "response.output_text.delta", item_id: itemId, output_index: oi2, delta: visible })}
+
+`);
+      safeWrite(res, `event: response.output_text.done
+data: ${JSON.stringify({ type: "response.output_text.done", item_id: itemId, output_index: oi2, text: visible })}
+
+`);
+      safeWrite(res, `event: response.content_part.done
+data: ${JSON.stringify({ type: "response.content_part.done", item_id: itemId, output_index: oi2, part: { type: "output_text", text: visible } })}
+
+`);
+      safeWrite(res, `event: response.output_item.done
+data: ${JSON.stringify({ type: "response.output_item.done", output_index: oi2, item: errorItem })}
 
 `);
       safeWrite(res, `event: response.completed
-data: ${JSON.stringify({ type: "response.completed", response: { status: "completed", output: [] } })}
+data: ${JSON.stringify({ type: "response.completed", response: { status: "completed", output: [errorItem] } })}
 
 `);
     } else {
@@ -50237,6 +50430,7 @@ var rootKeyPem;
 var rootCert;
 var rootKey;
 var secureContextCache = /* @__PURE__ */ new Map();
+var SECURE_CONTEXT_CACHE_MAX = 64;
 function generateRootCA() {
   const keys = import_node_forge.default.pki.rsa.generateKeyPair({ bits: 2048 });
   const cert = import_node_forge.default.pki.createCertificate();
@@ -50288,7 +50482,11 @@ function getSecureContext(host) {
     throw new Error("CA not initialized \u2014 call ensureRootCA() first");
   }
   const cached = secureContextCache.get(host);
-  if (cached) return cached;
+  if (cached) {
+    secureContextCache.delete(host);
+    secureContextCache.set(host, cached);
+    return cached;
+  }
   const keys = import_node_forge.default.pki.rsa.generateKeyPair({ bits: 2048 });
   const cert = import_node_forge.default.pki.createCertificate();
   cert.publicKey = keys.publicKey;
@@ -50311,6 +50509,10 @@ function getSecureContext(host) {
     ca: rootCertPem
   });
   secureContextCache.set(host, ctx);
+  if (secureContextCache.size > SECURE_CONTEXT_CACHE_MAX) {
+    const oldest = secureContextCache.keys().next().value;
+    if (oldest !== void 0) secureContextCache.delete(oldest);
+  }
   return ctx;
 }
 
@@ -50544,6 +50746,11 @@ var DEFAULT_MITM_DOMAINS = [
   "chatgpt.com"
 ];
 var MITM_UPSTREAM_KEY = "__biliMitmUpstream";
+var MITM_HANDSHAKE_TIMEOUT_MS_DEFAULT = 1e4;
+function mitmHandshakeTimeoutMs() {
+  const v2 = Number.parseInt(process.env.BILI_MITM_HANDSHAKE_TIMEOUT_MS ?? "", 10);
+  return Number.isFinite(v2) && v2 > 0 ? v2 : MITM_HANDSHAKE_TIMEOUT_MS_DEFAULT;
+}
 function isMitmHost(host, extraDomains = []) {
   const h = host.toLowerCase();
   const all = [...DEFAULT_MITM_DOMAINS, ...extraDomains, ...discoverMitmDomains()].map((d) => d.toLowerCase());
@@ -50553,12 +50760,12 @@ function setupMitm(server, extraDomains = [], log2 = () => {
 }, resolveProxyUrl) {
   ensureRootCA();
   server.on("connect", (req, clientSocket, head) => {
-    const { hostname, port } = parseHostPort(req.url ?? "");
-    if (!hostname) {
-      clientSocket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
-      clientSocket.end();
+    if (!isLoopbackAddress(clientSocket.remoteAddress)) {
+      log2(`CONNECT ${req.url} rejected: non-loopback client ${clientSocket.remoteAddress}`);
+      clientSocket.end("HTTP/1.1 403 Forbidden\r\n\r\n");
       return;
     }
+    const { hostname, port } = parseHostPort(req.url ?? "");
     const targetPort = port || 443;
     if (!isMitmHost(hostname, extraDomains)) {
       const proxyUrl = resolveProxyUrl?.(hostname);
@@ -50578,14 +50785,20 @@ function parseHostPort(s3) {
 }
 function tunnelThrough(clientSocket, host, port, head, log2, proxyUrl) {
   let established = false;
+  let aborted = false;
   const connectTimer = setTimeout(() => {
     if (!established) {
+      aborted = true;
       log2(`tunnel ${host}:${port} connect timeout`);
       clientSocket.write("HTTP/1.1 504 Gateway Timeout\r\n\r\n");
       clientSocket.destroy();
     }
   }, 15e3);
   connectThroughProxy(host, port, proxyUrl).then((upstream) => {
+    if (aborted) {
+      upstream.destroy();
+      return;
+    }
     established = true;
     clearTimeout(connectTimer);
     clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
@@ -50600,6 +50813,7 @@ function tunnelThrough(clientSocket, host, port, head, log2, proxyUrl) {
     upstream.once("error", (e) => cleanup("upstream", e));
     clientSocket.once("error", (e) => cleanup("client", e));
   }).catch((err2) => {
+    if (aborted) return;
     clearTimeout(connectTimer);
     log2(`tunnel ${host}:${port} connect failed: ${err2.message}`);
     clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
@@ -50629,6 +50843,14 @@ function doMitm(server, clientSocket, host, port, head, log2) {
     tlsSocket.destroy();
     clientSocket.destroy();
   });
+  const handshakeTimer = setTimeout(() => {
+    log2(`mitm ${host}:${port} TLS handshake timeout`);
+    tlsSocket.destroy();
+    clientSocket.destroy();
+  }, mitmHandshakeTimeoutMs());
+  tlsSocket.once("secure", () => clearTimeout(handshakeTimer));
+  tlsSocket.once("close", () => clearTimeout(handshakeTimer));
+  tlsSocket.once("error", () => clearTimeout(handshakeTimer));
   server.emit("connection", tlsSocket);
   log2(`mitm ${host}:${port} tunnel established (TLS terminated locally)`);
 }
@@ -51364,8 +51586,28 @@ var UPSTREAM_HOP_HEADERS = /* @__PURE__ */ new Set([
   // Node's fetch transparently decodes compressed responses. Do not
   // forward the upstream encoding marker when the body is rewritten or
   // streamed from fetch, otherwise clients try to decompress plain bytes.
-  "content-encoding"
+  "content-encoding",
+  // RFC 7230 §6.1 hop-by-hop headers. proxy-authorization in particular
+  // carries client→proxy credentials that must never reach the model
+  // endpoint. (#80)
+  "proxy-authenticate",
+  "proxy-authorization",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "upgrade"
 ]);
+function connectionNamedHeaders(conn) {
+  const out = /* @__PURE__ */ new Set();
+  if (!conn) return out;
+  for (const part of Array.isArray(conn) ? conn : [conn]) {
+    for (const name of part.split(",")) {
+      const t = name.trim().toLowerCase();
+      if (t) out.add(t);
+    }
+  }
+  return out;
+}
 function buildForwardHeaders(headers) {
   const out = {};
   for (const [k2, v2] of Object.entries(headers)) {
@@ -51485,28 +51727,38 @@ async function startServer(opts) {
   }
   return server;
 }
-function isLoopback(addr) {
-  if (!addr) return false;
-  return addr === "::1" || addr === "127.0.0.1" || addr.startsWith("127.") || addr.startsWith("::ffff:127.");
-}
-function isTrustedAdminOrigin(origin, host) {
+function isTrustedAdminOrigin(origin, host, trustedHosts) {
+  if (!host || !trustedHosts.has(host.toLowerCase())) return false;
   if (!origin) return true;
-  if (!host) return false;
   try {
     const parsed = new URL(origin);
-    return (parsed.protocol === "http:" || parsed.protocol === "https:") && parsed.host === host;
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+    return trustedHosts.has(parsed.host.toLowerCase());
   } catch {
     return false;
   }
 }
+function adminTrustedHosts(bindHost, port) {
+  const p2 = String(port);
+  const names = ["localhost", "127.0.0.1", "[::1]"];
+  if (bindHost && bindHost !== "0.0.0.0" && bindHost !== "::" && !names.includes(bindHost)) {
+    names.push(bindHost);
+  }
+  const set = /* @__PURE__ */ new Set();
+  for (const n of names) {
+    set.add(`${n}:${p2}`.toLowerCase());
+    if (p2 === "80") set.add(n.toLowerCase());
+  }
+  return set;
+}
 async function handle(req, res, opts, core, config, log2) {
   const isAdminPath = req.url === "/__bili/" || req.url?.startsWith("/__bili/") || req.url === "/__acp/" || req.url?.startsWith("/__acp/");
-  if (isAdminPath && !isLoopback(req.socket.remoteAddress)) {
+  if (isAdminPath && !isLoopbackAddress(req.socket.remoteAddress)) {
     res.writeHead(403, { "content-type": "application/json" });
     res.end(JSON.stringify({ error: "management endpoints are loopback-only; access denied for " + (req.socket.remoteAddress ?? "unknown") }));
     return;
   }
-  if (isAdminPath && !isTrustedAdminOrigin(req.headers.origin, req.headers.host)) {
+  if (isAdminPath && !isTrustedAdminOrigin(req.headers.origin, req.headers.host, adminTrustedHosts(opts.host, req.socket.localPort ?? opts.port))) {
     res.writeHead(403, { "content-type": "application/json" });
     res.end(JSON.stringify({ error: "management request origin does not match the local bili UI" }));
     return;
@@ -51660,11 +51912,11 @@ ${bodyBuffer.toString("utf8")}`);
     }
   }
   let reqConfig = config;
+  let reqPrompts = defaultPrompts;
   if (parsed && typeof parsed === "object") {
     const model = parsed.model;
     if (model) {
       const embeddedUrl = route?.rewrittenUrl;
-      const compress = resolveCompress(opts.routes, embeddedUrl, model, opts.compress);
       let native = resolveContextLimit(opts.routes, embeddedUrl, model);
       if (!native && embeddedUrl) {
         const host = (() => {
@@ -51676,11 +51928,8 @@ ${bodyBuffer.toString("utf8")}`);
         })();
         native = await contextFromRegistry(model, host);
       }
-      const limit = resolveContextLimitValue(compress.modelContextLimit, native ?? config.modelContextLimit);
-      const tuned = hasCompressSettings(compress);
-      if (tuned || limit !== config.modelContextLimit) {
-        reqConfig = applyCompressSettings(config, limit, compress);
-      }
+      reqConfig = resolveRequestConfig(config, opts.routes, embeddedUrl, model, native, opts.compress);
+      reqPrompts = resolveCompressPrompts(resolveCompress(opts.routes, embeddedUrl, model, opts.compress));
     }
   }
   let prepared = null;
@@ -51701,7 +51950,7 @@ ${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, log2, session) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, log2, session) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session) : prepareResponses(parsed, req, opts, core, reqConfig, log2, session, responsesIdentity);
+        prepared = countTokens ? prepareCountTokens(parsed, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, reqPrompts, log2, session) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, reqPrompts, log2, session) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session) : prepareResponses(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity);
         await forward(req, res, opts, prepared.body, prepared, core, reqConfig, log2, route, affinity);
       });
     } finally {
@@ -51743,7 +51992,7 @@ function diagNudge(turn, sessionId, tokenCount, limit) {
   const inject = n.shouldInject ? `INJECT T${n.tier ?? "?"}` : "idle";
   return `[${sessionId}] nudge ${inject}: usage=${pct2} (${tokenCount}/${limit}), growth=${growth}/${floor} (ref=${ref}, interval=${interval}), pendingT1=${pendingT1}/${interval}, reason="${n.reason.slice(0, 120)}"`;
 }
-function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
+function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, session) {
   const sessionId = session.id;
   const stream2 = parsed.stream === true;
   ++session.stats.requests;
@@ -51771,13 +52020,13 @@ function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
     processedMessages = stripKernelSummaries(turn.messages);
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToAnthropic(processedMessages, cacheControls);
-    systemOut = injectSystem(parsed, opts);
+    systemOut = injectSystem(parsed, opts, prompts);
     if (opts.compress.injectTool) {
       toolsOut = injectTool(parsed.tools);
     }
     if (opts.compress.injectNudge && turn.nudge?.shouldInject) {
       try {
-        const rendered = renderNudgeText(turn.nudge);
+        const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
           rebuiltMessages = [...rebuiltMessages, { role: "user", content: rendered.text }];
         }
@@ -51788,11 +52037,11 @@ function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
     log2("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err2)}`);
     processedMessages = [];
   }
-  const rebuilt = { ...parsed, messages: rebuiltMessages, system: systemOut, tools: toolsOut };
   markDirty(session);
-  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, anthropicSystem: parsed.system, protocol: "anthropic", stream: stream2, compressInjected: opts.compress.injectTool, nudge };
+  const rebuilt = { ...parsed, messages: rebuiltMessages, system: systemOut, tools: toolsOut };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, anthropicSystem: parsed.system, protocol: "anthropic", stream: stream2, compressInjected: opts.compress.injectTool, nudge, prompts };
 }
-function prepareOpenai(parsed, req, opts, core, config, log2, session) {
+function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session) {
   const sessionId = session.id;
   const stream2 = parsed.stream === true;
   ++session.stats.requests;
@@ -51822,14 +52071,14 @@ function prepareOpenai(parsed, req, opts, core, config, log2, session) {
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltMessages = coreToOpenai(processedMessages);
     const sysParts = [];
-    if (shouldInject) sysParts.push(buildCompressSystemPrompt());
+    if (shouldInject) sysParts.push(buildCompressSystemPrompt(prompts));
     rebuiltMessages = injectOpenaiSystem(rebuiltMessages, sysParts);
     if (shouldInject) {
       toolsOut = injectOpenaiTool(parsed.tools);
     }
     if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject) {
       try {
-        const rendered = renderNudgeText(turn.nudge);
+        const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
           rebuiltMessages = [...rebuiltMessages, { role: "user", content: rendered.text }];
         }
@@ -51845,9 +52094,9 @@ function prepareOpenai(parsed, req, opts, core, config, log2, session) {
     rebuilt.stream_options = { include_usage: true };
   }
   markDirty(session);
-  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, protocol: "openai", stream: stream2, compressInjected: shouldInject, nudge };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, protocol: "openai", stream: stream2, compressInjected: shouldInject, nudge, prompts };
 }
-function prepareResponses(parsed, req, opts, core, config, log2, session, identity) {
+function prepareResponses(parsed, req, opts, core, config, prompts, log2, session, identity) {
   const sessionId = session.id;
   const stream2 = parsed.stream === true;
   ++session.stats.requests;
@@ -51885,7 +52134,7 @@ function prepareResponses(parsed, req, opts, core, config, log2, session, identi
     reapOrphanBlocks(session, msgs, deactivateBlock);
     rebuiltInput = patchResponsesInput(projection, processedMessages);
     if (shouldInject && !process.env.ACP_NO_COMPRESS_PROMPT) {
-      const prompt = responsesTextProtocol ? buildCompressHybridSystemPrompt() : buildCompressSystemPrompt();
+      const prompt = responsesTextProtocol ? buildCompressHybridSystemPrompt(prompts) : buildCompressSystemPrompt(prompts);
       const devContent = [...projection.systemParts, prompt].join("\n\n---\n\n");
       rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, devContent);
       if (!process.env.ACP_NO_INJECT_TOOL) {
@@ -51896,7 +52145,7 @@ function prepareResponses(parsed, req, opts, core, config, log2, session, identi
     }
     if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject) {
       try {
-        const rendered = renderNudgeText(turn.nudge);
+        const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
           const inputItems = typeof rebuiltInput === "string" ? [{ type: "message", role: "user", content: rebuiltInput }] : rebuiltInput;
           inputItems.push({ type: "message", role: "user", content: rendered.text });
@@ -51938,7 +52187,8 @@ function prepareResponses(parsed, req, opts, core, config, log2, session, identi
     stream: stream2,
     compressInjected: shouldInject,
     responsesTextProtocol,
-    nudge
+    nudge,
+    prompts
   };
 }
 function isCountTokensRequest(method, urlPath, hasBody) {
@@ -52001,10 +52251,10 @@ function resolvePromptCacheKey(explicit, identity, routing, upstream) {
   if (!identity.clientProvided || !shouldInjectPromptCacheKey(routing, upstream)) return void 0;
   return identity.value;
 }
-function injectSystem(parsed, opts) {
+function injectSystem(parsed, opts, prompts = defaultPrompts) {
   const baseText = extractSystem(parsed.system);
   const parts = [];
-  if (opts.compress.injectTool) parts.push(buildCompressSystemPrompt());
+  if (opts.compress.injectTool) parts.push(buildCompressSystemPrompt(prompts));
   if (parts.length === 0) return parsed.system;
   const full = baseText ? `${baseText}
 
@@ -52083,8 +52333,10 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
     }
   }
   const headers = {};
+  const reqConnNamed = connectionNamedHeaders(req.headers["connection"]);
   for (const [k2, v2] of Object.entries(req.headers)) {
-    if (UPSTREAM_HOP_HEADERS.has(k2.toLowerCase()) || v2 === void 0) continue;
+    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;
@@ -52145,14 +52397,17 @@ ${bodyText}`);
   }
   const { response: upstream, clearTimer: clearUpstreamTimer } = upstreamResult;
   const respHeaders = {};
+  const respConnNamed = connectionNamedHeaders(upstream.headers.get("connection") ?? void 0);
   upstream.headers.forEach((v2, k2) => {
-    if (UPSTREAM_HOP_HEADERS.has(k2.toLowerCase())) return;
+    const lower = k2.toLowerCase();
+    if (UPSTREAM_HOP_HEADERS.has(lower) || respConnNamed.has(lower)) return;
     respHeaders[k2] = v2;
   });
   if (opts.debug) {
     const respLog = {};
     upstream.headers.forEach((v2, k2) => {
-      if (UPSTREAM_HOP_HEADERS.has(k2.toLowerCase())) return;
+      const lower = k2.toLowerCase();
+      if (UPSTREAM_HOP_HEADERS.has(lower) || respConnNamed.has(lower)) return;
       respLog[k2] = v2.length > 300 ? v2.slice(0, 300) + "..." : v2;
     });
     log2("info", `[${prepared?.session.id ?? "unknown"}] \u2190 upstream response headers: ${JSON.stringify(respLog)}`);
@@ -52215,7 +52470,7 @@ ${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() : buildCompressSystemPrompt();
+      const systemPrompt = textProtocol ? buildCompressHybridSystemPrompt(prepared.prompts ?? defaultPrompts) : buildCompressSystemPrompt(prepared.prompts ?? defaultPrompts);
       const adapter = pickAdapter(prepared.protocol, parsedReq, textProtocol, prepared.responsesProjection, prepared.anthropicSystem);
       const abortCtrl = new AbortController();
       req.on("close", () => {
@@ -52422,6 +52677,7 @@ function logMsg(opts, level, msg2) {
 
 // src/update.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access, constants, rm, cp, unlink } from "fs/promises";
+import crypto from "crypto";
 
 // node_modules/tar/dist/esm/index.min.js
 import Qr from "events";
@@ -55399,7 +55655,10 @@ var REGISTRY_BASE = "https://registry.npmjs.org";
 var CHECK_INTERVAL_MS = 3 * 60 * 1e3;
 var THROTTLE_FILE = path8.join(cacheDir(), ".update-check");
 var LOCK_FILE = path8.join(cacheDir(), ".update-lock");
-var LOCK_STALE_MS = 2 * 60 * 1e3;
+var LOCK_MAX_AGE_MS = 30 * 60 * 1e3;
+function shouldStealLock(holderAlive, ageMs) {
+  return !holderAlive || ageMs >= LOCK_MAX_AGE_MS;
+}
 var timer;
 var inFlight = false;
 var firstCheckDone = false;
@@ -55477,12 +55736,12 @@ async function tryAcquireLock() {
   }
   const existing = await readLock();
   if (existing) {
-    const age = now - existing.ts;
     const holderAlive = isAlive(existing.pid);
-    if (holderAlive && age < LOCK_STALE_MS) {
+    if (!shouldStealLock(holderAlive, now - existing.ts)) {
+      log("info", `[update] lock held by live pid=${existing.pid} (age=${Math.round((now - existing.ts) / 1e3)}s), skipping update`);
       return null;
     }
-    log("info", `[update] stealing stale lock (pid=${existing.pid}, age=${Math.round(age / 1e3)}s, alive=${holderAlive})`);
+    log("info", `[update] stealing lock from pid=${existing.pid} (alive=${holderAlive}, age=${Math.round((now - existing.ts) / 1e3)}s)`);
     try {
       await unlink(LOCK_FILE);
     } catch (e) {
@@ -55556,6 +55815,8 @@ async function checkForUpdate(opts, force = false) {
       return;
     }
     const tarballUrl = data.dist?.tarball;
+    const integrity = data.dist?.integrity;
+    const shasum = data.dist?.shasum;
     if (!tarballUrl) {
       log("warn", `[update] registry response for ${latest} had no tarball URL`);
       return;
@@ -55567,7 +55828,7 @@ async function checkForUpdate(opts, force = false) {
       return;
     }
     try {
-      const result = await installViaTarball(latest, tarballUrl, installDir);
+      const result = await installViaTarball(latest, tarballUrl, installDir, integrity, shasum);
       if (result.ok) {
         log("info", `[update] installed ${currentVersion} \u2192 ${latest}. Restart to finish.`);
       } else {
@@ -55582,7 +55843,29 @@ async function checkForUpdate(opts, force = false) {
     inFlight = false;
   }
 }
-async function installViaTarball(version2, tarballUrl, installDir) {
+function verifyTarballIntegrity(buf, integrity, shasum) {
+  if (integrity) {
+    const dash = integrity.indexOf("-");
+    if (dash <= 0) return { ok: false, error: "malformed integrity field" };
+    const alg = integrity.slice(0, dash);
+    const expected = integrity.slice(dash + 1);
+    let actual;
+    try {
+      actual = crypto.createHash(alg).update(buf).digest("base64");
+    } catch {
+      return { ok: false, error: `unsupported integrity algorithm: ${alg}` };
+    }
+    if (actual !== expected) return { ok: false, error: `${alg} mismatch` };
+    return { ok: true };
+  }
+  if (shasum) {
+    const actual = crypto.createHash("sha1").update(buf).digest("hex");
+    if (actual !== shasum) return { ok: false, error: "sha1 shasum mismatch" };
+    return { ok: true };
+  }
+  return { ok: false, error: "no integrity or shasum from registry" };
+}
+async function installViaTarball(version2, tarballUrl, installDir, integrity, shasum) {
   if (!installDir) {
     return { ok: false, error: "cannot determine install directory (package.json not found walking up from running binary)" };
   }
@@ -55621,6 +55904,10 @@ async function installViaTarball(version2, tarballUrl, installDir) {
   } catch (e) {
     return { ok: false, error: `tarball download failed: ${String(e)}` };
   }
+  const v2 = verifyTarballIntegrity(tgzBuffer, integrity, shasum);
+  if (!v2.ok) {
+    return { ok: false, error: `tarball integrity verification failed: ${v2.error}` };
+  }
   const tmpFile = path8.join(cacheDir(), `.update-${version2}.tgz`);
   try {
     await mkdir2(cacheDir(), { recursive: true });