billion-context 0.1.113 → 0.1.114

package/dist/index.js

@@ -26858,15 +26858,15 @@ var require_util7 = __commonJS({
       }
       return true;
     };
-    util.format = function(format) {
+    util.format = function(format2) {
       var re2 = /%./g;
       var match;
       var part;
       var argi = 0;
       var parts = [];
       var last = 0;
-      while (match = re2.exec(format)) {
-        part = format.substring(last, re2.lastIndex - 2);
+      while (match = re2.exec(format2)) {
+        part = format2.substring(last, re2.lastIndex - 2);
         if (part.length > 0) {
           parts.push(part);
         }
@@ -26891,7 +26891,7 @@ var require_util7 = __commonJS({
             parts.push("<%" + code + "?>");
         }
       }
-      parts.push(format.substring(last));
+      parts.push(format2.substring(last));
       return parts.join("");
     };
     util.formatNumber = function(number, decimals, dec_point, thousands_sep) {
@@ -28794,18 +28794,18 @@ var require_asn1 = __commonJS({
         return date;
       }
       var rval = "";
-      var format = [];
-      format.push(("" + date.getUTCFullYear()).substr(2));
-      format.push("" + (date.getUTCMonth() + 1));
-      format.push("" + date.getUTCDate());
-      format.push("" + date.getUTCHours());
-      format.push("" + date.getUTCMinutes());
-      format.push("" + date.getUTCSeconds());
-      for (var i = 0; i < format.length; ++i) {
-        if (format[i].length < 2) {
+      var format2 = [];
+      format2.push(("" + date.getUTCFullYear()).substr(2));
+      format2.push("" + (date.getUTCMonth() + 1));
+      format2.push("" + date.getUTCDate());
+      format2.push("" + date.getUTCHours());
+      format2.push("" + date.getUTCMinutes());
+      format2.push("" + date.getUTCSeconds());
+      for (var i = 0; i < format2.length; ++i) {
+        if (format2[i].length < 2) {
           rval += "0";
         }
-        rval += format[i];
+        rval += format2[i];
       }
       rval += "Z";
       return rval;
@@ -28815,18 +28815,18 @@ var require_asn1 = __commonJS({
         return date;
       }
       var rval = "";
-      var format = [];
-      format.push("" + date.getUTCFullYear());
-      format.push("" + (date.getUTCMonth() + 1));
-      format.push("" + date.getUTCDate());
-      format.push("" + date.getUTCHours());
-      format.push("" + date.getUTCMinutes());
-      format.push("" + date.getUTCSeconds());
-      for (var i = 0; i < format.length; ++i) {
-        if (format[i].length < 2) {
+      var format2 = [];
+      format2.push("" + date.getUTCFullYear());
+      format2.push("" + (date.getUTCMonth() + 1));
+      format2.push("" + date.getUTCDate());
+      format2.push("" + date.getUTCHours());
+      format2.push("" + date.getUTCMinutes());
+      format2.push("" + date.getUTCSeconds());
+      for (var i = 0; i < format2.length; ++i) {
+        if (format2[i].length < 2) {
           rval += "0";
         }
-        rval += format[i];
+        rval += format2[i];
       }
       rval += "Z";
       return rval;
@@ -44022,9 +44022,43 @@ function collectSummaryAnchors(state, indexById, summaryIndexById) {
   anchors.sort((left, right) => left.insertAt - right.insertAt);
   return anchors;
 }
+function pairSafeAnchorIndex(messages, index) {
+  let safe = index;
+  while (safe > 0 && safe < messages.length && messages[safe - 1].role === "assistant" && messages[safe].role === "assistant") {
+    safe--;
+  }
+  const resultIndexByCallId = /* @__PURE__ */ new Map();
+  messages.forEach((message, at2) => {
+    if (message.contentType !== "tool-result") return;
+    if (typeof message.toolCallId !== "string") return;
+    if (!resultIndexByCallId.has(message.toolCallId)) {
+      resultIndexByCallId.set(message.toolCallId, at2);
+    }
+  });
+  for (let guard = 0; guard < messages.length; guard++) {
+    let moved = safe;
+    for (let at2 = 0; at2 < safe && at2 < messages.length; at2++) {
+      const message = messages[at2];
+      if (message.role !== "assistant") continue;
+      if (message.contentType !== "tool-call") continue;
+      if (typeof message.toolCallId !== "string") continue;
+      const resultIndex = resultIndexByCallId.get(message.toolCallId);
+      if (resultIndex !== void 0 && resultIndex >= safe && resultIndex + 1 > moved) {
+        moved = resultIndex + 1;
+      }
+    }
+    if (moved === safe) break;
+    safe = moved;
+  }
+  return safe;
+}
 function rebuildMessages(messages, covered, firstUserIndex, anchors) {
+  const safeAnchors = anchors.map((anchor) => ({
+    ...anchor,
+    insertAt: pairSafeAnchorIndex(messages, anchor.insertAt)
+  })).sort((left, right) => left.insertAt - right.insertAt);
   const result = [];
-  const pending = [...anchors];
+  const pending = [...safeAnchors];
   const anchoredSummaryIds = new Set(
     anchors.map((anchor) => summaryMessageId(anchor.blockId))
   );
@@ -46362,17 +46396,42 @@ function applySingleRange(input) {
       splitTurnCount++;
       for (const id of group) withdrawIds.add(id);
     }
+    const resultIdByCallId = /* @__PURE__ */ new Map();
+    for (const m2 of input.messages) {
+      if (!m2.id || m2.contentType !== "tool-result") continue;
+      if (typeof m2.toolCallId !== "string") continue;
+      if (!resultIdByCallId.has(m2.toolCallId)) {
+        resultIdByCallId.set(m2.toolCallId, m2.id);
+      }
+    }
+    let splitPairCount = 0;
+    for (const m2 of input.messages) {
+      if (!m2.id || m2.contentType !== "tool-call") continue;
+      if (typeof m2.toolCallId !== "string") continue;
+      const resultId = resultIdByCallId.get(m2.toolCallId);
+      if (resultId === void 0) continue;
+      if (effectiveMessageIds.has(m2.id) === effectiveMessageIds.has(resultId)) {
+        continue;
+      }
+      withdrawIds.add(m2.id);
+      withdrawIds.add(resultId);
+      splitPairCount++;
+    }
     if (withdrawIds.size > 0) {
       for (const id of withdrawIds) effectiveMessageIds.delete(id);
       const beforeWithdraw = filteredIds.length;
       filteredIds = filteredIds.filter((id) => !withdrawIds.has(id));
+      const splitDesc = [
+        splitTurnCount > 0 ? `${splitTurnCount} turn(s)` : null,
+        splitPairCount > 0 ? `${splitPairCount} tool call/result pair(s)` : null
+      ].filter((part) => part !== null).join(" and ");
       if (filteredIds.length === 0 && consumedBlockIds.length === 0) {
         throw new Error(
-          `Range would split ${splitTurnCount} turn(s) at the protected-zone boundary: a visible tool-call must keep its reasoning run (strict-echo providers reject a rebuilt request that lost it). Shrink the range to end before the turn starts, or wait until the whole turn ages out of the protected zone.`
+          `Range would split ${splitDesc} at the protected-zone boundary: a visible tool-call must keep its reasoning run and its results (strict providers reject a rebuilt request that lost either). Shrink the range to end before the turn starts, or wait until the whole turn ages out of the protected zone.`
         );
       }
       warnings.push(
-        `Withdrawn ${beforeWithdraw - filteredIds.length} message(s) from compression range to keep ${splitTurnCount} turn(s) intact (visible tool-call would lose its reasoning run).`
+        `Withdrawn ${beforeWithdraw - filteredIds.length} message(s) from compression range to keep ${splitDesc} intact (visible tool-call would lose its reasoning run or its results).`
       );
     }
   }
@@ -50040,9 +50099,10 @@ ${summary}` }]
   }
   return { items, replaced, dropped };
 }
+var CODEX_COMPACT_HEALTH_RATIO = 0.9;
 function codexCompactGatePre(session, effectiveLimit) {
   if (effectiveLimit <= 0) return false;
-  if (session.stats.lastInputTokens >= effectiveLimit * 0.9) return false;
+  if (session.stats.lastInputTokens >= effectiveLimit * CODEX_COMPACT_HEALTH_RATIO) return false;
   return session.state.blocks.some((b2) => b2.active);
 }
 function codexCompactGate(session, effectiveLimit, transformOk) {
@@ -53083,8 +53143,8 @@ var HEADER_SCAN_CHARS = 64;
 var JPEG_SCAN_CHARS = 35e4;
 function decodeImageDims(b64) {
   const head = Buffer.from(b64.slice(0, HEADER_SCAN_CHARS), "base64");
-  for (const parse2 of [pngDims, gifDims, bmpDims, webpDims]) {
-    const d = parse2(head);
+  for (const parse4 of [pngDims, gifDims, bmpDims, webpDims]) {
+    const d = parse4(head);
     if (d) return d;
   }
   if (head.length >= 2 && head[0] === 255 && head[1] === 216) {
@@ -53616,6 +53676,7 @@ function noEmergencyTruncate(config) {
 }
 async function preflightCompress(deps, messages) {
   const limit = deps.config.modelContextLimit;
+  let target = Math.min(limit, deps.compressionTarget ?? limit);
   const result = { compressedRanges: 0, savedTokens: 0, payloadEstimate: estimateCoreMessages(messages) + (deps.imageFloor ?? 0) + (deps.wireOverhead ?? 0), fitsWindow: true };
   if (limit <= 0) return result;
   const budget = Math.max(MIN_CHUNK_TOKENS, Math.floor(limit * CHUNK_FRACTION));
@@ -53655,12 +53716,13 @@ async function preflightCompress(deps, messages) {
     }
     result.payloadEstimate = estimateCoreMessages(turn.messages) + (deps.imageFloor ?? 0) + (deps.wireOverhead ?? 0);
     if (startTokens < 0) startTokens = currentTokens;
-    if (currentTokens < limit) break;
+    if (currentTokens < target) break;
     const ranges = viableRanges(turn.nudge?.compressibleRanges ?? []);
     if (ranges.length === 0) {
       if (!relaxed && result.payloadEstimate >= limit) {
         activeConfig = relaxedConfig(deps.config);
         relaxed = true;
+        target = limit;
         summaryCalls = 0;
         budgetHit = false;
         deps.log("warn", "[preflight] no compressible ranges outside the protected recent zone; relaxing soft protection (preserveRecentMessages/Tokens -> 0) and retrying");
@@ -53672,7 +53734,7 @@ async function preflightCompress(deps, messages) {
     const ordered = [...ranges].sort((a, b2) => refNum3(a.startRef) - refNum3(b2.startRef));
     let appliedThisRound = 0;
     for (const range of ordered) {
-      if (currentTokens < limit) break;
+      if (currentTokens < target) break;
       if (deps.signal?.aborted) {
         failure = ABORTED_FAILURE;
         break;
@@ -53690,7 +53752,7 @@ async function preflightCompress(deps, messages) {
       rangesTried += 1;
       const spans = splitChunks(messages, startIdx, endIdx, budget, baselineKnown ? 0 : minChars, countText).slice().reverse();
       while (spans.length > 0) {
-        if (currentTokens < limit) break;
+        if (currentTokens < target) break;
         if (deps.signal?.aborted) {
           failure = ABORTED_FAILURE;
           break;
@@ -59333,6 +59395,867 @@ import path14 from "path";
 import fs7 from "fs";
 import os from "os";
 import path13 from "path";
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
+      }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
+    }
+    return value2;
+  }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+      }
+    }
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
+      }
+    }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+        end = pos;
+      } else {
+        scanError = 3;
+      }
+    }
+    return text.substring(start, end);
+  }
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += "\n";
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "	";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
+            }
+            break;
+          default:
+            scanError = 5;
+        }
+        start = pos;
+        continue;
+      }
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
+        } else {
+          scanError = 6;
+        }
+      }
+      pos++;
+    }
+    return result;
+  }
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += "\n";
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      // tokens: []{}:,
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      // strings
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      // comments
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      // numbers
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      // found a minus, followed by a number so
+      // we fall through to proceed with scanning
+      // numbers
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      // literals and unknown symbols
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
+  }
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
+    }
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
+    }
+    return true;
+  }
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_2, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_2, index) => {
+      return "\n" + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_2, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_2, index) => {
+      return "\r\n" + " ".repeat(index);
+    })
+  },
+  "	": {
+    "\n": new Array(maxCachedValues).fill(0).map((_2, index) => {
+      return "\n" + "	".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_2, index) => {
+      return "\r" + "	".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_2, index) => {
+      return "\r\n" + "	".repeat(index);
+    })
+  }
+};
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse2(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(
+            14
+            /* ParseErrorCode.InvalidUnicode */
+          );
+          break;
+        case 5:
+          handleError(
+            15
+            /* ParseErrorCode.InvalidEscapeCharacter */
+          );
+          break;
+        case 3:
+          handleError(
+            13
+            /* ParseErrorCode.UnexpectedEndOfNumber */
+          );
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(
+              11
+              /* ParseErrorCode.UnexpectedEndOfComment */
+            );
+          }
+          break;
+        case 2:
+          handleError(
+            12
+            /* ParseErrorCode.UnexpectedEndOfString */
+          );
+          break;
+        case 6:
+          handleError(
+            16
+            /* ParseErrorCode.InvalidCharacter */
+          );
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(
+              10
+              /* ParseErrorCode.InvalidCommentToken */
+            );
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(
+            1
+            /* ParseErrorCode.InvalidSymbol */
+          );
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(
+            2
+            /* ParseErrorCode.InvalidNumberFormat */
+          );
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+    } else {
+      handleError(5, [], [
+        2,
+        5
+        /* SyntaxKind.CommaToken */
+      ]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [
+          2,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [
+        2
+        /* SyntaxKind.CloseBraceToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [
+          4,
+          5
+          /* SyntaxKind.CommaToken */
+        ]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [
+        4
+        /* SyntaxKind.CloseBracketToken */
+      ], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse3 = parse2;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// src/client-config.ts
 function toModelWindow(id, contextWindow) {
   return typeof id === "string" && id.length > 0 && typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0 ? { id, contextWindow: Math.floor(contextWindow) } : null;
 }
@@ -59900,26 +60823,49 @@ function readHermesConfig(hermesHome) {
   }
   return parseHermesYaml(text);
 }
-function resolveOpencodeConfigFile(env) {
-  if (nonEmpty2(env.OPENCODE_CONFIG)) return env.OPENCODE_CONFIG;
-  const xdg2 = nonEmpty2(env.XDG_CONFIG_HOME) ? env.XDG_CONFIG_HOME : path13.join(os.homedir(), ".config");
-  return path13.join(xdg2, "opencode", "opencode.json");
-}
-function readOpencodeConfig(file) {
-  let text;
+function parseConfigText(text) {
+  let parsed;
   try {
-    text = fs7.readFileSync(file, "utf8");
+    parsed = JSON.parse(text);
   } catch {
-    return { providers: {} };
+    const errors = [];
+    parsed = parse3(text, errors, { allowTrailingComma: true });
   }
-  let parsed;
+  if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  return void 0;
+}
+function readConfigFileRoot(file) {
   try {
-    parsed = JSON.parse(text);
+    return parseConfigText(fs7.readFileSync(file, "utf8"));
   } catch {
-    return { providers: {} };
+    return void 0;
   }
+}
+function mergeConfigDeep(target, source) {
+  const out = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    const existing = out[key];
+    out[key] = value !== null && typeof value === "object" && !Array.isArray(value) && existing !== null && typeof existing === "object" && !Array.isArray(existing) ? mergeConfigDeep(existing, value) : value;
+  }
+  return out;
+}
+function readOpencodeConfigRoot(env) {
+  let root;
+  const xdg2 = nonEmpty2(env.XDG_CONFIG_HOME) ? env.XDG_CONFIG_HOME : path13.join(os.homedir(), ".config");
+  const dir = path13.join(xdg2, "opencode");
+  for (const file of ["config.json", "opencode.json", "opencode.jsonc"]) {
+    const next = readConfigFileRoot(path13.join(dir, file));
+    if (next !== void 0) root = root === void 0 ? next : mergeConfigDeep(root, next);
+  }
+  if (nonEmpty2(env.OPENCODE_CONFIG)) {
+    const next = readConfigFileRoot(env.OPENCODE_CONFIG);
+    if (next !== void 0) root = root === void 0 ? next : mergeConfigDeep(root, next);
+  }
+  return root;
+}
+function parseOpencodeProviders(parsed) {
   const providers = {};
-  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+  if (parsed !== void 0) {
     const root = parsed;
     const provRoot = root.provider;
     if (provRoot && typeof provRoot === "object" && !Array.isArray(provRoot)) {
@@ -59990,7 +60936,7 @@ function loadClientConfig(env, cwd) {
   const zcodeHome = nonEmpty2(env.ZCODE_DATA_BASE_DIR) ? env.ZCODE_DATA_BASE_DIR : path13.join(home, ".zcode");
   config.zcode = readZcodeConfig(zcodeHome);
   config.omp = readOmpConfig(resolveOmpHome(env));
-  config.opencode = readOpencodeConfig(resolveOpencodeConfigFile(env));
+  config.opencode = parseOpencodeProviders(readOpencodeConfigRoot(env));
   config.hermes = readHermesConfig(resolveHermesHome(env));
   config.dsh = readDshConfig(resolveDshHome(env));
   config.codebuddy = readCodebuddyConfig(resolveCodebuddyHome(env), cwd, env);
@@ -62931,6 +63877,7 @@ function beginPreflightHold(res, prepared, log2) {
 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 compressionTarget = prepared.protocol === "responses" && isCodexClient(req.headers) && codexCompactMode() === "intercept" ? limit * CODEX_COMPACT_HEALTH_RATIO : limit;
   const preflightReqUrl = req.url ?? "";
   const billingUpstream = route?.rewrittenUrl ?? (/^https?:\/\//i.test(preflightReqUrl) ? preflightReqUrl : opts.upstream);
   const imageTokens = imageTokensInRawBody(prepared.protocol, prepared.body, imageBillingFor(opts, billingUpstream));
@@ -62939,10 +63886,11 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
   const payloadEstimate = textEstimate + overheadEstimate + imageTokens;
   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;
+  if (limit <= 0 || !model || tokenCount < compressionTarget) return prepared;
+  const payloadFitsWindow = (unknownBaseline ? tokenCount : payloadEstimate) < limit;
   const learnedLimit = resolveLearnedLimit(session, model);
   const noOverflowEvidence = session.stats.lastInputTokens < limit && learnedLimit === void 0;
-  if (imageTokens > 0 && textEstimate < limit && noOverflowEvidence) {
+  if (imageTokens > 0 && payloadEstimate >= limit && 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)`);
     return prepared;
   }
@@ -62953,8 +63901,8 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
     return { failFast: true, status: status2, message, retryable, respond: !res.writableEnded };
   };
   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`);
+    if (payloadFitsWindow) {
+      log2("warn", `[${session.id}] preflight target reached (~${tokenCount}) but the payload fits with no compressible ranges (~${payloadEstimate}/${limit}); forwarding as-is`);
       return prepared;
     }
     if (unknownBaseline) {
@@ -62965,11 +63913,12 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
   if (deadEnd && typeof deadEnd === "object") {
     const de2 = deadEnd;
     if (typeof de2.key === "string" && de2.key === `${model}\0${limit}` && typeof de2.until === "number" && de2.until > Date.now() && typeof de2.message === "string") {
+      if (payloadFitsWindow) return prepared;
       log2("warn", `[${session.id}] preflight dead-end cooldown active (${Math.ceil((de2.until - Date.now()) / 1e3)}s left); failing fast without upstream calls (#726)`);
       return { failFast: true, status: typeof de2.status === "number" ? de2.status : 502, message: de2.message, retryable: de2.retryable === true, respond: !res.writableEnded };
     }
   }
-  log2("warn", `[${session.id}] context ${tokenCount} tokens exceeds model window ${limit} (model=${model}); preflight compressing before forward`);
+  log2("warn", `[${session.id}] context ${tokenCount} tokens reached preflight target ${compressionTarget} (model window ${limit}, model=${model}); preflight compressing before forward`);
   const { upstreamUrl, headers, proxyUrl } = buildForwardTarget(req, opts, route, affinity, instanceId);
   const clientAbort = new AbortController();
   res.on("close", () => {
@@ -62988,6 +63937,7 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
         core,
         session,
         config,
+        compressionTarget,
         prompts: prepared.prompts ?? defaultPrompts,
         surface: prepared.surface,
         protocol: prepared.protocol,
@@ -68754,17 +69704,9 @@ function opencodeMajorVersion(command) {
   ocMajorCache.set(command, major);
   return major;
 }
-function prepareOpencodeHttpRewrite(configFile2, origin, httpRewrites, httpsRewrites, pluginPath, pluginDirMode) {
+function prepareOpencodeHttpRewrite(userRoot, origin, httpRewrites, httpsRewrites, pluginPath, pluginDirMode) {
   if (httpRewrites.length === 0 && httpsRewrites.length === 0 && !pluginPath) return void 0;
-  let root = {};
-  try {
-    const txt = fs13.readFileSync(configFile2, "utf8");
-    const parsed = JSON.parse(txt);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      root = { ...parsed };
-    }
-  } catch {
-  }
+  const root = structuredClone(userRoot ?? {});
   const provRoot = root.provider;
   if (provRoot && typeof provRoot === "object" && !Array.isArray(provRoot)) {
     const providers = provRoot;
@@ -69225,7 +70167,7 @@ async function runLaunch(params, deps = {}) {
     const opencodePlugin = selfDistFile("agent/opencode.js");
     const opencodePluginPath = opencodePlugin && fs13.existsSync(opencodePlugin) ? opencodePlugin : void 0;
     const ocDirMode = opencodePluginPath !== void 0 && opencodeMajorVersion(resolveClientCommand("opencode", process.env).command) >= 2;
-    opencodeTmpFile = prepareOpencodeHttpRewrite(resolveOpencodeConfigFile(process.env), origin, routes.httpRewrites, routes.httpsRewrites, opencodePluginPath, ocDirMode);
+    opencodeTmpFile = prepareOpencodeHttpRewrite(readOpencodeConfigRoot(process.env), origin, routes.httpRewrites, routes.httpsRewrites, opencodePluginPath, ocDirMode);
     if (opencodeTmpFile) env.OPENCODE_CONFIG = opencodeTmpFile;
   } else if (base === "hermes") {
     env = stripInheritedProxy(process.env);