oricore 1.4.0 → 1.5.0

package/dist/index.cjs

@@ -559,6 +559,22 @@ var init_models = __esm({
         open_weights: false,
         limit: { context: 2e5, output: 65536 }
       },
+      "gemini-3.1-pro-preview": {
+        name: "Gemini 3.1 Pro Preview",
+        attachment: true,
+        reasoning: true,
+        temperature: true,
+        tool_call: true,
+        knowledge: "2025-01",
+        release_date: "2026-02-19",
+        last_updated: "2026-02-19",
+        modalities: {
+          input: ["text", "image", "audio", "video", "pdf"],
+          output: ["text"]
+        },
+        open_weights: false,
+        limit: { context: 1048576, output: 65536 }
+      },
       "gemini-3-flash-preview": {
         name: "Gemini 3 Flash Preview",
         attachment: true,
@@ -845,6 +861,19 @@ var init_models = __esm({
         open_weights: false,
         limit: { context: 4e5, output: 128e3 }
       },
+      "gpt-5.3-codex": {
+        name: "GPT-5.3 Codex",
+        attachment: true,
+        reasoning: true,
+        temperature: false,
+        tool_call: true,
+        knowledge: "2025-08-31",
+        release_date: "2026-02-05",
+        last_updated: "2026-02-05",
+        modalities: { input: ["text", "image", "pdf"], output: ["text"] },
+        open_weights: false,
+        limit: { context: 4e5, output: 128e3 }
+      },
       "gpt-4.1": {
         name: "GPT-4.1",
         attachment: true,
@@ -1027,6 +1056,19 @@ var init_models = __esm({
         open_weights: true,
         limit: { context: 204800, output: 131072 }
       },
+      "glm-5": {
+        name: "GLM-5",
+        attachment: false,
+        reasoning: true,
+        temperature: true,
+        tool_call: true,
+        knowledge: "2025-06",
+        release_date: "2026-02-10",
+        last_updated: "2026-02-10",
+        modalities: { input: ["text"], output: ["text"] },
+        open_weights: true,
+        limit: { context: 262144, output: 131072 }
+      },
       "sonoma-dusk-alpha": {
         name: "Sonoma Dusk Alpha",
         attachment: true,
@@ -1105,6 +1147,33 @@ var init_models = __esm({
         open_weights: false,
         limit: { context: 2e5, output: 64e3 }
       },
+      "claude-opus-4-6": {
+        name: "Claude Opus 4.6",
+        attachment: true,
+        reasoning: true,
+        temperature: true,
+        tool_call: true,
+        knowledge: "2025-05-31",
+        release_date: "2026-02-05",
+        last_updated: "2026-02-05",
+        modalities: { input: ["text", "image", "pdf"], output: ["text"] },
+        open_weights: false,
+        limit: { context: 2e5, output: 128e3 }
+      },
+      "claude-sonnet-4-6": {
+        name: "Claude Sonnet 4.6",
+        shortName: "Sonnet 4.6",
+        attachment: true,
+        reasoning: true,
+        temperature: true,
+        tool_call: true,
+        knowledge: "2025-07-31",
+        release_date: "2026-02-17",
+        last_updated: "2026-02-17",
+        modalities: { input: ["text", "image", "pdf"], output: ["text"] },
+        open_weights: false,
+        limit: { context: 1e6, output: 64e3 }
+      },
       "ling-1t": {
         name: "InclusionAI Ling-1T",
         attachment: true,
@@ -1247,6 +1316,32 @@ var init_models = __esm({
         modalities: { input: ["text"], output: ["text"] },
         open_weights: true,
         limit: { context: 204800, output: 131072 }
+      },
+      "minimax-m2.5": {
+        name: "MiniMax M2.5",
+        attachment: false,
+        reasoning: true,
+        temperature: true,
+        tool_call: true,
+        knowledge: "",
+        release_date: "2026-02-13",
+        last_updated: "2026-02-13",
+        modalities: { input: ["text"], output: ["text"] },
+        open_weights: true,
+        limit: { context: 204800, output: 131072 }
+      },
+      "minimax-m2.7": {
+        name: "MiniMax M2.7",
+        attachment: false,
+        reasoning: true,
+        temperature: true,
+        tool_call: true,
+        knowledge: "",
+        release_date: "2026-03-18",
+        last_updated: "2026-03-18",
+        modalities: { input: ["text"], output: ["text"] },
+        open_weights: true,
+        limit: { context: 204800, output: 131072 }
       }
     };
   }
@@ -1392,12 +1487,16 @@ var require_symbols = __commonJS({
       kListeners: /* @__PURE__ */ Symbol("listeners"),
       kHTTPContext: /* @__PURE__ */ Symbol("http context"),
       kMaxConcurrentStreams: /* @__PURE__ */ Symbol("max concurrent streams"),
+      kHTTP2InitialWindowSize: /* @__PURE__ */ Symbol("http2 initial window size"),
+      kHTTP2ConnectionWindowSize: /* @__PURE__ */ Symbol("http2 connection window size"),
       kEnableConnectProtocol: /* @__PURE__ */ Symbol("http2session connect protocol"),
       kRemoteSettings: /* @__PURE__ */ Symbol("http2session remote settings"),
       kHTTP2Stream: /* @__PURE__ */ Symbol("http2session client stream"),
+      kPingInterval: /* @__PURE__ */ Symbol("ping interval"),
       kNoProxyAgent: /* @__PURE__ */ Symbol("no proxy agent"),
       kHttpProxyAgent: /* @__PURE__ */ Symbol("http proxy agent"),
-      kHttpsProxyAgent: /* @__PURE__ */ Symbol("https proxy agent")
+      kHttpsProxyAgent: /* @__PURE__ */ Symbol("https proxy agent"),
+      kSocks5ProxyAgent: /* @__PURE__ */ Symbol("socks5 proxy agent")
     };
   }
 });
@@ -1987,6 +2086,29 @@ var require_errors = __commonJS({
         return true;
       }
     };
+    var Socks5ProxyError = class extends UndiciError {
+      constructor(message, code) {
+        super(message);
+        this.name = "Socks5ProxyError";
+        this.message = message || "SOCKS5 proxy error";
+        this.code = code || "UND_ERR_SOCKS5";
+      }
+    };
+    var kMessageSizeExceededError = /* @__PURE__ */ Symbol.for("undici.error.UND_ERR_WS_MESSAGE_SIZE_EXCEEDED");
+    var MessageSizeExceededError = class extends UndiciError {
+      constructor(message) {
+        super(message);
+        this.name = "MessageSizeExceededError";
+        this.message = message || "Max decompressed message size exceeded";
+        this.code = "UND_ERR_WS_MESSAGE_SIZE_EXCEEDED";
+      }
+      static [Symbol.hasInstance](instance) {
+        return instance && instance[kMessageSizeExceededError] === true;
+      }
+      get [kMessageSizeExceededError]() {
+        return true;
+      }
+    };
     module2.exports = {
       AbortError,
       HTTPParserError,
@@ -2010,7 +2132,9 @@ var require_errors = __commonJS({
       RequestRetryError,
       ResponseError,
       SecureProxyConnectionError,
-      MaxOriginsReachedError
+      MaxOriginsReachedError,
+      Socks5ProxyError,
+      MessageSizeExceededError
     };
   }
 });
@@ -2330,6 +2454,8 @@ var require_util = __commonJS({
         return body;
       } else if (body && typeof body.pipeTo === "function") {
         return new BodyAsyncIterable(body);
+      } else if (body && isFormDataLike(body)) {
+        return body;
       } else if (body && typeof body !== "string" && !ArrayBuffer.isView(body) && isIterable(body)) {
         return new BodyAsyncIterable(body);
       } else {
@@ -2454,6 +2580,11 @@ var require_util = __commonJS({
     function isIterable(obj) {
       return !!(obj != null && (typeof obj[Symbol.iterator] === "function" || typeof obj[Symbol.asyncIterator] === "function"));
     }
+    function hasSafeIterator(obj) {
+      const prototype = Object.getPrototypeOf(obj);
+      const ownIterator = Object.prototype.hasOwnProperty.call(obj, Symbol.iterator);
+      return ownIterator || prototype != null && prototype !== Object.prototype && typeof obj[Symbol.iterator] === "function";
+    }
     function bodyLength(body) {
       if (body == null) {
         return 0;
@@ -2504,51 +2635,46 @@ var require_util = __commonJS({
       for (let i = 0; i < headers.length; i += 2) {
         const key = headerNameToString(headers[i]);
         let val = obj[key];
-        if (val) {
-          if (typeof val === "string") {
-            val = [val];
-            obj[key] = val;
-          }
-          val.push(headers[i + 1].toString("utf8"));
-        } else {
-          const headersValue = headers[i + 1];
-          if (typeof headersValue === "string") {
-            obj[key] = headersValue;
+        if (val !== void 0) {
+          if (!Object.hasOwn(obj, key)) {
+            const headersValue = typeof headers[i + 1] === "string" ? headers[i + 1] : Array.isArray(headers[i + 1]) ? headers[i + 1].map((x) => x.toString("latin1")) : headers[i + 1].toString("latin1");
+            if (key === "__proto__") {
+              Object.defineProperty(obj, key, {
+                value: headersValue,
+                enumerable: true,
+                configurable: true,
+                writable: true
+              });
+            } else {
+              obj[key] = headersValue;
+            }
           } else {
-            obj[key] = Array.isArray(headersValue) ? headersValue.map((x) => x.toString("utf8")) : headersValue.toString("utf8");
+            if (typeof val === "string") {
+              val = [val];
+              obj[key] = val;
+            }
+            val.push(headers[i + 1].toString("latin1"));
           }
+        } else {
+          const headersValue = typeof headers[i + 1] === "string" ? headers[i + 1] : Array.isArray(headers[i + 1]) ? headers[i + 1].map((x) => x.toString("latin1")) : headers[i + 1].toString("latin1");
+          obj[key] = headersValue;
         }
       }
-      if ("content-length" in obj && "content-disposition" in obj) {
-        obj["content-disposition"] = Buffer.from(obj["content-disposition"]).toString("latin1");
-      }
       return obj;
     }
     function parseRawHeaders(headers) {
       const headersLength = headers.length;
       const ret = new Array(headersLength);
-      let hasContentLength = false;
-      let contentDispositionIdx = -1;
       let key;
       let val;
-      let kLen = 0;
       for (let n = 0; n < headersLength; n += 2) {
         key = headers[n];
         val = headers[n + 1];
         typeof key !== "string" && (key = key.toString());
-        typeof val !== "string" && (val = val.toString("utf8"));
-        kLen = key.length;
-        if (kLen === 14 && key[7] === "-" && (key === "content-length" || key.toLowerCase() === "content-length")) {
-          hasContentLength = true;
-        } else if (kLen === 19 && key[7] === "-" && (key === "content-disposition" || key.toLowerCase() === "content-disposition")) {
-          contentDispositionIdx = n + 1;
-        }
+        typeof val !== "string" && (val = val.toString("latin1"));
         ret[n] = key;
         ret[n + 1] = val;
       }
-      if (hasContentLength && contentDispositionIdx !== -1) {
-        ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString("latin1");
-      }
       return ret;
     }
     function encodeRawHeaders(headers) {
@@ -3063,6 +3189,7 @@ var require_util = __commonJS({
       getServerName,
       isStream,
       isIterable,
+      hasSafeIterator,
       isAsyncIterable,
       isDestroyed,
       headerNameToString,
@@ -3301,10 +3428,12 @@ var require_diagnostics = __commonJS({
       diagnosticsChannel.subscribe(
         "undici:websocket:open",
         (evt) => {
-          const {
-            address: { address, port }
-          } = evt;
-          debugLog("connection opened %s%s", address, port ? `:${port}` : "");
+          if (evt.address != null) {
+            const { address, port } = evt.address;
+            debugLog("connection opened %s%s", address, port ? `:${port}` : "");
+          } else {
+            debugLog("connection opened");
+          }
         }
       );
       diagnosticsChannel.subscribe(
@@ -3369,6 +3498,7 @@ var require_request = __commonJS({
       isBuffer,
       isFormDataLike,
       isIterable,
+      hasSafeIterator,
       isBlobLike,
       serializePathWithQuery,
       assertRequestHandler,
@@ -3396,7 +3526,8 @@ var require_request = __commonJS({
         expectContinue,
         servername,
         throwOnError,
-        maxRedirections
+        maxRedirections,
+        typeOfService
       }, handler) {
         if (typeof path26 !== "string") {
           throw new InvalidArgumentError("path must be a string");
@@ -3413,6 +3544,9 @@ var require_request = __commonJS({
         if (upgrade && typeof upgrade !== "string") {
           throw new InvalidArgumentError("upgrade must be a string");
         }
+        if (upgrade && !isValidHeaderValue(upgrade)) {
+          throw new InvalidArgumentError("invalid upgrade header");
+        }
         if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
           throw new InvalidArgumentError("invalid headersTimeout");
         }
@@ -3431,9 +3565,13 @@ var require_request = __commonJS({
         if (maxRedirections != null && maxRedirections !== 0) {
           throw new InvalidArgumentError("maxRedirections is not supported, use the redirect interceptor");
         }
+        if (typeOfService != null && (!Number.isInteger(typeOfService) || typeOfService < 0 || typeOfService > 255)) {
+          throw new InvalidArgumentError("typeOfService must be an integer between 0 and 255");
+        }
         this.headersTimeout = headersTimeout;
         this.bodyTimeout = bodyTimeout;
         this.method = method;
+        this.typeOfService = typeOfService ?? 0;
         this.abort = null;
         if (body == null) {
           this.body = null;
@@ -3489,7 +3627,7 @@ var require_request = __commonJS({
             processHeader(this, headers[i], headers[i + 1]);
           }
         } else if (headers && typeof headers === "object") {
-          if (headers[Symbol.iterator]) {
+          if (hasSafeIterator(headers)) {
             for (const header of headers) {
               if (!Array.isArray(header) || header.length !== 2) {
                 throw new InvalidArgumentError("headers must be in key-value pair format");
@@ -3658,12 +3796,18 @@ var require_request = __commonJS({
       } else {
         val = `${val}`;
       }
-      if (request.host === null && headerName === "host") {
+      if (headerName === "host") {
+        if (request.host !== null) {
+          throw new InvalidArgumentError("duplicate host header");
+        }
         if (typeof val !== "string") {
           throw new InvalidArgumentError("invalid host header");
         }
         request.host = val;
-      } else if (request.contentLength === null && headerName === "content-length") {
+      } else if (headerName === "content-length") {
+        if (request.contentLength !== null) {
+          throw new InvalidArgumentError("duplicate content-length header");
+        }
         request.contentLength = parseInt(val, 10);
         if (!Number.isFinite(request.contentLength)) {
           throw new InvalidArgumentError("invalid content-length header");
@@ -3674,12 +3818,18 @@ var require_request = __commonJS({
       } else if (headerName === "transfer-encoding" || headerName === "keep-alive" || headerName === "upgrade") {
         throw new InvalidArgumentError(`invalid ${headerName} header`);
       } else if (headerName === "connection") {
-        const value = typeof val === "string" ? val.toLowerCase() : null;
-        if (value !== "close" && value !== "keep-alive") {
+        const value = typeof val === "string" ? val : null;
+        if (value === null) {
           throw new InvalidArgumentError("invalid connection header");
         }
-        if (value === "close") {
-          request.reset = true;
+        for (const token of value.toLowerCase().split(",")) {
+          const trimmed = token.trim();
+          if (!isValidHTTPToken(trimmed)) {
+            throw new InvalidArgumentError("invalid connection header");
+          }
+          if (trimmed === "close") {
+            request.reset = true;
+          }
         }
       } else if (headerName === "expect") {
         throw new NotSupportedError("expect header not supported");
@@ -3708,6 +3858,9 @@ var require_wrap_handler = __commonJS({
       onConnect(abort, context) {
         return this.#handler.onConnect?.(abort, context);
       }
+      onResponseStarted() {
+        return this.#handler.onResponseStarted?.();
+      }
       onHeaders(statusCode, rawHeaders, resume, statusMessage) {
         return this.#handler.onHeaders?.(statusCode, rawHeaders, resume, statusMessage);
       }
@@ -3733,14 +3886,14 @@ var require_wrap_handler = __commonJS({
       onRequestUpgrade(controller, statusCode, headers, socket) {
         const rawHeaders = [];
         for (const [key, val] of Object.entries(headers)) {
-          rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
+          rawHeaders.push(Buffer.from(key, "latin1"), toRawHeaderValue(val));
         }
         this.#handler.onUpgrade?.(statusCode, rawHeaders, socket);
       }
       onResponseStart(controller, statusCode, headers, statusMessage) {
         const rawHeaders = [];
         for (const [key, val] of Object.entries(headers)) {
-          rawHeaders.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
+          rawHeaders.push(Buffer.from(key, "latin1"), toRawHeaderValue(val));
         }
         if (this.#handler.onHeaders?.(statusCode, rawHeaders, () => controller.resume(), statusMessage) === false) {
           controller.pause();
@@ -3754,7 +3907,7 @@ var require_wrap_handler = __commonJS({
       onResponseEnd(controller, trailers) {
         const rawTrailers = [];
         for (const [key, val] of Object.entries(trailers)) {
-          rawTrailers.push(Buffer.from(key), Array.isArray(val) ? val.map((v) => Buffer.from(v)) : Buffer.from(val));
+          rawTrailers.push(Buffer.from(key, "latin1"), toRawHeaderValue(val));
         }
         this.#handler.onComplete?.(rawTrailers);
       }
@@ -3765,6 +3918,9 @@ var require_wrap_handler = __commonJS({
         this.#handler.onError?.(err);
       }
     };
+    function toRawHeaderValue(value) {
+      return Array.isArray(value) ? value.map((item) => Buffer.from(item, "latin1")) : Buffer.from(value, "latin1");
+    }
   }
 });
 
@@ -3865,6 +4021,9 @@ var require_unwrap_handler = __commonJS({
         this.#controller = new UnwrapController(abort);
         this.#handler.onRequestStart?.(this.#controller, context);
       }
+      onResponseStarted() {
+        return this.#handler.onResponseStarted?.();
+      }
       onUpgrade(statusCode, rawHeaders, socket) {
         this.#handler.onRequestUpgrade?.(this.#controller, statusCode, parseHeaders(rawHeaders), socket);
       }
@@ -5584,6 +5743,7 @@ var require_runtime_features = __commonJS({
 var require_webidl = __commonJS({
   "node_modules/undici/lib/web/webidl/index.js"(exports2, module2) {
     "use strict";
+    var assert5 = require("assert");
     var { types, inspect } = require("util");
     var { runtimeFeatures } = require_runtime_features();
     var UNDEFINED = 1;
@@ -5870,6 +6030,7 @@ var require_webidl = __commonJS({
       };
     };
     webidl.dictionaryConverter = function(converters) {
+      converters.sort((a, b) => (a.key > b.key) - (a.key < b.key));
       return (dictionary, prefix, argument) => {
         const dict = {};
         if (dictionary != null && webidl.util.Type(dictionary) !== OBJECT) {
@@ -5928,6 +6089,27 @@ var require_webidl = __commonJS({
     webidl.is.BufferSource = function(V) {
       return types.isArrayBuffer(V) || ArrayBuffer.isView(V) && types.isArrayBuffer(V.buffer);
     };
+    webidl.util.getCopyOfBytesHeldByBufferSource = function(bufferSource) {
+      const jsBufferSource = bufferSource;
+      let jsArrayBuffer = jsBufferSource;
+      let offset = 0;
+      let length = 0;
+      if (types.isTypedArray(jsBufferSource) || types.isDataView(jsBufferSource)) {
+        jsArrayBuffer = jsBufferSource.buffer;
+        offset = jsBufferSource.byteOffset;
+        length = jsBufferSource.byteLength;
+      } else {
+        assert5(types.isAnyArrayBuffer(jsBufferSource));
+        length = jsBufferSource.byteLength;
+      }
+      if (jsArrayBuffer.detached) {
+        return new Uint8Array(0);
+      }
+      const bytes = new Uint8Array(length);
+      const view = new Uint8Array(jsArrayBuffer, offset, length);
+      bytes.set(view);
+      return bytes;
+    };
     webidl.converters.DOMString = function(V, prefix, argument, flags) {
       if (V === null && webidl.util.HasFlag(flags, webidl.attributes.LegacyNullToEmptyString)) {
         return "";
@@ -6852,6 +7034,15 @@ var require_util2 = __commonJS({
       }
       return gettingDecodingSplitting(value);
     }
+    function hasAuthenticationEntry(request) {
+      return false;
+    }
+    function includesCredentials(url) {
+      return !!(url.username || url.password);
+    }
+    function isTraversableNavigable(navigable) {
+      return true;
+    }
     var EnvironmentSettingsObjectBase = class {
       get baseUrl() {
         return getGlobalOrigin();
@@ -6909,7 +7100,10 @@ var require_util2 = __commonJS({
       extractMimeType,
       getDecodeSplit,
       environmentSettingsObject,
-      isOriginIPPotentiallyTrustworthy
+      isOriginIPPotentiallyTrustworthy,
+      hasAuthenticationEntry,
+      includesCredentials,
+      isTraversableNavigable
     };
   }
 });
@@ -7086,9 +7280,9 @@ var require_formdata_parser = __commonJS({
     var { webidl } = require_webidl();
     var assert5 = require("assert");
     var { isomorphicDecode } = require_infra();
-    var { utf8DecodeBytes } = require_encoding();
     var dd = Buffer.from("--");
     var decoder = new TextDecoder();
+    var decoderIgnoreBOM = new TextDecoder("utf-8", { ignoreBOM: true });
     function isAsciiString(chars) {
       for (let i = 0; i < chars.length; ++i) {
         if ((chars.charCodeAt(i) & ~127) !== 0) {
@@ -7165,7 +7359,7 @@ var require_formdata_parser = __commonJS({
           }
           value = new File([body], filename, { type: contentType });
         } else {
-          value = utf8DecodeBytes(Buffer.from(body));
+          value = decoderIgnoreBOM.decode(Buffer.from(body));
         }
         assert5(webidl.is.USVString(name));
         assert5(typeof value === "string" && webidl.is.USVString(value) || webidl.is.File(value));
@@ -7434,7 +7628,7 @@ var require_body = __commonJS({
     var { webidl } = require_webidl();
     var assert5 = require("assert");
     var { isErrored, isDisturbed } = require("stream");
-    var { isArrayBuffer } = require("util/types");
+    var { isUint8Array } = require("util/types");
     var { serializeAMimeType } = require_data_url();
     var { multipartFormDataParser } = require_formdata_parser();
     var { createDeferredPromise } = require_promise();
@@ -7453,20 +7647,19 @@ var require_body = __commonJS({
     });
     function extractBody(object, keepalive = false) {
       let stream = null;
+      let controller = null;
       if (webidl.is.ReadableStream(object)) {
         stream = object;
       } else if (webidl.is.Blob(object)) {
         stream = object.stream();
       } else {
         stream = new ReadableStream({
-          pull(controller) {
-            const buffer = typeof source === "string" ? textEncoder.encode(source) : source;
-            if (buffer.byteLength) {
-              controller.enqueue(buffer);
-            }
-            queueMicrotask(() => readableStreamClose(controller));
+          pull() {
           },
-          start() {
+          start(c) {
+            controller = c;
+          },
+          cancel() {
           },
           type: "bytes"
         });
@@ -7483,7 +7676,7 @@ var require_body = __commonJS({
         source = object.toString();
         type = "application/x-www-form-urlencoded;charset=UTF-8";
       } else if (webidl.is.BufferSource(object)) {
-        source = isArrayBuffer(object) ? new Uint8Array(object.slice()) : new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
+        source = webidl.util.getCopyOfBytesHeldByBufferSource(object);
       } else if (webidl.is.FormData(object)) {
         const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
         const prefix = `--${boundary}\r
@@ -7550,38 +7743,29 @@ Content-Type: ${value.type || "application/octet-stream"}\r
         }
         stream = webidl.is.ReadableStream(object) ? object : ReadableStreamFrom(object);
       }
-      if (typeof source === "string" || util.isBuffer(source)) {
-        length = Buffer.byteLength(source);
+      if (typeof source === "string" || isUint8Array(source)) {
+        action = () => {
+          length = typeof source === "string" ? Buffer.byteLength(source) : source.length;
+          return source;
+        };
       }
       if (action != null) {
-        let iterator;
-        stream = new ReadableStream({
-          start() {
-            iterator = action(object)[Symbol.asyncIterator]();
-          },
-          pull(controller) {
-            return iterator.next().then(({ value, done }) => {
-              if (done) {
-                queueMicrotask(() => {
-                  controller.close();
-                  controller.byobRequest?.respond(0);
-                });
-              } else {
-                if (!isErrored(stream)) {
-                  const buffer = new Uint8Array(value);
-                  if (buffer.byteLength) {
-                    controller.enqueue(buffer);
-                  }
-                }
+        ;
+        (async () => {
+          const result = action();
+          const iterator = result?.[Symbol.asyncIterator]?.();
+          if (iterator) {
+            for await (const bytes of iterator) {
+              if (isErrored(stream)) break;
+              if (bytes.length) {
+                controller.enqueue(new Uint8Array(bytes));
               }
-              return controller.desiredSize > 0;
-            });
-          },
-          cancel(reason) {
-            return iterator.return();
-          },
-          type: "bytes"
-        });
+            }
+          } else if (result?.length && !isErrored(stream)) {
+            controller.enqueue(typeof result === "string" ? textEncoder.encode(result) : new Uint8Array(result));
+          }
+          queueMicrotask(() => readableStreamClose(controller));
+        })();
       }
       const body = { stream, source, length };
       return [body, type];
@@ -7669,13 +7853,10 @@ Content-Type: ${value.type || "application/octet-stream"}\r
       } catch (e) {
         return Promise.reject(e);
       }
-      const state = getInternalState(object);
-      if (bodyUnusable(state)) {
+      object = getInternalState(object);
+      if (bodyUnusable(object)) {
         return Promise.reject(new TypeError("Body is unusable: Body has already been read"));
       }
-      if (state.aborted) {
-        return Promise.reject(new DOMException("The operation was aborted.", "AbortError"));
-      }
       const promise = createDeferredPromise();
       const errorSteps = promise.reject;
       const successSteps = (data) => {
@@ -7685,11 +7866,11 @@ Content-Type: ${value.type || "application/octet-stream"}\r
           errorSteps(e);
         }
       };
-      if (state.body == null) {
+      if (object.body == null) {
         successSteps(Buffer.allocUnsafe(0));
         return promise.promise;
       }
-      fullyReadBody(state.body, successSteps, errorSteps);
+      fullyReadBody(object.body, successSteps, errorSteps);
       return promise.promise;
     }
     function bodyUnusable(object) {
@@ -8291,8 +8472,12 @@ var require_client_h1 = __commonJS({
         return 0;
       }
     };
-    function onParserTimeout(parser) {
-      const { socket, timeoutType, client, paused } = parser.deref();
+    function onParserTimeout(parserWeakRef) {
+      const parser = parserWeakRef.deref();
+      if (!parser) {
+        return;
+      }
+      const { socket, timeoutType, client, paused } = parser;
       if (timeoutType === TIMEOUT_HEADERS) {
         if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
           assert5(!paused, "cannot be paused while waiting for headers");
@@ -8528,6 +8713,9 @@ var require_client_h1 = __commonJS({
       if (blocking) {
         socket[kBlocking] = true;
       }
+      if (socket.setTypeOfService) {
+        socket.setTypeOfService(request.typeOfService);
+      }
       let header = `${method} ${path26} HTTP/1.1\r
 `;
       if (typeof host === "string") {
@@ -8902,7 +9090,10 @@ var require_client_h2 = __commonJS({
       kStrictContentLength,
       kOnError,
       kMaxConcurrentStreams,
+      kPingInterval,
       kHTTP2Session,
+      kHTTP2InitialWindowSize,
+      kHTTP2ConnectionWindowSize,
       kResume,
       kSize,
       kHTTPContext,
@@ -8910,7 +9101,8 @@ var require_client_h2 = __commonJS({
       kBodyTimeout,
       kEnableConnectProtocol,
       kRemoteSettings,
-      kHTTP2Stream
+      kHTTP2Stream,
+      kHTTP2SessionState
     } = require_symbols();
     var { channels } = require_diagnostics();
     var kOpenStreams = /* @__PURE__ */ Symbol("open streams");
@@ -8950,20 +9142,31 @@ var require_client_h2 = __commonJS({
     }
     function connectH2(client, socket) {
       client[kSocket] = socket;
+      const http2InitialWindowSize = client[kHTTP2InitialWindowSize];
+      const http2ConnectionWindowSize = client[kHTTP2ConnectionWindowSize];
       const session = http2.connect(client[kUrl], {
         createConnection: () => socket,
         peerMaxConcurrentStreams: client[kMaxConcurrentStreams],
         settings: {
           // TODO(metcoder95): add support for PUSH
-          enablePush: false
+          enablePush: false,
+          ...http2InitialWindowSize != null ? { initialWindowSize: http2InitialWindowSize } : null
         }
       });
+      client[kSocket] = socket;
       session[kOpenStreams] = 0;
       session[kClient] = client;
       session[kSocket] = socket;
-      session[kHTTP2Session] = null;
+      session[kHTTP2SessionState] = {
+        ping: {
+          interval: client[kPingInterval] === 0 ? null : setInterval(onHttp2SendPing, client[kPingInterval], session).unref()
+        }
+      };
       session[kEnableConnectProtocol] = false;
       session[kRemoteSettings] = false;
+      if (http2ConnectionWindowSize) {
+        util.addListener(session, "connect", applyConnectionWindowSize.bind(session, http2ConnectionWindowSize));
+      }
       util.addListener(session, "error", onHttp2SessionError);
       util.addListener(session, "frameError", onHttp2FrameError);
       util.addListener(session, "end", onHttp2SessionEnd);
@@ -9041,6 +9244,14 @@ var require_client_h2 = __commonJS({
         }
       }
     }
+    function applyConnectionWindowSize(connectionWindowSize) {
+      try {
+        if (typeof this.setLocalWindowSize === "function") {
+          this.setLocalWindowSize(connectionWindowSize);
+        }
+      } catch {
+      }
+    }
     function onHttp2RemoteSettings(settings) {
       this[kClient][kMaxConcurrentStreams] = settings.maxConcurrentStreams ?? this[kClient][kMaxConcurrentStreams];
       if (this[kRemoteSettings] === true && this[kEnableConnectProtocol] === true && settings.enableConnectProtocol === false) {
@@ -9053,6 +9264,26 @@ var require_client_h2 = __commonJS({
       this[kRemoteSettings] = true;
       this[kClient][kResume]();
     }
+    function onHttp2SendPing(session) {
+      const state = session[kHTTP2SessionState];
+      if ((session.closed || session.destroyed) && state.ping.interval != null) {
+        clearInterval(state.ping.interval);
+        state.ping.interval = null;
+        return;
+      }
+      session.ping(onPing.bind(session));
+      function onPing(err, duration) {
+        const client = this[kClient];
+        const socket = this[kClient];
+        if (err != null) {
+          const error = new InformationalError(`HTTP/2: "PING" errored - type ${err.message}`);
+          socket[kError] = error;
+          client[kOnError](error);
+        } else {
+          client.emit("ping", duration);
+        }
+      }
+    }
     function onHttp2SessionError(err) {
       assert5(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID");
       this[kSocket][kError] = err;
@@ -9090,11 +9321,15 @@ var require_client_h2 = __commonJS({
       client[kResume]();
     }
     function onHttp2SessionClose() {
-      const { [kClient]: client } = this;
+      const { [kClient]: client, [kHTTP2SessionState]: state } = this;
       const { [kSocket]: socket } = client;
       const err = this[kSocket][kError] || this[kError] || new SocketError("closed", util.getSocketInfo(socket));
       client[kSocket] = null;
       client[kHTTPContext] = null;
+      if (state.ping.interval != null) {
+        clearInterval(state.ping.interval);
+        state.ping.interval = null;
+      }
       if (client.destroyed) {
         assert5(client[kPending] === 0);
         const requests = client[kQueue].splice(client[kRunningIdx]);
@@ -9299,9 +9534,11 @@ var require_client_h2 = __commonJS({
       }
       ++session[kOpenStreams];
       stream.setTimeout(requestTimeout);
+      let responseReceived = false;
       stream.once("response", (headers2) => {
         const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers2;
         request.onResponseStarted();
+        responseReceived = true;
         if (request.aborted) {
           stream.removeAllListeners("data");
           return;
@@ -9309,26 +9546,25 @@ var require_client_h2 = __commonJS({
         if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), "") === false) {
           stream.pause();
         }
+        stream.on("data", (chunk) => {
+          if (request.aborted || request.completed) {
+            return;
+          }
+          if (request.onData(chunk) === false) {
+            stream.pause();
+          }
+        });
       });
-      stream.on("data", (chunk) => {
-        if (request.onData(chunk) === false) {
-          stream.pause();
-        }
-      });
-      stream.once("end", (err) => {
+      stream.once("end", () => {
         stream.removeAllListeners("data");
-        if (stream.state?.state == null || stream.state.state < 6) {
+        if (responseReceived) {
           if (!request.aborted && !request.completed) {
             request.onComplete({});
           }
           client[kQueue][client[kRunningIdx]++] = null;
           client[kResume]();
         } else {
-          --session[kOpenStreams];
-          if (session[kOpenStreams] === 0) {
-            session.unref();
-          }
-          abort(err ?? new InformationalError("HTTP/2: stream half-closed (remote)"));
+          abort(new InformationalError("HTTP/2: stream half-closed (remote)"));
           client[kQueue][client[kRunningIdx]++] = null;
           client[kPendingIdx] = client[kRunningIdx];
           client[kResume]();
@@ -9365,6 +9601,7 @@ var require_client_h2 = __commonJS({
         if (request.aborted || request.completed) {
           return;
         }
+        stream.removeAllListeners("data");
         request.onComplete(trailers);
       });
       return true;
@@ -9608,7 +9845,10 @@ var require_client = __commonJS({
       kOnError,
       kHTTPContext,
       kMaxConcurrentStreams,
-      kResume
+      kHTTP2InitialWindowSize,
+      kHTTP2ConnectionWindowSize,
+      kResume,
+      kPingInterval
     } = require_symbols();
     var connectH1 = require_client_h1();
     var connectH2 = require_client_h2();
@@ -9654,7 +9894,10 @@ var require_client = __commonJS({
         // h2
         maxConcurrentStreams,
         allowH2,
-        useH2c
+        useH2c,
+        initialWindowSize,
+        connectionWindowSize,
+        pingInterval
       } = {}) {
         if (keepAlive !== void 0) {
           throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
@@ -9723,6 +9966,15 @@ var require_client = __commonJS({
         if (useH2c != null && typeof useH2c !== "boolean") {
           throw new InvalidArgumentError("useH2c must be a valid boolean value");
         }
+        if (initialWindowSize != null && (!Number.isInteger(initialWindowSize) || initialWindowSize < 1)) {
+          throw new InvalidArgumentError("initialWindowSize must be a positive integer, greater than 0");
+        }
+        if (connectionWindowSize != null && (!Number.isInteger(connectionWindowSize) || connectionWindowSize < 1)) {
+          throw new InvalidArgumentError("connectionWindowSize must be a positive integer, greater than 0");
+        }
+        if (pingInterval != null && (typeof pingInterval !== "number" || !Number.isInteger(pingInterval) || pingInterval < 0)) {
+          throw new InvalidArgumentError("pingInterval must be a positive integer, greater or equal to 0");
+        }
         super();
         if (typeof connect2 !== "function") {
           connect2 = buildConnector({
@@ -9735,6 +9987,9 @@ var require_client = __commonJS({
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
             ...connect2
           });
+        } else if (socketPath != null) {
+          const customConnect = connect2;
+          connect2 = (opts, callback) => customConnect({ ...opts, socketPath }, callback);
         }
         this[kUrl] = util.parseOrigin(url);
         this[kConnector] = connect2;
@@ -9756,8 +10011,11 @@ var require_client = __commonJS({
         this[kMaxRequests] = maxRequestsPerClient;
         this[kClosedResolve] = null;
         this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
-        this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100;
         this[kHTTPContext] = null;
+        this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100;
+        this[kHTTP2InitialWindowSize] = initialWindowSize != null ? initialWindowSize : 262144;
+        this[kHTTP2ConnectionWindowSize] = connectionWindowSize != null ? connectionWindowSize : 524288;
+        this[kPingInterval] = pingInterval != null ? pingInterval : 6e4;
         this[kQueue] = [];
         this[kRunningIdx] = 0;
         this[kPendingIdx] = 0;
@@ -9880,56 +10138,61 @@ var require_client = __commonJS({
           connector: client[kConnector]
         });
       }
-      client[kConnector]({
-        host,
-        hostname,
-        protocol,
-        port,
-        servername: client[kServerName],
-        localAddress: client[kLocalAddress]
-      }, (err, socket) => {
-        if (err) {
-          handleConnectError(client, err, { host, hostname, protocol, port });
-          client[kResume]();
-          return;
-        }
-        if (client.destroyed) {
-          util.destroy(socket.on("error", noop), new ClientDestroyedError());
-          client[kResume]();
-          return;
-        }
-        assert5(socket);
-        try {
-          client[kHTTPContext] = socket.alpnProtocol === "h2" ? connectH2(client, socket) : connectH1(client, socket);
-        } catch (err2) {
-          socket.destroy().on("error", noop);
-          handleConnectError(client, err2, { host, hostname, protocol, port });
+      try {
+        client[kConnector]({
+          host,
+          hostname,
+          protocol,
+          port,
+          servername: client[kServerName],
+          localAddress: client[kLocalAddress]
+        }, (err, socket) => {
+          if (err) {
+            handleConnectError(client, err, { host, hostname, protocol, port });
+            client[kResume]();
+            return;
+          }
+          if (client.destroyed) {
+            util.destroy(socket.on("error", noop), new ClientDestroyedError());
+            client[kResume]();
+            return;
+          }
+          assert5(socket);
+          try {
+            client[kHTTPContext] = socket.alpnProtocol === "h2" ? connectH2(client, socket) : connectH1(client, socket);
+          } catch (err2) {
+            socket.destroy().on("error", noop);
+            handleConnectError(client, err2, { host, hostname, protocol, port });
+            client[kResume]();
+            return;
+          }
+          client[kConnecting] = false;
+          socket[kCounter] = 0;
+          socket[kMaxRequests] = client[kMaxRequests];
+          socket[kClient] = client;
+          socket[kError] = null;
+          if (channels.connected.hasSubscribers) {
+            channels.connected.publish({
+              connectParams: {
+                host,
+                hostname,
+                protocol,
+                port,
+                version: client[kHTTPContext]?.version,
+                servername: client[kServerName],
+                localAddress: client[kLocalAddress]
+              },
+              connector: client[kConnector],
+              socket
+            });
+          }
+          client.emit("connect", client[kUrl], [client]);
           client[kResume]();
-          return;
-        }
-        client[kConnecting] = false;
-        socket[kCounter] = 0;
-        socket[kMaxRequests] = client[kMaxRequests];
-        socket[kClient] = client;
-        socket[kError] = null;
-        if (channels.connected.hasSubscribers) {
-          channels.connected.publish({
-            connectParams: {
-              host,
-              hostname,
-              protocol,
-              port,
-              version: client[kHTTPContext]?.version,
-              servername: client[kServerName],
-              localAddress: client[kLocalAddress]
-            },
-            connector: client[kConnector],
-            socket
-          });
-        }
-        client.emit("connect", client[kUrl], [client]);
+        });
+      } catch (err) {
+        handleConnectError(client, err, { host, hostname, protocol, port });
         client[kResume]();
-      });
+      }
     }
     function handleConnectError(client, err, { host, hostname, protocol, port }) {
       if (client.destroyed) {
@@ -10011,6 +10274,9 @@ var require_client = __commonJS({
           return;
         }
         const request = client[kQueue][client[kPendingIdx]];
+        if (request === null) {
+          return;
+        }
         if (client[kUrl].protocol === "https:" && client[kServerName] !== request.servername) {
           if (client[kRunning] > 0) {
             return;
@@ -10157,9 +10423,12 @@ var require_pool_base = __commonJS({
           this.emit("drain", origin, [this, ...targets]);
         }
         if (this[kClosedResolve] && queue.isEmpty()) {
-          const closeAll = new Array(this[kClients].length);
+          const closeAll = [];
           for (let i = 0; i < this[kClients].length; i++) {
-            closeAll[i] = this[kClients][i].close();
+            const client2 = this[kClients][i];
+            if (!client2.destroyed) {
+              closeAll.push(client2.close());
+            }
           }
           return Promise.all(closeAll).then(this[kClosedResolve]);
         }
@@ -10216,9 +10485,12 @@ var require_pool_base = __commonJS({
       }
       [kClose]() {
         if (this[kQueue].isEmpty()) {
-          const closeAll = new Array(this[kClients].length);
+          const closeAll = [];
           for (let i = 0; i < this[kClients].length; i++) {
-            closeAll[i] = this[kClients][i].close();
+            const client = this[kClients][i];
+            if (!client.destroyed) {
+              closeAll.push(client.close());
+            }
           }
           return Promise.all(closeAll);
         } else {
@@ -10349,7 +10621,7 @@ var require_pool = __commonJS({
         super();
         this[kConnections] = connections || null;
         this[kUrl] = util.parseOrigin(origin);
-        this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl };
+        this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl, socketPath };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kFactory] = factory;
         this.on("connect", (origin2, targets) => {
@@ -10406,7 +10678,7 @@ var require_balanced_pool = __commonJS({
     } = require_pool_base();
     var Pool = require_pool();
     var { kUrl } = require_symbols();
-    var { parseOrigin } = require_util();
+    var util = require_util();
     var kFactory = /* @__PURE__ */ Symbol("factory");
     var kOptions = /* @__PURE__ */ Symbol("options");
     var kGreatestCommonDivisor = /* @__PURE__ */ Symbol("kGreatestCommonDivisor");
@@ -10433,7 +10705,8 @@ var require_balanced_pool = __commonJS({
           throw new InvalidArgumentError("factory must be a function.");
         }
         super();
-        this[kOptions] = opts;
+        this[kOptions] = { ...util.deepClone(opts) };
+        this[kOptions].interceptors = opts.interceptors ? { ...opts.interceptors } : void 0;
         this[kIndex] = -1;
         this[kCurrentWeight] = 0;
         this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100;
@@ -10448,11 +10721,11 @@ var require_balanced_pool = __commonJS({
         this._updateBalancedPoolStats();
       }
       addUpstream(upstream) {
-        const upstreamOrigin = parseOrigin(upstream).origin;
+        const upstreamOrigin = util.parseOrigin(upstream).origin;
         if (this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true)) {
           return this;
         }
-        const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]));
+        const pool = this[kFactory](upstreamOrigin, this[kOptions]);
         this[kAddClient](pool);
         pool.on("connect", () => {
           pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty]);
@@ -10482,7 +10755,7 @@ var require_balanced_pool = __commonJS({
         this[kGreatestCommonDivisor] = result;
       }
       removeUpstream(upstream) {
-        const upstreamOrigin = parseOrigin(upstream).origin;
+        const upstreamOrigin = util.parseOrigin(upstream).origin;
         const pool = this[kClients].find((pool2) => pool2[kUrl].origin === upstreamOrigin && pool2.closed !== true && pool2.destroyed !== true);
         if (pool) {
           this[kRemoveClient](pool);
@@ -10490,7 +10763,7 @@ var require_balanced_pool = __commonJS({
         return this;
       }
       getUpstream(upstream) {
-        const upstreamOrigin = parseOrigin(upstream).origin;
+        const upstreamOrigin = util.parseOrigin(upstream).origin;
         return this[kClients].find((pool) => pool[kUrl].origin === upstreamOrigin && pool.closed !== true && pool.destroyed !== true);
       }
       get upstreams() {
@@ -10599,7 +10872,7 @@ var require_round_robin_pool = __commonJS({
         super();
         this[kConnections] = connections || null;
         this[kUrl] = util.parseOrigin(origin);
-        this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl };
+        this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl, socketPath };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kFactory] = factory;
         this[kIndex] = -1;
@@ -10730,7 +11003,9 @@ var require_agent = __commonJS({
               if (connected) result2.count -= 1;
               if (result2.count <= 0) {
                 this[kClients].delete(key);
-                result2.dispatcher.close();
+                if (!result2.dispatcher.destroyed) {
+                  result2.dispatcher.close();
+                }
               }
               this[kOrigins].delete(key);
             }
@@ -10783,6 +11058,667 @@ var require_agent = __commonJS({
   }
 });
 
+// node_modules/undici/lib/core/socks5-utils.js
+var require_socks5_utils = __commonJS({
+  "node_modules/undici/lib/core/socks5-utils.js"(exports2, module2) {
+    "use strict";
+    var { Buffer: Buffer2 } = require("buffer");
+    var net = require("net");
+    var { InvalidArgumentError } = require_errors();
+    function parseAddress(address) {
+      if (net.isIPv4(address)) {
+        const parts = address.split(".").map(Number);
+        return {
+          type: 1,
+          // IPv4
+          buffer: Buffer2.from(parts)
+        };
+      }
+      if (net.isIPv6(address)) {
+        return {
+          type: 4,
+          // IPv6
+          buffer: parseIPv6(address)
+        };
+      }
+      const domainBuffer = Buffer2.from(address, "utf8");
+      if (domainBuffer.length > 255) {
+        throw new InvalidArgumentError("Domain name too long (max 255 bytes)");
+      }
+      return {
+        type: 3,
+        // Domain
+        buffer: Buffer2.concat([Buffer2.from([domainBuffer.length]), domainBuffer])
+      };
+    }
+    function parseIPv6(address) {
+      const buffer = Buffer2.alloc(16);
+      const parts = address.split(":");
+      let partIndex = 0;
+      let bufferIndex = 0;
+      const doubleColonIndex = address.indexOf("::");
+      if (doubleColonIndex !== -1) {
+        const nonEmptyParts = parts.filter((p) => p.length > 0).length;
+        const skipParts = 8 - nonEmptyParts;
+        for (let i = 0; i < parts.length; i++) {
+          if (parts[i] === "" && i === doubleColonIndex / 3) {
+            bufferIndex += skipParts * 2;
+          } else if (parts[i] !== "") {
+            const value = parseInt(parts[i], 16);
+            buffer.writeUInt16BE(value, bufferIndex);
+            bufferIndex += 2;
+          }
+        }
+      } else {
+        for (const part of parts) {
+          if (part === "") continue;
+          const value = parseInt(part, 16);
+          buffer.writeUInt16BE(value, partIndex * 2);
+          partIndex++;
+        }
+      }
+      return buffer;
+    }
+    function buildAddressBuffer(type, addressBuffer, port) {
+      const portBuffer = Buffer2.allocUnsafe(2);
+      portBuffer.writeUInt16BE(port, 0);
+      return Buffer2.concat([
+        Buffer2.from([type]),
+        addressBuffer,
+        portBuffer
+      ]);
+    }
+    function parseResponseAddress(buffer, offset = 0) {
+      if (buffer.length < offset + 1) {
+        throw new InvalidArgumentError("Buffer too small to contain address type");
+      }
+      const addressType = buffer[offset];
+      let address;
+      let currentOffset = offset + 1;
+      switch (addressType) {
+        case 1: {
+          if (buffer.length < currentOffset + 6) {
+            throw new InvalidArgumentError("Buffer too small for IPv4 address");
+          }
+          address = Array.from(buffer.subarray(currentOffset, currentOffset + 4)).join(".");
+          currentOffset += 4;
+          break;
+        }
+        case 3: {
+          if (buffer.length < currentOffset + 1) {
+            throw new InvalidArgumentError("Buffer too small for domain length");
+          }
+          const domainLength = buffer[currentOffset];
+          currentOffset += 1;
+          if (buffer.length < currentOffset + domainLength + 2) {
+            throw new InvalidArgumentError("Buffer too small for domain address");
+          }
+          address = buffer.subarray(currentOffset, currentOffset + domainLength).toString("utf8");
+          currentOffset += domainLength;
+          break;
+        }
+        case 4: {
+          if (buffer.length < currentOffset + 18) {
+            throw new InvalidArgumentError("Buffer too small for IPv6 address");
+          }
+          const parts = [];
+          for (let i = 0; i < 8; i++) {
+            const value = buffer.readUInt16BE(currentOffset + i * 2);
+            parts.push(value.toString(16));
+          }
+          address = parts.join(":");
+          currentOffset += 16;
+          break;
+        }
+        default:
+          throw new InvalidArgumentError(`Invalid address type: ${addressType}`);
+      }
+      if (buffer.length < currentOffset + 2) {
+        throw new InvalidArgumentError("Buffer too small for port");
+      }
+      const port = buffer.readUInt16BE(currentOffset);
+      currentOffset += 2;
+      return {
+        address,
+        port,
+        bytesRead: currentOffset - offset
+      };
+    }
+    function createReplyError(replyCode) {
+      const messages = {
+        1: "General SOCKS server failure",
+        2: "Connection not allowed by ruleset",
+        3: "Network unreachable",
+        4: "Host unreachable",
+        5: "Connection refused",
+        6: "TTL expired",
+        7: "Command not supported",
+        8: "Address type not supported"
+      };
+      const message = messages[replyCode] || `Unknown SOCKS5 error code: ${replyCode}`;
+      const error = new Error(message);
+      error.code = `SOCKS5_${replyCode}`;
+      return error;
+    }
+    module2.exports = {
+      parseAddress,
+      parseIPv6,
+      buildAddressBuffer,
+      parseResponseAddress,
+      createReplyError
+    };
+  }
+});
+
+// node_modules/undici/lib/core/socks5-client.js
+var require_socks5_client = __commonJS({
+  "node_modules/undici/lib/core/socks5-client.js"(exports2, module2) {
+    "use strict";
+    var { EventEmitter: EventEmitter2 } = require("events");
+    var { Buffer: Buffer2 } = require("buffer");
+    var { InvalidArgumentError, Socks5ProxyError } = require_errors();
+    var { debuglog } = require("util");
+    var { parseAddress } = require_socks5_utils();
+    var debug9 = debuglog("undici:socks5");
+    var SOCKS_VERSION = 5;
+    var AUTH_METHODS = {
+      NO_AUTH: 0,
+      GSSAPI: 1,
+      USERNAME_PASSWORD: 2,
+      NO_ACCEPTABLE: 255
+    };
+    var COMMANDS = {
+      CONNECT: 1,
+      BIND: 2,
+      UDP_ASSOCIATE: 3
+    };
+    var ADDRESS_TYPES = {
+      IPV4: 1,
+      DOMAIN: 3,
+      IPV6: 4
+    };
+    var REPLY_CODES = {
+      SUCCEEDED: 0,
+      GENERAL_FAILURE: 1,
+      CONNECTION_NOT_ALLOWED: 2,
+      NETWORK_UNREACHABLE: 3,
+      HOST_UNREACHABLE: 4,
+      CONNECTION_REFUSED: 5,
+      TTL_EXPIRED: 6,
+      COMMAND_NOT_SUPPORTED: 7,
+      ADDRESS_TYPE_NOT_SUPPORTED: 8
+    };
+    var STATES = {
+      INITIAL: "initial",
+      HANDSHAKING: "handshaking",
+      AUTHENTICATING: "authenticating",
+      CONNECTING: "connecting",
+      CONNECTED: "connected",
+      ERROR: "error",
+      CLOSED: "closed"
+    };
+    var Socks5Client = class extends EventEmitter2 {
+      constructor(socket, options = {}) {
+        super();
+        if (!socket) {
+          throw new InvalidArgumentError("socket is required");
+        }
+        this.socket = socket;
+        this.options = options;
+        this.state = STATES.INITIAL;
+        this.buffer = Buffer2.alloc(0);
+        this.authMethods = [];
+        if (options.username && options.password) {
+          this.authMethods.push(AUTH_METHODS.USERNAME_PASSWORD);
+        }
+        this.authMethods.push(AUTH_METHODS.NO_AUTH);
+        this.socket.on("data", this.onData.bind(this));
+        this.socket.on("error", this.onError.bind(this));
+        this.socket.on("close", this.onClose.bind(this));
+      }
+      /**
+       * Handle incoming data from the socket
+       */
+      onData(data) {
+        debug9("received data", data.length, "bytes in state", this.state);
+        this.buffer = Buffer2.concat([this.buffer, data]);
+        try {
+          switch (this.state) {
+            case STATES.HANDSHAKING:
+              this.handleHandshakeResponse();
+              break;
+            case STATES.AUTHENTICATING:
+              this.handleAuthResponse();
+              break;
+            case STATES.CONNECTING:
+              this.handleConnectResponse();
+              break;
+          }
+        } catch (err) {
+          this.onError(err);
+        }
+      }
+      /**
+       * Handle socket errors
+       */
+      onError(err) {
+        debug9("socket error", err);
+        this.state = STATES.ERROR;
+        this.emit("error", err);
+        this.destroy();
+      }
+      /**
+       * Handle socket close
+       */
+      onClose() {
+        debug9("socket closed");
+        this.state = STATES.CLOSED;
+        this.emit("close");
+      }
+      /**
+       * Destroy the client and underlying socket
+       */
+      destroy() {
+        if (this.socket && !this.socket.destroyed) {
+          this.socket.destroy();
+        }
+      }
+      /**
+       * Start the SOCKS5 handshake
+       */
+      handshake() {
+        if (this.state !== STATES.INITIAL) {
+          throw new InvalidArgumentError("Handshake already started");
+        }
+        debug9("starting handshake with", this.authMethods.length, "auth methods");
+        this.state = STATES.HANDSHAKING;
+        const request = Buffer2.alloc(2 + this.authMethods.length);
+        request[0] = SOCKS_VERSION;
+        request[1] = this.authMethods.length;
+        this.authMethods.forEach((method, i) => {
+          request[2 + i] = method;
+        });
+        this.socket.write(request);
+      }
+      /**
+       * Handle handshake response from server
+       */
+      handleHandshakeResponse() {
+        if (this.buffer.length < 2) {
+          return;
+        }
+        const version = this.buffer[0];
+        const method = this.buffer[1];
+        if (version !== SOCKS_VERSION) {
+          throw new Socks5ProxyError(`Invalid SOCKS version: ${version}`, "UND_ERR_SOCKS5_VERSION");
+        }
+        if (method === AUTH_METHODS.NO_ACCEPTABLE) {
+          throw new Socks5ProxyError("No acceptable authentication method", "UND_ERR_SOCKS5_AUTH_REJECTED");
+        }
+        this.buffer = this.buffer.subarray(2);
+        debug9("server selected auth method", method);
+        if (method === AUTH_METHODS.NO_AUTH) {
+          this.emit("authenticated");
+        } else if (method === AUTH_METHODS.USERNAME_PASSWORD) {
+          this.state = STATES.AUTHENTICATING;
+          this.sendAuthRequest();
+        } else {
+          throw new Socks5ProxyError(`Unsupported authentication method: ${method}`, "UND_ERR_SOCKS5_AUTH_METHOD");
+        }
+      }
+      /**
+       * Send username/password authentication request
+       */
+      sendAuthRequest() {
+        const { username, password } = this.options;
+        if (!username || !password) {
+          throw new InvalidArgumentError("Username and password required for authentication");
+        }
+        debug9("sending username/password auth");
+        const usernameBuffer = Buffer2.from(username);
+        const passwordBuffer = Buffer2.from(password);
+        if (usernameBuffer.length > 255 || passwordBuffer.length > 255) {
+          throw new InvalidArgumentError("Username or password too long");
+        }
+        const request = Buffer2.alloc(3 + usernameBuffer.length + passwordBuffer.length);
+        request[0] = 1;
+        request[1] = usernameBuffer.length;
+        usernameBuffer.copy(request, 2);
+        request[2 + usernameBuffer.length] = passwordBuffer.length;
+        passwordBuffer.copy(request, 3 + usernameBuffer.length);
+        this.socket.write(request);
+      }
+      /**
+       * Handle authentication response
+       */
+      handleAuthResponse() {
+        if (this.buffer.length < 2) {
+          return;
+        }
+        const version = this.buffer[0];
+        const status = this.buffer[1];
+        if (version !== 1) {
+          throw new Socks5ProxyError(`Invalid auth sub-negotiation version: ${version}`, "UND_ERR_SOCKS5_AUTH_VERSION");
+        }
+        if (status !== 0) {
+          throw new Socks5ProxyError("Authentication failed", "UND_ERR_SOCKS5_AUTH_FAILED");
+        }
+        this.buffer = this.buffer.subarray(2);
+        debug9("authentication successful");
+        this.emit("authenticated");
+      }
+      /**
+       * Send CONNECT command
+       * @param {string} address - Target address (IP or domain)
+       * @param {number} port - Target port
+       */
+      connect(address, port) {
+        if (this.state === STATES.CONNECTED) {
+          throw new InvalidArgumentError("Already connected");
+        }
+        debug9("connecting to", address, port);
+        this.state = STATES.CONNECTING;
+        const request = this.buildConnectRequest(COMMANDS.CONNECT, address, port);
+        this.socket.write(request);
+      }
+      /**
+       * Build a SOCKS5 request
+       */
+      buildConnectRequest(command, address, port) {
+        const { type: addressType, buffer: addressBuffer } = parseAddress(address);
+        const request = Buffer2.alloc(4 + addressBuffer.length + 2);
+        request[0] = SOCKS_VERSION;
+        request[1] = command;
+        request[2] = 0;
+        request[3] = addressType;
+        addressBuffer.copy(request, 4);
+        request.writeUInt16BE(port, 4 + addressBuffer.length);
+        return request;
+      }
+      /**
+       * Handle CONNECT response
+       */
+      handleConnectResponse() {
+        if (this.buffer.length < 4) {
+          return;
+        }
+        const version = this.buffer[0];
+        const reply = this.buffer[1];
+        const addressType = this.buffer[3];
+        if (version !== SOCKS_VERSION) {
+          throw new Socks5ProxyError(`Invalid SOCKS version in reply: ${version}`, "UND_ERR_SOCKS5_REPLY_VERSION");
+        }
+        let responseLength = 4;
+        if (addressType === ADDRESS_TYPES.IPV4) {
+          responseLength += 4 + 2;
+        } else if (addressType === ADDRESS_TYPES.DOMAIN) {
+          if (this.buffer.length < 5) {
+            return;
+          }
+          responseLength += 1 + this.buffer[4] + 2;
+        } else if (addressType === ADDRESS_TYPES.IPV6) {
+          responseLength += 16 + 2;
+        } else {
+          throw new Socks5ProxyError(`Invalid address type in reply: ${addressType}`, "UND_ERR_SOCKS5_ADDR_TYPE");
+        }
+        if (this.buffer.length < responseLength) {
+          return;
+        }
+        if (reply !== REPLY_CODES.SUCCEEDED) {
+          const errorMessage = this.getReplyErrorMessage(reply);
+          throw new Socks5ProxyError(`SOCKS5 connection failed: ${errorMessage}`, `UND_ERR_SOCKS5_REPLY_${reply}`);
+        }
+        let boundAddress;
+        let offset = 4;
+        if (addressType === ADDRESS_TYPES.IPV4) {
+          boundAddress = Array.from(this.buffer.subarray(offset, offset + 4)).join(".");
+          offset += 4;
+        } else if (addressType === ADDRESS_TYPES.DOMAIN) {
+          const domainLength = this.buffer[offset];
+          offset += 1;
+          boundAddress = this.buffer.subarray(offset, offset + domainLength).toString();
+          offset += domainLength;
+        } else if (addressType === ADDRESS_TYPES.IPV6) {
+          const parts = [];
+          for (let i = 0; i < 8; i++) {
+            const value = this.buffer.readUInt16BE(offset + i * 2);
+            parts.push(value.toString(16));
+          }
+          boundAddress = parts.join(":");
+          offset += 16;
+        }
+        const boundPort = this.buffer.readUInt16BE(offset);
+        this.buffer = this.buffer.subarray(responseLength);
+        this.state = STATES.CONNECTED;
+        debug9("connected, bound address:", boundAddress, "port:", boundPort);
+        this.emit("connected", { address: boundAddress, port: boundPort });
+      }
+      /**
+       * Get human-readable error message for reply code
+       */
+      getReplyErrorMessage(reply) {
+        switch (reply) {
+          case REPLY_CODES.GENERAL_FAILURE:
+            return "General SOCKS server failure";
+          case REPLY_CODES.CONNECTION_NOT_ALLOWED:
+            return "Connection not allowed by ruleset";
+          case REPLY_CODES.NETWORK_UNREACHABLE:
+            return "Network unreachable";
+          case REPLY_CODES.HOST_UNREACHABLE:
+            return "Host unreachable";
+          case REPLY_CODES.CONNECTION_REFUSED:
+            return "Connection refused";
+          case REPLY_CODES.TTL_EXPIRED:
+            return "TTL expired";
+          case REPLY_CODES.COMMAND_NOT_SUPPORTED:
+            return "Command not supported";
+          case REPLY_CODES.ADDRESS_TYPE_NOT_SUPPORTED:
+            return "Address type not supported";
+          default:
+            return `Unknown error code: ${reply}`;
+        }
+      }
+    };
+    module2.exports = {
+      Socks5Client,
+      AUTH_METHODS,
+      COMMANDS,
+      ADDRESS_TYPES,
+      REPLY_CODES,
+      STATES
+    };
+  }
+});
+
+// node_modules/undici/lib/dispatcher/socks5-proxy-agent.js
+var require_socks5_proxy_agent = __commonJS({
+  "node_modules/undici/lib/dispatcher/socks5-proxy-agent.js"(exports2, module2) {
+    "use strict";
+    var net = require("net");
+    var { URL: URL2 } = require("url");
+    var tls;
+    var DispatcherBase = require_dispatcher_base();
+    var { InvalidArgumentError } = require_errors();
+    var { Socks5Client } = require_socks5_client();
+    var { kDispatch, kClose, kDestroy } = require_symbols();
+    var Pool = require_pool();
+    var buildConnector = require_connect();
+    var { debuglog } = require("util");
+    var debug9 = debuglog("undici:socks5-proxy");
+    var kProxyUrl = /* @__PURE__ */ Symbol("proxy url");
+    var kProxyHeaders = /* @__PURE__ */ Symbol("proxy headers");
+    var kProxyAuth = /* @__PURE__ */ Symbol("proxy auth");
+    var kPool = /* @__PURE__ */ Symbol("pool");
+    var kConnector = /* @__PURE__ */ Symbol("connector");
+    var experimentalWarningEmitted = false;
+    var Socks5ProxyAgent = class extends DispatcherBase {
+      constructor(proxyUrl, options = {}) {
+        super();
+        if (!experimentalWarningEmitted) {
+          process.emitWarning(
+            "SOCKS5 proxy support is experimental and subject to change",
+            "ExperimentalWarning"
+          );
+          experimentalWarningEmitted = true;
+        }
+        if (!proxyUrl) {
+          throw new InvalidArgumentError("Proxy URL is mandatory");
+        }
+        const url = typeof proxyUrl === "string" ? new URL2(proxyUrl) : proxyUrl;
+        if (url.protocol !== "socks5:" && url.protocol !== "socks:") {
+          throw new InvalidArgumentError("Proxy URL must use socks5:// or socks:// protocol");
+        }
+        this[kProxyUrl] = url;
+        this[kProxyHeaders] = options.headers || {};
+        this[kProxyAuth] = {
+          username: options.username || (url.username ? decodeURIComponent(url.username) : null),
+          password: options.password || (url.password ? decodeURIComponent(url.password) : null)
+        };
+        this[kConnector] = options.connect || buildConnector({
+          ...options.proxyTls,
+          servername: options.proxyTls?.servername || url.hostname
+        });
+        this[kPool] = null;
+      }
+      /**
+       * Create a SOCKS5 connection to the proxy
+       */
+      async createSocks5Connection(targetHost, targetPort) {
+        const proxyHost = this[kProxyUrl].hostname;
+        const proxyPort = parseInt(this[kProxyUrl].port) || 1080;
+        debug9("creating SOCKS5 connection to", proxyHost, proxyPort);
+        const socket = await new Promise((resolve4, reject) => {
+          const onConnect = () => {
+            socket2.removeListener("error", onError);
+            resolve4(socket2);
+          };
+          const onError = (err) => {
+            socket2.removeListener("connect", onConnect);
+            reject(err);
+          };
+          const socket2 = net.connect({
+            host: proxyHost,
+            port: proxyPort
+          });
+          socket2.once("connect", onConnect);
+          socket2.once("error", onError);
+        });
+        const socks5Client = new Socks5Client(socket, this[kProxyAuth]);
+        socks5Client.on("error", (err) => {
+          debug9("SOCKS5 error:", err);
+          socket.destroy();
+        });
+        await socks5Client.handshake();
+        await new Promise((resolve4, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error("SOCKS5 authentication timeout"));
+          }, 5e3);
+          const onAuthenticated = () => {
+            clearTimeout(timeout);
+            socks5Client.removeListener("error", onError);
+            resolve4();
+          };
+          const onError = (err) => {
+            clearTimeout(timeout);
+            socks5Client.removeListener("authenticated", onAuthenticated);
+            reject(err);
+          };
+          if (socks5Client.state === "authenticated") {
+            clearTimeout(timeout);
+            resolve4();
+          } else {
+            socks5Client.once("authenticated", onAuthenticated);
+            socks5Client.once("error", onError);
+          }
+        });
+        await socks5Client.connect(targetHost, targetPort);
+        await new Promise((resolve4, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error("SOCKS5 connection timeout"));
+          }, 5e3);
+          const onConnected = (info) => {
+            debug9("SOCKS5 tunnel established to", targetHost, targetPort, "via", info);
+            clearTimeout(timeout);
+            socks5Client.removeListener("error", onError);
+            resolve4();
+          };
+          const onError = (err) => {
+            clearTimeout(timeout);
+            socks5Client.removeListener("connected", onConnected);
+            reject(err);
+          };
+          socks5Client.once("connected", onConnected);
+          socks5Client.once("error", onError);
+        });
+        return socket;
+      }
+      /**
+       * Dispatch a request through the SOCKS5 proxy
+       */
+      async [kDispatch](opts, handler) {
+        const { origin } = opts;
+        debug9("dispatching request to", origin, "via SOCKS5");
+        try {
+          if (!this[kPool] || this[kPool].destroyed || this[kPool].closed) {
+            this[kPool] = new Pool(origin, {
+              pipelining: opts.pipelining,
+              connections: opts.connections,
+              connect: async (connectOpts, callback) => {
+                try {
+                  const url = new URL2(origin);
+                  const targetHost = url.hostname;
+                  const targetPort = parseInt(url.port) || (url.protocol === "https:" ? 443 : 80);
+                  debug9("establishing SOCKS5 connection to", targetHost, targetPort);
+                  const socket = await this.createSocks5Connection(targetHost, targetPort);
+                  let finalSocket = socket;
+                  if (url.protocol === "https:") {
+                    if (!tls) {
+                      tls = require("tls");
+                    }
+                    debug9("upgrading to TLS");
+                    finalSocket = tls.connect({
+                      socket,
+                      servername: targetHost,
+                      ...connectOpts.tls || {}
+                    });
+                    await new Promise((resolve4, reject) => {
+                      finalSocket.once("secureConnect", resolve4);
+                      finalSocket.once("error", reject);
+                    });
+                  }
+                  callback(null, finalSocket);
+                } catch (err) {
+                  debug9("SOCKS5 connection error:", err);
+                  callback(err);
+                }
+              }
+            });
+          }
+          return this[kPool][kDispatch](opts, handler);
+        } catch (err) {
+          debug9("dispatch error:", err);
+          if (typeof handler.onError === "function") {
+            handler.onError(err);
+          } else {
+            throw err;
+          }
+        }
+      }
+      async [kClose]() {
+        if (this[kPool]) {
+          await this[kPool].close();
+        }
+      }
+      async [kDestroy](err) {
+        if (this[kPool]) {
+          await this[kPool].destroy(err);
+        }
+      }
+    };
+    module2.exports = Socks5ProxyAgent;
+  }
+});
+
 // node_modules/undici/lib/dispatcher/proxy-agent.js
 var require_proxy_agent = __commonJS({
   "node_modules/undici/lib/dispatcher/proxy-agent.js"(exports2, module2) {
@@ -10795,6 +11731,7 @@ var require_proxy_agent = __commonJS({
     var buildConnector = require_connect();
     var Client = require_client();
     var { channels } = require_diagnostics();
+    var Socks5ProxyAgent = require_socks5_proxy_agent();
     var kAgent = /* @__PURE__ */ Symbol("proxy agent");
     var kClient = /* @__PURE__ */ Symbol("proxy client");
     var kProxyHeaders = /* @__PURE__ */ Symbol("proxy headers");
@@ -10893,6 +11830,16 @@ var require_proxy_agent = __commonJS({
         const agentFactory = opts.factory || defaultAgentFactory;
         const factory = (origin2, options) => {
           const { protocol: protocol2 } = new URL(origin2);
+          if (this[kProxy].protocol === "socks5:" || this[kProxy].protocol === "socks:") {
+            return new Socks5ProxyAgent(this[kProxy].uri, {
+              headers: this[kProxyHeaders],
+              connect,
+              factory: agentFactory,
+              username: opts.username || username,
+              password: opts.password || password,
+              proxyTls: opts.proxyTls
+            });
+          }
           if (!this[kTunnelProxy] && protocol2 === "http:" && this[kProxy].protocol === "http:") {
             return new Http1ProxyWrapper(this[kProxy].uri, {
               headers: this[kProxyHeaders],
@@ -10902,11 +11849,19 @@ var require_proxy_agent = __commonJS({
           }
           return agentFactory(origin2, options);
         };
-        this[kClient] = clientFactory(url, { connect });
+        if (protocol === "socks5:" || protocol === "socks:") {
+          this[kClient] = null;
+        } else {
+          this[kClient] = clientFactory(url, { connect });
+        }
         this[kAgent] = new Agent({
           ...opts,
           factory,
           connect: async (opts2, callback) => {
+            if (!this[kClient]) {
+              callback(new InvalidArgumentError("Cannot establish tunnel connection without a proxy client"));
+              return;
+            }
             let requestedPath = opts2.host;
             if (!opts2.port) {
               requestedPath += `:${defaultProtocolPort(opts2.protocol)}`;
@@ -10986,16 +11941,18 @@ var require_proxy_agent = __commonJS({
         }
       }
       [kClose]() {
-        return Promise.all([
-          this[kAgent].close(),
-          this[kClient].close()
-        ]);
+        const promises = [this[kAgent].close()];
+        if (this[kClient]) {
+          promises.push(this[kClient].close());
+        }
+        return Promise.all(promises);
       }
       [kDestroy]() {
-        return Promise.all([
-          this[kAgent].destroy(),
-          this[kClient].destroy()
-        ]);
+        const promises = [this[kAgent].destroy()];
+        if (this[kClient]) {
+          promises.push(this[kClient].destroy());
+        }
+        return Promise.all(promises);
       }
     };
     function buildHeaders(headers) {
@@ -11099,14 +12056,11 @@ var require_env_http_proxy_agent = __commonJS({
           if (entry.port && entry.port !== port) {
             continue;
           }
-          if (!/^[.*]/.test(entry.hostname)) {
-            if (hostname === entry.hostname) {
-              return false;
-            }
-          } else {
-            if (hostname.endsWith(entry.hostname.replace(/^\*/, ""))) {
-              return false;
-            }
+          if (hostname === entry.hostname) {
+            return false;
+          }
+          if (hostname.slice(-(entry.hostname.length + 1)) === `.${entry.hostname}`) {
+            return false;
           }
         }
         return true;
@@ -11122,7 +12076,8 @@ var require_env_http_proxy_agent = __commonJS({
           }
           const parsed = entry.match(/^(.+):(\d+)$/);
           noProxyEntries.push({
-            hostname: (parsed ? parsed[1] : entry).toLowerCase(),
+            // strip leading dot or asterisk with dot
+            hostname: (parsed ? parsed[1] : entry).replace(/^\*?\./, "").toLowerCase(),
             port: parsed ? Number.parseInt(parsed[2], 10) : 0
           });
         }
@@ -12036,6 +12991,7 @@ var require_api_request = __commonJS({
           try {
             this.runInAsyncScope(callback, null, null, {
               statusCode,
+              statusText: statusMessage,
               headers,
               trailers: this.trailers,
               opaque,
@@ -12777,7 +13733,8 @@ var require_mock_symbols = __commonJS({
       kMockAgentAddCallHistoryLog: /* @__PURE__ */ Symbol("mock agent add call history log"),
       kMockAgentIsCallHistoryEnabled: /* @__PURE__ */ Symbol("mock agent is call history enabled"),
       kMockAgentAcceptsNonStandardSearchParameters: /* @__PURE__ */ Symbol("mock agent accepts non standard search parameters"),
-      kMockCallHistoryAddLog: /* @__PURE__ */ Symbol("mock call history add log")
+      kMockCallHistoryAddLog: /* @__PURE__ */ Symbol("mock call history add log"),
+      kTotalDispatchCount: /* @__PURE__ */ Symbol("total dispatch count")
     };
   }
 });
@@ -12792,7 +13749,8 @@ var require_mock_utils = __commonJS({
       kMockAgent,
       kOriginalDispatch,
       kOrigin,
-      kGetNetConnect
+      kGetNetConnect,
+      kTotalDispatchCount
     } = require_mock_symbols();
     var { serializePathWithQuery } = require_util();
     var { STATUS_CODES } = require("http");
@@ -12952,6 +13910,7 @@ var require_mock_utils = __commonJS({
       const replyData = typeof data === "function" ? { callback: data } : { ...data };
       const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } };
       mockDispatches.push(newMockDispatch);
+      mockDispatches[kTotalDispatchCount] = (mockDispatches[kTotalDispatchCount] || 0) + 1;
       return newMockDispatch;
     }
     function deleteMockDispatch(mockDispatches, key) {
@@ -13027,23 +13986,43 @@ var require_mock_utils = __commonJS({
         handler.onError(error);
         return true;
       }
+      let aborted = false;
+      let timer = null;
+      function abort(err) {
+        if (aborted) {
+          return;
+        }
+        aborted = true;
+        if (timer !== null) {
+          clearTimeout(timer);
+          timer = null;
+        }
+        handler.onError(err);
+      }
+      handler.onConnect?.(abort, null);
       if (typeof delay === "number" && delay > 0) {
-        setTimeout(() => {
+        timer = setTimeout(() => {
+          timer = null;
           handleReply(this[kDispatches]);
         }, delay);
       } else {
         handleReply(this[kDispatches]);
       }
       function handleReply(mockDispatches, _data = data) {
+        if (aborted) {
+          return;
+        }
         const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers;
         const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data;
         if (isPromise2(body)) {
           return body.then((newData) => handleReply(mockDispatches, newData));
         }
+        if (aborted) {
+          return;
+        }
         const responseData = getResponseData(body);
         const responseHeaders = generateKeyValues(headers);
         const responseTrailers = generateKeyValues(trailers);
-        handler.onConnect?.((err) => handler.onError(err), null);
         handler.onHeaders?.(statusCode, responseHeaders, resume, getStatusText(statusCode));
         handler.onData?.(Buffer.from(responseData));
         handler.onComplete?.(responseTrailers);
@@ -13064,13 +14043,16 @@ var require_mock_utils = __commonJS({
           } catch (error) {
             if (error.code === "UND_MOCK_ERR_MOCK_NOT_MATCHED") {
               const netConnect = agent[kGetNetConnect]();
+              const totalInterceptsCount = this[kDispatches][kTotalDispatchCount] || this[kDispatches].length;
+              const pendingInterceptsCount = this[kDispatches].filter(({ consumed }) => !consumed).length;
+              const interceptsMessage = `, ${pendingInterceptsCount} interceptor(s) remaining out of ${totalInterceptsCount} defined`;
               if (netConnect === false) {
-                throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
+                throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)${interceptsMessage}`);
               }
               if (checkNetConnect(netConnect, origin)) {
                 originalDispatch.call(this, opts, handler);
               } else {
-                throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
+                throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)${interceptsMessage}`);
               }
             } else {
               throw error;
@@ -13090,6 +14072,15 @@ var require_mock_utils = __commonJS({
       }
       return false;
     }
+    function normalizeOrigin(origin) {
+      if (typeof origin !== "string" && !(origin instanceof URL)) {
+        return origin;
+      }
+      if (origin instanceof URL) {
+        return origin.origin;
+      }
+      return origin.toLowerCase();
+    }
     function buildAndValidateMockOptions(opts) {
       const { agent, ...mockOptions } = opts;
       if ("enableCallHistory" in mockOptions && typeof mockOptions.enableCallHistory !== "boolean") {
@@ -13119,7 +14110,8 @@ var require_mock_utils = __commonJS({
       buildAndValidateMockOptions,
       getHeaderByName,
       buildHeadersFromArray,
-      normalizeSearchParams
+      normalizeSearchParams,
+      normalizeOrigin
     };
   }
 });
@@ -13677,7 +14669,7 @@ var require_mock_agent = __commonJS({
     } = require_mock_symbols();
     var MockClient = require_mock_client();
     var MockPool = require_mock_pool();
-    var { matchValue, normalizeSearchParams, buildAndValidateMockOptions } = require_mock_utils();
+    var { matchValue, normalizeSearchParams, buildAndValidateMockOptions, normalizeOrigin } = require_mock_utils();
     var { InvalidArgumentError, UndiciError } = require_errors();
     var Dispatcher = require_dispatcher();
     var PendingInterceptorsFormatter = require_pending_interceptors_formatter();
@@ -13703,7 +14695,8 @@ var require_mock_agent = __commonJS({
         }
       }
       get(origin) {
-        const originKey = this[kIgnoreTrailingSlash] ? origin.replace(/\/$/, "") : origin;
+        const normalizedOrigin = normalizeOrigin(origin);
+        const originKey = this[kIgnoreTrailingSlash] ? normalizedOrigin.replace(/\/$/, "") : normalizedOrigin;
         let dispatcher = this[kMockAgentGet](originKey);
         if (!dispatcher) {
           dispatcher = this[kFactory](originKey);
@@ -13712,6 +14705,7 @@ var require_mock_agent = __commonJS({
         return dispatcher;
       }
       dispatch(opts, handler) {
+        opts.origin = normalizeOrigin(opts.origin);
         this.get(opts.origin);
         this[kMockAgentAddCallHistoryLog](opts);
         const acceptNonStandardSearchParameters = this[kMockAgentAcceptsNonStandardSearchParameters];
@@ -14830,7 +15824,7 @@ var require_redirect_handler = __commonJS({
           }
         }
       } else if (headers && typeof headers === "object") {
-        const entries = typeof headers[Symbol.iterator] === "function" ? headers : Object.entries(headers);
+        const entries = util.hasSafeIterator(headers) ? headers : Object.entries(headers);
         for (const [key, value] of entries) {
           if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
             ret.push(key, value);
@@ -15068,6 +16062,85 @@ var require_dns = __commonJS({
     var DecoratorHandler = require_decorator_handler();
     var { InvalidArgumentError, InformationalError } = require_errors();
     var maxInt = Math.pow(2, 31) - 1;
+    function hasSafeIterator(headers) {
+      const prototype = Object.getPrototypeOf(headers);
+      const ownIterator = Object.prototype.hasOwnProperty.call(headers, Symbol.iterator);
+      return ownIterator || prototype != null && prototype !== Object.prototype && typeof headers[Symbol.iterator] === "function";
+    }
+    function isHostHeader(key) {
+      return typeof key === "string" && key.toLowerCase() === "host";
+    }
+    function normalizeHeaders(headers) {
+      if (headers == null) {
+        return null;
+      }
+      if (Array.isArray(headers)) {
+        if (headers.length === 0 || !Array.isArray(headers[0])) {
+          return headers;
+        }
+        const normalized = [];
+        for (const header of headers) {
+          if (Array.isArray(header) && header.length === 2) {
+            normalized.push(header[0], header[1]);
+          } else {
+            normalized.push(header);
+          }
+        }
+        return normalized;
+      }
+      if (typeof headers === "object" && hasSafeIterator(headers)) {
+        const normalized = [];
+        for (const header of headers) {
+          if (Array.isArray(header) && header.length === 2) {
+            normalized.push(header[0], header[1]);
+          } else {
+            normalized.push(header);
+          }
+        }
+        return normalized;
+      }
+      return headers;
+    }
+    function hasHostHeader(headers) {
+      if (headers == null) {
+        return false;
+      }
+      if (Array.isArray(headers)) {
+        if (headers.length === 0) {
+          return false;
+        }
+        for (let i = 0; i < headers.length; i += 2) {
+          if (isHostHeader(headers[i])) {
+            return true;
+          }
+        }
+        return false;
+      }
+      if (typeof headers === "object") {
+        for (const key in headers) {
+          if (isHostHeader(key)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    function withHostHeader(host, headers) {
+      const normalizedHeaders = normalizeHeaders(headers);
+      if (hasHostHeader(normalizedHeaders)) {
+        return normalizedHeaders;
+      }
+      if (Array.isArray(normalizedHeaders)) {
+        return ["host", host, ...normalizedHeaders];
+      }
+      if (normalizedHeaders && typeof normalizedHeaders === "object") {
+        return {
+          host,
+          ...normalizedHeaders
+        };
+      }
+      return { host };
+    }
     var DNSStorage = class {
       #maxItems = 0;
       #records = /* @__PURE__ */ new Map();
@@ -15326,7 +16399,8 @@ var require_dns = __commonJS({
               }
               const dispatchOpts = {
                 ...this.#opts,
-                origin: `${this.#origin.protocol}//${ip.family === 6 ? `[${ip.address}]` : ip.address}${port}`
+                origin: `${this.#origin.protocol}//${ip.family === 6 ? `[${ip.address}]` : ip.address}${port}`,
+                headers: withHostHeader(this.#origin.host, this.#opts.headers)
               };
               this.#dispatch(dispatchOpts, this);
               return;
@@ -15401,10 +16475,7 @@ var require_dns = __commonJS({
               servername: origin.hostname,
               // For SNI on TLS
               origin: newOrigin.origin,
-              headers: {
-                host: origin.host,
-                ...origDispatchOpts.headers
-              }
+              headers: withHostHeader(origin.host, origDispatchOpts.headers)
             };
             dispatch(
               dispatchOpts,
@@ -15427,7 +16498,8 @@ var require_cache = __commonJS({
     "use strict";
     var {
       safeHTTPMethods,
-      pathHasQueryOrFragment
+      pathHasQueryOrFragment,
+      hasSafeIterator
     } = require_util();
     var { serializePathWithQuery } = require_util();
     function makeCacheKey(opts) {
@@ -15449,22 +16521,23 @@ var require_cache = __commonJS({
       let headers;
       if (opts.headers == null) {
         headers = {};
-      } else if (typeof opts.headers[Symbol.iterator] === "function") {
+      } else if (typeof opts.headers === "object") {
         headers = {};
-        for (const x of opts.headers) {
-          if (!Array.isArray(x)) {
-            throw new Error("opts.headers is not a valid header map");
+        if (hasSafeIterator(opts.headers)) {
+          for (const x of opts.headers) {
+            if (!Array.isArray(x)) {
+              throw new Error("opts.headers is not a valid header map");
+            }
+            const [key, val] = x;
+            if (typeof key !== "string" || typeof val !== "string") {
+              throw new Error("opts.headers is not a valid header map");
+            }
+            headers[key.toLowerCase()] = val;
           }
-          const [key, val] = x;
-          if (typeof key !== "string" || typeof val !== "string") {
-            throw new Error("opts.headers is not a valid header map");
+        } else {
+          for (const key of Object.keys(opts.headers)) {
+            headers[key.toLowerCase()] = opts.headers[key];
           }
-          headers[key.toLowerCase()] = val;
-        }
-      } else if (typeof opts.headers === "object") {
-        headers = {};
-        for (const key of Object.keys(opts.headers)) {
-          headers[key.toLowerCase()] = opts.headers[key];
         }
       } else {
         throw new Error("opts.headers is not an object");
@@ -16288,7 +17361,7 @@ var require_cache_handler = __commonJS({
           return downstreamOnHeaders();
         }
         const cacheControlDirectives = cacheControlHeader ? parseCacheControlHeader(cacheControlHeader) : {};
-        if (!canCacheResponse(this.#cacheType, statusCode, resHeaders, cacheControlDirectives)) {
+        if (!canCacheResponse(this.#cacheType, statusCode, resHeaders, cacheControlDirectives, this.#cacheKey.headers)) {
           return downstreamOnHeaders();
         }
         const now = Date.now();
@@ -16326,40 +17399,67 @@ var require_cache_handler = __commonJS({
           deleteAt
         };
         if (statusCode === 304) {
-          const cachedValue = this.#store.get(this.#cacheKey);
-          if (!cachedValue) {
-            return downstreamOnHeaders();
-          }
-          value.statusCode = cachedValue.statusCode;
-          value.statusMessage = cachedValue.statusMessage;
-          value.etag = cachedValue.etag;
-          value.headers = { ...cachedValue.headers, ...strippedHeaders };
-          downstreamOnHeaders();
-          this.#writeStream = this.#store.createWriteStream(this.#cacheKey, value);
-          if (!this.#writeStream || !cachedValue?.body) {
-            return;
-          }
-          const bodyIterator = cachedValue.body.values();
-          const streamCachedBody = () => {
-            for (const chunk of bodyIterator) {
-              const full = this.#writeStream.write(chunk) === false;
-              this.#handler.onResponseData?.(controller, chunk);
-              if (full) {
-                break;
-              }
+          const handle304 = (cachedValue) => {
+            if (!cachedValue) {
+              return downstreamOnHeaders();
             }
-          };
-          this.#writeStream.on("error", function() {
-            handler.#writeStream = void 0;
-            handler.#store.delete(handler.#cacheKey);
-          }).on("drain", () => {
-            streamCachedBody();
-          }).on("close", function() {
-            if (handler.#writeStream === this) {
-              handler.#writeStream = void 0;
+            value.statusCode = cachedValue.statusCode;
+            value.statusMessage = cachedValue.statusMessage;
+            value.etag = cachedValue.etag;
+            value.headers = { ...cachedValue.headers, ...strippedHeaders };
+            downstreamOnHeaders();
+            this.#writeStream = this.#store.createWriteStream(this.#cacheKey, value);
+            if (!this.#writeStream || !cachedValue?.body) {
+              return;
             }
-          });
-          streamCachedBody();
+            if (typeof cachedValue.body.values === "function") {
+              const bodyIterator = cachedValue.body.values();
+              const streamCachedBody = () => {
+                for (const chunk of bodyIterator) {
+                  const full = this.#writeStream.write(chunk) === false;
+                  this.#handler.onResponseData?.(controller, chunk);
+                  if (full) {
+                    break;
+                  }
+                }
+              };
+              this.#writeStream.on("error", function() {
+                handler.#writeStream = void 0;
+                handler.#store.delete(handler.#cacheKey);
+              }).on("drain", () => {
+                streamCachedBody();
+              }).on("close", function() {
+                if (handler.#writeStream === this) {
+                  handler.#writeStream = void 0;
+                }
+              });
+              streamCachedBody();
+            } else if (typeof cachedValue.body.on === "function") {
+              cachedValue.body.on("data", (chunk) => {
+                this.#writeStream.write(chunk);
+                this.#handler.onResponseData?.(controller, chunk);
+              }).on("end", () => {
+                this.#writeStream.end();
+              }).on("error", () => {
+                this.#writeStream = void 0;
+                this.#store.delete(this.#cacheKey);
+              });
+              this.#writeStream.on("error", function() {
+                handler.#writeStream = void 0;
+                handler.#store.delete(handler.#cacheKey);
+              }).on("close", function() {
+                if (handler.#writeStream === this) {
+                  handler.#writeStream = void 0;
+                }
+              });
+            }
+          };
+          const result = this.#store.get(this.#cacheKey);
+          if (result && typeof result.then === "function") {
+            result.then(handle304);
+          } else {
+            handle304(result);
+          }
         } else {
           if (typeof resHeaders.etag === "string" && isEtagUsable(resHeaders.etag)) {
             value.etag = resHeaders.etag;
@@ -16396,7 +17496,7 @@ var require_cache_handler = __commonJS({
         this.#handler.onResponseError?.(controller, err);
       }
     };
-    function canCacheResponse(cacheType, statusCode, resHeaders, cacheControlDirectives) {
+    function canCacheResponse(cacheType, statusCode, resHeaders, cacheControlDirectives, reqHeaders) {
       if (statusCode < 200 || NOT_UNDERSTOOD_STATUS_CODES.includes(statusCode)) {
         return false;
       }
@@ -16413,8 +17513,11 @@ var require_cache_handler = __commonJS({
       if (resHeaders.vary?.includes("*")) {
         return false;
       }
-      if (resHeaders.authorization) {
-        if (!cacheControlDirectives.public || typeof resHeaders.authorization !== "string") {
+      if (reqHeaders?.authorization) {
+        if (!cacheControlDirectives.public && !cacheControlDirectives["s-maxage"] && !cacheControlDirectives["must-revalidate"]) {
+          return false;
+        }
+        if (typeof reqHeaders.authorization !== "string") {
           return false;
         }
         if (Array.isArray(cacheControlDirectives["no-cache"]) && cacheControlDirectives["no-cache"].includes("authorization")) {
@@ -16483,9 +17586,13 @@ var require_cache_handler = __commonJS({
       if (cacheControlDirectives["stale-if-error"]) {
         staleIfError = staleAt + cacheControlDirectives["stale-if-error"] * 1e3;
       }
-      if (staleWhileRevalidate === -Infinity && staleIfError === -Infinity) {
+      if (cacheControlDirectives.immutable && staleWhileRevalidate === -Infinity && staleIfError === -Infinity) {
         immutable = now + 31536e6;
       }
+      if (staleWhileRevalidate === -Infinity && staleIfError === -Infinity && immutable === -Infinity) {
+        const freshnessLifetime = staleAt - now;
+        return staleAt + freshnessLifetime;
+      }
       return Math.max(staleAt, staleWhileRevalidate, staleIfError, immutable);
     }
     function stripNecessaryHeaders(resHeaders, cacheControlDirectives) {
@@ -16806,6 +17913,18 @@ var require_cache2 = __commonJS({
     var CacheRevalidationHandler = require_cache_revalidation_handler();
     var { assertCacheStore, assertCacheMethods, makeCacheKey, normalizeHeaders, parseCacheControlHeader } = require_cache();
     var { AbortError } = require_errors();
+    function assertCacheOrigins(origins, name) {
+      if (origins === void 0) return;
+      if (!Array.isArray(origins)) {
+        throw new TypeError(`expected ${name} to be an array or undefined, got ${typeof origins}`);
+      }
+      for (let i = 0; i < origins.length; i++) {
+        const origin = origins[i];
+        if (typeof origin !== "string" && !(origin instanceof RegExp)) {
+          throw new TypeError(`expected ${name}[${i}] to be a string or RegExp, got ${typeof origin}`);
+        }
+      }
+    }
     var nop = () => {
     };
     function needsRevalidation(result, cacheControlDirectives, { headers = {} }) {
@@ -16950,7 +18069,7 @@ var require_cache2 = __commonJS({
         if (!revalidate && withinStaleWhileRevalidateWindow(result)) {
           sendCachedValue(handler, opts, result, age, null, true);
           queueMicrotask(() => {
-            let headers2 = {
+            const headers2 = {
               ...opts.headers,
               "if-modified-since": new Date(result.cachedAt).toUTCString()
             };
@@ -16958,10 +18077,11 @@ var require_cache2 = __commonJS({
               headers2["if-none-match"] = result.etag;
             }
             if (result.vary) {
-              headers2 = {
-                ...headers2,
-                ...result.vary
-              };
+              for (const key in result.vary) {
+                if (result.vary[key] != null) {
+                  headers2[key] = result.vary[key];
+                }
+              }
             }
             dispatch(
               {
@@ -16992,7 +18112,7 @@ var require_cache2 = __commonJS({
         if (staleIfErrorExpiry) {
           withinStaleIfErrorThreshold = now < result.staleAt + staleIfErrorExpiry * 1e3;
         }
-        let headers = {
+        const headers = {
           ...opts.headers,
           "if-modified-since": new Date(result.cachedAt).toUTCString()
         };
@@ -17000,10 +18120,11 @@ var require_cache2 = __commonJS({
           headers["if-none-match"] = result.etag;
         }
         if (result.vary) {
-          headers = {
-            ...headers,
-            ...result.vary
-          };
+          for (const key in result.vary) {
+            if (result.vary[key] != null) {
+              headers[key] = result.vary[key];
+            }
+          }
         }
         return dispatch(
           {
@@ -17033,13 +18154,15 @@ var require_cache2 = __commonJS({
         store = new MemoryCacheStore(),
         methods = ["GET"],
         cacheByDefault = void 0,
-        type = "shared"
+        type = "shared",
+        origins = void 0
       } = opts;
       if (typeof opts !== "object" || opts === null) {
         throw new TypeError(`expected type of opts to be an Object, got ${opts === null ? "null" : typeof opts}`);
       }
       assertCacheStore(store, "opts.store");
       assertCacheMethods(methods, "opts.methods");
+      assertCacheOrigins(origins, "opts.origins");
       if (typeof cacheByDefault !== "undefined" && typeof cacheByDefault !== "number") {
         throw new TypeError(`expected opts.cacheByDefault to be number or undefined, got ${typeof cacheByDefault}`);
       }
@@ -17058,6 +18181,25 @@ var require_cache2 = __commonJS({
           if (!opts2.origin || safeMethodsToNotCache.includes(opts2.method)) {
             return dispatch(opts2, handler);
           }
+          if (origins !== void 0) {
+            const requestOrigin = opts2.origin.toString().toLowerCase();
+            let isAllowed = false;
+            for (let i = 0; i < origins.length; i++) {
+              const allowed = origins[i];
+              if (typeof allowed === "string") {
+                if (allowed.toLowerCase() === requestOrigin) {
+                  isAllowed = true;
+                  break;
+                }
+              } else if (allowed.test(requestOrigin)) {
+                isAllowed = true;
+                break;
+              }
+            }
+            if (!isAllowed) {
+              return dispatch(opts2, handler);
+            }
+          }
           opts2 = {
             ...opts2,
             headers: normalizeHeaders(opts2)
@@ -17123,8 +18265,6 @@ var require_decompress = __commonJS({
     var DecompressHandler = class extends DecoratorHandler {
       /** @type {Transform[]} */
       #decompressors = [];
-      /** @type {NodeJS.WritableStream&NodeJS.ReadableStream|null} */
-      #pipelineStream;
       /** @type {Readonly<number[]>} */
       #skipStatusCodes;
       /** @type {boolean} */
@@ -17211,7 +18351,7 @@ var require_decompress = __commonJS({
       #setupMultipleDecompressors(controller) {
         const lastDecompressor = this.#decompressors[this.#decompressors.length - 1];
         this.#setupDecompressorEvents(lastDecompressor, controller);
-        this.#pipelineStream = pipeline(this.#decompressors, (err) => {
+        pipeline(this.#decompressors, (err) => {
           if (err) {
             super.onResponseError(controller, err);
             return;
@@ -17225,7 +18365,6 @@ var require_decompress = __commonJS({
        */
       #cleanupDecompressors() {
         this.#decompressors.length = 0;
-        this.#pipelineStream = null;
       }
       /**
        * @param {Controller} controller
@@ -17251,7 +18390,7 @@ var require_decompress = __commonJS({
         } else {
           this.#setupMultipleDecompressors(controller);
         }
-        super.onResponseStart(controller, statusCode, newHeaders, statusMessage);
+        return super.onResponseStart(controller, statusCode, newHeaders, statusMessage);
       }
       /**
        * @param {Controller} controller
@@ -17316,19 +18455,21 @@ var require_decompress = __commonJS({
 var require_deduplication_handler = __commonJS({
   "node_modules/undici/lib/handler/deduplication-handler.js"(exports2, module2) {
     "use strict";
+    var { RequestAbortedError } = require_errors();
+    var DEFAULT_MAX_BUFFER_SIZE = 5 * 1024 * 1024;
     var DeduplicationHandler = class {
       /**
        * @type {DispatchHandler}
        */
       #primaryHandler;
       /**
-       * @type {DispatchHandler[]}
+       * @type {WaitingHandler[]}
        */
       #waitingHandlers = [];
       /**
-       * @type {Buffer[]}
+       * @type {number}
        */
-      #chunks = [];
+      #maxBufferSize = DEFAULT_MAX_BUFFER_SIZE;
       /**
        * @type {number}
        */
@@ -17345,6 +18486,18 @@ var require_deduplication_handler = __commonJS({
        * @type {boolean}
        */
       #aborted = false;
+      /**
+       * @type {boolean}
+       */
+      #responseStarted = false;
+      /**
+       * @type {boolean}
+       */
+      #responseDataStarted = false;
+      /**
+       * @type {boolean}
+       */
+      #completed = false;
       /**
        * @type {import('../../types/dispatcher.d.ts').default.DispatchController | null}
        */
@@ -17356,20 +18509,51 @@ var require_deduplication_handler = __commonJS({
       /**
        * @param {DispatchHandler} primaryHandler The primary handler
        * @param {() => void} onComplete Callback when request completes
+       * @param {number} [maxBufferSize] Maximum paused buffer size per waiting handler
        */
-      constructor(primaryHandler, onComplete) {
+      constructor(primaryHandler, onComplete, maxBufferSize = DEFAULT_MAX_BUFFER_SIZE) {
         this.#primaryHandler = primaryHandler;
         this.#onComplete = onComplete;
+        this.#maxBufferSize = maxBufferSize;
       }
       /**
-       * Add a waiting handler that will receive the buffered response
+       * Add a waiting handler that will receive response events.
+       * Returns false if deduplication can no longer safely attach this handler.
+       *
        * @param {DispatchHandler} handler
+       * @returns {boolean}
        */
       addWaitingHandler(handler) {
-        this.#waitingHandlers.push(handler);
+        if (this.#completed || this.#responseDataStarted) {
+          return false;
+        }
+        const waitingHandler = this.#createWaitingHandler(handler);
+        const waitingController = waitingHandler.controller;
+        try {
+          handler.onRequestStart?.(waitingController, null);
+          if (waitingController.aborted) {
+            waitingHandler.done = true;
+            return true;
+          }
+          if (this.#responseStarted) {
+            handler.onResponseStart?.(
+              waitingController,
+              this.#statusCode,
+              this.#headers,
+              this.#statusMessage
+            );
+          }
+        } catch {
+          waitingHandler.done = true;
+          return true;
+        }
+        if (!waitingController.aborted) {
+          this.#waitingHandlers.push(waitingHandler);
+        }
+        return true;
       }
       /**
-       * @param {() => void} abort
+       * @param {import('../../types/dispatcher.d.ts').default.DispatchController} controller
        * @param {any} context
        */
       onRequestStart(controller, context) {
@@ -17392,26 +18576,95 @@ var require_deduplication_handler = __commonJS({
        * @param {string} statusMessage
        */
       onResponseStart(controller, statusCode, headers, statusMessage) {
+        this.#responseStarted = true;
         this.#statusCode = statusCode;
         this.#headers = headers;
         this.#statusMessage = statusMessage;
         this.#primaryHandler.onResponseStart?.(controller, statusCode, headers, statusMessage);
+        for (const waitingHandler of this.#waitingHandlers) {
+          const { handler, controller: waitingController } = waitingHandler;
+          if (waitingHandler.done || waitingController.aborted) {
+            waitingHandler.done = true;
+            continue;
+          }
+          try {
+            handler.onResponseStart?.(
+              waitingController,
+              statusCode,
+              headers,
+              statusMessage
+            );
+          } catch {
+          }
+          if (waitingController.aborted) {
+            waitingHandler.done = true;
+          }
+        }
+        this.#pruneDoneWaitingHandlers();
       }
       /**
        * @param {import('../../types/dispatcher.d.ts').default.DispatchController} controller
        * @param {Buffer} chunk
        */
       onResponseData(controller, chunk) {
-        this.#chunks.push(Buffer.from(chunk));
+        if (this.#aborted || this.#completed) {
+          return;
+        }
+        this.#responseDataStarted = true;
         this.#primaryHandler.onResponseData?.(controller, chunk);
+        for (const waitingHandler of this.#waitingHandlers) {
+          const { handler, controller: waitingController } = waitingHandler;
+          if (waitingHandler.done || waitingController.aborted) {
+            waitingHandler.done = true;
+            continue;
+          }
+          if (waitingController.paused) {
+            this.#bufferWaitingChunk(waitingHandler, chunk);
+            continue;
+          }
+          try {
+            handler.onResponseData?.(waitingController, chunk);
+          } catch {
+          }
+          if (waitingController.aborted) {
+            waitingHandler.done = true;
+            waitingHandler.bufferedChunks = [];
+            waitingHandler.bufferedBytes = 0;
+          }
+        }
+        this.#pruneDoneWaitingHandlers();
       }
       /**
        * @param {import('../../types/dispatcher.d.ts').default.DispatchController} controller
        * @param {object} trailers
        */
       onResponseEnd(controller, trailers) {
+        if (this.#aborted || this.#completed) {
+          return;
+        }
+        this.#completed = true;
         this.#primaryHandler.onResponseEnd?.(controller, trailers);
-        this.#notifyWaitingHandlers();
+        for (const waitingHandler of this.#waitingHandlers) {
+          if (waitingHandler.done || waitingHandler.controller.aborted) {
+            waitingHandler.done = true;
+            continue;
+          }
+          this.#flushWaitingHandler(waitingHandler);
+          if (waitingHandler.done || waitingHandler.controller.aborted) {
+            waitingHandler.done = true;
+            continue;
+          }
+          if (waitingHandler.controller.paused && waitingHandler.bufferedChunks.length > 0) {
+            waitingHandler.pendingTrailers = trailers;
+            continue;
+          }
+          try {
+            waitingHandler.handler.onResponseEnd?.(waitingHandler.controller, trailers);
+          } catch {
+          }
+          waitingHandler.done = true;
+        }
+        this.#pruneDoneWaitingHandlers();
         this.#onComplete?.();
       }
       /**
@@ -17419,89 +18672,138 @@ var require_deduplication_handler = __commonJS({
        * @param {Error} err
        */
       onResponseError(controller, err) {
+        if (this.#completed) {
+          return;
+        }
         this.#aborted = true;
+        this.#completed = true;
         this.#primaryHandler.onResponseError?.(controller, err);
-        this.#notifyWaitingHandlersError(err);
+        for (const waitingHandler of this.#waitingHandlers) {
+          this.#errorWaitingHandler(waitingHandler, err);
+        }
+        this.#waitingHandlers = [];
         this.#onComplete?.();
       }
       /**
-       * Notify all waiting handlers with the buffered response
+       * @param {DispatchHandler} handler
+       * @returns {WaitingHandler}
        */
-      #notifyWaitingHandlers() {
-        const body = Buffer.concat(this.#chunks);
-        for (const handler of this.#waitingHandlers) {
-          const waitingController = {
-            resume() {
-            },
-            pause() {
-            },
-            get paused() {
-              return false;
-            },
-            get aborted() {
-              return false;
-            },
-            get reason() {
-              return null;
-            },
-            abort() {
-            }
-          };
-          try {
-            handler.onRequestStart?.(waitingController, null);
-            if (waitingController.aborted) {
-              continue;
+      #createWaitingHandler(handler) {
+        const waitingHandler = {
+          handler,
+          controller: null,
+          bufferedChunks: [],
+          bufferedBytes: 0,
+          pendingTrailers: null,
+          done: false
+        };
+        const state = {
+          aborted: false,
+          paused: false,
+          reason: null
+        };
+        waitingHandler.controller = {
+          resume: () => {
+            if (state.aborted) {
+              return;
             }
-            handler.onResponseStart?.(
-              waitingController,
-              this.#statusCode,
-              this.#headers,
-              this.#statusMessage
-            );
-            if (waitingController.aborted) {
-              continue;
+            state.paused = false;
+            this.#flushWaitingHandler(waitingHandler);
+            if (this.#completed && waitingHandler.pendingTrailers && waitingHandler.bufferedChunks.length === 0 && !state.paused && !state.aborted) {
+              try {
+                waitingHandler.handler.onResponseEnd?.(waitingHandler.controller, waitingHandler.pendingTrailers);
+              } catch {
+              }
+              waitingHandler.pendingTrailers = null;
+              waitingHandler.done = true;
             }
-            if (body.length > 0) {
-              handler.onResponseData?.(waitingController, body);
+            this.#pruneDoneWaitingHandlers();
+          },
+          pause: () => {
+            if (!state.aborted) {
+              state.paused = true;
             }
-            handler.onResponseEnd?.(waitingController, {});
-          } catch {
+          },
+          get paused() {
+            return state.paused;
+          },
+          get aborted() {
+            return state.aborted;
+          },
+          get reason() {
+            return state.reason;
+          },
+          abort: (reason) => {
+            state.aborted = true;
+            state.reason = reason ?? null;
+            waitingHandler.done = true;
+            waitingHandler.pendingTrailers = null;
+            waitingHandler.bufferedChunks = [];
+            waitingHandler.bufferedBytes = 0;
           }
+        };
+        return waitingHandler;
+      }
+      /**
+       * @param {WaitingHandler} waitingHandler
+       * @param {Buffer} chunk
+       */
+      #bufferWaitingChunk(waitingHandler, chunk) {
+        if (waitingHandler.done || waitingHandler.controller.aborted) {
+          waitingHandler.done = true;
+          waitingHandler.bufferedChunks = [];
+          waitingHandler.bufferedBytes = 0;
+          return;
+        }
+        const bufferedChunk = Buffer.from(chunk);
+        waitingHandler.bufferedChunks.push(bufferedChunk);
+        waitingHandler.bufferedBytes += bufferedChunk.length;
+        if (waitingHandler.bufferedBytes > this.#maxBufferSize) {
+          const err = new RequestAbortedError(`Deduplicated waiting handler exceeded maxBufferSize (${this.#maxBufferSize} bytes) while paused`);
+          this.#errorWaitingHandler(waitingHandler, err);
         }
-        this.#waitingHandlers = [];
-        this.#chunks = [];
       }
       /**
-       * Notify all waiting handlers of an error
-       * @param {Error} err
+       * @param {WaitingHandler} waitingHandler
        */
-      #notifyWaitingHandlersError(err) {
-        for (const handler of this.#waitingHandlers) {
-          const waitingController = {
-            resume() {
-            },
-            pause() {
-            },
-            get paused() {
-              return false;
-            },
-            get aborted() {
-              return true;
-            },
-            get reason() {
-              return err;
-            },
-            abort() {
-            }
-          };
+      #flushWaitingHandler(waitingHandler) {
+        const { handler, controller } = waitingHandler;
+        while (!waitingHandler.done && !controller.aborted && !controller.paused && waitingHandler.bufferedChunks.length > 0) {
+          const bufferedChunk = waitingHandler.bufferedChunks.shift();
+          waitingHandler.bufferedBytes -= bufferedChunk.length;
           try {
-            handler.onRequestStart?.(waitingController, null);
-            handler.onResponseError?.(waitingController, err);
+            handler.onResponseData?.(controller, bufferedChunk);
           } catch {
           }
+          if (controller.aborted) {
+            waitingHandler.done = true;
+            waitingHandler.pendingTrailers = null;
+            waitingHandler.bufferedChunks = [];
+            waitingHandler.bufferedBytes = 0;
+            break;
+          }
         }
-        this.#waitingHandlers = [];
-        this.#chunks = [];
+      }
+      /**
+       * @param {WaitingHandler} waitingHandler
+       * @param {Error} err
+       */
+      #errorWaitingHandler(waitingHandler, err) {
+        if (waitingHandler.done) {
+          return;
+        }
+        waitingHandler.done = true;
+        waitingHandler.pendingTrailers = null;
+        waitingHandler.bufferedChunks = [];
+        waitingHandler.bufferedBytes = 0;
+        try {
+          waitingHandler.controller.abort(err);
+          waitingHandler.handler.onResponseError?.(waitingHandler.controller, err);
+        } catch {
+        }
+      }
+      #pruneDoneWaitingHandlers() {
+        this.#waitingHandlers = this.#waitingHandlers.filter((waitingHandler) => waitingHandler.done === false);
       }
     };
     module2.exports = DeduplicationHandler;
@@ -17521,7 +18823,8 @@ var require_deduplicate = __commonJS({
       const {
         methods = ["GET"],
         skipHeaderNames = [],
-        excludeHeaderNames = []
+        excludeHeaderNames = [],
+        maxBufferSize = 5 * 1024 * 1024
       } = opts;
       if (typeof opts !== "object" || opts === null) {
         throw new TypeError(`expected type of opts to be an Object, got ${opts === null ? "null" : typeof opts}`);
@@ -17540,13 +18843,15 @@ var require_deduplicate = __commonJS({
       if (!Array.isArray(excludeHeaderNames)) {
         throw new TypeError(`expected opts.excludeHeaderNames to be an array, got ${typeof excludeHeaderNames}`);
       }
+      if (!Number.isFinite(maxBufferSize) || maxBufferSize <= 0) {
+        throw new TypeError(`expected opts.maxBufferSize to be a positive finite number, got ${maxBufferSize}`);
+      }
       const skipHeaderNamesSet = new Set(skipHeaderNames.map((name) => name.toLowerCase()));
       const excludeHeaderNamesSet = new Set(excludeHeaderNames.map((name) => name.toLowerCase()));
-      const safeMethodsToNotDeduplicate = util.safeHTTPMethods.filter((method) => methods.includes(method) === false);
       const pendingRequests = /* @__PURE__ */ new Map();
       return (dispatch) => {
         return (opts2, handler) => {
-          if (!opts2.origin || safeMethodsToNotDeduplicate.includes(opts2.method)) {
+          if (!opts2.origin || methods.includes(opts2.method) === false) {
             return dispatch(opts2, handler);
           }
           opts2 = {
@@ -17564,8 +18869,10 @@ var require_deduplicate = __commonJS({
           const dedupeKey = makeDeduplicationKey(cacheKey, excludeHeaderNamesSet);
           const pendingHandler = pendingRequests.get(dedupeKey);
           if (pendingHandler) {
-            pendingHandler.addWaitingHandler(handler);
-            return true;
+            if (pendingHandler.addWaitingHandler(handler)) {
+              return true;
+            }
+            return dispatch(opts2, handler);
           }
           const deduplicationHandler = new DeduplicationHandler(
             handler,
@@ -17574,7 +18881,8 @@ var require_deduplicate = __commonJS({
               if (pendingRequestsChannel.hasSubscribers) {
                 pendingRequestsChannel.publish({ size: pendingRequests.size, key: dedupeKey, type: "removed" });
               }
-            }
+            },
+            maxBufferSize
           );
           pendingRequests.set(dedupeKey, deduplicationHandler);
           if (pendingRequestsChannel.hasSubscribers) {
@@ -18555,7 +19863,7 @@ var require_response = __commonJS({
           });
         }
         const clonedResponse = cloneResponse(this.#state);
-        if (this.#state.body?.stream) {
+        if (this.#state.urlList.length !== 0 && this.#state.body?.stream) {
           streamRegistry.register(this, new WeakRef(this.#state.body.stream));
         }
         return fromInnerResponse(clonedResponse, getHeadersGuard(this.#headers));
@@ -18766,7 +20074,7 @@ var require_response = __commonJS({
       setResponseHeaders(response, headers);
       setHeadersList(headers, innerResponse.headersList);
       setHeadersGuard(headers, guard);
-      if (innerResponse.body?.stream) {
+      if (innerResponse.urlList.length !== 0 && innerResponse.body?.stream) {
         streamRegistry.register(response, new WeakRef(innerResponse.body.stream));
       }
       return response;
@@ -19425,6 +20733,8 @@ var require_request2 = __commonJS({
         preventNoCacheCacheControlHeaderModification: init.preventNoCacheCacheControlHeaderModification ?? false,
         done: init.done ?? false,
         timingAllowFailed: init.timingAllowFailed ?? false,
+        useURLCredentials: init.useURLCredentials ?? void 0,
+        traversableForUserPrompts: init.traversableForUserPrompts ?? "client",
         urlList: init.urlList,
         url: init.urlList[0],
         headersList: init.headersList ? new HeadersList(init.headersList) : new HeadersList()
@@ -19766,7 +21076,10 @@ var require_fetch = __commonJS({
       simpleRangeHeaderValue,
       buildContentRange,
       createInflate,
-      extractMimeType
+      extractMimeType,
+      hasAuthenticationEntry,
+      includesCredentials,
+      isTraversableNavigable
     } = require_util2();
     var assert5 = require("assert");
     var { safelyExtractBody, extractBody } = require_body();
@@ -19837,7 +21150,7 @@ var require_fetch = __commonJS({
       }
       const request = getRequestState(requestObject);
       if (requestObject.signal.aborted) {
-        abortFetch(p, request, null, requestObject.signal.reason);
+        abortFetch(p, request, null, requestObject.signal.reason, null);
         return p.promise;
       }
       const globalObject = request.client.globalObject;
@@ -19854,7 +21167,7 @@ var require_fetch = __commonJS({
           assert5(controller != null);
           controller.abort(requestObject.signal.reason);
           const realResponse = responseObject?.deref();
-          abortFetch(p, request, realResponse, requestObject.signal.reason);
+          abortFetch(p, request, realResponse, requestObject.signal.reason, controller.controller);
         }
       );
       const processResponse = (response) => {
@@ -19862,7 +21175,7 @@ var require_fetch = __commonJS({
           return;
         }
         if (response.aborted) {
-          abortFetch(p, request, responseObject, controller.serializedAbortReason);
+          abortFetch(p, request, responseObject, controller.serializedAbortReason, controller.controller);
           return;
         }
         if (response.type === "error") {
@@ -19877,8 +21190,11 @@ var require_fetch = __commonJS({
         request,
         processResponseEndOfBody: handleFetchDone,
         processResponse,
-        dispatcher: getRequestDispatcher(requestObject)
+        dispatcher: getRequestDispatcher(requestObject),
         // undici
+        // Keep requestObject alive to prevent its AbortController from being GC'd
+        // See https://github.com/nodejs/undici/issues/4627
+        requestObject
       });
       return p.promise;
     }
@@ -19918,7 +21234,7 @@ var require_fetch = __commonJS({
       );
     }
     var markResourceTiming = performance.markResourceTiming;
-    function abortFetch(p, request, responseObject, error) {
+    function abortFetch(p, request, responseObject, error, controller) {
       if (p) {
         p.reject(error);
       }
@@ -19935,12 +21251,7 @@ var require_fetch = __commonJS({
       }
       const response = getResponseState(responseObject);
       if (response.body?.stream != null && isReadable(response.body.stream)) {
-        response.body.stream.cancel(error).catch((err) => {
-          if (err.code === "ERR_INVALID_STATE") {
-            return;
-          }
-          throw err;
-        });
+        controller.error(error);
       }
     }
     function fetching({
@@ -19951,8 +21262,10 @@ var require_fetch = __commonJS({
       processResponseEndOfBody,
       processResponseConsumeBody,
       useParallelQueue = false,
-      dispatcher = getGlobalDispatcher()
+      dispatcher = getGlobalDispatcher(),
       // undici
+      requestObject = null
+      // Keep alive to prevent AbortController GC, see #4627
     }) {
       assert5(dispatcher);
       let taskDestination = null;
@@ -19975,7 +21288,9 @@ var require_fetch = __commonJS({
         processResponseConsumeBody,
         processResponseEndOfBody,
         taskDestination,
-        crossOriginIsolatedCapability
+        crossOriginIsolatedCapability,
+        // Keep requestObject alive to prevent its AbortController from being GC'd
+        requestObject
       };
       assert5(!request.body || request.body.stream);
       if (request.window === "client") {
@@ -20424,6 +21739,17 @@ var require_fetch = __commonJS({
       }
       httpRequest.headersList.delete("host", true);
       if (includeCredentials) {
+        if (!httpRequest.headersList.contains("authorization", true)) {
+          let authorizationValue = null;
+          if (hasAuthenticationEntry(httpRequest) && (httpRequest.useURLCredentials === void 0 || !includesCredentials(requestCurrentURL(httpRequest)))) {
+          } else if (includesCredentials(requestCurrentURL(httpRequest)) && isAuthenticationFetch) {
+            const { username, password } = requestCurrentURL(httpRequest);
+            authorizationValue = `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`;
+          }
+          if (authorizationValue !== null) {
+            httpRequest.headersList.append("Authorization", authorizationValue, false);
+          }
+        }
       }
       if (httpCache == null) {
         httpRequest.cache = "no-store";
@@ -20452,6 +21778,22 @@ var require_fetch = __commonJS({
         response.rangeRequested = true;
       }
       response.requestIncludesCredentials = includeCredentials;
+      if (response.status === 401 && httpRequest.responseTainting !== "cors" && includeCredentials && isTraversableNavigable(request.traversableForUserPrompts)) {
+        if (request.body != null) {
+          if (request.body.source == null) {
+            return makeNetworkError("expected non-null body source");
+          }
+          request.body = safelyExtractBody(request.body.source)[0];
+        }
+        if (request.useURLCredentials === void 0 || isAuthenticationFetch) {
+          if (isCancelled(fetchParams)) {
+            return makeAppropriateNetworkError(fetchParams);
+          }
+          return response;
+        }
+        fetchParams.controller.connection.destroy();
+        response = await httpNetworkOrCacheFetch(fetchParams, true);
+      }
       if (response.status === 407) {
         if (request.window === "no-window") {
           return makeNetworkError();
@@ -20646,9 +21988,11 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url = requestCurrentURL(request);
         const agent = fetchParams.controller.dispatcher;
+        const path26 = url.pathname + url.search;
+        const hasTrailingQuestionMark = url.search.length === 0 && url.href[url.href.length - url.hash.length - 1] === "?";
         return new Promise((resolve4, reject) => agent.dispatch(
           {
-            path: url.pathname + url.search,
+            path: hasTrailingQuestionMark ? `${path26}?` : path26,
             origin: url.origin,
             method: request.method,
             body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
@@ -20761,6 +22105,32 @@ var require_fetch = __commonJS({
               fetchParams.controller.terminate(error);
               reject(error);
             },
+            onRequestUpgrade(_controller, status, headers, socket) {
+              if (socket.session != null && status !== 200 || socket.session == null && status !== 101) {
+                return false;
+              }
+              const headersList = new HeadersList();
+              for (const [name, value] of Object.entries(headers)) {
+                if (value == null) {
+                  continue;
+                }
+                const headerName = name.toLowerCase();
+                if (Array.isArray(value)) {
+                  for (const entry of value) {
+                    headersList.append(headerName, String(entry), true);
+                  }
+                } else {
+                  headersList.append(headerName, String(value), true);
+                }
+              }
+              resolve4({
+                status,
+                statusText: STATUS_CODES[status],
+                headersList,
+                socket
+              });
+              return true;
+            },
             onUpgrade(status, rawHeaders, socket) {
               if (socket.session != null && status !== 200 || socket.session == null && status !== 101) {
                 return false;
@@ -21309,8 +22679,8 @@ var require_cache3 = __commonJS({
         }
         const responseList = [];
         for (const response of responses) {
-          const responseObject = fromInnerResponse(response, "immutable");
-          responseList.push(responseObject.clone());
+          const responseObject = fromInnerResponse(cloneResponse(response), "immutable");
+          responseList.push(responseObject);
           if (responseList.length >= maxResponses) {
             break;
           }
@@ -22359,13 +23729,17 @@ var require_util5 = __commonJS({
       return extensionList;
     }
     function isValidClientWindowBits(value) {
+      if (value.length === 0) {
+        return false;
+      }
       for (let i = 0; i < value.length; i++) {
         const byte = value.charCodeAt(i);
         if (byte < 48 || byte > 57) {
           return false;
         }
       }
-      return true;
+      const num = Number.parseInt(value, 10);
+      return num >= 8 && num <= 15;
     }
     function getURLRecord(url, baseURL) {
       let urlRecord;
@@ -22566,7 +23940,8 @@ var require_connection = __commonJS({
         mode: "websocket",
         credentials: "include",
         cache: "no-store",
-        redirect: "error"
+        redirect: "error",
+        useURLCredentials: true
       });
       if (options.headers) {
         const headersList = getHeadersList(new Headers(options.headers));
@@ -22701,18 +24076,31 @@ var require_permessage_deflate = __commonJS({
     "use strict";
     var { createInflateRaw, Z_DEFAULT_WINDOWBITS } = require("zlib");
     var { isValidClientWindowBits } = require_util5();
+    var { MessageSizeExceededError } = require_errors();
     var tail = Buffer.from([0, 0, 255, 255]);
     var kBuffer = /* @__PURE__ */ Symbol("kBuffer");
     var kLength = /* @__PURE__ */ Symbol("kLength");
+    var kDefaultMaxDecompressedSize = 4 * 1024 * 1024;
     var PerMessageDeflate = class {
       /** @type {import('node:zlib').InflateRaw} */
       #inflate;
       #options = {};
+      /** @type {boolean} */
+      #aborted = false;
+      /** @type {Function|null} */
+      #currentCallback = null;
+      /**
+       * @param {Map<string, string>} extensions
+       */
       constructor(extensions) {
         this.#options.serverNoContextTakeover = extensions.has("server_no_context_takeover");
         this.#options.serverMaxWindowBits = extensions.get("server_max_window_bits");
       }
       decompress(chunk, fin, callback) {
+        if (this.#aborted) {
+          callback(new MessageSizeExceededError());
+          return;
+        }
         if (!this.#inflate) {
           let windowBits = Z_DEFAULT_WINDOWBITS;
           if (this.#options.serverMaxWindowBits) {
@@ -22722,26 +24110,51 @@ var require_permessage_deflate = __commonJS({
             }
             windowBits = Number.parseInt(this.#options.serverMaxWindowBits);
           }
-          this.#inflate = createInflateRaw({ windowBits });
+          try {
+            this.#inflate = createInflateRaw({ windowBits });
+          } catch (err) {
+            callback(err);
+            return;
+          }
           this.#inflate[kBuffer] = [];
           this.#inflate[kLength] = 0;
           this.#inflate.on("data", (data) => {
-            this.#inflate[kBuffer].push(data);
+            if (this.#aborted) {
+              return;
+            }
             this.#inflate[kLength] += data.length;
+            if (this.#inflate[kLength] > kDefaultMaxDecompressedSize) {
+              this.#aborted = true;
+              this.#inflate.removeAllListeners();
+              this.#inflate.destroy();
+              this.#inflate = null;
+              if (this.#currentCallback) {
+                const cb = this.#currentCallback;
+                this.#currentCallback = null;
+                cb(new MessageSizeExceededError());
+              }
+              return;
+            }
+            this.#inflate[kBuffer].push(data);
           });
           this.#inflate.on("error", (err) => {
             this.#inflate = null;
             callback(err);
           });
         }
+        this.#currentCallback = callback;
         this.#inflate.write(chunk);
         if (fin) {
           this.#inflate.write(tail);
         }
         this.#inflate.flush(() => {
+          if (this.#aborted || !this.#inflate) {
+            return;
+          }
           const full = Buffer.concat(this.#inflate[kBuffer], this.#inflate[kLength]);
           this.#inflate[kBuffer].length = 0;
           this.#inflate[kLength] = 0;
+          this.#currentCallback = null;
           callback(null, full);
         });
       }
@@ -22769,6 +24182,7 @@ var require_receiver = __commonJS({
     var { failWebsocketConnection } = require_connection();
     var { WebsocketFrameSend } = require_frame();
     var { PerMessageDeflate } = require_permessage_deflate();
+    var { MessageSizeExceededError } = require_errors();
     var ByteParser = class extends Writable {
       #buffers = [];
       #fragmentsBytes = 0;
@@ -22781,6 +24195,10 @@ var require_receiver = __commonJS({
       #extensions;
       /** @type {import('./websocket').Handler} */
       #handler;
+      /**
+       * @param {import('./websocket').Handler} handler
+       * @param {Map<string, string>|null} extensions
+       */
       constructor(handler, extensions) {
         super();
         this.#handler = handler;
@@ -22884,12 +24302,12 @@ var require_receiver = __commonJS({
             }
             const buffer = this.consume(8);
             const upper = buffer.readUInt32BE(0);
-            if (upper > 2 ** 31 - 1) {
+            const lower = buffer.readUInt32BE(4);
+            if (upper !== 0 || lower > 2 ** 31 - 1) {
               failWebsocketConnection(this.#handler, 1009, "Received payload length > 2^31 bytes.");
               return;
             }
-            const lower = buffer.readUInt32BE(4);
-            this.#info.payloadLength = (upper << 8) + lower;
+            this.#info.payloadLength = lower;
             this.#state = parserStates.READ_DATA;
           } else if (this.#state === parserStates.READ_DATA) {
             if (this.#byteOffset < this.#info.payloadLength) {
@@ -22909,7 +24327,8 @@ var require_receiver = __commonJS({
               } else {
                 this.#extensions.get("permessage-deflate").decompress(body, this.#info.fin, (error, data) => {
                   if (error) {
-                    failWebsocketConnection(this.#handler, 1007, error.message);
+                    const code = error instanceof MessageSizeExceededError ? 1009 : 1007;
+                    failWebsocketConnection(this.#handler, code, error.message);
                     return;
                   }
                   this.writeFragments(data);
@@ -23177,6 +24596,15 @@ var require_websocket = __commonJS({
     var { SendQueue } = require_sender();
     var { WebsocketFrameSend } = require_frame();
     var { channels } = require_diagnostics();
+    function getSocketAddress(socket) {
+      if (typeof socket?.address === "function") {
+        return socket.address();
+      }
+      if (typeof socket?.session?.socket?.address === "function") {
+        return socket.session.socket.address();
+      }
+      return null;
+    }
     var WebSocket = class _WebSocket extends EventTarget {
       #events = {
         open: null,
@@ -23448,7 +24876,7 @@ var require_websocket = __commonJS({
         if (channels.open.hasSubscribers) {
           const headers = response.headersList.entries;
           channels.open.publish({
-            address: response.socket.address(),
+            address: getSocketAddress(response.socket),
             protocol: this.#protocol,
             extensions: this.#extensions,
             websocket: this,
@@ -23935,7 +25363,7 @@ var require_websocketstream = __commonJS({
         if (!this.#handler.wasEverConnected) {
           this.#openedPromise.reject(new WebSocketError("Socket never opened"));
         }
-        const result = this.#parser.closingInfo;
+        const result = this.#parser?.closingInfo;
         let code = result?.code ?? 1005;
         if (!this.#handler.closeState.has(sentCloseFrameState.SENT) && !this.#handler.closeState.has(sentCloseFrameState.RECEIVED)) {
           code = 1006;
@@ -23952,8 +25380,8 @@ var require_websocketstream = __commonJS({
           });
         } else {
           const error = createUnvalidatedWebSocketError("unclean close", code, reason);
-          this.#readableStreamController.error(error);
-          this.#writableStream.abort(error);
+          this.#readableStreamController?.error(error);
+          this.#writableStream?.abort(error);
           this.#closedPromise.reject(error);
         }
       }
@@ -24596,6 +26024,7 @@ var require_undici = __commonJS({
     var RoundRobinPool = require_round_robin_pool();
     var Agent = require_agent();
     var ProxyAgent2 = require_proxy_agent();
+    var Socks5ProxyAgent = require_socks5_proxy_agent();
     var EnvHttpProxyAgent = require_env_http_proxy_agent();
     var RetryAgent = require_retry_agent();
     var H2CClient = require_h2c_client();
@@ -24622,6 +26051,7 @@ var require_undici = __commonJS({
     module2.exports.RoundRobinPool = RoundRobinPool;
     module2.exports.Agent = Agent;
     module2.exports.ProxyAgent = ProxyAgent2;
+    module2.exports.Socks5ProxyAgent = Socks5ProxyAgent;
     module2.exports.EnvHttpProxyAgent = EnvHttpProxyAgent;
     module2.exports.RetryAgent = RetryAgent;
     module2.exports.H2CClient = H2CClient;
@@ -24691,10 +26121,31 @@ var require_undici = __commonJS({
     module2.exports.setGlobalDispatcher = setGlobalDispatcher;
     module2.exports.getGlobalDispatcher = getGlobalDispatcher;
     var fetchImpl = require_fetch().fetch;
+    var currentFilename = typeof __filename !== "undefined" ? __filename : void 0;
+    function appendFetchStackTrace(err, filename) {
+      if (!err || typeof err !== "object") {
+        return;
+      }
+      const stack = typeof err.stack === "string" ? err.stack : "";
+      const normalizedFilename = filename.replace(/\\/g, "/");
+      if (stack && (stack.includes(filename) || stack.includes(normalizedFilename))) {
+        return;
+      }
+      const capture = {};
+      Error.captureStackTrace(capture, appendFetchStackTrace);
+      if (!capture.stack) {
+        return;
+      }
+      const captureLines = capture.stack.split("\n").slice(1).join("\n");
+      err.stack = stack ? `${stack}
+${captureLines}` : capture.stack;
+    }
     module2.exports.fetch = function fetch2(init, options = void 0) {
       return fetchImpl(init, options).catch((err) => {
-        if (err && typeof err === "object") {
-          Error.captureStackTrace(err);
+        if (currentFilename) {
+          appendFetchStackTrace(err, currentFilename);
+        } else if (err && typeof err === "object") {
+          Error.captureStackTrace(err, module2.exports.fetch);
         }
         throw err;
       });
@@ -24850,42 +26301,6 @@ var init_proxy2 = __esm({
   }
 });
 
-// src/utils/mergeSystemMessagesMiddleware.ts
-var mergeSystemMessagesMiddleware;
-var init_mergeSystemMessagesMiddleware = __esm({
-  "src/utils/mergeSystemMessagesMiddleware.ts"() {
-    "use strict";
-    mergeSystemMessagesMiddleware = {
-      specificationVersion: "v3",
-      transformParams: async ({ params }) => {
-        const mergedPrompt = [];
-        let pendingSystemContent = [];
-        for (const msg of params.prompt) {
-          if (msg.role === "system") {
-            pendingSystemContent.push(msg.content);
-          } else {
-            if (pendingSystemContent.length > 0) {
-              mergedPrompt.push({
-                role: "system",
-                content: pendingSystemContent.join("\n\n")
-              });
-              pendingSystemContent = [];
-            }
-            mergedPrompt.push(msg);
-          }
-        }
-        if (pendingSystemContent.length > 0) {
-          mergedPrompt.push({
-            role: "system",
-            content: pendingSystemContent.join("\n\n")
-          });
-        }
-        return { ...params, prompt: mergedPrompt };
-      }
-    };
-  }
-});
-
 // src/core/model/providers.ts
 var import_anthropic, import_cerebras, import_google, import_huggingface, import_openai, import_openai_compatible, import_xai, import_ai_sdk_provider, import_ai_sdk_provider2, import_ai, import_assert, defaultModelCreator, defaultAnthropicModelCreator, openaiModelCreator, openaiModelResponseCreator, createModelCreatorCompatible, providers;
 var init_providers = __esm({
@@ -24905,7 +26320,6 @@ var init_providers = __esm({
     init_models();
     init_utils();
     init_proxy2();
-    init_mergeSystemMessagesMiddleware();
     defaultModelCreator = (name, provider) => {
       if (provider.id !== "openai") {
         (0, import_assert.default)(provider.api, `Provider ${provider.id} must have an api`);
@@ -25012,7 +26426,8 @@ var init_providers = __esm({
           "gpt-5-codex": models["gpt-5-codex"],
           "gpt-5.2": models["gpt-5.2"],
           "gpt-5.2-pro": models["gpt-5.2-pro"],
-          "gpt-5.2-codex": models["gpt-5.2-codex"]
+          "gpt-5.2-codex": models["gpt-5.2-codex"],
+          "gpt-5.3-codex": models["gpt-5.3-codex"]
         },
         createModel: openaiModelCreator
       },
@@ -25029,6 +26444,7 @@ var init_providers = __esm({
           "gemini-2.5-flash-lite": models["gemini-2.5-flash-lite-preview-06-17"],
           "gemini-2.5-pro": models["gemini-2.5-pro"],
           "gemini-3-pro-preview": models["gemini-3-pro-preview"],
+          "gemini-3.1-pro-preview": models["gemini-3.1-pro-preview"],
           "gemini-3-flash-preview": models["gemini-3-flash-preview"]
         },
         createModel(name, provider) {
@@ -25095,7 +26511,9 @@ var init_providers = __esm({
           "claude-3-7-sonnet-20250219-thinking": models["claude-3-7-sonnet"],
           "claude-3-5-sonnet-20241022": models["claude-3-5-sonnet-20241022"],
           "claude-haiku-4-5": models["claude-haiku-4-5"],
-          "claude-opus-4-5": models["claude-opus-4-5"]
+          "claude-opus-4-5": models["claude-opus-4-5"],
+          "claude-opus-4-6": models["claude-opus-4-6"],
+          "claude-sonnet-4-6": models["claude-sonnet-4-6"]
         },
         apiFormat: "anthropic",
         headers: {
@@ -25165,6 +26583,8 @@ var init_providers = __esm({
           "anthropic/claude-opus-4": models["claude-4-opus"],
           "anthropic/claude-opus-4.1": models["claude-4.1-opus"],
           "anthropic/claude-opus-4.5": models["claude-opus-4-5"],
+          "anthropic/claude-sonnet-4.6": models["claude-sonnet-4-6"],
+          "anthropic/claude-opus-4.6": models["claude-opus-4-6"],
           "deepseek/deepseek-r1-0528": models["deepseek-r1-0528"],
           "deepseek/deepseek-chat-v3-0324": models["deepseek-v3-0324"],
           "deepseek/deepseek-chat-v3.1": models["deepseek-v3-1"],
@@ -25190,6 +26610,7 @@ var init_providers = __esm({
           "openai/gpt-5.2": models["gpt-5.2"],
           "openai/gpt-5.2-pro": models["gpt-5.2-pro"],
           "openai/gpt-5.2-codex": models["gpt-5.2-codex"],
+          "openai/gpt-5.3-codex": models["gpt-5.3-codex"],
           "google/gemini-3-flash-preview": models["gemini-3-flash-preview"],
           "google/gemini-3-pro-preview": models["gemini-3-pro-preview"],
           "moonshotai/kimi-k2": models["kimi-k2"],
@@ -25207,7 +26628,9 @@ var init_providers = __esm({
           "z-ai/glm-4.6": models["glm-4.6"],
           "z-ai/glm-4.6v": models["glm-4.6v"],
           "z-ai/glm-4.7": models["glm-4.7"],
+          "z-ai/glm-5": models["glm-5"],
           "minimax/minimax-m2": models["minimax-m2"],
+          "minimax/minimax-m2.5": models["minimax-m2.5"],
           "openrouter/sherlock-dash-alpha": models["sherlock-dash-alpha"],
           "openrouter/sherlock-think-alpha": models["sherlock-think-alpha"],
           "xiaomi/mimo-v2-flash:free": models["mimo-v2-flash"]
@@ -25226,43 +26649,6 @@ var init_providers = __esm({
           ).chat(name);
         }
       },
-      iflow: {
-        id: "iflow",
-        source: "built-in",
-        env: ["IFLOW_API_KEY"],
-        name: "iFlow",
-        api: "https://apis.iflow.cn/v1/",
-        doc: "https://iflow.cn/",
-        models: {
-          "qwen3-coder-plus": models["qwen3-coder-plus"],
-          "kimi-k2": models["kimi-k2"],
-          "kimi-k2-0905": models["kimi-k2-0905"],
-          "deepseek-v3": models["deepseek-v3-0324"],
-          "deepseek-v3.2": models["deepseek-v3-2-exp"],
-          "deepseek-r1": models["deepseek-r1-0528"],
-          "glm-4.6": models["glm-4.6"],
-          "glm-4.7": models["glm-4.7"],
-          "minimax-m2.1": models["minimax-m2.1"],
-          "qwen3-max": models["qwen3-max"]
-        },
-        createModel: createModelCreatorCompatible({
-          fetch: (url, options) => {
-            return fetch(url, {
-              ...options,
-              headers: {
-                ...options.headers,
-                "user-agent": "iFlow-Cli"
-              }
-            });
-          },
-          middlewares: [
-            mergeSystemMessagesMiddleware,
-            (0, import_ai.extractReasoningMiddleware)({
-              tagName: "think"
-            })
-          ]
-        })
-      },
       moonshotai: {
         id: "moonshotai",
         source: "built-in",
@@ -25339,7 +26725,12 @@ var init_providers = __esm({
           "deepseek-ai/DeepSeek-R1": models["deepseek-r1-0528"],
           "deepseek-ai/DeepSeek-V3.1": models["deepseek-v3-1"],
           "deepseek-ai/DeepSeek-V3": models["deepseek-v3-0324"],
-          "zai-org/GLM-4.5": models["glm-4.5"]
+          "zai-org/GLM-4.5": models["glm-4.5"],
+          "Pro/moonshotai/Kimi-K2.5": models["kimi-k2-5"],
+          "Pro/zai-org/GLM-5": models["glm-5"],
+          "Pro/zai-org/GLM-4.7": models["glm-4.7"],
+          "Pro/MiniMaxAI/MiniMax-M2.5": models["minimax-m2.5"],
+          "Pro/deepseek-ai/DeepSeek-V3.2": models["deepseek-v3.2"]
         },
         createModel: defaultModelCreator
       },
@@ -25356,6 +26747,7 @@ var init_providers = __esm({
           "ZhipuAI/GLM-4.5": models["glm-4.5"],
           "ZhipuAI/GLM-4.5V": models["glm-4.5v"],
           "ZhipuAI/GLM-4.6": models["glm-4.6"],
+          "ZhipuAI/GLM-5": models["glm-5"],
           "deepseek-ai/DeepSeek-V3.2": models["deepseek-v3.2"],
           "deepseek-ai/DeepSeek-V3.2-Speciale": models["deepseek-v3.2-speciale"]
         },
@@ -25390,7 +26782,8 @@ var init_providers = __esm({
           "glm-4.5v": models["glm-4.5v"],
           "glm-4.6": models["glm-4.6"],
           "glm-4.6v": models["glm-4.6v"],
-          "glm-4.7": models["glm-4.7"]
+          "glm-4.7": models["glm-4.7"],
+          "glm-5": models["glm-5"]
         },
         createModel: defaultModelCreator
       },
@@ -25408,10 +26801,31 @@ var init_providers = __esm({
           "glm-4.5": models["glm-4.5"],
           "glm-4.5-flash": models["glm-4.5-flash"],
           "glm-4.6v": models["glm-4.6v"],
-          "glm-4.7": models["glm-4.7"]
+          "glm-4.7": models["glm-4.7"],
+          "glm-5": models["glm-5"]
         },
         createModel: defaultModelCreator
       },
+      "bailian-coding-plan": {
+        id: "bailian-coding-plan",
+        source: "built-in",
+        env: ["BAILIAN_CODING_API_KEY"],
+        name: "BaiLian Coding Plan",
+        api: "https://coding.dashscope.aliyuncs.com/apps/anthropic/v1",
+        doc: "https://www.aliyun.com/benefit/scene/codingplan",
+        apiFormat: "anthropic",
+        models: {
+          "qwen3.5-plus": models["qwen3-5-plus"],
+          "qwen3-max-2026-01-23": models["qwen3-max"],
+          "qwen3-coder-next": models["qwen3-coder-plus"],
+          "qwen3-coder-plus": models["qwen3-coder-plus"],
+          "MiniMax-M2.5": models["minimax-m2.5"],
+          "glm-5": models["glm-5"],
+          "glm-4.7": models["glm-4.7"],
+          "kimi-k2.5": models["kimi-k2-5"]
+        },
+        createModel: defaultAnthropicModelCreator
+      },
       zhipuai: {
         id: "zhipuai",
         source: "built-in",
@@ -25426,7 +26840,8 @@ var init_providers = __esm({
           "glm-4.5": models["glm-4.5"],
           "glm-4.5-flash": models["glm-4.5-flash"],
           "glm-4.6v": models["glm-4.6v"],
-          "glm-4.7": models["glm-4.7"]
+          "glm-4.7": models["glm-4.7"],
+          "glm-5": models["glm-5"]
         },
         createModel: defaultModelCreator
       },
@@ -25451,15 +26866,21 @@ var init_providers = __esm({
           "openai/gpt-5.1-codex-mini": models["gpt-5.1-codex-mini"],
           "openai/gpt-5.2": models["gpt-5.2"],
           "openai/gpt-5.2-pro": models["gpt-5.2-pro"],
+          "openai/gpt-5.2-codex": models["gpt-5.2-codex"],
+          "openai/gpt-5.3-codex": models["gpt-5.3-codex"],
           "anthropic/claude-sonnet-4.5": models["claude-4-5-sonnet"],
           "anthropic/claude-opus-4.1": models["claude-4.1-opus"],
           "anthropic/claude-opus-4.5": models["claude-opus-4-5"],
+          "anthropic/claude-opus-4.6": models["claude-opus-4-6"],
           "z-ai/glm-4.6": models["glm-4.6"],
           "z-ai/glm-4.6v": models["glm-4.6v"],
           "z-ai/glm-4.6v-flash": models["glm-4.6v"],
+          "z-ai/glm-4.7": models["glm-4.7"],
+          "z-ai/glm-5": models["glm-5"],
           "deepseek/deepseek-v3.2-speciale": models["deepseek-v3.2-speciale"],
           "deepseek/deepseek-chat": models["deepseek-v3-2-exp"],
-          "deepseek/deepseek-reasoner": models["deepseek-r1-0528"]
+          "deepseek/deepseek-reasoner": models["deepseek-r1-0528"],
+          "minimax/minimax-m2.5": models["minimax-m2.5"]
         },
         headers: {
           "X-Title": "OriCore",
@@ -25475,7 +26896,9 @@ var init_providers = __esm({
         doc: "https://platform.minimaxi.io/docs/guides/quickstart",
         models: {
           "minimax-m2": models["minimax-m2"],
-          "minimax-m2.1": models["minimax-m2.1"]
+          "minimax-m2.1": models["minimax-m2.1"],
+          "minimax-m2.5": models["minimax-m2.5"],
+          "minimax-m2.7": models["minimax-m2.7"]
         },
         createModel(name, provider) {
           const baseURL = getProviderBaseURL(provider);
@@ -25494,7 +26917,9 @@ var init_providers = __esm({
         doc: "https://platform.minimaxi.com/docs/guides/quickstart",
         models: {
           "minimax-m2": models["minimax-m2"],
-          "minimax-m2.1": models["minimax-m2.1"]
+          "minimax-m2.1": models["minimax-m2.1"],
+          "minimax-m2.5": models["minimax-m2.5"],
+          "minimax-m2.7": models["minimax-m2.7"]
         },
         createModel(name, provider) {
           const baseURL = getProviderBaseURL(provider);
@@ -25623,7 +27048,9 @@ var init_providers = __esm({
           "zai/glm-4.7": models["glm-4.7"],
           "moonshotai/kimi-k2-thinking": models["kimi-k2-thinking"],
           "moonshotai/kimi-k2.5": models["kimi-k2.5"],
-          "deepseek/deepseek-chat-v3.2": models["deepseek-v3-2-exp"]
+          "deepseek/deepseek-chat-v3.2": models["deepseek-v3-2-exp"],
+          "openai/gpt-oss-120b": models["gpt-oss-120b"],
+          "xiaomimimo/mimo-v2-flash": models["mimo-v2-flash"]
         },
         createModel: defaultModelCreator
       },
@@ -25643,12 +27070,15 @@ var init_providers = __esm({
           "claude-4-5-sonnet": models["claude-4-5-sonnet"],
           "claude-haiku-4-5": models["claude-haiku-4-5"],
           "claude-opus-4-5": models["claude-opus-4-5"],
+          "claude-sonnet-4-6": models["claude-sonnet-4-6"],
+          "claude-opus-4-6": models["claude-opus-4-6"],
           "gpt-5.1": models["gpt-5.1"],
           "gpt-5.1-codex-max": models["gpt-5.1-codex-max"],
           "gpt-5.1-codex": models["gpt-5.1-codex"],
           "gpt-5.1-codex-mini": models["gpt-5.1-codex-mini"],
           "gpt-5.2": models["gpt-5.2"],
-          "gpt-5.2-codex": models["gpt-5.2-codex"]
+          "gpt-5.2-codex": models["gpt-5.2-codex"],
+          "gpt-5.3-codex": models["gpt-5.3-codex"]
         },
         createModel: (name, provider) => {
           if (name.startsWith("claude-") || name.startsWith("gemini-")) {
@@ -25659,6 +27089,38 @@ var init_providers = __esm({
           }
           return defaultModelCreator(name, provider);
         }
+      },
+      kilo: {
+        id: "kilo",
+        source: "built-in",
+        env: ["KILO_API_KEY"],
+        name: "Kilo",
+        api: "https://api.kilo.ai/api/gateway",
+        doc: "https://kilo.ai",
+        apiFormat: "openai",
+        models: {
+          "z-ai/glm-5": models["glm-5"],
+          "z-ai/glm-5:free": models["glm-5"],
+          "z-ai/glm-4.7": models["glm-4.7"],
+          "anthropic/claude-opus-4.6": models["claude-opus-4-6"],
+          "anthropic/claude-sonnet-4.6": models["claude-sonnet-4-6"],
+          "anthropic/claude-haiku-4.5": models["claude-haiku-4-5"],
+          "anthropic/claude-sonnet-4.5": models["claude-4-5-sonnet"],
+          "google/gemini-3-flash-preview": models["gemini-3-flash-preview"],
+          "google/gemini-3-pro-preview": models["gemini-3-pro-preview"],
+          "minimax/minimax-m2.5:free": models["minimax-m2.5"],
+          "minimax/minimax-m2.5": models["minimax-m2.5"],
+          "moonshotai/kimi-k2.5": models["kimi-k2-5"]
+        },
+        createModel: (name, provider) => {
+          if (name.includes("claude-")) {
+            return defaultAnthropicModelCreator(name, provider);
+          }
+          if (name.includes("gemini-")) {
+            return defaultAnthropicModelCreator(name, provider);
+          }
+          return defaultModelCreator(name, provider);
+        }
       }
     };
   }
@@ -26230,6 +27692,17 @@ function transformVariants(model, provider) {
     return {};
   }
   const id = (model.id || "").toLowerCase();
+  if (provider.id === "bailian-coding-plan") {
+    if (id.includes("kimi") || id.includes("minimax") || id.includes("glm")) {
+      return {
+        on: {
+          thinking: {
+            type: "enabled"
+          }
+        }
+      };
+    }
+  }
   if (id.includes("deepseek") || id.includes("minimax") || id.includes("glm") || id.includes("mistral") || // id.includes("kimi") ||
   id.includes("grok")) {
     return {};
@@ -26953,6 +28426,9 @@ function stripAnsi(string) {
   if (typeof string !== "string") {
     throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
   }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
   return string.replace(regex, "");
 }
 var regex;
@@ -28952,6 +30428,18 @@ function normalizeMessagesForCompact(messages) {
         content: "[Tool operations completed]"
       };
     }
+    if (message.role === "user") {
+      if (Array.isArray(message.content)) {
+        const filteredContent = message.content.filter(
+          (part) => part.type === "text"
+        );
+        return {
+          ...message,
+          content: filteredContent.length > 0 ? filteredContent : message.content
+        };
+      }
+      return message;
+    }
     return message;
   }).filter((message) => {
     if (typeof message.content === "string") {
@@ -29889,6 +31377,7 @@ async function runLoop(opts) {
             request: result.request,
             response: result.response
           });
+          let finishChunkReceived = false;
           for await (const chunk of result.stream) {
             if (opts.signal?.aborted) {
               return createCancelError();
@@ -29920,6 +31409,7 @@ async function runLoop(opts) {
                 });
                 break;
               case "finish":
+                finishChunkReceived = true;
                 lastUsage = Usage.fromEventUsage(chunk.usage);
                 totalUsage.add(lastUsage);
                 if (toolCalls.length === 0 && text.trim() === "") {
@@ -29958,6 +31448,13 @@ async function runLoop(opts) {
                 break;
             }
           }
+          if (!finishChunkReceived && toolCalls.length === 0 && text.trim() === "") {
+            const error = new Error(
+              "Empty response: stream ended without any chunks"
+            );
+            error.isRetryable = true;
+            throw error;
+          }
           break;
         } catch (error) {
           const nextRetryCount = retryCount + 1;
@@ -30125,6 +31622,8 @@ async function runLoop(opts) {
           }
         }
       };
+      const approvedToolUses = [];
+      let earlyReturn = null;
       for (const toolCall of toolCalls) {
         let toolUse = {
           name: toolCall.toolName,
@@ -30148,25 +31647,10 @@ async function runLoop(opts) {
           }
         }
         if (approved) {
-          toolCallsCount++;
           if (updatedParams) {
             toolUse.params = { ...toolUse.params, ...updatedParams };
           }
-          let toolResult = await opts.tools.invoke(
-            toolUse.name,
-            JSON.stringify(toolUse.params),
-            toolUse.callId
-          );
-          if (opts.onToolResult) {
-            toolResult = await opts.onToolResult(toolUse, toolResult, approved);
-          }
-          toolResults.push({
-            toolCallId: toolUse.callId,
-            toolName: toolUse.name,
-            input: toolUse.params,
-            result: toolResult
-          });
-          turnsCount--;
+          approvedToolUses.push(toolUse);
         } else {
           let message = "Error: Tool execution was denied by user.";
           if (denyReason) {
@@ -30177,7 +31661,7 @@ async function runLoop(opts) {
             isError: true
           };
           if (opts.onToolResult) {
-            toolResult = await opts.onToolResult(toolUse, toolResult, approved);
+            toolResult = await opts.onToolResult(toolUse, toolResult, false);
           }
           toolResults.push({
             toolCallId: toolUse.callId,
@@ -30185,8 +31669,8 @@ async function runLoop(opts) {
             input: toolUse.params,
             result: toolResult
           });
-          await addDeniedResultsForRemainingTools();
           if (!denyReason) {
+            await addDeniedResultsForRemainingTools();
             await history.addMessage({
               role: "tool",
               content: toolResults.map(
@@ -30198,7 +31682,7 @@ async function runLoop(opts) {
                 )
               )
             });
-            return {
+            earlyReturn = {
               success: false,
               error: {
                 type: "tool_denied",
@@ -30210,9 +31694,60 @@ async function runLoop(opts) {
                 }
               }
             };
-          } else {
             break;
           }
+          await addDeniedResultsForRemainingTools();
+          break;
+        }
+      }
+      if (earlyReturn) {
+        return earlyReturn;
+      }
+      if (approvedToolUses.length > 0) {
+        const executionResults = await Promise.allSettled(
+          approvedToolUses.map(async (toolUse) => {
+            let toolResult = await opts.tools.invoke(
+              toolUse.name,
+              JSON.stringify(toolUse.params),
+              toolUse.callId
+            );
+            if (opts.onToolResult) {
+              toolResult = await opts.onToolResult(toolUse, toolResult, true);
+            }
+            return {
+              toolCallId: toolUse.callId,
+              toolName: toolUse.name,
+              input: toolUse.params,
+              result: toolResult
+            };
+          })
+        );
+        toolCallsCount += approvedToolUses.length;
+        turnsCount -= approvedToolUses.length;
+        for (let i = 0; i < executionResults.length; i++) {
+          const settledResult = executionResults[i];
+          if (settledResult.status === "fulfilled") {
+            toolResults.push(settledResult.value);
+          } else {
+            const failedToolUse = approvedToolUses[i];
+            let errorResult = {
+              llmContent: `Tool execution error: ${settledResult.reason instanceof Error ? settledResult.reason.message : String(settledResult.reason)}`,
+              isError: true
+            };
+            if (opts.onToolResult) {
+              errorResult = await opts.onToolResult(
+                failedToolUse,
+                errorResult,
+                true
+              );
+            }
+            toolResults.push({
+              toolCallId: failedToolUse.callId,
+              toolName: failedToolUse.name,
+              input: failedToolUse.params,
+              result: errorResult
+            });
+          }
         }
       }
       if (opts.signal?.aborted) {
@@ -30595,8 +32130,8 @@ var init_ripgrep = __esm({
       }
       try {
         const url = import_meta.url;
-        const __filename = url.startsWith("file://") ? new URL(url).pathname : url;
-        const moduleDir = import_pathe10.default.dirname(__filename);
+        const __filename2 = url.startsWith("file://") ? new URL(url).pathname : url;
+        const moduleDir = import_pathe10.default.dirname(__filename2);
         return isDev ? import_pathe10.default.resolve(moduleDir, "../../") : import_pathe10.default.resolve(moduleDir, "../");
       } catch {
         return process.cwd();
@@ -34751,8 +36286,10 @@ var MCPManager = class _MCPManager {
     return true;
   }
   #convertAiSdkToolToLocal(toolName, toolDef, serverName, config) {
+    const safeServerName = serverName.replace(/[^a-zA-Z0-9_-]/g, "");
+    const safeToolName = toolName.replace(/[^a-zA-Z0-9_-]/g, "_");
     return {
-      name: `mcp__${serverName.replace(/[^a-zA-Z0-9_-]/g, "")}__${toolName}`,
+      name: `mcp__${safeServerName}__${safeToolName}`,
       description: toolDef.description,
       getDescription: ({ params }) => {
         return formatParamsDescription(params);
@@ -34983,6 +36520,16 @@ var import_fs23 = __toESM(require("fs"), 1);
 var import_os9 = __toESM(require("os"), 1);
 var import_pathe26 = __toESM(require("pathe"), 1);
 init_plugin();
+function isDirOrSymlinkToDir(parentDir, entry) {
+  if (entry.isDirectory()) return true;
+  if (entry.isSymbolicLink()) {
+    try {
+      return import_fs23.default.statSync(import_pathe26.default.join(parentDir, entry.name)).isDirectory();
+    } catch {
+    }
+  }
+  return false;
+}
 var SkillSource = /* @__PURE__ */ ((SkillSource2) => {
   SkillSource2["Plugin"] = "plugin";
   SkillSource2["GlobalClaude"] = "global-claude";
@@ -35073,7 +36620,7 @@ var SkillManager = class {
     try {
       const entries = import_fs23.default.readdirSync(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
-        if (entry.isDirectory()) {
+        if (isDirOrSymlinkToDir(skillsDir, entry)) {
           const skillPath = import_pathe26.default.join(skillsDir, entry.name, "SKILL.md");
           if (import_fs23.default.existsSync(skillPath)) {
             this.loadSkillFile(skillPath, source);
@@ -35283,7 +36830,7 @@ var SkillManager = class {
     if (import_fs23.default.existsSync(skillsDir) && import_fs23.default.statSync(skillsDir).isDirectory()) {
       const entries2 = import_fs23.default.readdirSync(skillsDir, { withFileTypes: true });
       for (const entry of entries2) {
-        if (entry.isDirectory()) {
+        if (isDirOrSymlinkToDir(skillsDir, entry)) {
           const skillPath = import_pathe26.default.join(skillsDir, entry.name, "SKILL.md");
           if (import_fs23.default.existsSync(skillPath)) {
             skills.push(skillPath);
@@ -35296,7 +36843,7 @@ var SkillManager = class {
     }
     const entries = import_fs23.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.isDirectory()) {
+      if (isDirOrSymlinkToDir(dir, entry)) {
         const skillPath = import_pathe26.default.join(dir, entry.name, "SKILL.md");
         if (import_fs23.default.existsSync(skillPath)) {
           skills.push(skillPath);