feat(proxy): fix thinking rectifiers and resolve clippy warnings (#1005)

* feat(proxy): align thinking rectifiers and resolve clippy warnings

- add thinking budget rectifier flow with single retry on anthropic budget errors

- align thinking signature rectification behavior with adaptive-safe handling

- expose requestThinkingBudget in settings/ui/i18n and default rectifier config to disabled

- fix clippy warnings in model_mapper format args and RectifierConfig default derive

* fix(proxy): thinking rectifiers

src-tauri/src/database/dao/settings.rs

@@ -168,7 +168,7 @@ impl Database {
 
     /// 获取整流器配置
     ///
-    /// 返回整流器配置，如果不存在则返回默认值（全部启用）
+    /// 返回整流器配置，如果不存在则返回默认值（全部开启）
     pub fn get_rectifier_config(&self) -> Result<crate::proxy::types::RectifierConfig, AppError> {
         match self.get_setting("rectifier_config")? {
             Some(json) => serde_json::from_str(&json)

src-tauri/src/proxy/forwarder.rs

@@ -8,7 +8,10 @@ use super::{
     failover_switch::FailoverSwitchManager,
     provider_router::ProviderRouter,
     providers::{get_adapter, ProviderAdapter, ProviderType},
-    thinking_rectifier::{rectify_anthropic_request, should_rectify_thinking_signature},
+    thinking_budget_rectifier::{rectify_thinking_budget, should_rectify_thinking_budget},
+    thinking_rectifier::{
+        normalize_thinking_type, rectify_anthropic_request, should_rectify_thinking_signature,
+    },
     types::{ProxyStatus, RectifierConfig},
     ProxyError,
 };
@@ -157,6 +160,7 @@ impl RequestForwarder {
 
         // 整流器重试标记：确保整流最多触发一次
         let mut rectifier_retried = false;
+        let mut budget_rectifier_retried = false;
 
         // 单 Provider 场景下跳过熔断器检查（故障转移关闭时）
         let bypass_circuit_breaker = providers.len() == 1;
@@ -258,6 +262,7 @@ impl RequestForwarder {
                         provider_type,
                         ProviderType::Claude | ProviderType::ClaudeAuth
                     );
+                    let mut signature_rectifier_non_retryable_client_error = false;
 
                     if is_anthropic_provider {
                         let error_message = extract_error_message(&e);
@@ -293,12 +298,185 @@ impl RequestForwarder {
                             // 首次触发：整流请求体
                             let rectified = rectify_anthropic_request(&mut body);
 
-                            // 整流未生效：直接返回错误（不可重试客户端错误）
+                            // 整流未生效：继续尝试 budget 整流路径，避免误判后短路
                             if !rectified.applied {
                                 log::warn!(
-                                    "[{app_type_str}] [RECT-006] 整流器触发但无可整流内容，不做无意义重试"
+                                    "[{app_type_str}] [RECT-006] thinking 签名整流器触发但无可整流内容，继续检查 budget；若 budget 也未命中则按客户端错误返回"
+                                );
+                                signature_rectifier_non_retryable_client_error = true;
+                            } else {
+                                log::info!(
+                                    "[{}] [RECT-001] thinking 签名整流器触发, 移除 {} thinking blocks, {} redacted_thinking blocks, {} signature fields",
+                                    app_type_str,
+                                    rectified.removed_thinking_blocks,
+                                    rectified.removed_redacted_thinking_blocks,
+                                    rectified.removed_signature_fields
+                                );
+
+                                // 标记已重试（当前逻辑下重试后必定 return，保留标记以备将来扩展）
+                                let _ = std::mem::replace(&mut rectifier_retried, true);
+
+                                // 使用同一供应商重试（不计入熔断器）
+                                match self
+                                    .forward(provider, endpoint, &body, &headers, adapter.as_ref())
+                                    .await
+                                {
+                                    Ok(response) => {
+                                        log::info!("[{app_type_str}] [RECT-002] 整流重试成功");
+                                        // 记录成功
+                                        let _ = self
+                                            .router
+                                            .record_result(
+                                                &provider.id,
+                                                app_type_str,
+                                                used_half_open_permit,
+                                                true,
+                                                None,
+                                            )
+                                            .await;
+
+                                        // 更新当前应用类型使用的 provider
+                                        {
+                                            let mut current_providers =
+                                                self.current_providers.write().await;
+                                            current_providers.insert(
+                                                app_type_str.to_string(),
+                                                (provider.id.clone(), provider.name.clone()),
+                                            );
+                                        }
+
+                                        // 更新成功统计
+                                        {
+                                            let mut status = self.status.write().await;
+                                            status.success_requests += 1;
+                                            status.last_error = None;
+                                            let should_switch =
+                                                self.current_provider_id_at_start.as_str()
+                                                    != provider.id.as_str();
+                                            if should_switch {
+                                                status.failover_count += 1;
+
+                                                // 异步触发供应商切换，更新 UI/托盘
+                                                let fm = self.failover_manager.clone();
+                                                let ah = self.app_handle.clone();
+                                                let pid = provider.id.clone();
+                                                let pname = provider.name.clone();
+                                                let at = app_type_str.to_string();
+
+                                                tokio::spawn(async move {
+                                                    let _ = fm
+                                                        .try_switch(ah.as_ref(), &at, &pid, &pname)
+                                                        .await;
+                                                });
+                                            }
+                                            if status.total_requests > 0 {
+                                                status.success_rate = (status.success_requests
+                                                    as f32
+                                                    / status.total_requests as f32)
+                                                    * 100.0;
+                                            }
+                                        }
+
+                                        return Ok(ForwardResult {
+                                            response,
+                                            provider: provider.clone(),
+                                        });
+                                    }
+                                    Err(retry_err) => {
+                                        // 整流重试仍失败：区分错误类型决定是否记录熔断器
+                                        log::warn!(
+                                            "[{app_type_str}] [RECT-003] 整流重试仍失败: {retry_err}"
+                                        );
+
+                                        // 区分错误类型：Provider 问题记录失败，客户端问题仅释放 permit
+                                        let is_provider_error = match &retry_err {
+                                            ProxyError::Timeout(_)
+                                            | ProxyError::ForwardFailed(_) => true,
+                                            ProxyError::UpstreamError { status, .. } => {
+                                                *status >= 500
+                                            }
+                                            _ => false,
+                                        };
+
+                                        if is_provider_error {
+                                            // Provider 问题：记录失败到熔断器
+                                            let _ = self
+                                                .router
+                                                .record_result(
+                                                    &provider.id,
+                                                    app_type_str,
+                                                    used_half_open_permit,
+                                                    false,
+                                                    Some(retry_err.to_string()),
+                                                )
+                                                .await;
+                                        } else {
+                                            // 客户端问题：仅释放 permit，不记录熔断器
+                                            self.router
+                                                .release_permit_neutral(
+                                                    &provider.id,
+                                                    app_type_str,
+                                                    used_half_open_permit,
+                                                )
+                                                .await;
+                                        }
+
+                                        let mut status = self.status.write().await;
+                                        status.failed_requests += 1;
+                                        status.last_error = Some(retry_err.to_string());
+                                        if status.total_requests > 0 {
+                                            status.success_rate = (status.success_requests as f32
+                                                / status.total_requests as f32)
+                                                * 100.0;
+                                        }
+                                        return Err(ForwardError {
+                                            error: retry_err,
+                                            provider: Some(provider.clone()),
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    // 检测是否需要触发 budget 整流器（仅 Claude/ClaudeAuth 供应商）
+                    if is_anthropic_provider {
+                        let error_message = extract_error_message(&e);
+                        if should_rectify_thinking_budget(
+                            error_message.as_deref(),
+                            &self.rectifier_config,
+                        ) {
+                            // 已经重试过：直接返回错误（不可重试客户端错误）
+                            if budget_rectifier_retried {
+                                log::warn!(
+                                    "[{app_type_str}] [RECT-013] budget 整流器已触发过，不再重试"
+                                );
+                                self.router
+                                    .release_permit_neutral(
+                                        &provider.id,
+                                        app_type_str,
+                                        used_half_open_permit,
+                                    )
+                                    .await;
+                                let mut status = self.status.write().await;
+                                status.failed_requests += 1;
+                                status.last_error = Some(e.to_string());
+                                if status.total_requests > 0 {
+                                    status.success_rate = (status.success_requests as f32
+                                        / status.total_requests as f32)
+                                        * 100.0;
+                                }
+                                return Err(ForwardError {
+                                    error: e,
+                                    provider: Some(provider.clone()),
+                                });
+                            }
+
+                            let budget_rectified = rectify_thinking_budget(&mut body);
+                            if !budget_rectified.applied {
+                                log::warn!(
+                                    "[{app_type_str}] [RECT-014] budget 整流器触发但无可整流内容，不做无意义重试"
                                 );
-                                // 释放 HalfOpen permit（不记录熔断器，这是客户端兼容性问题）
                                 self.router
                                     .release_permit_neutral(
                                         &provider.id,
@@ -321,15 +499,13 @@ impl RequestForwarder {
                             }
 
                             log::info!(
-                                "[{}] [RECT-001] thinking 签名整流器触发, 移除 {} thinking blocks, {} redacted_thinking blocks, {} signature fields",
+                                "[{}] [RECT-010] thinking budget 整流器触发, before={:?}, after={:?}",
                                 app_type_str,
-                                rectified.removed_thinking_blocks,
-                                rectified.removed_redacted_thinking_blocks,
-                                rectified.removed_signature_fields
+                                budget_rectified.before,
+                                budget_rectified.after
                             );
 
-                            // 标记已重试（当前逻辑下重试后必定 return，保留标记以备将来扩展）
-                            let _ = std::mem::replace(&mut rectifier_retried, true);
+                            let _ = std::mem::replace(&mut budget_rectifier_retried, true);
 
                             // 使用同一供应商重试（不计入熔断器）
                             match self
@@ -337,8 +513,7 @@ impl RequestForwarder {
                                 .await
                             {
                                 Ok(response) => {
-                                    log::info!("[{app_type_str}] [RECT-002] 整流重试成功");
-                                    // 记录成功
+                                    log::info!("[{app_type_str}] [RECT-011] budget 整流重试成功");
                                     let _ = self
                                         .router
                                         .record_result(
@@ -350,7 +525,6 @@ impl RequestForwarder {
                                         )
                                         .await;
 
-                                    // 更新当前应用类型使用的 provider
                                     {
                                         let mut current_providers =
                                             self.current_providers.write().await;
@@ -360,7 +534,6 @@ impl RequestForwarder {
                                         );
                                     }
 
-                                    // 更新成功统计
                                     {
                                         let mut status = self.status.write().await;
                                         status.success_requests += 1;
@@ -370,14 +543,11 @@ impl RequestForwarder {
                                                 != provider.id.as_str();
                                         if should_switch {
                                             status.failover_count += 1;
-
-                                            // 异步触发供应商切换，更新 UI/托盘
                                             let fm = self.failover_manager.clone();
                                             let ah = self.app_handle.clone();
                                             let pid = provider.id.clone();
                                             let pname = provider.name.clone();
                                             let at = app_type_str.to_string();
-
                                             tokio::spawn(async move {
                                                 let _ = fm
                                                     .try_switch(ah.as_ref(), &at, &pid, &pname)
@@ -397,12 +567,10 @@ impl RequestForwarder {
                                     });
                                 }
                                 Err(retry_err) => {
-                                    // 整流重试仍失败：区分错误类型决定是否记录熔断器
                                     log::warn!(
-                                        "[{app_type_str}] [RECT-003] 整流重试仍失败: {retry_err}"
+                                        "[{app_type_str}] [RECT-012] budget 整流重试仍失败: {retry_err}"
                                     );
 
-                                    // 区分错误类型：Provider 问题记录失败，客户端问题仅释放 permit
                                     let is_provider_error = match &retry_err {
                                         ProxyError::Timeout(_) | ProxyError::ForwardFailed(_) => {
                                             true
@@ -412,7 +580,6 @@ impl RequestForwarder {
                                     };
 
                                     if is_provider_error {
-                                        // Provider 问题：记录失败到熔断器
                                         let _ = self
                                             .router
                                             .record_result(
@@ -424,7 +591,6 @@ impl RequestForwarder {
                                             )
                                             .await;
                                     } else {
-                                        // 客户端问题：仅释放 permit，不记录熔断器
                                         self.router
                                             .release_permit_neutral(
                                                 &provider.id,
@@ -451,6 +617,28 @@ impl RequestForwarder {
                         }
                     }
 
+                    if signature_rectifier_non_retryable_client_error {
+                        self.router
+                            .release_permit_neutral(
+                                &provider.id,
+                                app_type_str,
+                                used_half_open_permit,
+                            )
+                            .await;
+                        let mut status = self.status.write().await;
+                        status.failed_requests += 1;
+                        status.last_error = Some(e.to_string());
+                        if status.total_requests > 0 {
+                            status.success_rate = (status.success_requests as f32
+                                / status.total_requests as f32)
+                                * 100.0;
+                        }
+                        return Err(ForwardError {
+                            error: e,
+                            provider: Some(provider.clone()),
+                        });
+                    }
+
                     // 失败：记录失败并更新熔断器
                     let _ = self
                         .router
@@ -575,6 +763,9 @@ impl RequestForwarder {
         let (mapped_body, _original_model, _mapped_model) =
             super::model_mapper::apply_model_mapping(body.clone(), provider);
 
+        // 与 CCH 对齐：请求前不做 thinking 主动改写（仅保留兼容入口）
+        let mapped_body = normalize_thinking_type(mapped_body);
+
         // 转换请求体（如果需要）
         let request_body = if needs_transform {
             adapter.transform_request(mapped_body, provider)?

src-tauri/src/proxy/mod.rs

@@ -21,6 +21,7 @@ pub mod response_handler;
 pub mod response_processor;
 pub(crate) mod server;
 pub mod session;
+pub mod thinking_budget_rectifier;
 pub mod thinking_rectifier;
 pub(crate) mod types;
 pub mod usage;

src-tauri/src/proxy/model_mapper.rs

@@ -97,11 +97,21 @@ impl ModelMapping {
 
 /// 检测请求是否启用了 thinking 模式
 pub fn has_thinking_enabled(body: &Value) -> bool {
-    body.get("thinking")
+    match body
+        .get("thinking")
         .and_then(|v| v.as_object())
         .and_then(|o| o.get("type"))
         .and_then(|t| t.as_str())
-        == Some("enabled")
+    {
+        Some("enabled") | Some("adaptive") => true,
+        Some("disabled") | None => false,
+        Some(other) => {
+            log::warn!(
+                "[ModelMapper] 未知 thinking.type='{other}'，按 disabled 处理以避免误路由 reasoning 模型"
+            );
+            false
+        }
+    }
 }
 
 /// 对请求体应用模型映射
@@ -300,6 +310,30 @@ mod tests {
         assert!(mapped.is_none());
     }
 
+    #[test]
+    fn test_thinking_adaptive() {
+        let provider = create_provider_with_mapping();
+        let body = json!({
+            "model": "claude-sonnet-4-5",
+            "thinking": {"type": "adaptive"}
+        });
+        let (result, _, mapped) = apply_model_mapping(body, &provider);
+        assert_eq!(result["model"], "reasoning-model");
+        assert_eq!(mapped, Some("reasoning-model".to_string()));
+    }
+
+    #[test]
+    fn test_thinking_unknown_type() {
+        let provider = create_provider_with_mapping();
+        let body = json!({
+            "model": "claude-sonnet-4-5",
+            "thinking": {"type": "some_future_type"}
+        });
+        let (result, _, mapped) = apply_model_mapping(body, &provider);
+        assert_eq!(result["model"], "sonnet-mapped");
+        assert_eq!(mapped, Some("sonnet-mapped".to_string()));
+    }
+
     #[test]
     fn test_case_insensitive() {
         let provider = create_provider_with_mapping();

src-tauri/src/proxy/thinking_budget_rectifier.rs

@@ -0,0 +1,359 @@
+//! Thinking Budget 整流器
+//!
+//! 用于自动修复 Anthropic API 中因 thinking budget 约束导致的请求错误。
+//! 当上游 API 返回 budget_tokens 相关错误时，系统会自动调整 budget 参数并重试。
+
+use super::types::RectifierConfig;
+use serde_json::Value;
+
+/// 最大 thinking budget tokens
+const MAX_THINKING_BUDGET: u64 = 32000;
+
+/// 最大 max_tokens 值
+const MAX_TOKENS_VALUE: u64 = 64000;
+
+/// max_tokens 必须大于 budget_tokens
+const MIN_MAX_TOKENS_FOR_BUDGET: u64 = MAX_THINKING_BUDGET + 1;
+
+/// Budget 整流结果
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct BudgetRectifySnapshot {
+    /// max_tokens
+    pub max_tokens: Option<u64>,
+    /// thinking.type
+    pub thinking_type: Option<String>,
+    /// thinking.budget_tokens
+    pub thinking_budget_tokens: Option<u64>,
+}
+
+/// Budget 整流结果
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct BudgetRectifyResult {
+    /// 是否应用了整流
+    pub applied: bool,
+    /// 整流前快照
+    pub before: BudgetRectifySnapshot,
+    /// 整流后快照
+    pub after: BudgetRectifySnapshot,
+}
+
+/// 检测是否需要触发 thinking budget 整流器
+///
+/// 检测条件：error message 同时包含 `budget_tokens` + `thinking` 相关约束
+pub fn should_rectify_thinking_budget(
+    error_message: Option<&str>,
+    config: &RectifierConfig,
+) -> bool {
+    // 检查总开关
+    if !config.enabled {
+        return false;
+    }
+    // 检查子开关
+    if !config.request_thinking_budget {
+        return false;
+    }
+
+    let Some(msg) = error_message else {
+        return false;
+    };
+    let lower = msg.to_lowercase();
+
+    // 与 CCH 对齐：仅在包含 budget_tokens + thinking + 1024 约束时触发
+    let has_budget_tokens_reference =
+        lower.contains("budget_tokens") || lower.contains("budget tokens");
+    let has_thinking_reference = lower.contains("thinking");
+    let has_1024_constraint = lower.contains("greater than or equal to 1024")
+        || lower.contains(">= 1024")
+        || (lower.contains("1024") && lower.contains("input should be"));
+    if has_budget_tokens_reference && has_thinking_reference && has_1024_constraint {
+        return true;
+    }
+
+    false
+}
+
+/// 对请求体执行 budget 整流
+///
+/// 整流动作：
+/// - `thinking.type = "enabled"`
+/// - `thinking.budget_tokens = 32000`
+/// - 如果 `max_tokens < 32001`，设为 `64000`
+pub fn rectify_thinking_budget(body: &mut Value) -> BudgetRectifyResult {
+    let before = snapshot_budget(body);
+
+    // 与 CCH 对齐：adaptive 请求不改写
+    if before.thinking_type.as_deref() == Some("adaptive") {
+        return BudgetRectifyResult {
+            applied: false,
+            before: before.clone(),
+            after: before,
+        };
+    }
+
+    // 与 CCH 对齐：缺少/非法 thinking 时自动创建后再整流
+    if !body.get("thinking").is_some_and(Value::is_object) {
+        body["thinking"] = Value::Object(serde_json::Map::new());
+    }
+
+    let Some(thinking) = body.get_mut("thinking").and_then(|t| t.as_object_mut()) else {
+        return BudgetRectifyResult {
+            applied: false,
+            before: before.clone(),
+            after: before,
+        };
+    };
+
+    thinking.insert("type".to_string(), Value::String("enabled".to_string()));
+    thinking.insert(
+        "budget_tokens".to_string(),
+        Value::Number(MAX_THINKING_BUDGET.into()),
+    );
+
+    if before.max_tokens.is_none() || before.max_tokens < Some(MIN_MAX_TOKENS_FOR_BUDGET) {
+        body["max_tokens"] = Value::Number(MAX_TOKENS_VALUE.into());
+    }
+
+    let after = snapshot_budget(body);
+    BudgetRectifyResult {
+        applied: before != after,
+        before,
+        after,
+    }
+}
+
+fn snapshot_budget(body: &Value) -> BudgetRectifySnapshot {
+    let max_tokens = body.get("max_tokens").and_then(|v| v.as_u64());
+    let thinking = body.get("thinking").and_then(|t| t.as_object());
+    let thinking_type = thinking
+        .and_then(|t| t.get("type"))
+        .and_then(|v| v.as_str())
+        .map(ToString::to_string);
+    let thinking_budget_tokens = thinking
+        .and_then(|t| t.get("budget_tokens"))
+        .and_then(|v| v.as_u64());
+    BudgetRectifySnapshot {
+        max_tokens,
+        thinking_type,
+        thinking_budget_tokens,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn enabled_config() -> RectifierConfig {
+        RectifierConfig {
+            enabled: true,
+            request_thinking_signature: true,
+            request_thinking_budget: true,
+        }
+    }
+
+    fn budget_disabled_config() -> RectifierConfig {
+        RectifierConfig {
+            enabled: true,
+            request_thinking_signature: true,
+            request_thinking_budget: false,
+        }
+    }
+
+    fn master_disabled_config() -> RectifierConfig {
+        RectifierConfig {
+            enabled: false,
+            request_thinking_signature: true,
+            request_thinking_budget: true,
+        }
+    }
+
+    // ==================== should_rectify_thinking_budget 测试 ====================
+
+    #[test]
+    fn test_detect_budget_tokens_thinking_error() {
+        assert!(should_rectify_thinking_budget(
+            Some("thinking.budget_tokens: Input should be greater than or equal to 1024"),
+            &enabled_config()
+        ));
+    }
+
+    #[test]
+    fn test_detect_budget_tokens_max_tokens_error() {
+        assert!(!should_rectify_thinking_budget(
+            Some("budget_tokens must be less than max_tokens"),
+            &enabled_config()
+        ));
+    }
+
+    #[test]
+    fn test_detect_budget_tokens_1024_error() {
+        assert!(!should_rectify_thinking_budget(
+            Some("budget_tokens: value must be at least 1024"),
+            &enabled_config()
+        ));
+    }
+
+    #[test]
+    fn test_detect_budget_tokens_with_thinking_and_1024_error() {
+        assert!(should_rectify_thinking_budget(
+            Some("thinking budget_tokens must be >= 1024"),
+            &enabled_config()
+        ));
+    }
+
+    #[test]
+    fn test_no_trigger_for_unrelated_error() {
+        assert!(!should_rectify_thinking_budget(
+            Some("Request timeout"),
+            &enabled_config()
+        ));
+        assert!(!should_rectify_thinking_budget(None, &enabled_config()));
+    }
+
+    #[test]
+    fn test_disabled_budget_config() {
+        assert!(!should_rectify_thinking_budget(
+            Some("thinking.budget_tokens: Input should be greater than or equal to 1024"),
+            &budget_disabled_config()
+        ));
+    }
+
+    #[test]
+    fn test_master_disabled() {
+        assert!(!should_rectify_thinking_budget(
+            Some("thinking.budget_tokens: Input should be greater than or equal to 1024"),
+            &master_disabled_config()
+        ));
+    }
+
+    // ==================== rectify_thinking_budget 测试 ====================
+
+    #[test]
+    fn test_rectify_budget_basic() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "enabled", "budget_tokens": 512 },
+            "max_tokens": 1024
+        });
+
+        let result = rectify_thinking_budget(&mut body);
+
+        assert!(result.applied);
+        assert_eq!(result.before.thinking_type.as_deref(), Some("enabled"));
+        assert_eq!(result.after.thinking_type.as_deref(), Some("enabled"));
+        assert_eq!(result.before.thinking_budget_tokens, Some(512));
+        assert_eq!(
+            result.after.thinking_budget_tokens,
+            Some(MAX_THINKING_BUDGET)
+        );
+        assert_eq!(result.before.max_tokens, Some(1024));
+        assert_eq!(result.after.max_tokens, Some(MAX_TOKENS_VALUE));
+        assert_eq!(body["thinking"]["type"], "enabled");
+        assert_eq!(body["thinking"]["budget_tokens"], MAX_THINKING_BUDGET);
+        assert_eq!(body["max_tokens"], MAX_TOKENS_VALUE);
+    }
+
+    #[test]
+    fn test_rectify_budget_skips_adaptive() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "adaptive", "budget_tokens": 512 },
+            "max_tokens": 1024
+        });
+
+        let result = rectify_thinking_budget(&mut body);
+
+        assert!(!result.applied);
+        assert_eq!(result.before, result.after);
+        assert_eq!(body["thinking"]["type"], "adaptive");
+        assert_eq!(body["thinking"]["budget_tokens"], 512);
+        assert_eq!(body["max_tokens"], 1024);
+    }
+
+    #[test]
+    fn test_rectify_budget_preserves_large_max_tokens() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "enabled", "budget_tokens": 512 },
+            "max_tokens": 100000
+        });
+
+        let result = rectify_thinking_budget(&mut body);
+
+        assert!(result.applied);
+        assert_eq!(result.before.max_tokens, Some(100000));
+        assert_eq!(result.after.max_tokens, Some(100000));
+        assert_eq!(body["max_tokens"], 100000);
+    }
+
+    #[test]
+    fn test_rectify_budget_creates_thinking_object_when_missing() {
+        let mut body = json!({
+            "model": "claude-test",
+            "max_tokens": 1024
+        });
+
+        let result = rectify_thinking_budget(&mut body);
+
+        assert!(result.applied);
+        assert_eq!(result.before.thinking_type, None);
+        assert_eq!(result.after.thinking_type.as_deref(), Some("enabled"));
+        assert_eq!(
+            result.after.thinking_budget_tokens,
+            Some(MAX_THINKING_BUDGET)
+        );
+        assert_eq!(result.after.max_tokens, Some(MAX_TOKENS_VALUE));
+        assert_eq!(body["thinking"]["type"], "enabled");
+        assert_eq!(body["thinking"]["budget_tokens"], MAX_THINKING_BUDGET);
+        assert_eq!(body["max_tokens"], MAX_TOKENS_VALUE);
+    }
+
+    #[test]
+    fn test_rectify_budget_no_max_tokens() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "enabled", "budget_tokens": 512 }
+        });
+
+        let result = rectify_thinking_budget(&mut body);
+
+        assert!(result.applied);
+        assert_eq!(result.before.max_tokens, None);
+        assert_eq!(result.after.max_tokens, Some(MAX_TOKENS_VALUE));
+        assert_eq!(body["max_tokens"], MAX_TOKENS_VALUE);
+    }
+
+    #[test]
+    fn test_rectify_budget_normalizes_non_enabled_type() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "disabled", "budget_tokens": 512 },
+            "max_tokens": 1024
+        });
+
+        let result = rectify_thinking_budget(&mut body);
+
+        assert!(result.applied);
+        assert_eq!(result.before.thinking_type.as_deref(), Some("disabled"));
+        assert_eq!(result.after.thinking_type.as_deref(), Some("enabled"));
+        assert_eq!(body["thinking"]["type"], "enabled");
+        assert_eq!(body["thinking"]["budget_tokens"], MAX_THINKING_BUDGET);
+        assert_eq!(body["max_tokens"], MAX_TOKENS_VALUE);
+    }
+
+    #[test]
+    fn test_rectify_budget_no_change_when_already_valid() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "enabled", "budget_tokens": 32000 },
+            "max_tokens": 64001
+        });
+
+        let result = rectify_thinking_budget(&mut body);
+
+        assert!(!result.applied);
+        assert_eq!(result.before, result.after);
+        assert_eq!(body["thinking"]["budget_tokens"], 32000);
+        assert_eq!(body["max_tokens"], 64001);
+    }
+}

src-tauri/src/proxy/thinking_rectifier.rs

@@ -59,10 +59,12 @@ pub fn should_rectify_thinking_signature(
     }
 
     // 场景3: expected thinking or redacted_thinking, found tool_use
+    // 与 CCH 对齐：要求明确包含 tool_use，避免过宽匹配。
     // 错误示例: "Expected `thinking` or `redacted_thinking`, but found `tool_use`"
     if lower.contains("expected")
         && (lower.contains("thinking") || lower.contains("redacted_thinking"))
         && lower.contains("found")
+        && lower.contains("tool_use")
     {
         return true;
     }
@@ -73,6 +75,28 @@ pub fn should_rectify_thinking_signature(
         return true;
     }
 
+    // 场景5: signature 字段不被接受（第三方渠道）
+    // 错误示例: "xxx.signature: Extra inputs are not permitted"
+    if lower.contains("signature") && lower.contains("extra inputs are not permitted") {
+        return true;
+    }
+
+    // 场景6: thinking/redacted_thinking 块被修改
+    // 错误示例: "thinking or redacted_thinking blocks ... cannot be modified"
+    if (lower.contains("thinking") || lower.contains("redacted_thinking"))
+        && lower.contains("cannot be modified")
+    {
+        return true;
+    }
+
+    // 场景7: 非法请求（与 CCH 对齐，按 invalid request 统一兜底）
+    if lower.contains("非法请求")
+        || lower.contains("illegal request")
+        || lower.contains("invalid request")
+    {
+        return true;
+    }
+
     false
 }
 
@@ -159,11 +183,13 @@ pub fn rectify_anthropic_request(body: &mut Value) -> RectifyResult {
 /// 判断是否需要删除顶层 thinking 字段
 fn should_remove_top_level_thinking(body: &Value, messages: &[Value]) -> bool {
     // 检查 thinking 是否启用
-    let thinking_enabled = body
+    let thinking_type = body
         .get("thinking")
         .and_then(|t| t.get("type"))
-        .and_then(|t| t.as_str())
-        == Some("enabled");
+        .and_then(|t| t.as_str());
+
+    // 与 CCH 对齐：仅 type=enabled 视为开启
+    let thinking_enabled = thinking_type == Some("enabled");
 
     if !thinking_enabled {
         return false;
@@ -202,6 +228,11 @@ fn should_remove_top_level_thinking(body: &Value, messages: &[Value]) -> bool {
         .any(|b| b.get("type").and_then(|t| t.as_str()) == Some("tool_use"))
 }
 
+/// 与 CCH 对齐：请求前不做 thinking type 主动改写。
+pub fn normalize_thinking_type(body: Value) -> Value {
+    body
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -211,6 +242,7 @@ mod tests {
         RectifierConfig {
             enabled: true,
             request_thinking_signature: true,
+            request_thinking_budget: true,
         }
     }
 
@@ -218,6 +250,7 @@ mod tests {
         RectifierConfig {
             enabled: true,
             request_thinking_signature: false,
+            request_thinking_budget: false,
         }
     }
 
@@ -225,6 +258,7 @@ mod tests {
         RectifierConfig {
             enabled: false,
             request_thinking_signature: true,
+            request_thinking_budget: true,
         }
     }
 
@@ -264,6 +298,14 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn test_no_detect_thinking_expected_without_tool_use() {
+        assert!(!should_rectify_thinking_signature(
+            Some("messages.69.content.0.type: Expected `thinking` or `redacted_thinking`, but found `text`."),
+            &enabled_config()
+        ));
+    }
+
     #[test]
     fn test_detect_must_start_with_thinking() {
         assert!(should_rectify_thinking_signature(
@@ -418,4 +460,230 @@ mod tests {
         // 此时会触发删除顶层 thinking 的逻辑
         // 这是预期行为：整流后如果仍然不符合要求，就删除顶层 thinking
     }
+
+    // ==================== 新增错误场景检测测试 ====================
+
+    #[test]
+    fn test_detect_signature_extra_inputs() {
+        // 场景5: signature 字段不被接受
+        assert!(should_rectify_thinking_signature(
+            Some("xxx.signature: Extra inputs are not permitted"),
+            &enabled_config()
+        ));
+    }
+
+    #[test]
+    fn test_detect_thinking_cannot_be_modified() {
+        // 场景6: thinking blocks cannot be modified
+        assert!(should_rectify_thinking_signature(
+            Some("thinking or redacted_thinking blocks in the response cannot be modified"),
+            &enabled_config()
+        ));
+    }
+
+    #[test]
+    fn test_detect_invalid_request() {
+        // 场景7: 非法请求（与 CCH 对齐，统一触发）
+        assert!(should_rectify_thinking_signature(
+            Some("非法请求：thinking signature 不合法"),
+            &enabled_config()
+        ));
+        assert!(should_rectify_thinking_signature(
+            Some("illegal request: tool_use block mismatch"),
+            &enabled_config()
+        ));
+        assert!(should_rectify_thinking_signature(
+            Some("invalid request: malformed JSON"),
+            &enabled_config()
+        ));
+    }
+
+    #[test]
+    fn test_do_not_detect_thinking_type_tag_mismatch() {
+        // 与 CCH 对齐：adaptive tag mismatch 不触发签名整流器
+        assert!(!should_rectify_thinking_signature(
+            Some("Input tag 'adaptive' found using 'type' does not match expected tags"),
+            &enabled_config()
+        ));
+    }
+
+    // ==================== adaptive thinking type 测试 ====================
+
+    #[test]
+    fn test_rectify_keeps_adaptive_when_no_legacy_blocks() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "adaptive" },
+            "messages": [{
+                "role": "user",
+                "content": [{ "type": "text", "text": "hello" }]
+            }]
+        });
+
+        let result = rectify_anthropic_request(&mut body);
+
+        assert!(!result.applied);
+        assert_eq!(body["thinking"]["type"], "adaptive");
+        assert!(body["thinking"].get("budget_tokens").is_none());
+    }
+
+    #[test]
+    fn test_rectify_adaptive_preserves_existing_budget_tokens() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "adaptive", "budget_tokens": 5000 },
+            "messages": [{
+                "role": "user",
+                "content": [{ "type": "text", "text": "hello" }]
+            }]
+        });
+
+        let result = rectify_anthropic_request(&mut body);
+
+        assert!(!result.applied);
+        assert_eq!(body["thinking"]["type"], "adaptive");
+        assert_eq!(body["thinking"]["budget_tokens"], 5000);
+    }
+
+    #[test]
+    fn test_rectify_does_not_change_enabled_type() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "enabled", "budget_tokens": 1024 },
+            "messages": [{
+                "role": "user",
+                "content": [{ "type": "text", "text": "hello" }]
+            }]
+        });
+
+        let result = rectify_anthropic_request(&mut body);
+
+        assert!(!result.applied);
+        assert_eq!(body["thinking"]["type"], "enabled");
+    }
+
+    #[test]
+    fn test_rectify_removes_top_level_thinking_adaptive() {
+        // 顶层 thinking 仅在 type=enabled 且 tool_use 场景才会删除，adaptive 不删除
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "adaptive" },
+            "messages": [{
+                "role": "assistant",
+                "content": [
+                    { "type": "tool_use", "id": "toolu_1", "name": "WebSearch", "input": {} }
+                ]
+            }, {
+                "role": "user",
+                "content": [{ "type": "tool_result", "tool_use_id": "toolu_1", "content": "ok" }]
+            }]
+        });
+
+        let result = rectify_anthropic_request(&mut body);
+
+        assert!(!result.applied);
+        assert_eq!(body["thinking"]["type"], "adaptive");
+    }
+
+    #[test]
+    fn test_rectify_adaptive_still_cleans_legacy_signature_blocks() {
+        let mut body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "adaptive" },
+            "messages": [{
+                "role": "assistant",
+                "content": [
+                    { "type": "thinking", "thinking": "t", "signature": "sig_thinking" },
+                    { "type": "text", "text": "hello", "signature": "sig_text" }
+                ]
+            }]
+        });
+
+        let result = rectify_anthropic_request(&mut body);
+
+        assert!(result.applied);
+        assert_eq!(result.removed_thinking_blocks, 1);
+        let content = body["messages"][0]["content"].as_array().unwrap();
+        assert_eq!(content.len(), 1);
+        assert_eq!(content[0]["type"], "text");
+        assert!(content[0].get("signature").is_none());
+        assert_eq!(body["thinking"]["type"], "adaptive");
+    }
+
+    // ==================== normalize_thinking_type 测试 ====================
+
+    #[test]
+    fn test_normalize_thinking_type_adaptive_unchanged() {
+        let body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "adaptive" }
+        });
+
+        let result = normalize_thinking_type(body);
+
+        assert_eq!(result["thinking"]["type"], "adaptive");
+        assert!(result["thinking"].get("budget_tokens").is_none());
+    }
+
+    #[test]
+    fn test_normalize_thinking_type_enabled_unchanged() {
+        let body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "enabled", "budget_tokens": 2048 }
+        });
+
+        let result = normalize_thinking_type(body);
+
+        assert_eq!(result["thinking"]["type"], "enabled");
+        assert_eq!(result["thinking"]["budget_tokens"], 2048);
+    }
+
+    #[test]
+    fn test_normalize_thinking_type_disabled_unchanged() {
+        let body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "disabled" }
+        });
+
+        let result = normalize_thinking_type(body);
+
+        assert_eq!(result["thinking"]["type"], "disabled");
+    }
+
+    #[test]
+    fn test_normalize_thinking_type_preserves_budget() {
+        let body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "adaptive", "budget_tokens": 5000 }
+        });
+
+        let result = normalize_thinking_type(body);
+
+        assert_eq!(result["thinking"]["type"], "adaptive");
+        assert_eq!(result["thinking"]["budget_tokens"], 5000);
+    }
+
+    #[test]
+    fn test_normalize_thinking_type_no_thinking() {
+        let body = json!({
+            "model": "claude-test"
+        });
+
+        let result = normalize_thinking_type(body);
+
+        assert!(result.get("thinking").is_none());
+    }
+
+    #[test]
+    fn test_normalize_thinking_type_unknown_unchanged() {
+        let body = json!({
+            "model": "claude-test",
+            "thinking": { "type": "unexpected", "budget_tokens": 100 }
+        });
+
+        let result = normalize_thinking_type(body);
+
+        assert_eq!(result["thinking"]["type"], "unexpected");
+        assert_eq!(result["thinking"]["budget_tokens"], 100);
+    }
 }

src-tauri/src/proxy/types.rs

@@ -195,17 +195,22 @@ pub struct AppProxyConfig {
 /// 整流器配置
 ///
 /// 存储在 settings 表中
-#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct RectifierConfig {
-    /// 总开关：是否启用整流器
-    #[serde(default)]
+    /// 总开关：是否启用整流器（默认开启）
+    #[serde(default = "default_true")]
     pub enabled: bool,
-    /// 请求整流：启用 thinking 签名整流器
+    /// 请求整流：启用 thinking 签名整流器（默认开启）
     ///
     /// 处理错误：Invalid 'signature' in 'thinking' block
-    #[serde(default)]
+    #[serde(default = "default_true")]
     pub request_thinking_signature: bool,
+    /// 请求整流：启用 thinking budget 整流器（默认开启）
+    ///
+    /// 处理错误：budget_tokens + thinking 相关约束
+    #[serde(default = "default_true")]
+    pub request_thinking_budget: bool,
 }
 
 fn default_true() -> bool {
@@ -216,6 +221,16 @@ fn default_log_level() -> String {
     "info".to_string()
 }
 
+impl Default for RectifierConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            request_thinking_signature: true,
+            request_thinking_budget: true,
+        }
+    }
+}
+
 /// 日志配置
 ///
 /// 存储在 settings 表的 log_config 字段中（JSON 格式）
@@ -261,32 +276,49 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_rectifier_config_default_disabled() {
-        // 验证 RectifierConfig::default() 返回全禁用状态
+    fn test_rectifier_config_default_enabled() {
+        // 验证 RectifierConfig::default() 返回全开启状态
         let config = RectifierConfig::default();
-        assert!(!config.enabled, "整流器总开关默认应为 false");
+        assert!(config.enabled, "整流器总开关默认应为 true");
         assert!(
-            !config.request_thinking_signature,
-            "thinking 签名整流器默认应为 false"
+            config.request_thinking_signature,
+            "thinking 签名整流器默认应为 true"
+        );
+        assert!(
+            config.request_thinking_budget,
+            "thinking budget 整流器默认应为 true"
         );
     }
 
     #[test]
     fn test_rectifier_config_serde_default() {
-        // 验证反序列化缺字段时使用默认值 false
+        // 验证反序列化缺字段时使用默认值 true
         let json = "{}";
         let config: RectifierConfig = serde_json::from_str(json).unwrap();
-        assert!(!config.enabled);
-        assert!(!config.request_thinking_signature);
+        assert!(config.enabled);
+        assert!(config.request_thinking_signature);
+        assert!(config.request_thinking_budget);
     }
 
     #[test]
     fn test_rectifier_config_serde_explicit_true() {
         // 验证显式设置 true 时正确反序列化
-        let json = r#"{"enabled": true, "requestThinkingSignature": true}"#;
+        let json =
+            r#"{"enabled": true, "requestThinkingSignature": true, "requestThinkingBudget": true}"#;
         let config: RectifierConfig = serde_json::from_str(json).unwrap();
         assert!(config.enabled);
         assert!(config.request_thinking_signature);
+        assert!(config.request_thinking_budget);
+    }
+
+    #[test]
+    fn test_rectifier_config_serde_partial_fields() {
+        // 验证只设置部分字段时，缺失字段使用默认值 true
+        let json = r#"{"enabled": true, "requestThinkingSignature": false}"#;
+        let config: RectifierConfig = serde_json::from_str(json).unwrap();
+        assert!(config.enabled);
+        assert!(!config.request_thinking_signature);
+        assert!(config.request_thinking_budget);
     }
 
     #[test]

src/components/settings/RectifierConfigPanel.tsx

@@ -10,6 +10,7 @@ export function RectifierConfigPanel() {
   const [config, setConfig] = useState<RectifierConfig>({
     enabled: true,
     requestThinkingSignature: true,
+    requestThinkingBudget: true,
   });
   const [isLoading, setIsLoading] = useState(true);
 
@@ -69,6 +70,21 @@ export function RectifierConfigPanel() {
             }
           />
         </div>
+        <div className="flex items-center justify-between pl-4">
+          <div className="space-y-0.5">
+            <Label>{t("settings.advanced.rectifier.thinkingBudget")}</Label>
+            <p className="text-xs text-muted-foreground">
+              {t("settings.advanced.rectifier.thinkingBudgetDescription")}
+            </p>
+          </div>
+          <Switch
+            checked={config.requestThinkingBudget}
+            disabled={!config.enabled}
+            onCheckedChange={(checked) =>
+              handleChange({ requestThinkingBudget: checked })
+            }
+          />
+        </div>
       </div>
     </div>
   );

src/i18n/locales/en.json

@@ -214,7 +214,9 @@
         "requestGroup": "Request Rectification",
         "responseGroup": "Response Rectification",
         "thinkingSignature": "Thinking Signature Rectification",
-        "thinkingSignatureDescription": "Automatically fix Claude API errors caused by thinking signature validation failures"
+        "thinkingSignatureDescription": "When an Anthropic-type provider returns thinking signature incompatibility or illegal request errors, automatically removes incompatible thinking-related blocks and retries once with the same provider",
+        "thinkingBudget": "Thinking Budget Rectification",
+        "thinkingBudgetDescription": "When an Anthropic-type provider returns budget_tokens constraint errors (such as at least 1024), automatically normalizes thinking to enabled, sets thinking budget to 32000, and raises max_tokens to 64000 if needed, then retries once"
       },
       "logConfig": {
         "title": "Log Management",

src/i18n/locales/ja.json

@@ -214,7 +214,9 @@
         "requestGroup": "リクエスト整流",
         "responseGroup": "レスポンス整流",
         "thinkingSignature": "Thinking 署名整流",
-        "thinkingSignatureDescription": "Claude API の thinking 署名検証エラーを自動修正"
+        "thinkingSignatureDescription": "Anthropic タイプのプロバイダーが thinking 署名の非互換性や不正なリクエストエラーを返した場合、互換性のない thinking 関連ブロックを自動削除し、同じプロバイダーで 1 回リトライします",
+        "thinkingBudget": "Thinking Budget 整流",
+        "thinkingBudgetDescription": "Anthropic タイプのプロバイダーが budget_tokens 制約エラー（例: 1024 以上）を返した場合、thinking を enabled に正規化し、thinking 予算を 32000 に設定し、必要に応じて max_tokens を 64000 に引き上げて 1 回リトライします"
       },
       "logConfig": {
         "title": "ログ管理",

src/i18n/locales/zh.json

@@ -214,7 +214,9 @@
         "requestGroup": "请求整流",
         "responseGroup": "响应整流",
         "thinkingSignature": "Thinking 签名整流",
-        "thinkingSignatureDescription": "自动修复 Claude API 中因 thinking 签名校验失败导致的请求错误"
+        "thinkingSignatureDescription": "当 Anthropic 类型供应商返回 thinking 签名不兼容或非法请求等错误时，自动移除不兼容的 thinking 相关块并对同一供应商重试一次",
+        "thinkingBudget": "Thinking Budget 整流",
+        "thinkingBudgetDescription": "当 Anthropic 类型供应商返回 budget_tokens 约束错误（如至少 1024）时，自动将 thinking 规范为 enabled 并将 budget 设为 32000，同时在需要时将 max_tokens 设为 64000，然后重试一次"
       },
       "logConfig": {
         "title": "日志管理",

src/lib/api/settings.ts

@@ -155,6 +155,7 @@ export const settingsApi = {
 export interface RectifierConfig {
   enabled: boolean;
   requestThinkingSignature: boolean;
+  requestThinkingBudget: boolean;
 }
 
 export interface LogConfig {