@openclaw/discord 2026.7.2-beta.2 → 2026.7.2-beta.4

package/node_modules/undici/docs/docs/site.json

@@ -0,0 +1,125 @@
+{
+  "sidebar": [
+    {
+      "groupName": "Documentation",
+      "items": [
+        { "link": "/", "label": "Home" },
+        { "link": "/getting-started", "label": "Getting Started" }
+      ]
+    },
+    {
+      "groupName": "API",
+      "items": [
+        {
+          "label": "Core",
+          "items": [
+            { "link": "/api/Dispatcher", "label": "Dispatcher" },
+            { "link": "/api/Client", "label": "Client" },
+            { "link": "/api/H2CClient", "label": "H2CClient" },
+            { "link": "/api/Pool", "label": "Pool" },
+            { "link": "/api/BalancedPool", "label": "BalancedPool" },
+            { "link": "/api/RoundRobinPool", "label": "RoundRobinPool" },
+            { "link": "/api/Agent", "label": "Agent" },
+            { "link": "/api/PoolStats", "label": "PoolStats" },
+            { "link": "/api/Connector", "label": "Connector" }
+          ]
+        },
+        {
+          "label": "Proxy & Agents",
+          "items": [
+            { "link": "/api/ProxyAgent", "label": "ProxyAgent" },
+            {
+              "link": "/api/EnvHttpProxyAgent",
+              "label": "EnvHttpProxyAgent"
+            },
+            { "link": "/api/Socks5ProxyAgent", "label": "Socks5ProxyAgent" },
+            { "link": "/api/RetryAgent", "label": "RetryAgent" }
+          ]
+        },
+        {
+          "label": "Web Standards",
+          "items": [
+            { "link": "/api/Fetch", "label": "Fetch" },
+            { "link": "/api/EventSource", "label": "EventSource" },
+            { "link": "/api/WebSocket", "label": "WebSocket" },
+            { "link": "/api/Cookies", "label": "Cookies" },
+            { "link": "/api/CacheStorage", "label": "CacheStorage" },
+            { "link": "/api/ContentType", "label": "MIME Type Parsing" }
+          ]
+        },
+        {
+          "label": "Mocking",
+          "items": [
+            { "link": "/api/MockClient", "label": "MockClient" },
+            { "link": "/api/MockPool", "label": "MockPool" },
+            { "link": "/api/MockAgent", "label": "MockAgent" },
+            { "link": "/api/SnapshotAgent", "label": "SnapshotAgent" },
+            { "link": "/api/MockCallHistory", "label": "MockCallHistory" },
+            {
+              "link": "/api/MockCallHistoryLog",
+              "label": "MockCallHistoryLog"
+            },
+            { "link": "/api/MockErrors", "label": "MockErrors" }
+          ]
+        },
+        {
+          "label": "Interceptors",
+          "items": [
+            { "link": "/api/Interceptors", "label": "Interceptors" }
+          ]
+        },
+        {
+          "label": "Handlers",
+          "items": [
+            { "link": "/api/RedirectHandler", "label": "RedirectHandler" },
+            { "link": "/api/RetryHandler", "label": "RetryHandler" }
+          ]
+        },
+        {
+          "label": "Diagnostics & Utilities",
+          "items": [
+            { "link": "/api/Errors", "label": "Errors" },
+            {
+              "link": "/api/DiagnosticsChannel",
+              "label": "Diagnostics Channel Support"
+            },
+            { "link": "/api/Debug", "label": "Debug" },
+            { "link": "/api/Util", "label": "Util" },
+            {
+              "link": "/api/GlobalInstallation",
+              "label": "Global Installation"
+            },
+            { "link": "/api/api-lifecycle", "label": "API Lifecycle" }
+          ]
+        }
+      ]
+    },
+    {
+      "groupName": "Best Practices",
+      "items": [
+        {
+          "link": "/best-practices/undici-vs-builtin-fetch",
+          "label": "Undici vs. Built-in Fetch"
+        },
+        {
+          "link": "/best-practices/migrating-from-v7-to-v8",
+          "label": "Migrating from Undici 7 to 8"
+        },
+        { "link": "/best-practices/proxy", "label": "Proxy" },
+        {
+          "link": "/best-practices/client-certificate",
+          "label": "Client Certificate"
+        },
+        {
+          "link": "/best-practices/writing-tests",
+          "label": "Writing Tests"
+        },
+        {
+          "link": "/best-practices/mocking-request",
+          "label": "Mocking Request"
+        },
+        { "link": "/best-practices/crawling", "label": "Crawling" }
+      ]
+    }
+  ]
+}

package/node_modules/undici/docs/docs/type-map.json

@@ -0,0 +1,79 @@
+{
+  "AbortError": "/api/Errors.md#class-aborterror",
+  "Agent": "/api/Agent.md#class-agent",
+  "AgentDispatchOptions": "/api/Agent.md#agentdispatchoptions-handler",
+  "AgentOptions": "/api/Agent.md#new-agentoptions",
+  "BalancedPool": "/api/BalancedPool.md#class-balancedpool",
+  "BalancedPoolOptions": "/api/BalancedPool.md#parameter-balancedpooloptions",
+  "BodyMixin": "/api/Fetch.md#new-formdata",
+  "Buffer": "https://nodejs.org/api/buffer.html#class-buffer",
+  "BuildOptions": "/api/Connector.md#buildconnectoroptions",
+  "CacheKey": "/api/CacheStore.md#cachekey",
+  "CacheStore": "/api/CacheStore.md#new-memorycachestoreoptions",
+  "CacheValue": "/api/CacheStore.md#cachevalue",
+  "ClientDestroyedError": "/api/Errors.md#class-clientdestroyederror",
+  "ClientOptions": "/api/Client.md#new-clienturl-options",
+  "ClientStats": "/api/ClientStats.md#class-clientstats",
+  "ConnectOptions": "/api/Dispatcher.md#class-dispatcher",
+  "Cookie": "/api/Cookies.md#cookie",
+  "DispatchController": "/api/Dispatcher.md#class-dispatcher",
+  "DispatchHandler": "/api/Dispatcher.md#class-dispatcher",
+  "DispatchOptions": "/api/Dispatcher.md#class-dispatcher",
+  "Dispatcher": "/api/Dispatcher.md#class-dispatcher",
+  "Duplex": "https://nodejs.org/api/stream.html#class-streamduplex",
+  "EnvHttpProxyAgent": "/api/EnvHttpProxyAgent.md#class-envhttpproxyagent",
+  "EnvHttpProxyAgentOptions": "/api/EnvHttpProxyAgent.md#new-envhttpproxyagentoptions",
+  "EventEmitter": "https://nodejs.org/api/events.html#class-eventemitter",
+  "GetResult": "/api/CacheStore.md#getresult",
+  "H2CClientOptions": "/api/H2CClient.md#new-h2cclienturl-options",
+  "HeadersInit": "https://developer.mozilla.org/docs/Web/API/Headers/Headers",
+  "InvalidArgumentError": "/api/Errors.md#class-invalidargumenterror",
+  "Iterable": "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Iteration_protocols",
+  "MaxOriginsReachedError": "/api/Errors.md#class-maxoriginsreachederror",
+  "MockAgent": "/api/MockAgent.md#class-mockagent",
+  "MockAgentOptions": "/api/MockAgent.md#parameter-mockagentoptions",
+  "MockCallHistory": "/api/MockCallHistory.md#class-mockcallhistory",
+  "MockCallHistoryLog": "/api/MockCallHistoryLog.md#class-mockcallhistorylog",
+  "MockClient": "/api/MockClient.md#class-mockclient",
+  "MockClientOptions": "/api/MockClient.md#parameter-mockclientoptions",
+  "MockInterceptor": "/api/MockPool.md#return-mockinterceptor",
+  "MockInterceptor.Options": "/api/MockPool.md#parameter-mockpoolinterceptoptions",
+  "MockPool": "/api/MockPool.md#class-mockpool",
+  "MockPoolInterceptOptions": "/api/MockPool.md#parameter-mockpoolinterceptoptions",
+  "MockPoolOptions": "/api/MockPool.md#parameter-mockpooloptions",
+  "MockResponseOptions": "/api/MockPool.md#parameter-mockresponseoptions",
+  "MockScope": "/api/MockPool.md#return-mockscope",
+  "PendingInterceptor": "/api/MockAgent.md#new-mockagentoptions",
+  "PipelineOptions": "/api/Dispatcher.md#class-dispatcher",
+  "Pool": "/api/Pool.md#class-pool",
+  "PoolOptions": "/api/Pool.md#new-poolurl-options",
+  "PoolStats": "/api/PoolStats.md#class-poolstats",
+  "ProxyAgent": "/api/ProxyAgent.md#class-proxyagent",
+  "ProxyAgentOptions": "/api/ProxyAgent.md#new-proxyagentoptions",
+  "Readable": "https://nodejs.org/api/stream.html#class-streamreadable",
+  "Record": "https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type",
+  "RequestInit": "/api/Fetch.md#new-formdata",
+  "RequestOptions": "/api/Dispatcher.md#class-dispatcher",
+  "ResponseInit": "/api/Fetch.md#new-formdata",
+  "RetryContext": "/api/RetryHandler.md#retrycontext",
+  "RetryHandler": "/api/RetryHandler.md#class-retryhandler",
+  "RetryHandlers": "/api/RetryHandler.md#parameter-retryhandlers",
+  "RetryOptions": "/api/RetryHandler.md#retryoptions",
+  "RetryState": "/api/RetryHandler.md#retrystate",
+  "RoundRobinPoolOptions": "/api/RoundRobinPool.md#parameter-roundrobinpooloptions",
+  "SnapshotRecorder": "/api/SnapshotAgent.md#new-snapshotagentoptions",
+  "Socket": "https://nodejs.org/api/net.html#class-netsocket",
+  "SocketInfo": "/api/Errors.md#new-requestretryerrormessage-code-options",
+  "StreamOptions": "/api/Dispatcher.md#class-dispatcher",
+  "TLSSocket": "https://nodejs.org/api/tls.html#class-tlstlssocket",
+  "UndiciError": "/api/Errors.md#class-undicierror",
+  "UndiciHeaders": "/api/Dispatcher.md#class-dispatcher",
+  "UpgradeOptions": "/api/Dispatcher.md#class-dispatcher",
+  "UrlObject": "/index.md#urlobject",
+  "WebSocketInit": "/api/WebSocket.md#new-websocketurl-protocols",
+  "WebSocketStreamOptions": "/api/WebSocket.md#new-websocketurl-protocols",
+  "Writable": "https://nodejs.org/api/stream.html#class-streamwritable",
+  "buildConnector.BuildOptions": "/api/Connector.md#buildconnectoroptions",
+  "net.Socket": "https://nodejs.org/api/net.html#class-netsocket",
+  "stream.Readable": "https://nodejs.org/api/stream.html#class-streamreadable"
+}

package/node_modules/undici/lib/api/api-request.js

@@ -66,7 +66,13 @@ class RequestHandler extends AsyncResource {
       this.removeAbortListener = util.addAbortListener(signal, () => {
         this.reason = signal.reason ?? new RequestAbortedError()
         if (this.res) {
-          util.destroy(this.res.on('error', noop), this.reason)
+          // Null the reference before destroying, mirroring onResponseError, so
+          // that chunks flushed after the abort (e.g. an async decompressor
+          // flush) are dropped by the `!this.res` guard in onResponseData
+          // instead of being pushed into the torn-down stream.
+          const res = this.res
+          this.res = null
+          util.destroy(res.on('error', noop), this.reason)
         } else if (this.abort) {
           this.abort(this.reason)
         }

package/node_modules/undici/lib/api/readable.js

@@ -15,6 +15,7 @@ const kContentType = Symbol('kContentType')
 const kContentLength = Symbol('kContentLength')
 const kUsed = Symbol('kUsed')
 const kBytesRead = Symbol('kBytesRead')
+const kPreservedBuffer = Symbol('kPreservedBuffer')
 
 const noop = () => {}
 
@@ -325,7 +326,37 @@ class BodyReadable extends Readable {
    */
   setEncoding (encoding) {
     if (Buffer.isEncoding(encoding)) {
-      this._readableState.encoding = encoding
+      // Preserve raw Buffer chunks for the consume path (body.text(),
+      // body.json(), etc.) before super.setEncoding() replaces them
+      // with decoded strings. Without this, the consume path would
+      // lose access to the original bytes — some of which may be held
+      // by the decoder for incomplete multi-byte sequences, and the
+      // rest converted to strings that can't be safely concatenated
+      // byte-wise.
+      const state = this._readableState
+      const buffer = state.buffer
+      if (buffer && state.length > 0) {
+        const bufferIndex = state.bufferIndex ?? 0
+        const preserved = []
+        const source = typeof buffer.slice === 'function'
+          ? buffer.slice(bufferIndex)
+          : buffer
+        for (const data of source) {
+          if (Buffer.isBuffer(data)) {
+            preserved.push(data)
+          }
+        }
+        if (preserved.length > 0) {
+          this[kPreservedBuffer] = (this[kPreservedBuffer] || []).concat(preserved)
+        }
+      }
+
+      // Delegate to Node.js Readable.setEncoding() which initializes a
+      // StringDecoder and re-encodes already-buffered chunks. This properly
+      // handles multi-byte sequences split at chunk boundaries for the
+      // for-await / on('data') paths. Without this, Node.js uses
+      // buf.toString(encoding) on each chunk, producing U+FFFD for split chars.
+      super.setEncoding(encoding)
     }
     return this
   }
@@ -433,7 +464,17 @@ function consumeStart (consume) {
 
   const { _readableState: state } = consume.stream
 
-  if (state.bufferIndex) {
+  // If setEncoding() was called, state.buffer may contain decoded strings
+  // (which would break Buffer.concat in chunksDecode). Use the preserved
+  // raw Buffers (saved before super.setEncoding() in setEncoding()) for
+  // byte-level accurate consumption. Otherwise read from state.buffer.
+  const preserved = consume.stream[kPreservedBuffer]
+  if (preserved && preserved.length > 0) {
+    for (const chunk of preserved) {
+      consumePush(consume, chunk)
+    }
+    consume.stream[kPreservedBuffer] = null
+  } else if (state.bufferIndex) {
     const start = state.bufferIndex
     const end = state.buffer.length
     for (let n = start; n < end; n++) {

package/node_modules/undici/lib/core/errors.js

@@ -403,6 +403,25 @@ class SecureProxyConnectionError extends UndiciError {
   }
 }
 
+const kProxyConnectionError = Symbol.for('undici.error.UND_ERR_PRX_CONN')
+class ProxyConnectionError extends UndiciError {
+  constructor (cause, message, options = {}) {
+    super(message, { cause, ...options })
+    this.name = 'ProxyConnectionError'
+    this.message = message || 'Proxy Connection failed'
+    this.code = 'UND_ERR_PRX_CONN'
+    this.cause = cause
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kProxyConnectionError] === true
+  }
+
+  get [kProxyConnectionError] () {
+    return true
+  }
+}
+
 const kMaxOriginsReachedError = Symbol.for('undici.error.UND_ERR_MAX_ORIGINS_REACHED')
 class MaxOriginsReachedError extends UndiciError {
   constructor (message) {
@@ -471,6 +490,7 @@ module.exports = {
   RequestRetryError,
   ResponseError,
   SecureProxyConnectionError,
+  ProxyConnectionError,
   MaxOriginsReachedError,
   Socks5ProxyError,
   MessageSizeExceededError

package/node_modules/undici/lib/core/request.js

@@ -225,7 +225,7 @@ class Request {
     this.protocol = getProtocolFromUrlString(origin)
 
     this.idempotent = idempotent == null
-      ? method === 'HEAD' || method === 'GET'
+      ? method === 'HEAD' || method === 'GET' || method === 'QUERY'
       : idempotent
 
     this.blocking = blocking ?? this.method !== 'HEAD'

package/node_modules/undici/lib/core/util.js

@@ -960,7 +960,9 @@ const normalizedMethodRecordsBase = {
   post: 'POST',
   POST: 'POST',
   put: 'PUT',
-  PUT: 'PUT'
+  PUT: 'PUT',
+  query: 'QUERY',
+  QUERY: 'QUERY'
 }
 
 const normalizedMethodRecords = {

package/node_modules/undici/lib/dispatcher/client-h1.js

@@ -377,6 +377,29 @@ class Parser {
 
     const { llhttp } = this
 
+    // The peer closed the connection. If the body parser was paused by
+    // backpressure we must finish parsing before signalling EOF, otherwise
+    // llhttp_finish() would crash (it used to assert !paused) or report a
+    // half-parsed message. Backpressure is advisory here: onData keeps buffering
+    // delivered bytes into the response stream, so resume across pauses and
+    // drain whatever is still buffered on the socket. A Content-Length/chunked
+    // body reaches on_message_complete during execute(); an EOF-delimited body
+    // stays paused (its length is unknown) and is completed by llhttp_finish().
+    if (this.paused) {
+      let data
+      do {
+        llhttp.llhttp_resume(this.ptr)
+        this.paused = false
+        data = this.socket.read() || EMPTY_BUF
+        this.execute(data)
+      } while (this.paused && data.length > 0)
+
+      if (this.paused) {
+        llhttp.llhttp_resume(this.ptr)
+        this.paused = false
+      }
+    }
+
     let ret
 
     try {

package/node_modules/undici/lib/dispatcher/client-h2.js

@@ -174,11 +174,7 @@ function canRetryRequestAfterGoAway (request) {
   return body == null || util.isBuffer(body) || util.isBlobLike(body)
 }
 
-function closeRequestStream (request, code = NGHTTP2_REFUSED_STREAM) {
-  const stream = request[kRequestStream]
-
-  clearRequestStream(request)
-
+function closeStream (stream, code = NGHTTP2_REFUSED_STREAM) {
   if (stream != null && !stream.destroyed && !stream.closed) {
     try {
       stream.close(code)
@@ -186,6 +182,14 @@ function closeRequestStream (request, code = NGHTTP2_REFUSED_STREAM) {
   }
 }
 
+function detachRequestStreamForClose (request) {
+  const stream = request[kRequestStream]
+
+  clearRequestStream(request)
+
+  return stream
+}
+
 function connectH2 (client, socket) {
   client[kSocket] = socket
 
@@ -447,11 +451,20 @@ function onHttp2SessionError (err) {
   assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
 
   this[kSocket][kError] = err
+
+  if (this[kReceivedGoAway]) {
+    return
+  }
+
   this[kClient][kOnError](err)
 }
 
 function onHttp2FrameError (type, code, id) {
   if (id === 0) {
+    if (this[kReceivedGoAway]) {
+      return
+    }
+
     const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)
     this[kSocket][kError] = err
     this[kClient][kOnError](err)
@@ -485,12 +498,16 @@ function onHttp2SessionGoAway (errorCode, lastStreamID) {
   const previousPendingIdx = client[kPendingIdx]
   const pendingIdx = getGoAwayPendingIdx(client, lastStreamID)
   const retriableRequests = []
+  const streamsToClose = []
 
+  // Closing one stream after GOAWAY can synchronously emit frameError on
+  // sibling streams. Detach all affected requests first so those errors do
+  // not fail requests that are about to be requeued.
   for (let i = pendingIdx; i < previousPendingIdx; i++) {
     const request = client[kQueue][i]
 
     if (request != null) {
-      closeRequestStream(request)
+      streamsToClose.push(detachRequestStreamForClose(request))
 
       if (canRetryRequestAfterGoAway(request)) {
         retriableRequests.push(request)
@@ -500,6 +517,10 @@ function onHttp2SessionGoAway (errorCode, lastStreamID) {
     }
   }
 
+  for (let i = 0; i < streamsToClose.length; i++) {
+    closeStream(streamsToClose[i])
+  }
+
   if (pendingIdx !== previousPendingIdx) {
     const remainingPendingRequests = client[kQueue].slice(previousPendingIdx)
     client[kQueue].length = pendingIdx
@@ -595,6 +616,10 @@ function onHttp2SocketError (err) {
 
   this[kError] = err
 
+  if (this[kHTTP2Session]?.[kReceivedGoAway]) {
+    return
+  }
+
   this[kClient][kOnError](err)
 }
 
@@ -1037,6 +1062,7 @@ function writeH2 (client, request) {
     headersTimeout,
     bodyTimeout,
     responseReceived: false,
+    bodySent: false,
     session,
     stream: null
   }
@@ -1136,6 +1162,13 @@ function onResponse (headers) {
 
   stream.off('response', onResponse)
 
+  // Final response received while still awaiting 100 (Continue): the body won't
+  // be sent, so close our half or the stream stays open and never completes.
+  if (state.body != null && !state.bodySent && !stream.writableEnded) {
+    stream.removeListener('continue', writeBodyH2)
+    stream.end()
+  }
+
   const statusCode = headers[HTTP2_HEADER_STATUS]
   delete headers[HTTP2_HEADER_STATUS]
   request.onResponseStarted()
@@ -1233,6 +1266,7 @@ function onTrailers (trailers) {
 function writeBodyH2 () {
   const stream = this
   const state = stream[kRequestStreamState]
+  state.bodySent = true
   const { abort, body, client, contentLength, expectsPayload, request } = state
 
   if (!body || contentLength === 0) {

package/node_modules/undici/lib/dispatcher/proxy-agent.js

@@ -4,7 +4,7 @@ const { kProxy, kClose, kDestroy, kDispatch } = require('../core/symbols')
 const Agent = require('./agent')
 const Pool = require('./pool')
 const DispatcherBase = require('./dispatcher-base')
-const { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require('../core/errors')
+const { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError, ProxyConnectionError } = require('../core/errors')
 const buildConnector = require('../core/connect')
 const Client = require('./client')
 const { channels } = require('../core/diagnostics')
@@ -231,6 +231,14 @@ class ProxyAgent extends DispatcherBase {
           if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
             // Throw a custom error to avoid loop in client.js#connect
             callback(new SecureProxyConnectionError(err))
+          } else if (err.code === 'UND_ERR_SOCKET') {
+            // A socket failure while establishing the tunnel means the CONNECT
+            // never completed, so there is nothing to recover - the proxy just
+            // tore down the connection. client.js#onError treats UND_ERR_SOCKET
+            // as a recoverable error on an established connection and leaves the
+            // request queued, which makes connect() retry forever. Surface it as
+            // a non-recoverable proxy error so the request fails instead. (#3897)
+            callback(new ProxyConnectionError(err))
           } else {
             callback(err)
           }

package/node_modules/undici/lib/handler/redirect-handler.js

@@ -55,6 +55,7 @@ class RedirectHandler {
     // https://tools.ietf.org/html/rfc7231#section-6.4.2
     // https://fetch.spec.whatwg.org/#http-redirect-fetch
     // In case of HTTP 301 or 302 with POST, change the method to GET
+    // QUERY is safe (RFC 10008) and should not change method like GET.
     if ((statusCode === 301 || statusCode === 302) && this.opts.method === 'POST') {
       this.opts.method = 'GET'
       if (util.isStream(this.opts.body)) {