@musistudio/claude-code-router 1.0.3 → 1.0.5

package/dist/cli.js

@@ -335,10 +335,10 @@ var require_browser = __commonJS({
     exports2.useColors = useColors;
     exports2.storage = localstorage();
     exports2.destroy = /* @__PURE__ */ (() => {
-      let warned = false;
+      let warned2 = false;
       return () => {
-        if (!warned) {
-          warned = true;
+        if (!warned2) {
+          warned2 = true;
           console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
         }
       };
@@ -2938,10 +2938,10 @@ var require_lib2 = __commonJS({
     var zlib = _interopDefault(require("zlib"));
     var Readable2 = Stream2.Readable;
     var BUFFER = Symbol("buffer");
-    var TYPE = Symbol("type");
+    var TYPE2 = Symbol("type");
     var Blob3 = class _Blob {
       constructor() {
-        this[TYPE] = "";
+        this[TYPE2] = "";
         const blobParts = arguments[0];
         const options = arguments[1];
         const buffers = [];
@@ -2970,14 +2970,14 @@ var require_lib2 = __commonJS({
         this[BUFFER] = Buffer.concat(buffers);
         let type = options && options.type !== void 0 && String(options.type).toLowerCase();
         if (type && !/[^\u0020-\u007E]/.test(type)) {
-          this[TYPE] = type;
+          this[TYPE2] = type;
         }
       }
       get size() {
         return this[BUFFER].length;
       }
       get type() {
-        return this[TYPE];
+        return this[TYPE2];
       }
       text() {
         return Promise.resolve(this[BUFFER].toString());
@@ -9181,12 +9181,12 @@ var require_utf16 = __commonJS({
       return this.decoder.end();
     };
     function detectEncoding(buf, defaultEncoding) {
-      var enc = defaultEncoding || "utf-16le";
+      var enc2 = defaultEncoding || "utf-16le";
       if (buf.length >= 2) {
         if (buf[0] == 254 && buf[1] == 255)
-          enc = "utf-16be";
+          enc2 = "utf-16be";
         else if (buf[0] == 255 && buf[1] == 254)
-          enc = "utf-16le";
+          enc2 = "utf-16le";
         else {
           var asciiCharsLE = 0, asciiCharsBE = 0, _len = Math.min(buf.length - buf.length % 2, 64);
           for (var i2 = 0; i2 < _len; i2 += 2) {
@@ -9194,12 +9194,12 @@ var require_utf16 = __commonJS({
             if (buf[i2] !== 0 && buf[i2 + 1] === 0) asciiCharsLE++;
           }
           if (asciiCharsBE > asciiCharsLE)
-            enc = "utf-16be";
+            enc2 = "utf-16be";
           else if (asciiCharsBE < asciiCharsLE)
-            enc = "utf-16le";
+            enc2 = "utf-16le";
         }
       }
-      return enc;
+      return enc2;
     }
   }
 });
@@ -11884,12 +11884,12 @@ var require_encodings = __commonJS({
     ];
     for (i2 = 0; i2 < modules.length; i2++) {
       module2 = modules[i2];
-      for (enc in module2)
-        if (Object.prototype.hasOwnProperty.call(module2, enc))
-          exports2[enc] = module2[enc];
+      for (enc2 in module2)
+        if (Object.prototype.hasOwnProperty.call(module2, enc2))
+          exports2[enc2] = module2[enc2];
     }
     var module2;
-    var enc;
+    var enc2;
     var i2;
   }
 });
@@ -12023,8 +12023,8 @@ var require_extend_node = __commonJS({
           "utf16le": true,
           "utf-16le": true
         };
-        Buffer2.isNativeEncoding = function(enc) {
-          return enc && nodeNativeEncodings[enc.toLowerCase()];
+        Buffer2.isNativeEncoding = function(enc2) {
+          return enc2 && nodeNativeEncodings[enc2.toLowerCase()];
         };
         var SlowBuffer = require("buffer").SlowBuffer;
         original.SlowBufferToString = SlowBuffer.prototype.toString;
@@ -12126,9 +12126,9 @@ var require_extend_node = __commonJS({
         if (iconv.supportsStreams) {
           var Readable2 = require("stream").Readable;
           original.ReadableSetEncoding = Readable2.prototype.setEncoding;
-          Readable2.prototype.setEncoding = function setEncoding(enc, options) {
-            this._readableState.decoder = iconv.getDecoder(enc, options);
-            this._readableState.encoding = enc;
+          Readable2.prototype.setEncoding = function setEncoding(enc2, options) {
+            this._readableState.decoder = iconv.getDecoder(enc2, options);
+            this._readableState.encoding = enc2;
           };
           Readable2.prototype.collect = iconv._collect;
         }
@@ -12187,9 +12187,9 @@ var require_lib3 = __commonJS({
       var trail = decoder.end();
       return trail ? res + trail : res;
     };
-    iconv.encodingExists = function encodingExists(enc) {
+    iconv.encodingExists = function encodingExists(enc2) {
       try {
-        iconv.getCodec(enc);
+        iconv.getCodec(enc2);
         return true;
       } catch (e2) {
         return false;
@@ -12201,32 +12201,32 @@ var require_lib3 = __commonJS({
     iconv.getCodec = function getCodec(encoding) {
       if (!iconv.encodings)
         iconv.encodings = require_encodings();
-      var enc = iconv._canonicalizeEncoding(encoding);
+      var enc2 = iconv._canonicalizeEncoding(encoding);
       var codecOptions = {};
       while (true) {
-        var codec = iconv._codecDataCache[enc];
+        var codec = iconv._codecDataCache[enc2];
         if (codec)
           return codec;
-        var codecDef = iconv.encodings[enc];
+        var codecDef = iconv.encodings[enc2];
         switch (typeof codecDef) {
           case "string":
-            enc = codecDef;
+            enc2 = codecDef;
             break;
           case "object":
             for (var key in codecDef)
               codecOptions[key] = codecDef[key];
             if (!codecOptions.encodingName)
-              codecOptions.encodingName = enc;
-            enc = codecDef.type;
+              codecOptions.encodingName = enc2;
+            enc2 = codecDef.type;
             break;
           case "function":
             if (!codecOptions.encodingName)
-              codecOptions.encodingName = enc;
+              codecOptions.encodingName = enc2;
             codec = new codecDef(codecOptions, iconv);
             iconv._codecDataCache[codecOptions.encodingName] = codec;
             return codec;
           default:
-            throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
+            throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc2 + "')");
         }
       }
     };
@@ -25261,17 +25261,17 @@ var require_router = __commonJS({
     var toString = Object.prototype.toString;
     var proto = module2.exports = function(options) {
       var opts = options || {};
-      function router(req, res, next) {
-        router.handle(req, res, next);
-      }
-      setPrototypeOf(router, proto);
-      router.params = {};
-      router._params = [];
-      router.caseSensitive = opts.caseSensitive;
-      router.mergeParams = opts.mergeParams;
-      router.strict = opts.strict;
-      router.stack = [];
-      return router;
+      function router2(req, res, next) {
+        router2.handle(req, res, next);
+      }
+      setPrototypeOf(router2, proto);
+      router2.params = {};
+      router2._params = [];
+      router2.caseSensitive = opts.caseSensitive;
+      router2.mergeParams = opts.mergeParams;
+      router2.strict = opts.strict;
+      router2.stack = [];
+      return router2;
     };
     proto.param = function param(name, fn) {
       if (typeof name === "function") {
@@ -27951,17 +27951,17 @@ var require_application = __commonJS({
       }
     };
     app.handle = function handle(req, res, callback) {
-      var router = this._router;
+      var router2 = this._router;
       var done = callback || finalhandler(req, res, {
         env: this.get("env"),
         onerror: logerror.bind(this)
       });
-      if (!router) {
+      if (!router2) {
         debug2("no routes defined on app");
         done();
         return;
       }
-      router.handle(req, res, done);
+      router2.handle(req, res, done);
     };
     app.use = function use(fn) {
       var offset = 0;
@@ -27981,15 +27981,15 @@ var require_application = __commonJS({
         throw new TypeError("app.use() requires a middleware function");
       }
       this.lazyrouter();
-      var router = this._router;
+      var router2 = this._router;
       fns.forEach(function(fn2) {
         if (!fn2 || !fn2.handle || !fn2.set) {
-          return router.use(path4, fn2);
+          return router2.use(path4, fn2);
         }
         debug2(".use app under %s", path4);
         fn2.mountpath = path4;
         fn2.parent = this;
-        router.use(path4, function mounted_app(req, res, next) {
+        router2.use(path4, function mounted_app(req, res, next) {
           var orig = req.app;
           fn2.handle(req, res, function(err) {
             setPrototypeOf(req, orig.request);
@@ -28975,14 +28975,14 @@ var require_cookie = __commonJS({
       return min;
     }
     function serialize(name, val, opt) {
-      var enc = opt && opt.encode || encodeURIComponent;
-      if (typeof enc !== "function") {
+      var enc2 = opt && opt.encode || encodeURIComponent;
+      if (typeof enc2 !== "function") {
         throw new TypeError("option encode is invalid");
       }
       if (!cookieNameRegExp.test(name)) {
         throw new TypeError("argument name is invalid");
       }
-      var value = enc(val);
+      var value = enc2(val);
       if (!cookieValueRegExp.test(value)) {
         throw new TypeError("argument val is invalid");
       }
@@ -29873,6 +29873,436 @@ var require_express2 = __commonJS({
   }
 });
 
+// node_modules/tiktoken/tiktoken_bg.cjs
+var require_tiktoken_bg = __commonJS({
+  "node_modules/tiktoken/tiktoken_bg.cjs"(exports2, module2) {
+    var wasm;
+    module2.exports.__wbg_set_wasm = function(val) {
+      wasm = val;
+    };
+    var lTextDecoder = typeof TextDecoder === "undefined" ? (0, module2.require)("util").TextDecoder : TextDecoder;
+    var cachedTextDecoder = new lTextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    var cachedUint8ArrayMemory0 = null;
+    function getUint8ArrayMemory0() {
+      if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+      }
+      return cachedUint8ArrayMemory0;
+    }
+    function getStringFromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+    }
+    var heap = new Array(128).fill(void 0);
+    heap.push(void 0, null, true, false);
+    var heap_next = heap.length;
+    function addHeapObject(obj) {
+      if (heap_next === heap.length) heap.push(heap.length + 1);
+      const idx = heap_next;
+      heap_next = heap[idx];
+      heap[idx] = obj;
+      return idx;
+    }
+    function handleError(f2, args) {
+      try {
+        return f2.apply(this, args);
+      } catch (e2) {
+        wasm.__wbindgen_export_0(addHeapObject(e2));
+      }
+    }
+    function getObject(idx) {
+      return heap[idx];
+    }
+    function dropObject(idx) {
+      if (idx < 132) return;
+      heap[idx] = heap_next;
+      heap_next = idx;
+    }
+    function takeObject(idx) {
+      const ret = getObject(idx);
+      dropObject(idx);
+      return ret;
+    }
+    var WASM_VECTOR_LEN = 0;
+    var lTextEncoder = typeof TextEncoder === "undefined" ? (0, module2.require)("util").TextEncoder : TextEncoder;
+    var cachedTextEncoder = new lTextEncoder("utf-8");
+    var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
+      return cachedTextEncoder.encodeInto(arg, view);
+    } : function(arg, view) {
+      const buf = cachedTextEncoder.encode(arg);
+      view.set(buf);
+      return {
+        read: arg.length,
+        written: buf.length
+      };
+    };
+    function passStringToWasm0(arg, malloc, realloc) {
+      if (realloc === void 0) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr2 = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr2;
+      }
+      let len = arg.length;
+      let ptr = malloc(len, 1) >>> 0;
+      const mem = getUint8ArrayMemory0();
+      let offset = 0;
+      for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 127) break;
+        mem[ptr + offset] = code;
+      }
+      if (offset !== len) {
+        if (offset !== 0) {
+          arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+      }
+      WASM_VECTOR_LEN = offset;
+      return ptr;
+    }
+    function isLikeNone(x2) {
+      return x2 === void 0 || x2 === null;
+    }
+    var cachedDataViewMemory0 = null;
+    function getDataViewMemory0() {
+      if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+      }
+      return cachedDataViewMemory0;
+    }
+    var cachedUint32ArrayMemory0 = null;
+    function getUint32ArrayMemory0() {
+      if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+      }
+      return cachedUint32ArrayMemory0;
+    }
+    function getArrayU32FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+    }
+    function passArray8ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 1, 1) >>> 0;
+      getUint8ArrayMemory0().set(arg, ptr / 1);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    function passArray32ToWasm0(arg, malloc) {
+      const ptr = malloc(arg.length * 4, 4) >>> 0;
+      getUint32ArrayMemory0().set(arg, ptr / 4);
+      WASM_VECTOR_LEN = arg.length;
+      return ptr;
+    }
+    function getArrayU8FromWasm0(ptr, len) {
+      ptr = ptr >>> 0;
+      return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+    }
+    module2.exports.get_encoding = function(encoding, extend_special_tokens) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(encoding, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.get_encoding(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    module2.exports.encoding_for_model = function(model, extend_special_tokens) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(model, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.encoding_for_model(retptr, ptr0, len0, addHeapObject(extend_special_tokens));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+          throw takeObject(r1);
+        }
+        return Tiktoken.__wrap(r0);
+      } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+      }
+    };
+    var TiktokenFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+    }, unregister: () => {
+    } } : new FinalizationRegistry((ptr) => wasm.__wbg_tiktoken_free(ptr >>> 0, 1));
+    var Tiktoken = class _Tiktoken {
+      /**
+       * @param {string} tiktoken_bfe
+       * @param {any} special_tokens
+       * @param {string} pat_str
+       */
+      constructor(tiktoken_bfe, special_tokens, pat_str) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passStringToWasm0(tiktoken_bfe, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(pat_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.tiktoken_new(ptr0, len0, addHeapObject(special_tokens), ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        TiktokenFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+      }
+      /** @returns {string | undefined} */
+      get name() {
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.tiktoken_name(retptr, this.__wbg_ptr);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          let v1;
+          if (r0 !== 0) {
+            v1 = getStringFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+          }
+          return v1;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(_Tiktoken.prototype);
+        obj.__wbg_ptr = ptr;
+        TiktokenFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+      }
+      __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TiktokenFinalization.unregister(this);
+        return ptr;
+      }
+      free() {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tiktoken_free(ptr, 0);
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {Uint32Array}
+       */
+      encode(text, allowed_special, disallowed_special) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_encode(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+          if (r3) {
+            throw takeObject(r2);
+          }
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @returns {Uint32Array}
+       */
+      encode_ordinary(text) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_encode_ordinary(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU32FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 4, 4);
+          return v2;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {string} text
+       * @param {any} allowed_special
+       * @param {any} disallowed_special
+       * @returns {any}
+       */
+      encode_with_unstable(text, allowed_special, disallowed_special) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_encode_with_unstable(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(allowed_special), addHeapObject(disallowed_special));
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+          if (r2) {
+            throw takeObject(r1);
+          }
+          return takeObject(r0);
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {Uint8Array} bytes
+       * @returns {number}
+       */
+      encode_single_token(bytes) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tiktoken_encode_single_token(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+      }
+      /**
+       * @param {Uint32Array} tokens
+       * @returns {Uint8Array}
+       */
+      decode(tokens) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          const ptr0 = passArray32ToWasm0(tokens, wasm.__wbindgen_export_1);
+          const len0 = WASM_VECTOR_LEN;
+          wasm.tiktoken_decode(retptr, this.__wbg_ptr, ptr0, len0);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v2 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v2;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /**
+       * @param {number} token
+       * @returns {Uint8Array}
+       */
+      decode_single_token_bytes(token) {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        try {
+          const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+          wasm.tiktoken_decode_single_token_bytes(retptr, this.__wbg_ptr, token);
+          var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+          var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+          var v1 = getArrayU8FromWasm0(r0, r1).slice();
+          wasm.__wbindgen_export_3(r0, r1 * 1, 1);
+          return v1;
+        } finally {
+          wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+      }
+      /** @returns {any} */
+      token_byte_values() {
+        if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+        const ret = wasm.tiktoken_token_byte_values(this.__wbg_ptr);
+        return takeObject(ret);
+      }
+    };
+    module2.exports.Tiktoken = Tiktoken;
+    module2.exports.__wbg_parse_def2e24ef1252aff = function() {
+      return handleError(function(arg0, arg1) {
+        const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module2.exports.__wbg_stringify_f7ed6987935b4a24 = function() {
+      return handleError(function(arg0) {
+        const ret = JSON.stringify(getObject(arg0));
+        return addHeapObject(ret);
+      }, arguments);
+    };
+    module2.exports.__wbindgen_error_new = function(arg0, arg1) {
+      const ret = new Error(getStringFromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    };
+    module2.exports.__wbindgen_is_undefined = function(arg0) {
+      const ret = getObject(arg0) === void 0;
+      return ret;
+    };
+    module2.exports.__wbindgen_object_drop_ref = function(arg0) {
+      takeObject(arg0);
+    };
+    module2.exports.__wbindgen_string_get = function(arg0, arg1) {
+      if (wasm == null) throw new Error("tiktoken: WASM binary has not been propery initialized.");
+      const obj = getObject(arg1);
+      const ret = typeof obj === "string" ? obj : void 0;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    module2.exports.__wbindgen_throw = function(arg0, arg1) {
+      throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+  }
+});
+
+// node_modules/tiktoken/tiktoken.cjs
+var require_tiktoken = __commonJS({
+  "node_modules/tiktoken/tiktoken.cjs"(exports2) {
+    var wasm = require_tiktoken_bg();
+    var imports = {};
+    imports["./tiktoken_bg.js"] = wasm;
+    var path4 = require("path");
+    var fs4 = require("fs");
+    var candidates = __dirname.split(path4.sep).reduce((memo, _2, index, array) => {
+      const prefix = array.slice(0, index + 1).join(path4.sep) + path4.sep;
+      if (!prefix.includes("node_modules" + path4.sep)) {
+        memo.unshift(
+          path4.join(
+            prefix,
+            "node_modules",
+            "tiktoken",
+            "",
+            "./tiktoken_bg.wasm"
+          )
+        );
+      }
+      return memo;
+    }, []);
+    candidates.unshift(path4.join(__dirname, "./tiktoken_bg.wasm"));
+    var bytes = null;
+    for (const candidate of candidates) {
+      try {
+        bytes = fs4.readFileSync(candidate);
+        break;
+      } catch {
+      }
+    }
+    if (bytes == null) throw new Error("Missing tiktoken_bg.wasm");
+    var wasmModule = new WebAssembly.Module(bytes);
+    var wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+    wasm.__wbg_set_wasm(wasmInstance.exports);
+    exports2["get_encoding"] = wasm["get_encoding"];
+    exports2["encoding_for_model"] = wasm["encoding_for_model"];
+    exports2["Tiktoken"] = wasm["Tiktoken"];
+  }
+});
+
 // src/index.ts
 var import_fs3 = require("fs");
 var import_promises3 = require("fs/promises");
@@ -36487,6 +36917,7 @@ var HOME_DIR = import_node_path.default.join(import_node_os.default.homedir(), "
 var CONFIG_FILE = `${HOME_DIR}/config.json`;
 var PLUGINS_DIR = `${HOME_DIR}/plugins`;
 var PID_FILE = import_node_path.default.join(HOME_DIR, ".claude-code-router.pid");
+var REFERENCE_COUNT_FILE = "/tmp/claude-code-reference-count.txt";
 var DEFAULT_CONFIG = {
   log: false,
   OPENAI_API_KEY: "",
@@ -36499,6 +36930,8 @@ function getOpenAICommonOptions() {
   const options = {};
   if (process.env.PROXY_URL) {
     options.httpAgent = new import_https_proxy_agent.HttpsProxyAgent(process.env.PROXY_URL);
+  } else if (process.env.HTTPS_PROXY) {
+    options.httpAgent = new import_https_proxy_agent.HttpsProxyAgent(process.env.HTTPS_PROXY);
   }
   return options;
 }
@@ -36552,6 +36985,7 @@ var writeConfigFile = async (config) => {
 var initConfig = async () => {
   const config = await readConfigFile();
   Object.assign(process.env, config);
+  return config;
 };
 var createClient = (options) => {
   const client = new openai_default({
@@ -36563,7 +36997,7 @@ var createClient = (options) => {
 
 // src/server.ts
 var import_express = __toESM(require_express2());
-var createServer = (port) => {
+var createServer = async (port) => {
   const app = (0, import_express.default)();
   app.use(import_express.default.json({ limit: "500mb" }));
   return {
@@ -36971,6 +37405,7 @@ var formatRequest = async (req, res, next) => {
     res.setHeader("Cache-Control", "no-cache");
     res.setHeader("Connection", "keep-alive");
     req.body = data;
+    console.log(JSON.stringify(data.messages, null, 2));
   } catch (error) {
     console.error("Error in request processing:", error);
     const errorCompletion = {
@@ -36978,7 +37413,7 @@ var formatRequest = async (req, res, next) => {
         yield {
           id: `error_${Date.now()}`,
           created: Math.floor(Date.now() / 1e3),
-          model: "gpt-3.5-turbo",
+          model,
           object: "chat.completion.chunk",
           choices: [
             {
@@ -37014,23 +37449,123 @@ import_node_module.default._load = function(request, parent, isMain) {
   return originalLoad.call(this, request, parent, isMain);
 };
 var rewriteBody = async (req, res, next) => {
-  if (!process.env.usePlugin) {
+  if (!req.config.usePlugins) {
     return next();
   }
-  const pluginPath = import_node_path3.default.join(PLUGINS_DIR, `${process.env.usePlugin}.js`);
+  for (const plugin of req.config.usePlugins) {
+    const pluginPath = import_node_path3.default.join(PLUGINS_DIR, `${plugin.trim()}.js`);
+    try {
+      await (0, import_promises2.access)(pluginPath);
+      const rewritePlugin = require(pluginPath);
+      await rewritePlugin(req, res);
+    } catch (e2) {
+      console.error(e2);
+    }
+  }
+  next();
+};
+
+// src/middlewares/router.ts
+var import_tiktoken = __toESM(require_tiktoken());
+var enc = (0, import_tiktoken.get_encoding)("cl100k_base");
+var getUseModel = (req, tokenCount) => {
+  if (tokenCount > 1e3 * 32) {
+    log("Using long context model due to token count:", tokenCount);
+    const [provider2, model2] = req.config.Router.longContext.split(",");
+    return {
+      provider: provider2,
+      model: model2
+    };
+  }
+  if (req.body.model?.startsWith("claude-3-5-haiku")) {
+    log("Using background model for ", req.body.model);
+    const [provider2, model2] = req.config.Router.background.split(",");
+    return {
+      provider: provider2,
+      model: model2
+    };
+  }
+  if (req.body.thinking) {
+    log("Using think model for ", req.body.thinking);
+    const [provider2, model2] = req.config.Router.think.split(",");
+    return {
+      provider: provider2,
+      model: model2
+    };
+  }
+  const [provider, model] = req.body.model.split(",");
+  if (provider && model) {
+    return {
+      provider,
+      model
+    };
+  }
+  return {
+    provider: "default",
+    model: req.config.OPENAI_MODEL
+  };
+};
+var router = async (req, res, next) => {
+  const { messages, system = [], tools } = req.body;
   try {
-    await (0, import_promises2.access)(pluginPath);
-    const rewritePlugin = require(pluginPath);
-    rewritePlugin(req, res, next);
-  } catch (e2) {
-    console.error(e2);
+    let tokenCount = 0;
+    if (Array.isArray(messages)) {
+      messages.forEach((message) => {
+        if (typeof message.content === "string") {
+          tokenCount += enc.encode(message.content).length;
+        } else if (Array.isArray(message.content)) {
+          message.content.forEach((contentPart) => {
+            if (contentPart.type === "text") {
+              tokenCount += enc.encode(contentPart.text).length;
+            } else if (contentPart.type === "tool_use") {
+              tokenCount += enc.encode(
+                JSON.stringify(contentPart.input)
+              ).length;
+            } else if (contentPart.type === "tool_result") {
+              tokenCount += enc.encode(contentPart.content || "").length;
+            }
+          });
+        }
+      });
+    }
+    if (typeof system === "string") {
+      tokenCount += enc.encode(system).length;
+    } else if (Array.isArray(system)) {
+      system.forEach((item) => {
+        if (item.type !== "text") return;
+        if (typeof item.text === "string") {
+          tokenCount += enc.encode(item.text).length;
+        } else if (Array.isArray(item.text)) {
+          item.text.forEach((textPart) => {
+            tokenCount += enc.encode(textPart || "").length;
+          });
+        }
+      });
+    }
+    if (tools) {
+      tools.forEach((tool) => {
+        if (tool.description) {
+          tokenCount += enc.encode(tool.name + tool.description).length;
+        }
+        if (tool.input_schema) {
+          tokenCount += enc.encode(JSON.stringify(tool.input_schema)).length;
+        }
+      });
+    }
+    const { provider, model } = getUseModel(req, tokenCount);
+    req.provider = provider;
+    req.body.model = model;
+  } catch (error) {
+    log("Error in router middleware:", error.message);
+    req.provider = "default";
+    req.body.model = req.config.OPENAI_MODEL;
+  } finally {
     next();
   }
 };
 
 // src/utils/processCheck.ts
 var import_fs2 = require("fs");
-var REFERENCE_COUNT_FILE = "/tmp/claude-code-reference-count.txt";
 function incrementReferenceCount() {
   let count = 0;
   if ((0, import_fs2.existsSync)(REFERENCE_COUNT_FILE)) {
@@ -37102,6 +37637,1393 @@ function getServiceInfo() {
   };
 }
 
+// node_modules/lru-cache/dist/esm/index.js
+var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+var warned = /* @__PURE__ */ new Set();
+var PROCESS = typeof process === "object" && !!process ? process : {};
+var emitWarning = (msg, type, code, fn) => {
+  typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
+};
+var AC = globalThis.AbortController;
+var AS = globalThis.AbortSignal;
+if (typeof AC === "undefined") {
+  AS = class AbortSignal {
+    onabort;
+    _onabort = [];
+    reason;
+    aborted = false;
+    addEventListener(_2, fn) {
+      this._onabort.push(fn);
+    }
+  };
+  AC = class AbortController {
+    constructor() {
+      warnACPolyfill();
+    }
+    signal = new AS();
+    abort(reason) {
+      if (this.signal.aborted)
+        return;
+      this.signal.reason = reason;
+      this.signal.aborted = true;
+      for (const fn of this.signal._onabort) {
+        fn(reason);
+      }
+      this.signal.onabort?.(reason);
+    }
+  };
+  let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
+  const warnACPolyfill = () => {
+    if (!printACPolyfillWarning)
+      return;
+    printACPolyfillWarning = false;
+    emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
+  };
+}
+var shouldWarn = (code) => !warned.has(code);
+var TYPE = Symbol("type");
+var isPosInt = (n2) => n2 && n2 === Math.floor(n2) && n2 > 0 && isFinite(n2);
+var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+var ZeroArray = class extends Array {
+  constructor(size) {
+    super(size);
+    this.fill(0);
+  }
+};
+var Stack = class _Stack {
+  heap;
+  length;
+  // private constructor
+  static #constructing = false;
+  static create(max) {
+    const HeapCls = getUintArray(max);
+    if (!HeapCls)
+      return [];
+    _Stack.#constructing = true;
+    const s2 = new _Stack(max, HeapCls);
+    _Stack.#constructing = false;
+    return s2;
+  }
+  constructor(max, HeapCls) {
+    if (!_Stack.#constructing) {
+      throw new TypeError("instantiate Stack using Stack.create(n)");
+    }
+    this.heap = new HeapCls(max);
+    this.length = 0;
+  }
+  push(n2) {
+    this.heap[this.length++] = n2;
+  }
+  pop() {
+    return this.heap[--this.length];
+  }
+};
+var LRUCache = class _LRUCache {
+  // options that cannot be changed without disaster
+  #max;
+  #maxSize;
+  #dispose;
+  #onInsert;
+  #disposeAfter;
+  #fetchMethod;
+  #memoMethod;
+  /**
+   * {@link LRUCache.OptionsBase.ttl}
+   */
+  ttl;
+  /**
+   * {@link LRUCache.OptionsBase.ttlResolution}
+   */
+  ttlResolution;
+  /**
+   * {@link LRUCache.OptionsBase.ttlAutopurge}
+   */
+  ttlAutopurge;
+  /**
+   * {@link LRUCache.OptionsBase.updateAgeOnGet}
+   */
+  updateAgeOnGet;
+  /**
+   * {@link LRUCache.OptionsBase.updateAgeOnHas}
+   */
+  updateAgeOnHas;
+  /**
+   * {@link LRUCache.OptionsBase.allowStale}
+   */
+  allowStale;
+  /**
+   * {@link LRUCache.OptionsBase.noDisposeOnSet}
+   */
+  noDisposeOnSet;
+  /**
+   * {@link LRUCache.OptionsBase.noUpdateTTL}
+   */
+  noUpdateTTL;
+  /**
+   * {@link LRUCache.OptionsBase.maxEntrySize}
+   */
+  maxEntrySize;
+  /**
+   * {@link LRUCache.OptionsBase.sizeCalculation}
+   */
+  sizeCalculation;
+  /**
+   * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+   */
+  noDeleteOnFetchRejection;
+  /**
+   * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+   */
+  noDeleteOnStaleGet;
+  /**
+   * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+   */
+  allowStaleOnFetchAbort;
+  /**
+   * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+   */
+  allowStaleOnFetchRejection;
+  /**
+   * {@link LRUCache.OptionsBase.ignoreFetchAbort}
+   */
+  ignoreFetchAbort;
+  // computed properties
+  #size;
+  #calculatedSize;
+  #keyMap;
+  #keyList;
+  #valList;
+  #next;
+  #prev;
+  #head;
+  #tail;
+  #free;
+  #disposed;
+  #sizes;
+  #starts;
+  #ttls;
+  #hasDispose;
+  #hasFetchMethod;
+  #hasDisposeAfter;
+  #hasOnInsert;
+  /**
+   * Do not call this method unless you need to inspect the
+   * inner workings of the cache.  If anything returned by this
+   * object is modified in any way, strange breakage may occur.
+   *
+   * These fields are private for a reason!
+   *
+   * @internal
+   */
+  static unsafeExposeInternals(c2) {
+    return {
+      // properties
+      starts: c2.#starts,
+      ttls: c2.#ttls,
+      sizes: c2.#sizes,
+      keyMap: c2.#keyMap,
+      keyList: c2.#keyList,
+      valList: c2.#valList,
+      next: c2.#next,
+      prev: c2.#prev,
+      get head() {
+        return c2.#head;
+      },
+      get tail() {
+        return c2.#tail;
+      },
+      free: c2.#free,
+      // methods
+      isBackgroundFetch: (p2) => c2.#isBackgroundFetch(p2),
+      backgroundFetch: (k2, index, options, context) => c2.#backgroundFetch(k2, index, options, context),
+      moveToTail: (index) => c2.#moveToTail(index),
+      indexes: (options) => c2.#indexes(options),
+      rindexes: (options) => c2.#rindexes(options),
+      isStale: (index) => c2.#isStale(index)
+    };
+  }
+  // Protected read-only members
+  /**
+   * {@link LRUCache.OptionsBase.max} (read-only)
+   */
+  get max() {
+    return this.#max;
+  }
+  /**
+   * {@link LRUCache.OptionsBase.maxSize} (read-only)
+   */
+  get maxSize() {
+    return this.#maxSize;
+  }
+  /**
+   * The total computed size of items in the cache (read-only)
+   */
+  get calculatedSize() {
+    return this.#calculatedSize;
+  }
+  /**
+   * The number of items stored in the cache (read-only)
+   */
+  get size() {
+    return this.#size;
+  }
+  /**
+   * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+   */
+  get fetchMethod() {
+    return this.#fetchMethod;
+  }
+  get memoMethod() {
+    return this.#memoMethod;
+  }
+  /**
+   * {@link LRUCache.OptionsBase.dispose} (read-only)
+   */
+  get dispose() {
+    return this.#dispose;
+  }
+  /**
+   * {@link LRUCache.OptionsBase.onInsert} (read-only)
+   */
+  get onInsert() {
+    return this.#onInsert;
+  }
+  /**
+   * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+   */
+  get disposeAfter() {
+    return this.#disposeAfter;
+  }
+  constructor(options) {
+    const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
+    if (max !== 0 && !isPosInt(max)) {
+      throw new TypeError("max option must be a nonnegative integer");
+    }
+    const UintArray = max ? getUintArray(max) : Array;
+    if (!UintArray) {
+      throw new Error("invalid max value: " + max);
+    }
+    this.#max = max;
+    this.#maxSize = maxSize;
+    this.maxEntrySize = maxEntrySize || this.#maxSize;
+    this.sizeCalculation = sizeCalculation;
+    if (this.sizeCalculation) {
+      if (!this.#maxSize && !this.maxEntrySize) {
+        throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+      }
+      if (typeof this.sizeCalculation !== "function") {
+        throw new TypeError("sizeCalculation set to non-function");
+      }
+    }
+    if (memoMethod !== void 0 && typeof memoMethod !== "function") {
+      throw new TypeError("memoMethod must be a function if defined");
+    }
+    this.#memoMethod = memoMethod;
+    if (fetchMethod !== void 0 && typeof fetchMethod !== "function") {
+      throw new TypeError("fetchMethod must be a function if specified");
+    }
+    this.#fetchMethod = fetchMethod;
+    this.#hasFetchMethod = !!fetchMethod;
+    this.#keyMap = /* @__PURE__ */ new Map();
+    this.#keyList = new Array(max).fill(void 0);
+    this.#valList = new Array(max).fill(void 0);
+    this.#next = new UintArray(max);
+    this.#prev = new UintArray(max);
+    this.#head = 0;
+    this.#tail = 0;
+    this.#free = Stack.create(max);
+    this.#size = 0;
+    this.#calculatedSize = 0;
+    if (typeof dispose === "function") {
+      this.#dispose = dispose;
+    }
+    if (typeof onInsert === "function") {
+      this.#onInsert = onInsert;
+    }
+    if (typeof disposeAfter === "function") {
+      this.#disposeAfter = disposeAfter;
+      this.#disposed = [];
+    } else {
+      this.#disposeAfter = void 0;
+      this.#disposed = void 0;
+    }
+    this.#hasDispose = !!this.#dispose;
+    this.#hasOnInsert = !!this.#onInsert;
+    this.#hasDisposeAfter = !!this.#disposeAfter;
+    this.noDisposeOnSet = !!noDisposeOnSet;
+    this.noUpdateTTL = !!noUpdateTTL;
+    this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+    this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+    this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+    this.ignoreFetchAbort = !!ignoreFetchAbort;
+    if (this.maxEntrySize !== 0) {
+      if (this.#maxSize !== 0) {
+        if (!isPosInt(this.#maxSize)) {
+          throw new TypeError("maxSize must be a positive integer if specified");
+        }
+      }
+      if (!isPosInt(this.maxEntrySize)) {
+        throw new TypeError("maxEntrySize must be a positive integer if specified");
+      }
+      this.#initializeSizeTracking();
+    }
+    this.allowStale = !!allowStale;
+    this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+    this.updateAgeOnGet = !!updateAgeOnGet;
+    this.updateAgeOnHas = !!updateAgeOnHas;
+    this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+    this.ttlAutopurge = !!ttlAutopurge;
+    this.ttl = ttl || 0;
+    if (this.ttl) {
+      if (!isPosInt(this.ttl)) {
+        throw new TypeError("ttl must be a positive integer if specified");
+      }
+      this.#initializeTTLTracking();
+    }
+    if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
+      throw new TypeError("At least one of max, maxSize, or ttl is required");
+    }
+    if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
+      const code = "LRU_CACHE_UNBOUNDED";
+      if (shouldWarn(code)) {
+        warned.add(code);
+        const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
+        emitWarning(msg, "UnboundedCacheWarning", code, _LRUCache);
+      }
+    }
+  }
+  /**
+   * Return the number of ms left in the item's TTL. If item is not in cache,
+   * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
+   */
+  getRemainingTTL(key) {
+    return this.#keyMap.has(key) ? Infinity : 0;
+  }
+  #initializeTTLTracking() {
+    const ttls = new ZeroArray(this.#max);
+    const starts = new ZeroArray(this.#max);
+    this.#ttls = ttls;
+    this.#starts = starts;
+    this.#setItemTTL = (index, ttl, start = perf.now()) => {
+      starts[index] = ttl !== 0 ? start : 0;
+      ttls[index] = ttl;
+      if (ttl !== 0 && this.ttlAutopurge) {
+        const t2 = setTimeout(() => {
+          if (this.#isStale(index)) {
+            this.#delete(this.#keyList[index], "expire");
+          }
+        }, ttl + 1);
+        if (t2.unref) {
+          t2.unref();
+        }
+      }
+    };
+    this.#updateItemAge = (index) => {
+      starts[index] = ttls[index] !== 0 ? perf.now() : 0;
+    };
+    this.#statusTTL = (status, index) => {
+      if (ttls[index]) {
+        const ttl = ttls[index];
+        const start = starts[index];
+        if (!ttl || !start)
+          return;
+        status.ttl = ttl;
+        status.start = start;
+        status.now = cachedNow || getNow();
+        const age = status.now - start;
+        status.remainingTTL = ttl - age;
+      }
+    };
+    let cachedNow = 0;
+    const getNow = () => {
+      const n2 = perf.now();
+      if (this.ttlResolution > 0) {
+        cachedNow = n2;
+        const t2 = setTimeout(() => cachedNow = 0, this.ttlResolution);
+        if (t2.unref) {
+          t2.unref();
+        }
+      }
+      return n2;
+    };
+    this.getRemainingTTL = (key) => {
+      const index = this.#keyMap.get(key);
+      if (index === void 0) {
+        return 0;
+      }
+      const ttl = ttls[index];
+      const start = starts[index];
+      if (!ttl || !start) {
+        return Infinity;
+      }
+      const age = (cachedNow || getNow()) - start;
+      return ttl - age;
+    };
+    this.#isStale = (index) => {
+      const s2 = starts[index];
+      const t2 = ttls[index];
+      return !!t2 && !!s2 && (cachedNow || getNow()) - s2 > t2;
+    };
+  }
+  // conditionally set private methods related to TTL
+  #updateItemAge = () => {
+  };
+  #statusTTL = () => {
+  };
+  #setItemTTL = () => {
+  };
+  /* c8 ignore stop */
+  #isStale = () => false;
+  #initializeSizeTracking() {
+    const sizes = new ZeroArray(this.#max);
+    this.#calculatedSize = 0;
+    this.#sizes = sizes;
+    this.#removeItemSize = (index) => {
+      this.#calculatedSize -= sizes[index];
+      sizes[index] = 0;
+    };
+    this.#requireSize = (k2, v2, size, sizeCalculation) => {
+      if (this.#isBackgroundFetch(v2)) {
+        return 0;
+      }
+      if (!isPosInt(size)) {
+        if (sizeCalculation) {
+          if (typeof sizeCalculation !== "function") {
+            throw new TypeError("sizeCalculation must be a function");
+          }
+          size = sizeCalculation(v2, k2);
+          if (!isPosInt(size)) {
+            throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+          }
+        } else {
+          throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+        }
+      }
+      return size;
+    };
+    this.#addItemSize = (index, size, status) => {
+      sizes[index] = size;
+      if (this.#maxSize) {
+        const maxSize = this.#maxSize - sizes[index];
+        while (this.#calculatedSize > maxSize) {
+          this.#evict(true);
+        }
+      }
+      this.#calculatedSize += sizes[index];
+      if (status) {
+        status.entrySize = size;
+        status.totalCalculatedSize = this.#calculatedSize;
+      }
+    };
+  }
+  #removeItemSize = (_i) => {
+  };
+  #addItemSize = (_i, _s, _st) => {
+  };
+  #requireSize = (_k, _v, size, sizeCalculation) => {
+    if (size || sizeCalculation) {
+      throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+    }
+    return 0;
+  };
+  *#indexes({ allowStale = this.allowStale } = {}) {
+    if (this.#size) {
+      for (let i2 = this.#tail; true; ) {
+        if (!this.#isValidIndex(i2)) {
+          break;
+        }
+        if (allowStale || !this.#isStale(i2)) {
+          yield i2;
+        }
+        if (i2 === this.#head) {
+          break;
+        } else {
+          i2 = this.#prev[i2];
+        }
+      }
+    }
+  }
+  *#rindexes({ allowStale = this.allowStale } = {}) {
+    if (this.#size) {
+      for (let i2 = this.#head; true; ) {
+        if (!this.#isValidIndex(i2)) {
+          break;
+        }
+        if (allowStale || !this.#isStale(i2)) {
+          yield i2;
+        }
+        if (i2 === this.#tail) {
+          break;
+        } else {
+          i2 = this.#next[i2];
+        }
+      }
+    }
+  }
+  #isValidIndex(index) {
+    return index !== void 0 && this.#keyMap.get(this.#keyList[index]) === index;
+  }
+  /**
+   * Return a generator yielding `[key, value]` pairs,
+   * in order from most recently used to least recently used.
+   */
+  *entries() {
+    for (const i2 of this.#indexes()) {
+      if (this.#valList[i2] !== void 0 && this.#keyList[i2] !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
+        yield [this.#keyList[i2], this.#valList[i2]];
+      }
+    }
+  }
+  /**
+   * Inverse order version of {@link LRUCache.entries}
+   *
+   * Return a generator yielding `[key, value]` pairs,
+   * in order from least recently used to most recently used.
+   */
+  *rentries() {
+    for (const i2 of this.#rindexes()) {
+      if (this.#valList[i2] !== void 0 && this.#keyList[i2] !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
+        yield [this.#keyList[i2], this.#valList[i2]];
+      }
+    }
+  }
+  /**
+   * Return a generator yielding the keys in the cache,
+   * in order from most recently used to least recently used.
+   */
+  *keys() {
+    for (const i2 of this.#indexes()) {
+      const k2 = this.#keyList[i2];
+      if (k2 !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
+        yield k2;
+      }
+    }
+  }
+  /**
+   * Inverse order version of {@link LRUCache.keys}
+   *
+   * Return a generator yielding the keys in the cache,
+   * in order from least recently used to most recently used.
+   */
+  *rkeys() {
+    for (const i2 of this.#rindexes()) {
+      const k2 = this.#keyList[i2];
+      if (k2 !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
+        yield k2;
+      }
+    }
+  }
+  /**
+   * Return a generator yielding the values in the cache,
+   * in order from most recently used to least recently used.
+   */
+  *values() {
+    for (const i2 of this.#indexes()) {
+      const v2 = this.#valList[i2];
+      if (v2 !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
+        yield this.#valList[i2];
+      }
+    }
+  }
+  /**
+   * Inverse order version of {@link LRUCache.values}
+   *
+   * Return a generator yielding the values in the cache,
+   * in order from least recently used to most recently used.
+   */
+  *rvalues() {
+    for (const i2 of this.#rindexes()) {
+      const v2 = this.#valList[i2];
+      if (v2 !== void 0 && !this.#isBackgroundFetch(this.#valList[i2])) {
+        yield this.#valList[i2];
+      }
+    }
+  }
+  /**
+   * Iterating over the cache itself yields the same results as
+   * {@link LRUCache.entries}
+   */
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  /**
+   * A String value that is used in the creation of the default string
+   * description of an object. Called by the built-in method
+   * `Object.prototype.toString`.
+   */
+  [Symbol.toStringTag] = "LRUCache";
+  /**
+   * Find a value for which the supplied fn method returns a truthy value,
+   * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
+   */
+  find(fn, getOptions = {}) {
+    for (const i2 of this.#indexes()) {
+      const v2 = this.#valList[i2];
+      const value = this.#isBackgroundFetch(v2) ? v2.__staleWhileFetching : v2;
+      if (value === void 0)
+        continue;
+      if (fn(value, this.#keyList[i2], this)) {
+        return this.get(this.#keyList[i2], getOptions);
+      }
+    }
+  }
+  /**
+   * Call the supplied function on each item in the cache, in order from most
+   * recently used to least recently used.
+   *
+   * `fn` is called as `fn(value, key, cache)`.
+   *
+   * If `thisp` is provided, function will be called in the `this`-context of
+   * the provided object, or the cache if no `thisp` object is provided.
+   *
+   * Does not update age or recenty of use, or iterate over stale values.
+   */
+  forEach(fn, thisp = this) {
+    for (const i2 of this.#indexes()) {
+      const v2 = this.#valList[i2];
+      const value = this.#isBackgroundFetch(v2) ? v2.__staleWhileFetching : v2;
+      if (value === void 0)
+        continue;
+      fn.call(thisp, value, this.#keyList[i2], this);
+    }
+  }
+  /**
+   * The same as {@link LRUCache.forEach} but items are iterated over in
+   * reverse order.  (ie, less recently used items are iterated over first.)
+   */
+  rforEach(fn, thisp = this) {
+    for (const i2 of this.#rindexes()) {
+      const v2 = this.#valList[i2];
+      const value = this.#isBackgroundFetch(v2) ? v2.__staleWhileFetching : v2;
+      if (value === void 0)
+        continue;
+      fn.call(thisp, value, this.#keyList[i2], this);
+    }
+  }
+  /**
+   * Delete any stale entries. Returns true if anything was removed,
+   * false otherwise.
+   */
+  purgeStale() {
+    let deleted = false;
+    for (const i2 of this.#rindexes({ allowStale: true })) {
+      if (this.#isStale(i2)) {
+        this.#delete(this.#keyList[i2], "expire");
+        deleted = true;
+      }
+    }
+    return deleted;
+  }
+  /**
+   * Get the extended info about a given entry, to get its value, size, and
+   * TTL info simultaneously. Returns `undefined` if the key is not present.
+   *
+   * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
+   * serialization, the `start` value is always the current timestamp, and the
+   * `ttl` is a calculated remaining time to live (negative if expired).
+   *
+   * Always returns stale values, if their info is found in the cache, so be
+   * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
+   * if relevant.
+   */
+  info(key) {
+    const i2 = this.#keyMap.get(key);
+    if (i2 === void 0)
+      return void 0;
+    const v2 = this.#valList[i2];
+    const value = this.#isBackgroundFetch(v2) ? v2.__staleWhileFetching : v2;
+    if (value === void 0)
+      return void 0;
+    const entry = { value };
+    if (this.#ttls && this.#starts) {
+      const ttl = this.#ttls[i2];
+      const start = this.#starts[i2];
+      if (ttl && start) {
+        const remain = ttl - (perf.now() - start);
+        entry.ttl = remain;
+        entry.start = Date.now();
+      }
+    }
+    if (this.#sizes) {
+      entry.size = this.#sizes[i2];
+    }
+    return entry;
+  }
+  /**
+   * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+   * passed to {@link LRUCache#load}.
+   *
+   * The `start` fields are calculated relative to a portable `Date.now()`
+   * timestamp, even if `performance.now()` is available.
+   *
+   * Stale entries are always included in the `dump`, even if
+   * {@link LRUCache.OptionsBase.allowStale} is false.
+   *
+   * Note: this returns an actual array, not a generator, so it can be more
+   * easily passed around.
+   */
+  dump() {
+    const arr = [];
+    for (const i2 of this.#indexes({ allowStale: true })) {
+      const key = this.#keyList[i2];
+      const v2 = this.#valList[i2];
+      const value = this.#isBackgroundFetch(v2) ? v2.__staleWhileFetching : v2;
+      if (value === void 0 || key === void 0)
+        continue;
+      const entry = { value };
+      if (this.#ttls && this.#starts) {
+        entry.ttl = this.#ttls[i2];
+        const age = perf.now() - this.#starts[i2];
+        entry.start = Math.floor(Date.now() - age);
+      }
+      if (this.#sizes) {
+        entry.size = this.#sizes[i2];
+      }
+      arr.unshift([key, entry]);
+    }
+    return arr;
+  }
+  /**
+   * Reset the cache and load in the items in entries in the order listed.
+   *
+   * The shape of the resulting cache may be different if the same options are
+   * not used in both caches.
+   *
+   * The `start` fields are assumed to be calculated relative to a portable
+   * `Date.now()` timestamp, even if `performance.now()` is available.
+   */
+  load(arr) {
+    this.clear();
+    for (const [key, entry] of arr) {
+      if (entry.start) {
+        const age = Date.now() - entry.start;
+        entry.start = perf.now() - age;
+      }
+      this.set(key, entry.value, entry);
+    }
+  }
+  /**
+   * Add a value to the cache.
+   *
+   * Note: if `undefined` is specified as a value, this is an alias for
+   * {@link LRUCache#delete}
+   *
+   * Fields on the {@link LRUCache.SetOptions} options param will override
+   * their corresponding values in the constructor options for the scope
+   * of this single `set()` operation.
+   *
+   * If `start` is provided, then that will set the effective start
+   * time for the TTL calculation. Note that this must be a previous
+   * value of `performance.now()` if supported, or a previous value of
+   * `Date.now()` if not.
+   *
+   * Options object may also include `size`, which will prevent
+   * calling the `sizeCalculation` function and just use the specified
+   * number if it is a positive integer, and `noDisposeOnSet` which
+   * will prevent calling a `dispose` function in the case of
+   * overwrites.
+   *
+   * If the `size` (or return value of `sizeCalculation`) for a given
+   * entry is greater than `maxEntrySize`, then the item will not be
+   * added to the cache.
+   *
+   * Will update the recency of the entry.
+   *
+   * If the value is `undefined`, then this is an alias for
+   * `cache.delete(key)`. `undefined` is never stored in the cache.
+   */
+  set(k2, v2, setOptions = {}) {
+    if (v2 === void 0) {
+      this.delete(k2);
+      return this;
+    }
+    const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
+    let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+    const size = this.#requireSize(k2, v2, setOptions.size || 0, sizeCalculation);
+    if (this.maxEntrySize && size > this.maxEntrySize) {
+      if (status) {
+        status.set = "miss";
+        status.maxEntrySizeExceeded = true;
+      }
+      this.#delete(k2, "set");
+      return this;
+    }
+    let index = this.#size === 0 ? void 0 : this.#keyMap.get(k2);
+    if (index === void 0) {
+      index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
+      this.#keyList[index] = k2;
+      this.#valList[index] = v2;
+      this.#keyMap.set(k2, index);
+      this.#next[this.#tail] = index;
+      this.#prev[index] = this.#tail;
+      this.#tail = index;
+      this.#size++;
+      this.#addItemSize(index, size, status);
+      if (status)
+        status.set = "add";
+      noUpdateTTL = false;
+      if (this.#hasOnInsert) {
+        this.#onInsert?.(v2, k2, "add");
+      }
+    } else {
+      this.#moveToTail(index);
+      const oldVal = this.#valList[index];
+      if (v2 !== oldVal) {
+        if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
+          oldVal.__abortController.abort(new Error("replaced"));
+          const { __staleWhileFetching: s2 } = oldVal;
+          if (s2 !== void 0 && !noDisposeOnSet) {
+            if (this.#hasDispose) {
+              this.#dispose?.(s2, k2, "set");
+            }
+            if (this.#hasDisposeAfter) {
+              this.#disposed?.push([s2, k2, "set"]);
+            }
+          }
+        } else if (!noDisposeOnSet) {
+          if (this.#hasDispose) {
+            this.#dispose?.(oldVal, k2, "set");
+          }
+          if (this.#hasDisposeAfter) {
+            this.#disposed?.push([oldVal, k2, "set"]);
+          }
+        }
+        this.#removeItemSize(index);
+        this.#addItemSize(index, size, status);
+        this.#valList[index] = v2;
+        if (status) {
+          status.set = "replace";
+          const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
+          if (oldValue !== void 0)
+            status.oldValue = oldValue;
+        }
+      } else if (status) {
+        status.set = "update";
+      }
+      if (this.#hasOnInsert) {
+        this.onInsert?.(v2, k2, v2 === oldVal ? "update" : "replace");
+      }
+    }
+    if (ttl !== 0 && !this.#ttls) {
+      this.#initializeTTLTracking();
+    }
+    if (this.#ttls) {
+      if (!noUpdateTTL) {
+        this.#setItemTTL(index, ttl, start);
+      }
+      if (status)
+        this.#statusTTL(status, index);
+    }
+    if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+      const dt2 = this.#disposed;
+      let task;
+      while (task = dt2?.shift()) {
+        this.#disposeAfter?.(...task);
+      }
+    }
+    return this;
+  }
+  /**
+   * Evict the least recently used item, returning its value or
+   * `undefined` if cache is empty.
+   */
+  pop() {
+    try {
+      while (this.#size) {
+        const val = this.#valList[this.#head];
+        this.#evict(true);
+        if (this.#isBackgroundFetch(val)) {
+          if (val.__staleWhileFetching) {
+            return val.__staleWhileFetching;
+          }
+        } else if (val !== void 0) {
+          return val;
+        }
+      }
+    } finally {
+      if (this.#hasDisposeAfter && this.#disposed) {
+        const dt2 = this.#disposed;
+        let task;
+        while (task = dt2?.shift()) {
+          this.#disposeAfter?.(...task);
+        }
+      }
+    }
+  }
+  #evict(free) {
+    const head = this.#head;
+    const k2 = this.#keyList[head];
+    const v2 = this.#valList[head];
+    if (this.#hasFetchMethod && this.#isBackgroundFetch(v2)) {
+      v2.__abortController.abort(new Error("evicted"));
+    } else if (this.#hasDispose || this.#hasDisposeAfter) {
+      if (this.#hasDispose) {
+        this.#dispose?.(v2, k2, "evict");
+      }
+      if (this.#hasDisposeAfter) {
+        this.#disposed?.push([v2, k2, "evict"]);
+      }
+    }
+    this.#removeItemSize(head);
+    if (free) {
+      this.#keyList[head] = void 0;
+      this.#valList[head] = void 0;
+      this.#free.push(head);
+    }
+    if (this.#size === 1) {
+      this.#head = this.#tail = 0;
+      this.#free.length = 0;
+    } else {
+      this.#head = this.#next[head];
+    }
+    this.#keyMap.delete(k2);
+    this.#size--;
+    return head;
+  }
+  /**
+   * Check if a key is in the cache, without updating the recency of use.
+   * Will return false if the item is stale, even though it is technically
+   * in the cache.
+   *
+   * Check if a key is in the cache, without updating the recency of
+   * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
+   * to `true` in either the options or the constructor.
+   *
+   * Will return `false` if the item is stale, even though it is technically in
+   * the cache. The difference can be determined (if it matters) by using a
+   * `status` argument, and inspecting the `has` field.
+   *
+   * Will not update item age unless
+   * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+   */
+  has(k2, hasOptions = {}) {
+    const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+    const index = this.#keyMap.get(k2);
+    if (index !== void 0) {
+      const v2 = this.#valList[index];
+      if (this.#isBackgroundFetch(v2) && v2.__staleWhileFetching === void 0) {
+        return false;
+      }
+      if (!this.#isStale(index)) {
+        if (updateAgeOnHas) {
+          this.#updateItemAge(index);
+        }
+        if (status) {
+          status.has = "hit";
+          this.#statusTTL(status, index);
+        }
+        return true;
+      } else if (status) {
+        status.has = "stale";
+        this.#statusTTL(status, index);
+      }
+    } else if (status) {
+      status.has = "miss";
+    }
+    return false;
+  }
+  /**
+   * Like {@link LRUCache#get} but doesn't update recency or delete stale
+   * items.
+   *
+   * Returns `undefined` if the item is stale, unless
+   * {@link LRUCache.OptionsBase.allowStale} is set.
+   */
+  peek(k2, peekOptions = {}) {
+    const { allowStale = this.allowStale } = peekOptions;
+    const index = this.#keyMap.get(k2);
+    if (index === void 0 || !allowStale && this.#isStale(index)) {
+      return;
+    }
+    const v2 = this.#valList[index];
+    return this.#isBackgroundFetch(v2) ? v2.__staleWhileFetching : v2;
+  }
+  #backgroundFetch(k2, index, options, context) {
+    const v2 = index === void 0 ? void 0 : this.#valList[index];
+    if (this.#isBackgroundFetch(v2)) {
+      return v2;
+    }
+    const ac = new AC();
+    const { signal } = options;
+    signal?.addEventListener("abort", () => ac.abort(signal.reason), {
+      signal: ac.signal
+    });
+    const fetchOpts = {
+      signal: ac.signal,
+      options,
+      context
+    };
+    const cb = (v3, updateCache = false) => {
+      const { aborted } = ac.signal;
+      const ignoreAbort = options.ignoreFetchAbort && v3 !== void 0;
+      if (options.status) {
+        if (aborted && !updateCache) {
+          options.status.fetchAborted = true;
+          options.status.fetchError = ac.signal.reason;
+          if (ignoreAbort)
+            options.status.fetchAbortIgnored = true;
+        } else {
+          options.status.fetchResolved = true;
+        }
+      }
+      if (aborted && !ignoreAbort && !updateCache) {
+        return fetchFail(ac.signal.reason);
+      }
+      const bf2 = p2;
+      if (this.#valList[index] === p2) {
+        if (v3 === void 0) {
+          if (bf2.__staleWhileFetching) {
+            this.#valList[index] = bf2.__staleWhileFetching;
+          } else {
+            this.#delete(k2, "fetch");
+          }
+        } else {
+          if (options.status)
+            options.status.fetchUpdated = true;
+          this.set(k2, v3, fetchOpts.options);
+        }
+      }
+      return v3;
+    };
+    const eb = (er2) => {
+      if (options.status) {
+        options.status.fetchRejected = true;
+        options.status.fetchError = er2;
+      }
+      return fetchFail(er2);
+    };
+    const fetchFail = (er2) => {
+      const { aborted } = ac.signal;
+      const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+      const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+      const noDelete = allowStale || options.noDeleteOnFetchRejection;
+      const bf2 = p2;
+      if (this.#valList[index] === p2) {
+        const del = !noDelete || bf2.__staleWhileFetching === void 0;
+        if (del) {
+          this.#delete(k2, "fetch");
+        } else if (!allowStaleAborted) {
+          this.#valList[index] = bf2.__staleWhileFetching;
+        }
+      }
+      if (allowStale) {
+        if (options.status && bf2.__staleWhileFetching !== void 0) {
+          options.status.returnedStale = true;
+        }
+        return bf2.__staleWhileFetching;
+      } else if (bf2.__returned === bf2) {
+        throw er2;
+      }
+    };
+    const pcall = (res, rej) => {
+      const fmp = this.#fetchMethod?.(k2, v2, fetchOpts);
+      if (fmp && fmp instanceof Promise) {
+        fmp.then((v3) => res(v3 === void 0 ? void 0 : v3), rej);
+      }
+      ac.signal.addEventListener("abort", () => {
+        if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
+          res(void 0);
+          if (options.allowStaleOnFetchAbort) {
+            res = (v3) => cb(v3, true);
+          }
+        }
+      });
+    };
+    if (options.status)
+      options.status.fetchDispatched = true;
+    const p2 = new Promise(pcall).then(cb, eb);
+    const bf = Object.assign(p2, {
+      __abortController: ac,
+      __staleWhileFetching: v2,
+      __returned: void 0
+    });
+    if (index === void 0) {
+      this.set(k2, bf, { ...fetchOpts.options, status: void 0 });
+      index = this.#keyMap.get(k2);
+    } else {
+      this.#valList[index] = bf;
+    }
+    return bf;
+  }
+  #isBackgroundFetch(p2) {
+    if (!this.#hasFetchMethod)
+      return false;
+    const b2 = p2;
+    return !!b2 && b2 instanceof Promise && b2.hasOwnProperty("__staleWhileFetching") && b2.__abortController instanceof AC;
+  }
+  async fetch(k2, fetchOptions = {}) {
+    const {
+      // get options
+      allowStale = this.allowStale,
+      updateAgeOnGet = this.updateAgeOnGet,
+      noDeleteOnStaleGet = this.noDeleteOnStaleGet,
+      // set options
+      ttl = this.ttl,
+      noDisposeOnSet = this.noDisposeOnSet,
+      size = 0,
+      sizeCalculation = this.sizeCalculation,
+      noUpdateTTL = this.noUpdateTTL,
+      // fetch exclusive options
+      noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,
+      allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
+      ignoreFetchAbort = this.ignoreFetchAbort,
+      allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
+      context,
+      forceRefresh = false,
+      status,
+      signal
+    } = fetchOptions;
+    if (!this.#hasFetchMethod) {
+      if (status)
+        status.fetch = "get";
+      return this.get(k2, {
+        allowStale,
+        updateAgeOnGet,
+        noDeleteOnStaleGet,
+        status
+      });
+    }
+    const options = {
+      allowStale,
+      updateAgeOnGet,
+      noDeleteOnStaleGet,
+      ttl,
+      noDisposeOnSet,
+      size,
+      sizeCalculation,
+      noUpdateTTL,
+      noDeleteOnFetchRejection,
+      allowStaleOnFetchRejection,
+      allowStaleOnFetchAbort,
+      ignoreFetchAbort,
+      status,
+      signal
+    };
+    let index = this.#keyMap.get(k2);
+    if (index === void 0) {
+      if (status)
+        status.fetch = "miss";
+      const p2 = this.#backgroundFetch(k2, index, options, context);
+      return p2.__returned = p2;
+    } else {
+      const v2 = this.#valList[index];
+      if (this.#isBackgroundFetch(v2)) {
+        const stale = allowStale && v2.__staleWhileFetching !== void 0;
+        if (status) {
+          status.fetch = "inflight";
+          if (stale)
+            status.returnedStale = true;
+        }
+        return stale ? v2.__staleWhileFetching : v2.__returned = v2;
+      }
+      const isStale = this.#isStale(index);
+      if (!forceRefresh && !isStale) {
+        if (status)
+          status.fetch = "hit";
+        this.#moveToTail(index);
+        if (updateAgeOnGet) {
+          this.#updateItemAge(index);
+        }
+        if (status)
+          this.#statusTTL(status, index);
+        return v2;
+      }
+      const p2 = this.#backgroundFetch(k2, index, options, context);
+      const hasStale = p2.__staleWhileFetching !== void 0;
+      const staleVal = hasStale && allowStale;
+      if (status) {
+        status.fetch = isStale ? "stale" : "refresh";
+        if (staleVal && isStale)
+          status.returnedStale = true;
+      }
+      return staleVal ? p2.__staleWhileFetching : p2.__returned = p2;
+    }
+  }
+  async forceFetch(k2, fetchOptions = {}) {
+    const v2 = await this.fetch(k2, fetchOptions);
+    if (v2 === void 0)
+      throw new Error("fetch() returned undefined");
+    return v2;
+  }
+  memo(k2, memoOptions = {}) {
+    const memoMethod = this.#memoMethod;
+    if (!memoMethod) {
+      throw new Error("no memoMethod provided to constructor");
+    }
+    const { context, forceRefresh, ...options } = memoOptions;
+    const v2 = this.get(k2, options);
+    if (!forceRefresh && v2 !== void 0)
+      return v2;
+    const vv = memoMethod(k2, v2, {
+      options,
+      context
+    });
+    this.set(k2, vv, options);
+    return vv;
+  }
+  /**
+   * Return a value from the cache. Will update the recency of the cache
+   * entry found.
+   *
+   * If the key is not found, get() will return `undefined`.
+   */
+  get(k2, getOptions = {}) {
+    const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
+    const index = this.#keyMap.get(k2);
+    if (index !== void 0) {
+      const value = this.#valList[index];
+      const fetching = this.#isBackgroundFetch(value);
+      if (status)
+        this.#statusTTL(status, index);
+      if (this.#isStale(index)) {
+        if (status)
+          status.get = "stale";
+        if (!fetching) {
+          if (!noDeleteOnStaleGet) {
+            this.#delete(k2, "expire");
+          }
+          if (status && allowStale)
+            status.returnedStale = true;
+          return allowStale ? value : void 0;
+        } else {
+          if (status && allowStale && value.__staleWhileFetching !== void 0) {
+            status.returnedStale = true;
+          }
+          return allowStale ? value.__staleWhileFetching : void 0;
+        }
+      } else {
+        if (status)
+          status.get = "hit";
+        if (fetching) {
+          return value.__staleWhileFetching;
+        }
+        this.#moveToTail(index);
+        if (updateAgeOnGet) {
+          this.#updateItemAge(index);
+        }
+        return value;
+      }
+    } else if (status) {
+      status.get = "miss";
+    }
+  }
+  #connect(p2, n2) {
+    this.#prev[n2] = p2;
+    this.#next[p2] = n2;
+  }
+  #moveToTail(index) {
+    if (index !== this.#tail) {
+      if (index === this.#head) {
+        this.#head = this.#next[index];
+      } else {
+        this.#connect(this.#prev[index], this.#next[index]);
+      }
+      this.#connect(this.#tail, index);
+      this.#tail = index;
+    }
+  }
+  /**
+   * Deletes a key out of the cache.
+   *
+   * Returns true if the key was deleted, false otherwise.
+   */
+  delete(k2) {
+    return this.#delete(k2, "delete");
+  }
+  #delete(k2, reason) {
+    let deleted = false;
+    if (this.#size !== 0) {
+      const index = this.#keyMap.get(k2);
+      if (index !== void 0) {
+        deleted = true;
+        if (this.#size === 1) {
+          this.#clear(reason);
+        } else {
+          this.#removeItemSize(index);
+          const v2 = this.#valList[index];
+          if (this.#isBackgroundFetch(v2)) {
+            v2.__abortController.abort(new Error("deleted"));
+          } else if (this.#hasDispose || this.#hasDisposeAfter) {
+            if (this.#hasDispose) {
+              this.#dispose?.(v2, k2, reason);
+            }
+            if (this.#hasDisposeAfter) {
+              this.#disposed?.push([v2, k2, reason]);
+            }
+          }
+          this.#keyMap.delete(k2);
+          this.#keyList[index] = void 0;
+          this.#valList[index] = void 0;
+          if (index === this.#tail) {
+            this.#tail = this.#prev[index];
+          } else if (index === this.#head) {
+            this.#head = this.#next[index];
+          } else {
+            const pi = this.#prev[index];
+            this.#next[pi] = this.#next[index];
+            const ni = this.#next[index];
+            this.#prev[ni] = this.#prev[index];
+          }
+          this.#size--;
+          this.#free.push(index);
+        }
+      }
+    }
+    if (this.#hasDisposeAfter && this.#disposed?.length) {
+      const dt2 = this.#disposed;
+      let task;
+      while (task = dt2?.shift()) {
+        this.#disposeAfter?.(...task);
+      }
+    }
+    return deleted;
+  }
+  /**
+   * Clear the cache entirely, throwing away all values.
+   */
+  clear() {
+    return this.#clear("delete");
+  }
+  #clear(reason) {
+    for (const index of this.#rindexes({ allowStale: true })) {
+      const v2 = this.#valList[index];
+      if (this.#isBackgroundFetch(v2)) {
+        v2.__abortController.abort(new Error("deleted"));
+      } else {
+        const k2 = this.#keyList[index];
+        if (this.#hasDispose) {
+          this.#dispose?.(v2, k2, reason);
+        }
+        if (this.#hasDisposeAfter) {
+          this.#disposed?.push([v2, k2, reason]);
+        }
+      }
+    }
+    this.#keyMap.clear();
+    this.#valList.fill(void 0);
+    this.#keyList.fill(void 0);
+    if (this.#ttls && this.#starts) {
+      this.#ttls.fill(0);
+      this.#starts.fill(0);
+    }
+    if (this.#sizes) {
+      this.#sizes.fill(0);
+    }
+    this.#head = 0;
+    this.#tail = 0;
+    this.#free.length = 0;
+    this.#calculatedSize = 0;
+    this.#size = 0;
+    if (this.#hasDisposeAfter && this.#disposed) {
+      const dt2 = this.#disposed;
+      let task;
+      while (task = dt2?.shift()) {
+        this.#disposeAfter?.(...task);
+      }
+    }
+  }
+};
+
 // src/index.ts
 async function initializeClaudeConfig() {
   const homeDir = process.env.HOME;
@@ -37123,14 +39045,56 @@ async function initializeClaudeConfig() {
   }
 }
 async function run(options = {}) {
-  const port = options.port || 3456;
   if (isServiceRunning()) {
     console.log("\u2705 Service is already running in the background.");
     return;
   }
   await initializeClaudeConfig();
   await initDir();
-  await initConfig();
+  const config = await initConfig();
+  const Providers = /* @__PURE__ */ new Map();
+  const providerCache = new LRUCache({
+    max: 10,
+    ttl: 2 * 60 * 60 * 1e3
+  });
+  function getProviderInstance(providerName) {
+    const provider = Providers.get(providerName);
+    if (provider === void 0) {
+      throw new Error(`Provider ${providerName} not found`);
+    }
+    let openai = providerCache.get(provider.name);
+    if (!openai) {
+      openai = new openai_default({
+        baseURL: provider.api_base_url,
+        apiKey: provider.api_key,
+        ...getOpenAICommonOptions()
+      });
+      providerCache.set(provider.name, openai);
+    }
+    return openai;
+  }
+  if (Array.isArray(config.Providers)) {
+    config.Providers.forEach((provider) => {
+      try {
+        Providers.set(provider.name, provider);
+      } catch (error) {
+        console.error("Failed to parse model provider:", error);
+      }
+    });
+  }
+  if (config.OPENAI_API_KEY && config.OPENAI_BASE_URL && config.OPENAI_MODEL) {
+    const defaultProvider = {
+      name: "default",
+      api_base_url: config.OPENAI_BASE_URL,
+      api_key: config.OPENAI_API_KEY,
+      models: [config.OPENAI_MODEL]
+    };
+    Providers.set("default", defaultProvider);
+  } else if (Providers.size > 0) {
+    const defaultProvider = Providers.values().next().value;
+    Providers.set("default", defaultProvider);
+  }
+  const port = options.port || 3456;
   savePid(process.pid);
   process.on("SIGINT", () => {
     console.log("Received SIGINT, cleaning up...");
@@ -37142,20 +39106,27 @@ async function run(options = {}) {
     process.exit(0);
   });
   const servicePort = process.env.SERVICE_PORT ? parseInt(process.env.SERVICE_PORT) : port;
-  const server = createServer(servicePort);
-  server.useMiddleware(formatRequest);
-  server.useMiddleware(rewriteBody);
-  const openai = new openai_default({
-    apiKey: process.env.OPENAI_API_KEY,
-    baseURL: process.env.OPENAI_BASE_URL,
-    ...getOpenAICommonOptions()
+  const server = await createServer(servicePort);
+  server.useMiddleware((req, res, next) => {
+    console.log("Middleware triggered for request:", req.body.model);
+    req.config = config;
+    next();
   });
+  server.useMiddleware(rewriteBody);
+  if (config.Router?.background && config.Router?.think && config?.Router?.longContext) {
+    server.useMiddleware(router);
+  } else {
+    server.useMiddleware((req, res, next) => {
+      req.provider = "default";
+      req.body.model = config.OPENAI_MODEL;
+      next();
+    });
+  }
+  server.useMiddleware(formatRequest);
   server.app.post("/v1/messages", async (req, res) => {
     try {
-      if (process.env.OPENAI_MODEL) {
-        req.body.model = process.env.OPENAI_MODEL;
-      }
-      const completion = await openai.chat.completions.create(req.body);
+      const provider = getProviderInstance(req.provider || "default");
+      const completion = await provider.chat.completions.create(req.body);
       await streamOpenAIResponse(res, completion, req.body.model, req.body);
     } catch (e2) {
       console.error("Error in OpenAI API call:", e2);
@@ -37165,29 +39136,6 @@ async function run(options = {}) {
   console.log(`\u{1F680} Claude Code Router is running on port ${servicePort}`);
 }
 
-// src/utils/close.ts
-var import_fs4 = require("fs");
-var import_path2 = require("path");
-async function closeService() {
-  const PID_FILE2 = (0, import_path2.join)(HOME_DIR, ".claude-code-router.pid");
-  if (!isServiceRunning()) {
-    console.log("No service is currently running.");
-    return;
-  }
-  if (getReferenceCount() > 0) {
-    return;
-  }
-  try {
-    const pid = parseInt((0, import_fs4.readFileSync)(PID_FILE2, "utf-8"));
-    process.kill(pid);
-    cleanupPidFile();
-    console.log("claude code router service has been successfully stopped.");
-  } catch (e2) {
-    console.log("Failed to stop the service. It may have already been stopped.");
-    cleanupPidFile();
-  }
-}
-
 // src/utils/status.ts
 function showStatus() {
   const info = getServiceInfo();
@@ -37214,23 +39162,51 @@ function showStatus() {
 
 // src/utils/codeCommand.ts
 var import_child_process = require("child_process");
+
+// src/utils/close.ts
+var import_fs4 = require("fs");
+var import_path2 = require("path");
+async function closeService() {
+  const PID_FILE2 = (0, import_path2.join)(HOME_DIR, ".claude-code-router.pid");
+  if (!isServiceRunning()) {
+    console.log("No service is currently running.");
+    return;
+  }
+  if (getReferenceCount() > 0) {
+    return;
+  }
+  try {
+    const pid = parseInt((0, import_fs4.readFileSync)(PID_FILE2, "utf-8"));
+    process.kill(pid);
+    cleanupPidFile();
+    console.log("claude code router service has been successfully stopped.");
+  } catch (e2) {
+    console.log("Failed to stop the service. It may have already been stopped.");
+    cleanupPidFile();
+  }
+}
+
+// src/utils/codeCommand.ts
 async function executeCodeCommand(args = []) {
   const env = {
     ...process.env,
     DISABLE_PROMPT_CACHING: "1",
     ANTHROPIC_AUTH_TOKEN: "test",
-    ANTHROPIC_BASE_URL: "http://127.0.0.1:3456",
+    ANTHROPIC_BASE_URL: `http://127.0.0.1:3456`,
     API_TIMEOUT_MS: "600000"
   };
   incrementReferenceCount();
-  const claudeProcess = (0, import_child_process.spawn)("claude", args, {
+  const claudePath = process.env.CLAUDE_PATH || "claude";
+  const claudeProcess = (0, import_child_process.spawn)(claudePath, args, {
     env,
     stdio: "inherit",
     shell: true
   });
   claudeProcess.on("error", (error) => {
     console.error("Failed to start claude command:", error.message);
-    console.log("Make sure Claude Code is installed: npm install -g @anthropic-ai/claude-code");
+    console.log(
+      "Make sure Claude Code is installed: npm install -g @anthropic-ai/claude-code"
+    );
     decrementReferenceCount();
     process.exit(1);
   });
@@ -37242,10 +39218,11 @@ async function executeCodeCommand(args = []) {
 }
 
 // package.json
-var version = "1.0.1";
+var version = "1.0.5";
 
 // src/cli.ts
 var import_child_process2 = require("child_process");
+var import_fs5 = require("fs");
 var command = process.argv[2];
 var HELP_TEXT = `
 Usage: claude-code [command]
@@ -37280,7 +39257,25 @@ async function main() {
       run();
       break;
     case "stop":
-      await closeService();
+      try {
+        const pid = parseInt((0, import_fs5.readFileSync)(PID_FILE, "utf-8"));
+        process.kill(pid);
+        cleanupPidFile();
+        if ((0, import_fs5.existsSync)(REFERENCE_COUNT_FILE)) {
+          try {
+            require("fs").unlinkSync(REFERENCE_COUNT_FILE);
+          } catch (e2) {
+          }
+        }
+        console.log(
+          "claude code router service has been successfully stopped."
+        );
+      } catch (e2) {
+        console.log(
+          "Failed to stop the service. It may have already been stopped."
+        );
+        cleanupPidFile();
+      }
       break;
     case "status":
       showStatus();