rezo 1.0.41 → 1.0.43

package/dist/adapters/http2.js

@@ -1,4 +1,5 @@
 import * as http2 from "node:http2";
+import * as tls from "node:tls";
 import * as zlib from "node:zlib";
 import { URL } from "node:url";
 import { Readable } from "node:stream";
@@ -14,9 +15,105 @@ import { DownloadResponse } from '../responses/download.js';
 import { UploadResponse } from '../responses/upload.js';
 import { CompressionUtil } from '../utils/compression.js';
 import { isSameDomain, RezoPerformance } from '../utils/tools.js';
+import { SocksClient } from '../internal/agents/socks-client.js';
+import * as net from "node:net";
 import { ResponseCache } from '../cache/response-cache.js';
 let zstdDecompressSync = null;
 let zstdChecked = false;
+const debugLog = {
+  requestStart: (config, url, method) => {
+    if (config.debug) {
+      console.log(`
+[Rezo Debug] ─────────────────────────────────────`);
+      console.log(`[Rezo Debug] ${method} ${url}`);
+      console.log(`[Rezo Debug] Request ID: ${config.requestId}`);
+      if (config.originalRequest?.headers) {
+        const headers = config.originalRequest.headers instanceof RezoHeaders ? config.originalRequest.headers.toObject() : config.originalRequest.headers;
+        console.log(`[Rezo Debug] Request Headers:`, JSON.stringify(headers, null, 2));
+      }
+      if (config.proxy && typeof config.proxy === "object") {
+        console.log(`[Rezo Debug] Proxy: ${config.proxy.protocol}://${config.proxy.host}:${config.proxy.port}`);
+      } else if (config.proxy && typeof config.proxy === "string") {
+        console.log(`[Rezo Debug] Proxy: ${config.proxy}`);
+      }
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] → ${method} ${url}`);
+    }
+  },
+  redirect: (config, fromUrl, toUrl, statusCode, method) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Redirect ${statusCode}: ${fromUrl}`);
+      console.log(`[Rezo Debug]        → ${toUrl} (${method})`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ↳ ${statusCode} → ${toUrl}`);
+    }
+  },
+  retry: (config, attempt, maxRetries, statusCode, delay) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Retry ${attempt}/${maxRetries} after status ${statusCode}${delay > 0 ? ` (waiting ${delay}ms)` : ""}`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ⟳ Retry ${attempt}/${maxRetries} (status ${statusCode})`);
+    }
+  },
+  maxRetries: (config, maxRetries) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Max retries (${maxRetries}) reached, throwing error`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track]   ✗ Max retries reached`);
+    }
+  },
+  response: (config, status, statusText, duration) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response: ${status} ${statusText} (${duration.toFixed(2)}ms)`);
+    }
+    if (config.trackUrl) {
+      console.log(`[Rezo Track] ✓ ${status} ${statusText}`);
+    }
+  },
+  responseHeaders: (config, headers) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Response Headers:`, JSON.stringify(headers, null, 2));
+    }
+  },
+  cookies: (config, cookieCount) => {
+    if (config.debug && cookieCount > 0) {
+      console.log(`[Rezo Debug] Cookies received: ${cookieCount}`);
+    }
+  },
+  timing: (config, timing) => {
+    if (config.debug) {
+      const parts = [];
+      if (timing.dns)
+        parts.push(`DNS: ${timing.dns.toFixed(2)}ms`);
+      if (timing.connect)
+        parts.push(`Connect: ${timing.connect.toFixed(2)}ms`);
+      if (timing.tls)
+        parts.push(`TLS: ${timing.tls.toFixed(2)}ms`);
+      if (timing.ttfb)
+        parts.push(`TTFB: ${timing.ttfb.toFixed(2)}ms`);
+      if (timing.total)
+        parts.push(`Total: ${timing.total.toFixed(2)}ms`);
+      if (parts.length > 0) {
+        console.log(`[Rezo Debug] Timing: ${parts.join(" | ")}`);
+      }
+    }
+  },
+  complete: (config, finalUrl, redirectCount, duration) => {
+    if (config.debug) {
+      console.log(`[Rezo Debug] Complete: ${finalUrl}`);
+      if (redirectCount > 0) {
+        console.log(`[Rezo Debug] Redirects: ${redirectCount}`);
+      }
+      console.log(`[Rezo Debug] Total Duration: ${duration.toFixed(2)}ms`);
+      console.log(`[Rezo Debug] ─────────────────────────────────────
+`);
+    }
+  }
+};
 async function decompressBuffer(buffer, contentEncoding) {
   const encoding = contentEncoding.toLowerCase();
   switch (encoding) {
@@ -100,40 +197,67 @@ class Http2SessionPool {
       this.cleanupInterval.unref();
     }
   }
-  getSessionKey(url, options) {
-    return `${url.protocol}//${url.host}`;
+  getSessionKey(url, options, proxy) {
+    const proxyKey = proxy ? typeof proxy === "string" ? proxy : `${proxy.protocol}://${proxy.host}:${proxy.port}` : "";
+    return `${url.protocol}//${url.host}${proxyKey ? `@${proxyKey}` : ""}`;
   }
-  async getSession(url, options, timeout) {
-    const key = this.getSessionKey(url, options);
+  isSessionHealthy(session, entry) {
+    if (session.closed || session.destroyed)
+      return false;
+    if (entry.goawayReceived)
+      return false;
+    const socket = session.socket;
+    if (socket && (socket.destroyed || socket.closed || !socket.writable))
+      return false;
+    return true;
+  }
+  async getSession(url, options, timeout, forceNew = false, proxy) {
+    const key = this.getSessionKey(url, options, proxy);
     const existing = this.sessions.get(key);
-    if (existing && !existing.session.closed && !existing.session.destroyed) {
+    if (!forceNew && existing && this.isSessionHealthy(existing.session, existing)) {
       existing.lastUsed = Date.now();
       existing.refCount++;
       return existing.session;
     }
-    const session = await this.createSession(url, options, timeout);
-    this.sessions.set(key, {
+    if (existing && !this.isSessionHealthy(existing.session, existing)) {
+      try {
+        existing.session.close();
+      } catch {}
+      this.sessions.delete(key);
+    }
+    const session = await this.createSession(url, options, timeout, proxy);
+    const entry = {
       session,
       lastUsed: Date.now(),
-      refCount: 1
-    });
+      refCount: 1,
+      goawayReceived: false,
+      proxy
+    };
+    this.sessions.set(key, entry);
     session.on("close", () => {
       this.sessions.delete(key);
     });
     session.on("error", () => {
       this.sessions.delete(key);
     });
+    session.on("goaway", () => {
+      entry.goawayReceived = true;
+    });
     return session;
   }
-  createSession(url, options, timeout) {
+  async createSession(url, options, timeout, proxy) {
+    const authority = `${url.protocol}//${url.host}`;
+    const sessionOptions = {
+      ...options,
+      rejectUnauthorized: options?.rejectUnauthorized !== false,
+      ALPNProtocols: ["h2", "http/1.1"],
+      timeout
+    };
+    if (proxy) {
+      const tunnelSocket = await this.createProxyTunnel(url, proxy, timeout, options?.rejectUnauthorized);
+      sessionOptions.createConnection = () => tunnelSocket;
+    }
     return new Promise((resolve, reject) => {
-      const authority = `${url.protocol}//${url.host}`;
-      const sessionOptions = {
-        ...options,
-        rejectUnauthorized: options?.rejectUnauthorized !== false,
-        ALPNProtocols: ["h2", "http/1.1"],
-        timeout
-      };
       const session = http2.connect(authority, sessionOptions);
       let settled = false;
       const timeoutId = timeout ? setTimeout(() => {
@@ -164,8 +288,186 @@ class Http2SessionPool {
       });
     });
   }
-  releaseSession(url) {
-    const key = this.getSessionKey(url);
+  async createProxyTunnel(url, proxy, timeout, rejectUnauthorized) {
+    return new Promise((resolve, reject) => {
+      let proxyUrl;
+      let proxyAuth;
+      if (typeof proxy === "string") {
+        proxyUrl = new URL(proxy);
+        if (proxyUrl.username || proxyUrl.password) {
+          proxyAuth = Buffer.from(`${decodeURIComponent(proxyUrl.username)}:${decodeURIComponent(proxyUrl.password)}`).toString("base64");
+        }
+      } else {
+        const protocol = proxy.protocol || "http";
+        let proxyUrlStr = `${protocol}://${proxy.host}:${proxy.port}`;
+        if (proxy.auth) {
+          const encodedUser = encodeURIComponent(proxy.auth.username);
+          const encodedPass = encodeURIComponent(proxy.auth.password);
+          proxyUrlStr = `${protocol}://${encodedUser}:${encodedPass}@${proxy.host}:${proxy.port}`;
+          proxyAuth = Buffer.from(`${proxy.auth.username}:${proxy.auth.password}`).toString("base64");
+        }
+        proxyUrl = new URL(proxyUrlStr);
+      }
+      const targetHost = url.hostname;
+      const targetPort = url.port || (url.protocol === "https:" ? "443" : "80");
+      if (proxyUrl.protocol.startsWith("socks")) {
+        const socksType = proxyUrl.protocol === "socks5:" || proxyUrl.protocol === "socks5h:" ? 5 : 4;
+        const socksOpts = {
+          proxy: {
+            host: proxyUrl.hostname,
+            port: parseInt(proxyUrl.port || "1080", 10),
+            type: socksType,
+            userId: proxyUrl.username ? decodeURIComponent(proxyUrl.username) : undefined,
+            password: proxyUrl.password ? decodeURIComponent(proxyUrl.password) : undefined
+          },
+          destination: {
+            host: targetHost,
+            port: parseInt(targetPort, 10)
+          },
+          command: "connect",
+          timeout
+        };
+        SocksClient.createConnection(socksOpts).then(({ socket }) => {
+          if (url.protocol === "https:") {
+            const tlsSocket = tls.connect({
+              socket,
+              host: targetHost,
+              servername: targetHost,
+              rejectUnauthorized: rejectUnauthorized !== false,
+              ALPNProtocols: ["h2", "http/1.1"]
+            });
+            const tlsTimeoutId = timeout ? setTimeout(() => {
+              tlsSocket.destroy();
+              reject(new Error(`TLS handshake timeout after ${timeout}ms`));
+            }, timeout) : null;
+            tlsSocket.on("secureConnect", () => {
+              if (tlsTimeoutId)
+                clearTimeout(tlsTimeoutId);
+              const alpn = tlsSocket.alpnProtocol;
+              if (alpn && alpn !== "h2") {
+                tlsSocket.destroy();
+                reject(new Error(`Server does not support HTTP/2 (negotiated: ${alpn})`));
+                return;
+              }
+              resolve(tlsSocket);
+            });
+            tlsSocket.on("error", (err) => {
+              if (tlsTimeoutId)
+                clearTimeout(tlsTimeoutId);
+              reject(new Error(`TLS handshake failed: ${err.message}`));
+            });
+          } else {
+            resolve(socket);
+          }
+        }).catch((err) => {
+          reject(new Error(`SOCKS proxy connection failed: ${err.message}`));
+        });
+        return;
+      }
+      const proxyHost = proxyUrl.hostname;
+      const proxyPort = parseInt(proxyUrl.port || (proxyUrl.protocol === "https:" ? "443" : "80"), 10);
+      let proxySocket;
+      const connectToProxy = () => {
+        if (proxyUrl.protocol === "https:") {
+          proxySocket = tls.connect({
+            host: proxyHost,
+            port: proxyPort,
+            rejectUnauthorized: rejectUnauthorized !== false
+          });
+        } else {
+          proxySocket = net.connect({
+            host: proxyHost,
+            port: proxyPort
+          });
+        }
+        let settled = false;
+        const timeoutId = timeout ? setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            proxySocket.destroy();
+            reject(new Error(`Proxy connection timeout after ${timeout}ms`));
+          }
+        }, timeout) : null;
+        proxySocket.on("error", (err) => {
+          if (!settled) {
+            settled = true;
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            reject(new Error(`Proxy connection error: ${err.message}`));
+          }
+        });
+        proxySocket.on("connect", () => {
+          const connectRequest = [
+            `CONNECT ${targetHost}:${targetPort} HTTP/1.1`,
+            `Host: ${targetHost}:${targetPort}`,
+            proxyAuth ? `Proxy-Authorization: Basic ${proxyAuth}` : "",
+            "",
+            ""
+          ].filter(Boolean).join(`\r
+`);
+          proxySocket.write(connectRequest);
+        });
+        let responseBuffer = "";
+        proxySocket.on("data", function onData(data) {
+          if (settled)
+            return;
+          responseBuffer += data.toString();
+          const headerEnd = responseBuffer.indexOf(`\r
+\r
+`);
+          if (headerEnd !== -1) {
+            settled = true;
+            if (timeoutId)
+              clearTimeout(timeoutId);
+            proxySocket.removeListener("data", onData);
+            const statusLine = responseBuffer.split(`\r
+`)[0];
+            const statusMatch = statusLine.match(/HTTP\/\d\.\d (\d{3})/);
+            const statusCode = statusMatch ? parseInt(statusMatch[1], 10) : 0;
+            if (statusCode === 200) {
+              if (url.protocol === "https:") {
+                const tlsSocket = tls.connect({
+                  socket: proxySocket,
+                  host: targetHost,
+                  servername: targetHost,
+                  rejectUnauthorized: rejectUnauthorized !== false,
+                  ALPNProtocols: ["h2", "http/1.1"]
+                });
+                const tlsTimeoutId = timeout ? setTimeout(() => {
+                  tlsSocket.destroy();
+                  reject(new Error(`TLS handshake timeout after ${timeout}ms`));
+                }, timeout) : null;
+                tlsSocket.on("secureConnect", () => {
+                  if (tlsTimeoutId)
+                    clearTimeout(tlsTimeoutId);
+                  const alpn = tlsSocket.alpnProtocol;
+                  if (alpn && alpn !== "h2") {
+                    tlsSocket.destroy();
+                    reject(new Error(`Server does not support HTTP/2 (negotiated: ${alpn})`));
+                    return;
+                  }
+                  resolve(tlsSocket);
+                });
+                tlsSocket.on("error", (err) => {
+                  if (tlsTimeoutId)
+                    clearTimeout(tlsTimeoutId);
+                  reject(new Error(`TLS handshake failed: ${err.message}`));
+                });
+              } else {
+                resolve(proxySocket);
+              }
+            } else {
+              proxySocket.destroy();
+              reject(new Error(`Proxy CONNECT failed with status ${statusCode}: ${statusLine}`));
+            }
+          }
+        });
+      };
+      connectToProxy();
+    });
+  }
+  releaseSession(url, proxy) {
+    const key = this.getSessionKey(url, undefined, proxy);
     const entry = this.sessions.get(key);
     if (entry) {
       entry.refCount = Math.max(0, entry.refCount - 1);
@@ -178,8 +480,8 @@ class Http2SessionPool {
       }
     }
   }
-  closeSession(url) {
-    const key = this.getSessionKey(url);
+  closeSession(url, proxy) {
+    const key = this.getSessionKey(url, undefined, proxy);
     const entry = this.sessions.get(key);
     if (entry) {
       entry.session.close();
@@ -308,7 +610,7 @@ function sanitizeConfig(config) {
   const { data: _data, ...sanitized } = config;
   return sanitized;
 }
-async function updateCookies(config, headers, url) {
+async function updateCookies(config, headers, url, rootJar) {
   const setCookieHeaders = headers["set-cookie"];
   if (!setCookieHeaders)
     return;
@@ -352,8 +654,9 @@ async function updateCookies(config, headers, url) {
   const acceptedCookieStrings = acceptedCookies.map((c) => c.toSetCookieString());
   const jar = new RezoCookieJar;
   jar.setCookiesSync(acceptedCookieStrings, url);
-  if (!config.disableCookieJar && config.cookieJar) {
-    config.cookieJar.setCookiesSync(acceptedCookieStrings, url);
+  const jarToSync = rootJar || config.cookieJar;
+  if (!config.disableCookieJar && jarToSync) {
+    jarToSync.setCookiesSync(acceptedCookieStrings, url);
   }
   const cookies = jar.cookies();
   cookies.setCookiesString = cookieHeaderArray;
@@ -525,7 +828,7 @@ export async function executeRequest(options, defaultOptions, jar) {
     }
   }
   try {
-    const res = executeHttp2Request(fetchOptions, mainConfig, options, perform, fs, streamResponse, downloadResponse, uploadResponse);
+    const res = executeHttp2Request(fetchOptions, mainConfig, options, perform, fs, streamResponse, downloadResponse, uploadResponse, jar);
     if (streamResponse) {
       return streamResponse;
     } else if (downloadResponse) {
@@ -558,7 +861,7 @@ export async function executeRequest(options, defaultOptions, jar) {
     throw error;
   }
 }
-async function executeHttp2Request(fetchOptions, config, options, perform, fs, streamResult, downloadResult, uploadResult) {
+async function executeHttp2Request(fetchOptions, config, options, perform, fs, streamResult, downloadResult, uploadResult, rootJar) {
   let requestCount = 0;
   const _stats = { statusOnNext: "abort" };
   let responseStatusCode;
@@ -578,6 +881,11 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
   config.setSignal();
   const timeoutClearInstance = config.timeoutClearInstanse;
   delete config.timeoutClearInstanse;
+  if (!config.requestId) {
+    config.requestId = `req_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+  }
+  const requestUrl = fetchOptions.fullUrl ? String(fetchOptions.fullUrl) : "";
+  debugLog.requestStart(config, requestUrl, fetchOptions.method || "GET");
   const eventEmitter = streamResult || downloadResult || uploadResult;
   if (eventEmitter) {
     eventEmitter.emit("initiated");
@@ -590,7 +898,7 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
       throw error;
     }
     try {
-      const response = await executeHttp2Stream(config, fetchOptions, requestCount, timing, _stats, responseStatusCode, fs, streamResult, downloadResult, uploadResult, sessionPool);
+      const response = await executeHttp2Stream(config, fetchOptions, requestCount, timing, _stats, responseStatusCode, fs, streamResult, downloadResult, uploadResult, sessionPool, rootJar);
       const statusOnNext = _stats.statusOnNext;
       if (response instanceof RezoError) {
         const fileName = config.fileName;
@@ -619,16 +927,12 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
               throw response;
             }
             if (maxRetries <= retries) {
-              if (config.debug) {
-                console.log(`Max retries (${maxRetries}) reached`);
-              }
+              debugLog.maxRetries(config, maxRetries);
               throw response;
             }
             retries++;
             const currentDelay = incrementDelay ? retryDelay * retries : retryDelay;
-            if (config.debug) {
-              console.log(`Retrying... ${retryDelay > 0 ? "in " + currentDelay + "ms" : ""}`);
-            }
+            debugLog.retry(config, retries, maxRetries, responseStatusCode || 0, currentDelay);
             if (config.hooks?.beforeRetry && config.hooks.beforeRetry.length > 0) {
               for (const hook of config.hooks.beforeRetry) {
                 await hook(config, response, retries);
@@ -643,6 +947,16 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
         continue;
       }
       if (statusOnNext === "success") {
+        const totalDuration = performance.now() - timing.startTime;
+        debugLog.response(config, response.status, response.statusText, totalDuration);
+        if (response.headers) {
+          const headersObj = response.headers instanceof RezoHeaders ? response.headers.toObject() : response.headers;
+          debugLog.responseHeaders(config, headersObj);
+        }
+        if (response.cookies?.array) {
+          debugLog.cookies(config, response.cookies.array.length);
+        }
+        debugLog.complete(config, response.finalUrl || requestUrl, config.redirectCount, totalDuration);
         return response;
       }
       if (statusOnNext === "error") {
@@ -686,18 +1000,20 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
           visitedUrls.add(normalizedRedirectUrl);
         }
         const redirectCode = response.status;
+        const fromUrl = fetchOptions.fullUrl;
         const redirectCallback = config.beforeRedirect || config.onRedirect;
         const onRedirect = redirectCallback ? redirectCallback({
           url: new URL(location),
           status: response.status,
           headers: response.headers,
           sameDomain: isSameDomain(fetchOptions.fullUrl, location),
-          method: fetchOptions.method.toUpperCase()
+          method: fetchOptions.method.toUpperCase(),
+          body: config.originalBody
         }) : undefined;
         if (typeof onRedirect !== "undefined") {
           if (typeof onRedirect === "boolean" && !onRedirect) {
             throw builErrorFromResponse("Redirect denied by user", response, config, fetchOptions);
-          } else if (typeof onRedirect === "object" && !onRedirect.redirect) {
+          } else if (typeof onRedirect === "object" && !onRedirect.redirect && !onRedirect.withoutBody && !("body" in onRedirect)) {
             throw builErrorFromResponse("Redirect denied by user", response, config, fetchOptions);
           }
         }
@@ -717,14 +1033,88 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
         });
         perform.reset();
         config.redirectCount++;
-        if (response.status === 301 || response.status === 302 || response.status === 303) {
-          if (config.treat302As303 !== false || response.status === 303) {
-            options.method = "GET";
+        fetchOptions.fullUrl = location;
+        delete options.params;
+        const normalizedRedirect = typeof onRedirect === "object" ? onRedirect.redirect || onRedirect.withoutBody || "body" in onRedirect : undefined;
+        if (typeof onRedirect === "object" && normalizedRedirect) {
+          let method;
+          const userMethod = onRedirect.method;
+          if (redirectCode === 301 || redirectCode === 302 || redirectCode === 303) {
+            method = userMethod || "GET";
+          } else {
+            method = userMethod || fetchOptions.method;
+          }
+          config.method = method;
+          options.method = method;
+          fetchOptions.method = method;
+          if (onRedirect.redirect && onRedirect.url) {
+            options.fullUrl = onRedirect.url;
+            fetchOptions.fullUrl = onRedirect.url;
+          }
+          if (onRedirect.withoutBody) {
+            delete options.body;
+            delete fetchOptions.body;
+            config.originalBody = undefined;
+            if (fetchOptions.headers instanceof RezoHeaders) {
+              fetchOptions.headers.delete("Content-Type");
+              fetchOptions.headers.delete("Content-Length");
+            }
+          } else if ("body" in onRedirect) {
+            options.body = onRedirect.body;
+            fetchOptions.body = onRedirect.body;
+            config.originalBody = onRedirect.body;
+          } else if (redirectCode === 307 || redirectCode === 308) {
+            const methodUpper = method.toUpperCase();
+            if ((methodUpper === "POST" || methodUpper === "PUT" || methodUpper === "PATCH") && config.originalBody !== undefined) {
+              options.body = config.originalBody;
+              fetchOptions.body = config.originalBody;
+            }
+          } else {
             delete options.body;
+            delete fetchOptions.body;
+            if (fetchOptions.headers instanceof RezoHeaders) {
+              fetchOptions.headers.delete("Content-Type");
+              fetchOptions.headers.delete("Content-Length");
+            }
           }
+          debugLog.redirect(config, fromUrl, fetchOptions.fullUrl, redirectCode, method);
+        } else if (response.status === 301 || response.status === 302 || response.status === 303) {
+          debugLog.redirect(config, fromUrl, fetchOptions.fullUrl, redirectCode, "GET");
+          options.method = "GET";
+          fetchOptions.method = "GET";
+          config.method = "GET";
+          delete options.body;
+          delete fetchOptions.body;
+          if (fetchOptions.headers instanceof RezoHeaders) {
+            fetchOptions.headers.delete("Content-Type");
+            fetchOptions.headers.delete("Content-Length");
+          }
+        } else {
+          debugLog.redirect(config, fromUrl, fetchOptions.fullUrl, redirectCode, fetchOptions.method);
+        }
+        const jarToSync = rootJar || config.cookieJar;
+        if (response.cookies?.setCookiesString?.length > 0 && jarToSync) {
+          try {
+            jarToSync.setCookiesSync(response.cookies.setCookiesString, fromUrl);
+          } catch (e) {}
+        }
+        if (jarToSync && !config.disableCookieJar) {
+          try {
+            const cookieString = jarToSync.getCookieStringSync(fetchOptions.fullUrl);
+            if (cookieString) {
+              if (fetchOptions.headers instanceof RezoHeaders) {
+                fetchOptions.headers.set("cookie", cookieString);
+              } else if (fetchOptions.headers) {
+                fetchOptions.headers["cookie"] = cookieString;
+              } else {
+                fetchOptions.headers = new RezoHeaders({ cookie: cookieString });
+              }
+              if (config.debug) {
+                console.log(`[Rezo Debug] HTTP/2: Updated Cookie header for redirect: ${cookieString.substring(0, 100)}...`);
+              }
+            }
+          } catch (e) {}
         }
-        fetchOptions.fullUrl = location;
-        delete options.params;
         requestCount++;
         continue;
       }
@@ -737,7 +1127,7 @@ async function executeHttp2Request(fetchOptions, config, options, perform, fs, s
     }
   }
 }
-async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _stats, responseStatusCode, fs, streamResult, downloadResult, uploadResult, sessionPool) {
+async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _stats, responseStatusCode, fs, streamResult, downloadResult, uploadResult, sessionPool, rootJar) {
   return new Promise(async (resolve) => {
     try {
       const { fullUrl, body } = fetchOptions;
@@ -764,6 +1154,11 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
       if (!headers["accept-encoding"]) {
         headers["accept-encoding"] = "gzip, deflate, br";
       }
+      if (config.debug && headers["cookie"]) {
+        console.log(`[Rezo Debug] HTTP/2: Sending Cookie header: ${String(headers["cookie"]).substring(0, 100)}...`);
+      } else if (config.debug) {
+        console.log(`[Rezo Debug] HTTP/2: No Cookie header in request`);
+      }
       if (body instanceof RezoFormData) {
         headers["content-type"] = `multipart/form-data; boundary=${body.getBoundary()}`;
       } else if (body instanceof FormData) {
@@ -797,30 +1192,136 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         sessionOptions.pfx = securityContext.pfx;
       if (securityContext?.passphrase)
         sessionOptions.passphrase = securityContext.passphrase;
+      const forceNewSession = requestCount > 0;
       let session;
+      if (config.debug) {
+        console.log(`[Rezo Debug] HTTP/2: Acquiring session for ${url.host}${forceNewSession ? " (forcing new for redirect)" : ""}${fetchOptions.proxy ? " (via proxy)" : ""}...`);
+      }
       try {
-        session = await (sessionPool || Http2SessionPool.getInstance()).getSession(url, sessionOptions, config.timeout !== null ? config.timeout : undefined);
+        session = await (sessionPool || Http2SessionPool.getInstance()).getSession(url, sessionOptions, config.timeout !== null ? config.timeout : undefined, forceNewSession, fetchOptions.proxy);
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Session acquired successfully`);
+        }
       } catch (err) {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Session failed:`, err.message);
+        }
         const error = buildSmartError(config, fetchOptions, err);
         _stats.statusOnNext = "error";
         resolve(error);
         return;
       }
-      const req = session.request(headers);
-      if (config.timeout) {
-        req.setTimeout(config.timeout, () => {
-          req.close(http2.constants.NGHTTP2_CANCEL);
-          const error = buildSmartError(config, fetchOptions, new Error(`Request timeout after ${config.timeout}ms`));
-          _stats.statusOnNext = "error";
-          resolve(error);
-        });
-      }
       let chunks = [];
       let contentLengthCounter = 0;
       let responseHeaders = {};
       let status = 0;
       let statusText = "";
+      let resolved = false;
+      let isRedirect = false;
+      let timeoutId = null;
+      const sessionErrorHandler = (err) => {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Session error:`, err.message);
+        }
+        if (!resolved) {
+          resolved = true;
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          const error = buildSmartError(config, fetchOptions, err);
+          _stats.statusOnNext = "error";
+          resolve(error);
+        }
+      };
+      session.on("error", sessionErrorHandler);
+      session.on("goaway", (errorCode, lastStreamID) => {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Session GOAWAY received (errorCode: ${errorCode}, lastStreamID: ${lastStreamID})`);
+        }
+      });
+      if (config.debug) {
+        console.log(`[Rezo Debug] HTTP/2: Creating request stream...`);
+      }
+      let req;
+      try {
+        req = session.request(headers);
+      } catch (err) {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Failed to create request stream:`, err.message);
+        }
+        session.removeListener("error", sessionErrorHandler);
+        const error = buildSmartError(config, fetchOptions, err);
+        _stats.statusOnNext = "error";
+        resolve(error);
+        return;
+      }
+      if (config.debug) {
+        console.log(`[Rezo Debug] HTTP/2: Request stream created`);
+      }
+      const requestTimeout = config.timeout || 30000;
+      timeoutId = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          if (config.debug) {
+            console.log(`[Rezo Debug] HTTP/2: Request timeout after ${requestTimeout}ms (no response received)`);
+          }
+          req.close(http2.constants.NGHTTP2_CANCEL);
+          const error = buildSmartError(config, fetchOptions, new Error(`Request timeout after ${requestTimeout}ms`));
+          _stats.statusOnNext = "error";
+          resolve(error);
+        }
+      }, requestTimeout);
+      const sessionSocket = session.socket;
+      if (sessionSocket && typeof sessionSocket.ref === "function") {
+        sessionSocket.ref();
+      }
+      req.on("close", () => {
+        if (config.debug && !resolved) {
+          console.log(`[Rezo Debug] HTTP/2: Stream closed (status: ${status}, resolved: ${resolved})`);
+        }
+        if (!resolved && status === 0) {
+          resolved = true;
+          clearTimeout(timeoutId);
+          if (config.debug) {
+            console.log(`[Rezo Debug] HTTP/2: Stream closed without response - retrying with new session`);
+          }
+          const error = buildSmartError(config, fetchOptions, new Error("HTTP/2 stream closed without response"));
+          _stats.statusOnNext = "error";
+          resolve(error);
+        }
+      });
+      req.on("aborted", () => {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Stream aborted`);
+        }
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeoutId);
+          const error = buildSmartError(config, fetchOptions, new Error("HTTP/2 stream aborted"));
+          _stats.statusOnNext = "error";
+          resolve(error);
+        }
+      });
+      req.on("error", (err) => {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Stream error:`, err.message);
+        }
+        if (!resolved) {
+          resolved = true;
+          clearTimeout(timeoutId);
+          const error = buildSmartError(config, fetchOptions, err);
+          _stats.statusOnNext = "error";
+          resolve(error);
+        }
+      });
+      req.on("frameError", (type, code, id) => {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Frame error - type: ${type}, code: ${code}, id: ${id}`);
+        }
+      });
       req.on("response", (headers) => {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Response received, status: ${headers[":status"]}`);
+        }
         responseHeaders = headers;
         status = Number(headers[http2.constants.HTTP2_HEADER_STATUS]) || 200;
         statusText = getStatusText(status);
@@ -829,7 +1330,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
           config.timing.responseStart = timing.firstByteTime;
         }
         const location = headers["location"];
-        const isRedirect = status >= 300 && status < 400 && location;
+        isRedirect = status >= 300 && status < 400 && !!location;
         if (isRedirect) {
           _stats.statusOnNext = "redirect";
           const redirectUrlObj = new URL(location, url);
@@ -841,7 +1342,7 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         config.network.httpVersion = "h2";
         (async () => {
           try {
-            await updateCookies(config, headers, url.href);
+            await updateCookies(config, headers, url.href, rootJar);
           } catch (err) {
             if (config.debug) {
               console.log("[Rezo Debug] Cookie hook error:", err);
@@ -874,6 +1375,9 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         }
       });
       req.on("data", (chunk) => {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Received data chunk: ${chunk.length} bytes (total: ${contentLengthCounter + chunk.length})`);
+        }
         chunks.push(chunk);
         contentLengthCounter += chunk.length;
         if (streamResult) {
@@ -895,209 +1399,221 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         }
       });
       req.on("end", async () => {
-        updateTiming(config, timing, contentLengthCounter);
-        if (!config.transfer) {
-          config.transfer = { requestSize: 0, responseSize: 0, headerSize: 0, bodySize: 0 };
-        }
-        if (config.transfer.requestSize === undefined) {
-          config.transfer.requestSize = 0;
-        }
-        if (config.transfer.requestSize === 0 && body) {
-          if (typeof body === "string") {
-            config.transfer.requestSize = Buffer.byteLength(body, "utf8");
-          } else if (Buffer.isBuffer(body) || body instanceof Uint8Array) {
-            config.transfer.requestSize = body.length;
-          } else if (body instanceof URLSearchParams || body instanceof RezoURLSearchParams) {
-            config.transfer.requestSize = Buffer.byteLength(body.toString(), "utf8");
-          } else if (body instanceof RezoFormData) {
-            config.transfer.requestSize = await body.getLength() || 0;
-          } else if (typeof body === "object") {
-            config.transfer.requestSize = Buffer.byteLength(JSON.stringify(body), "utf8");
-          }
-        }
-        (sessionPool || Http2SessionPool.getInstance()).releaseSession(url);
-        if (_stats.statusOnNext === "redirect") {
-          const partialResponse = {
-            data: "",
-            status,
-            statusText,
-            headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
-            cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
-            config,
-            contentType: responseHeaders["content-type"],
-            contentLength: contentLengthCounter,
-            finalUrl: url.href,
-            urls: buildUrlTree(config, url.href)
-          };
-          resolve(partialResponse);
+        if (resolved)
           return;
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Stream 'end' event fired (status: ${status}, chunks: ${chunks.length}, bytes: ${contentLengthCounter})`);
         }
-        let responseBody = Buffer.concat(chunks);
-        const contentEncoding = responseHeaders["content-encoding"];
-        if (contentEncoding && contentLengthCounter > 0 && CompressionUtil.shouldDecompress(contentEncoding, config)) {
-          try {
-            const decompressed = await decompressBuffer(responseBody, contentEncoding);
-            responseBody = decompressed;
-          } catch (err) {
-            const error = buildDecompressionError({
-              statusCode: status,
-              headers: sanitizeHttp2Headers(responseHeaders),
+        resolved = true;
+        clearTimeout(timeoutId);
+        try {
+          updateTiming(config, timing, contentLengthCounter);
+          if (!config.transfer) {
+            config.transfer = { requestSize: 0, responseSize: 0, headerSize: 0, bodySize: 0 };
+          }
+          if (config.transfer.requestSize === undefined) {
+            config.transfer.requestSize = 0;
+          }
+          if (config.transfer.requestSize === 0 && body) {
+            if (typeof body === "string") {
+              config.transfer.requestSize = Buffer.byteLength(body, "utf8");
+            } else if (Buffer.isBuffer(body) || body instanceof Uint8Array) {
+              config.transfer.requestSize = body.length;
+            } else if (body instanceof URLSearchParams || body instanceof RezoURLSearchParams) {
+              config.transfer.requestSize = Buffer.byteLength(body.toString(), "utf8");
+            } else if (body instanceof RezoFormData) {
+              config.transfer.requestSize = await body.getLength() || 0;
+            } else if (typeof body === "object") {
+              config.transfer.requestSize = Buffer.byteLength(JSON.stringify(body), "utf8");
+            }
+          }
+          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url, fetchOptions.proxy);
+          if (isRedirect) {
+            _stats.statusOnNext = "redirect";
+            const partialResponse = {
+              data: "",
+              status,
+              statusText,
+              headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
+              cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
+              config,
               contentType: responseHeaders["content-type"],
-              contentLength: String(contentLengthCounter),
-              cookies: config.responseCookies?.setCookiesString || [],
-              statusText: err.message,
-              url: url.href,
-              body: responseBody,
+              contentLength: contentLengthCounter,
               finalUrl: url.href,
-              config,
-              request: fetchOptions
-            });
-            _stats.statusOnNext = "error";
-            resolve(error);
+              urls: buildUrlTree(config, url.href)
+            };
+            resolve(partialResponse);
             return;
           }
-        }
-        let data;
-        const contentType = responseHeaders["content-type"] || "";
-        const responseType = config.responseType || fetchOptions.responseType || "auto";
-        if (responseType === "buffer" || responseType === "arrayBuffer") {
-          data = responseBody;
-        } else if (responseType === "text") {
-          data = responseBody.toString("utf-8");
-        } else if (responseType === "json" || responseType === "auto" && contentType.includes("application/json")) {
-          try {
-            data = JSON.parse(responseBody.toString("utf-8"));
-          } catch {
-            data = responseBody.toString("utf-8");
+          let responseBody = Buffer.concat(chunks);
+          const contentEncoding = responseHeaders["content-encoding"];
+          if (contentEncoding && contentLengthCounter > 0 && CompressionUtil.shouldDecompress(contentEncoding, config)) {
+            try {
+              const decompressed = await decompressBuffer(responseBody, contentEncoding);
+              responseBody = decompressed;
+            } catch (err) {
+              const error = buildDecompressionError({
+                statusCode: status,
+                headers: sanitizeHttp2Headers(responseHeaders),
+                contentType: responseHeaders["content-type"],
+                contentLength: String(contentLengthCounter),
+                cookies: config.responseCookies?.setCookiesString || [],
+                statusText: err.message,
+                url: url.href,
+                body: responseBody,
+                finalUrl: url.href,
+                config,
+                request: fetchOptions
+              });
+              _stats.statusOnNext = "error";
+              resolve(error);
+              return;
+            }
           }
-        } else {
-          if (contentType.includes("application/json")) {
+          let data;
+          const contentType = responseHeaders["content-type"] || "";
+          const responseType = config.responseType || fetchOptions.responseType || "auto";
+          if (responseType === "buffer" || responseType === "arrayBuffer") {
+            data = responseBody;
+          } else if (responseType === "text") {
+            data = responseBody.toString("utf-8");
+          } else if (responseType === "json" || responseType === "auto" && contentType.includes("application/json")) {
             try {
               data = JSON.parse(responseBody.toString("utf-8"));
             } catch {
               data = responseBody.toString("utf-8");
             }
           } else {
-            data = responseBody.toString("utf-8");
+            if (contentType.includes("application/json")) {
+              try {
+                data = JSON.parse(responseBody.toString("utf-8"));
+              } catch {
+                data = responseBody.toString("utf-8");
+              }
+            } else {
+              data = responseBody.toString("utf-8");
+            }
           }
-        }
-        config.status = status;
-        config.statusText = statusText;
-        _stats.statusOnNext = status >= 400 ? "error" : "success";
-        const responseCookies = config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] };
-        const mergedCookies = mergeRequestAndResponseCookies(config, responseCookies, url.href);
-        const finalResponse = {
-          data,
-          status,
-          statusText,
-          headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
-          cookies: mergedCookies,
-          config,
-          contentType,
-          contentLength: contentLengthCounter,
-          finalUrl: url.href,
-          urls: buildUrlTree(config, url.href)
-        };
-        if (downloadResult && fs && config.fileName) {
-          try {
-            fs.writeFileSync(config.fileName, responseBody);
-            const downloadFinishEvent = {
+          config.status = status;
+          config.statusText = statusText;
+          _stats.statusOnNext = status >= 400 ? "error" : "success";
+          const responseCookies = config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] };
+          const mergedCookies = mergeRequestAndResponseCookies(config, responseCookies, url.href);
+          const finalResponse = {
+            data,
+            status,
+            statusText,
+            headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
+            cookies: mergedCookies,
+            config,
+            contentType,
+            contentLength: contentLengthCounter,
+            finalUrl: url.href,
+            urls: buildUrlTree(config, url.href)
+          };
+          if (downloadResult && fs && config.fileName) {
+            try {
+              fs.writeFileSync(config.fileName, responseBody);
+              const downloadFinishEvent = {
+                status,
+                statusText,
+                headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
+                contentType,
+                contentLength: responseBody.length,
+                finalUrl: url.href,
+                cookies: mergedCookies,
+                urls: buildUrlTree(config, url.href),
+                fileName: config.fileName,
+                fileSize: responseBody.length,
+                timing: {
+                  ...getTimingDurations(config),
+                  download: getTimingDurations(config).download || 0
+                },
+                averageSpeed: getTimingDurations(config).download ? responseBody.length / getTimingDurations(config).download * 1000 : 0,
+                config: sanitizeConfig(config)
+              };
+              downloadResult.emit("finish", downloadFinishEvent);
+              downloadResult.emit("done", downloadFinishEvent);
+              downloadResult._markFinished();
+            } catch (err) {
+              const error = buildDownloadError({
+                statusCode: status,
+                headers: sanitizeHttp2Headers(responseHeaders),
+                contentType,
+                contentLength: String(contentLengthCounter),
+                cookies: config.responseCookies?.setCookiesString || [],
+                statusText: err.message,
+                url: url.href,
+                body: responseBody,
+                finalUrl: url.href,
+                config,
+                request: fetchOptions
+              });
+              downloadResult.emit("error", error);
+              resolve(error);
+              return;
+            }
+          }
+          if (streamResult) {
+            const streamFinishEvent = {
               status,
               statusText,
               headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
               contentType,
-              contentLength: responseBody.length,
+              contentLength: contentLengthCounter,
+              finalUrl: url.href,
+              cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
+              urls: buildUrlTree(config, url.href),
+              timing: getTimingDurations(config),
+              config: sanitizeConfig(config)
+            };
+            streamResult.emit("finish", streamFinishEvent);
+            streamResult.emit("done", streamFinishEvent);
+            streamResult.emit("end");
+            streamResult._markFinished();
+          }
+          if (uploadResult) {
+            const uploadFinishEvent = {
+              response: {
+                status,
+                statusText,
+                headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
+                data,
+                contentType,
+                contentLength: contentLengthCounter
+              },
               finalUrl: url.href,
-              cookies: mergedCookies,
+              cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
               urls: buildUrlTree(config, url.href),
-              fileName: config.fileName,
-              fileSize: responseBody.length,
+              uploadSize: config.transfer.requestSize || 0,
               timing: {
                 ...getTimingDurations(config),
-                download: getTimingDurations(config).download || 0
+                upload: getTimingDurations(config).firstByte || 0,
+                waiting: getTimingDurations(config).download > 0 && getTimingDurations(config).firstByte > 0 ? getTimingDurations(config).download - getTimingDurations(config).firstByte : 0
               },
-              averageSpeed: getTimingDurations(config).download ? responseBody.length / getTimingDurations(config).download * 1000 : 0,
+              averageUploadSpeed: getTimingDurations(config).firstByte && config.transfer.requestSize ? config.transfer.requestSize / getTimingDurations(config).firstByte * 1000 : 0,
+              averageDownloadSpeed: getTimingDurations(config).download ? contentLengthCounter / getTimingDurations(config).download * 1000 : 0,
               config: sanitizeConfig(config)
             };
-            downloadResult.emit("finish", downloadFinishEvent);
-            downloadResult.emit("done", downloadFinishEvent);
-            downloadResult._markFinished();
-          } catch (err) {
-            const error = buildDownloadError({
-              statusCode: status,
-              headers: sanitizeHttp2Headers(responseHeaders),
-              contentType,
-              contentLength: String(contentLengthCounter),
-              cookies: config.responseCookies?.setCookiesString || [],
-              statusText: err.message,
-              url: url.href,
-              body: responseBody,
-              finalUrl: url.href,
-              config,
-              request: fetchOptions
-            });
-            downloadResult.emit("error", error);
-            resolve(error);
-            return;
+            uploadResult.emit("finish", uploadFinishEvent);
+            uploadResult.emit("done", uploadFinishEvent);
+            uploadResult._markFinished();
           }
+          resolve(finalResponse);
+        } catch (endError) {
+          if (config.debug) {
+            console.log(`[Rezo Debug] HTTP/2: Error in 'end' handler:`, endError.message);
+          }
+          (sessionPool || Http2SessionPool.getInstance()).releaseSession(url, fetchOptions.proxy);
+          const error = buildSmartError(config, fetchOptions, endError);
+          _stats.statusOnNext = "error";
+          resolve(error);
         }
-        if (streamResult) {
-          const streamFinishEvent = {
-            status,
-            statusText,
-            headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
-            contentType,
-            contentLength: contentLengthCounter,
-            finalUrl: url.href,
-            cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
-            urls: buildUrlTree(config, url.href),
-            timing: getTimingDurations(config),
-            config: sanitizeConfig(config)
-          };
-          streamResult.emit("finish", streamFinishEvent);
-          streamResult.emit("done", streamFinishEvent);
-          streamResult.emit("end");
-          streamResult._markFinished();
-        }
-        if (uploadResult) {
-          const uploadFinishEvent = {
-            response: {
-              status,
-              statusText,
-              headers: new RezoHeaders(sanitizeHttp2Headers(responseHeaders)),
-              data,
-              contentType,
-              contentLength: contentLengthCounter
-            },
-            finalUrl: url.href,
-            cookies: config.responseCookies || { array: [], serialized: [], netscape: "", string: "", setCookiesString: [] },
-            urls: buildUrlTree(config, url.href),
-            uploadSize: config.transfer.requestSize || 0,
-            timing: {
-              ...getTimingDurations(config),
-              upload: getTimingDurations(config).firstByte || 0,
-              waiting: getTimingDurations(config).download > 0 && getTimingDurations(config).firstByte > 0 ? getTimingDurations(config).download - getTimingDurations(config).firstByte : 0
-            },
-            averageUploadSpeed: getTimingDurations(config).firstByte && config.transfer.requestSize ? config.transfer.requestSize / getTimingDurations(config).firstByte * 1000 : 0,
-            averageDownloadSpeed: getTimingDurations(config).download ? contentLengthCounter / getTimingDurations(config).download * 1000 : 0,
-            config: sanitizeConfig(config)
-          };
-          uploadResult.emit("finish", uploadFinishEvent);
-          uploadResult.emit("done", uploadFinishEvent);
-          uploadResult._markFinished();
-        }
-        resolve(finalResponse);
-      });
-      req.on("error", (err) => {
-        _stats.statusOnNext = "error";
-        (sessionPool || Http2SessionPool.getInstance()).releaseSession(url);
-        const error = buildSmartError(config, fetchOptions, err);
-        if (eventEmitter) {
-          eventEmitter.emit("error", error);
-        }
-        resolve(error);
       });
       if (body) {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Writing request body (type: ${body?.constructor?.name || typeof body})...`);
+        }
         if (body instanceof URLSearchParams || body instanceof RezoURLSearchParams) {
           req.write(body.toString());
         } else if (body instanceof FormData || body instanceof RezoFormData) {
@@ -1107,13 +1623,26 @@ async function executeHttp2Stream(config, fetchOptions, requestCount, timing, _s
         } else if (typeof body === "object" && !Buffer.isBuffer(body) && !(body instanceof Uint8Array) && !(body instanceof Readable)) {
           req.write(JSON.stringify(body));
         } else if (body instanceof Readable) {
+          if (config.debug) {
+            console.log(`[Rezo Debug] HTTP/2: Piping stream body...`);
+          }
           body.pipe(req);
           return;
         } else {
           req.write(body);
         }
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: Body written, calling req.end()...`);
+        }
+      } else {
+        if (config.debug) {
+          console.log(`[Rezo Debug] HTTP/2: No body, calling req.end()...`);
+        }
       }
       req.end();
+      if (config.debug) {
+        console.log(`[Rezo Debug] HTTP/2: req.end() called, waiting for response...`);
+      }
     } catch (error) {
       _stats.statusOnNext = "error";
       const rezoError = buildSmartError(config, fetchOptions, error);