@blockrun/clawrouter 0.12.239 → 0.12.241

package/dist/index.js

@@ -93,7 +93,6 @@ var init_top_models = __esm({
       "deepseek/deepseek-chat",
       "deepseek/deepseek-reasoner",
       "free/deepseek-v4-flash",
-      "free/seed-oss-36b",
       "free/nemotron-3-nano-omni-30b-a3b-reasoning",
       "free/mistral-nemotron",
       "free/step-3.7-flash",
@@ -403,9 +402,10 @@ var init_models = __esm({
       "free/deepseek-v4-pro": "free/deepseek-v4-flash",
       "nvidia/deepseek-v4-flash": "free/deepseek-v4-flash",
       "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning": "free/nemotron-3-nano-omni-30b-a3b-reasoning",
-      // qwen3-coder-480b retired (NVIDIA EOL 2026-06-14) → redirects to seed-oss-36b
-      // server-side; keep the explicit id mappings for pinned callers (BlockRun still
-      // resolves them), but point the generic coding shorthands at the live successor.
+      // qwen3-coder-480b retired (NVIDIA EOL 2026-06-14). Its server-side redirect used
+      // to be seed-oss-36b, but that EOL'd too on 2026-08-03, so blockrun re-pointed it
+      // at gpt-oss-120b. Keep the explicit id mappings for pinned callers (BlockRun still
+      // resolves them); the generic coding shorthands follow the gateway to gpt-oss-120b.
       "nvidia/qwen3-coder-480b": "free/qwen3-coder-480b",
       "qwen/qwen3-coder-480b-a35b-instruct": "free/qwen3-coder-480b",
       // glm-4.7 pin keeps the real id — blockrun redirects it server-side (→ gpt-oss-120b).
@@ -451,13 +451,14 @@ var init_models = __esm({
       "v4-flash": "free/deepseek-v4-flash",
       "mistral-free": "free/mistral-nemotron",
       // mistral-large-3-675b EOL'd 2026-07-28 → last live free Mistral (blockrun demoted its /free-mistral primary the same way)
-      "glm-free": "free/seed-oss-36b",
-      // qwen3-coder retired → live coder successor
+      "glm-free": "free/gpt-oss-120b",
+      // seed-oss-36b (the prior target) EOL'd 2026-08-03
       "llama-free": "free/gpt-oss-120b",
       // no live free Llama left (maverick died 2026-07)
-      "qwen-coder": "free/seed-oss-36b",
-      // qwen3-coder-480b retired → seed-oss-36b
-      "qwen-coder-free": "free/seed-oss-36b",
+      // qwen3-coder-480b retired 2026-06-14 → seed-oss-36b, which then EOL'd 2026-08-03.
+      // Follow the gateway's own retarget rather than chaining to a second dead model.
+      "qwen-coder": "free/gpt-oss-120b",
+      "qwen-coder-free": "free/gpt-oss-120b",
       "qwen-thinking": "free/gpt-oss-120b",
       // qwen3-next died 2026-07-17; no live free Qwen left
       "qwen3-next": "free/qwen3-next-80b-a3b-instruct",
@@ -466,9 +467,11 @@ var init_models = __esm({
       "mistral-small": "free/mistral-nemotron",
       // closest live Mistral-family free model
       // New live free models (2026-06-14 BlockRun free-tier refresh)
+      // seed-oss pins name the model itself — kept routable, the gateway redirects them.
       "seed-oss": "free/seed-oss-36b",
       "seed-oss-36b": "free/seed-oss-36b",
-      "coder-free": "free/seed-oss-36b",
+      "coder-free": "free/gpt-oss-120b",
+      // generic "a free coder" → follows the gateway retarget
       "mistral-nemotron": "free/mistral-nemotron",
       "step-flash": "free/step-3.7-flash",
       "step-3.7-flash": "free/step-3.7-flash",
@@ -489,8 +492,9 @@ var init_models = __esm({
       "nemotron-super": "free/gpt-oss-120b",
       "nemotron-49b": "free/gpt-oss-120b",
       "nemotron-120b": "free/gpt-oss-120b",
-      devstral: "free/seed-oss-36b",
-      "devstral-2": "free/seed-oss-36b",
+      devstral: "free/gpt-oss-120b",
+      // seed-oss-36b EOL'd 2026-08-03; matches blockrun's own retarget
+      "devstral-2": "free/gpt-oss-120b",
       maverick: "free/llama-4-maverick",
       // explicit-ish pin — gateway redirects
       free: "free/gpt-oss-120b",
@@ -1613,8 +1617,13 @@ var init_models = __esm({
         reasoning: true
       },
       {
-        // ByteDance Seed-OSS 36B: strong open-source coder, 131K context. Successor
-        // to the retired qwen3-coder-480b (BlockRun redirects qwen3-coder → seed-oss).
+        // ByteDance Seed-OSS 36B: was the free coder, and the redirect target for the
+        // retired qwen3-coder-480b. EOL'd 2026-08-03 — blockrun's probe got HTTP 410
+        // Gone from NVIDIA on both passes and the prod health gate fired
+        // [ALERT][free-model-dead] kind=gone the same day; upstream now hides it and
+        // re-pointed its own dependents (qwen3-coder-480b, devstral-2) at gpt-oss-120b.
+        // Entry kept so explicit pins stay routable; off the picker, the FREE_MODELS
+        // cascade, and the router fallback chains.
         id: "free/seed-oss-36b",
         name: "[Free] Seed-OSS 36B",
         version: "oss-36b",
@@ -36378,8 +36387,8 @@ var init_config = __esm({
             // FREE — smaller, faster
             "free/deepseek-v4-flash",
             // FREE — 1M ctx; slow (~10 tok/s, 07-28 probe) but completes
-            "free/seed-oss-36b",
-            // FREE — live coder (qwen3.5-122b + qwen3-next died 2026-07; mistral-large-3-675b EOL'd 07-28)
+            // seed-oss-36b sat here as the free coder until it EOL'd 2026-08-03 (HTTP 410).
+            // gpt-oss-120b/20b already head this chain, so the rung is dropped, not retargeted.
             "google/gemini-3.1-flash-lite",
             // $0.25/$1.50 — newest flash-lite
             "openai/gpt-5.4-nano",
@@ -36496,8 +36505,8 @@ var init_config = __esm({
             "openai/gpt-5.3-codex",
             "deepseek/deepseek-chat",
             // Cheap, reliable
-            "free/seed-oss-36b"
-            // NVIDIA free ultimate backstop (qwen3-coder-480b retired)
+            "free/gpt-oss-120b"
+            // NVIDIA free ultimate backstop (was seed-oss-36b; EOL'd 2026-08-03)
           ]
         },
         REASONING: {
@@ -36586,8 +36595,8 @@ var init_config = __esm({
             // Previous flagship — 6,213ms, reliable
             "deepseek/deepseek-chat",
             // 1,431ms — cheap, reliable
-            "free/seed-oss-36b"
-            // NVIDIA free ultimate backstop (qwen3-coder-480b retired)
+            "free/gpt-oss-120b"
+            // NVIDIA free ultimate backstop (was seed-oss-36b; EOL'd 2026-08-03)
           ]
         },
         REASONING: {
@@ -56858,6 +56867,7 @@ var require_symbols = __commonJS({
       kCounter: /* @__PURE__ */ Symbol("socket request counter"),
       kMaxResponseSize: /* @__PURE__ */ Symbol("max response size"),
       kHTTP2Session: /* @__PURE__ */ Symbol("http2Session"),
+      kHTTP2Options: /* @__PURE__ */ Symbol("http2 options"),
       kHTTP2SessionState: /* @__PURE__ */ Symbol("http2Session state"),
       kRetryHandlerDefaultRetry: /* @__PURE__ */ Symbol("retry agent default retry"),
       kConstruct: /* @__PURE__ */ Symbol("constructable"),
@@ -59626,14 +59636,26 @@ var require_connect = __commonJS({
         } else {
           assert10(!httpSocket, "httpSocket can only be sent on TLS update");
           port = port || 80;
-          socket = net3.connect({
+          const connectOptions = {
             highWaterMark: 64 * 1024,
             // Same as nodejs fs streams.
             ...options,
             localAddress,
             port,
             host: hostname
-          });
+          };
+          const family = net3.isIP(hostname);
+          if (family !== 0 && servername && servername !== hostname) {
+            connectOptions.host = servername;
+            connectOptions.lookup = (_hostname, lookupOptions, cb) => {
+              if (lookupOptions.all) {
+                cb(null, [{ address: hostname, family }]);
+              } else {
+                cb(null, hostname, family);
+              }
+            };
+          }
+          socket = net3.connect(connectOptions);
           if (useH2c === true) {
             socket.alpnProtocol = "h2";
           }
@@ -64073,20 +64095,20 @@ var require_client_h1 = __commonJS({
     }
     function clearIdleSocketValidation(socket) {
       if (socket[kIdleSocketValidationTimeout]) {
-        clearImmediate(socket[kIdleSocketValidationTimeout]);
+        clearTimeout(socket[kIdleSocketValidationTimeout]);
         socket[kIdleSocketValidationTimeout] = null;
       }
       socket[kIdleSocketValidation] = 0;
     }
     function scheduleIdleSocketValidation(client, socket) {
       socket[kIdleSocketValidation] = 1;
-      socket[kIdleSocketValidationTimeout] = setImmediate(() => {
+      socket[kIdleSocketValidationTimeout] = setTimeout(() => {
         socket[kIdleSocketValidationTimeout] = null;
         socket[kIdleSocketValidation] = 2;
         if (client[kSocket] === socket && !socket.destroyed) {
           client[kResume]();
         }
-      });
+      }, 0);
       socket[kIdleSocketValidationTimeout].unref?.();
     }
     function resumeH1(client) {
@@ -64610,10 +64632,7 @@ var require_client_h2 = __commonJS({
       kStrictContentLength,
       kOnError,
       kMaxConcurrentStreams,
-      kPingInterval,
       kHTTP2Session,
-      kHTTP2InitialWindowSize,
-      kHTTP2ConnectionWindowSize,
       kHostAuthority,
       kResume,
       kSize,
@@ -64625,7 +64644,8 @@ var require_client_h2 = __commonJS({
       kEnableConnectProtocol,
       kRemoteSettings,
       kHTTP2Stream,
-      kHTTP2SessionState
+      kHTTP2SessionState,
+      kHTTP2Options
     } = require_symbols();
     var { channels } = require_diagnostics();
     var kOpenStreams = /* @__PURE__ */ Symbol("open streams");
@@ -64634,6 +64654,9 @@ var require_client_h2 = __commonJS({
     var kRequestStreamCleanup = /* @__PURE__ */ Symbol("request stream cleanup");
     var kRequestStreamState = /* @__PURE__ */ Symbol("request stream state");
     var kReceivedGoAway = /* @__PURE__ */ Symbol("received goaway");
+    var kGoAwayReplayAttempts = /* @__PURE__ */ Symbol("goaway replay attempts");
+    var kRefusedStreamRetry = /* @__PURE__ */ Symbol("refused stream retry");
+    var MAX_GOAWAY_REPLAY_ATTEMPTS = 1;
     var extractBody;
     var http23;
     try {
@@ -64731,10 +64754,15 @@ var require_client_h2 = __commonJS({
         client[kPendingIdx] = client[kRunningIdx];
       }
     }
-    function canRetryRequestAfterGoAway(request2) {
+    function canReplayRequest(request2) {
       const { body } = request2;
       return body == null || util5.isBuffer(body) || util5.isBlobLike(body);
     }
+    function registerGoAwayRefusal(request2) {
+      const attempts = (request2[kGoAwayReplayAttempts] ?? 0) + 1;
+      request2[kGoAwayReplayAttempts] = attempts;
+      return attempts <= MAX_GOAWAY_REPLAY_ATTEMPTS;
+    }
     function closeStream(stream4, code = NGHTTP2_REFUSED_STREAM) {
       if (stream4 != null && !stream4.destroyed && !stream4.closed) {
         try {
@@ -64746,15 +64774,30 @@ var require_client_h2 = __commonJS({
     function detachRequestStreamForClose(request2) {
       const stream4 = request2[kRequestStream];
       clearRequestStream(request2);
+      severRequestStream(stream4);
       return stream4;
     }
+    function severRequestStream(stream4) {
+      if (stream4 == null || stream4[kRequestStreamState] == null) {
+        return;
+      }
+      stream4[kRequestStreamState] = null;
+      stream4.off("close", completeRequestStream);
+      stream4.off("close", onUpgradeStreamClose);
+      if (stream4[kHTTP2Session] != null) {
+        closeStreamSession(stream4);
+      }
+      if (!stream4.destroyed && !stream4.closed) {
+        stream4.once("error", noop2);
+      }
+    }
     function connectH2(client, socket) {
       client[kSocket] = socket;
-      const http2InitialWindowSize = client[kHTTP2InitialWindowSize];
-      const http2ConnectionWindowSize = client[kHTTP2ConnectionWindowSize];
+      const http2InitialWindowSize = client[kHTTP2Options].sessionOptions?.initialWindowSize;
+      const http2ConnectionWindowSize = client[kHTTP2Options].connectionWindowSize;
       const session = http23.connect(client[kUrl], {
         createConnection: () => socket,
-        peerMaxConcurrentStreams: client[kMaxConcurrentStreams],
+        peerMaxConcurrentStreams: client[kHTTP2Options].maxConcurrentStreams,
         settings: {
           // TODO(metcoder95): add support for PUSH
           enablePush: false,
@@ -64767,13 +64810,16 @@ var require_client_h2 = __commonJS({
       session[kSocket] = socket;
       session[kHTTP2SessionState] = {
         idleTimeout: null,
+        // Armed while the peer advertises MAX_CONCURRENT_STREAMS = 0 and we have
+        // work that cannot start. See setNoStreamsTimeout.
+        noStreamsTimeout: null,
         // Sockets start out ref'd. Session ref/unref proxies to the socket, so a
         // single cached flag lets us skip redundant uv ref/unref calls, provided
         // every ref/unref of the session or its socket goes through
         // refH2Session/unrefH2Session.
         refed: true,
         ping: {
-          interval: client[kPingInterval] === 0 ? null : setInterval(onHttp2SendPing, client[kPingInterval], session).unref()
+          interval: client[kHTTP2Options].pingInterval === 0 ? null : setInterval(onHttp2SendPing, client[kHTTP2Options].pingInterval, session).unref()
         }
       };
       session[kReceivedGoAway] = false;
@@ -64878,8 +64924,48 @@ var require_client_h2 = __commonJS({
         } else {
           clearHttp2IdleTimeout(session);
         }
+        if (client[kMaxConcurrentStreams] === 0 && client[kRunning] === 0 && client[kPending] > 0) {
+          setNoStreamsTimeout(session);
+        } else {
+          clearNoStreamsTimeout(session);
+        }
+      }
+    }
+    function clearNoStreamsTimeout(session) {
+      const state = session[kHTTP2SessionState];
+      if (state?.noStreamsTimeout != null) {
+        clearTimeout(state.noStreamsTimeout);
+        state.noStreamsTimeout = null;
       }
     }
+    function setNoStreamsTimeout(session) {
+      const client = session[kClient];
+      const state = session[kHTTP2SessionState];
+      const timeout = client[kHeadersTimeout];
+      if (!timeout || state.noStreamsTimeout != null) {
+        return;
+      }
+      state.noStreamsTimeout = setTimeout(onNoStreamsTimeout, timeout, session).unref();
+    }
+    function onNoStreamsTimeout(session) {
+      const client = session[kClient];
+      const state = session[kHTTP2SessionState];
+      state.noStreamsTimeout = null;
+      if (client[kHTTP2Session] !== session || client[kMaxConcurrentStreams] !== 0 || client[kRunning] !== 0 || client[kPending] === 0) {
+        return;
+      }
+      const err = new HeadersTimeoutError(
+        `HTTP/2: server did not accept a new stream within ${client[kHeadersTimeout]}`
+      );
+      const requests = client[kQueue].splice(client[kPendingIdx]);
+      for (let i = 0; i < requests.length; i++) {
+        if (requests[i] != null) {
+          util5.errorRequest(client, requests[i], err);
+        }
+      }
+      session[kError] = err;
+      resetHttp2Session(session, err);
+    }
     function clearHttp2IdleTimeout(session) {
       const state = session[kHTTP2SessionState];
       if (state?.idleTimeout != null) {
@@ -64986,7 +65072,7 @@ var require_client_h2 = __commonJS({
         const request2 = client[kQueue][i];
         if (request2 != null) {
           streamsToClose.push(detachRequestStreamForClose(request2));
-          if (canRetryRequestAfterGoAway(request2)) {
+          if (canReplayRequest(request2) && registerGoAwayRefusal(request2)) {
             retriableRequests.push(request2);
           } else {
             util5.errorRequest(client, request2, err);
@@ -65007,6 +65093,7 @@ var require_client_h2 = __commonJS({
         client[kHTTP2Session] = null;
       }
       clearHttp2IdleTimeout(this);
+      clearNoStreamsTimeout(this);
       if (!this.closed && !this.destroyed) {
         this.close();
       }
@@ -65023,6 +65110,7 @@ var require_client_h2 = __commonJS({
         client[kHTTP2Session] = null;
       }
       clearHttp2IdleTimeout(this);
+      clearNoStreamsTimeout(this);
       if (state.ping.interval != null) {
         clearInterval(state.ping.interval);
         state.ping.interval = null;
@@ -65098,6 +65186,12 @@ var require_client_h2 = __commonJS({
       releaseRequestStream(this);
       if (state.pendingEnd && !state.request.aborted && !state.request.completed) {
         state.request.onResponseEnd(state.trailers || {});
+      } else if (!state.request.aborted && !state.request.completed) {
+        util5.errorRequest(
+          state.client,
+          state.request,
+          new InformationalError("HTTP/2: stream closed before the response was complete")
+        );
       }
       finalizeRequest(state);
       closeStreamSession(this);
@@ -65497,6 +65591,20 @@ var require_client_h2 = __commonJS({
         state.abort(new InformationalError("HTTP/2: stream half-closed (remote)"), true);
       }
     }
+    function retryRefusedStream(stream4, state) {
+      const { client, request: request2 } = state;
+      if (state.responseReceived || request2.aborted || request2.completed || request2[kRefusedStreamRetry] || !canReplayRequest(request2)) {
+        return false;
+      }
+      request2[kRefusedStreamRetry] = true;
+      detachRequestStreamForClose(request2);
+      state.stream = null;
+      state.requestFinalized = true;
+      completeRequest(client, request2);
+      client[kQueue].splice(client[kPendingIdx], 0, request2);
+      client[kResume]();
+      return true;
+    }
     function onError(err) {
       const stream4 = this;
       const state = stream4[kRequestStreamState];
@@ -65504,6 +65612,12 @@ var require_client_h2 = __commonJS({
         return;
       }
       stream4.off("error", onError);
+      if (typeof stream4.rstCode === "number" && stream4.rstCode !== NGHTTP2_NO_ERROR) {
+        err.http2ErrorCode = stream4.rstCode;
+      }
+      if (stream4.rstCode === NGHTTP2_REFUSED_STREAM && retryRefusedStream(stream4, state)) {
+        return;
+      }
       state.abort(err);
     }
     function onFrameError(type, code) {
@@ -65785,10 +65899,8 @@ var require_client = __commonJS({
       kHTTPContext,
       kMaxConcurrentStreams,
       kHostAuthority,
-      kHTTP2InitialWindowSize,
-      kHTTP2ConnectionWindowSize,
       kResume,
-      kPingInterval
+      kHTTP2Options
     } = require_symbols();
     var connectH1 = require_client_h1();
     var connectH2 = require_client_h2();
@@ -65801,6 +65913,14 @@ var require_client = __commonJS({
     function getPipelining(client) {
       return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1;
     }
+    var h2NamespaceOptsWarning = false;
+    function emitH2OptionsNamespaceWarning(optName) {
+      if (h2NamespaceOptsWarning === true) return;
+      process.emitWarning(`Use h2Options.${optName} instead. ${optName} for H2 will be deprecated in future major.`, {
+        code: "UNDICI-H2-OPTIONS"
+      });
+      h2NamespaceOptsWarning = true;
+    }
     function getMaxConcurrent(client) {
       if (client[kHTTPContext]?.version === "h2") {
         return client[kMaxConcurrentStreams];
@@ -65844,7 +65964,8 @@ var require_client = __commonJS({
         initialWindowSize,
         connectionWindowSize,
         pingInterval,
-        webSocket
+        webSocket,
+        h2Options
       } = {}) {
         if (keepAlive !== void 0) {
           throw new InvalidArgumentError("unsupported keepAlive, use pipelining=0 instead");
@@ -65907,20 +66028,45 @@ var require_client = __commonJS({
         if (allowH2 != null && typeof allowH2 !== "boolean") {
           throw new InvalidArgumentError("allowH2 must be a valid boolean value");
         }
-        if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) {
-          throw new InvalidArgumentError("maxConcurrentStreams must be a positive integer, greater than 0");
-        }
-        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");
+        if (allowH2 !== false) {
+          if (h2Options != null) {
+            if (h2Options.useH2c != null && typeof h2Options.useH2c !== "boolean") {
+              throw new InvalidArgumentError("h2Options.useH2c must be a valid boolean value");
+            }
+            if (h2Options.settings?.initialWindowSize != null && (!Number.isInteger(h2Options.settings.initialWindowSize) || h2Options.settings.initialWindowSize < 1)) {
+              throw new InvalidArgumentError("h2Options.settings.initialWindowSize must be a positive integer, greater than 0");
+            }
+            if (h2Options.maxConcurrentStreams != null && (!Number.isInteger(h2Options.connectionWindowSize) || h2Options.maxConcurrentStreams < 1)) {
+              throw new InvalidArgumentError("h2Options.maxConcurrentStreams must be a positive integer, greater than 0");
+            }
+            if (h2Options.connectionWindowSize != null && (!Number.isInteger(h2Options.connectionWindowSize) || h2Options.connectionWindowSize < 1)) {
+              throw new InvalidArgumentError("h2Options.connectionWindowSize must be a positive integer, greater than 0");
+            }
+            if (h2Options.pingInterval != null && (typeof h2Options.pingInterval !== "number" || !Number.isInteger(h2Options.pingInterval) || h2Options.pingInterval < 0)) {
+              throw new InvalidArgumentError("h2Options.pingInterval must be a positive integer, greater or equal to 0");
+            }
+          } else {
+            if (useH2c != null && typeof useH2c !== "boolean") {
+              emitH2OptionsNamespaceWarning("useH2c");
+              throw new InvalidArgumentError("useH2c must be a valid boolean value");
+            }
+            if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== "number" || maxConcurrentStreams < 1)) {
+              emitH2OptionsNamespaceWarning("maxConcurrentStreams");
+              throw new InvalidArgumentError("maxConcurrentStreams must be a positive integer, greater than 0");
+            }
+            if (initialWindowSize != null && (!Number.isInteger(initialWindowSize) || initialWindowSize < 1)) {
+              emitH2OptionsNamespaceWarning("initialWindowSize");
+              throw new InvalidArgumentError("initialWindowSize must be a positive integer, greater than 0");
+            }
+            if (connectionWindowSize != null && (!Number.isInteger(connectionWindowSize) || connectionWindowSize < 1)) {
+              emitH2OptionsNamespaceWarning("connectionWindowSize");
+              throw new InvalidArgumentError("connectionWindowSize must be a positive integer, greater than 0");
+            }
+            if (pingInterval != null && (typeof pingInterval !== "number" || !Number.isInteger(pingInterval) || pingInterval < 0)) {
+              emitH2OptionsNamespaceWarning("pingInterval");
+              throw new InvalidArgumentError("pingInterval must be a positive integer, greater or equal to 0");
+            }
+          }
         }
         super({ webSocket });
         if (typeof connect4 !== "function") {
@@ -65928,8 +66074,8 @@ var require_client = __commonJS({
             ...tls2,
             maxCachedSessions,
             allowH2,
-            useH2c,
             socketPath,
+            useH2c: h2Options?.useH2c ?? useH2c,
             timeout: connectTimeout,
             ...typeof autoSelectFamily === "boolean" ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : void 0,
             ...connect4
@@ -65964,10 +66110,21 @@ var require_client = __commonJS({
         this[kClosedResolve] = null;
         this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1;
         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[kHTTP2Options] = {
+          pingInterval: h2Options?.pingInterval ?? pingInterval ?? 6e4,
+          connectionWindowSize: h2Options?.connectionWindowSize ?? connectionWindowSize ?? 524288,
+          maxConcurrentStreams: h2Options?.maxConcurrentStreams ?? maxConcurrentStreams ?? 100,
+          // Max peerConcurrentStreams for a Node h2 server
+          sessionOptions: {
+            // HTTP/2 window sizes are set to higher defaults than Node.js core for better performance:
+            // - initialWindowSize: 262144 (256KB) vs Node.js default 65535 (64KB - 1)
+            //   Allows more data to be sent before requiring acknowledgment, improving throughput
+            //   especially on high-latency networks. This matches common production HTTP/2 servers.
+            // - connectionWindowSize: 524288 (512KB) vs Node.js default (none set)
+            //   Provides better flow control for the entire connection across multiple streams.
+            initialWindowSize: h2Options?.initialWindowSize ?? initialWindowSize ?? 262144
+          }
+        };
         this[kQueue] = [];
         this[kRunningIdx] = 0;
         this[kPendingIdx] = 0;
@@ -66252,6 +66409,7 @@ var require_client = __commonJS({
           return;
         }
         if (!client[kHTTPContext]) {
+          client[kServerName] = request2.servername;
           connect3(client);
           return;
         }
@@ -67662,7 +67820,7 @@ var require_socks5_proxy_agent = __commonJS({
     var DispatcherBase = require_dispatcher_base();
     var { InvalidArgumentError } = require_errors();
     var { Socks5Client, STATES } = require_socks5_client();
-    var { kDispatch, kClose, kDestroy } = require_symbols();
+    var { kBusy, kConnected, kDispatch, kClose, kDestroy } = require_symbols();
     var Pool = require_pool();
     var buildConnector = require_connect();
     var { debuglog } = __require("util");
@@ -67820,6 +67978,17 @@ var require_socks5_proxy_agent = __commonJS({
               }
             });
             this[kPools].set(originKey, pool);
+            const closePoolIfUnused = () => {
+              if (this[kPools].get(originKey) !== pool || pool[kConnected] > 0 || pool[kBusy]) {
+                return;
+              }
+              this[kPools].delete(originKey);
+              if (!pool.destroyed) {
+                pool.close();
+              }
+            };
+            pool.on("disconnect", closePoolIfUnused);
+            pool.on("connectionError", closePoolIfUnused);
           }
           return pool[kDispatch](opts, handler);
         } catch (err) {
@@ -68204,7 +68373,7 @@ var require_env_http_proxy_agent = __commonJS({
       }
       #getProxyAgentForUrl(url2) {
         let { protocol, host: hostname, port } = url2;
-        hostname = hostname.replace(/:\d*$/, "").toLowerCase();
+        hostname = hostname.replace(/:\d*$/, "").replace(/^\[(.+)\]$/, "$1").toLowerCase();
         port = Number.parseInt(port, 10) || DEFAULT_PORTS3[protocol] || 0;
         if (!this.#shouldProxy(hostname, port)) {
           return this[kNoProxyAgent];
@@ -68247,11 +68416,22 @@ var require_env_http_proxy_agent = __commonJS({
           if (!entry) {
             continue;
           }
-          const parsed = entry.match(/^(.+):(\d+)$/);
+          let hostname, port;
+          const ipv6WithPort = entry.match(/^\[(.+)\]:(\d+)$/);
+          if (ipv6WithPort) {
+            hostname = ipv6WithPort[1];
+            port = Number.parseInt(ipv6WithPort[2], 10);
+          } else {
+            const unbracketed = entry.replace(/^\[(.+)\]$/, "$1");
+            const colonCount = (unbracketed.match(/:/g) || []).length;
+            const parsed = colonCount === 1 && unbracketed.match(/^(.+):(\d+)$/);
+            hostname = parsed ? parsed[1] : unbracketed;
+            port = parsed ? Number.parseInt(parsed[2], 10) : 0;
+          }
           noProxyEntries.push({
             // strip leading dot or asterisk with dot
-            hostname: (parsed ? parsed[1] : entry).replace(/^\*?\./, "").toLowerCase(),
-            port: parsed ? Number.parseInt(parsed[2], 10) : 0
+            hostname: hostname.replace(/^\*?\./, "").toLowerCase(),
+            port
           });
         }
         this.#noProxyValue = noProxyValue;
@@ -68473,6 +68653,10 @@ var require_retry_handler = __commonJS({
         setTimeout(() => cb(null), retryTimeout);
       }
       onResponseStart(controller, statusCode, headers, statusMessage) {
+        if (statusCode < 200) {
+          this.handler.onResponseStart?.(this.controllerProxy, statusCode, headers, statusMessage);
+          return;
+        }
         this.error = null;
         this.retryCount += 1;
         this.statusCode = statusCode;
@@ -68516,7 +68700,7 @@ var require_retry_handler = __commonJS({
         if (this.end == null) {
           if (statusCode === 206) {
             const range = parseRangeHeader(headers["content-range"]);
-            if (range == null) {
+            if (range == null || range.end == null) {
               this.headersSent = true;
               this.handler.onResponseStart?.(
                 this.controllerProxy,
@@ -68536,7 +68720,7 @@ var require_retry_handler = __commonJS({
             this.start = start;
             this.end = end;
           }
-          if (this.end == null) {
+          if (this.end == null && this.opts.method !== "HEAD") {
             const contentLength = headers["content-length"];
             this.end = contentLength != null ? Number(contentLength) - 1 : null;
           }
@@ -68737,7 +68921,6 @@ var require_readable = __commonJS({
     var kContentLength = /* @__PURE__ */ Symbol("kContentLength");
     var kUsed = /* @__PURE__ */ Symbol("kUsed");
     var kBytesRead = /* @__PURE__ */ Symbol("kBytesRead");
-    var kPreservedBuffer = /* @__PURE__ */ Symbol("kPreservedBuffer");
     var noop2 = () => {
     };
     var BodyReadable = class extends Readable2 {
@@ -68976,21 +69159,6 @@ var require_readable = __commonJS({
        */
       setEncoding(encoding) {
         if (Buffer.isEncoding(encoding)) {
-          const state = this._readableState;
-          const buffer2 = state.buffer;
-          if (buffer2 && state.length > 0) {
-            const bufferIndex = state.bufferIndex ?? 0;
-            const preserved = [];
-            const source = typeof buffer2.slice === "function" ? buffer2.slice(bufferIndex) : buffer2;
-            for (const data of source) {
-              if (Buffer.isBuffer(data)) {
-                preserved.push(data);
-              }
-            }
-            if (preserved.length > 0) {
-              this[kPreservedBuffer] = (this[kPreservedBuffer] || []).concat(preserved);
-            }
-          }
           super.setEncoding(encoding);
         }
         return this;
@@ -69041,13 +69209,7 @@ var require_readable = __commonJS({
         return;
       }
       const { _readableState: state } = consume2.stream;
-      const preserved = consume2.stream[kPreservedBuffer];
-      if (preserved && preserved.length > 0) {
-        for (const chunk of preserved) {
-          consumePush(consume2, chunk);
-        }
-        consume2.stream[kPreservedBuffer] = null;
-      } else if (state.bufferIndex) {
+      if (state.bufferIndex) {
         const start = state.bufferIndex;
         const end = state.buffer.length;
         for (let n = start; n < end; n++) {
@@ -69058,13 +69220,17 @@ var require_readable = __commonJS({
           consumePush(consume2, chunk);
         }
       }
+      const decoder2 = state.decoder;
+      if (decoder2 != null && decoder2.lastNeed > 0) {
+        consumePush(consume2, Buffer.from(decoder2.lastChar.subarray(0, decoder2.lastTotal - decoder2.lastNeed)));
+      }
       if (state.endEmitted) {
-        consumeEnd(this[kConsume], this._readableState.encoding);
-      } else {
-        consume2.stream.on("end", function() {
-          consumeEnd(this[kConsume], this._readableState.encoding);
-        });
+        consumeEnd(consume2, state.encoding);
+        return;
       }
+      consume2.stream.on("end", function() {
+        consumeEnd(this[kConsume], this._readableState.encoding);
+      });
       consume2.stream.resume();
       while (consume2.stream.read() != null) {
       }
@@ -69121,6 +69287,9 @@ var require_readable = __commonJS({
       if (consume2.body === null) {
         return;
       }
+      if (typeof chunk === "string") {
+        chunk = Buffer.from(chunk, consume2.stream._readableState.encoding);
+      }
       consume2.length += chunk.length;
       consume2.body.push(chunk);
     }
@@ -70105,6 +70274,7 @@ var require_mock_utils = __commonJS({
       }
     } = __require("util");
     var { InvalidArgumentError } = require_errors();
+    var requestAborted = /* @__PURE__ */ Symbol("request aborted");
     function matchValue(match, value) {
       if (typeof match === "string") {
         return match === value;
@@ -70217,6 +70387,8 @@ var require_mock_utils = __commonJS({
         return data;
       } else if (data instanceof ArrayBuffer) {
         return data;
+      } else if (ArrayBuffer.isView(data)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
       } else if (typeof data === "object") {
         return JSON.stringify(data);
       } else if (data) {
@@ -70270,6 +70442,9 @@ var require_mock_utils = __commonJS({
       }
     }
     function removeTrailingSlash(path6) {
+      if (typeof path6 !== "string") {
+        return path6;
+      }
       while (path6.endsWith("/")) {
         path6 = path6.slice(0, -1);
       }
@@ -70323,30 +70498,38 @@ var require_mock_utils = __commonJS({
       const { timesInvoked, times } = mockDispatch2;
       mockDispatch2.consumed = !mockDispatch2.persist && timesInvoked >= times;
       mockDispatch2.pending = timesInvoked < times;
-      if (mockDispatch2.data.callback) {
-        const callbackResult = mockDispatch2.data.callback(opts);
+      const hasBodyHooks = typeof handler.onBodySent === "function" || typeof handler.onRequestSent === "function";
+      if (mockDispatch2.data.callback && (!hasBodyHooks || opts.body == null)) {
+        const { callback, ...responseDefaults } = mockDispatch2.data;
+        const callbackResult = callback(opts);
         if (isPromise(callbackResult)) {
           callbackResult.then(
             (resolvedData) => {
-              mockDispatch2.data = { ...mockDispatch2.data, ...resolvedData };
+              if (resolvedData == null || typeof resolvedData !== "object") {
+                handler.onResponseError(null, new InvalidArgumentError("reply options callback must return an object"));
+                return;
+              }
+              mockDispatch2.data = { ...responseDefaults, ...resolvedData };
               dispatchMockReply(mockDispatches, mockDispatch2, key2, opts, handler);
             },
             (error) => {
-              deleteMockDispatch(mockDispatches, key2);
               handler.onResponseError(null, error);
             }
           );
           return true;
         }
-        mockDispatch2.data = { ...mockDispatch2.data, ...callbackResult };
+        if (callbackResult == null || typeof callbackResult !== "object") {
+          throw new InvalidArgumentError("reply options callback must return an object");
+        }
+        mockDispatch2.data = { ...responseDefaults, ...callbackResult };
       }
       return dispatchMockReply(mockDispatches, mockDispatch2, key2, opts, handler);
     }
     function dispatchMockReply(mockDispatches, mockDispatch2, key2, opts, handler) {
-      const { data: { statusCode, data, headers, trailers, error }, delay } = mockDispatch2;
-      if (error !== null) {
+      const { data: response, delay } = mockDispatch2;
+      if (response.error !== null) {
         deleteMockDispatch(mockDispatches, key2);
-        handler.onResponseError(null, error);
+        handler.onResponseError(null, response.error);
         return true;
       }
       let aborted = false;
@@ -70373,30 +70556,91 @@ var require_mock_utils = __commonJS({
           handler.onResponseError?.(controller, reason);
         }
       };
+      let replyOpts = opts;
+      const dispatches = mockDispatches;
       handler.onRequestStart?.(controller, null);
-      if (typeof delay === "number" && delay > 0) {
-        timer2 = setTimeout(() => {
-          timer2 = null;
-          handleReply(mockDispatches);
-        }, delay);
-      } else {
-        handleReply(mockDispatches);
+      if (aborted) {
+        return true;
+      }
+      const requestBody = dispatchRequestBody(opts.body, handler, controller, () => aborted);
+      if (isPromise(requestBody)) {
+        requestBody.then((body) => {
+          if (body === requestAborted) {
+            return;
+          }
+          if (body !== opts.body) {
+            replyOpts = { ...opts, body };
+          }
+          sendReply();
+        }, (error) => controller.abort(error));
+        return true;
+      }
+      if (requestBody === requestAborted) {
+        return true;
+      }
+      if (requestBody !== opts.body) {
+        replyOpts = { ...opts, body: requestBody };
+      }
+      sendReply();
+      function sendReply() {
+        if (response.callback) {
+          const { callback, ...responseDefaults } = response;
+          let callbackResult;
+          try {
+            callbackResult = callback(replyOpts);
+          } catch (err) {
+            deleteMockDispatch(mockDispatches, key2);
+            handler.onResponseError(null, err);
+            return;
+          }
+          if (isPromise(callbackResult)) {
+            callbackResult.then(
+              (resolvedData) => {
+                if (resolvedData == null || typeof resolvedData !== "object") {
+                  handler.onResponseError(null, new InvalidArgumentError("reply options callback must return an object"));
+                  return;
+                }
+                mockDispatch2.data = { ...responseDefaults, ...resolvedData };
+                handleReply(dispatches, mockDispatch2.data);
+              },
+              (err) => {
+                handler.onResponseError(null, err);
+              }
+            );
+            return;
+          }
+          if (callbackResult == null || typeof callbackResult !== "object") {
+            throw new InvalidArgumentError("reply options callback must return an object");
+          }
+          mockDispatch2.data = { ...responseDefaults, ...callbackResult };
+          handleReply(dispatches, mockDispatch2.data);
+          return;
+        }
+        if (typeof delay === "number" && delay > 0) {
+          timer2 = setTimeout(() => {
+            timer2 = null;
+            handleReply(dispatches);
+          }, delay);
+        } else {
+          handleReply(dispatches);
+        }
       }
-      function handleReply(mockDispatches2, _data = data) {
+      function handleReply(mockDispatches2, _response = response) {
         if (aborted) {
           return;
         }
+        const { statusCode, data, headers, trailers } = _response;
         const optsHeaders = Array.isArray(opts.headers) ? buildHeadersFromArray(opts.headers) : opts.headers;
-        const body = typeof _data === "function" ? _data({ ...opts, headers: optsHeaders }) : _data;
+        const body = typeof data === "function" ? data({ ...replyOpts, headers: optsHeaders }) : data;
         if (isPromise(body)) {
-          return body.then((newData) => handleReply(mockDispatches2, newData));
+          return body.then((newData) => handleReply(mockDispatches2, { ..._response, data: newData }));
         }
         if (aborted) {
           return;
         }
         const responseData = getResponseData(body);
-        const responseHeaders = generateKeyValues(headers);
-        const responseTrailers = generateKeyValues(trailers);
+        const responseHeaders = generateKeyValues(headers ?? {});
+        const responseTrailers = generateKeyValues(trailers ?? {});
         controller.rawHeaders = responseHeaders;
         controller.rawTrailers = responseTrailers;
         handler.onResponseStart?.(controller, statusCode, parseHeaders(responseHeaders), getStatusText(statusCode));
@@ -70406,6 +70650,78 @@ var require_mock_utils = __commonJS({
       }
       return true;
     }
+    function dispatchRequestBody(body, handler, controller, isAborted2) {
+      if (typeof handler.onBodySent !== "function" && typeof handler.onRequestSent !== "function") {
+        return body;
+      }
+      if (body == null) {
+        return callOnRequestSent(handler, controller, isAborted2) ? body : requestAborted;
+      }
+      if (body && typeof body[Symbol.asyncIterator] === "function") {
+        return dispatchAsyncIterableBody(body, handler, controller, isAborted2);
+      }
+      if (isIterableBody(body)) {
+        const chunks = [];
+        for (const chunk of body) {
+          if (isAborted2()) {
+            return requestAborted;
+          }
+          chunks.push(chunk);
+          if (!callOnBodySent(handler, controller, chunk) || isAborted2()) {
+            return requestAborted;
+          }
+        }
+        return callOnRequestSent(handler, controller, isAborted2) ? chunks : requestAborted;
+      }
+      if (isAborted2()) {
+        return requestAborted;
+      }
+      if (!callOnBodySent(handler, controller, body)) {
+        return requestAborted;
+      }
+      return callOnRequestSent(handler, controller, isAborted2) ? body : requestAborted;
+    }
+    async function dispatchAsyncIterableBody(body, handler, controller, isAborted2) {
+      const chunks = [];
+      for await (const chunk of body) {
+        if (isAborted2()) {
+          return requestAborted;
+        }
+        chunks.push(chunk);
+        if (!callOnBodySent(handler, controller, chunk) || isAborted2()) {
+          return requestAborted;
+        }
+      }
+      if (!callOnRequestSent(handler, controller, isAborted2)) {
+        return requestAborted;
+      }
+      return {
+        async *[Symbol.asyncIterator]() {
+          yield* chunks;
+        }
+      };
+    }
+    function callOnBodySent(handler, controller, chunk) {
+      try {
+        handler.onBodySent?.(chunk);
+        return true;
+      } catch (error) {
+        controller.abort(error);
+        return false;
+      }
+    }
+    function callOnRequestSent(handler, controller, isAborted2) {
+      try {
+        handler.onRequestSent?.();
+        return !isAborted2();
+      } catch (error) {
+        controller.abort(error);
+        return false;
+      }
+    }
+    function isIterableBody(body) {
+      return typeof body !== "string" && !Buffer.isBuffer(body) && !ArrayBuffer.isView(body) && typeof body[Symbol.iterator] === "function";
+    }
     function buildMockDispatch() {
       const agent = this[kMockAgent];
       const origin2 = this[kOrigin];
@@ -73049,15 +73365,13 @@ var require_cache = __commonJS({
       }
     }
     function makeCacheKey(opts) {
-      if (!opts.origin) {
-        throw new Error("opts.origin is undefined");
-      }
+      const origin2 = opts.origin ? opts.origin.toString() : "";
       let fullPath = opts.path || "/";
       if (opts.query && !pathHasQueryOrFragment(fullPath)) {
         fullPath = serializePathWithQuery(fullPath, opts.query);
       }
       return {
-        origin: opts.origin.toString(),
+        origin: origin2,
         method: opts.method,
         path: fullPath,
         headers: opts.headers
@@ -75140,10 +75454,13 @@ var require_cache2 = __commonJS({
       }
       return (dispatch) => {
         return (opts2, handler) => {
-          if (!opts2.origin || arrayIncludes(safeMethodsToNotCache, opts2.method)) {
+          if (arrayIncludes(safeMethodsToNotCache, opts2.method)) {
             return dispatch(opts2, handler);
           }
           if (origins !== void 0) {
+            if (!opts2.origin) {
+              return dispatch(opts2, handler);
+            }
             const requestOrigin = opts2.origin.toString().toLowerCase();
             let isAllowed = false;
             for (let i = 0; i < origins.length; i++) {
@@ -75841,7 +76158,7 @@ var require_deduplicate = __commonJS({
       const pendingRequests = /* @__PURE__ */ new Map();
       return (dispatch) => {
         return (opts2, handler) => {
-          if (!opts2.origin || methods.includes(opts2.method) === false) {
+          if (opts2.upgrade || methods.includes(opts2.method) === false) {
             return dispatch(opts2, handler);
           }
           opts2 = {
@@ -81691,6 +82008,8 @@ var require_websocket2 = __commonJS({
     var { SendQueue } = require_sender2();
     var { WebsocketFrameSend } = require_frame();
     var { channels } = require_diagnostics();
+    var kRef = /* @__PURE__ */ Symbol.for("nodejs.ref");
+    var kUnref = /* @__PURE__ */ Symbol.for("nodejs.unref");
     function getSocketAddress(socket) {
       if (typeof socket?.address === "function") {
         return socket.address();
@@ -81710,6 +82029,7 @@ var require_websocket2 = __commonJS({
       #bufferedAmount = 0;
       #protocol = "";
       #extensions = "";
+      #refed = true;
       /** @type {SendQueue} */
       #sendQueue;
       /** @type {Handler} */
@@ -81792,6 +82112,16 @@ var require_websocket2 = __commonJS({
         this.#handler.readyState = _WebSocket.CONNECTING;
         this.#binaryType = "blob";
       }
+      [kRef]() {
+        webidl.brandCheck(this, _WebSocket);
+        this.#refed = true;
+        this.#handler.socket?.ref?.();
+      }
+      [kUnref]() {
+        webidl.brandCheck(this, _WebSocket);
+        this.#refed = false;
+        this.#handler.socket?.unref?.();
+      }
       /**
        * @see https://websockets.spec.whatwg.org/#dom-websocket-close
        * @param {number|undefined} code
@@ -81953,6 +82283,9 @@ var require_websocket2 = __commonJS({
        */
       #onConnectionEstablished(response, parsedExtensions) {
         this.#handler.socket = response.socket;
+        if (!this.#refed) {
+          this.#handler.socket.unref?.();
+        }
         const maxFragments = this.#handler.controller.dispatcher?.webSocketOptions?.maxFragments;
         const maxPayloadSize = this.#handler.controller.dispatcher?.webSocketOptions?.maxPayloadSize;
         const parser = new ByteParser(this.#handler, parsedExtensions, {
@@ -89712,8 +90045,6 @@ var init_proxy = __esm({
       "free/gpt-oss-20b",
       "free/deepseek-v4-flash",
       // 1M ctx; slow (~10 tok/s, 07-28 probe) but completes
-      "free/seed-oss-36b",
-      // live coder (successor to retired qwen3-coder-480b)
       "free/mistral-nemotron",
       // strong instruction following
       "free/step-3.7-flash",