proxy-pool-manager 1.0.9 → 1.0.11

package/README.md

@@ -4,12 +4,11 @@
 
 ## ✨ 特性
 
-- 🪶 **轻量级模式**：无需 MongoDB，仅使用请求和队列功能
-- 🔄 **智能代理管理**：支持从 MongoDB 加载代理，自动验证和轮换（可选）
+- 🪶 **内存代理**：代理列表由 `proxies` 传入，只保存在进程内存中
+- 🔄 **可选轮换**：`rotateOnError: true` 时，上游代理失败才换下一条；默认关闭，重试沿用本次代理
 - 🌐 **HTTP 请求封装**：内置 HTTP 客户端，支持自动代理切换或直接指定代理
 - 📊 **代理健康检查**：自动检测代理可用性，支持自定义检测规则（可选）
 - 🎯 **多种代理策略**：支持顺序、随机、故障转移三种策略
-- 📦 **批量操作**：支持批量插入和管理代理
 - 🔍 **日志系统**：基于 Winston 的完整日志记录
 - ⚡ **异步队列**：高效的异步任务处理机制
 - 🛡️ **类型安全**：完整的 TypeScript 类型定义
@@ -22,58 +21,54 @@ npm install proxy-pool-manager
 
 ## 🚀 快速开始
 
-### 轻量级模式（推荐，无需 MongoDB）
+### 只发请求
 
-如果你只需要使用 HTTP 请求和队列功能，不需要代理管理，可以使用轻量级模式：
+不需要代理池时，只创建请求客户端：
 
 ```typescript
 import { createProxyRequest } from 'proxy-pool-manager';
 
-// 创建轻量级 SDK 实例（不连接 MongoDB）
 const sdk = await createProxyRequest({
   maxRetries: 3,
   timeout: 30,
   logLevel: 'info'
 });
 
-// 发送 GET 请求
 const response = await sdk.get('https://api.example.com/data', {
   params: { page: 1 }
 });
 
-// 在请求中直接指定代理（可选）
 const responseWithProxy = await sdk.post('http://your-api.com/request', {
   url: 'https://api.example.com/data',
   method: 'GET',
-  proxy: 'http://proxy.example.com:8080',  // 直接指定代理
+  proxy: 'http://proxy.example.com:8080',
   timeout: 10
 });
 
 console.log(response.data);
 ```
 
-### 轻量级模式 + 代理数组（支持异常时自动轮换）
+### 传入代理数组
 
-如果你需要代理管理但不想连接 MongoDB，可以传入代理数组：
+失败后换下一条需要 `rotateOnError: true`，默认关闭。
+
+代理只存在当前进程内存中，进程退出后清空。
 
 ```typescript
 import { createProxyRequest } from 'proxy-pool-manager';
 
-// 创建轻量级 SDK 实例 + 代理数组（不连接 MongoDB）
 const sdk = await createProxyRequest({
   proxies: [
     'proxy1.example.com:8080:user1:pass1',
     'proxy2.example.com:8080:user2:pass2',
     'proxy3.example.com:8080:user3:pass3'
   ],
-  proxyStrategy: 'sequential',  // 顺序策略
+  proxyStrategy: 'sequential',
   maxRetries: 3,
   timeout: 30,
   logLevel: 'info'
 });
 
-// 发送请求，会自动使用代理管理器选择的代理
-// 如果代理失败，会自动轮换到下一个代理并重试
 const response = await sdk.post('http://your-api.com/request', {
   url: 'https://api.example.com/data',
   method: 'GET',
@@ -84,84 +79,10 @@ console.log('当前使用的代理:', sdk.getCurrentProxy());
 console.log('可用代理列表:', sdk.getAvailableProxies());
 ```
 
-### 完整模式（包含代理管理功能）
-
-如果需要代理管理功能（自动轮换、健康检查等），需要提供 MongoDB 连接：
-
-```typescript
-import { createProxyRequest } from 'proxy-pool-manager';
-
-// 创建完整 SDK 实例（包含代理管理）
-const sdk = await createProxyRequest({
-  mongoUri: 'mongodb://localhost:27017/proxy_db',
-  proxyStrategy: 'sequential',
-  logLevel: 'info',
-  timeout: 30,
-  proxyCheckOptions: {
-    mainUrl: 'http://example.com/check',
-    timeout: 10,
-  }
-});
-
-// 发送 GET 请求（自动使用代理管理器选择的代理）
-const response = await sdk.get('https://api.example.com/data', {
-  params: { page: 1 }
-});
-
-// 或者为特定请求指定代理（优先级高于自动选择）
-const responseWithSpecificProxy = await sdk.post('http://your-api.com/request', {
-  url: 'https://api.example.com/data',
-  method: 'GET',
-  proxy: 'http://specific-proxy.com:8080',  // 请求级代理优先
-  timeout: 10
-});
-
-console.log(response.data);
-```
-
-### 完整模式 + 代理数组（支持异常时自动轮换）
-
-如果需要代理管理功能，并且想预先设置代理列表：
-
-```typescript
-import { createProxyRequest } from 'proxy-pool-manager';
-
-// 创建完整 SDK 实例 + 代理数组（连接 MongoDB）
-const sdk = await createProxyRequest({
-  mongoUri: 'mongodb://localhost:27017/proxy_db',
-  proxies: [
-    'proxy1.example.com:8080:user1:pass1',
-    'proxy2.example.com:8080:user2:pass2',
-    'proxy3.example.com:8080:user3:pass3'
-  ],
-  proxyStrategy: 'failover',  // 故障转移策略
-  maxRetries: 3,
-  timeout: 30,
-  proxyCheckOptions: {
-    mainUrl: 'http://example.com/check',
-    timeout: 10,
-  }
-});
-
-// 代理会被保存到 MongoDB，并支持自动轮换
-// 如果请求失败，会自动轮换到下一个代理并重试
-const response = await sdk.get('https://api.example.com/data');
-```
-
-### 添加代理
+### 追加代理
 
 ```typescript
-// 添加单个代理
 await sdk.addProxy('proxy.example.com:8080:username:password');
-
-// 批量添加代理
-const count = await sdk.bulkInsertProxies([
-  'proxy1.example.com:8080:user1:pass1',
-  'proxy2.example.com:8080:user2:pass2',
-  'proxy3.example.com:8080:user3:pass3',
-]);
-
-console.log(`成功添加 ${count} 个代理`);
 ```
 
 ### HTTP 请求方法
@@ -213,21 +134,20 @@ const customResponse = await sdk.request({
 
 ```typescript
 interface SDKOptions {
-  mongoUri?: string;                    // MongoDB 连接 URI（可选，启用代理管理时需要）
   maxRetries?: number;                  // 最大重试次数，默认 3
   timeout?: number;                     // 请求超时时间（秒），默认 30
   proxyStrategy?: ProxyStrategy;        // 代理策略，默认 'sequential'
   logLevel?: LogLevel;                  // 日志级别，默认 'info'
   instanceId?: string;                  // 实例 ID，用于多实例场景
-  proxies?: string[];                   // 代理数组，支持异常时自动轮换
+  proxies?: string[];                   // 代理数组，只保存在内存中
   proxy?: string;                       // 单个代理
   retryDelay?: number;                   // 重试间隔（毫秒），默认使用指数退避策略
   retryDelayBase?: number;              // 指数退避的基础延迟（毫秒），默认 1000
   retryDelayMultiplier?: number;        // 指数退避的倍数，默认 2
+  rotateOnError?: boolean;              // 上游代理失败时换下一条，默认 false
   proxyCheckEnabled?: boolean;          // 是否启用代理检查，默认 true
-  proxyLimit?: number;                  // 代理加载限制，0 表示不加载，默认 0
-  proxyCheckOptions?: {                 // 代理检查配置（启用代理管理时需要）
-    mainUrl: string;                   // 代理检查主 URL（启用代理管理时必需）
+  proxyCheckOptions?: {                 // 代理检查配置（启用健康检查时需要）
+    mainUrl: string;                   // 代理检查主 URL（启用代理检查时必需）
     testUrls?: string[];                // 额外的测试 URL
     timeout?: number;                  // 检查超时时间（秒）
     successStatusCodes?: number[];     // 成功状态码列表
@@ -240,12 +160,9 @@ interface SDKOptions {
 
 **配置说明：**
 
-- **轻量级模式**：不提供 `mongoUri` 和 `proxyCheckOptions`，SDK 将以轻量级模式运行，不连接 MongoDB，不初始化代理管理功能
-- **轻量级模式 + 代理数组**：提供 `proxies` 或 `proxy` 但不提供 `mongoUri`，SDK 将以轻量级模式运行，代理仅存储在内存中，支持异常时自动轮换
-- **完整模式**：提供 `mongoUri` 或 `proxyCheckOptions`，SDK 将启用代理管理功能
-- **完整模式 + 代理数组**：同时提供 `mongoUri` 和 `proxies`，代理会被保存到 MongoDB，并支持异常时自动轮换
-- **禁用代理检查**：设置 `proxyCheckEnabled: false` 可禁用代理检查
-- **不加载代理**：设置 `proxyLimit: 0` 可不从数据库加载代理
+- 不传 `proxies` / `proxy` / `proxyCheckOptions` 时，只提供 HTTP 请求，不启用代理池
+- 传入 `proxies` 或 `proxy` 后启用代理池，列表只在内存中
+- 设置 `proxyCheckEnabled: false` 可禁用代理健康检查
 
 #### 方法
 
@@ -271,10 +188,6 @@ interface SDKOptions {
 - `getProxyDetails(proxyUrl: string): ProxyItem | undefined` - 获取代理详情
 - `hasProxyManagement(): boolean` - 检查是否启用了代理管理功能
 
-##### 批量操作
-
-- `bulkInsertProxies(proxyUrls: string[]): Promise<number>` - 批量插入代理
-
 ##### 统计信息
 
 - `getProxyStats(): Promise<ProxyStats>` - 获取代理统计信息
@@ -376,7 +289,7 @@ const response3 = await sdk.get('https://api.example.com/data');
 - 根据代理的历史表现（失败率、响应时间）自动选择最优代理
 - 优先使用失败率低、响应时间短的代理
 - 适合需要高可用性和性能的场景
-- **不需要 MongoDB**：统计信息存储在内存中，实时更新
+- 统计信息只存在内存中，进程重启后清空
 
 **选择优先级：**
 
@@ -390,55 +303,25 @@ const response3 = await sdk.get('https://api.example.com/data');
 - 代理质量差异较大，需要自动选择最优代理
 - 需要自动排除故障代理
 - 对请求成功率要求较高的场景
-- **轻量级模式**：不需要 MongoDB，仅使用内存统计
 
 **示例：**
 
 ```typescript
-// 轻量级模式 + failover（不需要 MongoDB）
-const sdk1 = await createProxyRequest({
-  proxies: [
-    'proxy1.example.com:8080:user1:pass1',  // 高质量代理
-    'proxy2.example.com:8080:user2:pass2',  // 中等质量代理
-    'proxy3.example.com:8080:user3:pass3'   // 低质量代理
-  ],
-  proxyStrategy: 'failover'  // 不需要 MongoDB，统计信息存储在内存中
-});
-
-// 自动选择最优代理（失败率低、响应时间短）
-const response = await sdk1.get('https://api.example.com/data');
-```
-
-```typescript
-// 完整模式 + failover（使用 MongoDB 持久化统计信息）
-const sdk2 = await createProxyRequest({
-  mongoUri: 'mongodb://localhost:27017/proxy_db',
+const sdk = await createProxyRequest({
   proxies: [
     'proxy1.example.com:8080:user1:pass1',
     'proxy2.example.com:8080:user2:pass2',
     'proxy3.example.com:8080:user3:pass3'
   ],
-  proxyStrategy: 'failover',
-  proxyCheckOptions: {
-    mainUrl: 'http://example.com/check'
-  }
+  proxyStrategy: 'failover'
 });
 
-// 统计信息会被持久化到 MongoDB，重启后仍然保留历史数据
-const response = await sdk2.get('https://api.example.com/data');
+const response = await sdk.get('https://api.example.com/data');
 ```
 
 **统计信息说明：**
 
-- **内存模式**（不提供 `mongoUri`）：
-  - 统计信息存储在内存中，实时更新
-  - 重启后统计信息会重置
-  - 适合临时使用或单次运行场景
-
-- **持久化模式**（提供 `mongoUri`）：
-  - 统计信息会保存到 MongoDB
-  - 重启后仍然保留历史数据
-  - 适合长期运行或需要历史数据的场景
+失败次数和响应时间只记在内存里，进程重启后重新计算。
 
 **轮换机制：**
 
@@ -470,10 +353,8 @@ const response = await sdk2.get('https://api.example.com/data');
 
 **重要说明：**
 
-- ✅ **不需要 MongoDB**：failover 策略可以在轻量级模式下使用，统计信息存储在内存中
-- ✅ **实时更新**：每次请求后，统计信息会立即更新（成功/失败次数、响应时间等）
-- ✅ **自动学习**：随着请求的进行，系统会自动学习每个代理的质量，并优先使用高质量代理
-- 💡 **MongoDB 的作用**：如果提供 MongoDB，统计信息会被持久化，重启后仍然保留历史数据，有助于更快地识别高质量代理
+- 每次请求后统计会立即更新
+- 连续失败超过阈值的代理会被标成无效，成功后再恢复
 
 ### 重试间隔配置
 
@@ -564,84 +445,23 @@ const sdk = await createProxyRequest({
   logLevel: 'info'
 });
 
-// 直接使用，无需 MongoDB
+// 不传 proxies 时只发请求
 const response = await sdk.get('https://api.example.com/data');
 ```
 
-#### 场景 2：需要临时使用代理
+#### 场景 2：单次请求指定代理
 
 ```typescript
-// 轻量级模式 + 直接指定代理
 const sdk = await createProxyRequest({
   maxRetries: 3,
   timeout: 30
 });
 
-// 在请求中直接指定代理
 const response = await sdk.post('http://your-api.com/request', {
   url: 'https://api.example.com/data',
   method: 'GET',
-  proxy: 'http://proxy.example.com:8080:user:pass'  // 直接指定代理
-});
-```
-
-#### 场景 2.5：使用代理数组 + 异常时自动轮换（推荐）
-
-```typescript
-// 轻量级模式 + 代理数组（不连接 MongoDB）
-const sdk = await createProxyRequest({
-  proxies: [
-    'proxy1.example.com:8080:user1:pass1',
-    'proxy2.example.com:8080:user2:pass2',
-    'proxy3.example.com:8080:user3:pass3'
-  ],
-  proxyStrategy: 'failover',  // 故障转移策略
-  maxRetries: 3,
-  timeout: 30
-});
-
-// 发送请求，如果代理失败会自动轮换到下一个代理
-const response = await sdk.post('http://your-api.com/request', {
-  url: 'https://api.example.com/data',
-  method: 'GET',
-  timeout: 10
-});
-```
-
-#### 场景 3：需要代理管理功能
-
-```typescript
-// 完整模式，启用代理管理
-const sdk = await createProxyRequest({
-  mongoUri: 'mongodb://localhost:27017/proxy_db',
-  proxyCheckOptions: {
-    mainUrl: 'http://example.com/check',
-    timeout: 10,
-  }
-});
-
-// 添加代理到管理器
-await sdk.addProxy('proxy1.example.com:8080:user1:pass1');
-
-// 自动使用代理管理器选择的代理
-const response = await sdk.get('https://api.example.com/data');
-```
-
-#### 场景 4：禁用代理检查，但仍使用代理管理
-
-```typescript
-// 使用代理管理，但禁用代理检查
-const sdk = await createProxyRequest({
-  mongoUri: 'mongodb://localhost:27017/proxy_db',
-  proxyCheckEnabled: false,  // 禁用代理检查
-  proxyLimit: 0,             // 不加载代理
-  proxyCheckOptions: {
-    mainUrl: 'http://example.com/check',  // 仍然需要提供（用于后续启用）
-  }
+  proxy: 'http://proxy.example.com:8080:user:pass'
 });
-
-// 手动添加代理，不进行自动检查
-await sdk.addProxy('proxy.example.com:8080:user:pass');
 ```
 
 ### 多实例场景
@@ -649,21 +469,14 @@ await sdk.addProxy('proxy.example.com:8080:user:pass');
 ```typescript
 import { initializeServices } from 'proxy-pool-manager';
 
-// 创建多个独立的 SDK 实例
 const sdk1 = await initializeServices({
-  mongoUri: 'mongodb://localhost:27017/proxy_db',
-  instanceId: 'instance-1',
-  proxyCheckOptions: {
-    mainUrl: 'http://example.com/check'
-  }
+  proxies: ['proxy1.example.com:8080:user1:pass1'],
+  instanceId: 'instance-1'
 });
 
 const sdk2 = await initializeServices({
-  mongoUri: 'mongodb://localhost:27017/proxy_db',
-  instanceId: 'instance-2',
-  proxyCheckOptions: {
-    mainUrl: 'http://example.com/check'
-  }
+  proxies: ['proxy2.example.com:8080:user2:pass2'],
+  instanceId: 'instance-2'
 });
 ```
 
@@ -671,7 +484,7 @@ const sdk2 = await initializeServices({
 
 ```typescript
 const sdk = await createProxyRequest({
-  mongoUri: 'mongodb://localhost:27017/proxy_db',
+  proxies: ['proxy1.example.com:8080:user1:pass1'],
   proxyCheckOptions: {
     mainUrl: 'https://httpbin.org/ip',
     testUrls: [
@@ -680,9 +493,9 @@ const sdk = await createProxyRequest({
     ],
     timeout: 15,
     successStatusCodes: [200, 201],
-    checkInterval: 60000,        // 每分钟检查一次
-    maxConsecutiveFails: 3,      // 连续失败3次后标记为无效
-    maxResponseTime: 5000         // 最大响应时间5秒
+    checkInterval: 60000,
+    maxConsecutiveFails: 3,
+    maxResponseTime: 5000
   }
 });
 ```
@@ -703,7 +516,7 @@ const response = await sdk.post('http://your-api.com/request', {
 });
 ```
 
-#### 2. 直接指定代理（轻量级模式和完整模式都支持）
+#### 2. 直接指定代理
 
 ```typescript
 // 为特定请求指定代理
@@ -715,7 +528,7 @@ const response = await sdk.post('http://your-api.com/request', {
 });
 ```
 
-#### 3. 使用代理数组（支持异常时自动轮换）
+#### 3. 使用代理数组
 
 ```typescript
 // 创建 SDK 时传入代理数组
@@ -729,8 +542,8 @@ const sdk = await createProxyRequest({
   maxRetries: 3
 });
 
-// 发送请求，会自动使用代理管理器选择的代理
-// 如果代理失败，会自动轮换到下一个代理并重试
+// 发送请求，会使用代理管理器选择的代理
+// 换下一条需要 rotateOnError: true
 const response = await sdk.post('http://your-api.com/request', {
   url: 'https://api.example.com/data',
   method: 'GET',
@@ -742,7 +555,7 @@ console.log('当前代理:', sdk.getCurrentProxy());
 console.log('可用代理:', sdk.getAvailableProxies());
 ```
 
-#### 4. 自动使用代理管理器选择的代理（完整模式）
+#### 4. 自动使用代理池选出的代理
 
 ```typescript
 // 先添加代理到管理器
@@ -769,7 +582,7 @@ const response = await sdk.post('http://your-api.com/request', {
 
 #### 6. 异常时自动轮换
 
-当请求失败时（超时、连接错误等），系统会自动轮换到下一个代理并重试：
+默认不换代理。设置 `rotateOnError: true` 后，网关返回的上游代理错误（代理认证、SOCKS、连接被拒绝、超时）才会换下一条并重试。连不上本次请求 URL 本身（网关不可达）不会记到代理凭证上。
 
 ```typescript
 const sdk = await createProxyRequest({
@@ -779,7 +592,8 @@ const sdk = await createProxyRequest({
     'proxy3.example.com:8080:user3:pass3'
   ],
   proxyStrategy: 'failover',  // 推荐使用故障转移策略
-  maxRetries: 3  // 最多重试3次，每次失败会自动轮换代理
+  rotateOnError: true,
+  maxRetries: 3  // 最多重试3次，开启 rotateOnError 后每次上游代理失败会换下一条
 });
 
 // 如果 proxy1 失败，会自动尝试 proxy2，再失败会尝试 proxy3
@@ -810,12 +624,11 @@ const response = await sdk.get('https://api.example.com/data');
 
 **故障检测：**
 
-系统会自动检测以下类型的错误并触发代理轮换：
+`rotateOnError: true` 时，按网关响应体判断上游代理失败并换凭证：
 
-- 连接超时（TimeoutError）
-- 连接被拒绝（ECONNREFUSED）
-- 网络错误（网络相关关键词）
-- HTTP 错误（根据配置）
+- 代理认证失败（407）
+- 响应里带有 proxy / socks / tunnel
+- 状态码 408、502、503，且错误文案是超时、连接被拒绝、域名无法解析
 
 **代理状态管理：**
 
@@ -858,26 +671,6 @@ console.log({
 });
 ```
 
-### 批量插入代理
-
-```typescript
-import { bulkInsertProxyUrls } from 'proxy-pool-manager';
-
-const count = await bulkInsertProxyUrls({
-  mongoUri: 'mongodb://localhost:27017/proxy_db',
-  proxyUrls: [
-    'proxy1.com:8080:user1:pass1',
-    'proxy2.com:8080:user2:pass2',
-    // ... 更多代理
-  ],
-  batchSize: 500,      // 每批处理500个
-  concurrency: 4,      // 并发4个批次
-  logLevel: 'info'
-});
-
-console.log(`成功插入 ${count} 个代理`);
-```
-
 ## 📋 异步队列使用
 
 `AsyncQueueSingleton` 是一个强大的异步任务队列管理器，支持并发控制、优先级任务、多实例等特性。
@@ -1207,24 +1000,6 @@ interface AsyncQueueOptions<T> {
 }
 ```
 
-## 🗄️ MongoDB 数据结构
-
-代理数据存储在 MongoDB 中，集合结构如下：
-
-```typescript
-interface ProxyDocument {
-  url: string;                    // 代理 URL（格式：host:port:username:password）
-  totalRequests: number;          // 总请求数
-  failCount: number;              // 失败次数
-  avgResponseTime: number;        // 平均响应时间（毫秒）
-  lastCheckTime: number;          // 最后检查时间（时间戳）
-  consecutiveFails: number;       // 连续失败次数
-  status: 'valid' | 'invalid';    // 状态
-  createdAt: Date;               // 创建时间
-  updatedAt: Date;               // 更新时间
-}
-```
-
 ## 📝 类型定义
 
 完整的 TypeScript 类型定义已包含在包中：
@@ -1242,24 +1017,10 @@ import type {
 
 ## ⚠️ 注意事项
 
-1. **轻量级模式 vs 完整模式**：
-   - **轻量级模式**：不提供 `mongoUri` 和 `proxyCheckOptions`，不连接 MongoDB，仅使用请求和队列功能
-   - **完整模式**：提供 `mongoUri` 或 `proxyCheckOptions`，启用代理管理功能，需要 MongoDB 连接
-
-2. **MongoDB 连接**：仅在启用代理管理功能时需要，确保 MongoDB 服务正在运行且连接 URI 正确
-
-3. **代理格式**：代理 URL 格式为 `host:port:username:password` 或 `http://host:port:username:password`
-
-4. **代理使用**：
-   - 轻量级模式下，只能通过 `options.proxy` 直接指定代理
-   - 完整模式下，可以自动使用代理管理器选择的代理，也可以直接指定代理（优先级更高）
-
-5. **初始化等待**：SDK 初始化是异步的，使用 `waitForReady()` 确保初始化完成
-
-6. **资源清理**：使用完毕后调用 `destroy()` 方法清理资源
-
-7. **并发限制**：代理检查的并发数可通过 `maxConcurrentChecks` 配置
-
-8. **禁用功能**：
-   - 设置 `proxyCheckEnabled: false` 可禁用代理检查
-   - 设置 `proxyLimit: 0` 可不从数据库加载代理
+1. **代理池**：传入 `proxies` 或 `proxy` 后启用。列表和失败计数只在内存中，进程退出后清空。不传则只发 HTTP 请求。
+2. **代理格式**：`host:port:username:password`，或 `http://user:pass@host:port`
+3. **代理使用**：请求级 `options.proxy` 优先于代理池自动选择；`noProxy: true` 强制直连。
+4. **初始化等待**：SDK 初始化是异步的，使用 `waitForReady()` 确保初始化完成
+5. **资源清理**：使用完毕后调用 `destroy()` 方法清理资源
+6. **并发限制**：代理检查的并发数可通过 `maxConcurrentChecks` 配置
+7. **禁用健康检查**：设置 `proxyCheckEnabled: false`

package/dist/Request.d.ts

@@ -9,6 +9,7 @@ export declare class Request {
     private readonly retryDelay;
     private readonly retryDelayBase;
     private readonly retryDelayMultiplier;
+    private readonly rotateOnError;
     constructor(options?: RequestInitOptions);
     /**
    * 设置日志等级
@@ -53,6 +54,9 @@ export declare class Request {
      * 检查是否启用了代理管理功能
      */
     hasProxyManagement(): boolean;
+    private shouldSwitchCredential;
+    private noteCredentialFailure;
+    private waitBeforeRetry;
 }
 export default Request;
 //# sourceMappingURL=Request.d.ts.map

package/dist/Request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Request.d.ts","sourceRoot":"","sources":["../src/Request.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,YAAY,EAEZ,UAAU,EACV,QAAQ,EACT,MAAM,SAAS,CAAC;AAIjB,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;gBAGlC,OAAO,GAAE,kBAAuB;IAyC5C;;KAEC;IACM,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAUzC;;OAEG;IACI,WAAW,IAAI,QAAQ;IAS9B;;MAEE;IACF,OAAO,CAAC,GAAG;IAiBX,eAAe;YACD,WAAW;IAuCzB;;OAEG;YACW,oBAAoB;IAuGlC,sBAAsB;IACtB,OAAO,CAAC,iBAAiB;IAMZ,GAAG,CAAC,CAAC,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAed,IAAI,CAAC,CAAC,EACjB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAQd,GAAG,CAAC,CAAC,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAQd,MAAM,CAAC,CAAC,EACnB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAQd,KAAK,CAAC,CAAC,EAClB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAQ3B,aAAa;IACA,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE;QAC9B,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,UAAU,CAAC;QACnB,OAAO,EAAE,cAAc,CAAA;KACxB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAyF5B,mBAAmB;IACnB,OAAO,CAAC,aAAa;IAkBd,eAAe,IAAI,MAAM,GAAG,IAAI;IAO1B,WAAW,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAO3C,eAAe,IAAI,IAAI;IAOvB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAOzC,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOlD,uBAAuB,IAAI,MAAM,EAAE;IAO1C;;OAEG;IACI,kBAAkB,IAAI,OAAO;CAGrC;AAED,eAAe,OAAO,CAAC"}
+{"version":3,"file":"Request.d.ts","sourceRoot":"","sources":["../src/Request.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,YAAY,EAEZ,UAAU,EACV,QAAQ,EACT,MAAM,SAAS,CAAC;AAIjB,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;gBAG5B,OAAO,GAAE,kBAAuB;IA0C5C;;KAEC;IACM,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAUzC;;OAEG;IACI,WAAW,IAAI,QAAQ;IAS9B;;MAEE;IACF,OAAO,CAAC,GAAG;IAiBX,eAAe;YACD,WAAW;IAuCzB;;OAEG;YACW,oBAAoB;IAgGlC,sBAAsB;IACtB,OAAO,CAAC,iBAAiB;IAMZ,GAAG,CAAC,CAAC,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAed,IAAI,CAAC,CAAC,EACjB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAQd,GAAG,CAAC,CAAC,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAQd,MAAM,CAAC,CAAC,EACnB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAQd,KAAK,CAAC,CAAC,EAClB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAQ3B,aAAa;IACA,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE;QAC9B,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,UAAU,CAAC;QACnB,OAAO,EAAE,cAAc,CAAA;KACxB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAoF5B,mBAAmB;IACnB,OAAO,CAAC,aAAa;IAkBd,eAAe,IAAI,MAAM,GAAG,IAAI;IAO1B,WAAW,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAO3C,eAAe,IAAI,IAAI;IAOvB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAOzC,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOlD,uBAAuB,IAAI,MAAM,EAAE;IAO1C;;OAEG;IACI,kBAAkB,IAAI,OAAO;IAIpC,OAAO,CAAC,sBAAsB;IAO9B,OAAO,CAAC,qBAAqB;YAMf,eAAe;CAW9B;AAgCD,eAAe,OAAO,CAAC"}