billion-context 0.1.57 → 0.1.58

package/dist/index.js

@@ -47137,6 +47137,81 @@ var import_undici = __toESM(require_undici(), 1);
 import { execFileSync } from "child_process";
 import net from "net";
 import tls from "tls";
+
+// src/log-mask.ts
+var PRIVATE_HOST = "<private-host>";
+var PUBLIC_HOST_SUFFIXES = [
+  "openai.com",
+  "chatgpt.com",
+  "anthropic.com",
+  "deepseek.com",
+  "googleapis.com",
+  "azure.com",
+  "amazonaws.com",
+  "mistral.ai",
+  "groq.com",
+  "cohere.com",
+  "together.ai",
+  "fireworks.ai",
+  "x.ai",
+  "openrouter.ai",
+  "huggingface.co",
+  "moonshot.ai",
+  "zhipuai.com",
+  "volcengine.com",
+  "aliyuncs.com",
+  "baidu.com",
+  "baidubce.com",
+  "minimax.io"
+];
+var CREDENTIAL_HEADER_RE = /key|auth|token|cookie/i;
+function isPublicApiHost(host) {
+  const h = host.replace(/^\[|\]$/g, "").toLowerCase();
+  return PUBLIC_HOST_SUFFIXES.some((s3) => h === s3 || h.endsWith(`.${s3}`));
+}
+function maskHostForLog(host) {
+  return isPublicApiHost(host) ? host : PRIVATE_HOST;
+}
+function maskUrlForLog(url) {
+  let u2;
+  try {
+    u2 = new URL(url);
+  } catch {
+    return "<unparseable-url>";
+  }
+  const host = isPublicApiHost(u2.hostname) ? u2.host : `${PRIVATE_HOST}${u2.port ? `:${u2.port}` : ""}`;
+  return `${u2.protocol}//${host}${u2.pathname}`;
+}
+function maskUrlsInText(text) {
+  return text.replace(/https?:\/\/[^\s"'<>]+/gi, (m2) => maskUrlForLog(m2));
+}
+function maskHostPortForLog(target) {
+  const i = target.lastIndexOf(":");
+  if (i <= 0) return maskHostForLog(target);
+  return `${maskHostForLog(target.slice(0, i))}${target.slice(i)}`;
+}
+function maskHeaderForLog(name, value) {
+  if (name.toLowerCase() === "host") return maskHostPortForLog(value);
+  if (CREDENTIAL_HEADER_RE.test(name)) return `<masked ${value.length} chars>`;
+  return value;
+}
+function maskHeadersForLog(headers) {
+  const out = {};
+  for (const [k2, v2] of Object.entries(headers)) out[k2] = maskHeaderForLog(k2, v2);
+  return out;
+}
+function maskHostInText(text, host) {
+  if (!host || isPublicApiHost(host)) return text;
+  const bare = host.replace(/^\[|\]$/g, "");
+  const forms = /* @__PURE__ */ new Set([host, bare]);
+  if (bare.includes(":")) forms.add(`[${bare}]`);
+  for (const form of forms) {
+    if (form.length > 0) text = text.split(form).join(PRIVATE_HOST);
+  }
+  return text;
+}
+
+// src/upstream-proxy.ts
 var dispatcherCache = /* @__PURE__ */ new Map();
 var lastConnection = {};
 var windowsProxyCache;
@@ -47460,13 +47535,20 @@ function formatUpstreamError(error, url, proxyUrl) {
   const chain = errorChain(error);
   const fields = ["code", "errno", "syscall", "address", "port"];
   const parts = [];
+  const maskHostIn = (s3) => {
+    try {
+      return maskHostInText(s3, new URL(url).hostname);
+    } catch {
+    }
+    return s3;
+  };
   for (const field of fields) {
     const value = chain.find((entry) => entry[field] !== void 0)?.[field];
-    if (value !== void 0) parts.push(`${field}=${String(value)}`);
+    if (value !== void 0) parts.push(`${field}=${maskHostIn(String(value))}`);
   }
-  const messages = chain.map((entry) => String(entry.message ?? "")).filter(Boolean);
+  const messages = chain.map((entry) => maskHostIn(String(entry.message ?? ""))).filter(Boolean);
   if (messages.length > 0) parts.push(`message=${messages.join(" <- ")}`);
-  parts.push(`url=${url}`);
+  parts.push(`url=${maskUrlForLog(url)}`);
   parts.push(`proxy=${redactProxyUrl(proxyUrl) ?? "direct"}`);
   return parts.join(" ");
 }
@@ -47520,9 +47602,7 @@ function lookupContextLimit(model) {
   }
   return void 0;
 }
-function resolveContextLimit(routes, upstreamUrl, model) {
-  return resolveConfiguredContextLimit(routes, upstreamUrl, model) ?? lookupContextLimit(model);
-}
+var FALLBACK_EFFECTIVE_WINDOW_FLOOR = 1e5;
 function findRoute(routes, upstreamUrl) {
   if (!upstreamUrl) return void 0;
   let bestKey = "";
@@ -48149,6 +48229,18 @@ function registryLookup(reg, model, host) {
     const ctx = entry?.limit?.context;
     if (typeof ctx === "number" && ctx > 0) return ctx;
   }
+  if (provider === void 0) {
+    const suffix = `/${model}`;
+    let agreed;
+    for (const key of Object.keys(reg)) {
+      if (!key.endsWith(suffix)) continue;
+      const ctx = reg[key].limit?.context;
+      if (typeof ctx !== "number" || ctx <= 0) continue;
+      if (agreed === void 0) agreed = ctx;
+      else if (agreed !== ctx) return void 0;
+    }
+    return agreed;
+  }
   return void 0;
 }
 
@@ -48890,6 +48982,7 @@ function subagentNamespace(identityValue, instructions) {
 
 // src/persist.ts
 import { createHash as createHash3 } from "crypto";
+import { rm } from "fs/promises";
 import * as path5 from "path";
 
 // node_modules/acp-kernel/dist/persist/index.js
@@ -49266,12 +49359,14 @@ function relPathFor(id, protocol, upstreamOrigin) {
 }
 var SessionStore = class {
   enabled;
+  dir;
   store;
   constructor(opts) {
     const debounceMs = opts?.debounceMs ?? defaultDebounce();
     this.enabled = (opts?.enabled ?? true) && debounceMs >= 0;
+    this.dir = opts?.dir ?? defaultDir();
     this.store = new StateStore({
-      dir: opts?.dir ?? defaultDir(),
+      dir: this.dir,
       version: PERSIST_VERSION,
       debounceMs: Math.max(0, debounceMs),
       enabled: this.enabled,
@@ -49295,6 +49390,71 @@ var SessionStore = class {
     }
     return out;
   }
+  /** One-time migration for the #286 identity change: sessions persisted
+   *  under the old derived hash id are re-keyed to the client-provided
+   *  conversation value stored in meta.label (which is now the session id
+   *  itself). Collisions on the same label keep the most recently saved
+   *  record; the losers, and any label already claimed by a new-format
+   *  session, are deleted. Records without a label cannot be mapped and are
+   *  left in place (they load under their old id but are never requested
+   *  again — the new proxy 400s anonymous requests). Self-terminating:
+   *  after one pass no loaded id differs from its label. */
+  async migrateLegacyIds() {
+    if (!this.enabled) return;
+    const loaded = await this.store.loadAll();
+    const claimed = /* @__PURE__ */ new Set();
+    const byLabel = /* @__PURE__ */ new Map();
+    let unlabeled = 0;
+    for (const [id, envelope] of loaded) {
+      const session = buildSession(envelope.payload);
+      const label = session.meta.label;
+      if (!label) {
+        unlabeled++;
+        continue;
+      }
+      if (label === id) {
+        claimed.add(id);
+        continue;
+      }
+      const prev = byLabel.get(label);
+      if (!prev || envelope.savedAt >= prev.savedAt) {
+        if (prev) await this.removeLegacyFile(prev.id, prev.session);
+        byLabel.set(label, { id, savedAt: envelope.savedAt, session });
+      } else {
+        await this.removeLegacyFile(id, session);
+      }
+    }
+    let rekeyed = 0;
+    for (const [label, { id, session }] of byLabel) {
+      if (claimed.has(label)) {
+        await this.removeLegacyFile(id, session);
+        continue;
+      }
+      session.id = label;
+      await this.store.writeNow(label, () => buildRecord(session));
+      await this.removeLegacyFile(id, session);
+      claimed.add(label);
+      rekeyed++;
+    }
+    if (rekeyed || unlabeled) {
+      log("info", `[persist] one-time migration (#286): rekeyed ${rekeyed} legacy session(s), left ${unlabeled} unlabeled legacy file(s) in place`);
+    }
+  }
+  /** Remove a legacy session file. The kernel store never deletes (cleanup
+   *  is downstream policy), so the path is recomputed here: the namespaced
+   *  layout for v2+/v3 files, the _unknown/ fallback, and the flat default
+   *  name for pre-envelope v1 files. */
+  async removeLegacyFile(id, session) {
+    const candidates = /* @__PURE__ */ new Set([
+      relPathFor(id, session.meta.protocol, session.meta.upstreamOrigin),
+      relPathFor(id),
+      flatFileNameFor(id)
+    ]);
+    for (const rel2 of candidates) {
+      await rm(path5.join(this.dir, rel2), { force: true }).catch(() => {
+      });
+    }
+  }
   /** Synchronous reload of a single session. Used on a memory miss (after
    *  LRU eviction). Sync fs is acceptable here because a miss is rare and
    *  reads a single small file (~1ms). Returns null if missing/corrupt or the
@@ -49439,6 +49599,7 @@ async function initSessions() {
   initialized = true;
   const store = getStore();
   if (!store.enabled) return;
+  await store.migrateLegacyIds();
   const loaded = await store.loadAll();
   if (loaded.size > MAX_SESSIONS) {
     const entries = [...loaded.entries()].sort((a, b2) => (b2[1].createdAt ?? 0) - (a[1].createdAt ?? 0));
@@ -50707,7 +50868,7 @@ async function* runCompressLoop(upstream, ctx, requestBody, requestOptions, adap
         }
       );
       let newBody = adapter.buildRequest(coreMessages, systemPrompt, requestBody);
-      if (process.env.ACP_DUMP_REQ !== "0" && ctx.debug) {
+      if (process.env.ACP_DUMP_BODY === "1") {
         try {
           const fs11 = await import("fs");
           const dumpDir = process.env.ACP_DUMP_DIR || `${process.env.HOME}/.local/state/billion-context/dumps`;
@@ -52383,13 +52544,6 @@ data: ${JSON.stringify({ type: "message_stop" })}
 }
 
 // src/session-id.ts
-function extractKey(headers) {
-  const auth = headers["authorization"];
-  if (typeof auth === "string" && auth.length > 0) return auth.trim();
-  const apiKey = headers["x-api-key"];
-  if (typeof apiKey === "string" && apiKey.length > 0) return `key:${apiKey.trim()}`;
-  return "(no-key)";
-}
 function clientConversationHeader(headers) {
   const pluginMarker = typeof headers["x-bili-plugin"] === "string";
   const names = ["x-bili-plugin-conversation", "x-claude-code-session-id", "x-session-affinity", "x-acp-session", "x-session-id", "x-opencode-session", "session-id", "session_id"];
@@ -52400,11 +52554,6 @@ function clientConversationHeader(headers) {
   }
   return void 0;
 }
-function deriveSessionId(headers, protocol, upstream, conversation) {
-  if (!conversation) throw new Error("deriveSessionId: conversation dimension is required (pass the conversationSignal* output)");
-  const key = extractKey(headers);
-  return hashId2(`${protocol}|${upstream}|${key}|${conversation}`);
-}
 function affinityToken(identity) {
   return identity.clientProvided ? identity.value : void 0;
 }
@@ -53746,7 +53895,7 @@ function setupMitm(server, extraDomains = [], log2 = () => {
   server.on("connect", (req, clientSocket, head) => {
     const remote = !isLoopbackAddress(clientSocket.remoteAddress);
     if (remote && !allowRemoteClients) {
-      log2(`CONNECT ${req.url} rejected: non-loopback client ${clientSocket.remoteAddress} (bind a non-loopback --host to allow remote clients)`);
+      log2(`CONNECT ${maskHostPortForLog(req.url ?? "")} rejected: non-loopback client ${clientSocket.remoteAddress} (bind a non-loopback --host to allow remote clients)`);
       clientSocket.end("HTTP/1.1 403 Forbidden\r\n\r\n");
       return;
     }
@@ -53754,7 +53903,7 @@ function setupMitm(server, extraDomains = [], log2 = () => {
     const targetPort = port || 443;
     if (!isMitmHost(hostname, extraDomains)) {
       if (remote) {
-        log2(`CONNECT ${req.url} rejected: remote client ${clientSocket.remoteAddress} tunneling non-whitelisted host`);
+        log2(`CONNECT ${maskHostPortForLog(req.url ?? "")} rejected: remote client ${clientSocket.remoteAddress} tunneling non-whitelisted host`);
         clientSocket.end("HTTP/1.1 403 Forbidden\r\n\r\n");
         return;
       }
@@ -53779,7 +53928,7 @@ function tunnelThrough(clientSocket, host, port, head, log2, proxyUrl) {
   const connectTimer = setTimeout(() => {
     if (!established) {
       aborted = true;
-      log2(`tunnel ${host}:${port} connect timeout`);
+      log2(`tunnel ${maskHostForLog(host)}:${port} connect timeout`);
       clientSocket.write("HTTP/1.1 504 Gateway Timeout\r\n\r\n");
       clientSocket.destroy();
     }
@@ -53796,7 +53945,7 @@ function tunnelThrough(clientSocket, host, port, head, log2, proxyUrl) {
     upstream.pipe(clientSocket);
     clientSocket.pipe(upstream);
     const cleanup = (where, err2) => {
-      log2(`tunnel ${host}:${port} ${where} closed: ${err2.message}`);
+      log2(`tunnel ${maskHostForLog(host)}:${port} ${where} closed: ${maskHostInText(err2.message, host)}`);
       upstream.destroy();
       clientSocket.destroy();
     };
@@ -53805,7 +53954,7 @@ function tunnelThrough(clientSocket, host, port, head, log2, proxyUrl) {
   }).catch((err2) => {
     if (aborted) return;
     clearTimeout(connectTimer);
-    log2(`tunnel ${host}:${port} connect failed: ${err2.message}`);
+    log2(`tunnel ${maskHostForLog(host)}:${port} connect failed: ${maskHostInText(err2.message, host)}`);
     clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
     clientSocket.destroy();
   });
@@ -53823,18 +53972,18 @@ function doMitm(server, clientSocket, host, port, head, log2) {
       ALPNProtocols: ["http/1.1"]
     });
   } catch (e) {
-    log2(`mitm ${host}:${port} TLS setup failed: ${e.message}`);
+    log2(`mitm ${maskHostForLog(host)}:${port} TLS setup failed: ${e.message}`);
     clientSocket.destroy();
     return;
   }
   tlsSocket[MITM_UPSTREAM_KEY] = `https://${host}`;
   tlsSocket.on("error", (err2) => {
-    log2(`mitm ${host}:${port} TLS error: ${err2.message}`);
+    log2(`mitm ${maskHostForLog(host)}:${port} TLS error: ${err2.message}`);
     tlsSocket.destroy();
     clientSocket.destroy();
   });
   const handshakeTimer = setTimeout(() => {
-    log2(`mitm ${host}:${port} TLS handshake timeout`);
+    log2(`mitm ${maskHostForLog(host)}:${port} TLS handshake timeout`);
     tlsSocket.destroy();
     clientSocket.destroy();
   }, mitmHandshakeTimeoutMs());
@@ -53842,7 +53991,7 @@ function doMitm(server, clientSocket, host, port, head, log2) {
   tlsSocket.once("close", () => clearTimeout(handshakeTimer));
   tlsSocket.once("error", () => clearTimeout(handshakeTimer));
   server.emit("connection", tlsSocket);
-  log2(`mitm ${host}:${port} tunnel established (TLS terminated locally)`);
+  log2(`mitm ${maskHostForLog(host)}:${port} tunnel established (TLS terminated locally)`);
 }
 function readMitmUpstream(socket) {
   if (!socket) return void 0;
@@ -54567,6 +54716,9 @@ async function decodeRequestBody(contentEncoding, input, maxOutputBytes) {
 }
 
 // src/server.ts
+function bodyDumpEnabled() {
+  return process.env.ACP_DUMP_BODY === "1";
+}
 function parseLauncherModelWindows(raw) {
   if (!raw) return {};
   try {
@@ -54585,6 +54737,10 @@ var LAUNCHER_MODEL_WINDOWS = parseLauncherModelWindows(process.env.BILI_LAUNCHER
 function launcherContextWindow(model) {
   return LAUNCHER_MODEL_WINDOWS[model];
 }
+function safeSessionId(id) {
+  return (id ?? "unknown").replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+var NO_IDENTITY_MESSAGE = "Missing stable conversation identity. Send one of the headers: x-session-id, x-session-affinity, x-acp-session, x-opencode-session, x-claude-code-session-id, session-id \u2014 or body session_id / prompt_cache_key (responses/openai). Content-fingerprint sessions are disabled (#286).";
 var UPSTREAM_HOP_HEADERS = /* @__PURE__ */ new Set([
   "host",
   "content-length",
@@ -54681,7 +54837,7 @@ async function startServer(opts) {
     }
   });
   server.on("upgrade", (req, socket) => {
-    log2("info", `[ws] rejected ${req.method} ${req.url ?? ""} host=${req.headers.host ?? "?"} with 426`);
+    log2("info", `[ws] rejected ${req.method} ${maskUrlsInText(req.url ?? "")} host=${req.headers.host ? maskHostPortForLog(req.headers.host) : "?"} with 426`);
     socket.on("error", () => {
     });
     const body = JSON.stringify({ error: "WebSocket upgrades are not supported; use HTTP POST" });
@@ -54963,25 +55119,31 @@ async function handle(req, res, opts, core, config, log2) {
     }
   }
   if (opts.debug && parsed && typeof parsed === "object") {
+    const p2 = parsed;
+    const hasPrev = p2.previous_response_id !== void 0;
+    const inLen = Array.isArray(p2.input) ? p2.input.length : 0;
+    log2("info", `[debug] INCOMING previous_response_id=${hasPrev ? String(p2.previous_response_id).slice(0, 16) : "absent"} input_items=${inLen} instructions=${p2.instructions !== void 0 ? "present" : "absent"}`);
+  }
+  if (bodyDumpEnabled() && parsed && typeof parsed === "object") {
     try {
-      const p2 = parsed;
-      const hasPrev = p2.previous_response_id !== void 0;
-      const inLen = Array.isArray(p2.input) ? p2.input.length : 0;
-      log2("info", `[debug] INCOMING previous_response_id=${hasPrev ? String(p2.previous_response_id).slice(0, 16) : "absent"} input_items=${inLen} instructions=${p2.instructions !== void 0 ? "present" : "absent"}`);
-      const rawDir = `${stateDir()}/raw`;
+      const rawDir = process.env.ACP_RAW_DUMP_DIR || `${stateDir()}/raw`;
       try {
         fs6.mkdirSync(rawDir, { recursive: true });
       } catch {
       }
-      const hdrs = Object.entries(req.headers).filter(([k2]) => !/authorization|x-api-key|cookie/i.test(k2)).map(([k2, v2]) => `${k2}: ${Array.isArray(v2) ? v2.join(",") : v2}`).join("\n");
-      fs6.writeFileSync(`${rawDir}/${Date.now()}-INCOMING.txt`, `${req.method} ${req.url}
-${hdrs}
+      const hdrs = maskHeadersForLog(
+        Object.fromEntries(Object.entries(req.headers).map(([k2, v2]) => [k2, Array.isArray(v2) ? v2.join(",") : String(v2)]))
+      );
+      const hdrText = Object.entries(hdrs).map(([k2, v2]) => `${k2}: ${v2}`).join("\n");
+      fs6.writeFileSync(`${rawDir}/${Date.now()}-INCOMING.txt`, `${req.method} ${maskUrlsInText(req.url ?? "")}
+${hdrText}
 
 ${bodyBuffer.toString("utf8")}`);
     } catch {
     }
   }
   let reqConfig = config;
+  let nativeFromFallback = false;
   let reqPrompts = defaultPrompts;
   if (parsed && typeof parsed === "object") {
     const model = parsed.model;
@@ -54994,9 +55156,16 @@ ${bodyBuffer.toString("utf8")}`);
           return void 0;
         }
       })();
-      let native = pluginReportedContextWindow(req.headers) ?? launcherContextWindow(model) ?? (host ? peekRegistryContext(model, host) : void 0) ?? resolveContextLimit(opts.routes, embeddedUrl, model);
+      const pluginWindow = pluginReportedContextWindow(req.headers);
+      const launcherWindow = launcherContextWindow(model);
+      const peekWindow = host ? peekRegistryContext(model, host) : void 0;
+      const configuredWindow = resolveConfiguredContextLimit(opts.routes, embeddedUrl, model);
+      let native = pluginWindow ?? launcherWindow ?? peekWindow ?? configuredWindow ?? lookupContextLimit(model);
+      const operatorWindowTuned = resolveCompress(opts.routes, embeddedUrl, model, opts.compress).modelContextLimit !== void 0;
+      nativeFromFallback = !pluginWindow && !launcherWindow && !peekWindow && !configuredWindow && !operatorWindowTuned;
       if (!native && host) {
         native = await contextFromRegistry(model, host);
+        if (native) nativeFromFallback = false;
       }
       reqConfig = resolveRequestConfig(config, opts.routes, embeddedUrl, model, native, opts.compress);
       reqPrompts = resolveCompressPrompts(resolveCompress(opts.routes, embeddedUrl, model, opts.compress));
@@ -55022,7 +55191,14 @@ ${bodyBuffer.toString("utf8")}`);
       responsesIdentity?.value ?? conversationSignalResponses(parsed, convHeader),
       parsed.instructions
     );
-    const sessionId = deriveSessionId(req.headers, protocol, upstreamOrigin, conversation);
+    const clientProvided = protocol === "responses" ? responsesIdentity?.clientProvided ?? false : protocol === "openai" ? openaiIdentity?.clientProvided ?? false : !!convHeader;
+    if (!clientProvided) {
+      log2("warn", `400: no stable conversation identity on ${protocol} request \u2192 ${upstreamOrigin}; refusing to create a content-fingerprint session (#286)`);
+      res.writeHead(400, { "content-type": "application/json" });
+      res.end(JSON.stringify(protocol === "anthropic" ? { type: "error", error: { type: "invalid_request_error", message: NO_IDENTITY_MESSAGE } } : { error: { type: "invalid_request_error", message: NO_IDENTITY_MESSAGE } }));
+      return;
+    }
+    const sessionId = conversation;
     const bodyIdentity = responsesIdentity ?? openaiIdentity;
     const affinity = affinityToken(bodyIdentity ?? {
       value: clientConv ?? conversation,
@@ -55065,19 +55241,24 @@ ${bodyBuffer.toString("utf8")}`);
     if (learnedLimit && learnedLimit > 0 && learnedLimit < reqConfig.modelContextLimit) {
       const resolved = reqConfig.modelContextLimit;
       reqConfig = { ...reqConfig, modelContextLimit: learnedLimit };
+      nativeFromFallback = false;
       log2("info", `[${session.id}] self-healed context window: ${resolved} \u2192 ${learnedLimit} (learned from an upstream overflow)`);
     }
     if (shouldReserveOutputHeadroom(protocol)) {
       const p2 = parsed;
       const rawMax = p2.max_tokens ?? p2.max_completion_tokens ?? p2.max_output_tokens;
       const maxOutput = typeof rawMax === "number" ? rawMax : 0;
-      const reserved = reserveOutputHeadroom(reqConfig.modelContextLimit, maxOutput);
+      let reserved = reserveOutputHeadroom(reqConfig.modelContextLimit, maxOutput);
+      if (nativeFromFallback && reserved < FALLBACK_EFFECTIVE_WINDOW_FLOOR) {
+        log2("info", `[${session.id}] fallback context window floored: ${reserved} \u2192 ${FALLBACK_EFFECTIVE_WINDOW_FLOOR} (model=${String(p2.model ?? "?")} not authoritatively identified; self-heal corrects it if the real window is smaller)`);
+        reserved = FALLBACK_EFFECTIVE_WINDOW_FLOOR;
+      }
       if (reserved !== reqConfig.modelContextLimit) reqConfig = { ...reqConfig, modelContextLimit: reserved };
     }
     acquireInFlight(session);
     try {
       await withSessionLock(session, async () => {
-        const runPrepare = () => countTokens ? prepareCountTokens(parsed, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session) : prepareResponses(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity, pluginMode);
+        const runPrepare = () => countTokens ? prepareCountTokens(parsed, core, reqConfig, log2, session) : protocol === "anthropic" ? prepareAnthropic(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : protocol === "openai" ? prepareOpenai(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, pluginMode) : responsesCompact ? prepareResponsesCompact(bodyBuffer, parsed, session) : prepareResponses(parsed, req, opts, core, reqConfig, reqPrompts, log2, session, responsesIdentity, pluginMode, upstreamOrigin);
         prepared = runPrepare();
         if (!countTokens && !responsesCompact) {
           prepared = await preflightCompressIfNeeded(
@@ -55105,7 +55286,7 @@ ${bodyBuffer.toString("utf8")}`);
   }
   if (!prepared) {
     if (protocol === null && !opts.passthrough) {
-      log2("warn", `unrecognized path ${req.url ?? ""} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses, /responses/compact); forwarding unchanged`);
+      log2("warn", `unrecognized path ${maskUrlsInText(req.url ?? "")} \u2014 not a known protocol (/chat/completions, /v1/messages, /responses, /responses/compact); forwarding unchanged`);
     }
     await forward(req, res, opts, bodyBuffer, null, core, reqConfig, log2, route, void 0);
   }
@@ -55254,6 +55435,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
     processedMessages = [];
   }
   const rebuilt = { ...parsed, messages: rebuiltMessages, tools: toolsOut };
+  delete rebuilt.prompt_cache_retention;
   if (stream2 && rebuilt.stream_options === void 0) {
     rebuilt.stream_options = { include_usage: true };
   }
@@ -55261,7 +55443,7 @@ function prepareOpenai(parsed, req, opts, core, config, prompts, log2, session,
   markDirty(session);
   return { body: JSON.stringify(rebuilt), session, processedMessages, originalMessages, protocol: "openai", stream: stream2, compressInjected: injectTools, pluginMode, nudge, prompts, openaiSystemText };
 }
-function prepareResponses(parsed, req, opts, core, config, prompts, log2, session, identity, pluginMode) {
+function prepareResponses(parsed, req, opts, core, config, prompts, log2, session, identity, pluginMode, upstreamOrigin) {
   const sessionId = session.id;
   const stream2 = parsed.stream === true;
   ++session.stats.requests;
@@ -55285,7 +55467,7 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
   }
   const shouldInject = opts.compress.injectTool;
   const injectTools = shouldInject && !pluginMode;
-  const responsesTextProtocol = FORCE_TEXT_PROTOCOL || resolveCompressProtocol(opts.routes, session.meta.upstreamOrigin) === "marker";
+  const responsesTextProtocol = FORCE_TEXT_PROTOCOL || resolveCompressProtocol(opts.routes, upstreamOrigin) === "marker";
   try {
     const projection = responsesToCore(parsed);
     responsesProjection = projection;
@@ -55320,7 +55502,8 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     } else if (projection.systemParts.length > 0) {
       rebuiltInput = injectResponsesDeveloperMessage(rebuiltInput, projection.systemParts.join("\n\n---\n\n"));
     }
-    if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject) {
+    const triggerFinal = Array.isArray(rebuiltInput) && rebuiltInput.length > 0 && rebuiltInput[rebuiltInput.length - 1].type === "compaction_trigger";
+    if (opts.compress.injectNudge && turn.nudge?.shouldInject && shouldInject && !triggerFinal) {
       try {
         const rendered = renderNudgeText(turn.nudge, prompts);
         if (rendered.text) {
@@ -55340,11 +55523,12 @@ function prepareResponses(parsed, req, opts, core, config, prompts, log2, sessio
     rebuilt.prompt_cache_key,
     identity,
     opts.promptCache.routing,
-    session.meta.upstreamOrigin
+    upstreamOrigin
   );
   if (promptCacheKey && !rebuilt.prompt_cache_key) rebuilt.prompt_cache_key = promptCacheKey;
   if (process.env.ACP_KEEP_RESPONSE_ID !== "1") delete rebuilt.previous_response_id;
   delete rebuilt.instructions;
+  delete rebuilt.prompt_cache_retention;
   if (process.env.ACP_DEBUG) {
     const fwdTools = (Array.isArray(toolsOut) ? toolsOut : []).map((t) => {
       const r = t;
@@ -55530,7 +55714,7 @@ async function preflightCompressIfNeeded(prepared, runPrepare, req, res, opts, c
 }
 async function forward(req, res, opts, body, prepared, core, config, log2, route, affinity) {
   const { upstreamUrl, headers, proxyUrl } = buildForwardTarget(req, opts, route, affinity);
-  log2("info", `forward ${req.method} \u2192 ${upstreamUrl}`);
+  log2("info", `forward ${req.method} \u2192 ${maskUrlForLog(upstreamUrl)}`);
   if (process.env.ACP_DEBUG && prepared) {
     const sid = prepared.session.id;
     const hdrKeys = Object.keys(req.headers);
@@ -55544,22 +55728,24 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
       }
     }
   }
-  if (opts.debug && typeof body === "string") {
+  if (typeof body === "string" && (opts.debug || bodyDumpEnabled())) {
     try {
       const parsed = JSON.parse(body);
-      const toolNames = (parsed.tools ?? []).map((t) => {
-        const fn = t.function;
-        return fn?.name ?? t.name ?? "?";
-      });
-      log2("info", `[debug] tools=[${toolNames.join(",")}] msgs=${parsed.messages?.length ?? 0} stream=${parsed.stream ?? false} system_len=${JSON.stringify(parsed.messages?.find((m2) => m2.role === "system")?.content ?? "").length}`);
-      if (process.env.ACP_DUMP_REQ !== "0") {
+      if (opts.debug) {
+        const toolNames = (parsed.tools ?? []).map((t) => {
+          const fn = t.function;
+          return fn?.name ?? t.name ?? "?";
+        });
+        log2("info", `[debug] tools=[${toolNames.join(",")}] msgs=${parsed.messages?.length ?? 0} stream=${parsed.stream ?? false} system_len=${JSON.stringify(parsed.messages?.find((m2) => m2.role === "system")?.content ?? "").length}`);
+      }
+      if (bodyDumpEnabled() && process.env.ACP_DUMP_REQ !== "0") {
         const dumpDir = process.env.ACP_DUMP_DIR || `${stateDir()}/dumps`;
         try {
           fs6.mkdirSync(dumpDir, { recursive: true });
         } catch {
         }
         const sid = prepared?.session.id ?? "unknown";
-        const out = `${dumpDir}/req-${Date.now()}-${sid}.json`;
+        const out = `${dumpDir}/req-${Date.now()}-${safeSessionId(sid)}.json`;
         try {
           const pretty = JSON.stringify(JSON.parse(body), null, 2);
           fs6.writeFileSync(out, pretty);
@@ -55574,26 +55760,28 @@ async function forward(req, res, opts, body, prepared, core, config, log2, route
   if (opts.debug) {
     const hdrLog = {};
     for (const [hk, hv] of Object.entries(headers)) {
-      if (typeof hv === "string") hdrLog[hk] = hv.length > 200 ? hv.slice(0, 200) + "..." : hv;
+      if (typeof hv === "string") {
+        const masked = maskHeaderForLog(hk, hv);
+        hdrLog[hk] = masked.length > 200 ? masked.slice(0, 200) + "..." : masked;
+      }
     }
     log2("info", `[${prepared?.session.id ?? "unknown"}] \u2192 upstream headers: ${JSON.stringify(hdrLog)}`);
   }
-  const rawBase = opts.debug ? (() => {
+  const rawBase = bodyDumpEnabled() ? (() => {
     try {
       const rawDir = process.env.ACP_RAW_DUMP_DIR || `${stateDir()}/raw`;
       fs6.mkdirSync(rawDir, { recursive: true });
-      return `${rawDir}/${Date.now()}-${prepared?.session.id ?? "unknown"}`;
+      return `${rawDir}/${Date.now()}-${safeSessionId(prepared?.session.id)}`;
     } catch {
       return "";
     }
   })() : "";
   if (rawBase) {
     try {
-      const maskHdr = (k2, v2) => /key|auth|token/i.test(k2) ? `<masked ${v2.length} chars>` : v2;
-      const hdrText = Object.entries(headers).map(([k2, v2]) => `${k2}: ${maskHdr(k2, String(v2))}`).join("\n");
+      const hdrText = Object.entries(maskHeadersForLog(headers)).map(([k2, v2]) => `${k2}: ${v2}`).join("\n");
       const bodyText = req.method === "GET" || req.method === "HEAD" ? "" : typeof body === "string" ? body : Buffer.from(body).toString("utf8");
       const reqPath = `${rawBase}-REQ.txt`;
-      fs6.writeFileSync(reqPath, `${req.method ?? "POST"} ${upstreamUrl}
+      fs6.writeFileSync(reqPath, `${req.method ?? "POST"} ${maskUrlForLog(upstreamUrl)}
 ${hdrText}
 
 ${bodyText}`);
@@ -55633,14 +55821,14 @@ ${bodyText}`);
     upstream.headers.forEach((v2, k2) => {
       const lower = k2.toLowerCase();
       if (UPSTREAM_HOP_HEADERS.has(lower) || respConnNamed.has(lower)) return;
-      respLog[k2] = v2.length > 300 ? v2.slice(0, 300) + "..." : v2;
+      const masked = maskHeaderForLog(k2, v2);
+      respLog[k2] = masked.length > 300 ? masked.slice(0, 300) + "..." : masked;
     });
     log2("info", `[${prepared?.session.id ?? "unknown"}] \u2190 upstream response headers: ${JSON.stringify(respLog)}`);
   }
   if (rawBase) {
     try {
-      const maskHdr = (k2, v2) => /key|auth|token/i.test(k2) ? `<masked ${v2.length} chars>` : v2;
-      const hdrText = Object.entries(respHeaders).map(([k2, v2]) => `${k2}: ${maskHdr(k2, v2)}`).join("\n");
+      const hdrText = Object.entries(maskHeadersForLog(respHeaders)).map(([k2, v2]) => `${k2}: ${v2}`).join("\n");
       const resPath = `${rawBase}-RES.txt`;
       fs6.writeFileSync(resPath, `${upstream.status}
 ${hdrText}
@@ -55747,7 +55935,7 @@ ${hdrText}
     if (opts.dumpSse) {
       const [a, b2] = upstream.body.tee();
       streamToRead = a;
-      dumpRaw = dumpStreamToFile(b2, opts.dumpSse, `${Date.now()}-${prepared.session.id}-raw.sse`);
+      dumpRaw = dumpStreamToFile(b2, opts.dumpSse, `${Date.now()}-${safeSessionId(prepared.session.id)}-raw.sse`);
     }
     try {
       const parsedReq = JSON.parse(typeof body === "string" ? body : body.toString("utf8"));
@@ -55976,7 +56164,7 @@ function logMsg(opts, level, msg) {
 }
 
 // src/update.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access, constants, rm, cp, unlink } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, access, constants, rm as rm2, cp, unlink } from "fs/promises";
 import { execFile } from "child_process";
 import crypto from "crypto";
 
@@ -59055,7 +59243,7 @@ async function syntaxCheckEntry(entryAbs) {
     return null;
   } finally {
     try {
-      await rm(tmpCheck, { force: true });
+      await rm2(tmpCheck, { force: true });
     } catch {
     }
   }
@@ -59140,7 +59328,7 @@ async function tryAcquireLock() {
     release: async () => {
       const current = await readLock();
       if (current?.pid === pid) {
-        await rm(LOCK_FILE, { force: true }).catch(() => {
+        await rm2(LOCK_FILE, { force: true }).catch(() => {
         });
       }
     }
@@ -59287,7 +59475,7 @@ async function installViaTarball(version2, tarballUrl, installDir, integrity, sh
   }
   const stagingDir = path10.join(cacheDir(), `.update-staging-${version2}`);
   try {
-    await rm(stagingDir, { recursive: true, force: true });
+    await rm2(stagingDir, { recursive: true, force: true });
     await mkdir2(stagingDir, { recursive: true });
     await So({
       file: tmpFile,
@@ -59305,18 +59493,18 @@ async function installViaTarball(version2, tarballUrl, installDir, integrity, sh
   } catch (e) {
     return { ok: false, error: `extraction failed: ${String(e)}` };
   } finally {
-    await rm(tmpFile, { force: true });
+    await rm2(tmpFile, { force: true });
   }
   const backupDir = path10.join(cacheDir(), `.update-backup-${version2}`);
   try {
-    await rm(backupDir, { recursive: true, force: true });
+    await rm2(backupDir, { recursive: true, force: true });
     await cp(installDir, backupDir, { recursive: true, force: true });
   } catch (e) {
     return { ok: false, error: `backup of current install failed (install left untouched): ${String(e)}` };
   }
   const restoreFromBackup = async () => {
     try {
-      await rm(installDir, { recursive: true, force: true });
+      await rm2(installDir, { recursive: true, force: true });
       await cp(backupDir, installDir, { recursive: true, force: true });
       return null;
     } catch (e) {
@@ -59329,7 +59517,7 @@ async function installViaTarball(version2, tarballUrl, installDir, integrity, sh
   } catch (e) {
     copyError = `failed to copy to install dir: ${String(e)}`;
   } finally {
-    await rm(stagingDir, { recursive: true, force: true });
+    await rm2(stagingDir, { recursive: true, force: true });
   }
   if (copyError !== null) {
     const rb2 = await restoreFromBackup();
@@ -59348,7 +59536,7 @@ async function installViaTarball(version2, tarballUrl, installDir, integrity, sh
     const rb2 = await restoreFromBackup();
     return { ok: false, error: rb2 ?? postEntryErr };
   }
-  await rm(backupDir, { recursive: true, force: true });
+  await rm2(backupDir, { recursive: true, force: true });
   return { ok: true };
 }
 function startAutoUpdate(opts) {
@@ -60033,7 +60221,7 @@ function launcherDirectUrl(env) {
   return env.BILI_LAUNCHER_DIRECT === "1";
 }
 function launcherInjectMcp(env, base) {
-  return base !== "pi" && base !== "omp" && base !== "opencode" && base !== "hermes" && base !== "dsh" && env.BILI_LAUNCHER_PLUGIN === "1";
+  return base !== "pi" && base !== "omp" && base !== "opencode" && base !== "hermes" && base !== "dsh" && env.BILI_LAUNCHER_PLUGIN !== "0";
 }
 function buildMcpConfig(origin) {
   const script = selfDistFile("mcp.js");
@@ -60369,7 +60557,7 @@ function prepareHermesHome(hermesHome, origin, rewrites) {
     const rawLine = lines[i];
     const m2 = /^(\s*(?:api|base_url|url):\s*)(\S+)(\s+#.*)?$/.exec(rawLine);
     if (!m2) continue;
-    const rawUrl = m2[2];
+    const rawUrl = m2[2].replace(/^["']|["']$/g, "");
     if (!/^https?:\/\//i.test(rawUrl)) continue;
     const real = unwrapUpstream2(rawUrl);
     if (!wrapSet.has(real)) continue;
@@ -60382,6 +60570,90 @@ function prepareHermesHome(hermesHome, origin, rewrites) {
   writeOverlayFileAtomic(overlay, "config.yaml", lines.join(eol));
   return overlay;
 }
+function writeHermesIdentityPlugin(hermesHome, overlay, rewrites) {
+  try {
+    if (fs10.existsSync(path13.join(hermesHome, "plugins"))) return false;
+  } catch {
+    return false;
+  }
+  const dir = path13.join("plugins", "model-providers", "bili-session-identity");
+  try {
+    fs10.mkdirSync(path13.join(overlay, dir), { recursive: true });
+  } catch {
+    return false;
+  }
+  const keys = rewrites.map((r) => r.key);
+  const pluginDir = path13.join(overlay, dir);
+  try {
+    fs10.writeFileSync(path13.join(pluginDir, "__init__.py"), hermesIdentityPluginSource(keys));
+    fs10.writeFileSync(path13.join(pluginDir, "plugin.yaml"), [
+      "name: bili-session-identity",
+      "kind: model-provider",
+      "version: 1.0.0",
+      "description: billion-context session identity (installed by `bili hermes` \u2014 safe to delete)",
+      "author: billion-context",
+      ""
+    ].join("\n"));
+  } catch {
+    return false;
+  }
+  try {
+    return fs10.existsSync(path13.join(overlay, dir, "__init__.py"));
+  } catch {
+    return false;
+  }
+}
+function hermesIdentityPluginSource(providerKeys) {
+  return [
+    '"""Installed by `bili hermes` (billion-context) \u2014 safe to delete.',
+    "",
+    "Re-registers hermes's `custom` provider profile (plus a `custom:<name>`",
+    "profile for every provider the proxy fronts) with one addition: the",
+    "REAL hermes session id is sent as `prompt_cache_key` on every request,",
+    "which the billion-context proxy uses as the stable conversation",
+    "identity for its compression sessions. Removing this file restores",
+    'stock behavior (no prompt_cache_key)."""',
+    "from providers import get_provider_profile, register_provider",
+    "from providers.base import ProviderProfile",
+    "",
+    `_PROVIDER_KEYS = ${JSON.stringify(providerKeys)}`,
+    "",
+    '_custom = get_provider_profile("custom")',
+    "_BASE = type(_custom) if _custom is not None else ProviderProfile",
+    "",
+    "",
+    "class _BiliSessionIdentity(_BASE):",
+    "    def build_api_kwargs_extras(self, *, session_id=None, **ctx):",
+    "        extra_body, top_level = _BASE.build_api_kwargs_extras(",
+    "            self, session_id=session_id, **ctx",
+    "        )",
+    '        sid = str(session_id or "").strip()',
+    "        if sid:",
+    '            top_level.setdefault("prompt_cache_key", sid[:64])',
+    "        return extra_body, top_level",
+    "",
+    "",
+    "def _register(name, template, with_aliases):",
+    "    fields = {}",
+    "    if template is not None:",
+    "        # Aliases are copied ONLY for the canonical custom",
+    "        # re-registration: copying them onto custom:<name> entries",
+    "        # would steal the aliases (register_provider re-points each",
+    "        # alias at the registering name).",
+    '        for attr in (("aliases",) if with_aliases else ()) + ("env_vars", "base_url", "default_max_tokens"):',
+    "            value = getattr(template, attr, None)",
+    "            if value:",
+    "                fields[attr] = value",
+    "    register_provider(_BiliSessionIdentity(name=name, **fields))",
+    "",
+    "",
+    "if _custom is not None:",
+    '    _register("custom", _custom, True)',
+    "for _key in _PROVIDER_KEYS:",
+    '    _register("custom:" + _key, _custom, False)',
+    ""
+  ].join("\n");
+}
 function prepareDshHome(dshHome, origin, rewrites) {
   const cfgPath = path13.join(dshHome, "settings.yaml");
   let txt;
@@ -60689,8 +60961,10 @@ async function runLaunch(params, deps = {}) {
     }
   }
   const injectMcp = launcherInjectMcp(process.env, base);
-  if (!injectMcp && (base === "claude" || base === "codex")) {
-    console.error("bili: plugin mode off \u2014 set BILI_LAUNCHER_PLUGIN=1 to enable native MCP tools (experimental; verified with claude 2.1.227 / codex 0.147.0).");
+  if (injectMcp) {
+    console.error(`bili: injecting native bili MCP tools for ${base} (disable with BILI_LAUNCHER_PLUGIN=0).`);
+  } else if (base === "claude" || base === "codex") {
+    console.error("bili: native MCP tools disabled (BILI_LAUNCHER_PLUGIN=0) \u2014 running in pure wire mode.");
   }
   const origin = handle2.origin;
   if (base === "pi") {
@@ -60720,6 +60994,11 @@ async function runLaunch(params, deps = {}) {
     hermesOverlayHome = prepareHermesHome(resolveHermesHome(process.env), origin, routes.httpRewrites);
     if (hermesOverlayHome) {
       env.HERMES_HOME = hermesOverlayHome;
+      if (!writeHermesIdentityPlugin(resolveHermesHome(process.env), hermesOverlayHome, routes.httpRewrites)) {
+        console.error(
+          "bili: ~/.hermes has its own plugins/ \u2014 skipping the session-identity plugin; hermes requests will be rejected by the proxy without an identity (see #286)."
+        );
+      }
     } else {
       console.error(
         routes.httpRewrites.length === 0 ? "bili: no hermes providers found in ~/.hermes/config.yaml \u2014 traffic will NOT go through the proxy (configure a provider first)." : "bili: hermes config.yaml could not be rewritten (unreadable or no matching provider endpoints) \u2014 traffic will NOT go through the proxy."
@@ -60728,6 +61007,7 @@ async function runLaunch(params, deps = {}) {
   } else if (base === "dsh") {
     env = { ...process.env, BILLION_CONTEXT_PROXY: origin };
     env.DEEPSEEK_BASE_URL = wrapUpstream(origin, "https://api.deepseek.com");
+    env.PI_CACHE_RETENTION = "long";
     const dshHomeDir = resolveDshHome(process.env);
     dshOverlayHome = prepareDshHome(dshHomeDir, origin, routes.httpRewrites);
     if (dshOverlayHome) {