rezo 1.0.137 → 1.0.139

package/dist/adapters/curl.cjs

@@ -11,6 +11,7 @@ const { RezoCookieJar, Cookie } = require('../cookies/cookie-jar.cjs');
 const RezoFormData = require('../utils/form-data.cjs');
 const { existsSync } = require("node:fs");
 const { getDefaultConfig, prepareHTTPOptions, calculateRetryDelay, shouldRetry } = require('../utils/http-config.cjs');
+const { debugErrorDump } = require('../utils/debug-error-dump.cjs');
 const { handleRateLimitWait, shouldWaitOnStatus } = require('../utils/rate-limit-wait.cjs');
 const { RezoHeaders } = require('../utils/headers.cjs');
 const { StreamResponse } = require('../responses/stream.cjs');
@@ -2470,12 +2471,15 @@ async function executeRequest(options, defaultOptions, jar) {
             }
           }
         }
+        debugErrorDump(config, error);
         throw error;
       }
       if (proxyManager && selectedProxy) {
         proxyManager.reportFailure(selectedProxy, error);
       }
-      throw buildSmartError(config, originalRequest, error);
+      const smartError = buildSmartError(config, originalRequest, error);
+      debugErrorDump(config, smartError);
+      throw smartError;
     }
   }
 }

package/dist/adapters/curl.js

@@ -11,6 +11,7 @@ import { RezoCookieJar, Cookie } from '../cookies/cookie-jar.js';
 import RezoFormData from '../utils/form-data.js';
 import { existsSync } from "node:fs";
 import { getDefaultConfig, prepareHTTPOptions, calculateRetryDelay, shouldRetry } from '../utils/http-config.js';
+import { debugErrorDump } from '../utils/debug-error-dump.js';
 import { handleRateLimitWait, shouldWaitOnStatus } from '../utils/rate-limit-wait.js';
 import { RezoHeaders } from '../utils/headers.js';
 import { StreamResponse } from '../responses/stream.js';
@@ -2470,12 +2471,15 @@ export async function executeRequest(options, defaultOptions, jar) {
             }
           }
         }
+        debugErrorDump(config, error);
         throw error;
       }
       if (proxyManager && selectedProxy) {
         proxyManager.reportFailure(selectedProxy, error);
       }
-      throw buildSmartError(config, originalRequest, error);
+      const smartError = buildSmartError(config, originalRequest, error);
+      debugErrorDump(config, smartError);
+      throw smartError;
     }
   }
 }

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

@@ -761,6 +761,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -2767,6 +2773,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -2776,34 +2807,36 @@ export interface RezoRequestConfig<D = any> {
 	 * TLS negotiation for HTTPS).
 	 *
 	 * **Behavior:**
-	 * - `false` (default) - Connection closes after each request. Process exits immediately.
-	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`keepAlive: true`):**
 	 * - Making multiple requests to the same host in sequence
 	 * - Long-running applications (servers, bots, scrapers)
 	 * - Performance-critical applications where connection overhead matters
 	 *
-	 * **When to use `keepAlive: false` (default):**
-	 * - Single requests or scripts that should exit immediately
-	 * - CLI tools that make one-off requests
-	 * - When you need predictable process termination
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * const { data } = await rezo.get('https://api.example.com/data');
 	 *
-	 * // Keep connection alive for 1 minute (default) for subsequent requests
-	 * const client = new Rezo({ keepAlive: true });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -4013,6 +4046,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -8581,7 +8616,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.139";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

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

@@ -759,6 +759,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -3035,6 +3041,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -4094,6 +4102,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -4103,34 +4136,36 @@ export interface RezoRequestConfig<D = any> {
 	 * TLS negotiation for HTTPS).
 	 *
 	 * **Behavior:**
-	 * - `false` (default) - Connection closes after each request. Process exits immediately.
-	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`keepAlive: true`):**
 	 * - Making multiple requests to the same host in sequence
 	 * - Long-running applications (servers, bots, scrapers)
 	 * - Performance-critical applications where connection overhead matters
 	 *
-	 * **When to use `keepAlive: false` (default):**
-	 * - Single requests or scripts that should exit immediately
-	 * - CLI tools that make one-off requests
-	 * - When you need predictable process termination
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * const { data } = await rezo.get('https://api.example.com/data');
 	 *
-	 * // Keep connection alive for 1 minute (default) for subsequent requests
-	 * const client = new Rezo({ keepAlive: true });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -6096,7 +6131,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.139";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

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

@@ -759,6 +759,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -3035,6 +3041,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -4094,6 +4102,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -4103,34 +4136,36 @@ export interface RezoRequestConfig<D = any> {
 	 * TLS negotiation for HTTPS).
 	 *
 	 * **Behavior:**
-	 * - `false` (default) - Connection closes after each request. Process exits immediately.
-	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`keepAlive: true`):**
 	 * - Making multiple requests to the same host in sequence
 	 * - Long-running applications (servers, bots, scrapers)
 	 * - Performance-critical applications where connection overhead matters
 	 *
-	 * **When to use `keepAlive: false` (default):**
-	 * - Single requests or scripts that should exit immediately
-	 * - CLI tools that make one-off requests
-	 * - When you need predictable process termination
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * const { data } = await rezo.get('https://api.example.com/data');
 	 *
-	 * // Keep connection alive for 1 minute (default) for subsequent requests
-	 * const client = new Rezo({ keepAlive: true });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -6171,7 +6206,7 @@ export declare function getSocketTelemetry(socket: Socket): SocketTelemetry | un
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.139";
 /**
  * Type guard to check if an error is a RezoError instance.
  */

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

@@ -760,6 +760,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -3036,6 +3042,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -4095,6 +4103,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -4104,34 +4137,36 @@ export interface RezoRequestConfig<D = any> {
 	 * TLS negotiation for HTTPS).
 	 *
 	 * **Behavior:**
-	 * - `false` (default) - Connection closes after each request. Process exits immediately.
-	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`keepAlive: true`):**
 	 * - Making multiple requests to the same host in sequence
 	 * - Long-running applications (servers, bots, scrapers)
 	 * - Performance-critical applications where connection overhead matters
 	 *
-	 * **When to use `keepAlive: false` (default):**
-	 * - Single requests or scripts that should exit immediately
-	 * - CLI tools that make one-off requests
-	 * - When you need predictable process termination
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * const { data } = await rezo.get('https://api.example.com/data');
 	 *
-	 * // Keep connection alive for 1 minute (default) for subsequent requests
-	 * const client = new Rezo({ keepAlive: true });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -6122,7 +6157,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.139";
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {

package/dist/adapters/entries/react-native.cjs

@@ -6,12 +6,12 @@ const { RezoFormData } = require('../../utils/form-data.cjs');
 const { RezoCookieJar, Cookie } = require('../../cookies/cookie-jar.cjs');
 const { createDefaultHooks, mergeHooks } = require('../../core/hooks.cjs');
 const { VERSION } = require('../../version.cjs');
-const _mod_bxvwu1 = require('../../platform/react-native-providers.cjs');
-exports.createFetchStreamTransport = _mod_bxvwu1.createFetchStreamTransport;
-exports.createExpoFileSystemAdapter = _mod_bxvwu1.createExpoFileSystemAdapter;
-exports.createReactNativeFsAdapter = _mod_bxvwu1.createReactNativeFsAdapter;
-exports.createNetInfoProvider = _mod_bxvwu1.createNetInfoProvider;
-exports.createExpoBackgroundTaskProvider = _mod_bxvwu1.createExpoBackgroundTaskProvider;;
+const _mod_hxyeij = require('../../platform/react-native-providers.cjs');
+exports.createFetchStreamTransport = _mod_hxyeij.createFetchStreamTransport;
+exports.createExpoFileSystemAdapter = _mod_hxyeij.createExpoFileSystemAdapter;
+exports.createReactNativeFsAdapter = _mod_hxyeij.createReactNativeFsAdapter;
+exports.createNetInfoProvider = _mod_hxyeij.createNetInfoProvider;
+exports.createExpoBackgroundTaskProvider = _mod_hxyeij.createExpoBackgroundTaskProvider;;
 exports.Rezo = Rezo;
 exports.RezoError = RezoError;
 exports.RezoErrorCode = RezoErrorCode;

package/dist/adapters/entries/react-native.d.ts

@@ -759,6 +759,12 @@ export interface RezoResponse<T = any> {
 	contentLength: number;
 	urls: string[];
 	config: RezoConfig;
+	/**
+	 * Present (true) only when `acceptPartialBody: true` salvaged a body whose
+	 * connection was torn down before a clean end-of-stream — the data may be
+	 * complete or may be missing its tail.
+	 */
+	truncated?: boolean;
 }
 /**
  * Platform-agnostic base interface for event-emitting responses
@@ -3035,6 +3041,8 @@ export interface RezoDefaultOptions {
 	decompress?: boolean;
 	/** Whether to keep the connection alive for reuse */
 	keepAlive?: boolean;
+	/** Accept bodies whose connection was torn down before a clean end-of-stream (response gets `truncated: true`) */
+	acceptPartialBody?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
@@ -4094,6 +4102,31 @@ export interface RezoRequestConfig<D = any> {
 	maxRedirects?: number;
 	/** Whether to automatically decompress response data */
 	decompress?: boolean;
+	/**
+	 * Accept response bodies that arrive without a clean end-of-stream.
+	 *
+	 * Some servers send the complete payload and then reset the connection
+	 * instead of closing it cleanly (or advertise a Content-Length larger than
+	 * what they send). Node reports this as `aborted`/`ECONNRESET` even though
+	 * the data may be complete and usable.
+	 *
+	 * With `acceptPartialBody: true`, if response headers passed validation and
+	 * at least one body byte arrived, the request **resolves normally** with
+	 * whatever was received instead of throwing. The response is marked with
+	 * `truncated: true` so you can decide whether to trust it.
+	 *
+	 * Off by default: a torn connection usually means missing data, and
+	 * silently returning an incomplete body is the more dangerous default.
+	 *
+	 * @example
+	 * ```typescript
+	 * const res = await rezo.get(url, { acceptPartialBody: true });
+	 * if (res.truncated) console.warn('body may be incomplete');
+	 * ```
+	 *
+	 * @default false
+	 */
+	acceptPartialBody?: boolean;
 	/**
 	 * Whether to keep TCP connections alive for reuse across multiple requests.
 	 *
@@ -4103,34 +4136,36 @@ export interface RezoRequestConfig<D = any> {
 	 * TLS negotiation for HTTPS).
 	 *
 	 * **Behavior:**
-	 * - `false` (default) - Connection closes after each request. Process exits immediately.
-	 * - `true` - Connection stays open for reuse. Idle connections close after `keepAliveMsecs`.
+	 * - `true` (default) - Connections are pooled and reused across requests to the
+	 *   same host. Idle pooled sockets are closed after ~5 seconds.
+	 * - `false` - A fresh connection is opened for every request and closed after
+	 *   the response. No pooling, no reuse.
 	 *
-	 * **When to use `keepAlive: true`:**
+	 * **When to keep the default (`keepAlive: true`):**
 	 * - Making multiple requests to the same host in sequence
 	 * - Long-running applications (servers, bots, scrapers)
 	 * - Performance-critical applications where connection overhead matters
 	 *
-	 * **When to use `keepAlive: false` (default):**
-	 * - Single requests or scripts that should exit immediately
-	 * - CLI tools that make one-off requests
-	 * - When you need predictable process termination
+	 * **When to use `keepAlive: false`:**
+	 * - Hosts that reset reused connections aggressively
+	 * - Debugging connection-level issues (isolates every request)
+	 * - One-off requests where connection reuse buys nothing
 	 *
 	 * @example
 	 * ```typescript
-	 * // Default: process exits immediately after request
+	 * // Default: pooled keep-alive connections
 	 * const { data } = await rezo.get('https://api.example.com/data');
 	 *
-	 * // Keep connection alive for 1 minute (default) for subsequent requests
-	 * const client = new Rezo({ keepAlive: true });
+	 * // Fresh connection per request for this instance
+	 * const client = rezo.create({ keepAlive: false });
 	 * await client.get('https://api.example.com/users');
-	 * await client.get('https://api.example.com/posts'); // Reuses connection
+	 * await client.get('https://api.example.com/posts'); // New connection again
 	 *
-	 * // Custom keep-alive timeout (30 seconds)
-	 * const client = new Rezo({ keepAlive: true, keepAliveMsecs: 30000 });
+	 * // Or per request
+	 * await rezo.get('https://api.example.com/data', { keepAlive: false });
 	 * ```
 	 *
-	 * @default false
+	 * @default true
 	 */
 	keepAlive?: boolean;
 	/**
@@ -6096,7 +6131,7 @@ export interface RezoInstance extends Rezo, RezoCallable {
  *
  * IMPORTANT: Update these values when bumping package version.
  */
-export declare const VERSION = "1.0.137";
+export declare const VERSION = "1.0.139";
 export interface ExpoFileSystemFileLike {
 	uri?: string;
 	size?: number;