billion-context 0.1.61 → 0.1.62

package/dist/index.js

@@ -43649,7 +43649,7 @@ function formatRanges(compressible, protectedRanges) {
   if (compressible.length === 0 && protectedRanges.length === 0) {
     return "[No specific ranges detected \u2014 compress any consumed content.]";
   }
-  const refNum3 = (ref) => {
+  const refNum4 = (ref) => {
     const m2 = ref.match(/\d+/);
     return m2 ? parseInt(m2[0], 10) : 0;
   };
@@ -43658,8 +43658,8 @@ function formatRanges(compressible, protectedRanges) {
     entries.push({
       startRef: r.startRef,
       endRef: r.endRef,
-      startNum: refNum3(r.startRef),
-      endNum: refNum3(r.endRef),
+      startNum: refNum4(r.startRef),
+      endNum: refNum4(r.endRef),
       count: r.count,
       tokens: r.tokens,
       toolPct: r.toolPct,
@@ -43676,8 +43676,8 @@ function formatRanges(compressible, protectedRanges) {
     entries.push({
       startRef: r.startRef,
       endRef: r.endRef,
-      startNum: refNum3(r.startRef),
-      endNum: refNum3(r.endRef),
+      startNum: refNum4(r.startRef),
+      endNum: refNum4(r.endRef),
       count: r.count,
       tokens: r.tokens,
       toolPct: 0,
@@ -47033,12 +47033,15 @@ function caDir() {
 }
 
 // src/logger.ts
-import { createWriteStream, mkdirSync, statSync, renameSync } from "fs";
+import { createWriteStream, fstatSync, mkdirSync, statSync, renameSync } from "fs";
 import path2 from "path";
 var MAX_BYTES = 10 * 1024 * 1024;
 var stream;
+var streamFd;
 var logPath;
 var bytesWritten = 0;
+var reopenWarned = false;
+var capture = null;
 function openStream(file) {
   mkdirSync(path2.dirname(file), { recursive: true });
   let existingSize = 0;
@@ -47054,23 +47057,69 @@ function openStream(file) {
   } catch {
   }
   const s3 = createWriteStream(file, { flags: "a" });
+  s3.on("open", (fd) => {
+    if (stream === s3) streamFd = fd;
+  });
   s3.on("error", () => {
     try {
       s3.destroy();
     } catch {
     }
-    if (stream === s3) stream = void 0;
+    if (stream === s3) {
+      stream = void 0;
+      streamFd = void 0;
+    }
   });
   bytesWritten = existingSize;
   return s3;
 }
+function isOrphaned(s3) {
+  if (stream === s3 && streamFd === void 0) return false;
+  try {
+    const fdStat = fstatSync(streamFd);
+    const pathStat = statSync(logPath);
+    return fdStat.ino !== pathStat.ino || fdStat.dev !== pathStat.dev;
+  } catch {
+    return true;
+  }
+}
+function closeQuietly(s3) {
+  try {
+    s3.end();
+  } catch {
+  }
+}
+function warnReopenFailed(err2) {
+  if (reopenWarned) return;
+  reopenWarned = true;
+  const reason = err2 instanceof Error ? err2.message : String(err2);
+  const msg = `log file ${logPath ?? "?"} unavailable (${reason}); continuing with stderr-only logging`;
+  if (capture) {
+    try {
+      capture("warn", msg);
+    } catch {
+    }
+  }
+  try {
+    process.stderr.write(`${(/* @__PURE__ */ new Date()).toISOString()} [warn] ${msg}
+`);
+  } catch {
+  }
+}
 function getStream() {
   if (!logPath) return void 0;
-  if (stream && stream.writable) return stream;
+  if (stream && stream.writable && !isOrphaned(stream)) return stream;
+  if (stream) closeQuietly(stream);
+  stream = void 0;
+  streamFd = void 0;
   try {
     stream = openStream(logPath);
+    reopenWarned = false;
     return stream;
-  } catch {
+  } catch (err2) {
+    stream = void 0;
+    streamFd = void 0;
+    warnReopenFailed(err2);
     return void 0;
   }
 }
@@ -47081,10 +47130,9 @@ function configureLogger(file) {
     return void 0;
   }
   logPath = file;
-  stream = openStream(file);
+  stream = getStream();
   return file;
 }
-var capture = null;
 var log = (level, msg) => {
   if (capture) {
     try {
@@ -47102,22 +47150,21 @@ var log = (level, msg) => {
   let s3 = getStream();
   if (s3) {
     if (bytesWritten >= MAX_BYTES) {
-      try {
-        s3.end();
-      } catch {
-      }
-      stream = openStream(logPath);
-      s3 = stream;
+      closeQuietly(s3);
+      stream = void 0;
+      s3 = getStream();
     }
-    try {
-      s3.write(line);
-      bytesWritten += Buffer.byteLength(line);
-    } catch {
+    if (s3) {
       try {
-        s3.destroy();
+        s3.write(line);
+        bytesWritten += Buffer.byteLength(line);
       } catch {
+        try {
+          s3.destroy();
+        } catch {
+        }
+        stream = void 0;
       }
-      stream = void 0;
     }
   }
 };
@@ -47129,6 +47176,7 @@ function closeLogger() {
     }
   }
   stream = void 0;
+  streamFd = void 0;
   bytesWritten = 0;
 }
 
@@ -48017,6 +48065,10 @@ function replayBaseDelayMs() {
   const raw = Number(process.env.BILI_REPLAY_RETRY_BASE_MS);
   return Number.isFinite(raw) && raw >= 0 ? raw : 1500;
 }
+function maxShrinkPerCompress() {
+  const raw = Number(process.env.BILI_MAX_SHRINK_PER_COMPRESS);
+  return Number.isFinite(raw) && raw > 0 && raw <= 1 ? raw : void 0;
+}
 function replayBackoffMs(attempt) {
   return replayBaseDelayMs() * 2 ** (attempt - 1);
 }
@@ -49592,6 +49644,10 @@ function getStore() {
 }
 
 // src/session.ts
+function lastCompressSuffix(info) {
+  if (!info) return "";
+  return ` [after compress: shrink ${Math.round(info.shrinkRatio * 100)}% foldPoint=${info.foldPoint} blocks=${info.blocks} ~${info.tokensCompressed}tok]`;
+}
 var sessions = /* @__PURE__ */ new Map();
 var MAX_SESSIONS = Math.max(1, Number.parseInt(process.env.BILI_MAX_SESSIONS ?? "256", 10) || 256);
 var initialized = false;
@@ -49745,6 +49801,11 @@ function parseCompressInput(input, callId) {
   }
   return ranges;
 }
+var STAGED_COMPRESS_GUIDANCE = "\n\n[Smooth-transition guidance: when you compress, prefer a SMALLER, TAIL-biased range \u2014 compress the most recent large content and keep the stable prefix (the earliest messages) intact. A large single rewrite changes the request shape sharply and can trip provider risk-control; smaller tail-biased folds keep the prefix cache alive and the transition gentle.]";
+function withStagedCompressGuidance(text) {
+  if (maxShrinkPerCompress() === void 0) return text;
+  return text + STAGED_COMPRESS_GUIDANCE;
+}
 
 // src/decompress-shared.ts
 import { mkdirSync as mkdirSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -50019,6 +50080,9 @@ ${lines.join("\n\n")}`;
   }
   return `[Unknown proxy tool: ${toolName}]`;
 }
+function refNum2(ref) {
+  return Number(ref.replace(/\D/g, "")) || 0;
+}
 function applyRanges(ranges, ctx) {
   if (ranges.length === 0) {
     ctx.log("[acp-proxy: compress call had no valid ranges; nothing compressed.]");
@@ -50057,8 +50121,17 @@ function applyRanges(ranges, ctx) {
       ctx.log(`[acp-proxy: compress FAILED ${detail} \u2192 0 blocks. ${errs}]`);
       return `[Compression FAILED: ${errs}]`;
     }
+    const preContext = ctx.session.stats.lastInputTokens;
+    const shrinkRatio = preContext > 0 ? r.tokensCompressed / preContext : 0;
+    const foldPoint = [...ranges].sort((a, b2) => refNum2(a.startRef) - refNum2(b2.startRef))[0]?.startRef ?? "unknown";
+    ctx.session.lastCompress = { at: Date.now(), shrinkRatio, foldPoint, blocks: r.blocksCreated, tokensCompressed: r.tokensCompressed };
+    ctx.log(`[acp-compress-obs] shrink ${Math.round(shrinkRatio * 100)}% (~${r.tokensCompressed}/${preContext} tok) foldPoint=${foldPoint} blocks=${r.blocksCreated}`);
     const warn = r.warnings.length > 0 ? ` ${r.warnings.join("; ")}` : "";
-    const msg = `[Compressed ${detail} \u2192 ${r.blocksCreated} block(s), ~${r.tokensCompressed} tokens saved.${warn}]`;
+    let msg = `[Compressed ${detail} \u2192 ${r.blocksCreated} block(s), ~${r.tokensCompressed} tokens saved.${warn}]`;
+    const maxShrink = maxShrinkPerCompress();
+    if (maxShrink !== void 0 && shrinkRatio > maxShrink) {
+      msg += ` [Staged-compress: this rewrite shrank context ${Math.round(shrinkRatio * 100)}%, above your ${Math.round(maxShrink * 100)}% per-compress target \u2014 the shape that trips provider risk-control (3007). Next time compress a SMALLER, TAIL-biased range (the most recent large content) and keep the stable prefix intact.]`;
+    }
     ctx.log(`[acp-proxy: ${msg}]`);
     ctx.session.stats.compressCreditTokens = (ctx.session.stats.compressCreditTokens ?? 0) + r.tokensCompressed;
     ctx.session.stats.lastInputTokens = Math.max(0, ctx.session.stats.lastInputTokens - r.tokensCompressed);
@@ -50116,7 +50189,7 @@ function refMaps(messages, state) {
   });
   return { refToIdx, idxToRef };
 }
-function refNum2(ref) {
+function refNum3(ref) {
   return Number(ref.replace(/\D/g, "")) || 0;
 }
 function estimateCoreMessages(messages) {
@@ -50206,7 +50279,9 @@ TASK: The conversation segment below (messages ${startRef}\u2013${endRef}) must
     },
     void 0,
     deps.signal,
-    (info) => deps.log("warn", `[preflight] summary attempt ${info.attempt} got HTTP ${info.status}; retrying in ${info.delayMs}ms`)
+    (info) => {
+      deps.log("warn", `[preflight] summary attempt ${info.attempt} got HTTP ${info.status}; retrying in ${info.delayMs}ms${lastCompressSuffix(deps.session.lastCompress)}`);
+    }
   );
   try {
     const text = await response.text();
@@ -50260,7 +50335,7 @@ async function preflightCompress(deps, messages) {
       failure = { kind: "exhausted", detail: "no compressible ranges remain in the conversation" };
       break;
     }
-    const range = [...ranges].sort((a, b2) => refNum2(a.startRef) - refNum2(b2.startRef))[0];
+    const range = [...ranges].sort((a, b2) => refNum3(a.startRef) - refNum3(b2.startRef))[0];
     const { refToIdx } = refMaps(messages, deps.session.state);
     const startIdx = refToIdx.get(range.startRef);
     const endIdx = refToIdx.get(range.endRef);
@@ -50914,8 +50989,9 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
         void 0,
         signal,
         (info) => {
-          ctx.log(`[acp-proxy: upstream rejected replay (HTTP ${info.status}: ${info.detail.slice(0, 120)}); likely provider risk-control \u2014 retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})]`);
-          log("warn", `[acp-loop] upstream rejected replay (HTTP ${info.status}); retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})`);
+          const lc = lastCompressSuffix(ctx.session.lastCompress);
+          ctx.log(`[acp-proxy: upstream rejected replay (HTTP ${info.status}: ${info.detail.slice(0, 120)}); likely provider risk-control \u2014 retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})${lc}]`);
+          log("warn", `[acp-loop] upstream rejected replay (HTTP ${info.status}); retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})${lc}`);
         }
       );
       let newBody = adapter.buildRequest(coreMessages, systemPrompt, requestBody);
@@ -52432,8 +52508,9 @@ async function compressLoopResponsesJson(initialResponse, ctx, requestBody, requ
       body: JSON.stringify(requestBody),
       ...ctx.proxyUrl ? { dispatcher: proxyDispatcher(ctx.proxyUrl) } : {}
     }, void 0, void 0, (info) => {
-      ctx.log(`[acp-proxy: responses upstream rejected replay (HTTP ${info.status}: ${info.detail.slice(0, 120)}); likely provider risk-control \u2014 retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})]`);
-      log("warn", `[acp-compress-responses] upstream rejected replay (HTTP ${info.status}); retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})`);
+      const lc = lastCompressSuffix(ctx.session.lastCompress);
+      ctx.log(`[acp-proxy: responses upstream rejected replay (HTTP ${info.status}: ${info.detail.slice(0, 120)}); likely provider risk-control \u2014 retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})${lc}]`);
+      log("warn", `[acp-compress-responses] upstream rejected replay (HTTP ${info.status}); retrying in ${info.delayMs}ms (attempt ${info.attempt}/${info.maxAttempts})${lc}`);
     }).catch((e) => {
       if (e instanceof UpstreamHttpError) {
         const suffix = e.attempts > 1 ? ` after ${e.attempts} attempt(s)` : "";
@@ -55583,7 +55660,7 @@ function prepareAnthropic(parsed, req, opts, core, config, prompts, log2, sessio
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
-          rebuiltMessages = [...rebuiltMessages, { role: "user", content: rendered.text }];
+          rebuiltMessages = [...rebuiltMessages, { role: "user", content: withStagedCompressGuidance(rendered.text) }];
         }
       } catch {
       }
@@ -55642,7 +55719,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
-          rebuiltMessages = [...rebuiltMessages, { role: "user", content: rendered.text }];
+          rebuiltMessages = [...rebuiltMessages, { role: "user", content: withStagedCompressGuidance(rendered.text) }];
         }
       } catch {
       }
@@ -55725,7 +55802,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
         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 });
+          inputItems.push({ type: "message", role: "user", content: withStagedCompressGuidance(rendered.text) });
           rebuiltInput = inputItems;
         }
       } catch {