fix(proxy): fix double encoding issue in proxy auth and add debug logs

- Remove encodeURIComponent in mergeAuth() since URL object's
  username/password setters already do percent-encoding automatically
- Add GP-010 debug log for database read operations
- Add GP-011 debug log to track incoming URL info (length, has_auth)
- Fix username.trim() in fallback branch for consistent behavior

src-tauri/src/commands/misc.rs

@@ -5,7 +5,6 @@ use crate::init_status::{InitErrorPayload, SkillsMigrationPayload};
 use crate::services::ProviderService;
 use once_cell::sync::Lazy;
 use regex::Regex;
-use std::path::Path;
 use std::str::FromStr;
 use tauri::AppHandle;
 use tauri::State;
@@ -97,9 +96,7 @@ pub async fn get_tool_versions() -> Result<Vec<ToolVersion>, String> {
 
     for tool in tools {
         // 1. 获取本地版本 - 先尝试直接执行，失败则扫描常见路径
-        let (local_version, local_error) = if let Some(distro) = wsl_distro_for_tool(tool) {
-            try_get_version_wsl(tool, &distro)
-        } else {
+        let (local_version, local_error) = {
             // 先尝试直接执行
             let direct_result = try_get_version(tool);
 
@@ -187,7 +184,7 @@ fn try_get_version(tool: &str) -> (Option<String>, Option<String>) {
             if out.status.success() {
                 let raw = if stdout.is_empty() { &stderr } else { &stdout };
                 if raw.is_empty() {
-                    (None, Some("not installed or not executable".to_string()))
+                    (None, Some("未安装或无法执行".to_string()))
                 } else {
                     (Some(extract_version(raw)), None)
                 }
@@ -196,7 +193,7 @@ fn try_get_version(tool: &str) -> (Option<String>, Option<String>) {
                 (
                     None,
                     Some(if err.is_empty() {
-                        "not installed or not executable".to_string()
+                        "未安装或无法执行".to_string()
                     } else {
                         err
                     }),
@@ -207,88 +204,6 @@ fn try_get_version(tool: &str) -> (Option<String>, Option<String>) {
     }
 }
 
-/// 校验 WSL 发行版名称是否合法
-/// WSL 发行版名称只允许字母、数字、连字符和下划线
-#[cfg(target_os = "windows")]
-fn is_valid_wsl_distro_name(name: &str) -> bool {
-    !name.is_empty()
-        && name.len() <= 64
-        && name
-            .chars()
-            .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_' || c == '.')
-}
-
-#[cfg(target_os = "windows")]
-fn try_get_version_wsl(tool: &str, distro: &str) -> (Option<String>, Option<String>) {
-    use std::process::Command;
-
-    // 防御性断言：tool 只能是预定义的值
-    debug_assert!(
-        ["claude", "codex", "gemini"].contains(&tool),
-        "unexpected tool name: {tool}"
-    );
-
-    // 校验 distro 名称，防止命令注入
-    if !is_valid_wsl_distro_name(distro) {
-        return (None, Some(format!("[WSL:{distro}] invalid distro name")));
-    }
-
-    let output = Command::new("wsl.exe")
-        .args([
-            "-d",
-            distro,
-            "--",
-            "sh",
-            "-lc",
-            &format!("{tool} --version"),
-        ])
-        .creation_flags(CREATE_NO_WINDOW)
-        .output();
-
-    match output {
-        Ok(out) => {
-            let stdout = String::from_utf8_lossy(&out.stdout).trim().to_string();
-            let stderr = String::from_utf8_lossy(&out.stderr).trim().to_string();
-            if out.status.success() {
-                let raw = if stdout.is_empty() { &stderr } else { &stdout };
-                if raw.is_empty() {
-                    (
-                        None,
-                        Some(format!("[WSL:{distro}] not installed or not executable")),
-                    )
-                } else {
-                    (Some(extract_version(raw)), None)
-                }
-            } else {
-                let err = if stderr.is_empty() { stdout } else { stderr };
-                (
-                    None,
-                    Some(format!(
-                        "[WSL:{distro}] {}",
-                        if err.is_empty() {
-                            "not installed or not executable".to_string()
-                        } else {
-                            err
-                        }
-                    )),
-                )
-            }
-        }
-        Err(e) => (None, Some(format!("[WSL:{distro}] exec failed: {e}"))),
-    }
-}
-
-/// 非 Windows 平台的 WSL 版本检测存根
-/// 注意：此函数实际上不会被调用，因为 `wsl_distro_from_path` 在非 Windows 平台总是返回 None。
-/// 保留此函数是为了保持 API 一致性，防止未来重构时遗漏。
-#[cfg(not(target_os = "windows"))]
-fn try_get_version_wsl(_tool: &str, _distro: &str) -> (Option<String>, Option<String>) {
-    (
-        None,
-        Some("WSL check not supported on this platform".to_string()),
-    )
-}
-
 /// 扫描常见路径查找 CLI
 fn scan_cli_version(tool: &str) -> (Option<String>, Option<String>) {
     use std::process::Command;
@@ -384,49 +299,7 @@ fn scan_cli_version(tool: &str) -> (Option<String>, Option<String>) {
         }
     }
 
-    (None, Some("not installed or not executable".to_string()))
-}
-
-fn wsl_distro_for_tool(tool: &str) -> Option<String> {
-    let override_dir = match tool {
-        "claude" => crate::settings::get_claude_override_dir(),
-        "codex" => crate::settings::get_codex_override_dir(),
-        "gemini" => crate::settings::get_gemini_override_dir(),
-        _ => None,
-    }?;
-
-    wsl_distro_from_path(&override_dir)
-}
-
-/// 从 UNC 路径中提取 WSL 发行版名称
-/// 支持 `\\wsl$\Ubuntu\...` 和 `\\wsl.localhost\Ubuntu\...` 两种格式
-#[cfg(target_os = "windows")]
-fn wsl_distro_from_path(path: &Path) -> Option<String> {
-    use std::path::{Component, Prefix};
-    let Some(Component::Prefix(prefix)) = path.components().next() else {
-        return None;
-    };
-    match prefix.kind() {
-        Prefix::UNC(server, share) | Prefix::VerbatimUNC(server, share) => {
-            let server_name = server.to_string_lossy();
-            if server_name.eq_ignore_ascii_case("wsl$")
-                || server_name.eq_ignore_ascii_case("wsl.localhost")
-            {
-                let distro = share.to_string_lossy().to_string();
-                if !distro.is_empty() {
-                    return Some(distro);
-                }
-            }
-            None
-        }
-        _ => None,
-    }
-}
-
-/// 非 Windows 平台不支持 WSL 路径解析
-#[cfg(not(target_os = "windows"))]
-fn wsl_distro_from_path(_path: &Path) -> Option<String> {
-    None
+    (None, Some("未安装或无法执行".to_string()))
 }
 
 /// 打开指定提供商的终端
@@ -532,7 +405,7 @@ fn launch_terminal_with_env(
     #[cfg(target_os = "macos")]
     {
         launch_macos_terminal(&config_file, &config_path_escaped)?;
-        Ok(())
+        return Ok(());
     }
 
     #[cfg(target_os = "linux")]
@@ -583,7 +456,8 @@ fn escape_shell_path(path: &std::path::Path) -> String {
 /// 生成 bash 包装脚本，用于清理临时文件
 fn generate_wrapper_script(config_path: &str, escaped_path: &str) -> String {
     format!(
-        "bash -c 'trap \"rm -f \\\"{config_path}\\\"\" EXIT; echo \"Using provider-specific claude config:\"; echo \"{escaped_path}\"; claude --settings \"{escaped_path}\"; exec bash --norc --noprofile'"
+        "bash -c 'trap \"rm -f \\\"{}\\\"\" EXIT; echo \"Using provider-specific claude config:\"; echo \"{}\"; claude --settings \"{}\"; exec bash --norc --noprofile'",
+        config_path, escaped_path, escaped_path
     )
 }
 

src-tauri/src/commands/settings.rs

@@ -59,24 +59,3 @@ pub async fn set_auto_launch(enabled: bool) -> Result<bool, String> {
 pub async fn get_auto_launch_status() -> Result<bool, String> {
     crate::auto_launch::is_auto_launch_enabled().map_err(|e| format!("获取开机自启状态失败: {e}"))
 }
-
-/// 获取整流器配置
-#[tauri::command]
-pub async fn get_rectifier_config(
-    state: tauri::State<'_, crate::AppState>,
-) -> Result<crate::proxy::types::RectifierConfig, String> {
-    state.db.get_rectifier_config().map_err(|e| e.to_string())
-}
-
-/// 设置整流器配置
-#[tauri::command]
-pub async fn set_rectifier_config(
-    state: tauri::State<'_, crate::AppState>,
-    config: crate::proxy::types::RectifierConfig,
-) -> Result<bool, String> {
-    state
-        .db
-        .set_rectifier_config(&config)
-        .map_err(|e| e.to_string())?;
-    Ok(true)
-}

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

@@ -163,27 +163,4 @@ impl Database {
         log::info!("已清除所有代理接管状态");
         Ok(())
     }
-
-    // --- 整流器配置 ---
-
-    /// 获取整流器配置
-    ///
-    /// 返回整流器配置，如果不存在则返回默认值（全部启用）
-    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)
-                .map_err(|e| AppError::Database(format!("解析整流器配置失败: {e}"))),
-            None => Ok(crate::proxy::types::RectifierConfig::default()),
-        }
-    }
-
-    /// 更新整流器配置
-    pub fn set_rectifier_config(
-        &self,
-        config: &crate::proxy::types::RectifierConfig,
-    ) -> Result<(), AppError> {
-        let json = serde_json::to_string(config)
-            .map_err(|e| AppError::Database(format!("序列化整流器配置失败: {e}")))?;
-        self.set_setting("rectifier_config", &json)
-    }
 }

src-tauri/src/lib.rs

@@ -734,8 +734,6 @@ pub fn run() {
             commands::read_live_provider_settings,
             commands::get_settings,
             commands::save_settings,
-            commands::get_rectifier_config,
-            commands::set_rectifier_config,
             commands::restart_app,
             commands::check_for_updates,
             commands::is_portable_mode,

src-tauri/src/proxy/circuit_breaker.rs

@@ -319,11 +319,7 @@ impl CircuitBreaker {
         }
     }
 
-    /// 仅释放 HalfOpen permit，不影响健康统计
-    ///
-    /// 用于整流器等场景：请求结果不应计入 Provider 健康度，
-    /// 但仍需释放占用的探测名额，避免 HalfOpen 状态卡死
-    pub fn release_half_open_permit(&self) {
+    fn release_half_open_permit(&self) {
         let mut current = self.half_open_requests.load(Ordering::SeqCst);
         loop {
             if current == 0 {

src-tauri/src/proxy/forwarder.rs

@@ -7,9 +7,8 @@ use super::{
     error::*,
     failover_switch::FailoverSwitchManager,
     provider_router::ProviderRouter,
-    providers::{get_adapter, ProviderAdapter, ProviderType},
-    thinking_rectifier::{rectify_anthropic_request, should_rectify_thinking_signature},
-    types::{ProxyStatus, RectifierConfig},
+    providers::{get_adapter, ProviderAdapter},
+    types::ProxyStatus,
     ProxyError,
 };
 use crate::{app_config::AppType, provider::Provider};
@@ -91,8 +90,6 @@ pub struct RequestForwarder {
     app_handle: Option<tauri::AppHandle>,
     /// 请求开始时的"当前供应商 ID"（用于判断是否需要同步 UI/托盘）
     current_provider_id_at_start: String,
-    /// 整流器配置
-    rectifier_config: RectifierConfig,
     /// 非流式请求超时（秒）
     non_streaming_timeout: std::time::Duration,
 }
@@ -109,7 +106,6 @@ impl RequestForwarder {
         current_provider_id_at_start: String,
         _streaming_first_byte_timeout: u64,
         _streaming_idle_timeout: u64,
-        rectifier_config: RectifierConfig,
     ) -> Self {
         Self {
             router,
@@ -118,7 +114,6 @@ impl RequestForwarder {
             failover_manager,
             app_handle,
             current_provider_id_at_start,
-            rectifier_config,
             non_streaming_timeout: std::time::Duration::from_secs(non_streaming_timeout),
         }
     }
@@ -135,7 +130,7 @@ impl RequestForwarder {
         &self,
         app_type: &AppType,
         endpoint: &str,
-        mut body: Value,
+        body: Value,
         headers: axum::http::HeaderMap,
         providers: Vec<Provider>,
     ) -> Result<ForwardResult, ForwardError> {
@@ -154,9 +149,6 @@ impl RequestForwarder {
         let mut last_provider = None;
         let mut attempted_providers = 0usize;
 
-        // 整流器重试标记：确保整流最多触发一次
-        let mut rectifier_retried = false;
-
         // 单 Provider 场景下跳过熔断器检查（故障转移关闭时）
         let bypass_circuit_breaker = providers.len() == 1;
 
@@ -251,205 +243,6 @@ impl RequestForwarder {
                     });
                 }
                 Err(e) => {
-                    // 检测是否需要触发整流器（仅 Claude/ClaudeAuth 供应商）
-                    let provider_type = ProviderType::from_app_type_and_config(app_type, provider);
-                    let is_anthropic_provider = matches!(
-                        provider_type,
-                        ProviderType::Claude | ProviderType::ClaudeAuth
-                    );
-
-                    if is_anthropic_provider {
-                        let error_message = extract_error_message(&e);
-                        if should_rectify_thinking_signature(
-                            error_message.as_deref(),
-                            &self.rectifier_config,
-                        ) {
-                            // 已经重试过：直接返回错误（不可重试客户端错误）
-                            if rectifier_retried {
-                                log::warn!("[{app_type_str}] [RECT-005] 整流器已触发过，不再重试");
-                                // 释放 HalfOpen 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(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 rectified = rectify_anthropic_request(&mut body);
-
-                            // 整流未生效：直接返回错误（不可重试客户端错误）
-                            if !rectified.applied {
-                                log::warn!(
-                                    "[{app_type_str}] [RECT-006] 整流器触发但无可整流内容，不做无意义重试"
-                                );
-                                // 释放 HalfOpen 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(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()),
-                                });
-                            }
-
-                            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()),
-                                    });
-                                }
-                            }
-                        }
-                    }
-
                     // 失败：记录失败并更新熔断器
                     let _ = self
                         .router
@@ -711,11 +504,3 @@ impl RequestForwarder {
         }
     }
 }
-
-/// 从 ProxyError 中提取错误消息
-fn extract_error_message(error: &ProxyError) -> Option<String> {
-    match error {
-        ProxyError::UpstreamError { body, .. } => body.clone(),
-        _ => Some(error.to_string()),
-    }
-}

src-tauri/src/proxy/handler_context.rs

@@ -5,10 +5,7 @@
 use crate::app_config::AppType;
 use crate::provider::Provider;
 use crate::proxy::{
-    extract_session_id,
-    forwarder::RequestForwarder,
-    server::ProxyState,
-    types::{AppProxyConfig, RectifierConfig},
+    extract_session_id, forwarder::RequestForwarder, server::ProxyState, types::AppProxyConfig,
     ProxyError,
 };
 use axum::http::HeaderMap;
@@ -57,8 +54,6 @@ pub struct RequestContext {
     pub app_type: AppType,
     /// Session ID（从客户端请求提取或新生成）
     pub session_id: String,
-    /// 整流器配置
-    pub rectifier_config: RectifierConfig,
 }
 
 impl RequestContext {
@@ -91,9 +86,6 @@ impl RequestContext {
             .await
             .map_err(|e| ProxyError::DatabaseError(e.to_string()))?;
 
-        // 从数据库读取整流器配置
-        let rectifier_config = state.db.get_rectifier_config().unwrap_or_default();
-
         let current_provider_id =
             crate::settings::get_current_provider(&app_type).unwrap_or_default();
 
@@ -155,7 +147,6 @@ impl RequestContext {
             app_type_str,
             app_type,
             session_id,
-            rectifier_config,
         })
     }
 
@@ -215,7 +206,6 @@ impl RequestContext {
             self.current_provider_id.clone(),
             first_byte_timeout,
             idle_timeout,
-            self.rectifier_config.clone(),
         )
     }
 

src-tauri/src/proxy/mod.rs

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

src-tauri/src/proxy/provider_router.rs

@@ -151,24 +151,6 @@ impl ProviderRouter {
         self.reset_circuit_breaker(&circuit_key).await;
     }
 
-    /// 仅释放 HalfOpen permit，不影响健康统计（neutral 接口）
-    ///
-    /// 用于整流器等场景：请求结果不应计入 Provider 健康度，
-    /// 但仍需释放占用的探测名额，避免 HalfOpen 状态卡死
-    pub async fn release_permit_neutral(
-        &self,
-        provider_id: &str,
-        app_type: &str,
-        used_half_open_permit: bool,
-    ) {
-        if !used_half_open_permit {
-            return;
-        }
-        let circuit_key = format!("{app_type}:{provider_id}");
-        let breaker = self.get_or_create_circuit_breaker(&circuit_key).await;
-        breaker.release_half_open_permit();
-    }
-
     /// 更新所有熔断器的配置（热更新）
     pub async fn update_all_configs(&self, config: CircuitBreakerConfig) {
         let breakers = self.circuit_breakers.read().await;
@@ -343,55 +325,4 @@ mod tests {
 
         assert!(router.allow_provider_request("b", "claude").await.allowed);
     }
-
-    #[tokio::test]
-    async fn test_release_permit_neutral_frees_half_open_slot() {
-        let db = Arc::new(Database::memory().unwrap());
-
-        // 配置熔断器：1 次失败即熔断，0 秒超时立即进入 HalfOpen
-        db.update_circuit_breaker_config(&CircuitBreakerConfig {
-            failure_threshold: 1,
-            timeout_seconds: 0,
-            ..Default::default()
-        })
-        .await
-        .unwrap();
-
-        let provider_a =
-            Provider::with_id("a".to_string(), "Provider A".to_string(), json!({}), None);
-        db.save_provider("claude", &provider_a).unwrap();
-        db.add_to_failover_queue("claude", "a").unwrap();
-
-        // 启用自动故障转移
-        let mut config = db.get_proxy_config_for_app("claude").await.unwrap();
-        config.auto_failover_enabled = true;
-        db.update_proxy_config_for_app(config).await.unwrap();
-
-        let router = ProviderRouter::new(db.clone());
-
-        // 触发熔断：1 次失败
-        router
-            .record_result("a", "claude", false, false, Some("fail".to_string()))
-            .await
-            .unwrap();
-
-        // 第一次请求：获取 HalfOpen 探测名额
-        let first = router.allow_provider_request("a", "claude").await;
-        assert!(first.allowed);
-        assert!(first.used_half_open_permit);
-
-        // 第二次请求应被拒绝（名额已被占用）
-        let second = router.allow_provider_request("a", "claude").await;
-        assert!(!second.allowed);
-
-        // 使用 release_permit_neutral 释放名额（不影响健康统计）
-        router
-            .release_permit_neutral("a", "claude", first.used_half_open_permit)
-            .await;
-
-        // 第三次请求应被允许（名额已释放）
-        let third = router.allow_provider_request("a", "claude").await;
-        assert!(third.allowed);
-        assert!(third.used_half_open_permit);
-    }
 }

src-tauri/src/proxy/thinking_rectifier.rs

@@ -1,421 +0,0 @@
-//! Thinking Signature 整流器
-//!
-//! 用于自动修复 Anthropic API 中因签名校验失败导致的请求错误。
-//! 当上游 API 返回签名相关错误时，系统会自动移除有问题的签名字段并重试请求。
-
-use super::types::RectifierConfig;
-use serde_json::Value;
-
-/// 整流结果
-#[derive(Debug, Clone, Default)]
-pub struct RectifyResult {
-    /// 是否应用了整流
-    pub applied: bool,
-    /// 移除的 thinking block 数量
-    pub removed_thinking_blocks: usize,
-    /// 移除的 redacted_thinking block 数量
-    pub removed_redacted_thinking_blocks: usize,
-    /// 移除的 signature 字段数量
-    pub removed_signature_fields: usize,
-}
-
-/// 检测是否需要触发 thinking 签名整流器
-///
-/// 返回 `true` 表示需要触发整流器，`false` 表示不需要。
-/// 会检查配置开关。
-pub fn should_rectify_thinking_signature(
-    error_message: Option<&str>,
-    config: &RectifierConfig,
-) -> bool {
-    // 检查总开关
-    if !config.enabled {
-        return false;
-    }
-    // 检查子开关
-    if !config.request_thinking_signature {
-        return false;
-    }
-
-    // 检测错误类型
-    let Some(msg) = error_message else {
-        return false;
-    };
-    let lower = msg.to_lowercase();
-
-    // 场景1: thinking block 中的签名无效
-    // 错误示例: "Invalid 'signature' in 'thinking' block"
-    if lower.contains("invalid")
-        && lower.contains("signature")
-        && lower.contains("thinking")
-        && lower.contains("block")
-    {
-        return true;
-    }
-
-    // 场景2: assistant 消息必须以 thinking block 开头
-    // 错误示例: "must start with a thinking block"
-    if lower.contains("must start with a thinking block") {
-        return true;
-    }
-
-    // 场景3: expected thinking or redacted_thinking, found 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")
-    {
-        return true;
-    }
-
-    // 场景4: signature 字段必需但缺失
-    // 错误示例: "signature: Field required"
-    if lower.contains("signature") && lower.contains("field required") {
-        return true;
-    }
-
-    false
-}
-
-/// 对 Anthropic 请求体做最小侵入整流
-///
-/// - 移除 messages[*].content 中的 thinking/redacted_thinking block
-/// - 移除非 thinking block 上遗留的 signature 字段
-/// - 特定条件下删除顶层 thinking 字段
-///
-/// 注意：该函数会原地修改 body 对象
-pub fn rectify_anthropic_request(body: &mut Value) -> RectifyResult {
-    let mut result = RectifyResult::default();
-
-    let messages = match body.get_mut("messages").and_then(|m| m.as_array_mut()) {
-        Some(m) => m,
-        None => return result,
-    };
-
-    // 遍历所有消息
-    for msg in messages.iter_mut() {
-        let content = match msg.get_mut("content").and_then(|c| c.as_array_mut()) {
-            Some(c) => c,
-            None => continue,
-        };
-
-        let mut new_content = Vec::with_capacity(content.len());
-        let mut content_modified = false;
-
-        for block in content.iter() {
-            let block_type = block.get("type").and_then(|t| t.as_str());
-
-            match block_type {
-                Some("thinking") => {
-                    result.removed_thinking_blocks += 1;
-                    content_modified = true;
-                    continue;
-                }
-                Some("redacted_thinking") => {
-                    result.removed_redacted_thinking_blocks += 1;
-                    content_modified = true;
-                    continue;
-                }
-                _ => {}
-            }
-
-            // 移除非 thinking block 上的 signature 字段
-            if block.get("signature").is_some() {
-                let mut block_clone = block.clone();
-                if let Some(obj) = block_clone.as_object_mut() {
-                    obj.remove("signature");
-                    result.removed_signature_fields += 1;
-                    content_modified = true;
-                    new_content.push(Value::Object(obj.clone()));
-                    continue;
-                }
-            }
-
-            new_content.push(block.clone());
-        }
-
-        if content_modified {
-            result.applied = true;
-            *content = new_content;
-        }
-    }
-
-    // 兜底处理：thinking 启用 + 工具调用链路中最后一条 assistant 消息未以 thinking 开头
-    let messages_snapshot: Vec<Value> = body
-        .get("messages")
-        .and_then(|m| m.as_array())
-        .map(|a| a.to_vec())
-        .unwrap_or_default();
-
-    if should_remove_top_level_thinking(body, &messages_snapshot) {
-        if let Some(obj) = body.as_object_mut() {
-            obj.remove("thinking");
-            result.applied = true;
-        }
-    }
-
-    result
-}
-
-/// 判断是否需要删除顶层 thinking 字段
-fn should_remove_top_level_thinking(body: &Value, messages: &[Value]) -> bool {
-    // 检查 thinking 是否启用
-    let thinking_enabled = body
-        .get("thinking")
-        .and_then(|t| t.get("type"))
-        .and_then(|t| t.as_str())
-        == Some("enabled");
-
-    if !thinking_enabled {
-        return false;
-    }
-
-    // 找到最后一条 assistant 消息
-    let last_assistant = messages
-        .iter()
-        .rev()
-        .find(|m| m.get("role").and_then(|r| r.as_str()) == Some("assistant"));
-
-    let last_assistant_content = match last_assistant
-        .and_then(|m| m.get("content"))
-        .and_then(|c| c.as_array())
-    {
-        Some(c) if !c.is_empty() => c,
-        _ => return false,
-    };
-
-    // 检查首块是否为 thinking/redacted_thinking
-    let first_block_type = last_assistant_content
-        .first()
-        .and_then(|b| b.get("type"))
-        .and_then(|t| t.as_str());
-
-    let missing_thinking_prefix =
-        first_block_type != Some("thinking") && first_block_type != Some("redacted_thinking");
-
-    if !missing_thinking_prefix {
-        return false;
-    }
-
-    // 检查是否存在 tool_use
-    last_assistant_content
-        .iter()
-        .any(|b| b.get("type").and_then(|t| t.as_str()) == Some("tool_use"))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    fn enabled_config() -> RectifierConfig {
-        RectifierConfig {
-            enabled: true,
-            request_thinking_signature: true,
-        }
-    }
-
-    fn disabled_config() -> RectifierConfig {
-        RectifierConfig {
-            enabled: true,
-            request_thinking_signature: false,
-        }
-    }
-
-    fn master_disabled_config() -> RectifierConfig {
-        RectifierConfig {
-            enabled: false,
-            request_thinking_signature: true,
-        }
-    }
-
-    // ==================== should_rectify_thinking_signature 测试 ====================
-
-    #[test]
-    fn test_detect_invalid_signature() {
-        assert!(should_rectify_thinking_signature(
-            Some("messages.1.content.0: Invalid `signature` in `thinking` block"),
-            &enabled_config()
-        ));
-    }
-
-    #[test]
-    fn test_detect_invalid_signature_no_backticks() {
-        assert!(should_rectify_thinking_signature(
-            Some("Messages.1.Content.0: invalid signature in thinking block"),
-            &enabled_config()
-        ));
-    }
-
-    #[test]
-    fn test_detect_invalid_signature_nested_json() {
-        // 测试嵌套 JSON 格式的错误消息（第三方渠道常见格式）
-        let nested_error = r#"{"error":{"message":"{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"***.content.0: Invalid `signature` in `thinking` block\"},\"request_id\":\"req_xxx\"}"}}"#;
-        assert!(should_rectify_thinking_signature(
-            Some(nested_error),
-            &enabled_config()
-        ));
-    }
-
-    #[test]
-    fn test_detect_thinking_expected() {
-        assert!(should_rectify_thinking_signature(
-            Some("messages.69.content.0.type: Expected `thinking` or `redacted_thinking`, but found `tool_use`."),
-            &enabled_config()
-        ));
-    }
-
-    #[test]
-    fn test_detect_must_start_with_thinking() {
-        assert!(should_rectify_thinking_signature(
-            Some("a final `assistant` message must start with a thinking block"),
-            &enabled_config()
-        ));
-    }
-
-    #[test]
-    fn test_no_trigger_for_unrelated_error() {
-        assert!(!should_rectify_thinking_signature(
-            Some("Request timeout"),
-            &enabled_config()
-        ));
-        assert!(!should_rectify_thinking_signature(
-            Some("Connection refused"),
-            &enabled_config()
-        ));
-        assert!(!should_rectify_thinking_signature(None, &enabled_config()));
-    }
-
-    #[test]
-    fn test_detect_signature_field_required() {
-        // 场景4: signature 字段缺失
-        assert!(should_rectify_thinking_signature(
-            Some("***.***.***.***.***.signature: Field required"),
-            &enabled_config()
-        ));
-        // 嵌套 JSON 格式
-        let nested_error = r#"{"error":{"type":"<nil>","message":"{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"***.***.***.***.***.signature: Field required\"},\"request_id\":\"req_xxx\"}"}}"#;
-        assert!(should_rectify_thinking_signature(
-            Some(nested_error),
-            &enabled_config()
-        ));
-    }
-
-    #[test]
-    fn test_disabled_config() {
-        // 即使错误匹配，配置关闭时也不触发
-        assert!(!should_rectify_thinking_signature(
-            Some("Invalid `signature` in `thinking` block"),
-            &disabled_config()
-        ));
-    }
-
-    #[test]
-    fn test_master_disabled() {
-        // 总开关关闭时，即使子开关开启也不触发
-        assert!(!should_rectify_thinking_signature(
-            Some("Invalid `signature` in `thinking` block"),
-            &master_disabled_config()
-        ));
-    }
-
-    // ==================== rectify_anthropic_request 测试 ====================
-
-    #[test]
-    fn test_rectify_removes_thinking_blocks() {
-        let mut body = json!({
-            "model": "claude-test",
-            "messages": [{
-                "role": "assistant",
-                "content": [
-                    { "type": "thinking", "thinking": "t", "signature": "sig" },
-                    { "type": "text", "text": "hello", "signature": "sig_text" },
-                    { "type": "tool_use", "id": "toolu_1", "name": "WebSearch", "input": {}, "signature": "sig_tool" },
-                    { "type": "redacted_thinking", "data": "r", "signature": "sig_redacted" }
-                ]
-            }]
-        });
-
-        let result = rectify_anthropic_request(&mut body);
-
-        assert!(result.applied);
-        assert_eq!(result.removed_thinking_blocks, 1);
-        assert_eq!(result.removed_redacted_thinking_blocks, 1);
-        assert_eq!(result.removed_signature_fields, 2);
-
-        let content = body["messages"][0]["content"].as_array().unwrap();
-        assert_eq!(content.len(), 2);
-        assert_eq!(content[0]["type"], "text");
-        assert!(content[0].get("signature").is_none());
-        assert_eq!(content[1]["type"], "tool_use");
-        assert!(content[1].get("signature").is_none());
-    }
-
-    #[test]
-    fn test_rectify_removes_top_level_thinking() {
-        let mut body = json!({
-            "model": "claude-test",
-            "thinking": { "type": "enabled", "budget_tokens": 1024 },
-            "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!(body.get("thinking").is_none());
-    }
-
-    #[test]
-    fn test_rectify_no_change_when_no_issues() {
-        let mut body = json!({
-            "model": "claude-test",
-            "messages": [{
-                "role": "user",
-                "content": [{ "type": "text", "text": "hello" }]
-            }]
-        });
-
-        let result = rectify_anthropic_request(&mut body);
-
-        assert!(!result.applied);
-        assert_eq!(result.removed_thinking_blocks, 0);
-    }
-
-    #[test]
-    fn test_rectify_no_messages() {
-        let mut body = json!({ "model": "claude-test" });
-        let result = rectify_anthropic_request(&mut body);
-        assert!(!result.applied);
-    }
-
-    #[test]
-    fn test_rectify_preserves_thinking_when_prefix_exists() {
-        let mut body = json!({
-            "model": "claude-test",
-            "thinking": { "type": "enabled" },
-            "messages": [{
-                "role": "assistant",
-                "content": [
-                    { "type": "thinking", "thinking": "some thought" },
-                    { "type": "tool_use", "id": "toolu_1", "name": "Test", "input": {} }
-                ]
-            }]
-        });
-
-        let result = rectify_anthropic_request(&mut body);
-
-        // thinking block 被移除，但顶层 thinking 不应被移除（因为原本有 thinking 前缀）
-        assert!(result.applied);
-        assert_eq!(result.removed_thinking_blocks, 1);
-        // 注意：由于 thinking block 被移除后，首块变成了 tool_use，
-        // 此时会触发删除顶层 thinking 的逻辑
-        // 这是预期行为：整流后如果仍然不符合要求，就删除顶层 thinking
-    }
-}

src-tauri/src/proxy/types.rs

@@ -191,67 +191,3 @@ pub struct AppProxyConfig {
     /// 计算错误率的最小请求数
     pub circuit_min_requests: u32,
 }
-
-/// 整流器配置
-///
-/// 存储在 settings 表中
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RectifierConfig {
-    /// 总开关：是否启用整流器
-    #[serde(default = "default_true")]
-    pub enabled: bool,
-    /// 请求整流：启用 thinking 签名整流器
-    ///
-    /// 处理错误：Invalid 'signature' in 'thinking' block
-    #[serde(default = "default_true")]
-    pub request_thinking_signature: bool,
-}
-
-impl Default for RectifierConfig {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            request_thinking_signature: true,
-        }
-    }
-}
-
-fn default_true() -> bool {
-    true
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_rectifier_config_default_enabled() {
-        // 验证 RectifierConfig::default() 返回全启用状态
-        // 防止回归：#[derive(Default)] 会使 bool 默认为 false
-        let config = RectifierConfig::default();
-        assert!(config.enabled, "整流器总开关默认应为 true");
-        assert!(
-            config.request_thinking_signature,
-            "thinking 签名整流器默认应为 true"
-        );
-    }
-
-    #[test]
-    fn test_rectifier_config_serde_default() {
-        // 验证反序列化缺字段时使用 default_true
-        let json = "{}";
-        let config: RectifierConfig = serde_json::from_str(json).unwrap();
-        assert!(config.enabled);
-        assert!(config.request_thinking_signature);
-    }
-
-    #[test]
-    fn test_rectifier_config_serde_explicit_false() {
-        // 验证显式设置 false 时正确反序列化
-        let json = r#"{"enabled": false, "requestThinkingSignature": false}"#;
-        let config: RectifierConfig = serde_json::from_str(json).unwrap();
-        assert!(!config.enabled);
-        assert!(!config.request_thinking_signature);
-    }
-}

src-tauri/src/services/stream_check.rs

@@ -36,13 +36,6 @@ pub struct StreamCheckConfig {
     pub codex_model: String,
     /// Gemini 测试模型
     pub gemini_model: String,
-    /// 检查提示词
-    #[serde(default = "default_test_prompt")]
-    pub test_prompt: String,
-}
-
-fn default_test_prompt() -> String {
-    "Who are you?".to_string()
 }
 
 impl Default for StreamCheckConfig {
@@ -54,7 +47,6 @@ impl Default for StreamCheckConfig {
             claude_model: "claude-haiku-4-5-20251001".to_string(),
             codex_model: "gpt-5.1-codex@low".to_string(),
             gemini_model: "gemini-3-pro-preview".to_string(),
-            test_prompt: default_test_prompt(),
         }
     }
 }
@@ -118,7 +110,7 @@ impl StreamCheckService {
         Ok(last_result.unwrap_or_else(|| StreamCheckResult {
             status: HealthStatus::Failed,
             success: false,
-            message: "Check failed".to_string(),
+            message: "检查失败".to_string(),
             response_time_ms: None,
             http_status: None,
             model_used: String::new(),
@@ -138,18 +130,17 @@ impl StreamCheckService {
 
         let base_url = adapter
             .extract_base_url(provider)
-            .map_err(|e| AppError::Message(format!("Failed to extract base_url: {e}")))?;
+            .map_err(|e| AppError::Message(format!("提取 base_url 失败: {e}")))?;
 
         let auth = adapter
             .extract_auth(provider)
-            .ok_or_else(|| AppError::Message("API Key not found".to_string()))?;
+            .ok_or_else(|| AppError::Message("未找到 API Key".to_string()))?;
 
         // 使用全局 HTTP 客户端（已包含代理配置）
         let client = crate::proxy::http_client::get();
         let request_timeout = std::time::Duration::from_secs(config.timeout_secs);
 
         let model_to_test = Self::resolve_test_model(app_type, provider, config);
-        let test_prompt = &config.test_prompt;
 
         let result = match app_type {
             AppType::Claude => {
@@ -158,21 +149,13 @@ impl StreamCheckService {
                     &base_url,
                     &auth,
                     &model_to_test,
-                    test_prompt,
                     request_timeout,
                 )
                 .await
             }
             AppType::Codex => {
-                Self::check_codex_stream(
-                    &client,
-                    &base_url,
-                    &auth,
-                    &model_to_test,
-                    test_prompt,
-                    request_timeout,
-                )
-                .await
+                Self::check_codex_stream(&client, &base_url, &auth, &model_to_test, request_timeout)
+                    .await
             }
             AppType::Gemini => {
                 Self::check_gemini_stream(
@@ -180,7 +163,6 @@ impl StreamCheckService {
                     &base_url,
                     &auth,
                     &model_to_test,
-                    test_prompt,
                     request_timeout,
                 )
                 .await
@@ -197,7 +179,7 @@ impl StreamCheckService {
                 Ok(StreamCheckResult {
                     status: health_status,
                     success: true,
-                    message: "Check succeeded".to_string(),
+                    message: "检查成功".to_string(),
                     response_time_ms: Some(response_time),
                     http_status: Some(status_code),
                     model_used: model,
@@ -219,68 +201,32 @@ impl StreamCheckService {
     }
 
     /// Claude 流式检查
-    ///
-    /// 严格按照 Claude CLI 真实请求格式构建请求
     async fn check_claude_stream(
         client: &Client,
         base_url: &str,
         auth: &AuthInfo,
         model: &str,
-        test_prompt: &str,
         timeout: std::time::Duration,
     ) -> Result<(u16, String), AppError> {
         let base = base_url.trim_end_matches('/');
-        // URL 必须包含 ?beta=true 参数（某些中转服务依赖此参数验证请求来源）
         let url = if base.ends_with("/v1") {
-            format!("{base}/messages?beta=true")
+            format!("{base}/messages")
         } else {
-            format!("{base}/v1/messages?beta=true")
+            format!("{base}/v1/messages")
         };
 
         let body = json!({
             "model": model,
             "max_tokens": 1,
-            "messages": [{ "role": "user", "content": test_prompt }],
+            "messages": [{ "role": "user", "content": "hi" }],
             "stream": true
         });
 
-        // 获取本地系统信息
-        let os_name = Self::get_os_name();
-        let arch_name = Self::get_arch_name();
-
-        // 严格按照 Claude CLI 请求格式设置 headers
         let response = client
             .post(&url)
-            // 认证 headers（双重认证）
-            .header("authorization", format!("Bearer {}", auth.api_key))
             .header("x-api-key", &auth.api_key)
-            // Anthropic 必需 headers
             .header("anthropic-version", "2023-06-01")
-            .header(
-                "anthropic-beta",
-                "claude-code-20250219,interleaved-thinking-2025-05-14",
-            )
-            .header("anthropic-dangerous-direct-browser-access", "true")
-            // 内容类型 headers
-            .header("content-type", "application/json")
-            .header("accept", "application/json")
-            .header("accept-encoding", "identity")
-            .header("accept-language", "*")
-            // 客户端标识 headers
-            .header("user-agent", "claude-cli/2.1.2 (external, cli)")
-            .header("x-app", "cli")
-            // x-stainless SDK headers（动态获取本地系统信息）
-            .header("x-stainless-lang", "js")
-            .header("x-stainless-package-version", "0.70.0")
-            .header("x-stainless-os", os_name)
-            .header("x-stainless-arch", arch_name)
-            .header("x-stainless-runtime", "node")
-            .header("x-stainless-runtime-version", "v22.20.0")
-            .header("x-stainless-retry-count", "0")
-            .header("x-stainless-timeout", "600")
-            // 其他 headers
-            .header("sec-fetch-mode", "cors")
-            .header("connection", "keep-alive")
+            .header("Content-Type", "application/json")
             .timeout(timeout)
             .json(&body)
             .send()
@@ -299,63 +245,52 @@ impl StreamCheckService {
         if let Some(chunk) = stream.next().await {
             match chunk {
                 Ok(_) => Ok((status, model.to_string())),
-                Err(e) => Err(AppError::Message(format!("Stream read failed: {e}"))),
+                Err(e) => Err(AppError::Message(format!("读取流失败: {e}"))),
             }
         } else {
-            Err(AppError::Message("No response data received".to_string()))
+            Err(AppError::Message("未收到响应数据".to_string()))
         }
     }
 
     /// Codex 流式检查
-    ///
-    /// 严格按照 Codex CLI 真实请求格式构建请求 (Responses API)
     async fn check_codex_stream(
         client: &Client,
         base_url: &str,
         auth: &AuthInfo,
         model: &str,
-        test_prompt: &str,
         timeout: std::time::Duration,
     ) -> Result<(u16, String), AppError> {
         let base = base_url.trim_end_matches('/');
-        // Codex CLI 使用 /v1/responses 端点 (OpenAI Responses API)
         let url = if base.ends_with("/v1") {
-            format!("{base}/responses")
+            format!("{base}/chat/completions")
         } else {
-            format!("{base}/v1/responses")
+            format!("{base}/v1/chat/completions")
         };
 
         // 解析模型名和推理等级 (支持 model@level 或 model#level 格式)
         let (actual_model, reasoning_effort) = Self::parse_model_with_effort(model);
 
-        // 获取本地系统信息
-        let os_name = Self::get_os_name();
-        let arch_name = Self::get_arch_name();
-
-        // Responses API 请求体格式 (input 必须是数组)
         let mut body = json!({
             "model": actual_model,
-            "input": [{ "role": "user", "content": test_prompt }],
+            "messages": [
+                { "role": "system", "content": "" },
+                { "role": "assistant", "content": "" },
+                { "role": "user", "content": "hi" }
+            ],
+            "max_tokens": 1,
+            "temperature": 0,
             "stream": true
         });
 
         // 如果是推理模型，添加 reasoning_effort
         if let Some(effort) = reasoning_effort {
-            body["reasoning"] = json!({ "effort": effort });
+            body["reasoning_effort"] = json!(effort);
         }
 
-        // 严格按照 Codex CLI 请求格式设置 headers
         let response = client
             .post(&url)
-            .header("authorization", format!("Bearer {}", auth.api_key))
-            .header("content-type", "application/json")
-            .header("accept", "text/event-stream")
-            .header("accept-encoding", "identity")
-            .header(
-                "user-agent",
-                format!("codex_cli_rs/0.80.0 ({os_name} 15.7.2; {arch_name}) Terminal"),
-            )
-            .header("originator", "codex_cli_rs")
+            .header("Authorization", format!("Bearer {}", auth.api_key))
+            .header("Content-Type", "application/json")
             .timeout(timeout)
             .json(&body)
             .send()
@@ -373,10 +308,10 @@ impl StreamCheckService {
         if let Some(chunk) = stream.next().await {
             match chunk {
                 Ok(_) => Ok((status, model.to_string())),
-                Err(e) => Err(AppError::Message(format!("Stream read failed: {e}"))),
+                Err(e) => Err(AppError::Message(format!("读取流失败: {e}"))),
             }
         } else {
-            Err(AppError::Message("No response data received".to_string()))
+            Err(AppError::Message("未收到响应数据".to_string()))
         }
     }
 
@@ -386,7 +321,6 @@ impl StreamCheckService {
         base_url: &str,
         auth: &AuthInfo,
         model: &str,
-        test_prompt: &str,
         timeout: std::time::Duration,
     ) -> Result<(u16, String), AppError> {
         let base = base_url.trim_end_matches('/');
@@ -394,7 +328,7 @@ impl StreamCheckService {
 
         let body = json!({
             "model": model,
-            "messages": [{ "role": "user", "content": test_prompt }],
+            "messages": [{ "role": "user", "content": "hi" }],
             "max_tokens": 1,
             "temperature": 0,
             "stream": true
@@ -421,10 +355,10 @@ impl StreamCheckService {
         if let Some(chunk) = stream.next().await {
             match chunk {
                 Ok(_) => Ok((status, model.to_string())),
-                Err(e) => Err(AppError::Message(format!("Stream read failed: {e}"))),
+                Err(e) => Err(AppError::Message(format!("读取流失败: {e}"))),
             }
         } else {
-            Err(AppError::Message("No response data received".to_string()))
+            Err(AppError::Message("未收到响应数据".to_string()))
         }
     }
 
@@ -439,6 +373,7 @@ impl StreamCheckService {
     /// 解析模型名和推理等级 (支持 model@level 或 model#level 格式)
     /// 返回 (实际模型名, Option<推理等级>)
     fn parse_model_with_effort(model: &str) -> (String, Option<String>) {
+        // 查找 @ 或 # 分隔符
         if let Some(pos) = model.find('@').or_else(|| model.find('#')) {
             let actual_model = model[..pos].to_string();
             let effort = model[pos + 1..].to_string();
@@ -451,14 +386,17 @@ impl StreamCheckService {
 
     fn should_retry(msg: &str) -> bool {
         let lower = msg.to_lowercase();
-        lower.contains("timeout") || lower.contains("abort") || lower.contains("timed out")
+        lower.contains("timeout")
+            || lower.contains("abort")
+            || lower.contains("中断")
+            || lower.contains("超时")
     }
 
     fn map_request_error(e: reqwest::Error) -> AppError {
         if e.is_timeout() {
-            AppError::Message("Request timeout".to_string())
+            AppError::Message("请求超时".to_string())
         } else if e.is_connect() {
-            AppError::Message(format!("Connection failed: {e}"))
+            AppError::Message(format!("连接失败: {e}"))
         } else {
             AppError::Message(e.to_string())
         }
@@ -505,26 +443,6 @@ impl StreamCheckService {
             .map(|m| m.as_str().trim().to_string())
             .filter(|value| !value.is_empty())
     }
-
-    /// 获取操作系统名称（映射为 Claude CLI 使用的格式）
-    fn get_os_name() -> &'static str {
-        match std::env::consts::OS {
-            "macos" => "MacOS",
-            "linux" => "Linux",
-            "windows" => "Windows",
-            other => other,
-        }
-    }
-
-    /// 获取 CPU 架构名称（映射为 Claude CLI 使用的格式）
-    fn get_arch_name() -> &'static str {
-        match std::env::consts::ARCH {
-            "aarch64" => "arm64",
-            "x86_64" => "x86_64",
-            "x86" => "x86",
-            other => other,
-        }
-    }
 }
 
 #[cfg(test)]
@@ -549,10 +467,9 @@ mod tests {
 
     #[test]
     fn test_should_retry() {
-        assert!(StreamCheckService::should_retry("Request timeout"));
-        assert!(StreamCheckService::should_retry("request timed out"));
-        assert!(StreamCheckService::should_retry("connection abort"));
-        assert!(!StreamCheckService::should_retry("API Key invalid"));
+        assert!(StreamCheckService::should_retry("请求超时"));
+        assert!(StreamCheckService::should_retry("request timeout"));
+        assert!(!StreamCheckService::should_retry("API Key 无效"));
     }
 
     #[test]
@@ -580,33 +497,4 @@ mod tests {
         assert_eq!(model, "gpt-4o-mini");
         assert_eq!(effort, None);
     }
-
-    #[test]
-    fn test_get_os_name() {
-        let os_name = StreamCheckService::get_os_name();
-        // 确保返回非空字符串
-        assert!(!os_name.is_empty());
-        // 在 macOS 上应该返回 "MacOS"
-        #[cfg(target_os = "macos")]
-        assert_eq!(os_name, "MacOS");
-        // 在 Linux 上应该返回 "Linux"
-        #[cfg(target_os = "linux")]
-        assert_eq!(os_name, "Linux");
-        // 在 Windows 上应该返回 "Windows"
-        #[cfg(target_os = "windows")]
-        assert_eq!(os_name, "Windows");
-    }
-
-    #[test]
-    fn test_get_arch_name() {
-        let arch_name = StreamCheckService::get_arch_name();
-        // 确保返回非空字符串
-        assert!(!arch_name.is_empty());
-        // 在 ARM64 上应该返回 "arm64"
-        #[cfg(target_arch = "aarch64")]
-        assert_eq!(arch_name, "arm64");
-        // 在 x86_64 上应该返回 "x86_64"
-        #[cfg(target_arch = "x86_64")]
-        assert_eq!(arch_name, "x86_64");
-    }
 }

src/components/providers/ProviderCard.tsx

@@ -1,4 +1,4 @@
-import { useMemo, useState, useEffect, useRef } from "react";
+import { useMemo, useState, useEffect } from "react";
 import { GripVertical, ChevronDown, ChevronUp } from "lucide-react";
 import { useTranslation } from "react-i18next";
 import type {
@@ -149,10 +149,6 @@ export function ProviderCard({
   // 多套餐默认展开
   const [isExpanded, setIsExpanded] = useState(false);
 
-  // 操作按钮容器 ref，用于动态计算宽度
-  const actionsRef = useRef<HTMLDivElement>(null);
-  const [actionsWidth, setActionsWidth] = useState(0);
-
   // 当检测到多套餐时自动展开
   useEffect(() => {
     if (hasMultiplePlans) {
@@ -160,20 +156,6 @@ export function ProviderCard({
     }
   }, [hasMultiplePlans]);
 
-  // 动态获取操作按钮宽度
-  useEffect(() => {
-    if (actionsRef.current) {
-      const updateWidth = () => {
-        const width = actionsRef.current?.offsetWidth || 0;
-        setActionsWidth(width);
-      };
-      updateWidth();
-      // 监听窗口大小变化
-      window.addEventListener("resize", updateWidth);
-      return () => window.removeEventListener("resize", updateWidth);
-    }
-  }, [onTest, onOpenTerminal]); // 按钮数量可能变化时重新计算
-
   const handleOpenWebsite = () => {
     if (!isClickableUrl) {
       return;
@@ -299,17 +281,10 @@ export function ProviderCard({
           </div>
         </div>
 
-        <div
-          className="relative flex items-center ml-auto min-w-0 gap-3"
-          style={
-            {
-              "--actions-width": `${actionsWidth || 320}px`,
-            } as React.CSSProperties
-          }
-        >
+        <div className="relative flex items-center ml-auto min-w-0">
           {/* 用量信息区域 - hover 时向左移动，为操作按钮腾出空间 */}
-          <div className="ml-auto">
-            <div className="flex items-center gap-1 transition-transform duration-200 group-hover:-translate-x-[var(--actions-width)] group-focus-within:-translate-x-[var(--actions-width)]">
+          <div className="ml-auto transition-transform duration-200 group-hover:-translate-x-[14.5rem] group-focus-within:-translate-x-[14.5rem] sm:group-hover:-translate-x-[16rem] sm:group-focus-within:-translate-x-[16rem]">
+            <div className="flex items-center gap-1">
               {/* 多套餐时显示套餐数量，单套餐时显示详细信息 */}
               {hasMultiplePlans ? (
                 <div className="flex items-center gap-2 text-xs text-gray-600 dark:text-gray-400">
@@ -354,11 +329,8 @@ export function ProviderCard({
             </div>
           </div>
 
-          {/* 操作按钮区域 - 绝对定位在右侧，hover 时滑入，与用量信息保持间距 */}
-          <div
-            ref={actionsRef}
-            className="absolute right-0 top-1/2 -translate-y-1/2 flex items-center gap-1.5 pl-3 opacity-0 pointer-events-none group-hover:opacity-100 group-focus-within:opacity-100 group-hover:pointer-events-auto group-focus-within:pointer-events-auto transition-all duration-200 translate-x-2 group-hover:translate-x-0 group-focus-within:translate-x-0"
-          >
+          {/* 操作按钮区域 - 绝对定位在右侧，hover 时滑入 */}
+          <div className="absolute right-0 top-1/2 -translate-y-1/2 flex items-center gap-1.5 opacity-0 pointer-events-none group-hover:opacity-100 group-focus-within:opacity-100 group-hover:pointer-events-auto group-focus-within:pointer-events-auto transition-all duration-200 translate-x-2 group-hover:translate-x-0 group-focus-within:translate-x-0">
             <ProviderActions
               isCurrent={isCurrent}
               isTesting={isTesting}

src/components/settings/RectifierConfigPanel.tsx

@@ -1,75 +0,0 @@
-import { useEffect, useState } from "react";
-import { useTranslation } from "react-i18next";
-import { toast } from "sonner";
-import { Switch } from "@/components/ui/switch";
-import { Label } from "@/components/ui/label";
-import { settingsApi, type RectifierConfig } from "@/lib/api/settings";
-
-export function RectifierConfigPanel() {
-  const { t } = useTranslation();
-  const [config, setConfig] = useState<RectifierConfig>({
-    enabled: true,
-    requestThinkingSignature: true,
-  });
-  const [isLoading, setIsLoading] = useState(true);
-
-  useEffect(() => {
-    settingsApi
-      .getRectifierConfig()
-      .then(setConfig)
-      .catch((e) => console.error("Failed to load rectifier config:", e))
-      .finally(() => setIsLoading(false));
-  }, []);
-
-  const handleChange = async (updates: Partial<RectifierConfig>) => {
-    const newConfig = { ...config, ...updates };
-    setConfig(newConfig);
-    try {
-      await settingsApi.setRectifierConfig(newConfig);
-    } catch (e) {
-      console.error("Failed to save rectifier config:", e);
-      toast.error(String(e));
-      setConfig(config);
-    }
-  };
-
-  if (isLoading) return null;
-
-  return (
-    <div className="space-y-6">
-      <div className="flex items-center justify-between">
-        <div className="space-y-0.5">
-          <Label>{t("settings.advanced.rectifier.enabled")}</Label>
-          <p className="text-xs text-muted-foreground">
-            {t("settings.advanced.rectifier.enabledDescription")}
-          </p>
-        </div>
-        <Switch
-          checked={config.enabled}
-          onCheckedChange={(checked) => handleChange({ enabled: checked })}
-        />
-      </div>
-
-      <div className="space-y-4">
-        <h4 className="text-sm font-medium text-muted-foreground">
-          {t("settings.advanced.rectifier.requestGroup")}
-        </h4>
-        <div className="flex items-center justify-between pl-4">
-          <div className="space-y-0.5">
-            <Label>{t("settings.advanced.rectifier.thinkingSignature")}</Label>
-            <p className="text-xs text-muted-foreground">
-              {t("settings.advanced.rectifier.thinkingSignatureDescription")}
-            </p>
-          </div>
-          <Switch
-            checked={config.requestThinkingSignature}
-            disabled={!config.enabled}
-            onCheckedChange={(checked) =>
-              handleChange({ requestThinkingSignature: checked })
-            }
-          />
-        </div>
-      </div>
-    </div>
-  );
-}

src/components/settings/SettingsPage.tsx

@@ -9,7 +9,6 @@ import {
   Database,
   Server,
   ChevronDown,
-  Zap,
   Globe,
 } from "lucide-react";
 import * as AccordionPrimitive from "@radix-ui/react-accordion";
@@ -43,7 +42,6 @@ import { ModelTestConfigPanel } from "@/components/usage/ModelTestConfigPanel";
 import { AutoFailoverConfigPanel } from "@/components/proxy/AutoFailoverConfigPanel";
 import { FailoverQueueManager } from "@/components/proxy/FailoverQueueManager";
 import { UsageDashboard } from "@/components/usage/UsageDashboard";
-import { RectifierConfigPanel } from "@/components/settings/RectifierConfigPanel";
 import { useSettings } from "@/hooks/useSettings";
 import { useImportExport } from "@/hooks/useImportExport";
 import { useTranslation } from "react-i18next";
@@ -552,28 +550,6 @@ export function SettingsPage({
                         />
                       </AccordionContent>
                     </AccordionItem>
-
-                    <AccordionItem
-                      value="rectifier"
-                      className="rounded-xl glass-card overflow-hidden"
-                    >
-                      <AccordionTrigger className="px-6 py-4 hover:no-underline hover:bg-muted/50 data-[state=open]:bg-muted/50">
-                        <div className="flex items-center gap-3">
-                          <Zap className="h-5 w-5 text-purple-500" />
-                          <div className="text-left">
-                            <h3 className="text-base font-semibold">
-                              {t("settings.advanced.rectifier.title")}
-                            </h3>
-                            <p className="text-sm text-muted-foreground font-normal">
-                              {t("settings.advanced.rectifier.description")}
-                            </p>
-                          </div>
-                        </div>
-                      </AccordionTrigger>
-                      <AccordionContent className="px-6 pb-6 pt-4 border-t border-border/50">
-                        <RectifierConfigPanel />
-                      </AccordionContent>
-                    </AccordionItem>
                   </Accordion>
 
                   <div className="pt-4">

src/components/usage/ModelTestConfigPanel.tsx

@@ -2,7 +2,6 @@ import { useState, useEffect } from "react";
 import { useTranslation } from "react-i18next";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
-import { Textarea } from "@/components/ui/textarea";
 import { Label } from "@/components/ui/label";
 import { Alert, AlertDescription } from "@/components/ui/alert";
 import { Save, Loader2 } from "lucide-react";
@@ -26,7 +25,6 @@ export function ModelTestConfigPanel() {
     claudeModel: "claude-haiku-4-5-20251001",
     codexModel: "gpt-5.1-codex@low",
     geminiModel: "gemini-3-pro-preview",
-    testPrompt: "Who are you?",
   });
 
   useEffect(() => {
@@ -45,7 +43,6 @@ export function ModelTestConfigPanel() {
         claudeModel: data.claudeModel,
         codexModel: data.codexModel,
         geminiModel: data.geminiModel,
-        testPrompt: data.testPrompt || "Who are you?",
       });
     } catch (e) {
       setError(String(e));
@@ -69,7 +66,6 @@ export function ModelTestConfigPanel() {
         claudeModel: config.claudeModel,
         codexModel: config.codexModel,
         geminiModel: config.geminiModel,
-        testPrompt: config.testPrompt || "Who are you?",
       };
       await saveStreamCheckConfig(parsed);
       toast.success(t("streamCheck.configSaved"), {
@@ -193,21 +189,6 @@ export function ModelTestConfigPanel() {
             />
           </div>
         </div>
-
-        {/* 检查提示词配置 */}
-        <div className="space-y-2">
-          <Label htmlFor="testPrompt">{t("streamCheck.testPrompt")}</Label>
-          <Textarea
-            id="testPrompt"
-            value={config.testPrompt}
-            onChange={(e) =>
-              setConfig({ ...config, testPrompt: e.target.value })
-            }
-            placeholder="Who are you?"
-            rows={2}
-            className="min-h-[60px]"
-          />
-        </div>
       </div>
 
       <div className="flex justify-end">

src/components/usage/PricingConfigPanel.tsx

@@ -202,7 +202,6 @@ export function PricingConfigPanel() {
 
       {editingModel && (
         <PricingEditModal
-          open={!!editingModel}
           model={editingModel}
           isNew={isAddingNew}
           onClose={() => {

src/components/usage/PricingEditModal.tsx

@@ -1,8 +1,13 @@
 import { useState } from "react";
 import { useTranslation } from "react-i18next";
 import { toast } from "sonner";
-import { Save, Plus } from "lucide-react";
-import { FullScreenPanel } from "@/components/common/FullScreenPanel";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogFooter,
+} from "@/components/ui/dialog";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
@@ -10,14 +15,12 @@ import { useUpdateModelPricing } from "@/lib/query/usage";
 import type { ModelPricing } from "@/types/usage";
 
 interface PricingEditModalProps {
-  open: boolean;
   model: ModelPricing;
   isNew?: boolean;
   onClose: () => void;
 }
 
 export function PricingEditModal({
-  open,
   model,
   isNew = false,
   onClose,
@@ -83,142 +86,139 @@ export function PricingEditModal({
   };
 
   return (
-    <FullScreenPanel
-      isOpen={open}
-      title={
-        isNew
-          ? t("usage.addPricing", "新增定价")
-          : `${t("usage.editPricing", "编辑定价")} - ${model.modelId}`
-      }
-      onClose={onClose}
-      footer={
-        <Button
-          type="submit"
-          form="pricing-form"
-          disabled={updatePricing.isPending}
-        >
-          {isNew ? (
-            <Plus className="h-4 w-4 mr-2" />
-          ) : (
-            <Save className="h-4 w-4 mr-2" />
+    <Dialog open onOpenChange={onClose}>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>
+            {isNew
+              ? t("usage.addPricing", "新增定价")
+              : `${t("usage.editPricing", "编辑定价")} - ${model.modelId}`}
+          </DialogTitle>
+        </DialogHeader>
+
+        <form onSubmit={handleSubmit} className="space-y-4">
+          {isNew && (
+            <div className="space-y-2">
+              <Label htmlFor="modelId">{t("usage.modelId", "模型 ID")}</Label>
+              <Input
+                id="modelId"
+                value={formData.modelId}
+                onChange={(e) =>
+                  setFormData({ ...formData, modelId: e.target.value })
+                }
+                placeholder={t("usage.modelIdPlaceholder", {
+                  defaultValue: "例如: claude-3-5-sonnet-20241022",
+                })}
+                required
+              />
+            </div>
           )}
-          {updatePricing.isPending
-            ? t("common.saving", "保存中...")
-            : isNew
-              ? t("common.add", "新增")
-              : t("common.save", "保存")}
-        </Button>
-      }
-    >
-      <form id="pricing-form" onSubmit={handleSubmit} className="space-y-6">
-        {isNew && (
+
           <div className="space-y-2">
-            <Label htmlFor="modelId">{t("usage.modelId", "模型 ID")}</Label>
+            <Label htmlFor="displayName">
+              {t("usage.displayName", "显示名称")}
+            </Label>
             <Input
-              id="modelId"
-              value={formData.modelId}
+              id="displayName"
+              value={formData.displayName}
               onChange={(e) =>
-                setFormData({ ...formData, modelId: e.target.value })
+                setFormData({ ...formData, displayName: e.target.value })
               }
-              placeholder={t("usage.modelIdPlaceholder", {
-                defaultValue: "例如: claude-3-5-sonnet-20241022",
+              placeholder={t("usage.displayNamePlaceholder", {
+                defaultValue: "例如: Claude 3.5 Sonnet",
               })}
               required
             />
           </div>
-        )}
 
-        <div className="space-y-2">
-          <Label htmlFor="displayName">
-            {t("usage.displayName", "显示名称")}
-          </Label>
-          <Input
-            id="displayName"
-            value={formData.displayName}
-            onChange={(e) =>
-              setFormData({ ...formData, displayName: e.target.value })
-            }
-            placeholder={t("usage.displayNamePlaceholder", {
-              defaultValue: "例如: Claude 3.5 Sonnet",
-            })}
-            required
-          />
-        </div>
+          <div className="space-y-2">
+            <Label htmlFor="inputCost">
+              {t("usage.inputCostPerMillion", "输入成本 (每百万 tokens, USD)")}
+            </Label>
+            <Input
+              id="inputCost"
+              type="number"
+              step="0.01"
+              min="0"
+              value={formData.inputCost}
+              onChange={(e) =>
+                setFormData({ ...formData, inputCost: e.target.value })
+              }
+              required
+            />
+          </div>
 
-        <div className="space-y-2">
-          <Label htmlFor="inputCost">
-            {t("usage.inputCostPerMillion", "输入成本 (每百万 tokens, USD)")}
-          </Label>
-          <Input
-            id="inputCost"
-            type="number"
-            step="0.01"
-            min="0"
-            value={formData.inputCost}
-            onChange={(e) =>
-              setFormData({ ...formData, inputCost: e.target.value })
-            }
-            required
-          />
-        </div>
+          <div className="space-y-2">
+            <Label htmlFor="outputCost">
+              {t("usage.outputCostPerMillion", "输出成本 (每百万 tokens, USD)")}
+            </Label>
+            <Input
+              id="outputCost"
+              type="number"
+              step="0.01"
+              min="0"
+              value={formData.outputCost}
+              onChange={(e) =>
+                setFormData({ ...formData, outputCost: e.target.value })
+              }
+              required
+            />
+          </div>
 
-        <div className="space-y-2">
-          <Label htmlFor="outputCost">
-            {t("usage.outputCostPerMillion", "输出成本 (每百万 tokens, USD)")}
-          </Label>
-          <Input
-            id="outputCost"
-            type="number"
-            step="0.01"
-            min="0"
-            value={formData.outputCost}
-            onChange={(e) =>
-              setFormData({ ...formData, outputCost: e.target.value })
-            }
-            required
-          />
-        </div>
+          <div className="space-y-2">
+            <Label htmlFor="cacheReadCost">
+              {t(
+                "usage.cacheReadCostPerMillion",
+                "缓存读取成本 (每百万 tokens, USD)",
+              )}
+            </Label>
+            <Input
+              id="cacheReadCost"
+              type="number"
+              step="0.01"
+              min="0"
+              value={formData.cacheReadCost}
+              onChange={(e) =>
+                setFormData({ ...formData, cacheReadCost: e.target.value })
+              }
+              required
+            />
+          </div>
 
-        <div className="space-y-2">
-          <Label htmlFor="cacheReadCost">
-            {t(
-              "usage.cacheReadCostPerMillion",
-              "缓存读取成本 (每百万 tokens, USD)",
-            )}
-          </Label>
-          <Input
-            id="cacheReadCost"
-            type="number"
-            step="0.01"
-            min="0"
-            value={formData.cacheReadCost}
-            onChange={(e) =>
-              setFormData({ ...formData, cacheReadCost: e.target.value })
-            }
-            required
-          />
-        </div>
+          <div className="space-y-2">
+            <Label htmlFor="cacheCreationCost">
+              {t(
+                "usage.cacheCreationCostPerMillion",
+                "缓存写入成本 (每百万 tokens, USD)",
+              )}
+            </Label>
+            <Input
+              id="cacheCreationCost"
+              type="number"
+              step="0.01"
+              min="0"
+              value={formData.cacheCreationCost}
+              onChange={(e) =>
+                setFormData({ ...formData, cacheCreationCost: e.target.value })
+              }
+              required
+            />
+          </div>
 
-        <div className="space-y-2">
-          <Label htmlFor="cacheCreationCost">
-            {t(
-              "usage.cacheCreationCostPerMillion",
-              "缓存写入成本 (每百万 tokens, USD)",
-            )}
-          </Label>
-          <Input
-            id="cacheCreationCost"
-            type="number"
-            step="0.01"
-            min="0"
-            value={formData.cacheCreationCost}
-            onChange={(e) =>
-              setFormData({ ...formData, cacheCreationCost: e.target.value })
-            }
-            required
-          />
-        </div>
-      </form>
-    </FullScreenPanel>
+          <DialogFooter>
+            <Button type="button" variant="outline" onClick={onClose}>
+              {t("common.cancel", "取消")}
+            </Button>
+            <Button type="submit" disabled={updatePricing.isPending}>
+              {updatePricing.isPending
+                ? t("common.saving", "保存中...")
+                : isNew
+                  ? t("common.add", "新增")
+                  : t("common.save", "保存")}
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
   );
 }

src/i18n/locales/en.json

@@ -190,16 +190,6 @@
       "data": {
         "title": "Data Management",
         "description": "Import/export configurations and backup/restore"
-      },
-      "rectifier": {
-        "title": "Rectifier",
-        "description": "Automatically fix API request compatibility issues",
-        "enabled": "Enable Rectifier",
-        "enabledDescription": "Master switch, all rectification features will be disabled when turned off",
-        "requestGroup": "Request Rectification",
-        "responseGroup": "Response Rectification",
-        "thinkingSignature": "Thinking Signature Rectification",
-        "thinkingSignatureDescription": "Automatically fix Claude API errors caused by thinking signature validation failures"
       }
     },
     "language": "Language",
@@ -1202,8 +1192,7 @@
     "checkParams": "Check Parameters",
     "timeout": "Timeout (seconds)",
     "maxRetries": "Max Retries",
-    "degradedThreshold": "Degraded Threshold (ms)",
-    "testPrompt": "Test Prompt"
+    "degradedThreshold": "Degraded Threshold (ms)"
   },
   "proxyConfig": {
     "proxyEnabled": "Proxy Enabled",

src/i18n/locales/ja.json

@@ -190,16 +190,6 @@
       "data": {
         "title": "データ管理",
         "description": "設定のインポート/エクスポートとバックアップ/復元"
-      },
-      "rectifier": {
-        "title": "整流器",
-        "description": "API リクエストの互換性問題を自動修正",
-        "enabled": "整流器を有効化",
-        "enabledDescription": "マスタースイッチ、オフにするとすべての整流機能が無効になります",
-        "requestGroup": "リクエスト整流",
-        "responseGroup": "レスポンス整流",
-        "thinkingSignature": "Thinking 署名整流",
-        "thinkingSignatureDescription": "Claude API の thinking 署名検証エラーを自動修正"
       }
     },
     "language": "言語",
@@ -1196,8 +1186,7 @@
     "checkParams": "チェックパラメーター",
     "timeout": "タイムアウト（秒）",
     "maxRetries": "最大リトライ回数",
-    "degradedThreshold": "劣化しきい値（ミリ秒）",
-    "testPrompt": "テストプロンプト"
+    "degradedThreshold": "劣化しきい値（ミリ秒）"
   },
   "proxyConfig": {
     "proxyEnabled": "プロキシ有効",

src/i18n/locales/zh.json

@@ -190,16 +190,6 @@
       "data": {
         "title": "数据管理",
         "description": "导入导出配置与备份恢复"
-      },
-      "rectifier": {
-        "title": "整流器",
-        "description": "自动修复 API 请求中的兼容性问题",
-        "enabled": "启用整流器",
-        "enabledDescription": "总开关，关闭后所有整流功能将被禁用",
-        "requestGroup": "请求整流",
-        "responseGroup": "响应整流",
-        "thinkingSignature": "Thinking 签名整流",
-        "thinkingSignatureDescription": "自动修复 Claude API 中因 thinking 签名校验失败导致的请求错误"
       }
     },
     "language": "界面语言",
@@ -1202,8 +1192,7 @@
     "checkParams": "检查参数",
     "timeout": "超时时间（秒）",
     "maxRetries": "最大重试次数",
-    "degradedThreshold": "降级阈值（毫秒）",
-    "testPrompt": "检查提示词"
+    "degradedThreshold": "降级阈值（毫秒）"
   },
   "proxyConfig": {
     "proxyEnabled": "代理总开关",

src/lib/api/model-test.ts

@@ -12,7 +12,6 @@ export interface StreamCheckConfig {
   claudeModel: string;
   codexModel: string;
   geminiModel: string;
-  testPrompt: string;
 }
 
 export interface StreamCheckResult {

src/lib/api/settings.ts

@@ -134,17 +134,4 @@ export const settingsApi = {
   > {
     return await invoke("get_tool_versions");
   },
-
-  async getRectifierConfig(): Promise<RectifierConfig> {
-    return await invoke("get_rectifier_config");
-  },
-
-  async setRectifierConfig(config: RectifierConfig): Promise<boolean> {
-    return await invoke("set_rectifier_config", { config });
-  },
 };
-
-export interface RectifierConfig {
-  enabled: boolean;
-  requestThinkingSignature: boolean;
-}