fix: 改进凭据故障转移策略，避免瞬态错误误禁用所有凭据(502错误高负载不禁用凭据, 继续重试) (#15)

* fix: 改进凭据故障转移策略，避免瞬态错误误禁用所有凭据

* fix: 瞬态错误(429/5xx/网络)不切换凭据，保持与eec4f69设计一致

- 网络错误：不切换凭据，只重试+指数退避
- 429/408/5xx：不切换凭据，只重试+指数退避
- 兜底错误：不切换凭据，只重试+指数退避

这与 commit eec4f69 的设计一致：429 high traffic / 502 high load 等
瞬态错误不应切换凭据，因为切换到其他凭据可能遇到同样的上游问题。

---------

Co-authored-by: hank9999 <hank9999@qq.com>

src/kiro/provider.rs

@@ -7,6 +7,8 @@
 use reqwest::Client;
 use reqwest::header::{AUTHORIZATION, CONNECTION, CONTENT_TYPE, HOST, HeaderMap, HeaderValue};
 use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::sleep;
 use uuid::Uuid;
 
 use crate::http_client::{ProxyConfig, build_client};
@@ -123,7 +125,8 @@ impl KiroProvider {
     ///
     /// 支持多凭据故障转移：
     /// - 400 Bad Request: 直接返回错误，不计入凭据失败
-    /// - 其他错误: 计入失败次数，达到阈值后切换凭据重试
+    /// - 401/403: 视为凭据/权限问题，计入失败次数并允许故障转移
+    /// - 429/5xx/网络等瞬态错误: 重试但不禁用或切换凭据（避免误把所有凭据锁死）
     ///
     /// # Arguments
     /// * `request_body` - JSON 格式的请求体字符串
@@ -138,7 +141,8 @@ impl KiroProvider {
     ///
     /// 支持多凭据故障转移：
     /// - 400 Bad Request: 直接返回错误，不计入凭据失败
-    /// - 其他错误: 计入失败次数，达到阈值后切换凭据重试
+    /// - 401/403: 视为凭据/权限问题，计入失败次数并允许故障转移
+    /// - 429/5xx/网络等瞬态错误: 重试但不禁用或切换凭据（避免误把所有凭据锁死）
     ///
     /// # Arguments
     /// * `request_body` - JSON 格式的请求体字符串
@@ -163,6 +167,7 @@ impl KiroProvider {
         let total_credentials = self.token_manager.total_count();
         let max_retries = (total_credentials * MAX_RETRIES_PER_CREDENTIAL).min(MAX_TOTAL_RETRIES);
         let mut last_error: Option<anyhow::Error> = None;
+        let api_type = if is_stream { "流式" } else { "非流式" };
 
         for attempt in 0..max_retries {
             // 获取调用上下文（绑定 index、credentials、token）
@@ -200,11 +205,12 @@ impl KiroProvider {
                         max_retries,
                         e
                     );
-                    // 网络错误，报告失败并重试（使用绑定的 id）
-                    if !self.token_manager.report_failure(ctx.id) {
-                        return Err(e.into());
-                    }
+                    // 网络错误通常是上游/链路瞬态问题，不应导致"禁用凭据"或"切换凭据"
+                    // （否则一段时间网络抖动会把所有凭据都误禁用，需要重启才能恢复）
                     last_error = Some(e.into());
+                    if attempt + 1 < max_retries {
+                        sleep(Self::retry_delay(attempt)).await;
+                    }
                     continue;
                 }
             };
@@ -217,63 +223,75 @@ impl KiroProvider {
                 return Ok(response);
             }
 
-            // 400 Bad Request - 不算凭据错误，直接返回
+            // 失败响应：读取 body 用于日志/错误信息
+            let body = response.text().await.unwrap_or_default();
+
+            // 400 Bad Request - 请求问题，重试/切换凭据无意义
             if status.as_u16() == 400 {
-                let body = response.text().await.unwrap_or_default();
-                let api_type = if is_stream { "流式" } else { "非流式" };
                 anyhow::bail!("{} API 请求失败: {} {}", api_type, status, body);
             }
 
-            // 429 Too Many Requests - 限流错误，不算凭据错误，重试但不禁用凭据
-            if status.as_u16() == 429 {
-                let body = response.text().await.unwrap_or_default();
+            // 401/403 - 更可能是凭据/权限问题：计入失败并允许故障转移
+            if matches!(status.as_u16(), 401 | 403) {
                 tracing::warn!(
-                    "API 请求被限流（尝试 {}/{}）: {} {}",
+                    "API 请求失败（可能为凭据错误，尝试 {}/{}）: {} {}",
                     attempt + 1,
                     max_retries,
                     status,
                     body
                 );
-                last_error = Some(anyhow::anyhow!(
-                    "{} API 请求被限流: {} {}",
-                    if is_stream { "流式" } else { "非流式" },
+
+                let has_available = self.token_manager.report_failure(ctx.id);
+                if !has_available {
+                    anyhow::bail!(
+                        "{} API 请求失败（所有凭据已用尽）: {} {}",
+                        api_type,
+                        status,
+                        body
+                    );
+                }
+
+                last_error = Some(anyhow::anyhow!("{} API 请求失败: {} {}", api_type, status, body));
+                continue;
+            }
+
+            // 429/408/5xx - 瞬态上游错误：重试但不禁用或切换凭据
+            // （避免 429 high traffic / 502 high load 等瞬态错误把所有凭据锁死）
+            if matches!(status.as_u16(), 408 | 429) || status.is_server_error() {
+                tracing::warn!(
+                    "API 请求失败（上游瞬态错误，尝试 {}/{}）: {} {}",
+                    attempt + 1,
+                    max_retries,
                     status,
                     body
-                ));
+                );
+                last_error = Some(anyhow::anyhow!("{} API 请求失败: {} {}", api_type, status, body));
+                if attempt + 1 < max_retries {
+                    sleep(Self::retry_delay(attempt)).await;
+                }
                 continue;
             }
 
-            // 其他错误 - 记录失败并可能重试（使用绑定的 id）
-            let body = response.text().await.unwrap_or_default();
+            // 其他 4xx - 通常为请求/配置问题：直接返回，不计入凭据失败
+            if status.is_client_error() {
+                anyhow::bail!("{} API 请求失败: {} {}", api_type, status, body);
+            }
+
+            // 兜底：当作可重试的瞬态错误处理（不切换凭据）
             tracing::warn!(
-                "API 请求失败（尝试 {}/{}）: {} {}",
+                "API 请求失败（未知错误，尝试 {}/{}）: {} {}",
                 attempt + 1,
                 max_retries,
                 status,
                 body
             );
-
-            let has_available = self.token_manager.report_failure(ctx.id);
-            if !has_available {
-                let api_type = if is_stream { "流式" } else { "非流式" };
-                anyhow::bail!(
-                    "{} API 请求失败（所有凭据已用尽）: {} {}",
-                    api_type,
-                    status,
-                    body
-                );
+            last_error = Some(anyhow::anyhow!("{} API 请求失败: {} {}", api_type, status, body));
+            if attempt + 1 < max_retries {
+                sleep(Self::retry_delay(attempt)).await;
             }
-
-            last_error = Some(anyhow::anyhow!(
-                "{} API 请求失败: {} {}",
-                if is_stream { "流式" } else { "非流式" },
-                status,
-                body
-            ));
         }
 
         // 所有重试都失败
-        let api_type = if is_stream { "流式" } else { "非流式" };
         Err(last_error.unwrap_or_else(|| {
             anyhow::anyhow!(
                 "{} API 请求失败：已达到最大重试次数（{}次）",
@@ -282,6 +300,17 @@ impl KiroProvider {
             )
         }))
     }
+
+    fn retry_delay(attempt: usize) -> Duration {
+        // 指数退避 + 少量抖动，避免上游抖动时放大故障
+        const BASE_MS: u64 = 200;
+        const MAX_MS: u64 = 2_000;
+        let exp = BASE_MS.saturating_mul(2u64.saturating_pow(attempt.min(6) as u32));
+        let backoff = exp.min(MAX_MS);
+        let jitter_max = (backoff / 4).max(1);
+        let jitter = fastrand::u64(0..=jitter_max);
+        Duration::from_millis(backoff.saturating_add(jitter))
+    }
 }
 
 #[cfg(test)]

src/kiro/token_manager.rs

@@ -373,6 +373,17 @@ struct CredentialEntry {
     failure_count: u32,
     /// 是否已禁用
     disabled: bool,
+    /// 禁用原因（用于区分手动禁用 vs 自动禁用，便于自愈）
+    disabled_reason: Option<DisabledReason>,
+}
+
+/// 禁用原因
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum DisabledReason {
+    /// Admin API 手动禁用
+    Manual,
+    /// 连续失败达到阈值后自动禁用
+    TooManyFailures,
 }
 
 // ============================================================================
@@ -485,6 +496,7 @@ impl MultiTokenManager {
                     credentials: cred,
                     failure_count: 0,
                     disabled: false,
+                    disabled_reason: None,
                 }
             })
             .collect();
@@ -577,7 +589,7 @@ impl MultiTokenManager {
             }
 
             let (id, credentials) = {
-                let entries = self.entries.lock();
+                let mut entries = self.entries.lock();
                 let current_id = *self.current_id.lock();
 
                 // 找到当前凭据
@@ -585,11 +597,34 @@ impl MultiTokenManager {
                     (entry.id, entry.credentials.clone())
                 } else {
                     // 当前凭据不可用，选择优先级最高的可用凭据
-                    if let Some(entry) = entries
+                    let mut best = entries
                         .iter()
                         .filter(|e| !e.disabled)
-                        .min_by_key(|e| e.credentials.priority)
+                        .min_by_key(|e| e.credentials.priority);
+
+                    // 没有可用凭据：如果是“自动禁用导致全灭”，做一次类似重启的自愈
+                    if best.is_none()
+                        && entries.iter().any(|e| {
+                            e.disabled && e.disabled_reason == Some(DisabledReason::TooManyFailures)
+                        })
                     {
+                        tracing::warn!(
+                            "所有凭据均已被自动禁用，执行自愈：重置失败计数并重新启用（等价于重启）"
+                        );
+                        for e in entries.iter_mut() {
+                            if e.disabled_reason == Some(DisabledReason::TooManyFailures) {
+                                e.disabled = false;
+                                e.disabled_reason = None;
+                                e.failure_count = 0;
+                            }
+                        }
+                        best = entries
+                            .iter()
+                            .filter(|e| !e.disabled)
+                            .min_by_key(|e| e.credentials.priority);
+                    }
+
+                    if let Some(entry) = best {
                         // 先提取数据
                         let new_id = entry.id;
                         let new_creds = entry.credentials.clone();
@@ -829,6 +864,7 @@ impl MultiTokenManager {
 
         if failure_count >= MAX_FAILURES_PER_CREDENTIAL {
             entry.disabled = true;
+            entry.disabled_reason = Some(DisabledReason::TooManyFailures);
             tracing::error!("凭据 #{} 已连续失败 {} 次，已被禁用", id, failure_count);
 
             // 切换到优先级最高的可用凭据
@@ -932,6 +968,9 @@ impl MultiTokenManager {
             if !disabled {
                 // 启用时重置失败计数
                 entry.failure_count = 0;
+                entry.disabled_reason = None;
+            } else {
+                entry.disabled_reason = Some(DisabledReason::Manual);
             }
         }
         // 持久化更改
@@ -969,6 +1008,7 @@ impl MultiTokenManager {
                 .ok_or_else(|| anyhow::anyhow!("凭据不存在: {}", id))?;
             entry.failure_count = 0;
             entry.disabled = false;
+            entry.disabled_reason = None;
         }
         // 持久化更改
         self.persist_credentials()?;
@@ -1079,6 +1119,7 @@ impl MultiTokenManager {
                 credentials: validated_cred,
                 failure_count: 0,
                 disabled: false,
+                disabled_reason: None,
             });
         }
 
@@ -1340,4 +1381,33 @@ mod tests {
             Some("token2".to_string())
         );
     }
+
+    #[tokio::test]
+    async fn test_multi_token_manager_acquire_context_auto_recovers_all_disabled() {
+        let config = Config::default();
+        let mut cred1 = KiroCredentials::default();
+        cred1.access_token = Some("t1".to_string());
+        cred1.expires_at = Some((Utc::now() + Duration::hours(1)).to_rfc3339());
+        let mut cred2 = KiroCredentials::default();
+        cred2.access_token = Some("t2".to_string());
+        cred2.expires_at = Some((Utc::now() + Duration::hours(1)).to_rfc3339());
+
+        let manager =
+            MultiTokenManager::new(config, vec![cred1, cred2], None, None, false).unwrap();
+
+        // 凭据会自动分配 ID（从 1 开始）
+        for _ in 0..MAX_FAILURES_PER_CREDENTIAL {
+            manager.report_failure(1);
+        }
+        for _ in 0..MAX_FAILURES_PER_CREDENTIAL {
+            manager.report_failure(2);
+        }
+
+        assert_eq!(manager.available_count(), 0);
+
+        // 应触发自愈：重置失败计数并重新启用，避免必须重启进程
+        let ctx = manager.acquire_context().await.unwrap();
+        assert!(ctx.token == "t1" || ctx.token == "t2");
+        assert_eq!(manager.available_count(), 2);
+    }
 }