billion-context 0.1.92 → 0.1.93-pr.630.451

package/dist/index.js

@@ -5632,7 +5632,7 @@ var require_util2 = __commonJS({
         callback();
       }
     };
-    function createInflate(zlibOptions) {
+    function createInflate2(zlibOptions) {
       return new InflateStream(zlibOptions);
     }
     function extractMimeType(headers) {
@@ -5764,7 +5764,7 @@ var require_util2 = __commonJS({
       readAllBytes,
       simpleRangeHeaderValue,
       buildContentRange,
-      createInflate,
+      createInflate: createInflate2,
       extractMimeType,
       getDecodeSplit,
       environmentSettingsObject,
@@ -13122,7 +13122,7 @@ var require_mock_interceptor = __commonJS({
 var require_mock_client = __commonJS({
   "node_modules/undici/lib/mock/mock-client.js"(exports, module) {
     "use strict";
-    var { promisify: promisify2 } = __require("util");
+    var { promisify } = __require("util");
     var Client = require_client();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -13170,7 +13170,7 @@ var require_mock_client = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify2(this[kOriginalClose])();
+        await promisify(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -13383,7 +13383,7 @@ var require_mock_call_history = __commonJS({
 var require_mock_pool = __commonJS({
   "node_modules/undici/lib/mock/mock-pool.js"(exports, module) {
     "use strict";
-    var { promisify: promisify2 } = __require("util");
+    var { promisify } = __require("util");
     var Pool2 = require_pool();
     var { buildMockDispatch } = require_mock_utils();
     var {
@@ -13431,7 +13431,7 @@ var require_mock_pool = __commonJS({
         this[kDispatches] = [];
       }
       async [kClose]() {
-        await promisify2(this[kOriginalClose])();
+        await promisify(this[kOriginalClose])();
         this[kConnected] = 0;
         this[kMockAgent][Symbols.kClients].delete(this[kOrigin]);
       }
@@ -17545,17 +17545,17 @@ var require_cache2 = __commonJS({
 var require_decompress = __commonJS({
   "node_modules/undici/lib/interceptor/decompress.js"(exports, module) {
     "use strict";
-    var { createInflate, createGunzip, createBrotliDecompress, createZstdDecompress } = __require("zlib");
+    var { createInflate: createInflate2, createGunzip: createGunzip2, createBrotliDecompress: createBrotliDecompress2, createZstdDecompress } = __require("zlib");
     var { pipeline } = __require("stream");
     var DecoratorHandler = require_decorator_handler();
     var { runtimeFeatures } = require_runtime_features();
     var supportedEncodings = {
-      gzip: createGunzip,
-      "x-gzip": createGunzip,
-      br: createBrotliDecompress,
-      deflate: createInflate,
-      compress: createInflate,
-      "x-compress": createInflate,
+      gzip: createGunzip2,
+      "x-gzip": createGunzip2,
+      br: createBrotliDecompress2,
+      deflate: createInflate2,
+      compress: createInflate2,
+      "x-compress": createInflate2,
       ...runtimeFeatures.has("zstd") ? { zstd: createZstdDecompress } : {}
     };
     var defaultSkipStatusCodes = (
@@ -20384,7 +20384,7 @@ var require_fetch = __commonJS({
       clampAndCoarsenConnectionTimingInfo,
       simpleRangeHeaderValue,
       buildContentRange,
-      createInflate,
+      createInflate: createInflate2,
       extractMimeType,
       hasAuthenticationEntry,
       includesCredentials,
@@ -21366,7 +21366,7 @@ var require_fetch = __commonJS({
                       finishFlush: zlib.constants.Z_SYNC_FLUSH
                     }));
                   } else if (coding === "deflate") {
-                    decoders.push(createInflate({
+                    decoders.push(createInflate2({
                       flush: zlib.constants.Z_SYNC_FLUSH,
                       finishFlush: zlib.constants.Z_SYNC_FLUSH
                     }));
@@ -23432,7 +23432,7 @@ var require_connection = __commonJS({
 var require_permessage_deflate = __commonJS({
   "node_modules/undici/lib/web/websocket/permessage-deflate.js"(exports, module) {
     "use strict";
-    var { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __require("zlib");
+    var { createInflateRaw: createInflateRaw2, Z_DEFAULT_WINDOWBITS } = __require("zlib");
     var { isValidClientWindowBits } = require_util5();
     var { MessageSizeExceededError } = require_errors();
     var tail = Buffer.from([0, 0, 255, 255]);
@@ -23468,7 +23468,7 @@ var require_permessage_deflate = __commonJS({
             windowBits = Number.parseInt(this.#options.serverMaxWindowBits);
           }
           try {
-            this.#inflate = createInflateRaw({ windowBits });
+            this.#inflate = createInflateRaw2({ windowBits });
           } catch (err2) {
             callback(err2);
             return;
@@ -38339,7 +38339,7 @@ var require_tls = __commonJS({
       }
       return rval;
     };
-    var inflate2 = function(c, record, s3) {
+    var inflate = function(c, record, s3) {
       var rval = false;
       try {
         var bytes = c.inflate(record.fragment.getBytes());
@@ -39484,7 +39484,7 @@ var require_tls = __commonJS({
           case tls4.CompressionMethod.none:
             break;
           case tls4.CompressionMethod.deflate:
-            state.read.compressFunction = inflate2;
+            state.read.compressFunction = inflate;
             state.write.compressFunction = deflate;
             break;
           default:
@@ -50329,6 +50329,7 @@ function buildAlertMessage(dir, count) {
 // src/persist.ts
 var PERSIST_VERSION = 3;
 var MIGRATION_MARKER = ".bili-migration-286.done";
+var STALE_WARN_THROTTLE_MS = 6e4;
 function mergeState(parsed) {
   const fresh = createInitialState();
   return {
@@ -50362,11 +50363,14 @@ var SessionStore = class {
   enabled;
   dir;
   store;
+  log;
+  staleWarnAt = /* @__PURE__ */ new Map();
   constructor(opts) {
     const debounceMs = opts?.debounceMs ?? defaultDebounce();
     this.enabled = (opts?.enabled ?? true) && debounceMs >= 0;
     this.dir = opts?.dir ?? defaultDir();
     const baseLog = opts?.log ?? defaultLogger;
+    this.log = baseLog;
     const epermAlert = new PersistEpermAlert({
       dir: this.dir,
       threshold: epermAlertThreshold(),
@@ -50516,40 +50520,83 @@ var SessionStore = class {
       });
     }
   }
+  /** Shared envelope probe for the sync read paths: namespaced path
+   *  first, then the _unknown/ location, letting the kernel store layer
+   *  also check its discovered map and the flat legacy name. */
+  loadEnvelope(id, meta) {
+    const envelopes = [
+      this.store.loadSync(id, relPathFor(id, meta?.protocol, meta?.upstreamOrigin)),
+      meta?.protocol ? this.store.loadSync(id, relPathFor(id)) : null
+    ];
+    for (const envelope of envelopes) {
+      if (envelope) return envelope;
+    }
+    return null;
+  }
   /** 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
    *  body id does not match what we asked for. */
   loadSync(id, meta) {
     if (!this.enabled) return null;
-    const envelopes = [
-      this.store.loadSync(id, relPathFor(id, meta?.protocol, meta?.upstreamOrigin)),
-      meta?.protocol ? this.store.loadSync(id, relPathFor(id)) : null
-    ];
-    for (const envelope of envelopes) {
-      if (envelope) {
-        const session = buildSession(envelope.payload);
-        if (hasNegativePersistedTokens(envelope.payload)) {
-          this.scheduleSave(session);
-          log("info", `[persist] clamped negative token stats on reload for ${id} (#408)`);
-        }
-        return session;
-      }
+    const envelope = this.loadEnvelope(id, meta);
+    if (!envelope) return null;
+    const session = buildSession(envelope.payload);
+    if (hasNegativePersistedTokens(envelope.payload)) {
+      this.scheduleSave(session);
+      log("info", `[persist] clamped negative token stats on reload for ${id} (#408)`);
+    }
+    return session;
+  }
+  /** #405 fix #4: dual-instance rollback guard. When two proxy processes
+   *  share BILI_SESSIONS_DIR, whoever saves last used to win — an instance
+   *  holding a STALE in-memory copy would roll counters back (requests:3 →
+   *  2). Both signals below are monotonic per session id, so either being
+   *  strictly smaller proves staleness. Returns the fresher-on-disk payload
+   *  when the incoming record is stale, else null. */
+  staleDiskPayload(incoming) {
+    const envelope = this.loadEnvelope(incoming.id, incoming.meta);
+    if (!envelope) return null;
+    const disk = envelope.payload;
+    const diskRequests = disk.stats?.requests ?? disk.requests ?? 0;
+    const incRequests = incoming.stats?.requests ?? incoming.requests ?? 0;
+    if (incRequests < diskRequests) return disk;
+    if (incRequests === diskRequests) {
+      const diskBlocks = disk.state?.nextBlockId ?? 0;
+      const incBlocks = incoming.state?.nextBlockId ?? 0;
+      if (incBlocks < diskBlocks) return disk;
     }
     return null;
   }
+  guardedBuild(session) {
+    return () => {
+      const record = buildRecord(session);
+      const disk = this.staleDiskPayload(record);
+      if (disk === null) return record;
+      const now = Date.now();
+      const last = this.staleWarnAt.get(record.id) ?? 0;
+      if (now - last >= STALE_WARN_THROTTLE_MS) {
+        this.staleWarnAt.set(record.id, now);
+        this.log(
+          "warn",
+          `[persist] rejected stale snapshot for session ${record.id}: in-memory copy is older than the on-disk one (another bili instance holds newer state) \u2014 keeping disk state, no rollback (#405)`
+        );
+      }
+      return disk;
+    };
+  }
   /** Schedule a debounced write for a session. Multiple calls within the
    *  window coalesce; the record is built at WRITE time, so the freshest
    *  session state is persisted. Safe to call on the hot path. No-op if
    *  disabled. */
   scheduleSave(session) {
-    this.store.scheduleSave(session.id, () => buildRecord(session));
+    this.store.scheduleSave(session.id, this.guardedBuild(session));
   }
   /** Asynchronously persist a session right now (skips the debounce). Throws
    *  on write failure so callers can react (e.g. avoid evicting). Serialized
    *  per-session by the kernel store's write chains. */
   async writeNow(session) {
-    await this.store.writeNow(session.id, () => buildRecord(session));
+    await this.store.writeNow(session.id, this.guardedBuild(session));
   }
   /** Synchronous flush for a single session. Used on memory eviction so a
    *  dirty evicted session is not lost. Sync because eviction runs in the
@@ -50557,7 +50604,7 @@ var SessionStore = class {
    *  Returns true on success, false on failure (caller must NOT evict on
    *  failure for a never-persisted session or it is lost permanently). */
   flushSync(session) {
-    return this.store.flushSync(session.id, () => buildRecord(session));
+    return this.store.flushSync(session.id, this.guardedBuild(session));
   }
   /** Flush all dirty sessions with a pending debounce timer. Called on
    *  SIGTERM/SIGINT for graceful shutdown. The kernel store flushes its own
@@ -57416,8 +57463,7 @@ function tunnelAllowlistFromEnv(env = process.env) {
 }
 
 // src/content-encoding.ts
-import { promisify } from "util";
-import { brotliDecompress, gunzip, inflate, inflateRaw } from "zlib";
+import { createBrotliDecompress, createGunzip, createInflate, createInflateRaw } from "zlib";
 
 // node_modules/fzstd/esm/index.mjs
 var ab = ArrayBuffer;
@@ -58090,31 +58136,54 @@ var Decompress = /* @__PURE__ */ (function() {
 })();
 
 // src/content-encoding.ts
-var gunzipAsync = promisify(gunzip);
-var inflateAsync = promisify(inflate);
-var inflateRawAsync = promisify(inflateRaw);
-var brotliAsync = promisify(brotliDecompress);
-async function decodeZstd(input, maxOutputBytes) {
+var DecompressedTooLargeError = class extends Error {
+  constructor(limit) {
+    super(`decompressed request exceeds ${limit} bytes`);
+    this.limit = limit;
+    this.name = "DecompressedTooLargeError";
+  }
+  limit;
+};
+function streamDecode(factory, input, max) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    const decoder = factory();
+    decoder.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > max) {
+        decoder.destroy();
+        reject(new DecompressedTooLargeError(max));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    decoder.on("end", () => resolve(Buffer.concat(chunks, size)));
+    decoder.on("error", (err2) => reject(err2));
+    decoder.end(input);
+  });
+}
+async function decodeZstd(input, max) {
   const chunks = [];
   let size = 0;
   const decoder = new Decompress((chunk) => {
     size += chunk.byteLength;
-    if (size > maxOutputBytes) throw new Error(`decompressed request exceeds ${maxOutputBytes} bytes`);
+    if (size > max) throw new DecompressedTooLargeError(max);
     chunks.push(Buffer.from(chunk));
   });
   decoder.push(input, true);
   return Buffer.concat(chunks, size);
 }
-async function decodeOne(coding, input, maxOutputBytes) {
-  const options = { maxOutputLength: maxOutputBytes };
-  if (coding === "gzip" || coding === "x-gzip") return gunzipAsync(input, options);
-  if (coding === "br") return brotliAsync(input, options);
-  if (coding === "zstd") return decodeZstd(input, maxOutputBytes);
+async function decodeOne(coding, input, max) {
+  if (coding === "gzip" || coding === "x-gzip") return streamDecode(createGunzip, input, max);
+  if (coding === "br") return streamDecode(createBrotliDecompress, input, max);
+  if (coding === "zstd") return decodeZstd(input, max);
   if (coding === "deflate") {
     try {
-      return await inflateAsync(input, options);
-    } catch {
-      return inflateRawAsync(input, options);
+      return await streamDecode(createInflate, input, max);
+    } catch (err2) {
+      if (err2 instanceof DecompressedTooLargeError) throw err2;
+      return streamDecode(createInflateRaw, input, max);
     }
   }
   throw new Error(`unsupported request content-encoding: ${coding}`);
@@ -58125,9 +58194,7 @@ async function decodeRequestBody(contentEncoding, input, maxOutputBytes) {
   let body = input;
   for (const coding of codings.reverse()) {
     body = await decodeOne(coding, body, maxOutputBytes);
-    if (body.byteLength > maxOutputBytes) {
-      throw new Error(`decompressed request exceeds ${maxOutputBytes} bytes`);
-    }
+    if (body.byteLength > maxOutputBytes) throw new DecompressedTooLargeError(maxOutputBytes);
   }
   return { body, decoded: true };
 }
@@ -58707,18 +58774,24 @@ async function handle(req, res, opts, core, config, log2, instanceId, instanceSt
     upstreamOrigin = route ? route.upstream : /^https?:\/\//i.test(url) ? new URL(url).origin : opts.upstream;
     protocol = route?.explicitProtocol ?? (req.method === "POST" && bodyBuffer.length > 0 ? urlPath.endsWith("/chat/completions") ? "openai" : urlPath.endsWith("/v1/messages") || urlPath.endsWith("/messages") ? "anthropic" : urlPath.endsWith("/responses") || responsesCompact ? "responses" : null : null);
     if (protocol !== null && bodyBuffer.length > 0) {
-      const decoded = await decodeRequestBody(headerValue2(req, "content-encoding"), bodyBuffer, MAX_REQUEST_BYTES);
-      bodyBuffer = decoded.body;
-      if (decoded.decoded) delete req.headers["content-encoding"];
+      try {
+        const decoded = await decodeRequestBody(headerValue2(req, "content-encoding"), bodyBuffer, MAX_REQUEST_BYTES);
+        bodyBuffer = decoded.body;
+        if (decoded.decoded) delete req.headers["content-encoding"];
+      } catch (decErr) {
+        if (decErr instanceof DecompressedTooLargeError) throw decErr;
+        protocol = null;
+        log2("warn", `decode body failed (${String(decErr)}) - forwarding raw body verbatim to ${upstreamOrigin}`);
+      }
     }
   } catch (err2) {
-    if (err2 instanceof BodyTooLargeError) {
+    if (err2 instanceof BodyTooLargeError || err2 instanceof DecompressedTooLargeError) {
       log2("warn", `413: request body exceeds ${err2.limit} bytes`);
       res.writeHead(413, { "content-type": "application/json" });
       res.end(JSON.stringify({ error: { type: "request_too_large", message: err2.message } }));
       return;
     }
-    log2("warn", `read/decode body failed: ${String(err2)}`);
+    log2("warn", `failed to prepare inbound request (${String(err2)}) - 400`);
     res.writeHead(400, { "content-type": "application/json" });
     res.end(JSON.stringify({ error: { type: "invalid_request", message: String(err2) } }));
     return;