billion-context 0.1.2 → 0.1.4

package/dist/index.js

@@ -28,14 +28,23 @@ function sessionsDir() {
   if (env && env.length > 0) return path.resolve(env);
   return path.join(dataDir(), "sessions");
 }
+function cacheDir() {
+  return path.join(xdg("XDG_CACHE_HOME", ".cache"), "billion-context");
+}
+function stateDir() {
+  return path.join(xdg("XDG_STATE_HOME", ".local/state"), "billion-context");
+}
+function defaultLogFile() {
+  return path.join(stateDir(), "bili.log");
+}
 
 // src/config.ts
-function safeReadJson(path4) {
+function safeReadJson(path6) {
   try {
-    return JSON.parse(readFileSync(path4, "utf8"));
+    return JSON.parse(readFileSync(path6, "utf8"));
   } catch (e) {
     if (e.code !== "ENOENT") {
-      console.error(`[acp-config] failed to parse ${path4}: ${String(e)}`);
+      console.error(`[acp-config] failed to parse ${path6}: ${String(e)}`);
     }
     return void 0;
   }
@@ -98,10 +107,6 @@ function loadOptions(env = process.env) {
     }
   }
   const modelContextLimit = parseInt(env.ACP_MODEL_CONTEXT_LIMIT ?? `${fileConfig.modelContextLimit ?? 2e5}`, 10);
-  const enabled = (env.ACP_CONDENSE_ENABLED ?? (fileConfig.condense?.enabled === false ? "0" : "1")) !== "0";
-  const keepRecentToolResults = parseInt(env.ACP_KEEP_RECENT_TOOL_RESULTS ?? `${fileConfig.condense?.keepRecentToolResults ?? 6}`, 10);
-  const minCharsToCondense = parseInt(env.ACP_MIN_CHARS_TO_CONDENSE ?? `${fileConfig.condense?.minCharsToCondense ?? 1500}`, 10);
-  const maxKeptChars = parseInt(env.ACP_MAX_KEPT_CHARS ?? `${fileConfig.condense?.maxKeptChars ?? 400}`, 10);
   return {
     port: Number.isFinite(port) ? port : 8787,
     host,
@@ -109,7 +114,6 @@ function loadOptions(env = process.env) {
     routes,
     modelContextLimit,
     kernelConfig: defaultConfig(modelContextLimit),
-    condense: { enabled, keepRecentToolResults, minCharsToCondense, maxKeptChars },
     compress: {
       injectTool: (env.ACP_COMPRESS_TOOL ?? (fileConfig.compress?.injectTool === false ? "0" : "1")) !== "0",
       injectNudge: (env.ACP_COMPRESS_NUDGE ?? (fileConfig.compress?.injectNudge === false ? "0" : "1")) !== "0"
@@ -118,7 +122,9 @@ function loadOptions(env = process.env) {
     log: env.ACP_LOG !== "0" && fileConfig.log !== false,
     debug: (env.ACP_DEBUG ?? (fileConfig.debug ? "1" : "0")) === "1",
     dumpSse: env.ACP_DUMP_SSE || fileConfig.dumpSse || void 0,
-    passthrough: (env.ACP_PASSTHROUGH ?? (fileConfig.passthrough ? "1" : "0")) === "1"
+    passthrough: (env.ACP_PASSTHROUGH ?? (fileConfig.passthrough ? "1" : "0")) === "1",
+    autoUpdate: (env.ACP_AUTO_UPDATE ?? (fileConfig.autoUpdate === false ? "0" : "1")) !== "0",
+    logFile: env.ACP_LOG_FILE !== void 0 ? env.ACP_LOG_FILE || void 0 : fileConfig.logFile
   };
 }
 function loadConfigFile() {
@@ -149,12 +155,12 @@ var MAX_REQUEST_BYTES = 100 * 1024 * 1024;
 var UPSTREAM_TIMEOUT_MS = 10 * 60 * 1e3;
 async function fetchWithTimeout(url, init, timeoutMs = UPSTREAM_TIMEOUT_MS) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const timer2 = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const response = await fetch(url, { ...init, signal: controller.signal });
-    return { response, clearTimer: () => clearTimeout(timer) };
+    return { response, clearTimer: () => clearTimeout(timer2) };
   } catch (e) {
-    clearTimeout(timer);
+    clearTimeout(timer2);
     throw e;
   }
 }
@@ -187,7 +193,6 @@ var ClusterCounter = class {
 };
 
 // src/anthropic.ts
-var CONDENSED_TAG = "[acp-proxy: condensed";
 function extractSystem(system) {
   if (!system) return "";
   if (typeof system === "string") return system;
@@ -195,13 +200,14 @@ function extractSystem(system) {
 }
 function buildSystem(text, original) {
   if (Array.isArray(original) && original.length > 0) {
-    const cc = original[0]?.cache_control;
-    return [{ type: "text", text, ...cc ? { cache_control: cc } : {} }];
+    const ccBlock = original.find((b) => b.cache_control);
+    return [{ type: "text", text, ...ccBlock ? { cache_control: ccBlock.cache_control } : {} }];
   }
   return text;
 }
 function anthropicToCore(body) {
   const msgs = [];
+  const cacheControls = /* @__PURE__ */ new Map();
   const clusters = new ClusterCounter();
   for (const m of body.messages) {
     const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : m.content;
@@ -209,7 +215,9 @@ function anthropicToCore(body) {
       switch (b.type) {
         case "text": {
           const base = deriveMessageId(m.role, "text", b.text);
-          msgs.push({ id: clusters.next(base), role: m.role, contentType: "text", text: b.text });
+          const id = clusters.next(base);
+          msgs.push({ id, role: m.role, contentType: "text", text: b.text });
+          if (b.cache_control) cacheControls.set(id, b.cache_control);
           break;
         }
         case "tool_use": {
@@ -217,26 +225,30 @@ function anthropicToCore(body) {
             toolCallId: b.id,
             toolName: b.name
           });
+          const id = clusters.next(base);
           msgs.push({
-            id: clusters.next(base),
+            id,
             role: "assistant",
             contentType: "tool-call",
             toolName: b.name,
             toolCallId: b.id,
             text: safeStringify(b.input)
           });
+          if (b.cache_control) cacheControls.set(id, b.cache_control);
           break;
         }
         case "tool_result": {
           const text = typeof b.content === "string" ? b.content : b.content.map((c) => c.text).join("\n");
           const base = deriveMessageId("tool", "tool-result", text, { toolCallId: b.tool_use_id });
+          const id = clusters.next(base);
           msgs.push({
-            id: clusters.next(base),
+            id,
             role: "tool",
             contentType: "tool-result",
             toolCallId: b.tool_use_id,
             text
           });
+          if (b.cache_control) cacheControls.set(id, b.cache_control);
           break;
         }
         case "thinking": {
@@ -252,9 +264,9 @@ function anthropicToCore(body) {
       }
     }
   }
-  return { msgs };
+  return { msgs, cacheControls };
 }
-function coreToAnthropic(messages) {
+function coreToAnthropic(messages, cacheControls) {
   const out = [];
   let current = null;
   const flush = () => {
@@ -263,6 +275,10 @@ function coreToAnthropic(messages) {
     }
     current = null;
   };
+  const cc = (id) => {
+    const v = cacheControls?.get(id);
+    return v ? { cache_control: v } : {};
+  };
   for (const m of messages) {
     const target = m.role === "assistant" ? "assistant" : "user";
     if (!current || current.role !== target) {
@@ -271,21 +287,23 @@ function coreToAnthropic(messages) {
     }
     switch (m.contentType) {
       case "text":
-        current.blocks.push({ type: "text", text: m.text ?? "" });
+        current.blocks.push({ type: "text", text: m.text ?? "", ...cc(m.id) });
         break;
       case "tool-call":
         current.blocks.push({
           type: "tool_use",
           id: m.toolCallId ?? `call_${m.id}`,
           name: m.toolName ?? "unknown",
-          input: safeParse(m.text)
+          input: safeParse(m.text),
+          ...cc(m.id)
         });
         break;
       case "tool-result":
         current.blocks.push({
           type: "tool_result",
           tool_use_id: m.toolCallId ?? "",
-          content: m.text ?? ""
+          content: m.text ?? "",
+          ...cc(m.id)
         });
         break;
       case "reasoning":
@@ -296,33 +314,6 @@ function coreToAnthropic(messages) {
   flush();
   return out;
 }
-function condenseOldToolResults(messages, opts) {
-  if (!opts.enabled) return { messages, condensedCount: 0, charsSaved: 0 };
-  const toolResultIndices = [];
-  for (let i = 0; i < messages.length; i++) {
-    const m = messages[i];
-    if (m && m.contentType === "tool-result") toolResultIndices.push(i);
-  }
-  if (toolResultIndices.length <= opts.keepRecent) {
-    return { messages, condensedCount: 0, charsSaved: 0 };
-  }
-  const toCondense = new Set(toolResultIndices.slice(0, toolResultIndices.length - opts.keepRecent));
-  let condensedCount = 0;
-  let charsSaved = 0;
-  const out = messages.map((m, i) => {
-    if (!toCondense.has(i)) return m;
-    const text = m.text ?? "";
-    if (text.length < opts.minChars) return m;
-    const head = text.slice(0, opts.maxKeptChars);
-    const stub = `${CONDENSED_TAG} ${text.length.toLocaleString()} chars]
-${head}
-[/acp-proxy]`;
-    charsSaved += text.length - stub.length;
-    condensedCount++;
-    return { ...m, text: stub };
-  });
-  return { messages: out, condensedCount, charsSaved };
-}
 function conversationSignalAnthropic(body, headerValue2) {
   if (headerValue2 && headerValue2.trim()) return headerValue2.trim();
   const firstUser = body.messages.find((m) => m.role === "user");
@@ -824,14 +815,14 @@ var SessionStore = class {
     if (!this.enabled) return;
     const existing = this.timers.get(session.id);
     if (existing) clearTimeout(existing);
-    const timer = setTimeout(() => {
+    const timer2 = setTimeout(() => {
       this.timers.delete(session.id);
       void this.writeNow(session).catch((e) => {
         this.log("error", `[persist] debounced write failed for ${session.id}: ${msg(e)}`);
       });
     }, this.debounceMs);
-    timer.unref?.();
-    this.timers.set(session.id, timer);
+    timer2.unref?.();
+    this.timers.set(session.id, timer2);
   }
   /** Asynchronously persist a session right now (skips the debounce). Throws
    *  on write failure so callers can react (e.g. avoid evicting). */
@@ -888,7 +879,7 @@ var SessionStore = class {
   async flushAll(sessions2) {
     if (!this.enabled) return;
     const dirty = new Set(this.timers.keys());
-    for (const timer of this.timers.values()) clearTimeout(timer);
+    for (const timer2 of this.timers.values()) clearTimeout(timer2);
     this.timers.clear();
     const pending = [];
     for (const s of sessions2) {
@@ -907,7 +898,7 @@ var SessionStore = class {
   }
   /** Cancel all pending writes without flushing (e.g. for tests). */
   cancelAll() {
-    for (const timer of this.timers.values()) clearTimeout(timer);
+    for (const timer2 of this.timers.values()) clearTimeout(timer2);
     this.timers.clear();
   }
 };
@@ -920,7 +911,6 @@ function buildRecord(session) {
     upstreamOrigin: session.upstreamOrigin,
     createdAt: session.createdAt,
     requests: session.requests,
-    condensedToolResults: session.condensedToolResults,
     tokensSaved: session.tokensSaved,
     state: session.state,
     blockContents: Object.fromEntries(session.blockContents)
@@ -939,7 +929,6 @@ function buildSession(parsed) {
     createdAt: parsed.createdAt ?? Date.now(),
     lastSeen: Date.now(),
     requests: parsed.requests ?? 0,
-    condensedToolResults: parsed.condensedToolResults ?? 0,
     tokensSaved: parsed.tokensSaved ?? 0,
     blockContents,
     inFlight: 0,
@@ -1026,7 +1015,6 @@ function getSession(id, meta) {
     createdAt: Date.now(),
     lastSeen: Date.now(),
     requests: 0,
-    condensedToolResults: 0,
     tokensSaved: 0,
     blockContents: /* @__PURE__ */ new Map(),
     inFlight: 0,
@@ -1597,6 +1585,46 @@ ${body.slice(0, 4e3)}...`;
 ${body}`;
 }
 
+// src/logger.ts
+import { createWriteStream, mkdirSync as mkdirSync3, statSync, renameSync as renameSync2 } from "fs";
+import path3 from "path";
+var MAX_BYTES = 10 * 1024 * 1024;
+var stream;
+var logPath;
+function open(pathStr) {
+  mkdirSync3(path3.dirname(pathStr), { recursive: true });
+  try {
+    if (statSync(pathStr).size >= MAX_BYTES) {
+      renameSync2(pathStr, pathStr + ".old");
+    }
+  } catch {
+  }
+  return createWriteStream(pathStr, { flags: "a" });
+}
+function configureLogger(file) {
+  if (!file || file === "off") {
+    logPath = void 0;
+    stream = void 0;
+    return void 0;
+  }
+  logPath = file;
+  stream = open(file);
+  return file;
+}
+var log = (level, msg2) => {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const line = `${ts} [${level}] ${msg2}
+`;
+  process.stderr.write(line);
+  if (stream) {
+    stream.write(line);
+  }
+};
+function closeLogger() {
+  stream?.end();
+  stream = void 0;
+}
+
 // src/compress-loop.ts
 function executeProxyTool(toolName, args, ctx) {
   if (toolName === "compress") {
@@ -1858,6 +1886,16 @@ async function* compressLoopStream(initialUpstream, ctx, requestBody, requestOpt
       const proxyCalls = toolCalls.filter((tc) => PROXY_TOOL_NAMES.has(tc.name));
       const realCalls = toolCalls.filter((tc) => !PROXY_TOOL_NAMES.has(tc.name));
       const hasOnlyProxy = proxyCalls.length > 0 && realCalls.length === 0;
+      if (usage) {
+        const prompt = usage.prompt_tokens ?? usage.input_tokens;
+        const det = usage.prompt_tokens_details ?? usage.prompt_cache_hit_tokens;
+        const cached = det?.cached_tokens ?? usage.prompt_cache_hit_tokens;
+        const out = usage.completion_tokens ?? usage.output_tokens;
+        if (typeof prompt === "number") {
+          const ch = typeof cached === "number" ? cached : 0;
+          log("info", `[acp-usage] round ${loopCount} input=${prompt} cached=${typeof cached === "number" ? cached : "?"} output=${out ?? "?"}${ch > 0 ? ` (cache hit ${Math.round(ch / prompt * 100)}%)` : ""}`);
+        }
+      }
       if (!hasOnlyProxy) {
         for (const tc of realCalls) {
           yield Buffer.from(buildToolCallSse(makeBase(), tc), "utf8");
@@ -1951,16 +1989,16 @@ function extractTextTriggers(text) {
   let i = 0;
   let n = 0;
   while (i < text.length) {
-    const open = text.indexOf(ACP_TEXT_OPEN, i);
-    if (open === -1) {
+    const open2 = text.indexOf(ACP_TEXT_OPEN, i);
+    if (open2 === -1) {
       clean += text.slice(i);
       break;
     }
-    clean += text.slice(i, open);
-    const after = open + ACP_TEXT_OPEN.length;
+    clean += text.slice(i, open2);
+    const after = open2 + ACP_TEXT_OPEN.length;
     const close = text.indexOf(ACP_TEXT_CLOSE, after);
     if (close === -1) {
-      clean += text.slice(open);
+      clean += text.slice(open2);
       break;
     }
     const payload = text.slice(after, close).trim();
@@ -2255,7 +2293,7 @@ async function* compressLoopResponsesStream(initialUpstream, ctx, requestBody, r
               const prDet = usage.prompt_tokens_details;
               const cached = inDet?.cached_tokens ?? prDet?.cached_tokens ?? "?";
               const out = usage.output_tokens ?? "?";
-              console.error(`[acp-usage] round ${loopCount} input=${prompt} cached=${cached} output=${out}${cached !== "?" && cached !== 0 && prompt !== "?" ? ` (cache hit ${Math.round(Number(cached) / Number(prompt) * 100)}%)` : ""}`);
+              log("info", `[acp-usage] round ${loopCount} input=${prompt} cached=${cached} output=${out}${cached !== "?" && cached !== 0 && prompt !== "?" ? ` (cache hit ${Math.round(Number(cached) / Number(prompt) * 100)}%)` : ""}`);
             }
           }
         }
@@ -2453,10 +2491,10 @@ function safeWrite(res, chunk) {
   } catch {
   }
 }
-function emitStreamError(res, protocol, message, log) {
+function emitStreamError(res, protocol, message, log2) {
   const visible = `
 \u274C [ACP] stream error: ${message}`;
-  log?.(`[acp-proxy: stream aborted mid-response: ${message}]`);
+  log2?.(`[acp-proxy: stream aborted mid-response: ${message}]`);
   try {
     if (protocol === "openai") {
       safeWrite(res, `data: ${JSON.stringify({ choices: [{ index: 0, delta: { content: visible }, finish_reason: null }] })}
@@ -2556,17 +2594,21 @@ function resolveUpstream(opts, reqUrl) {
   return void 0;
 }
 async function startServer(opts) {
+  const filePath = configureLogger(opts.logFile ?? defaultLogFile());
   const core = createCore();
   const config = opts.kernelConfig;
-  const log = (level, msg2) => logMsg(opts, level, msg2);
+  const log2 = (level, msg2) => logMsg(opts, level, msg2);
   await initSessions();
-  log("info", `[persist] ${getStore().enabled ? "enabled" : "disabled"}`);
+  log2("info", `[persist] ${getStore().enabled ? "enabled" : "disabled"}`);
+  if (filePath) {
+    log2("info", `[log] writing to ${filePath}`);
+  }
   const server = http.createServer(async (req, res) => {
     try {
-      await handle(req, res, opts, core, config, log);
+      await handle(req, res, opts, core, config, log2);
     } catch (err) {
       const msg2 = String(err);
-      log("error", msg2);
+      log2("error", msg2);
       if (!res.headersSent) {
         const status = msg2.includes("exceeds") ? 413 : 502;
         res.writeHead(status, { "content-type": "application/json" });
@@ -2577,7 +2619,7 @@ async function startServer(opts) {
     }
   });
   server.listen(opts.port, opts.host, () => {
-    log(
+    log2(
       "info",
       `acp-proxy listening on http://${opts.host}:${opts.port}` + (Object.keys(opts.routes).length ? ` \u2014 routes: ${Object.entries(opts.routes).map(([n, u]) => `${n}=${typeof u === "string" ? u : u.url}`).join(", ")}` : ` \u2192 ${opts.upstream}`)
     );
@@ -2586,9 +2628,10 @@ async function startServer(opts) {
   const shutdown = (sig) => {
     if (shuttingDown) return;
     shuttingDown = true;
-    log("info", `${sig} received \u2014 flushing sessions\u2026`);
+    log2("info", `${sig} received \u2014 flushing sessions\u2026`);
     server.close();
     void flushAllSessions().finally(() => {
+      closeLogger();
       process.exit(0);
     });
   };
@@ -2596,21 +2639,7 @@ async function startServer(opts) {
   process.on("SIGINT", () => shutdown("SIGINT"));
   return server;
 }
-function applyCondense(messages, opts, session) {
-  const condenseOpts = {
-    enabled: opts.condense.enabled,
-    keepRecent: opts.condense.keepRecentToolResults,
-    minChars: opts.condense.minCharsToCondense,
-    maxKeptChars: opts.condense.maxKeptChars
-  };
-  const { messages: out, condensedCount, charsSaved } = condenseOldToolResults(messages, condenseOpts);
-  if (condensedCount > 0) {
-    session.condensedToolResults += condensedCount;
-    session.tokensSaved += Math.ceil(charsSaved / 4);
-  }
-  return out;
-}
-async function handle(req, res, opts, core, config, log) {
+async function handle(req, res, opts, core, config, log2) {
   if (req.method === "GET" && req.url === "/__acp/stats") return sendStats(res);
   if (req.method === "GET" && (req.url === "/" || req.url === "/__acp/health")) {
     res.writeHead(200, { "content-type": "application/json" });
@@ -2622,12 +2651,12 @@ async function handle(req, res, opts, core, config, log) {
     bodyBuffer = await readBody(req);
   } catch (err) {
     if (err instanceof BodyTooLargeError) {
-      log("warn", `413: request body exceeds ${err.limit} bytes`);
+      log2("warn", `413: request body exceeds ${err.limit} bytes`);
       res.writeHead(413, { "content-type": "application/json" });
       res.end(JSON.stringify({ error: { type: "request_too_large", message: err.message } }));
       return;
     }
-    log("warn", `read body failed: ${String(err)}`);
+    log2("warn", `read body failed: ${String(err)}`);
     res.writeHead(400, { "content-type": "application/json" });
     res.end(JSON.stringify({ error: { type: "invalid_request", message: String(err) } }));
     return;
@@ -2663,10 +2692,10 @@ async function handle(req, res, opts, core, config, log) {
     const session = getSession(sessionId, { protocol, upstreamOrigin });
     const affinity = affinityToken(req.headers, conversation);
     await withSessionLock(session, async () => {
-      prepared = protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, log, session) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, log, session) : prepareResponses(parsed, req, opts, core, reqConfig, log, session);
+      prepared = protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, log2, session) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, log2, session) : prepareResponses(parsed, req, opts, core, reqConfig, log2, session);
       acquireInFlight(session);
       try {
-        await forward(req, res, opts, prepared.body, prepared, core, reqConfig, log, route, affinity);
+        await forward(req, res, opts, prepared.body, prepared, core, reqConfig, log2, route, affinity);
       } finally {
         releaseInFlight(session);
       }
@@ -2674,9 +2703,9 @@ async function handle(req, res, opts, core, config, log) {
   }
   if (!prepared) {
     if (protocol === null && !opts.passthrough) {
-      log("warn", `unrecognized path ${url} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses); forwarding unchanged`);
+      log2("warn", `unrecognized path ${url} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses); forwarding unchanged`);
     }
-    await forward(req, res, opts, bodyBuffer, null, core, reqConfig, log, route, void 0);
+    await forward(req, res, opts, bodyBuffer, null, core, reqConfig, log2, route, void 0);
   }
 }
 var ACP_TAG_MARK = "<acp ";
@@ -2704,24 +2733,24 @@ function diagNudge(turn, sessionId, tokenCount, limit) {
   const inject = n.shouldInject ? `INJECT T${n.tier ?? "?"}` : "idle";
   return `[${sessionId}] nudge ${inject}: usage=${pct} (${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, log, session) {
+function prepareAnthropic(parsed, req, opts, core, config, log2, session) {
   const sessionId = session.id;
-  const stream = parsed.stream === true;
+  const stream2 = parsed.stream === true;
   session.requests++;
   let processedMessages = [];
   let rebuiltMessages = parsed.messages;
   let systemOut = parsed.system;
   let toolsOut = parsed.tools;
   try {
-    const { msgs } = anthropicToCore(parsed);
+    const { msgs, cacheControls } = anthropicToCore(parsed);
     const tokenCount = estimateTokensFast3(msgs.map((m) => m.text ?? "").join("\n"));
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
-    log("info", diagTagSummary(turn.messages, sessionId, "text-only"));
-    log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
-    processedMessages = applyCondense(turn.messages, opts, session);
+    log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
+    log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
+    processedMessages = turn.messages;
     reapOrphanBlocks(session, msgs, deactivateBlock4);
-    rebuiltMessages = coreToAnthropic(processedMessages);
+    rebuiltMessages = coreToAnthropic(processedMessages, cacheControls);
     systemOut = injectSystem(parsed, opts);
     if (opts.compress.injectTool) {
       toolsOut = injectTool(parsed.tools);
@@ -2736,31 +2765,31 @@ function prepareAnthropic(parsed, req, opts, core, config, log, session) {
       }
     }
   } catch (err) {
-    log("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
+    log2("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
     processedMessages = [];
   }
   const rebuilt = { ...parsed, messages: rebuiltMessages, system: systemOut, tools: toolsOut };
   markDirty(session);
-  return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "anthropic", stream, compressInjected: opts.compress.injectTool };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "anthropic", stream: stream2, compressInjected: opts.compress.injectTool };
 }
-function prepareOpenai(parsed, req, opts, core, config, log, session) {
+function prepareOpenai(parsed, req, opts, core, config, log2, session) {
   const sessionId = session.id;
-  const stream = parsed.stream === true;
+  const stream2 = parsed.stream === true;
   session.requests++;
   let processedMessages = [];
   let rebuiltMessages = parsed.messages;
   let toolsOut = parsed.tools;
   const maxTokens = typeof parsed.max_tokens === "number" ? parsed.max_tokens : 8192;
-  const isTitleGen = maxTokens <= 200 || parsed.messages.length <= 2;
+  const isTitleGen = maxTokens <= 200;
   const shouldInject = opts.compress.injectTool && !isTitleGen;
   try {
     const { msgs } = openaiToCore(parsed);
     const tokenCount = estimateTokensFast3(msgs.map((m) => m.text ?? "").join("\n"));
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: "text-only" });
     session.state = turn.state;
-    log("info", diagTagSummary(turn.messages, sessionId, "text-only"));
-    log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
-    processedMessages = applyCondense(turn.messages, opts, session);
+    log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
+    log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
+    processedMessages = turn.messages;
     reapOrphanBlocks(session, msgs, deactivateBlock4);
     rebuiltMessages = coreToOpenai(processedMessages);
     const sysParts = [];
@@ -2779,16 +2808,16 @@ function prepareOpenai(parsed, req, opts, core, config, log, session) {
       }
     }
   } catch (err) {
-    log("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
+    log2("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
     processedMessages = [];
   }
   const rebuilt = { ...parsed, messages: rebuiltMessages, tools: toolsOut };
   markDirty(session);
-  return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "openai", stream, compressInjected: shouldInject };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "openai", stream: stream2, compressInjected: shouldInject };
 }
-function prepareResponses(parsed, req, opts, core, config, log, session) {
+function prepareResponses(parsed, req, opts, core, config, log2, session) {
   const sessionId = session.id;
-  const stream = parsed.stream === true;
+  const stream2 = parsed.stream === true;
   session.requests++;
   let processedMessages = [];
   let rebuiltInput = parsed.input;
@@ -2797,18 +2826,18 @@ function prepareResponses(parsed, req, opts, core, config, log, session) {
   try {
     const { msgs, systemParts, preamble, customToolCallIds } = responsesToCore(parsed);
     if (process.env.ACP_DEBUG) {
-      log("info", `[${sessionId}] input items: ${Array.isArray(parsed.input) ? parsed.input.map((i) => i.type).join(",") : "(string)"}`);
+      log2("info", `[${sessionId}] input items: ${Array.isArray(parsed.input) ? parsed.input.map((i) => i.type).join(",") : "(string)"}`);
     }
     const tokenCount = estimateTokensFast3(msgs.map((m) => m.text ?? "").join("\n"));
     const turn = core.processTurn({ messages: msgs, state: session.state, config, tokenCount, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
     session.state = turn.state;
-    log("info", diagTagSummary(turn.messages, sessionId, "text-only"));
-    log("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
-    processedMessages = applyCondense(turn.messages, opts, session);
+    log2("info", diagTagSummary(turn.messages, sessionId, "text-only"));
+    log2("info", diagNudge(turn, sessionId, tokenCount, config.modelContextLimit));
+    processedMessages = turn.messages;
     reapOrphanBlocks(session, msgs, deactivateBlock4);
     const conversationItems = coreToResponses(processedMessages, customToolCallIds);
     if (preamble.length > 0) {
-      log("info", `[${sessionId}] preserved ${preamble.length} opaque preamble item(s): ${preamble.map((p) => p.type).join(",")}`);
+      log2("info", `[${sessionId}] preserved ${preamble.length} opaque preamble item(s): ${preamble.map((p) => p.type).join(",")}`);
     }
     const inputItems = [...preamble];
     if (shouldInject && !process.env.ACP_NO_COMPRESS_PROMPT) {
@@ -2824,7 +2853,7 @@ function prepareResponses(parsed, req, opts, core, config, log, session) {
     if (process.env.ACP_DEBUG) {
       const ctcs = conversationItems.filter((i) => i.type === "custom_tool_call").length;
       const ctcos = conversationItems.filter((i) => i.type === "custom_tool_call_output").length;
-      log("info", `[${sessionId}] rebuilt: msgs=${msgs.length} -> conv=${conversationItems.length} (custom_tool_call=${ctcs} custom_tool_call_output=${ctcos})`);
+      log2("info", `[${sessionId}] rebuilt: msgs=${msgs.length} -> conv=${conversationItems.length} (custom_tool_call=${ctcs} custom_tool_call_output=${ctcos})`);
     }
     if (turn.nudge?.shouldInject && shouldInject) {
       try {
@@ -2837,7 +2866,7 @@ function prepareResponses(parsed, req, opts, core, config, log, session) {
     }
     rebuiltInput = inputItems;
   } catch (err) {
-    log("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
+    log2("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
     processedMessages = [];
   }
   const rebuilt = { ...parsed, input: rebuiltInput, tools: toolsOut };
@@ -2847,10 +2876,10 @@ function prepareResponses(parsed, req, opts, core, config, log, session) {
       const sub = Array.isArray(r.tools) ? `(${r.tools.length} sub)` : "";
       return `${r.type}:${r.name ?? "?"}${sub}`;
     });
-    log("info", `[${sessionId}] responses forward tools=[${fwdTools.join(",")}] injectTool=${shouldInject} NO_INJECT_TOOL=${!!process.env.ACP_NO_INJECT_TOOL} NO_COMPRESS_PROMPT=${!!process.env.ACP_NO_COMPRESS_PROMPT}`);
+    log2("info", `[${sessionId}] responses forward tools=[${fwdTools.join(",")}] injectTool=${shouldInject} NO_INJECT_TOOL=${!!process.env.ACP_NO_INJECT_TOOL} NO_COMPRESS_PROMPT=${!!process.env.ACP_NO_COMPRESS_PROMPT}`);
   }
   markDirty(session);
-  return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "responses", stream, compressInjected: shouldInject };
+  return { body: JSON.stringify(rebuilt), session, processedMessages, protocol: "responses", stream: stream2, compressInjected: shouldInject };
 }
 function injectSystem(parsed, opts) {
   const baseText = extractSystem(parsed.system);
@@ -2886,19 +2915,19 @@ function injectResponsesTool(tools) {
   const additions = ACP_TOOLS_RESPONSES.filter((t) => !present.has(t.name));
   return [...tools, ...additions];
 }
-async function forward(req, res, opts, body, prepared, core, config, log, route, affinity) {
+async function forward(req, res, opts, body, prepared, core, config, log2, route, affinity) {
   const upstreamUrl = route ? route.rewrittenUrl : opts.upstream + (req.url ?? "");
-  log("info", `forward ${req.method} ${req.url ?? ""} \u2192 ${upstreamUrl}${route ? ` (${route.provider})` : ""}`);
+  log2("info", `forward ${req.method} ${req.url ?? ""} \u2192 ${upstreamUrl}${route ? ` (${route.provider})` : ""}`);
   if (process.env.ACP_DEBUG && prepared) {
     const sid = prepared.session.id;
     const hdrKeys = Object.keys(req.headers);
-    log("info", `[${sid}] client headers: ${hdrKeys.join(",")}`);
+    log2("info", `[${sid}] client headers: ${hdrKeys.join(",")}`);
     for (const k of ["authorization", "x-api-key", "x-session-id", "x-session-affinity", "x-acp-session", "x-opencode-session", "prompt-cache-key", "anthropic-beta"]) {
       const v = req.headers[k] ?? req.headers[k.toLowerCase()];
       if (v) {
         const s = Array.isArray(v) ? v.join(",") : String(v);
         const masked = /key|auth|token/i.test(k) ? s.slice(0, 8) + "..." + s.slice(-4) + ` (${s.length} chars)` : s.slice(0, 60);
-        log("info", `[${sid}] client hdr ${k}=${masked}`);
+        log2("info", `[${sid}] client hdr ${k}=${masked}`);
       }
     }
   }
@@ -2909,11 +2938,11 @@ async function forward(req, res, opts, body, prepared, core, config, log, route,
         const fn = t.function;
         return fn?.name ?? t.name ?? "?";
       });
-      log("info", `[debug] tools=[${toolNames.join(",")}] msgs=${parsed.messages?.length ?? 0} stream=${parsed.stream ?? false} system_len=${JSON.stringify(parsed.messages?.find((m) => m.role === "system")?.content ?? "").length}`);
+      log2("info", `[debug] tools=[${toolNames.join(",")}] msgs=${parsed.messages?.length ?? 0} stream=${parsed.stream ?? false} system_len=${JSON.stringify(parsed.messages?.find((m) => m.role === "system")?.content ?? "").length}`);
       if (process.env.ACP_DUMP_REQ === "1") {
         const out = `/tmp/acp-proxy-debug-req-${Date.now()}.json`;
         fs2.writeFileSync(out, body.slice(0, 5e4));
-        log("info", `[debug] forwarded body written to ${out}`);
+        log2("info", `[debug] forwarded body written to ${out}`);
       }
     } catch {
     }
@@ -2961,7 +2990,7 @@ async function forward(req, res, opts, body, prepared, core, config, log, route,
     config,
     messages: prepared.processedMessages,
     session: prepared.session,
-    log: (msg2) => log("info", `[${prepared.session.id}] ${msg2}`),
+    log: (msg2) => log2("info", `[${prepared.session.id}] ${msg2}`),
     debug: opts.debug
   };
   if (prepared.stream) {
@@ -2991,7 +3020,7 @@ async function forward(req, res, opts, body, prepared, core, config, log, route,
           {
             const s = chunk.toString("utf8");
             if (s.includes("<acp ") || s.includes("</acp")) {
-              log("warn", `[${prepared.session.id}] tag echo: openai response stream contains <acp tag`);
+              log2("warn", `[${prepared.session.id}] tag echo: openai response stream contains <acp tag`);
             }
           }
           if (!res.write(chunk)) await new Promise((r) => res.once("drain", () => r()));
@@ -3014,7 +3043,7 @@ async function forward(req, res, opts, body, prepared, core, config, log, route,
           {
             const s = chunk.toString("utf8");
             if (s.includes("<acp ") || s.includes("</acp")) {
-              log("warn", `[${prepared.session.id}] tag echo: responses response stream contains <acp tag`);
+              log2("warn", `[${prepared.session.id}] tag echo: responses response stream contains <acp tag`);
             }
           }
           if (!res.write(chunk)) await new Promise((r) => res.once("drain", () => r()));
@@ -3025,7 +3054,7 @@ async function forward(req, res, opts, body, prepared, core, config, log, route,
           {
             const s = chunk.toString("utf8");
             if (s.includes("<acp ") || s.includes("</acp")) {
-              log("warn", `[${prepared.session.id}] tag echo: anthropic response stream contains <acp tag`);
+              log2("warn", `[${prepared.session.id}] tag echo: anthropic response stream contains <acp tag`);
             }
           }
           if (!res.write(chunk)) await new Promise((r) => res.once("drain", () => r()));
@@ -3033,7 +3062,7 @@ async function forward(req, res, opts, body, prepared, core, config, log, route,
       }
       res.end();
     } catch (e) {
-      emitStreamError(res, prepared.protocol, e?.message ?? String(e), (m) => log("error", `[${prepared.session.id}] ${m}`));
+      emitStreamError(res, prepared.protocol, e?.message ?? String(e), (m) => log2("error", `[${prepared.session.id}] ${m}`));
     } finally {
       clearUpstreamTimer();
       if (dumpRaw) await dumpRaw;
@@ -3058,8 +3087,8 @@ async function forward(req, res, opts, body, prepared, core, config, log, route,
   }
   markDirty(prepared.session);
 }
-async function pipeThrough(stream, res) {
-  const reader = stream.getReader();
+async function pipeThrough(stream2, res) {
+  const reader = stream2.getReader();
   try {
     for (; ; ) {
       const { done, value } = await reader.read();
@@ -3073,13 +3102,13 @@ async function pipeThrough(stream, res) {
     res.end();
   }
 }
-async function dumpStreamToFile(stream, dir, name) {
-  const { mkdirSync: mkdirSync3, createWriteStream } = await import("fs");
+async function dumpStreamToFile(stream2, dir, name) {
+  const { mkdirSync: mkdirSync4, createWriteStream: createWriteStream2 } = await import("fs");
   const { join: join3 } = await import("path");
   try {
-    mkdirSync3(dir, { recursive: true });
-    const ws = createWriteStream(join3(dir, name));
-    const reader = stream.getReader();
+    mkdirSync4(dir, { recursive: true });
+    const ws = createWriteStream2(join3(dir, name));
+    const reader = stream2.getReader();
     try {
       for (; ; ) {
         const { done, value } = await reader.read();
@@ -3097,7 +3126,6 @@ function sendStats(res) {
   const sessions2 = listSessions().map((s) => ({
     id: s.id,
     requests: s.requests,
-    condensedToolResults: s.condensedToolResults,
     tokensSaved: s.tokensSaved,
     lastSeen: new Date(s.lastSeen).toISOString()
   }));
@@ -3144,27 +3172,133 @@ function readBody(req) {
 }
 function logMsg(opts, level, msg2) {
   if (!opts.log) return;
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  console.error(`${ts} [${level}] ${msg2}`);
+  log(level, msg2);
+}
+
+// src/update.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { execFile } from "child_process";
+import path4 from "path";
+var REGISTRY_BASE = "https://registry.npmjs.org";
+var CHECK_INTERVAL_MS = 3 * 60 * 1e3;
+var THROTTLE_FILE = path4.join(cacheDir(), ".update-check");
+var SEMVER_RE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z-.]+)?$/;
+var timer;
+var inFlight = false;
+function parseVersion(v) {
+  return v.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+}
+function isNewer(latest, current) {
+  const l = parseVersion(latest);
+  const c = parseVersion(current);
+  for (let i = 0; i < 3; i++) {
+    const lv = l[i] ?? 0;
+    const cv = c[i] ?? 0;
+    if (lv > cv) return true;
+    if (lv < cv) return false;
+  }
+  return false;
+}
+async function readLastCheck() {
+  try {
+    const data = await readFile(THROTTLE_FILE, "utf-8");
+    return parseInt(data.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+async function writeLastCheck(ts) {
+  try {
+    await mkdir(path4.dirname(THROTTLE_FILE), { recursive: true });
+    await writeFile(THROTTLE_FILE, String(ts), "utf-8");
+  } catch {
+  }
+}
+async function checkForUpdate(opts, force = false) {
+  if (!opts.autoUpdate && !force) return;
+  if (inFlight) return;
+  inFlight = true;
+  try {
+    const now = Date.now();
+    if (!force && now - await readLastCheck() < CHECK_INTERVAL_MS) return;
+    await writeLastCheck(now);
+    const url = `${REGISTRY_BASE}/${opts.packageName}/latest`;
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(5e3),
+      headers: { Accept: "application/json" }
+    });
+    if (!res.ok) return;
+    const data = await res.json();
+    const latest = data.version;
+    if (!latest || !isNewer(latest, opts.currentVersion)) return;
+    const installed = await installLatest(opts.packageName, latest);
+    if (installed) {
+      console.error(
+        `\x1B[32m\u2714 ${opts.packageName} auto-updated ${opts.currentVersion} \u2192 ${latest}. Restart bili to finish.\x1B[0m`
+      );
+    } else {
+      console.error(
+        `\x1B[33m${opts.packageName} ${latest} is available (you have ${opts.currentVersion}). Update with: npm install -g ${opts.packageName}@latest\x1B[0m`
+      );
+    }
+  } catch {
+  } finally {
+    inFlight = false;
+  }
+}
+async function installLatest(packageName, latest) {
+  if (!SEMVER_RE.test(latest)) return false;
+  try {
+    const code = await new Promise((resolve) => {
+      execFile(
+        "npm",
+        ["install", "-g", `${packageName}@${latest}`, "--silent", "--no-audit", "--no-fund"],
+        { timeout: 12e4, shell: process.platform === "win32" },
+        (err) => resolve(err ? 1 : 0)
+      );
+    });
+    return code === 0;
+  } catch {
+    return false;
+  }
+}
+function startAutoUpdate(opts) {
+  setTimeout(() => {
+    void checkForUpdate(opts);
+  }, 1e4);
+  timer = setInterval(() => {
+    void checkForUpdate(opts);
+  }, CHECK_INTERVAL_MS);
+  timer.unref?.();
 }
 
 // src/cli.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath } from "url";
-import path3 from "path";
+import path5 from "path";
 var VERSION = (() => {
   try {
     const here = fileURLToPath(import.meta.url);
-    const pkg = path3.join(path3.dirname(here), "..", "package.json");
+    const pkg = path5.join(path5.dirname(here), "..", "package.json");
     return JSON.parse(readFileSync3(pkg, "utf8")).version ?? "dev";
   } catch {
     return "dev";
   }
 })();
+var PACKAGE_NAME = (() => {
+  try {
+    const here = fileURLToPath(import.meta.url);
+    const pkg = path5.join(path5.dirname(here), "..", "package.json");
+    return JSON.parse(readFileSync3(pkg, "utf8")).name ?? "billion-context";
+  } catch {
+    return "billion-context";
+  }
+})();
 var HELP = `bili ${VERSION} \u2014 billion-context proxy
 
 Usage:
   bili [start] [options]        start the proxy (default: reads ${configFile()})
+  bili update                   check for & install a newer version now
   bili --version                print version
   bili --help                   show this help
 
@@ -3175,9 +3309,10 @@ Options (override config file / env):
   --debug                       verbose logging
   --passthrough                 forward without compression
   --no-passthrough              force compression on (overrides config)
+  --no-auto-update              disable background self-update this run
 
 Config: ${configFile()}
-  Set port/host/debug/providers/condense/compress there. See README \xA7Configuration.
+  Set port/host/debug/providers/compress/autoUpdate there. See README \xA7Configuration.
   Env vars (ACP_*, BILI_*) also work and override the file; CLI flags win.
 
 Docs: https://github.com/ranxianglei/billion-context
@@ -3200,6 +3335,9 @@ function parseArgs(argv) {
       case "--debug":
         overrides.ACP_DEBUG = "1";
         break;
+      case "--no-auto-update":
+        overrides.ACP_AUTO_UPDATE = "0";
+        break;
       case "--passthrough":
         overrides.ACP_PASSTHROUGH = "1";
         break;
@@ -3237,6 +3375,8 @@ function parseArgs(argv) {
     const cmd = positional[0];
     if (cmd === "start") {
       command = command === "help" || command === "version" ? command : "start";
+    } else if (cmd === "update") {
+      command = "update";
     } else {
       console.error(`bili: unknown command "${cmd}" (try "bili --help")`);
       process.exit(2);
@@ -3254,17 +3394,23 @@ async function main() {
     process.stdout.write(VERSION + "\n");
     return;
   }
+  if (command === "update") {
+    await checkForUpdate({ packageName: PACKAGE_NAME, currentVersion: VERSION, autoUpdate: true }, true);
+    return;
+  }
   for (const [k, v] of Object.entries(overrides)) {
     if (v !== void 0) process.env[k] = v;
   }
   const opts = loadOptions();
   await startServer(opts);
+  if (opts.autoUpdate) {
+    startAutoUpdate({ packageName: PACKAGE_NAME, currentVersion: VERSION, autoUpdate: true });
+  }
 }
+
+// src/index.ts
 main().catch((err) => {
   console.error("bili: failed to start:", err);
   process.exit(1);
 });
-
-// src/index.ts
-main();
 //# sourceMappingURL=index.js.map