@kevisual/ai 0.0.4 → 0.0.5

package/dist/ai-provider.js

@@ -6263,7 +6263,1224 @@ var init_fileFromPath = __esm(() => {
   };
 });
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/internal/qs/formats.mjs
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/core.js
+var require_core = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory();
+    } else if (typeof define === "function" && define.amd) {
+      define([], factory);
+    } else {
+      root.CryptoJS = factory();
+    }
+  })(exports, function() {
+    var CryptoJS = CryptoJS || function(Math2, undefined2) {
+      var crypto;
+      if (typeof window !== "undefined" && window.crypto) {
+        crypto = window.crypto;
+      }
+      if (typeof self !== "undefined" && self.crypto) {
+        crypto = self.crypto;
+      }
+      if (typeof globalThis !== "undefined" && globalThis.crypto) {
+        crypto = globalThis.crypto;
+      }
+      if (!crypto && typeof window !== "undefined" && window.msCrypto) {
+        crypto = window.msCrypto;
+      }
+      if (!crypto && typeof global !== "undefined" && global.crypto) {
+        crypto = global.crypto;
+      }
+      if (!crypto && true) {
+        try {
+          crypto = __require("crypto");
+        } catch (err) {}
+      }
+      var cryptoSecureRandomInt = function() {
+        if (crypto) {
+          if (typeof crypto.getRandomValues === "function") {
+            try {
+              return crypto.getRandomValues(new Uint32Array(1))[0];
+            } catch (err) {}
+          }
+          if (typeof crypto.randomBytes === "function") {
+            try {
+              return crypto.randomBytes(4).readInt32LE();
+            } catch (err) {}
+          }
+        }
+        throw new Error("Native crypto module could not be used to get secure random number.");
+      };
+      var create = Object.create || function() {
+        function F2() {}
+        return function(obj) {
+          var subtype;
+          F2.prototype = obj;
+          subtype = new F2;
+          F2.prototype = null;
+          return subtype;
+        };
+      }();
+      var C2 = {};
+      var C_lib = C2.lib = {};
+      var Base = C_lib.Base = function() {
+        return {
+          extend: function(overrides) {
+            var subtype = create(this);
+            if (overrides) {
+              subtype.mixIn(overrides);
+            }
+            if (!subtype.hasOwnProperty("init") || this.init === subtype.init) {
+              subtype.init = function() {
+                subtype.$super.init.apply(this, arguments);
+              };
+            }
+            subtype.init.prototype = subtype;
+            subtype.$super = this;
+            return subtype;
+          },
+          create: function() {
+            var instance = this.extend();
+            instance.init.apply(instance, arguments);
+            return instance;
+          },
+          init: function() {},
+          mixIn: function(properties) {
+            for (var propertyName in properties) {
+              if (properties.hasOwnProperty(propertyName)) {
+                this[propertyName] = properties[propertyName];
+              }
+            }
+            if (properties.hasOwnProperty("toString")) {
+              this.toString = properties.toString;
+            }
+          },
+          clone: function() {
+            return this.init.prototype.extend(this);
+          }
+        };
+      }();
+      var WordArray = C_lib.WordArray = Base.extend({
+        init: function(words, sigBytes) {
+          words = this.words = words || [];
+          if (sigBytes != undefined2) {
+            this.sigBytes = sigBytes;
+          } else {
+            this.sigBytes = words.length * 4;
+          }
+        },
+        toString: function(encoder) {
+          return (encoder || Hex).stringify(this);
+        },
+        concat: function(wordArray) {
+          var thisWords = this.words;
+          var thatWords = wordArray.words;
+          var thisSigBytes = this.sigBytes;
+          var thatSigBytes = wordArray.sigBytes;
+          this.clamp();
+          if (thisSigBytes % 4) {
+            for (var i2 = 0;i2 < thatSigBytes; i2++) {
+              var thatByte = thatWords[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+              thisWords[thisSigBytes + i2 >>> 2] |= thatByte << 24 - (thisSigBytes + i2) % 4 * 8;
+            }
+          } else {
+            for (var j2 = 0;j2 < thatSigBytes; j2 += 4) {
+              thisWords[thisSigBytes + j2 >>> 2] = thatWords[j2 >>> 2];
+            }
+          }
+          this.sigBytes += thatSigBytes;
+          return this;
+        },
+        clamp: function() {
+          var words = this.words;
+          var sigBytes = this.sigBytes;
+          words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
+          words.length = Math2.ceil(sigBytes / 4);
+        },
+        clone: function() {
+          var clone = Base.clone.call(this);
+          clone.words = this.words.slice(0);
+          return clone;
+        },
+        random: function(nBytes) {
+          var words = [];
+          for (var i2 = 0;i2 < nBytes; i2 += 4) {
+            words.push(cryptoSecureRandomInt());
+          }
+          return new WordArray.init(words, nBytes);
+        }
+      });
+      var C_enc = C2.enc = {};
+      var Hex = C_enc.Hex = {
+        stringify: function(wordArray) {
+          var words = wordArray.words;
+          var sigBytes = wordArray.sigBytes;
+          var hexChars = [];
+          for (var i2 = 0;i2 < sigBytes; i2++) {
+            var bite = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+            hexChars.push((bite >>> 4).toString(16));
+            hexChars.push((bite & 15).toString(16));
+          }
+          return hexChars.join("");
+        },
+        parse: function(hexStr) {
+          var hexStrLength = hexStr.length;
+          var words = [];
+          for (var i2 = 0;i2 < hexStrLength; i2 += 2) {
+            words[i2 >>> 3] |= parseInt(hexStr.substr(i2, 2), 16) << 24 - i2 % 8 * 4;
+          }
+          return new WordArray.init(words, hexStrLength / 2);
+        }
+      };
+      var Latin1 = C_enc.Latin1 = {
+        stringify: function(wordArray) {
+          var words = wordArray.words;
+          var sigBytes = wordArray.sigBytes;
+          var latin1Chars = [];
+          for (var i2 = 0;i2 < sigBytes; i2++) {
+            var bite = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+            latin1Chars.push(String.fromCharCode(bite));
+          }
+          return latin1Chars.join("");
+        },
+        parse: function(latin1Str) {
+          var latin1StrLength = latin1Str.length;
+          var words = [];
+          for (var i2 = 0;i2 < latin1StrLength; i2++) {
+            words[i2 >>> 2] |= (latin1Str.charCodeAt(i2) & 255) << 24 - i2 % 4 * 8;
+          }
+          return new WordArray.init(words, latin1StrLength);
+        }
+      };
+      var Utf8 = C_enc.Utf8 = {
+        stringify: function(wordArray) {
+          try {
+            return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+          } catch (e2) {
+            throw new Error("Malformed UTF-8 data");
+          }
+        },
+        parse: function(utf8Str) {
+          return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+        }
+      };
+      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+        reset: function() {
+          this._data = new WordArray.init;
+          this._nDataBytes = 0;
+        },
+        _append: function(data) {
+          if (typeof data == "string") {
+            data = Utf8.parse(data);
+          }
+          this._data.concat(data);
+          this._nDataBytes += data.sigBytes;
+        },
+        _process: function(doFlush) {
+          var processedWords;
+          var data = this._data;
+          var dataWords = data.words;
+          var dataSigBytes = data.sigBytes;
+          var blockSize = this.blockSize;
+          var blockSizeBytes = blockSize * 4;
+          var nBlocksReady = dataSigBytes / blockSizeBytes;
+          if (doFlush) {
+            nBlocksReady = Math2.ceil(nBlocksReady);
+          } else {
+            nBlocksReady = Math2.max((nBlocksReady | 0) - this._minBufferSize, 0);
+          }
+          var nWordsReady = nBlocksReady * blockSize;
+          var nBytesReady = Math2.min(nWordsReady * 4, dataSigBytes);
+          if (nWordsReady) {
+            for (var offset = 0;offset < nWordsReady; offset += blockSize) {
+              this._doProcessBlock(dataWords, offset);
+            }
+            processedWords = dataWords.splice(0, nWordsReady);
+            data.sigBytes -= nBytesReady;
+          }
+          return new WordArray.init(processedWords, nBytesReady);
+        },
+        clone: function() {
+          var clone = Base.clone.call(this);
+          clone._data = this._data.clone();
+          return clone;
+        },
+        _minBufferSize: 0
+      });
+      var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+        cfg: Base.extend(),
+        init: function(cfg) {
+          this.cfg = this.cfg.extend(cfg);
+          this.reset();
+        },
+        reset: function() {
+          BufferedBlockAlgorithm.reset.call(this);
+          this._doReset();
+        },
+        update: function(messageUpdate) {
+          this._append(messageUpdate);
+          this._process();
+          return this;
+        },
+        finalize: function(messageUpdate) {
+          if (messageUpdate) {
+            this._append(messageUpdate);
+          }
+          var hash = this._doFinalize();
+          return hash;
+        },
+        blockSize: 512 / 32,
+        _createHelper: function(hasher) {
+          return function(message, cfg) {
+            return new hasher.init(cfg).finalize(message);
+          };
+        },
+        _createHmacHelper: function(hasher) {
+          return function(message, key) {
+            return new C_algo.HMAC.init(hasher, key).finalize(message);
+          };
+        }
+      });
+      var C_algo = C2.algo = {};
+      return C2;
+    }(Math);
+    return CryptoJS;
+  });
+});
+
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/enc-base64.js
+var require_enc_base64 = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C2 = CryptoJS;
+      var C_lib = C2.lib;
+      var WordArray = C_lib.WordArray;
+      var C_enc = C2.enc;
+      var Base64 = C_enc.Base64 = {
+        stringify: function(wordArray) {
+          var words = wordArray.words;
+          var sigBytes = wordArray.sigBytes;
+          var map = this._map;
+          wordArray.clamp();
+          var base64Chars = [];
+          for (var i2 = 0;i2 < sigBytes; i2 += 3) {
+            var byte1 = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+            var byte2 = words[i2 + 1 >>> 2] >>> 24 - (i2 + 1) % 4 * 8 & 255;
+            var byte3 = words[i2 + 2 >>> 2] >>> 24 - (i2 + 2) % 4 * 8 & 255;
+            var triplet = byte1 << 16 | byte2 << 8 | byte3;
+            for (var j2 = 0;j2 < 4 && i2 + j2 * 0.75 < sigBytes; j2++) {
+              base64Chars.push(map.charAt(triplet >>> 6 * (3 - j2) & 63));
+            }
+          }
+          var paddingChar = map.charAt(64);
+          if (paddingChar) {
+            while (base64Chars.length % 4) {
+              base64Chars.push(paddingChar);
+            }
+          }
+          return base64Chars.join("");
+        },
+        parse: function(base64Str) {
+          var base64StrLength = base64Str.length;
+          var map = this._map;
+          var reverseMap = this._reverseMap;
+          if (!reverseMap) {
+            reverseMap = this._reverseMap = [];
+            for (var j2 = 0;j2 < map.length; j2++) {
+              reverseMap[map.charCodeAt(j2)] = j2;
+            }
+          }
+          var paddingChar = map.charAt(64);
+          if (paddingChar) {
+            var paddingIndex = base64Str.indexOf(paddingChar);
+            if (paddingIndex !== -1) {
+              base64StrLength = paddingIndex;
+            }
+          }
+          return parseLoop(base64Str, base64StrLength, reverseMap);
+        },
+        _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+      };
+      function parseLoop(base64Str, base64StrLength, reverseMap) {
+        var words = [];
+        var nBytes = 0;
+        for (var i2 = 0;i2 < base64StrLength; i2++) {
+          if (i2 % 4) {
+            var bits1 = reverseMap[base64Str.charCodeAt(i2 - 1)] << i2 % 4 * 2;
+            var bits2 = reverseMap[base64Str.charCodeAt(i2)] >>> 6 - i2 % 4 * 2;
+            var bitsCombined = bits1 | bits2;
+            words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
+            nBytes++;
+          }
+        }
+        return WordArray.create(words, nBytes);
+      }
+    })();
+    return CryptoJS.enc.Base64;
+  });
+});
+
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/md5.js
+var require_md5 = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function(Math2) {
+      var C2 = CryptoJS;
+      var C_lib = C2.lib;
+      var WordArray = C_lib.WordArray;
+      var Hasher = C_lib.Hasher;
+      var C_algo = C2.algo;
+      var T2 = [];
+      (function() {
+        for (var i2 = 0;i2 < 64; i2++) {
+          T2[i2] = Math2.abs(Math2.sin(i2 + 1)) * 4294967296 | 0;
+        }
+      })();
+      var MD5 = C_algo.MD5 = Hasher.extend({
+        _doReset: function() {
+          this._hash = new WordArray.init([
+            1732584193,
+            4023233417,
+            2562383102,
+            271733878
+          ]);
+        },
+        _doProcessBlock: function(M2, offset) {
+          for (var i2 = 0;i2 < 16; i2++) {
+            var offset_i = offset + i2;
+            var M_offset_i = M2[offset_i];
+            M2[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
+          }
+          var H2 = this._hash.words;
+          var M_offset_0 = M2[offset + 0];
+          var M_offset_1 = M2[offset + 1];
+          var M_offset_2 = M2[offset + 2];
+          var M_offset_3 = M2[offset + 3];
+          var M_offset_4 = M2[offset + 4];
+          var M_offset_5 = M2[offset + 5];
+          var M_offset_6 = M2[offset + 6];
+          var M_offset_7 = M2[offset + 7];
+          var M_offset_8 = M2[offset + 8];
+          var M_offset_9 = M2[offset + 9];
+          var M_offset_10 = M2[offset + 10];
+          var M_offset_11 = M2[offset + 11];
+          var M_offset_12 = M2[offset + 12];
+          var M_offset_13 = M2[offset + 13];
+          var M_offset_14 = M2[offset + 14];
+          var M_offset_15 = M2[offset + 15];
+          var a2 = H2[0];
+          var b2 = H2[1];
+          var c2 = H2[2];
+          var d2 = H2[3];
+          a2 = FF(a2, b2, c2, d2, M_offset_0, 7, T2[0]);
+          d2 = FF(d2, a2, b2, c2, M_offset_1, 12, T2[1]);
+          c2 = FF(c2, d2, a2, b2, M_offset_2, 17, T2[2]);
+          b2 = FF(b2, c2, d2, a2, M_offset_3, 22, T2[3]);
+          a2 = FF(a2, b2, c2, d2, M_offset_4, 7, T2[4]);
+          d2 = FF(d2, a2, b2, c2, M_offset_5, 12, T2[5]);
+          c2 = FF(c2, d2, a2, b2, M_offset_6, 17, T2[6]);
+          b2 = FF(b2, c2, d2, a2, M_offset_7, 22, T2[7]);
+          a2 = FF(a2, b2, c2, d2, M_offset_8, 7, T2[8]);
+          d2 = FF(d2, a2, b2, c2, M_offset_9, 12, T2[9]);
+          c2 = FF(c2, d2, a2, b2, M_offset_10, 17, T2[10]);
+          b2 = FF(b2, c2, d2, a2, M_offset_11, 22, T2[11]);
+          a2 = FF(a2, b2, c2, d2, M_offset_12, 7, T2[12]);
+          d2 = FF(d2, a2, b2, c2, M_offset_13, 12, T2[13]);
+          c2 = FF(c2, d2, a2, b2, M_offset_14, 17, T2[14]);
+          b2 = FF(b2, c2, d2, a2, M_offset_15, 22, T2[15]);
+          a2 = GG(a2, b2, c2, d2, M_offset_1, 5, T2[16]);
+          d2 = GG(d2, a2, b2, c2, M_offset_6, 9, T2[17]);
+          c2 = GG(c2, d2, a2, b2, M_offset_11, 14, T2[18]);
+          b2 = GG(b2, c2, d2, a2, M_offset_0, 20, T2[19]);
+          a2 = GG(a2, b2, c2, d2, M_offset_5, 5, T2[20]);
+          d2 = GG(d2, a2, b2, c2, M_offset_10, 9, T2[21]);
+          c2 = GG(c2, d2, a2, b2, M_offset_15, 14, T2[22]);
+          b2 = GG(b2, c2, d2, a2, M_offset_4, 20, T2[23]);
+          a2 = GG(a2, b2, c2, d2, M_offset_9, 5, T2[24]);
+          d2 = GG(d2, a2, b2, c2, M_offset_14, 9, T2[25]);
+          c2 = GG(c2, d2, a2, b2, M_offset_3, 14, T2[26]);
+          b2 = GG(b2, c2, d2, a2, M_offset_8, 20, T2[27]);
+          a2 = GG(a2, b2, c2, d2, M_offset_13, 5, T2[28]);
+          d2 = GG(d2, a2, b2, c2, M_offset_2, 9, T2[29]);
+          c2 = GG(c2, d2, a2, b2, M_offset_7, 14, T2[30]);
+          b2 = GG(b2, c2, d2, a2, M_offset_12, 20, T2[31]);
+          a2 = HH(a2, b2, c2, d2, M_offset_5, 4, T2[32]);
+          d2 = HH(d2, a2, b2, c2, M_offset_8, 11, T2[33]);
+          c2 = HH(c2, d2, a2, b2, M_offset_11, 16, T2[34]);
+          b2 = HH(b2, c2, d2, a2, M_offset_14, 23, T2[35]);
+          a2 = HH(a2, b2, c2, d2, M_offset_1, 4, T2[36]);
+          d2 = HH(d2, a2, b2, c2, M_offset_4, 11, T2[37]);
+          c2 = HH(c2, d2, a2, b2, M_offset_7, 16, T2[38]);
+          b2 = HH(b2, c2, d2, a2, M_offset_10, 23, T2[39]);
+          a2 = HH(a2, b2, c2, d2, M_offset_13, 4, T2[40]);
+          d2 = HH(d2, a2, b2, c2, M_offset_0, 11, T2[41]);
+          c2 = HH(c2, d2, a2, b2, M_offset_3, 16, T2[42]);
+          b2 = HH(b2, c2, d2, a2, M_offset_6, 23, T2[43]);
+          a2 = HH(a2, b2, c2, d2, M_offset_9, 4, T2[44]);
+          d2 = HH(d2, a2, b2, c2, M_offset_12, 11, T2[45]);
+          c2 = HH(c2, d2, a2, b2, M_offset_15, 16, T2[46]);
+          b2 = HH(b2, c2, d2, a2, M_offset_2, 23, T2[47]);
+          a2 = II(a2, b2, c2, d2, M_offset_0, 6, T2[48]);
+          d2 = II(d2, a2, b2, c2, M_offset_7, 10, T2[49]);
+          c2 = II(c2, d2, a2, b2, M_offset_14, 15, T2[50]);
+          b2 = II(b2, c2, d2, a2, M_offset_5, 21, T2[51]);
+          a2 = II(a2, b2, c2, d2, M_offset_12, 6, T2[52]);
+          d2 = II(d2, a2, b2, c2, M_offset_3, 10, T2[53]);
+          c2 = II(c2, d2, a2, b2, M_offset_10, 15, T2[54]);
+          b2 = II(b2, c2, d2, a2, M_offset_1, 21, T2[55]);
+          a2 = II(a2, b2, c2, d2, M_offset_8, 6, T2[56]);
+          d2 = II(d2, a2, b2, c2, M_offset_15, 10, T2[57]);
+          c2 = II(c2, d2, a2, b2, M_offset_6, 15, T2[58]);
+          b2 = II(b2, c2, d2, a2, M_offset_13, 21, T2[59]);
+          a2 = II(a2, b2, c2, d2, M_offset_4, 6, T2[60]);
+          d2 = II(d2, a2, b2, c2, M_offset_11, 10, T2[61]);
+          c2 = II(c2, d2, a2, b2, M_offset_2, 15, T2[62]);
+          b2 = II(b2, c2, d2, a2, M_offset_9, 21, T2[63]);
+          H2[0] = H2[0] + a2 | 0;
+          H2[1] = H2[1] + b2 | 0;
+          H2[2] = H2[2] + c2 | 0;
+          H2[3] = H2[3] + d2 | 0;
+        },
+        _doFinalize: function() {
+          var data = this._data;
+          var dataWords = data.words;
+          var nBitsTotal = this._nDataBytes * 8;
+          var nBitsLeft = data.sigBytes * 8;
+          dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+          var nBitsTotalH = Math2.floor(nBitsTotal / 4294967296);
+          var nBitsTotalL = nBitsTotal;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
+          data.sigBytes = (dataWords.length + 1) * 4;
+          this._process();
+          var hash = this._hash;
+          var H2 = hash.words;
+          for (var i2 = 0;i2 < 4; i2++) {
+            var H_i = H2[i2];
+            H2[i2] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
+          }
+          return hash;
+        },
+        clone: function() {
+          var clone = Hasher.clone.call(this);
+          clone._hash = this._hash.clone();
+          return clone;
+        }
+      });
+      function FF(a2, b2, c2, d2, x2, s2, t2) {
+        var n2 = a2 + (b2 & c2 | ~b2 & d2) + x2 + t2;
+        return (n2 << s2 | n2 >>> 32 - s2) + b2;
+      }
+      function GG(a2, b2, c2, d2, x2, s2, t2) {
+        var n2 = a2 + (b2 & d2 | c2 & ~d2) + x2 + t2;
+        return (n2 << s2 | n2 >>> 32 - s2) + b2;
+      }
+      function HH(a2, b2, c2, d2, x2, s2, t2) {
+        var n2 = a2 + (b2 ^ c2 ^ d2) + x2 + t2;
+        return (n2 << s2 | n2 >>> 32 - s2) + b2;
+      }
+      function II(a2, b2, c2, d2, x2, s2, t2) {
+        var n2 = a2 + (c2 ^ (b2 | ~d2)) + x2 + t2;
+        return (n2 << s2 | n2 >>> 32 - s2) + b2;
+      }
+      C2.MD5 = Hasher._createHelper(MD5);
+      C2.HmacMD5 = Hasher._createHmacHelper(MD5);
+    })(Math);
+    return CryptoJS.MD5;
+  });
+});
+
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/sha1.js
+var require_sha1 = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C2 = CryptoJS;
+      var C_lib = C2.lib;
+      var WordArray = C_lib.WordArray;
+      var Hasher = C_lib.Hasher;
+      var C_algo = C2.algo;
+      var W2 = [];
+      var SHA1 = C_algo.SHA1 = Hasher.extend({
+        _doReset: function() {
+          this._hash = new WordArray.init([
+            1732584193,
+            4023233417,
+            2562383102,
+            271733878,
+            3285377520
+          ]);
+        },
+        _doProcessBlock: function(M2, offset) {
+          var H2 = this._hash.words;
+          var a2 = H2[0];
+          var b2 = H2[1];
+          var c2 = H2[2];
+          var d2 = H2[3];
+          var e2 = H2[4];
+          for (var i2 = 0;i2 < 80; i2++) {
+            if (i2 < 16) {
+              W2[i2] = M2[offset + i2] | 0;
+            } else {
+              var n2 = W2[i2 - 3] ^ W2[i2 - 8] ^ W2[i2 - 14] ^ W2[i2 - 16];
+              W2[i2] = n2 << 1 | n2 >>> 31;
+            }
+            var t2 = (a2 << 5 | a2 >>> 27) + e2 + W2[i2];
+            if (i2 < 20) {
+              t2 += (b2 & c2 | ~b2 & d2) + 1518500249;
+            } else if (i2 < 40) {
+              t2 += (b2 ^ c2 ^ d2) + 1859775393;
+            } else if (i2 < 60) {
+              t2 += (b2 & c2 | b2 & d2 | c2 & d2) - 1894007588;
+            } else {
+              t2 += (b2 ^ c2 ^ d2) - 899497514;
+            }
+            e2 = d2;
+            d2 = c2;
+            c2 = b2 << 30 | b2 >>> 2;
+            b2 = a2;
+            a2 = t2;
+          }
+          H2[0] = H2[0] + a2 | 0;
+          H2[1] = H2[1] + b2 | 0;
+          H2[2] = H2[2] + c2 | 0;
+          H2[3] = H2[3] + d2 | 0;
+          H2[4] = H2[4] + e2 | 0;
+        },
+        _doFinalize: function() {
+          var data = this._data;
+          var dataWords = data.words;
+          var nBitsTotal = this._nDataBytes * 8;
+          var nBitsLeft = data.sigBytes * 8;
+          dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296);
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+          data.sigBytes = dataWords.length * 4;
+          this._process();
+          return this._hash;
+        },
+        clone: function() {
+          var clone = Hasher.clone.call(this);
+          clone._hash = this._hash.clone();
+          return clone;
+        }
+      });
+      C2.SHA1 = Hasher._createHelper(SHA1);
+      C2.HmacSHA1 = Hasher._createHmacHelper(SHA1);
+    })();
+    return CryptoJS.SHA1;
+  });
+});
+
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/hmac.js
+var require_hmac = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C2 = CryptoJS;
+      var C_lib = C2.lib;
+      var Base = C_lib.Base;
+      var C_enc = C2.enc;
+      var Utf8 = C_enc.Utf8;
+      var C_algo = C2.algo;
+      var HMAC = C_algo.HMAC = Base.extend({
+        init: function(hasher, key) {
+          hasher = this._hasher = new hasher.init;
+          if (typeof key == "string") {
+            key = Utf8.parse(key);
+          }
+          var hasherBlockSize = hasher.blockSize;
+          var hasherBlockSizeBytes = hasherBlockSize * 4;
+          if (key.sigBytes > hasherBlockSizeBytes) {
+            key = hasher.finalize(key);
+          }
+          key.clamp();
+          var oKey = this._oKey = key.clone();
+          var iKey = this._iKey = key.clone();
+          var oKeyWords = oKey.words;
+          var iKeyWords = iKey.words;
+          for (var i2 = 0;i2 < hasherBlockSize; i2++) {
+            oKeyWords[i2] ^= 1549556828;
+            iKeyWords[i2] ^= 909522486;
+          }
+          oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
+          this.reset();
+        },
+        reset: function() {
+          var hasher = this._hasher;
+          hasher.reset();
+          hasher.update(this._iKey);
+        },
+        update: function(messageUpdate) {
+          this._hasher.update(messageUpdate);
+          return this;
+        },
+        finalize: function(messageUpdate) {
+          var hasher = this._hasher;
+          var innerHash = hasher.finalize(messageUpdate);
+          hasher.reset();
+          var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
+          return hmac;
+        }
+      });
+    })();
+  });
+});
+
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/evpkdf.js
+var require_evpkdf = __commonJS((exports, module) => {
+  (function(root, factory, undef) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core(), require_sha1(), require_hmac());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core", "./sha1", "./hmac"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C2 = CryptoJS;
+      var C_lib = C2.lib;
+      var Base = C_lib.Base;
+      var WordArray = C_lib.WordArray;
+      var C_algo = C2.algo;
+      var MD5 = C_algo.MD5;
+      var EvpKDF = C_algo.EvpKDF = Base.extend({
+        cfg: Base.extend({
+          keySize: 128 / 32,
+          hasher: MD5,
+          iterations: 1
+        }),
+        init: function(cfg) {
+          this.cfg = this.cfg.extend(cfg);
+        },
+        compute: function(password, salt) {
+          var block;
+          var cfg = this.cfg;
+          var hasher = cfg.hasher.create();
+          var derivedKey = WordArray.create();
+          var derivedKeyWords = derivedKey.words;
+          var keySize = cfg.keySize;
+          var iterations = cfg.iterations;
+          while (derivedKeyWords.length < keySize) {
+            if (block) {
+              hasher.update(block);
+            }
+            block = hasher.update(password).finalize(salt);
+            hasher.reset();
+            for (var i2 = 1;i2 < iterations; i2++) {
+              block = hasher.finalize(block);
+              hasher.reset();
+            }
+            derivedKey.concat(block);
+          }
+          derivedKey.sigBytes = keySize * 4;
+          return derivedKey;
+        }
+      });
+      C2.EvpKDF = function(password, salt, cfg) {
+        return EvpKDF.create(cfg).compute(password, salt);
+      };
+    })();
+    return CryptoJS.EvpKDF;
+  });
+});
+
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/cipher-core.js
+var require_cipher_core = __commonJS((exports, module) => {
+  (function(root, factory, undef) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core(), require_evpkdf());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core", "./evpkdf"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    CryptoJS.lib.Cipher || function(undefined2) {
+      var C2 = CryptoJS;
+      var C_lib = C2.lib;
+      var Base = C_lib.Base;
+      var WordArray = C_lib.WordArray;
+      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
+      var C_enc = C2.enc;
+      var Utf8 = C_enc.Utf8;
+      var Base64 = C_enc.Base64;
+      var C_algo = C2.algo;
+      var EvpKDF = C_algo.EvpKDF;
+      var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
+        cfg: Base.extend(),
+        createEncryptor: function(key, cfg) {
+          return this.create(this._ENC_XFORM_MODE, key, cfg);
+        },
+        createDecryptor: function(key, cfg) {
+          return this.create(this._DEC_XFORM_MODE, key, cfg);
+        },
+        init: function(xformMode, key, cfg) {
+          this.cfg = this.cfg.extend(cfg);
+          this._xformMode = xformMode;
+          this._key = key;
+          this.reset();
+        },
+        reset: function() {
+          BufferedBlockAlgorithm.reset.call(this);
+          this._doReset();
+        },
+        process: function(dataUpdate) {
+          this._append(dataUpdate);
+          return this._process();
+        },
+        finalize: function(dataUpdate) {
+          if (dataUpdate) {
+            this._append(dataUpdate);
+          }
+          var finalProcessedData = this._doFinalize();
+          return finalProcessedData;
+        },
+        keySize: 128 / 32,
+        ivSize: 128 / 32,
+        _ENC_XFORM_MODE: 1,
+        _DEC_XFORM_MODE: 2,
+        _createHelper: function() {
+          function selectCipherStrategy(key) {
+            if (typeof key == "string") {
+              return PasswordBasedCipher;
+            } else {
+              return SerializableCipher;
+            }
+          }
+          return function(cipher) {
+            return {
+              encrypt: function(message, key, cfg) {
+                return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
+              },
+              decrypt: function(ciphertext, key, cfg) {
+                return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
+              }
+            };
+          };
+        }()
+      });
+      var StreamCipher = C_lib.StreamCipher = Cipher.extend({
+        _doFinalize: function() {
+          var finalProcessedBlocks = this._process(true);
+          return finalProcessedBlocks;
+        },
+        blockSize: 1
+      });
+      var C_mode = C2.mode = {};
+      var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
+        createEncryptor: function(cipher, iv) {
+          return this.Encryptor.create(cipher, iv);
+        },
+        createDecryptor: function(cipher, iv) {
+          return this.Decryptor.create(cipher, iv);
+        },
+        init: function(cipher, iv) {
+          this._cipher = cipher;
+          this._iv = iv;
+        }
+      });
+      var CBC = C_mode.CBC = function() {
+        var CBC2 = BlockCipherMode.extend();
+        CBC2.Encryptor = CBC2.extend({
+          processBlock: function(words, offset) {
+            var cipher = this._cipher;
+            var blockSize = cipher.blockSize;
+            xorBlock.call(this, words, offset, blockSize);
+            cipher.encryptBlock(words, offset);
+            this._prevBlock = words.slice(offset, offset + blockSize);
+          }
+        });
+        CBC2.Decryptor = CBC2.extend({
+          processBlock: function(words, offset) {
+            var cipher = this._cipher;
+            var blockSize = cipher.blockSize;
+            var thisBlock = words.slice(offset, offset + blockSize);
+            cipher.decryptBlock(words, offset);
+            xorBlock.call(this, words, offset, blockSize);
+            this._prevBlock = thisBlock;
+          }
+        });
+        function xorBlock(words, offset, blockSize) {
+          var block;
+          var iv = this._iv;
+          if (iv) {
+            block = iv;
+            this._iv = undefined2;
+          } else {
+            block = this._prevBlock;
+          }
+          for (var i2 = 0;i2 < blockSize; i2++) {
+            words[offset + i2] ^= block[i2];
+          }
+        }
+        return CBC2;
+      }();
+      var C_pad = C2.pad = {};
+      var Pkcs7 = C_pad.Pkcs7 = {
+        pad: function(data, blockSize) {
+          var blockSizeBytes = blockSize * 4;
+          var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+          var paddingWord = nPaddingBytes << 24 | nPaddingBytes << 16 | nPaddingBytes << 8 | nPaddingBytes;
+          var paddingWords = [];
+          for (var i2 = 0;i2 < nPaddingBytes; i2 += 4) {
+            paddingWords.push(paddingWord);
+          }
+          var padding = WordArray.create(paddingWords, nPaddingBytes);
+          data.concat(padding);
+        },
+        unpad: function(data) {
+          var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
+          data.sigBytes -= nPaddingBytes;
+        }
+      };
+      var BlockCipher = C_lib.BlockCipher = Cipher.extend({
+        cfg: Cipher.cfg.extend({
+          mode: CBC,
+          padding: Pkcs7
+        }),
+        reset: function() {
+          var modeCreator;
+          Cipher.reset.call(this);
+          var cfg = this.cfg;
+          var iv = cfg.iv;
+          var mode = cfg.mode;
+          if (this._xformMode == this._ENC_XFORM_MODE) {
+            modeCreator = mode.createEncryptor;
+          } else {
+            modeCreator = mode.createDecryptor;
+            this._minBufferSize = 1;
+          }
+          if (this._mode && this._mode.__creator == modeCreator) {
+            this._mode.init(this, iv && iv.words);
+          } else {
+            this._mode = modeCreator.call(mode, this, iv && iv.words);
+            this._mode.__creator = modeCreator;
+          }
+        },
+        _doProcessBlock: function(words, offset) {
+          this._mode.processBlock(words, offset);
+        },
+        _doFinalize: function() {
+          var finalProcessedBlocks;
+          var padding = this.cfg.padding;
+          if (this._xformMode == this._ENC_XFORM_MODE) {
+            padding.pad(this._data, this.blockSize);
+            finalProcessedBlocks = this._process(true);
+          } else {
+            finalProcessedBlocks = this._process(true);
+            padding.unpad(finalProcessedBlocks);
+          }
+          return finalProcessedBlocks;
+        },
+        blockSize: 128 / 32
+      });
+      var CipherParams = C_lib.CipherParams = Base.extend({
+        init: function(cipherParams) {
+          this.mixIn(cipherParams);
+        },
+        toString: function(formatter) {
+          return (formatter || this.formatter).stringify(this);
+        }
+      });
+      var C_format = C2.format = {};
+      var OpenSSLFormatter = C_format.OpenSSL = {
+        stringify: function(cipherParams) {
+          var wordArray;
+          var ciphertext = cipherParams.ciphertext;
+          var salt = cipherParams.salt;
+          if (salt) {
+            wordArray = WordArray.create([1398893684, 1701076831]).concat(salt).concat(ciphertext);
+          } else {
+            wordArray = ciphertext;
+          }
+          return wordArray.toString(Base64);
+        },
+        parse: function(openSSLStr) {
+          var salt;
+          var ciphertext = Base64.parse(openSSLStr);
+          var ciphertextWords = ciphertext.words;
+          if (ciphertextWords[0] == 1398893684 && ciphertextWords[1] == 1701076831) {
+            salt = WordArray.create(ciphertextWords.slice(2, 4));
+            ciphertextWords.splice(0, 4);
+            ciphertext.sigBytes -= 16;
+          }
+          return CipherParams.create({ ciphertext, salt });
+        }
+      };
+      var SerializableCipher = C_lib.SerializableCipher = Base.extend({
+        cfg: Base.extend({
+          format: OpenSSLFormatter
+        }),
+        encrypt: function(cipher, message, key, cfg) {
+          cfg = this.cfg.extend(cfg);
+          var encryptor = cipher.createEncryptor(key, cfg);
+          var ciphertext = encryptor.finalize(message);
+          var cipherCfg = encryptor.cfg;
+          return CipherParams.create({
+            ciphertext,
+            key,
+            iv: cipherCfg.iv,
+            algorithm: cipher,
+            mode: cipherCfg.mode,
+            padding: cipherCfg.padding,
+            blockSize: cipher.blockSize,
+            formatter: cfg.format
+          });
+        },
+        decrypt: function(cipher, ciphertext, key, cfg) {
+          cfg = this.cfg.extend(cfg);
+          ciphertext = this._parse(ciphertext, cfg.format);
+          var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
+          return plaintext;
+        },
+        _parse: function(ciphertext, format) {
+          if (typeof ciphertext == "string") {
+            return format.parse(ciphertext, this);
+          } else {
+            return ciphertext;
+          }
+        }
+      });
+      var C_kdf = C2.kdf = {};
+      var OpenSSLKdf = C_kdf.OpenSSL = {
+        execute: function(password, keySize, ivSize, salt, hasher) {
+          if (!salt) {
+            salt = WordArray.random(64 / 8);
+          }
+          if (!hasher) {
+            var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
+          } else {
+            var key = EvpKDF.create({ keySize: keySize + ivSize, hasher }).compute(password, salt);
+          }
+          var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
+          key.sigBytes = keySize * 4;
+          return CipherParams.create({ key, iv, salt });
+        }
+      };
+      var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
+        cfg: SerializableCipher.cfg.extend({
+          kdf: OpenSSLKdf
+        }),
+        encrypt: function(cipher, message, password, cfg) {
+          cfg = this.cfg.extend(cfg);
+          var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, cfg.salt, cfg.hasher);
+          cfg.iv = derivedParams.iv;
+          var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
+          ciphertext.mixIn(derivedParams);
+          return ciphertext;
+        },
+        decrypt: function(cipher, ciphertext, password, cfg) {
+          cfg = this.cfg.extend(cfg);
+          ciphertext = this._parse(ciphertext, cfg.format);
+          var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt, cfg.hasher);
+          cfg.iv = derivedParams.iv;
+          var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
+          return plaintext;
+        }
+      });
+    }();
+  });
+});
+
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/aes.js
+var require_aes = __commonJS((exports, module) => {
+  (function(root, factory, undef) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core(), require_enc_base64(), require_md5(), require_evpkdf(), require_cipher_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C2 = CryptoJS;
+      var C_lib = C2.lib;
+      var BlockCipher = C_lib.BlockCipher;
+      var C_algo = C2.algo;
+      var SBOX = [];
+      var INV_SBOX = [];
+      var SUB_MIX_0 = [];
+      var SUB_MIX_1 = [];
+      var SUB_MIX_2 = [];
+      var SUB_MIX_3 = [];
+      var INV_SUB_MIX_0 = [];
+      var INV_SUB_MIX_1 = [];
+      var INV_SUB_MIX_2 = [];
+      var INV_SUB_MIX_3 = [];
+      (function() {
+        var d2 = [];
+        for (var i2 = 0;i2 < 256; i2++) {
+          if (i2 < 128) {
+            d2[i2] = i2 << 1;
+          } else {
+            d2[i2] = i2 << 1 ^ 283;
+          }
+        }
+        var x2 = 0;
+        var xi = 0;
+        for (var i2 = 0;i2 < 256; i2++) {
+          var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
+          sx = sx >>> 8 ^ sx & 255 ^ 99;
+          SBOX[x2] = sx;
+          INV_SBOX[sx] = x2;
+          var x22 = d2[x2];
+          var x4 = d2[x22];
+          var x8 = d2[x4];
+          var t2 = d2[sx] * 257 ^ sx * 16843008;
+          SUB_MIX_0[x2] = t2 << 24 | t2 >>> 8;
+          SUB_MIX_1[x2] = t2 << 16 | t2 >>> 16;
+          SUB_MIX_2[x2] = t2 << 8 | t2 >>> 24;
+          SUB_MIX_3[x2] = t2;
+          var t2 = x8 * 16843009 ^ x4 * 65537 ^ x22 * 257 ^ x2 * 16843008;
+          INV_SUB_MIX_0[sx] = t2 << 24 | t2 >>> 8;
+          INV_SUB_MIX_1[sx] = t2 << 16 | t2 >>> 16;
+          INV_SUB_MIX_2[sx] = t2 << 8 | t2 >>> 24;
+          INV_SUB_MIX_3[sx] = t2;
+          if (!x2) {
+            x2 = xi = 1;
+          } else {
+            x2 = x22 ^ d2[d2[d2[x8 ^ x22]]];
+            xi ^= d2[d2[xi]];
+          }
+        }
+      })();
+      var RCON = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54];
+      var AES = C_algo.AES = BlockCipher.extend({
+        _doReset: function() {
+          var t2;
+          if (this._nRounds && this._keyPriorReset === this._key) {
+            return;
+          }
+          var key = this._keyPriorReset = this._key;
+          var keyWords = key.words;
+          var keySize = key.sigBytes / 4;
+          var nRounds = this._nRounds = keySize + 6;
+          var ksRows = (nRounds + 1) * 4;
+          var keySchedule = this._keySchedule = [];
+          for (var ksRow = 0;ksRow < ksRows; ksRow++) {
+            if (ksRow < keySize) {
+              keySchedule[ksRow] = keyWords[ksRow];
+            } else {
+              t2 = keySchedule[ksRow - 1];
+              if (!(ksRow % keySize)) {
+                t2 = t2 << 8 | t2 >>> 24;
+                t2 = SBOX[t2 >>> 24] << 24 | SBOX[t2 >>> 16 & 255] << 16 | SBOX[t2 >>> 8 & 255] << 8 | SBOX[t2 & 255];
+                t2 ^= RCON[ksRow / keySize | 0] << 24;
+              } else if (keySize > 6 && ksRow % keySize == 4) {
+                t2 = SBOX[t2 >>> 24] << 24 | SBOX[t2 >>> 16 & 255] << 16 | SBOX[t2 >>> 8 & 255] << 8 | SBOX[t2 & 255];
+              }
+              keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t2;
+            }
+          }
+          var invKeySchedule = this._invKeySchedule = [];
+          for (var invKsRow = 0;invKsRow < ksRows; invKsRow++) {
+            var ksRow = ksRows - invKsRow;
+            if (invKsRow % 4) {
+              var t2 = keySchedule[ksRow];
+            } else {
+              var t2 = keySchedule[ksRow - 4];
+            }
+            if (invKsRow < 4 || ksRow <= 4) {
+              invKeySchedule[invKsRow] = t2;
+            } else {
+              invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t2 >>> 24]] ^ INV_SUB_MIX_1[SBOX[t2 >>> 16 & 255]] ^ INV_SUB_MIX_2[SBOX[t2 >>> 8 & 255]] ^ INV_SUB_MIX_3[SBOX[t2 & 255]];
+            }
+          }
+        },
+        encryptBlock: function(M2, offset) {
+          this._doCryptBlock(M2, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
+        },
+        decryptBlock: function(M2, offset) {
+          var t2 = M2[offset + 1];
+          M2[offset + 1] = M2[offset + 3];
+          M2[offset + 3] = t2;
+          this._doCryptBlock(M2, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
+          var t2 = M2[offset + 1];
+          M2[offset + 1] = M2[offset + 3];
+          M2[offset + 3] = t2;
+        },
+        _doCryptBlock: function(M2, offset, keySchedule, SUB_MIX_02, SUB_MIX_12, SUB_MIX_22, SUB_MIX_32, SBOX2) {
+          var nRounds = this._nRounds;
+          var s0 = M2[offset] ^ keySchedule[0];
+          var s1 = M2[offset + 1] ^ keySchedule[1];
+          var s2 = M2[offset + 2] ^ keySchedule[2];
+          var s3 = M2[offset + 3] ^ keySchedule[3];
+          var ksRow = 4;
+          for (var round = 1;round < nRounds; round++) {
+            var t0 = SUB_MIX_02[s0 >>> 24] ^ SUB_MIX_12[s1 >>> 16 & 255] ^ SUB_MIX_22[s2 >>> 8 & 255] ^ SUB_MIX_32[s3 & 255] ^ keySchedule[ksRow++];
+            var t1 = SUB_MIX_02[s1 >>> 24] ^ SUB_MIX_12[s2 >>> 16 & 255] ^ SUB_MIX_22[s3 >>> 8 & 255] ^ SUB_MIX_32[s0 & 255] ^ keySchedule[ksRow++];
+            var t2 = SUB_MIX_02[s2 >>> 24] ^ SUB_MIX_12[s3 >>> 16 & 255] ^ SUB_MIX_22[s0 >>> 8 & 255] ^ SUB_MIX_32[s1 & 255] ^ keySchedule[ksRow++];
+            var t3 = SUB_MIX_02[s3 >>> 24] ^ SUB_MIX_12[s0 >>> 16 & 255] ^ SUB_MIX_22[s1 >>> 8 & 255] ^ SUB_MIX_32[s2 & 255] ^ keySchedule[ksRow++];
+            s0 = t0;
+            s1 = t1;
+            s2 = t2;
+            s3 = t3;
+          }
+          var t0 = (SBOX2[s0 >>> 24] << 24 | SBOX2[s1 >>> 16 & 255] << 16 | SBOX2[s2 >>> 8 & 255] << 8 | SBOX2[s3 & 255]) ^ keySchedule[ksRow++];
+          var t1 = (SBOX2[s1 >>> 24] << 24 | SBOX2[s2 >>> 16 & 255] << 16 | SBOX2[s3 >>> 8 & 255] << 8 | SBOX2[s0 & 255]) ^ keySchedule[ksRow++];
+          var t2 = (SBOX2[s2 >>> 24] << 24 | SBOX2[s3 >>> 16 & 255] << 16 | SBOX2[s0 >>> 8 & 255] << 8 | SBOX2[s1 & 255]) ^ keySchedule[ksRow++];
+          var t3 = (SBOX2[s3 >>> 24] << 24 | SBOX2[s0 >>> 16 & 255] << 16 | SBOX2[s1 >>> 8 & 255] << 8 | SBOX2[s2 & 255]) ^ keySchedule[ksRow++];
+          M2[offset] = t0;
+          M2[offset + 1] = t1;
+          M2[offset + 2] = t2;
+          M2[offset + 3] = t3;
+        },
+        keySize: 256 / 32
+      });
+      C2.AES = BlockCipher._createHelper(AES);
+    })();
+    return CryptoJS.AES;
+  });
+});
+
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/enc-utf8.js
+var require_enc_utf8 = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    return CryptoJS.enc.Utf8;
+  });
+});
+
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/internal/qs/formats.mjs
 var default_format = "RFC3986";
 var formatters = {
   RFC1738: (v) => String(v).replace(/%20/g, "+"),
@@ -6271,7 +7488,7 @@ var formatters = {
 };
 var RFC1738 = "RFC1738";
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/internal/qs/utils.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/internal/qs/utils.mjs
 var is_array = Array.isArray;
 var hex_table = (() => {
   const array = [];
@@ -6343,7 +7560,7 @@ function maybe_map(val, fn) {
   return fn(val);
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/internal/qs/stringify.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/internal/qs/stringify.mjs
 var has = Object.prototype.hasOwnProperty;
 var array_prefix_generators = {
   brackets(prefix) {
@@ -6573,10 +7790,10 @@ function stringify(object, opts = {}) {
   }
   return joined.length > 0 ? prefix + joined : "";
 }
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/version.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/version.mjs
 var VERSION = "4.103.0";
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/_shims/registry.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/_shims/registry.mjs
 var auto = false;
 var kind = undefined;
 var fetch = undefined;
@@ -6614,7 +7831,7 @@ function setShims(shims, options = { auto: false }) {
   isFsReadStream = shims.isFsReadStream;
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/_shims/node-runtime.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/_shims/node-runtime.mjs
 var nf = __toESM(require_lib2(), 1);
 
 // ../../node_modules/.pnpm/formdata-node@4.4.1/node_modules/formdata-node/lib/esm/FormData.js
@@ -6754,7 +7971,7 @@ class FormData2 {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/_shims/node-runtime.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/_shims/node-runtime.mjs
 var import_agentkeepalive = __toESM(require_agentkeepalive(), 1);
 var import_abort_controller = __toESM(require_abort_controller(), 1);
 import { ReadStream as FsReadStream } from "node:fs";
@@ -6940,10 +8157,10 @@ class FormDataEncoder {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/_shims/node-runtime.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/_shims/node-runtime.mjs
 import { Readable } from "node:stream";
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/_shims/MultipartBody.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/_shims/MultipartBody.mjs
 class MultipartBody {
   constructor(body) {
     this.body = body;
@@ -6953,7 +8170,7 @@ class MultipartBody {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/_shims/node-runtime.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/_shims/node-runtime.mjs
 import { ReadableStream as ReadableStream3 } from "node:stream/web";
 var fileFromPathWarned = false;
 async function fileFromPath3(path, ...args) {
@@ -6998,14 +8215,14 @@ function getRuntime() {
   };
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/_shims/index.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/_shims/index.mjs
 var init = () => {
   if (!kind)
     setShims(getRuntime(), { auto: true });
 };
 init();
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/error.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/error.mjs
 class OpenAIError extends Error {
 }
 
@@ -7123,7 +8340,7 @@ class ContentFilterFinishReasonError extends OpenAIError {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/internal/decoders/line.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/internal/decoders/line.mjs
 var __classPrivateFieldSet5 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
@@ -7243,7 +8460,7 @@ function findDoubleNewlineIndex(buffer) {
   return -1;
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/internal/stream-utils.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/internal/stream-utils.mjs
 function ReadableStreamToAsyncIterable(stream) {
   if (stream[Symbol.asyncIterator])
     return stream;
@@ -7272,7 +8489,7 @@ function ReadableStreamToAsyncIterable(stream) {
   };
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/streaming.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/streaming.mjs
 class Stream {
   constructor(iterator, controller) {
     this.iterator = iterator;
@@ -7398,12 +8615,12 @@ class Stream {
     ];
   }
   toReadableStream() {
-    const self = this;
+    const self2 = this;
     let iter;
     const encoder = new TextEncoder;
     return new ReadableStream({
       async start() {
-        iter = self[Symbol.asyncIterator]();
+        iter = self2[Symbol.asyncIterator]();
       },
       async pull(ctrl) {
         try {
@@ -7514,7 +8731,7 @@ function partition(str, delimiter) {
   return [str, "", ""];
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/uploads.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/uploads.mjs
 var isResponseLike = (value) => value != null && typeof value === "object" && typeof value.url === "string" && typeof value.blob === "function";
 var isFileLike2 = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number" && isBlobLike(value);
 var isBlobLike = (value) => value != null && typeof value === "object" && typeof value.size === "number" && typeof value.type === "string" && typeof value.text === "function" && typeof value.slice === "function" && typeof value.arrayBuffer === "function";
@@ -7602,7 +8819,7 @@ var addFormValue = async (form, key, value) => {
   }
 };
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/core.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/core.mjs
 var __classPrivateFieldSet6 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
@@ -8309,7 +9526,7 @@ function isObj(obj) {
   return obj != null && typeof obj === "object" && !Array.isArray(obj);
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/pagination.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/pagination.mjs
 class Page extends AbstractPage {
   constructor(client, response, body, options) {
     super(client, response, body, options);
@@ -8366,14 +9583,14 @@ class CursorPage extends AbstractPage {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resource.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resource.mjs
 class APIResource {
   constructor(client) {
     this._client = client;
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/chat/completions/messages.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/chat/completions/messages.mjs
 class Messages extends APIResource {
   list(completionId, query = {}, options) {
     if (isRequestOptions(query)) {
@@ -8383,7 +9600,7 @@ class Messages extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/chat/completions/completions.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/chat/completions/completions.mjs
 class Completions extends APIResource {
   constructor() {
     super(...arguments);
@@ -8417,7 +9634,7 @@ class ChatCompletionStoreMessagesPage extends CursorPage {
 Completions.ChatCompletionsPage = ChatCompletionsPage;
 Completions.Messages = Messages;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/chat/chat.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/chat/chat.mjs
 class Chat extends APIResource {
   constructor() {
     super(...arguments);
@@ -8426,7 +9643,7 @@ class Chat extends APIResource {
 }
 Chat.Completions = Completions;
 Chat.ChatCompletionsPage = ChatCompletionsPage;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/audio/speech.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/audio/speech.mjs
 class Speech extends APIResource {
   create(body, options) {
     return this._client.post("/audio/speech", {
@@ -8438,7 +9655,7 @@ class Speech extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/audio/transcriptions.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/audio/transcriptions.mjs
 class Transcriptions extends APIResource {
   create(body, options) {
     return this._client.post("/audio/transcriptions", multipartFormRequestOptions({
@@ -8450,14 +9667,14 @@ class Transcriptions extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/audio/translations.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/audio/translations.mjs
 class Translations extends APIResource {
   create(body, options) {
     return this._client.post("/audio/translations", multipartFormRequestOptions({ body, ...options, __metadata: { model: body.model } }));
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/audio/audio.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/audio/audio.mjs
 class Audio extends APIResource {
   constructor() {
     super(...arguments);
@@ -8469,7 +9686,7 @@ class Audio extends APIResource {
 Audio.Transcriptions = Transcriptions;
 Audio.Translations = Translations;
 Audio.Speech = Speech;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/batches.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/batches.mjs
 class Batches extends APIResource {
   create(body, options) {
     return this._client.post("/batches", { body, ...options });
@@ -8491,7 +9708,7 @@ class Batches extends APIResource {
 class BatchesPage extends CursorPage {
 }
 Batches.BatchesPage = BatchesPage;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/EventStream.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/EventStream.mjs
 var __classPrivateFieldSet7 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
@@ -8660,7 +9877,7 @@ _EventStream_connectedPromise = new WeakMap, _EventStream_resolveConnectedPromis
   return this._emit("error", new OpenAIError(String(error)));
 };
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/AssistantStream.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/AssistantStream.mjs
 var __classPrivateFieldGet9 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
@@ -9213,7 +10430,7 @@ _AssistantStream_addEvent = function _AssistantStream_addEvent2(event) {
 };
 function assertNever(_x) {}
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/assistants.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/assistants.mjs
 class Assistants extends APIResource {
   create(body, options) {
     return this._client.post("/assistants", {
@@ -9257,12 +10474,12 @@ class AssistantsPage extends CursorPage {
 }
 Assistants.AssistantsPage = AssistantsPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/RunnableFunction.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/RunnableFunction.mjs
 function isRunnableFunctionWithParse(fn) {
   return typeof fn.parse === "function";
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/chatCompletionUtils.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/chatCompletionUtils.mjs
 var isAssistantMessage = (message) => {
   return message?.role === "assistant";
 };
@@ -9273,7 +10490,7 @@ var isToolMessage = (message) => {
   return message?.role === "tool";
 };
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/parser.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/parser.mjs
 function isAutoParsableResponseFormat(response_format) {
   return response_format?.["$brand"] === "auto-parseable-response-format";
 }
@@ -9366,7 +10583,7 @@ function validateInputTools(tools) {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/AbstractChatCompletionRunner.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/AbstractChatCompletionRunner.mjs
 var __classPrivateFieldGet10 = function(receiver, state, kind2, f2) {
   if (kind2 === "a" && !f2)
     throw new TypeError("Private accessor was defined without a getter");
@@ -9699,7 +10916,7 @@ _AbstractChatCompletionRunner_instances = new WeakSet, _AbstractChatCompletionRu
   return typeof rawContent === "string" ? rawContent : rawContent === undefined ? "undefined" : JSON.stringify(rawContent);
 };
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/ChatCompletionRunner.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/ChatCompletionRunner.mjs
 class ChatCompletionRunner extends AbstractChatCompletionRunner {
   static runFunctions(client, params, options) {
     const runner = new ChatCompletionRunner;
@@ -9727,7 +10944,7 @@ class ChatCompletionRunner extends AbstractChatCompletionRunner {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/_vendor/partial-json-parser/parser.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/_vendor/partial-json-parser/parser.mjs
 var STR = 1;
 var NUM = 2;
 var ARR = 4;
@@ -9941,7 +11158,7 @@ var _parseJSON = (jsonString, allow) => {
 };
 var partialParse = (input) => parseJSON(input, Allow.ALL ^ Allow.NUM);
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/ChatCompletionStream.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/ChatCompletionStream.mjs
 var __classPrivateFieldSet9 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
@@ -10430,7 +11647,7 @@ function assertIsEmpty(obj) {
 }
 function assertNever2(_x) {}
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/ChatCompletionStreamingRunner.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/ChatCompletionStreamingRunner.mjs
 class ChatCompletionStreamingRunner extends ChatCompletionStream {
   static fromReadableStream(stream) {
     const runner = new ChatCompletionStreamingRunner(null);
@@ -10457,7 +11674,7 @@ class ChatCompletionStreamingRunner extends ChatCompletionStream {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/chat/completions.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/chat/completions.mjs
 class Completions2 extends APIResource {
   parse(body, options) {
     validateInputTools(body.tools);
@@ -10486,7 +11703,7 @@ class Completions2 extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/chat/chat.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/chat/chat.mjs
 class Chat2 extends APIResource {
   constructor() {
     super(...arguments);
@@ -10497,7 +11714,7 @@ class Chat2 extends APIResource {
   Chat3.Completions = Completions2;
 })(Chat2 || (Chat2 = {}));
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/realtime/sessions.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/realtime/sessions.mjs
 class Sessions extends APIResource {
   create(body, options) {
     return this._client.post("/realtime/sessions", {
@@ -10508,7 +11725,7 @@ class Sessions extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/realtime/transcription-sessions.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/realtime/transcription-sessions.mjs
 class TranscriptionSessions extends APIResource {
   create(body, options) {
     return this._client.post("/realtime/transcription_sessions", {
@@ -10519,7 +11736,7 @@ class TranscriptionSessions extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/realtime/realtime.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/realtime/realtime.mjs
 class Realtime extends APIResource {
   constructor() {
     super(...arguments);
@@ -10530,7 +11747,7 @@ class Realtime extends APIResource {
 Realtime.Sessions = Sessions;
 Realtime.TranscriptionSessions = TranscriptionSessions;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/threads/messages.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/threads/messages.mjs
 class Messages2 extends APIResource {
   create(threadId, body, options) {
     return this._client.post(`/threads/${threadId}/messages`, {
@@ -10574,7 +11791,7 @@ class MessagesPage extends CursorPage {
 }
 Messages2.MessagesPage = MessagesPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/threads/runs/steps.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/threads/runs/steps.mjs
 class Steps extends APIResource {
   retrieve(threadId, runId, stepId, query = {}, options) {
     if (isRequestOptions(query)) {
@@ -10602,7 +11819,7 @@ class RunStepsPage extends CursorPage {
 }
 Steps.RunStepsPage = RunStepsPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/threads/runs/runs.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/threads/runs/runs.mjs
 class Runs extends APIResource {
   constructor() {
     super(...arguments);
@@ -10718,7 +11935,7 @@ Runs.RunsPage = RunsPage;
 Runs.Steps = Steps;
 Runs.RunStepsPage = RunStepsPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/threads/threads.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/threads/threads.mjs
 class Threads extends APIResource {
   constructor() {
     super(...arguments);
@@ -10775,7 +11992,7 @@ Threads.RunsPage = RunsPage;
 Threads.Messages = Messages2;
 Threads.MessagesPage = MessagesPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/beta/beta.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/beta/beta.mjs
 class Beta extends APIResource {
   constructor() {
     super(...arguments);
@@ -10789,13 +12006,13 @@ Beta.Realtime = Realtime;
 Beta.Assistants = Assistants;
 Beta.AssistantsPage = AssistantsPage;
 Beta.Threads = Threads;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/completions.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/completions.mjs
 class Completions3 extends APIResource {
   create(body, options) {
     return this._client.post("/completions", { body, ...options, stream: body.stream ?? false });
   }
 }
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/containers/files/content.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/containers/files/content.mjs
 class Content extends APIResource {
   retrieve(containerId, fileId, options) {
     return this._client.get(`/containers/${containerId}/files/${fileId}/content`, {
@@ -10805,7 +12022,7 @@ class Content extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/containers/files/files.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/containers/files/files.mjs
 class Files extends APIResource {
   constructor() {
     super(...arguments);
@@ -10839,7 +12056,7 @@ class FileListResponsesPage extends CursorPage {
 Files.FileListResponsesPage = FileListResponsesPage;
 Files.Content = Content;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/containers/containers.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/containers/containers.mjs
 class Containers extends APIResource {
   constructor() {
     super(...arguments);
@@ -10870,7 +12087,7 @@ class ContainerListResponsesPage extends CursorPage {
 Containers.ContainerListResponsesPage = ContainerListResponsesPage;
 Containers.Files = Files;
 Containers.FileListResponsesPage = FileListResponsesPage;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/embeddings.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/embeddings.mjs
 class Embeddings extends APIResource {
   create(body, options) {
     const hasUserProvidedEncodingFormat = !!body.encoding_format;
@@ -10900,7 +12117,7 @@ class Embeddings extends APIResource {
     });
   }
 }
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/evals/runs/output-items.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/evals/runs/output-items.mjs
 class OutputItems extends APIResource {
   retrieve(evalId, runId, outputItemId, options) {
     return this._client.get(`/evals/${evalId}/runs/${runId}/output_items/${outputItemId}`, options);
@@ -10917,7 +12134,7 @@ class OutputItemListResponsesPage extends CursorPage {
 }
 OutputItems.OutputItemListResponsesPage = OutputItemListResponsesPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/evals/runs/runs.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/evals/runs/runs.mjs
 class Runs2 extends APIResource {
   constructor() {
     super(...arguments);
@@ -10949,7 +12166,7 @@ Runs2.RunListResponsesPage = RunListResponsesPage;
 Runs2.OutputItems = OutputItems;
 Runs2.OutputItemListResponsesPage = OutputItemListResponsesPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/evals/evals.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/evals/evals.mjs
 class Evals extends APIResource {
   constructor() {
     super(...arguments);
@@ -10980,7 +12197,7 @@ class EvalListResponsesPage extends CursorPage {
 Evals.EvalListResponsesPage = EvalListResponsesPage;
 Evals.Runs = Runs2;
 Evals.RunListResponsesPage = RunListResponsesPage;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/files.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/files.mjs
 class Files2 extends APIResource {
   create(body, options) {
     return this._client.post("/files", multipartFormRequestOptions({ body, ...options }));
@@ -11027,11 +12244,11 @@ class Files2 extends APIResource {
 class FileObjectsPage extends CursorPage {
 }
 Files2.FileObjectsPage = FileObjectsPage;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/fine-tuning/methods.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/fine-tuning/methods.mjs
 class Methods extends APIResource {
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/fine-tuning/alpha/graders.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/fine-tuning/alpha/graders.mjs
 class Graders extends APIResource {
   run(body, options) {
     return this._client.post("/fine_tuning/alpha/graders/run", { body, ...options });
@@ -11041,7 +12258,7 @@ class Graders extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/fine-tuning/alpha/alpha.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/fine-tuning/alpha/alpha.mjs
 class Alpha extends APIResource {
   constructor() {
     super(...arguments);
@@ -11050,7 +12267,7 @@ class Alpha extends APIResource {
 }
 Alpha.Graders = Graders;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/fine-tuning/checkpoints/permissions.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/fine-tuning/checkpoints/permissions.mjs
 class Permissions extends APIResource {
   create(fineTunedModelCheckpoint, body, options) {
     return this._client.getAPIList(`/fine_tuning/checkpoints/${fineTunedModelCheckpoint}/permissions`, PermissionCreateResponsesPage, { body, method: "post", ...options });
@@ -11073,7 +12290,7 @@ class PermissionCreateResponsesPage extends Page {
 }
 Permissions.PermissionCreateResponsesPage = PermissionCreateResponsesPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/fine-tuning/checkpoints/checkpoints.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/fine-tuning/checkpoints/checkpoints.mjs
 class Checkpoints extends APIResource {
   constructor() {
     super(...arguments);
@@ -11083,7 +12300,7 @@ class Checkpoints extends APIResource {
 Checkpoints.Permissions = Permissions;
 Checkpoints.PermissionCreateResponsesPage = PermissionCreateResponsesPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/fine-tuning/jobs/checkpoints.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/fine-tuning/jobs/checkpoints.mjs
 class Checkpoints2 extends APIResource {
   list(fineTuningJobId, query = {}, options) {
     if (isRequestOptions(query)) {
@@ -11097,7 +12314,7 @@ class FineTuningJobCheckpointsPage extends CursorPage {
 }
 Checkpoints2.FineTuningJobCheckpointsPage = FineTuningJobCheckpointsPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/fine-tuning/jobs/jobs.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/fine-tuning/jobs/jobs.mjs
 class Jobs extends APIResource {
   constructor() {
     super(...arguments);
@@ -11145,7 +12362,7 @@ Jobs.FineTuningJobEventsPage = FineTuningJobEventsPage;
 Jobs.Checkpoints = Checkpoints2;
 Jobs.FineTuningJobCheckpointsPage = FineTuningJobCheckpointsPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/fine-tuning/fine-tuning.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/fine-tuning/fine-tuning.mjs
 class FineTuning extends APIResource {
   constructor() {
     super(...arguments);
@@ -11161,11 +12378,11 @@ FineTuning.FineTuningJobsPage = FineTuningJobsPage;
 FineTuning.FineTuningJobEventsPage = FineTuningJobEventsPage;
 FineTuning.Checkpoints = Checkpoints;
 FineTuning.Alpha = Alpha;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/graders/grader-models.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/graders/grader-models.mjs
 class GraderModels extends APIResource {
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/graders/graders.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/graders/graders.mjs
 class Graders2 extends APIResource {
   constructor() {
     super(...arguments);
@@ -11173,7 +12390,7 @@ class Graders2 extends APIResource {
   }
 }
 Graders2.GraderModels = GraderModels;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/images.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/images.mjs
 class Images extends APIResource {
   createVariation(body, options) {
     return this._client.post("/images/variations", multipartFormRequestOptions({ body, ...options }));
@@ -11185,7 +12402,7 @@ class Images extends APIResource {
     return this._client.post("/images/generations", { body, ...options });
   }
 }
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/models.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/models.mjs
 class Models extends APIResource {
   retrieve(model, options) {
     return this._client.get(`/models/${model}`, options);
@@ -11201,13 +12418,13 @@ class Models extends APIResource {
 class ModelsPage extends Page {
 }
 Models.ModelsPage = ModelsPage;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/moderations.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/moderations.mjs
 class Moderations extends APIResource {
   create(body, options) {
     return this._client.post("/moderations", { body, ...options });
   }
 }
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/ResponsesParser.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/ResponsesParser.mjs
 function maybeParseResponse(response, params) {
   if (!params || !hasAutoParseableInput2(params)) {
     return {
@@ -11328,7 +12545,7 @@ function addOutputText(rsp) {
   rsp.output_text = texts.join("");
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/responses/input-items.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/responses/input-items.mjs
 class InputItems extends APIResource {
   list(responseId, query = {}, options) {
     if (isRequestOptions(query)) {
@@ -11341,7 +12558,7 @@ class InputItems extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/responses/ResponseStream.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/responses/ResponseStream.mjs
 var __classPrivateFieldSet10 = function(receiver, state, value, kind2, f2) {
   if (kind2 === "m")
     throw new TypeError("Private method is not writable");
@@ -11592,7 +12809,7 @@ function finalizeResponse(snapshot, params) {
   return maybeParseResponse(snapshot, params);
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/responses/responses.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/responses/responses.mjs
 class Responses extends APIResource {
   constructor() {
     super(...arguments);
@@ -11644,14 +12861,14 @@ class Responses extends APIResource {
 class ResponseItemsPage extends CursorPage {
 }
 Responses.InputItems = InputItems;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/uploads/parts.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/uploads/parts.mjs
 class Parts extends APIResource {
   create(uploadId, body, options) {
     return this._client.post(`/uploads/${uploadId}/parts`, multipartFormRequestOptions({ body, ...options }));
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/uploads/uploads.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/uploads/uploads.mjs
 class Uploads extends APIResource {
   constructor() {
     super(...arguments);
@@ -11668,7 +12885,7 @@ class Uploads extends APIResource {
   }
 }
 Uploads.Parts = Parts;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/lib/Util.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/lib/Util.mjs
 var allSettledWithThrow = async (promises) => {
   const results = await Promise.allSettled(promises);
   const rejected = results.filter((result) => result.status === "rejected");
@@ -11687,7 +12904,7 @@ var allSettledWithThrow = async (promises) => {
   return values;
 };
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/vector-stores/files.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/vector-stores/files.mjs
 class Files3 extends APIResource {
   create(vectorStoreId, body, options) {
     return this._client.post(`/vector_stores/${vectorStoreId}/files`, {
@@ -11783,7 +13000,7 @@ class FileContentResponsesPage extends Page {
 Files3.VectorStoreFilesPage = VectorStoreFilesPage;
 Files3.FileContentResponsesPage = FileContentResponsesPage;
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/vector-stores/file-batches.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/vector-stores/file-batches.mjs
 class FileBatches extends APIResource {
   create(vectorStoreId, body, options) {
     return this._client.post(`/vector_stores/${vectorStoreId}/file_batches`, {
@@ -11870,7 +13087,7 @@ class FileBatches extends APIResource {
   }
 }
 
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/resources/vector-stores/vector-stores.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/resources/vector-stores/vector-stores.mjs
 class VectorStores extends APIResource {
   constructor() {
     super(...arguments);
@@ -11934,7 +13151,7 @@ VectorStores.Files = Files3;
 VectorStores.VectorStoreFilesPage = VectorStoreFilesPage;
 VectorStores.FileContentResponsesPage = FileContentResponsesPage;
 VectorStores.FileBatches = FileBatches;
-// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.24.2/node_modules/openai/index.mjs
+// ../../node_modules/.pnpm/openai@4.103.0_ws@8.18.1_zod@3.25.28/node_modules/openai/index.mjs
 var _a;
 
 class OpenAI extends APIClient {
@@ -12220,14 +13437,14 @@ class ModelScope extends BaseChat {
   }
 }
 
-// src/provider/index.ts
+// src/provider/chat.ts
 var OllamaProvider = Ollama;
 var SiliconFlowProvider = SiliconFlow;
 var CustomProvider = Custom;
 var VolcesProvider = Volces;
 var DeepSeekProvider = DeepSeek;
 var ModelScopeProvider = ModelScope;
-var ProviderMap = {
+var ChatProviderMap = {
   Ollama: OllamaProvider,
   SiliconFlow: SiliconFlowProvider,
   Custom: CustomProvider,
@@ -12241,7 +13458,7 @@ class ProviderManager {
   provider;
   constructor(config) {
     const { provider, model, apiKey, baseURL } = config;
-    const Provider = ProviderMap[provider];
+    const Provider = ChatProviderMap[provider];
     if (!Provider) {
       throw new Error(`Provider ${provider} not found`);
     }
@@ -12266,15 +13483,195 @@ class ProviderManager {
     return this.provider.chat(messages);
   }
 }
+// src/provider/knowledge-adapter/knowledge-base.ts
+class KnowledgeBase extends BaseChat {
+  embeddingModel;
+  splitSize;
+  splitOverlap;
+  batchSize;
+  constructor(options) {
+    super(options);
+    this.embeddingModel = options.embeddingModel;
+    this.splitSize = options.splitSize || 2000;
+    this.splitOverlap = options.splitOverlap || 200;
+    this.prompt_tokens = 0;
+    this.total_tokens = 0;
+    this.batchSize = options.batchSize || 4;
+  }
+  async generateEmbedding(text) {
+    try {
+      const res = await this.generateEmbeddingCore(text, { model: this.embeddingModel });
+      return { code: 200, data: res.data };
+    } catch (error) {
+      const has413 = error?.message?.includes("413");
+      if (has413) {
+        return {
+          code: 413,
+          message: "请求过大，请分割文本"
+        };
+      }
+      return {
+        code: error?.code || 500,
+        message: "生成embedding失败"
+      };
+    }
+  }
+  async generateEmbeddingBatch(textArray) {
+    const batchSize = this.batchSize || 4;
+    const embeddings = [];
+    for (let i2 = 0;i2 < textArray.length; i2 += batchSize) {
+      const batch = textArray.slice(i2, i2 + batchSize);
+      const res = await this.generateEmbedding(batch);
+      if (res.code === 200) {
+        embeddings.push(...res.data.map((item) => item.embedding));
+      }
+    }
+    return embeddings;
+  }
+  async splitLongText(text) {
+    const chunks = [];
+    let startIndex = 0;
+    while (startIndex < text.length) {
+      const endIndex = Math.min(startIndex + this.splitSize, text.length);
+      const chunk = text.substring(startIndex, endIndex);
+      chunks.push(chunk);
+      startIndex = endIndex - this.splitOverlap;
+      if (startIndex >= text.length - this.splitOverlap) {
+        break;
+      }
+    }
+    const embeddings = await this.generateEmbeddingBatch(chunks);
+    return chunks.map((chunk, index) => ({
+      text: chunk,
+      embedding: embeddings[index]
+    }));
+  }
+}
+
+// src/provider/knowledge-adapter/siliconflow.ts
+class SiliconFlowKnowledge extends KnowledgeBase {
+  static BASE_URL = "https://api.siliconflow.com/v1";
+  constructor(options) {
+    super({ ...options, baseURL: options?.baseURL ?? SiliconFlowKnowledge.BASE_URL });
+  }
+  async rerank(data) {
+    return this.openai.post("/rerank", {
+      body: data
+    });
+  }
+}
+// src/provider/utils/parse-config.ts
+var import_aes = __toESM(require_aes(), 1);
+var import_enc_utf8 = __toESM(require_enc_utf8(), 1);
+var CryptoJS = { AES: import_aes.default, enc: { Utf8: import_enc_utf8.default } };
+function encryptAES(plainText, secretKey) {
+  return CryptoJS.AES.encrypt(plainText, secretKey).toString();
+}
+function decryptAES(cipherText, secretKey) {
+  const bytes = CryptoJS.AES.decrypt(cipherText, secretKey);
+  return bytes.toString(CryptoJS.enc.Utf8);
+}
+
+class AIConfigParser {
+  config;
+  result;
+  constructor(config) {
+    this.config = config;
+  }
+  getProvider(opts) {
+    const { model, group, decryptKey } = opts;
+    const modelConfig = this.config.models.find((m2) => m2.model === model && m2.group === group);
+    const groupConfig = this.config.secretKeys.find((m2) => m2.group === group);
+    if (!modelConfig) {
+      throw new Error(`在模型组 ${group} 中未找到模型 ${model}`);
+    }
+    const mergeConfig = {
+      ...modelConfig,
+      ...groupConfig,
+      decryptKey: decryptKey || groupConfig?.decryptKey
+    };
+    if (!mergeConfig.provider) {
+      throw new Error(`模型 ${model} 未配置提供商`);
+    }
+    if (!mergeConfig.model) {
+      throw new Error(`模型 ${model} 未配置模型名称`);
+    }
+    if (!mergeConfig.apiKey) {
+      throw new Error(`组 ${group} 未配置 API 密钥`);
+    }
+    if (!mergeConfig.group) {
+      throw new Error(`组 ${group} 未配置`);
+    }
+    this.result = mergeConfig;
+    return mergeConfig;
+  }
+  async getSecretKey(opts) {
+    const { getCache, setCache, providerResult } = opts || {};
+    const { apiKey, decryptKey, group = "", model } = providerResult || this.result;
+    const cacheKey = `${group}--${model}`;
+    if (!decryptKey) {
+      return apiKey;
+    }
+    if (getCache) {
+      const cache = await getCache(cacheKey);
+      if (cache) {
+        return cache;
+      }
+    }
+    const secretKey = decryptAES(apiKey, decryptKey);
+    if (setCache) {
+      await setCache(cacheKey, secretKey);
+    }
+    return secretKey;
+  }
+  encrypt(plainText, secretKey) {
+    return encryptAES(plainText, secretKey);
+  }
+  decrypt(cipherText, secretKey) {
+    return decryptAES(cipherText, secretKey);
+  }
+  getSelectOpts() {
+    const { models, secretKeys = [] } = this.config;
+    return models.map((model) => {
+      const selectOpts = secretKeys.find((m2) => m2.group === model.group);
+      return {
+        ...model,
+        ...selectOpts
+      };
+    });
+  }
+  getConfig(keepSecret, config) {
+    const chatConfig = config ?? this.config;
+    if (keepSecret) {
+      return chatConfig;
+    }
+    const { secretKeys = [], ...rest } = chatConfig || {};
+    return {
+      ...rest,
+      secretKeys: secretKeys.map((item) => {
+        return {
+          ...item,
+          apiKey: undefined,
+          decryptKey: undefined
+        };
+      })
+    };
+  }
+}
 export {
   readStream,
+  encryptAES,
+  decryptAES,
   VolcesProvider,
   SiliconFlowProvider,
-  ProviderMap,
+  SiliconFlowKnowledge,
   ProviderManager,
   OllamaProvider,
   ModelScopeProvider,
+  KnowledgeBase,
   DeepSeekProvider,
   CustomProvider,
-  BaseChat
+  ChatProviderMap,
+  BaseChat,
+  AIConfigParser
 };