rezo 1.0.107 → 1.0.108

package/dist/adapters/curl.cjs

@@ -10,7 +10,8 @@ const { buildSmartError, builErrorFromResponse } = require('../responses/buildEr
 const { RezoCookieJar, Cookie } = require('../cookies/cookie-jar.cjs');
 const RezoFormData = require('../utils/form-data.cjs');
 const { existsSync } = require("node:fs");
-const { getDefaultConfig, prepareHTTPOptions, calculateRetryDelay } = require('../utils/http-config.cjs');
+const { getDefaultConfig, prepareHTTPOptions, calculateRetryDelay, shouldRetry } = require('../utils/http-config.cjs');
+const { handleRateLimitWait, shouldWaitOnStatus } = require('../utils/rate-limit-wait.cjs');
 const { RezoHeaders } = require('../utils/headers.cjs');
 const { StreamResponse } = require('../responses/stream.cjs');
 const { DownloadResponse } = require('../responses/download.cjs');
@@ -2288,9 +2289,20 @@ async function executeRequest(options, defaultOptions, jar) {
     }
   }
   const executor = new CurlExecutor;
-  try {
-    const result = await executor.execute(config, originalRequest, streamResponse, downloadResponse, uploadResponse);
-    if (!streamResponse && !downloadResponse && !uploadResponse) {
+  const retryConfig = config.retry;
+  let retryAttempt = 0;
+  const ABSOLUTE_MAX_ATTEMPTS = 50;
+  let totalAttempts = 0;
+  while (true) {
+    totalAttempts++;
+    if (totalAttempts > ABSOLUTE_MAX_ATTEMPTS) {
+      throw new RezoError(`Absolute maximum attempts (${ABSOLUTE_MAX_ATTEMPTS}) exceeded. This prevents infinite loops from retries and redirects.`, config, "ERR_MAX_ATTEMPTS", originalRequest);
+    }
+    try {
+      const result = await executor.execute(config, originalRequest, streamResponse, downloadResponse, uploadResponse);
+      if (streamResponse || downloadResponse || uploadResponse) {
+        return result;
+      }
       const response = result;
       if (proxyManager && selectedProxy) {
         proxyManager.reportSuccess(selectedProxy);
@@ -2317,67 +2329,140 @@ async function executeRequest(options, defaultOptions, jar) {
         }
       }
       debugLog.complete(config, response.finalUrl || requestUrl, config.redirectHistory?.length || 0, duration);
-      if (response.status >= 400) {
+      const _validateStatus = originalRequest.validateStatus ?? ((s) => s >= 200 && s < 300);
+      if (originalRequest.validateStatus !== null && !_validateStatus(response.status)) {
+        if (shouldWaitOnStatus(response.status, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+            url: requestUrl,
+            method,
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, originalRequest);
-        if (config.retry) {
-          const maxRetries = config.retry.maxRetries || 0;
-          const statusCodes = config.retry.statusCodes || [408, 429, 500, 502, 503, 504];
-          if (statusCodes.includes(response.status)) {
-            if (config.retryAttempts < maxRetries) {
-              config.retryAttempts++;
-              if (!config.errors)
-                config.errors = [];
-              config.errors.push({
-                attempt: config.retryAttempts,
-                error: httpError,
-                duration: perform.now()
-              });
-              perform.reset();
-              const delay = calculateRetryDelay(config.retryAttempts, config.retry.retryDelay, config.retry.backoff, config.retry.maxDelay);
-              debugLog.retry(config, config.retryAttempts, maxRetries, response.status, delay);
-              if (config.hooks?.beforeRetry && config.hooks.beforeRetry.length > 0) {
-                for (const hook of config.hooks.beforeRetry) {
-                  await hook(config, httpError, config.retryAttempts);
-                }
+        if (retryConfig) {
+          retryAttempt++;
+          if (retryConfig.condition) {
+            const shouldContinue = await retryConfig.condition(httpError, retryAttempt);
+            if (shouldContinue === false) {
+              if (retryConfig.onRetryExhausted) {
+                await retryConfig.onRetryExhausted(httpError, retryAttempt);
               }
-              if (delay > 0) {
-                await new Promise((resolve) => setTimeout(resolve, delay));
+              throw httpError;
+            }
+          } else {
+            const canRetry = shouldRetry(httpError, retryAttempt, method, retryConfig);
+            if (!canRetry) {
+              if (retryAttempt > retryConfig.maxRetries) {
+                debugLog.maxRetries(config, retryConfig.maxRetries);
+                if (retryConfig.onRetryExhausted) {
+                  await retryConfig.onRetryExhausted(httpError, retryAttempt);
+                }
               }
-              return executeRequest(options, defaultOptions, jar);
+              throw httpError;
+            }
+          }
+          if (!config.errors)
+            config.errors = [];
+          config.errors.push({
+            attempt: retryAttempt,
+            error: httpError,
+            duration: perform.now()
+          });
+          perform.reset();
+          const currentDelay = calculateRetryDelay(retryAttempt, retryConfig.retryDelay, retryConfig.backoff, retryConfig.maxDelay);
+          debugLog.retry(config, retryAttempt, retryConfig.maxRetries, response.status, currentDelay);
+          if (retryConfig.onRetry) {
+            const shouldProceed = await retryConfig.onRetry(httpError, retryAttempt, currentDelay);
+            if (shouldProceed === false) {
+              throw httpError;
             }
           }
-          debugLog.maxRetries(config, maxRetries);
+          if (config.hooks?.beforeRetry && config.hooks.beforeRetry.length > 0) {
+            for (const hook of config.hooks.beforeRetry) {
+              await hook(config, httpError, retryAttempt);
+            }
+          }
+          if (currentDelay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, currentDelay));
+          }
+          config.retryAttempts++;
+          continue;
         }
         throw httpError;
       }
-    }
-    return result;
-  } catch (error) {
-    if (proxyManager && selectedProxy) {
-      proxyManager.reportFailure(selectedProxy, error);
-      if (proxyManager.config.retryWithNextProxy) {
-        const maxRetries = proxyManager.config.maxProxyRetries ?? 3;
-        const attempt = (config._proxyRetryCount ?? 0) + 1;
-        if (attempt <= maxRetries) {
-          config._proxyRetryCount = attempt;
-          const retryUrl = typeof originalRequest.url === "string" ? originalRequest.url : originalRequest.url?.toString() || "";
-          const nextProxy = proxyManager.next(retryUrl);
-          if (nextProxy) {
-            options.proxy = {
-              protocol: nextProxy.protocol,
-              host: nextProxy.host,
-              port: nextProxy.port,
-              auth: nextProxy.auth
-            };
-            return executeRequest(options, defaultOptions, jar);
+      return result;
+    } catch (error) {
+      if (error instanceof RezoError) {
+        if (retryConfig && !retryConfig.condition) {
+          const errorCode = error.code ?? error.cause?.code;
+          const isRetryableError = errorCode && shouldRetry(error, retryAttempt + 1, method, retryConfig);
+          if (isRetryableError) {
+            retryAttempt++;
+            if (!config.errors)
+              config.errors = [];
+            config.errors.push({
+              attempt: retryAttempt,
+              error,
+              duration: perform.now()
+            });
+            perform.reset();
+            const currentDelay = calculateRetryDelay(retryAttempt, retryConfig.retryDelay, retryConfig.backoff, retryConfig.maxDelay);
+            debugLog.retry(config, retryAttempt, retryConfig.maxRetries, 0, currentDelay);
+            if (retryConfig.onRetry) {
+              const shouldProceed = await retryConfig.onRetry(error, retryAttempt, currentDelay);
+              if (shouldProceed === false)
+                throw error;
+            }
+            if (config.hooks?.beforeRetry && config.hooks.beforeRetry.length > 0) {
+              for (const hook of config.hooks.beforeRetry) {
+                await hook(config, error, retryAttempt);
+              }
+            }
+            if (currentDelay > 0) {
+              await new Promise((resolve) => setTimeout(resolve, currentDelay));
+            }
+            config.retryAttempts++;
+            continue;
           }
         }
+        if (proxyManager && selectedProxy) {
+          proxyManager.reportFailure(selectedProxy, error);
+          if (proxyManager.config.retryWithNextProxy) {
+            const maxProxyRetries = proxyManager.config.maxProxyRetries ?? 3;
+            const proxyAttempt = (config._proxyRetryCount ?? 0) + 1;
+            if (proxyAttempt <= maxProxyRetries) {
+              config._proxyRetryCount = proxyAttempt;
+              const retryUrl = typeof originalRequest.url === "string" ? originalRequest.url : originalRequest.url?.toString() || "";
+              const nextProxy = proxyManager.next(retryUrl);
+              if (nextProxy) {
+                originalRequest.proxy = {
+                  protocol: nextProxy.protocol,
+                  host: nextProxy.host,
+                  port: nextProxy.port,
+                  auth: nextProxy.auth
+                };
+                continue;
+              }
+            }
+          }
+        }
+        throw error;
       }
+      if (proxyManager && selectedProxy) {
+        proxyManager.reportFailure(selectedProxy, error);
+      }
+      throw buildSmartError(config, originalRequest, error);
     }
-    if (error instanceof RezoError) {
-      throw error;
-    }
-    throw buildSmartError(config, originalRequest, error);
   }
 }
 

package/dist/adapters/curl.js

@@ -10,7 +10,8 @@ import { buildSmartError, builErrorFromResponse } from '../responses/buildError.
 import { RezoCookieJar, Cookie } from '../cookies/cookie-jar.js';
 import RezoFormData from '../utils/form-data.js';
 import { existsSync } from "node:fs";
-import { getDefaultConfig, prepareHTTPOptions, calculateRetryDelay } from '../utils/http-config.js';
+import { getDefaultConfig, prepareHTTPOptions, calculateRetryDelay, shouldRetry } from '../utils/http-config.js';
+import { handleRateLimitWait, shouldWaitOnStatus } from '../utils/rate-limit-wait.js';
 import { RezoHeaders } from '../utils/headers.js';
 import { StreamResponse } from '../responses/stream.js';
 import { DownloadResponse } from '../responses/download.js';
@@ -2288,9 +2289,20 @@ export async function executeRequest(options, defaultOptions, jar) {
     }
   }
   const executor = new CurlExecutor;
-  try {
-    const result = await executor.execute(config, originalRequest, streamResponse, downloadResponse, uploadResponse);
-    if (!streamResponse && !downloadResponse && !uploadResponse) {
+  const retryConfig = config.retry;
+  let retryAttempt = 0;
+  const ABSOLUTE_MAX_ATTEMPTS = 50;
+  let totalAttempts = 0;
+  while (true) {
+    totalAttempts++;
+    if (totalAttempts > ABSOLUTE_MAX_ATTEMPTS) {
+      throw new RezoError(`Absolute maximum attempts (${ABSOLUTE_MAX_ATTEMPTS}) exceeded. This prevents infinite loops from retries and redirects.`, config, "ERR_MAX_ATTEMPTS", originalRequest);
+    }
+    try {
+      const result = await executor.execute(config, originalRequest, streamResponse, downloadResponse, uploadResponse);
+      if (streamResponse || downloadResponse || uploadResponse) {
+        return result;
+      }
       const response = result;
       if (proxyManager && selectedProxy) {
         proxyManager.reportSuccess(selectedProxy);
@@ -2317,67 +2329,140 @@ export async function executeRequest(options, defaultOptions, jar) {
         }
       }
       debugLog.complete(config, response.finalUrl || requestUrl, config.redirectHistory?.length || 0, duration);
-      if (response.status >= 400) {
+      const _validateStatus = originalRequest.validateStatus ?? ((s) => s >= 200 && s < 300);
+      if (originalRequest.validateStatus !== null && !_validateStatus(response.status)) {
+        if (shouldWaitOnStatus(response.status, options.waitOnStatus)) {
+          const rateLimitWaitAttempt = config._rateLimitWaitAttempt || 0;
+          const waitResult = await handleRateLimitWait({
+            status: response.status,
+            headers: response.headers,
+            data: response.data,
+            url: requestUrl,
+            method,
+            config,
+            options,
+            currentWaitAttempt: rateLimitWaitAttempt
+          });
+          if (waitResult.shouldRetry) {
+            config._rateLimitWaitAttempt = waitResult.waitAttempt;
+            continue;
+          }
+        }
         const httpError = builErrorFromResponse(`Request failed with status code ${response.status}`, response, config, originalRequest);
-        if (config.retry) {
-          const maxRetries = config.retry.maxRetries || 0;
-          const statusCodes = config.retry.statusCodes || [408, 429, 500, 502, 503, 504];
-          if (statusCodes.includes(response.status)) {
-            if (config.retryAttempts < maxRetries) {
-              config.retryAttempts++;
-              if (!config.errors)
-                config.errors = [];
-              config.errors.push({
-                attempt: config.retryAttempts,
-                error: httpError,
-                duration: perform.now()
-              });
-              perform.reset();
-              const delay = calculateRetryDelay(config.retryAttempts, config.retry.retryDelay, config.retry.backoff, config.retry.maxDelay);
-              debugLog.retry(config, config.retryAttempts, maxRetries, response.status, delay);
-              if (config.hooks?.beforeRetry && config.hooks.beforeRetry.length > 0) {
-                for (const hook of config.hooks.beforeRetry) {
-                  await hook(config, httpError, config.retryAttempts);
-                }
+        if (retryConfig) {
+          retryAttempt++;
+          if (retryConfig.condition) {
+            const shouldContinue = await retryConfig.condition(httpError, retryAttempt);
+            if (shouldContinue === false) {
+              if (retryConfig.onRetryExhausted) {
+                await retryConfig.onRetryExhausted(httpError, retryAttempt);
               }
-              if (delay > 0) {
-                await new Promise((resolve) => setTimeout(resolve, delay));
+              throw httpError;
+            }
+          } else {
+            const canRetry = shouldRetry(httpError, retryAttempt, method, retryConfig);
+            if (!canRetry) {
+              if (retryAttempt > retryConfig.maxRetries) {
+                debugLog.maxRetries(config, retryConfig.maxRetries);
+                if (retryConfig.onRetryExhausted) {
+                  await retryConfig.onRetryExhausted(httpError, retryAttempt);
+                }
               }
-              return executeRequest(options, defaultOptions, jar);
+              throw httpError;
+            }
+          }
+          if (!config.errors)
+            config.errors = [];
+          config.errors.push({
+            attempt: retryAttempt,
+            error: httpError,
+            duration: perform.now()
+          });
+          perform.reset();
+          const currentDelay = calculateRetryDelay(retryAttempt, retryConfig.retryDelay, retryConfig.backoff, retryConfig.maxDelay);
+          debugLog.retry(config, retryAttempt, retryConfig.maxRetries, response.status, currentDelay);
+          if (retryConfig.onRetry) {
+            const shouldProceed = await retryConfig.onRetry(httpError, retryAttempt, currentDelay);
+            if (shouldProceed === false) {
+              throw httpError;
             }
           }
-          debugLog.maxRetries(config, maxRetries);
+          if (config.hooks?.beforeRetry && config.hooks.beforeRetry.length > 0) {
+            for (const hook of config.hooks.beforeRetry) {
+              await hook(config, httpError, retryAttempt);
+            }
+          }
+          if (currentDelay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, currentDelay));
+          }
+          config.retryAttempts++;
+          continue;
         }
         throw httpError;
       }
-    }
-    return result;
-  } catch (error) {
-    if (proxyManager && selectedProxy) {
-      proxyManager.reportFailure(selectedProxy, error);
-      if (proxyManager.config.retryWithNextProxy) {
-        const maxRetries = proxyManager.config.maxProxyRetries ?? 3;
-        const attempt = (config._proxyRetryCount ?? 0) + 1;
-        if (attempt <= maxRetries) {
-          config._proxyRetryCount = attempt;
-          const retryUrl = typeof originalRequest.url === "string" ? originalRequest.url : originalRequest.url?.toString() || "";
-          const nextProxy = proxyManager.next(retryUrl);
-          if (nextProxy) {
-            options.proxy = {
-              protocol: nextProxy.protocol,
-              host: nextProxy.host,
-              port: nextProxy.port,
-              auth: nextProxy.auth
-            };
-            return executeRequest(options, defaultOptions, jar);
+      return result;
+    } catch (error) {
+      if (error instanceof RezoError) {
+        if (retryConfig && !retryConfig.condition) {
+          const errorCode = error.code ?? error.cause?.code;
+          const isRetryableError = errorCode && shouldRetry(error, retryAttempt + 1, method, retryConfig);
+          if (isRetryableError) {
+            retryAttempt++;
+            if (!config.errors)
+              config.errors = [];
+            config.errors.push({
+              attempt: retryAttempt,
+              error,
+              duration: perform.now()
+            });
+            perform.reset();
+            const currentDelay = calculateRetryDelay(retryAttempt, retryConfig.retryDelay, retryConfig.backoff, retryConfig.maxDelay);
+            debugLog.retry(config, retryAttempt, retryConfig.maxRetries, 0, currentDelay);
+            if (retryConfig.onRetry) {
+              const shouldProceed = await retryConfig.onRetry(error, retryAttempt, currentDelay);
+              if (shouldProceed === false)
+                throw error;
+            }
+            if (config.hooks?.beforeRetry && config.hooks.beforeRetry.length > 0) {
+              for (const hook of config.hooks.beforeRetry) {
+                await hook(config, error, retryAttempt);
+              }
+            }
+            if (currentDelay > 0) {
+              await new Promise((resolve) => setTimeout(resolve, currentDelay));
+            }
+            config.retryAttempts++;
+            continue;
           }
         }
+        if (proxyManager && selectedProxy) {
+          proxyManager.reportFailure(selectedProxy, error);
+          if (proxyManager.config.retryWithNextProxy) {
+            const maxProxyRetries = proxyManager.config.maxProxyRetries ?? 3;
+            const proxyAttempt = (config._proxyRetryCount ?? 0) + 1;
+            if (proxyAttempt <= maxProxyRetries) {
+              config._proxyRetryCount = proxyAttempt;
+              const retryUrl = typeof originalRequest.url === "string" ? originalRequest.url : originalRequest.url?.toString() || "";
+              const nextProxy = proxyManager.next(retryUrl);
+              if (nextProxy) {
+                originalRequest.proxy = {
+                  protocol: nextProxy.protocol,
+                  host: nextProxy.host,
+                  port: nextProxy.port,
+                  auth: nextProxy.auth
+                };
+                continue;
+              }
+            }
+          }
+        }
+        throw error;
       }
+      if (proxyManager && selectedProxy) {
+        proxyManager.reportFailure(selectedProxy, error);
+      }
+      throw buildSmartError(config, originalRequest, error);
     }
-    if (error instanceof RezoError) {
-      throw error;
-    }
-    throw buildSmartError(config, originalRequest, error);
   }
 }
 

package/dist/adapters/entries/curl.d.ts

@@ -2921,6 +2921,23 @@ export interface RezoDefaultOptions {
 	 * ```
 	 */
 	proxyManager?: ProxyManager | ProxyManagerConfig;
+	/**
+	 * Determines whether a given HTTP status code should be treated as successful.
+	 * When a status code fails validation, the request throws an error.
+	 *
+	 * @default (status) => status >= 200 && status < 300
+	 */
+	validateStatus?: ((status: number) => boolean) | null;
+	/**
+	 * Custom function to serialize URL query parameters.
+	 * Replaces the default serialization logic.
+	 */
+	paramsSerializer?: (params: Record<string, any>) => string;
+	/**
+	 * Custom DNS lookup function for hostname resolution.
+	 * Replaces the default `dns.lookup` used by Node.js.
+	 */
+	dnsLookup?: RezoHttpRequest["dnsLookup"];
 	/** Browser fingerprint stealth configuration (instance-level only) */
 	stealth?: RezoStealth;
 }
@@ -3302,6 +3319,16 @@ export interface RezoConfig {
 	onRedirect?: RezoRequestConfig["beforeRedirect"];
 	/** Character encoding for request body and response data */
 	encoding?: BufferEncoding;
+	/**
+	 * Determines whether a given HTTP status code should be treated as successful.
+	 * Used by adapters to decide if a response is an error.
+	 * @default (status) => status >= 200 && status < 300
+	 */
+	validateStatus?: ((status: number) => boolean) | null;
+	/**
+	 * Custom DNS lookup function for hostname resolution.
+	 */
+	dnsLookup?: (hostname: string, options: any, callback: (err: Error | null, address: string, family: number) => void) => void;
 	/**
 	 * Whether to use cookies for the request
 	 */
@@ -4117,6 +4144,60 @@ export interface RezoRequestConfig<D = any> {
 	};
 	/** Character encoding for request body and response data */
 	encoding?: BufferEncoding;
+	/**
+	 * Determines whether a given HTTP status code should be treated as a successful response.
+	 * When a status code fails validation, the request will throw an error.
+	 *
+	 * @param status - The HTTP response status code
+	 * @returns true if the status code should be considered successful
+	 *
+	 * @default (status) => status >= 200 && status < 300
+	 *
+	 * @example
+	 * ```typescript
+	 * // Accept all 2xx and 3xx as success
+	 * validateStatus: (status) => status >= 200 && status < 400
+	 *
+	 * // Never throw on any status code
+	 * validateStatus: () => true
+	 *
+	 * // Only accept 200
+	 * validateStatus: (status) => status === 200
+	 * ```
+	 */
+	validateStatus?: ((status: number) => boolean) | null;
+	/**
+	 * Custom function to serialize URL query parameters.
+	 * When provided, this replaces the default serialization logic.
+	 *
+	 * @param params - The params object to serialize
+	 * @returns The serialized query string (without leading '?')
+	 *
+	 * @example
+	 * ```typescript
+	 * // Custom array serialization
+	 * paramsSerializer: (params) => qs.stringify(params, { arrayFormat: 'brackets' })
+	 *
+	 * // Simple key=value pairs
+	 * paramsSerializer: (params) =>
+	 *   Object.entries(params).map(([k, v]) => `${k}=${v}`).join('&')
+	 * ```
+	 */
+	paramsSerializer?: (params: Record<string, any>) => string;
+	/**
+	 * Custom DNS lookup function for hostname resolution.
+	 * Replaces the default `dns.lookup` used by Node.js for this request.
+	 *
+	 * @example
+	 * ```typescript
+	 * import { lookup } from 'node:dns/promises';
+	 * dnsLookup: (hostname, options, callback) => {
+	 *   // Custom DNS resolution logic
+	 *   lookup(hostname).then(result => callback(null, result.address, result.family));
+	 * }
+	 * ```
+	 */
+	dnsLookup?: (hostname: string, options: any, callback: (err: Error | null, address: string, family: number) => void) => void;
 	/**
 	 * Request lifecycle hooks for intercepting and modifying request/response behavior.
 	 * Optional hooks that will be merged with default hooks during request processing.
@@ -5591,7 +5672,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.107";
+export declare const VERSION = "1.0.108";
 /**
  * cURL Options Configuration
  *

package/dist/adapters/entries/fetch.d.ts

@@ -2921,6 +2921,23 @@ export interface RezoDefaultOptions {
 	 * ```
 	 */
 	proxyManager?: ProxyManager | ProxyManagerConfig;
+	/**
+	 * Determines whether a given HTTP status code should be treated as successful.
+	 * When a status code fails validation, the request throws an error.
+	 *
+	 * @default (status) => status >= 200 && status < 300
+	 */
+	validateStatus?: ((status: number) => boolean) | null;
+	/**
+	 * Custom function to serialize URL query parameters.
+	 * Replaces the default serialization logic.
+	 */
+	paramsSerializer?: (params: Record<string, any>) => string;
+	/**
+	 * Custom DNS lookup function for hostname resolution.
+	 * Replaces the default `dns.lookup` used by Node.js.
+	 */
+	dnsLookup?: RezoHttpRequest["dnsLookup"];
 	/** Browser fingerprint stealth configuration (instance-level only) */
 	stealth?: RezoStealth;
 }
@@ -3302,6 +3319,16 @@ export interface RezoConfig {
 	onRedirect?: RezoRequestConfig["beforeRedirect"];
 	/** Character encoding for request body and response data */
 	encoding?: BufferEncoding;
+	/**
+	 * Determines whether a given HTTP status code should be treated as successful.
+	 * Used by adapters to decide if a response is an error.
+	 * @default (status) => status >= 200 && status < 300
+	 */
+	validateStatus?: ((status: number) => boolean) | null;
+	/**
+	 * Custom DNS lookup function for hostname resolution.
+	 */
+	dnsLookup?: (hostname: string, options: any, callback: (err: Error | null, address: string, family: number) => void) => void;
 	/**
 	 * Whether to use cookies for the request
 	 */
@@ -4117,6 +4144,60 @@ export interface RezoRequestConfig<D = any> {
 	};
 	/** Character encoding for request body and response data */
 	encoding?: BufferEncoding;
+	/**
+	 * Determines whether a given HTTP status code should be treated as a successful response.
+	 * When a status code fails validation, the request will throw an error.
+	 *
+	 * @param status - The HTTP response status code
+	 * @returns true if the status code should be considered successful
+	 *
+	 * @default (status) => status >= 200 && status < 300
+	 *
+	 * @example
+	 * ```typescript
+	 * // Accept all 2xx and 3xx as success
+	 * validateStatus: (status) => status >= 200 && status < 400
+	 *
+	 * // Never throw on any status code
+	 * validateStatus: () => true
+	 *
+	 * // Only accept 200
+	 * validateStatus: (status) => status === 200
+	 * ```
+	 */
+	validateStatus?: ((status: number) => boolean) | null;
+	/**
+	 * Custom function to serialize URL query parameters.
+	 * When provided, this replaces the default serialization logic.
+	 *
+	 * @param params - The params object to serialize
+	 * @returns The serialized query string (without leading '?')
+	 *
+	 * @example
+	 * ```typescript
+	 * // Custom array serialization
+	 * paramsSerializer: (params) => qs.stringify(params, { arrayFormat: 'brackets' })
+	 *
+	 * // Simple key=value pairs
+	 * paramsSerializer: (params) =>
+	 *   Object.entries(params).map(([k, v]) => `${k}=${v}`).join('&')
+	 * ```
+	 */
+	paramsSerializer?: (params: Record<string, any>) => string;
+	/**
+	 * Custom DNS lookup function for hostname resolution.
+	 * Replaces the default `dns.lookup` used by Node.js for this request.
+	 *
+	 * @example
+	 * ```typescript
+	 * import { lookup } from 'node:dns/promises';
+	 * dnsLookup: (hostname, options, callback) => {
+	 *   // Custom DNS resolution logic
+	 *   lookup(hostname).then(result => callback(null, result.address, result.family));
+	 * }
+	 * ```
+	 */
+	dnsLookup?: (hostname: string, options: any, callback: (err: Error | null, address: string, family: number) => void) => void;
 	/**
 	 * Request lifecycle hooks for intercepting and modifying request/response behavior.
 	 * Optional hooks that will be merged with default hooks during request processing.
@@ -5591,7 +5672,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.107";
+export declare const VERSION = "1.0.108";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {