billion-context 0.1.15 → 0.1.16

package/dist/index.js

@@ -38,65 +38,6 @@ function defaultLogFile() {
   return path.join(stateDir(), "bili.log");
 }
 
-// src/logger.ts
-import { createWriteStream, mkdirSync, statSync, renameSync } from "fs";
-import path2 from "path";
-var MAX_BYTES = 10 * 1024 * 1024;
-var stream;
-var logPath;
-var bytesWritten = 0;
-function open(pathStr) {
-  mkdirSync(path2.dirname(pathStr), { recursive: true });
-  let existingSize = 0;
-  try {
-    existingSize = statSync(pathStr).size;
-    if (existingSize >= MAX_BYTES) {
-      rotate(pathStr);
-      existingSize = 0;
-    }
-  } catch {
-  }
-  const s = createWriteStream(pathStr, { flags: "a" });
-  bytesWritten = existingSize;
-  return s;
-}
-function rotate(pathStr) {
-  try {
-    renameSync(pathStr, pathStr + ".old");
-  } catch {
-  }
-}
-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 && logPath) {
-    if (bytesWritten >= MAX_BYTES) {
-      stream.end();
-      rotate(logPath);
-      stream = open(logPath);
-    }
-    stream.write(line);
-    bytesWritten += Buffer.byteLength(line);
-  }
-};
-function closeLogger() {
-  stream?.end();
-  stream = void 0;
-  bytesWritten = 0;
-}
-
 // src/config.ts
 function safeReadJson(path6) {
   try {
@@ -104,7 +45,7 @@ function safeReadJson(path6) {
     return JSON.parse(raw);
   } catch (e) {
     if (e.code !== "ENOENT") {
-      log("error", `[acp-config] failed to parse ${path6}: ${String(e)}`);
+      console.error(`[acp-config] failed to parse ${path6}: ${String(e)}`);
     }
     return void 0;
   }
@@ -743,9 +684,9 @@ import { createInitialState as createInitialState2 } from "acp-kernel";
 
 // src/persist.ts
 import { promises as fs } from "fs";
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
 import { createHash as createHash2 } from "crypto";
-import * as path3 from "path";
+import * as path2 from "path";
 import { createInitialState } from "acp-kernel";
 var PERSIST_VERSION = 1;
 function mergeState(parsed) {
@@ -771,7 +712,7 @@ function hostLabel(upstreamOrigin) {
 function relPathFor(id, protocol, upstreamOrigin) {
   const proto = protocol ?? "_unknown";
   const host = protocol ? hostLabel(upstreamOrigin) + "_" : "";
-  return path3.join(proto, `${host}${createHash2("sha256").update(id, "utf8").digest("hex").slice(0, 24)}.json`);
+  return path2.join(proto, `${host}${createHash2("sha256").update(id, "utf8").digest("hex").slice(0, 24)}.json`);
 }
 function legacyFileNameFor(id) {
   return createHash2("sha256").update(id, "utf8").digest("hex").slice(0, 24) + ".json";
@@ -791,13 +732,13 @@ var SessionStore = class {
     this.log = opts?.log ?? defaultLogger;
   }
   filePath(id, protocol, upstreamOrigin) {
-    return path3.join(this.dir, relPathFor(id, protocol, upstreamOrigin));
+    return path2.join(this.dir, relPathFor(id, protocol, upstreamOrigin));
   }
   /** A unique temp path per write (per process). Two overlapping writes for
    *  the same session must not share a temp file, or one rename invalidates
    *  the other. */
   tempPath(id) {
-    return path3.join(this.dir, `.tmp-${legacyFileNameFor(id)}-${process.pid}-${this.tmpSeq++}`);
+    return path2.join(this.dir, `.tmp-${legacyFileNameFor(id)}-${process.pid}-${this.tmpSeq++}`);
   }
   /** Bulk-load every persisted session from disk into a map keyed by the
    *  REAL session id (read from the file body, not the filename). Called once
@@ -821,7 +762,7 @@ var SessionStore = class {
       }
       for (const e of entries) {
         if (e.name.startsWith(".tmp-")) continue;
-        const full = path3.join(dir, e.name);
+        const full = path2.join(dir, e.name);
         if (e.isDirectory()) {
           await walk(full);
         } else if (e.isFile() && e.name.endsWith(".json")) {
@@ -831,13 +772,13 @@ var SessionStore = class {
     };
     await walk(this.dir);
     for (const full of files) {
-      const name = path3.basename(full);
+      const name = path2.basename(full);
       try {
         const parsed = JSON.parse(await fs.readFile(full, "utf8"));
         if (!isValidRecord(parsed)) continue;
         const proto = parsed.protocol;
         const origin = parsed.upstreamOrigin;
-        const expectedNamespaced = path3.basename(relPathFor(parsed.id, proto, origin));
+        const expectedNamespaced = path2.basename(relPathFor(parsed.id, proto, origin));
         const expectedLegacy = legacyFileNameFor(parsed.id);
         if (name !== expectedNamespaced && name !== expectedLegacy) {
           this.log("warn", `[persist] skipping ${full}: filename does not match body id (expected ${expectedNamespaced})`);
@@ -892,7 +833,7 @@ var SessionStore = class {
     const record = buildRecord(session);
     const file = this.filePath(session.id, session.protocol, session.upstreamOrigin);
     try {
-      await fs.mkdir(path3.dirname(file), { recursive: true });
+      await fs.mkdir(path2.dirname(file), { recursive: true });
     } catch (e) {
       this.log("warn", `[persist] could not create session dir ${this.dir}: ${msg(e)}`);
     }
@@ -926,14 +867,14 @@ var SessionStore = class {
     const record = buildRecord(session);
     const file = this.filePath(session.id, session.protocol, session.upstreamOrigin);
     try {
-      mkdirSync2(path3.dirname(file), { recursive: true });
+      mkdirSync(path2.dirname(file), { recursive: true });
     } catch (e) {
       this.log("warn", `[persist] could not create session dir ${this.dir}: ${msg(e)}`);
     }
     const tmp = this.tempPath(session.id);
     try {
       writeFileSync(tmp, JSON.stringify(record), "utf8");
-      renameSync2(tmp, file);
+      renameSync(tmp, file);
       return true;
     } catch (e) {
       this.log("error", `[persist] flushSync FAILED for ${session.id}: ${msg(e)} \u2014 session NOT evicted to prevent loss`);
@@ -1031,12 +972,12 @@ function persistEnabled() {
   return true;
 }
 function defaultLogger(level, m) {
-  log(level, m);
+  console.error(`[${level}] ${m}`);
 }
 var _store = null;
 function getStore() {
   if (!_store) {
-    _store = new SessionStore({ enabled: persistEnabled(), log: defaultLogger });
+    _store = new SessionStore({ enabled: persistEnabled() });
   }
   return _store;
 }
@@ -1176,17 +1117,17 @@ var COMPRESS_TOOL = {
 };
 function parseCompressInput(input) {
   if (!input || typeof input !== "object") {
-    log("warn", `[acp-compress-input] rejected: not object (${typeof input})`);
+    console.error(`[acp-compress-input] rejected: not object (${typeof input})`);
     return [];
   }
   const obj = input;
   if (Array.isArray(obj.content)) {
     const out = obj.content.map((r) => toRange(r)).filter((r) => r !== null);
-    if (out.length === 0) log("warn", `[acp-compress-input] content array but 0 valid ranges. keys per item: ${obj.content.map((c) => Object.keys(c ?? {}).join(",")).join(" | ")}`);
+    if (out.length === 0) console.error(`[acp-compress-input] content array but 0 valid ranges. keys per item: ${obj.content.map((c) => Object.keys(c ?? {}).join(",")).join(" | ")}`);
     return out;
   }
   const single = toRange(obj);
-  if (!single) log("warn", `[acp-compress-input] no content array, single-parse failed. top keys: ${Object.keys(obj).join(",")}`);
+  if (!single) console.error(`[acp-compress-input] no content array, single-parse failed. top keys: ${Object.keys(obj).join(",")}`);
   return single ? [single] : [];
 }
 function toRange(r) {
@@ -1608,7 +1549,7 @@ import {
   collectBlockContent as collectBlockContent2,
   deactivateBlock
 } from "acp-kernel";
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { dirname as dirname2, join as join2 } from "path";
 import { tmpdir } from "os";
 function resolveDecompress(args, ctx) {
@@ -1641,7 +1582,7 @@ function resolveDecompress(args, ctx) {
   const outPath = body.length > 1e4 ? join2(tmpdir(), `acp-decompress-${safeBlockId}-${Date.now()}.txt`) : null;
   if (outPath) {
     try {
-      mkdirSync3(dirname2(outPath), { recursive: true });
+      mkdirSync2(dirname2(outPath), { recursive: true });
       writeFileSync2(outPath, body, "utf8");
       return `${header}
 Content (${body.length} chars) written to: ${outPath}
@@ -1656,6 +1597,65 @@ ${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;
+var bytesWritten = 0;
+function open(pathStr) {
+  mkdirSync3(path3.dirname(pathStr), { recursive: true });
+  let existingSize = 0;
+  try {
+    existingSize = statSync(pathStr).size;
+    if (existingSize >= MAX_BYTES) {
+      rotate(pathStr);
+      existingSize = 0;
+    }
+  } catch {
+  }
+  const s = createWriteStream(pathStr, { flags: "a" });
+  bytesWritten = existingSize;
+  return s;
+}
+function rotate(pathStr) {
+  try {
+    renameSync2(pathStr, pathStr + ".old");
+  } catch {
+  }
+}
+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 && logPath) {
+    if (bytesWritten >= MAX_BYTES) {
+      stream.end();
+      rotate(logPath);
+      stream = open(logPath);
+    }
+    stream.write(line);
+    bytesWritten += Buffer.byteLength(line);
+  }
+};
+function closeLogger() {
+  stream?.end();
+  stream = void 0;
+  bytesWritten = 0;
+}
+
 // src/compress-loop.ts
 function executeProxyTool(toolName, args, ctx) {
   if (toolName === "compress") {
@@ -2350,7 +2350,7 @@ async function* compressLoopResponsesStream(initialUpstream, ctx, requestBody, r
     const allCalls = [...fcByItemId.values()].filter((c) => c.name.length > 0);
     const proxyCalls = allCalls.filter((c) => PROXY_TOOL_NAMES.has(c.name));
     const realCalls = allCalls.filter((c) => !PROXY_TOOL_NAMES.has(c.name));
-    log("debug", `[acp-diag] round ${loopCount} allCalls=[${allCalls.map((c) => c.name).join(",")}] realCalls=[${realCalls.map((c) => c.name).join(",")}] text=${JSON.stringify(contentText.slice(0, 120))}`);
+    console.error(`[acp-diag] round ${loopCount} allCalls=[${allCalls.map((c) => c.name).join(",")}] realCalls=[${realCalls.map((c) => c.name).join(",")}] text=${JSON.stringify(contentText.slice(0, 120))}`);
     const hasOnlyProxy = proxyCalls.length > 0 && realCalls.length === 0;
     if (!hasOnlyProxy) {
       let oi = nextOutputIndex;
@@ -2393,11 +2393,11 @@ async function* compressLoopResponsesStream(initialUpstream, ctx, requestBody, r
       try {
         args = JSON.parse(fc.arguments);
       } catch (e) {
-        log("warn", `[acp-compress-args] ${fc.name} JSON.parse failed: ${String(e)}. raw arguments (len=${fc.arguments.length}): ${fc.arguments.slice(0, 300)}`);
+        console.error(`[acp-compress-args] ${fc.name} JSON.parse failed: ${String(e)}. raw arguments (len=${fc.arguments.length}): ${fc.arguments.slice(0, 300)}`);
         args = {};
       }
       if (fc.name === "compress") {
-        log("debug", `[acp-compress-args] compress args parsed: ${JSON.stringify(args).slice(0, 400)}`);
+        console.error(`[acp-compress-args] compress args parsed: ${JSON.stringify(args).slice(0, 400)}`);
       }
       const result = executeProxyTool2(fc.name, args, ctx);
       const preview = result.length > 120 ? result.slice(0, 120) + "..." : result;