diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index df47eda..4c53864 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -14,6 +14,10 @@ rust-version = "1.85.0"
 name = "cc_switch_lib"
 crate-type = ["staticlib", "cdylib", "rlib"]
 
+[features]
+default = []
+test-hooks = []
+
 [build-dependencies]
 tauri-build = { version = "2.4.0", features = [] }
 
diff --git a/src-tauri/src/app_store.rs b/src-tauri/src/app_store.rs
index fe16e1f..485fdf7 100644
--- a/src-tauri/src/app_store.rs
+++ b/src-tauri/src/app_store.rs
@@ -8,40 +8,32 @@ use crate::error::AppError;
 /// Store 中的键名
 const STORE_KEY_APP_CONFIG_DIR: &str = "app_config_dir_override";
 
-/// 全局缓存的 AppHandle (在应用启动时设置)
-static APP_HANDLE: OnceLock<RwLock<Option<tauri::AppHandle>>> = OnceLock::new();
+/// 缓存当前的 app_config_dir 覆盖路径，避免存储 AppHandle
+static APP_CONFIG_DIR_OVERRIDE: OnceLock<RwLock<Option<PathBuf>>> = OnceLock::new();
 
-/// 设置全局 AppHandle
-pub fn set_app_handle(handle: tauri::AppHandle) {
-    let store = APP_HANDLE.get_or_init(|| RwLock::new(None));
-    if let Ok(mut guard) = store.write() {
-        *guard = Some(handle);
+fn override_cache() -> &'static RwLock<Option<PathBuf>> {
+    APP_CONFIG_DIR_OVERRIDE.get_or_init(|| RwLock::new(None))
+}
+
+fn update_cached_override(value: Option<PathBuf>) {
+    if let Ok(mut guard) = override_cache().write() {
+        *guard = value;
     }
 }
 
-/// 获取全局 AppHandle
-fn get_app_handle() -> Option<tauri::AppHandle> {
-    let store = APP_HANDLE.get()?;
-    let guard = store.read().ok()?;
-    guard.as_ref().cloned()
-}
-
-/// 从 Tauri Store 读取 app_config_dir 覆盖配置 (无需 AppHandle 版本)
+/// 获取缓存中的 app_config_dir 覆盖路径
 pub fn get_app_config_dir_override() -> Option<PathBuf> {
-    let app = get_app_handle()?;
-    get_app_config_dir_from_store(&app)
+    override_cache().read().ok()?.clone()
 }
 
-/// 从 Tauri Store 读取 app_config_dir 覆盖配置（公开函数）
-pub fn get_app_config_dir_from_store(app: &tauri::AppHandle) -> Option<PathBuf> {
-    let store = app.store_builder("app_paths.json").build();
-
-    if let Err(e) = &store {
-        log::warn!("无法创建 Store: {}", e);
-        return None;
-    }
-
-    let store = store.unwrap();
+fn read_override_from_store(app: &tauri::AppHandle) -> Option<PathBuf> {
+    let store = match app.store_builder("app_paths.json").build() {
+        Ok(store) => store,
+        Err(e) => {
+            log::warn!("无法创建 Store: {}", e);
+            return None;
+        }
+    };
 
     match store.get(STORE_KEY_APP_CONFIG_DIR) {
         Some(Value::String(path_str)) => {
@@ -52,7 +44,6 @@ pub fn get_app_config_dir_from_store(app: &tauri::AppHandle) -> Option<PathBuf>
 
             let path = resolve_path(path_str);
 
-            // 验证路径是否存在
             if !path.exists() {
                 log::warn!(
                     "Store 中配置的 app_config_dir 不存在: {:?}\n\
@@ -76,6 +67,13 @@ pub fn get_app_config_dir_from_store(app: &tauri::AppHandle) -> Option<PathBuf>
     }
 }
 
+/// 从 Store 刷新 app_config_dir 覆盖值并更新缓存
+pub fn refresh_app_config_dir_override(app: &tauri::AppHandle) -> Option<PathBuf> {
+    let value = read_override_from_store(app);
+    update_cached_override(value.clone());
+    value
+}
+
 /// 写入 app_config_dir 到 Tauri Store
 pub fn set_app_config_dir_to_store(
     app: &tauri::AppHandle,
@@ -93,13 +91,11 @@ pub fn set_app_config_dir_to_store(
                 store.set(STORE_KEY_APP_CONFIG_DIR, Value::String(trimmed.to_string()));
                 log::info!("已将 app_config_dir 写入 Store: {}", trimmed);
             } else {
-                // 空字符串 = 删除配置
                 store.delete(STORE_KEY_APP_CONFIG_DIR);
                 log::info!("已从 Store 中删除 app_config_dir 配置");
             }
         }
         None => {
-            // None = 删除配置
             store.delete(STORE_KEY_APP_CONFIG_DIR);
             log::info!("已从 Store 中删除 app_config_dir 配置");
         }
@@ -109,6 +105,7 @@ pub fn set_app_config_dir_to_store(
         .save()
         .map_err(|e| AppError::Message(format!("保存 Store 失败: {}", e)))?;
 
+    refresh_app_config_dir_override(app);
     Ok(())
 }
 
@@ -137,8 +134,6 @@ pub fn migrate_app_config_dir_from_settings(app: &tauri::AppHandle) -> Result<()
     // 如果用户在旧版本设置过 app_config_dir，需要在 Store 中手动配置
     log::info!("app_config_dir 迁移功能已移除，请在设置中重新配置");
 
-    // 确保 Store 初始化正常
-    let _ = get_app_config_dir_from_store(app);
-
+    let _ = refresh_app_config_dir_override(app);
     Ok(())
 }
diff --git a/src-tauri/src/commands/provider.rs b/src-tauri/src/commands/provider.rs
index 30580e7..e365c79 100644
--- a/src-tauri/src/commands/provider.rs
+++ b/src-tauri/src/commands/provider.rs
@@ -1,7 +1,4 @@
-#![allow(non_snake_case)]
-
 use std::collections::HashMap;
-
 use tauri::State;
 
 use crate::app_config::AppType;
@@ -16,95 +13,62 @@ fn missing_param(param: &str) -> String {
 
 /// 获取所有供应商
 #[tauri::command]
-pub async fn get_providers(
+pub fn get_providers(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
 ) -> Result<HashMap<String, Provider>, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
     ProviderService::list(state.inner(), app_type).map_err(|e| e.to_string())
 }
 
 /// 获取当前供应商ID
 #[tauri::command]
-pub async fn get_current_provider(
+pub fn get_current_provider(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
 ) -> Result<String, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
     ProviderService::current(state.inner(), app_type).map_err(|e| e.to_string())
 }
 
 /// 添加供应商
 #[tauri::command]
-pub async fn add_provider(
+pub fn add_provider(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
     provider: Provider,
 ) -> Result<bool, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
     ProviderService::add(state.inner(), app_type, provider).map_err(|e| e.to_string())
 }
 
 /// 更新供应商
 #[tauri::command]
-pub async fn update_provider(
+pub fn update_provider(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
     provider: Provider,
 ) -> Result<bool, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
     ProviderService::update(state.inner(), app_type, provider).map_err(|e| e.to_string())
 }
 
 /// 删除供应商
 #[tauri::command]
-pub async fn delete_provider(
+pub fn delete_provider(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
     id: String,
 ) -> Result<bool, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
-    {
-        let mut config = state
-            .config
-            .write()
-            .map_err(|e| format!("获取锁失败: {}", e))?;
-        ProviderService::delete(&mut config, app_type, &id).map_err(|e| e.to_string())?;
-    }
-
-    state.save()?;
-
-    Ok(true)
+    ProviderService::delete(state.inner(), app_type, &id)
+        .map(|_| true)
+        .map_err(|e| e.to_string())
 }
 
 /// 切换供应商
@@ -112,7 +76,7 @@ fn switch_provider_internal(state: &AppState, app_type: AppType, id: &str) -> Re
     ProviderService::switch(state, app_type, id)
 }
 
-#[doc(hidden)]
+#[cfg_attr(not(feature = "test-hooks"), doc(hidden))]
 pub fn switch_provider_test_hook(
     state: &AppState,
     app_type: AppType,
@@ -122,17 +86,12 @@ pub fn switch_provider_test_hook(
 }
 
 #[tauri::command]
-pub async fn switch_provider(
+pub fn switch_provider(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
     id: String,
 ) -> Result<bool, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
     switch_provider_internal(&state, app_type, &id)
         .map(|_| true)
@@ -143,7 +102,7 @@ fn import_default_config_internal(state: &AppState, app_type: AppType) -> Result
     ProviderService::import_default_config(state, app_type)
 }
 
-#[doc(hidden)]
+#[cfg_attr(not(feature = "test-hooks"), doc(hidden))]
 pub fn import_default_config_test_hook(
     state: &AppState,
     app_type: AppType,
@@ -153,16 +112,11 @@ pub fn import_default_config_test_hook(
 
 /// 导入当前配置为默认供应商
 #[tauri::command]
-pub async fn import_default_config(
+pub fn import_default_config(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
 ) -> Result<bool, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
     import_default_config_internal(&state, app_type)
         .map(|_| true)
@@ -174,19 +128,11 @@ pub async fn import_default_config(
 pub async fn query_provider_usage(
     state: State<'_, AppState>,
     provider_id: Option<String>,
-    providerId: Option<String>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
 ) -> Result<crate::provider::UsageResult, String> {
-    let provider_id = provider_id
-        .or(providerId)
-        .ok_or_else(|| missing_param("providerId"))?;
+    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
 
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
     ProviderService::query_usage(state.inner(), app_type, &provider_id)
         .await
@@ -195,15 +141,8 @@ pub async fn query_provider_usage(
 
 /// 读取当前生效的配置内容
 #[tauri::command]
-pub async fn read_live_provider_settings(
-    app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
-) -> Result<serde_json::Value, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+pub fn read_live_provider_settings(app_type: Option<AppType>) -> Result<serde_json::Value, String> {
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
     ProviderService::read_live_settings(app_type).map_err(|e| e.to_string())
 }
@@ -221,104 +160,67 @@ pub async fn test_api_endpoints(
 
 /// 获取自定义端点列表
 #[tauri::command]
-pub async fn get_custom_endpoints(
+pub fn get_custom_endpoints(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
     provider_id: Option<String>,
-    providerId: Option<String>,
 ) -> Result<Vec<crate::settings::CustomEndpoint>, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
-    let provider_id = provider_id
-        .or(providerId)
-        .ok_or_else(|| missing_param("providerId"))?;
+    let app_type = app_type.unwrap_or(AppType::Claude);
+    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
     ProviderService::get_custom_endpoints(state.inner(), app_type, &provider_id)
         .map_err(|e| e.to_string())
 }
 
 /// 添加自定义端点
 #[tauri::command]
-pub async fn add_custom_endpoint(
+pub fn add_custom_endpoint(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
     provider_id: Option<String>,
-    providerId: Option<String>,
     url: String,
 ) -> Result<(), String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
-    let provider_id = provider_id
-        .or(providerId)
-        .ok_or_else(|| missing_param("providerId"))?;
+    let app_type = app_type.unwrap_or(AppType::Claude);
+    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
     ProviderService::add_custom_endpoint(state.inner(), app_type, &provider_id, url)
         .map_err(|e| e.to_string())
 }
 
 /// 删除自定义端点
 #[tauri::command]
-pub async fn remove_custom_endpoint(
+pub fn remove_custom_endpoint(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
     provider_id: Option<String>,
-    providerId: Option<String>,
     url: String,
 ) -> Result<(), String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
-    let provider_id = provider_id
-        .or(providerId)
-        .ok_or_else(|| missing_param("providerId"))?;
+    let app_type = app_type.unwrap_or(AppType::Claude);
+    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
     ProviderService::remove_custom_endpoint(state.inner(), app_type, &provider_id, url)
         .map_err(|e| e.to_string())
 }
 
 /// 更新端点最后使用时间
 #[tauri::command]
-pub async fn update_endpoint_last_used(
+pub fn update_endpoint_last_used(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
     provider_id: Option<String>,
-    providerId: Option<String>,
     url: String,
 ) -> Result<(), String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
-    let provider_id = provider_id
-        .or(providerId)
-        .ok_or_else(|| missing_param("providerId"))?;
+    let app_type = app_type.unwrap_or(AppType::Claude);
+    let provider_id = provider_id.ok_or_else(|| missing_param("providerId"))?;
     ProviderService::update_endpoint_last_used(state.inner(), app_type, &provider_id, url)
         .map_err(|e| e.to_string())
 }
 
 /// 更新多个供应商的排序
 #[tauri::command]
-pub async fn update_providers_sort_order(
+pub fn update_providers_sort_order(
     state: State<'_, AppState>,
     app_type: Option<AppType>,
-    app: Option<String>,
-    appType: Option<String>,
     updates: Vec<ProviderSortUpdate>,
 ) -> Result<bool, String> {
-    let app_type = app_type
-        .or_else(|| app.as_deref().map(|s| s.into()))
-        .or_else(|| appType.as_deref().map(|s| s.into()))
-        .unwrap_or(AppType::Claude);
+    let app_type = app_type.unwrap_or(AppType::Claude);
 
     ProviderService::update_sort_order(state.inner(), app_type, updates).map_err(|e| e.to_string())
 }
diff --git a/src-tauri/src/commands/settings.rs b/src-tauri/src/commands/settings.rs
index 7f7292e..ee76526 100644
--- a/src-tauri/src/commands/settings.rs
+++ b/src-tauri/src/commands/settings.rs
@@ -24,7 +24,7 @@ pub async fn restart_app(app: AppHandle) -> Result<bool, String> {
 /// 获取 app_config_dir 覆盖配置 (从 Store)
 #[tauri::command]
 pub async fn get_app_config_dir_override(app: AppHandle) -> Result<Option<String>, String> {
-    Ok(crate::app_store::get_app_config_dir_from_store(&app)
+    Ok(crate::app_store::refresh_app_config_dir_override(&app)
         .map(|p| p.to_string_lossy().to_string()))
 }
 
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 5eaadde..133d8dc 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -221,14 +221,12 @@ fn handle_tray_menu_event(app: &tauri::AppHandle, event_id: &str) {
             // 执行切换
             let app_handle = app.clone();
             let provider_id = provider_id.to_string();
-            tauri::async_runtime::spawn(async move {
+            tauri::async_runtime::spawn_blocking(move || {
                 if let Err(e) = switch_provider_internal(
                     &app_handle,
                     crate::app_config::AppType::Claude,
                     provider_id,
-                )
-                .await
-                {
+                ) {
                     log::error!("切换Claude供应商失败: {}", e);
                 }
             });
@@ -240,14 +238,12 @@ fn handle_tray_menu_event(app: &tauri::AppHandle, event_id: &str) {
             // 执行切换
             let app_handle = app.clone();
             let provider_id = provider_id.to_string();
-            tauri::async_runtime::spawn(async move {
+            tauri::async_runtime::spawn_blocking(move || {
                 if let Err(e) = switch_provider_internal(
                     &app_handle,
                     crate::app_config::AppType::Codex,
                     provider_id,
-                )
-                .await
-                {
+                ) {
                     log::error!("切换Codex供应商失败: {}", e);
                 }
             });
@@ -261,7 +257,7 @@ fn handle_tray_menu_event(app: &tauri::AppHandle, event_id: &str) {
 //
 
 /// 内部切换供应商函数
-async fn switch_provider_internal(
+fn switch_provider_internal(
     app: &tauri::AppHandle,
     app_type: crate::app_config::AppType,
     provider_id: String,
@@ -271,15 +267,8 @@ async fn switch_provider_internal(
         let app_type_str = app_type.as_str().to_string();
         let provider_id_clone = provider_id.clone();
 
-        crate::commands::switch_provider(
-            app_state.clone(),
-            Some(app_type),
-            None,
-            None,
-            provider_id,
-        )
-        .await
-        .map_err(AppError::Message)?;
+        crate::commands::switch_provider(app_state.clone(), Some(app_type), provider_id)
+            .map_err(AppError::Message)?;
 
         // 切换成功后重新创建托盘菜单
         if let Ok(new_menu) = create_tray_menu(app, app_state.inner()) {
@@ -366,8 +355,6 @@ pub fn run() {
         .plugin(tauri_plugin_opener::init())
         .plugin(tauri_plugin_store::Builder::new().build())
         .setup(|app| {
-            // 设置全局 AppHandle 以供 Store 使用
-            app_store::set_app_handle(app.handle().clone());
             // 注册 Updater 插件（桌面端）
             #[cfg(desktop)]
             {
@@ -418,6 +405,9 @@ pub fn run() {
                 )?;
             }
 
+            // 预先刷新 Store 覆盖配置，确保 AppState 初始化时可读取到最新路径
+            app_store::refresh_app_config_dir_override(app.handle());
+
             // 初始化应用状态（仅创建一次，并在本函数末尾注入 manage）
             let app_state = AppState::new();
 
diff --git a/src-tauri/src/services/provider.rs b/src-tauri/src/services/provider.rs
index f8987bd..b9e88bd 100644
--- a/src-tauri/src/services/provider.rs
+++ b/src-tauri/src/services/provider.rs
@@ -1043,50 +1043,63 @@ impl ProviderService {
             .as_millis() as i64
     }
 
-    pub fn delete(
-        config: &mut MultiAppConfig,
-        app_type: AppType,
-        provider_id: &str,
-    ) -> Result<(), AppError> {
-        let current_matches = config
-            .get_manager(&app_type)
-            .map(|m| m.current == provider_id)
-            .unwrap_or(false);
-        if current_matches {
-            return Err(AppError::localized(
-                "provider.delete.current",
-                "不能删除当前正在使用的供应商",
-                "Cannot delete the provider currently in use",
-            ));
-        }
+    pub fn delete(state: &AppState, app_type: AppType, provider_id: &str) -> Result<(), AppError> {
+        let provider_snapshot = {
+            let config = state.config.read().map_err(AppError::from)?;
+            let manager = config
+                .get_manager(&app_type)
+                .ok_or_else(|| Self::app_not_found(&app_type))?;
 
-        let provider = config
-            .get_manager(&app_type)
-            .ok_or_else(|| Self::app_not_found(&app_type))?
-            .providers
-            .get(provider_id)
-            .cloned()
-            .ok_or_else(|| AppError::ProviderNotFound(provider_id.to_string()))?;
+            if manager.current == provider_id {
+                return Err(AppError::localized(
+                    "provider.delete.current",
+                    "不能删除当前正在使用的供应商",
+                    "Cannot delete the provider currently in use",
+                ));
+            }
+
+            manager
+                .providers
+                .get(provider_id)
+                .cloned()
+                .ok_or_else(|| AppError::ProviderNotFound(provider_id.to_string()))?
+        };
 
         match app_type {
             AppType::Codex => {
-                crate::codex_config::delete_codex_provider_config(provider_id, &provider.name)?;
+                crate::codex_config::delete_codex_provider_config(
+                    provider_id,
+                    &provider_snapshot.name,
+                )?;
             }
             AppType::Claude => {
                 // 兼容旧版本：历史上会在 Claude 目录内为每个供应商生成 settings-*.json 副本
                 // 这里继续清理这些遗留文件，避免堆积过期配置。
-                let by_name = get_provider_config_path(provider_id, Some(&provider.name));
+                let by_name = get_provider_config_path(provider_id, Some(&provider_snapshot.name));
                 let by_id = get_provider_config_path(provider_id, None);
                 delete_file(&by_name)?;
                 delete_file(&by_id)?;
             }
         }
 
-        if let Some(manager) = config.get_manager_mut(&app_type) {
+        {
+            let mut config = state.config.write().map_err(AppError::from)?;
+            let manager = config
+                .get_manager_mut(&app_type)
+                .ok_or_else(|| Self::app_not_found(&app_type))?;
+
+            if manager.current == provider_id {
+                return Err(AppError::localized(
+                    "provider.delete.current",
+                    "不能删除当前正在使用的供应商",
+                    "Cannot delete the provider currently in use",
+                ));
+            }
+
             manager.providers.remove(provider_id);
         }
 
-        Ok(())
+        state.save()
     }
 }
 
diff --git a/src-tauri/src/services/speedtest.rs b/src-tauri/src/services/speedtest.rs
index 3264966..83ec872 100644
--- a/src-tauri/src/services/speedtest.rs
+++ b/src-tauri/src/services/speedtest.rs
@@ -126,7 +126,7 @@ mod tests {
         );
         assert_eq!(
             SpeedtestService::sanitize_timeout(Some(10)),
-            10.min(MAX_TIMEOUT_SECS).max(MIN_TIMEOUT_SECS)
+            10.clamp(MIN_TIMEOUT_SECS, MAX_TIMEOUT_SECS)
         );
         assert_eq!(
             SpeedtestService::sanitize_timeout(None),
diff --git a/src-tauri/tests/provider_service.rs b/src-tauri/tests/provider_service.rs
index b96f20b..c24cc36 100644
--- a/src-tauri/tests/provider_service.rs
+++ b/src-tauri/tests/provider_service.rs
@@ -326,10 +326,15 @@ fn provider_service_delete_codex_removes_provider_and_files() {
     std::fs::write(&auth_path, "{}").expect("seed auth file");
     std::fs::write(&cfg_path, "base_url = \"https://example\"").expect("seed config file");
 
-    ProviderService::delete(&mut config, AppType::Codex, "to-delete")
+    let app_state = AppState {
+        config: RwLock::new(config),
+    };
+
+    ProviderService::delete(&app_state, AppType::Codex, "to-delete")
         .expect("delete provider should succeed");
 
-    let manager = config.get_manager(&AppType::Codex).expect("codex manager");
+    let locked = app_state.config.read().expect("lock config after delete");
+    let manager = locked.get_manager(&AppType::Codex).expect("codex manager");
     assert!(
         !manager.providers.contains_key("to-delete"),
         "provider entry should be removed"
@@ -384,10 +389,14 @@ fn provider_service_delete_claude_removes_provider_files() {
     std::fs::write(&by_name, "{}").expect("seed settings by name");
     std::fs::write(&by_id, "{}").expect("seed settings by id");
 
-    ProviderService::delete(&mut config, AppType::Claude, "delete")
-        .expect("delete claude provider");
+    let app_state = AppState {
+        config: RwLock::new(config),
+    };
 
-    let manager = config
+    ProviderService::delete(&app_state, AppType::Claude, "delete").expect("delete claude provider");
+
+    let locked = app_state.config.read().expect("lock config after delete");
+    let manager = locked
         .get_manager(&AppType::Claude)
         .expect("claude manager");
     assert!(
@@ -421,7 +430,11 @@ fn provider_service_delete_current_provider_returns_error() {
         );
     }
 
-    let err = ProviderService::delete(&mut config, AppType::Claude, "keep")
+    let app_state = AppState {
+        config: RwLock::new(config),
+    };
+
+    let err = ProviderService::delete(&app_state, AppType::Claude, "keep")
         .expect_err("deleting current provider should fail");
     match err {
         AppError::Localized { zh, .. } => assert!(
diff --git a/src/lib/api/providers.ts b/src/lib/api/providers.ts
index d7541ee..c5d0837 100644
--- a/src/lib/api/providers.ts
+++ b/src/lib/api/providers.ts
@@ -15,53 +15,31 @@ export interface ProviderSwitchEvent {
 
 export const providersApi = {
   async getAll(appType: AppType): Promise<Record<string, Provider>> {
-    return await invoke("get_providers", { app_type: appType, app: appType });
+    return await invoke("get_providers", { app_type: appType });
   },
 
   async getCurrent(appType: AppType): Promise<string> {
-    return await invoke("get_current_provider", {
-      app_type: appType,
-      app: appType,
-    });
+    return await invoke("get_current_provider", { app_type: appType });
   },
 
   async add(provider: Provider, appType: AppType): Promise<boolean> {
-    return await invoke("add_provider", {
-      provider,
-      app_type: appType,
-      app: appType,
-    });
+    return await invoke("add_provider", { provider, app_type: appType });
   },
 
   async update(provider: Provider, appType: AppType): Promise<boolean> {
-    return await invoke("update_provider", {
-      provider,
-      app_type: appType,
-      app: appType,
-    });
+    return await invoke("update_provider", { provider, app_type: appType });
   },
 
   async delete(id: string, appType: AppType): Promise<boolean> {
-    return await invoke("delete_provider", {
-      id,
-      app_type: appType,
-      app: appType,
-    });
+    return await invoke("delete_provider", { id, app_type: appType });
   },
 
   async switch(id: string, appType: AppType): Promise<boolean> {
-    return await invoke("switch_provider", {
-      id,
-      app_type: appType,
-      app: appType,
-    });
+    return await invoke("switch_provider", { id, app_type: appType });
   },
 
   async importDefault(appType: AppType): Promise<boolean> {
-    return await invoke("import_default_config", {
-      app_type: appType,
-      app: appType,
-    });
+    return await invoke("import_default_config", { app_type: appType });
   },
 
   async updateTrayMenu(): Promise<boolean> {
@@ -75,7 +53,6 @@ export const providersApi = {
     return await invoke("update_providers_sort_order", {
       updates,
       app_type: appType,
-      app: appType,
     });
   },
 
diff --git a/src/lib/api/settings.ts b/src/lib/api/settings.ts
index 8bfc255..ec7cfb7 100644
--- a/src/lib/api/settings.ts
+++ b/src/lib/api/settings.ts
@@ -31,14 +31,11 @@ export const settingsApi = {
   },
 
   async getConfigDir(appType: AppType): Promise<string> {
-    return await invoke("get_config_dir", {
-      app_type: appType,
-      app: appType,
-    });
+    return await invoke("get_config_dir", { app_type: appType });
   },
 
   async openConfigFolder(appType: AppType): Promise<void> {
-    await invoke("open_config_folder", { app_type: appType, app: appType });
+    await invoke("open_config_folder", { app_type: appType });
   },
 
   async selectConfigDirectory(defaultPath?: string): Promise<string | null> {
diff --git a/src/lib/api/usage.ts b/src/lib/api/usage.ts
index 4c42dd8..fa4ef81 100644
--- a/src/lib/api/usage.ts
+++ b/src/lib/api/usage.ts
@@ -6,10 +6,7 @@ export const usageApi = {
   async query(providerId: string, appType: AppType): Promise<UsageResult> {
     return await invoke("query_provider_usage", {
       provider_id: providerId,
-      providerId: providerId,
       app_type: appType,
-      app: appType,
-      appType,
     });
   },
 };
diff --git a/src/lib/api/vscode.ts b/src/lib/api/vscode.ts
index 7346fd6..c2fe05e 100644
--- a/src/lib/api/vscode.ts
+++ b/src/lib/api/vscode.ts
@@ -11,11 +11,7 @@ export interface EndpointLatencyResult {
 
 export const vscodeApi = {
   async getLiveProviderSettings(appType: AppType) {
-    return await invoke("read_live_provider_settings", {
-      app_type: appType,
-      app: appType,
-      appType,
-    });
+    return await invoke("read_live_provider_settings", { app_type: appType });
   },
 
   async testApiEndpoints(
@@ -34,10 +30,7 @@ export const vscodeApi = {
   ): Promise<CustomEndpoint[]> {
     return await invoke("get_custom_endpoints", {
       app_type: appType,
-      app: appType,
-      appType,
       provider_id: providerId,
-      providerId,
     });
   },
 
@@ -48,10 +41,7 @@ export const vscodeApi = {
   ): Promise<void> {
     await invoke("add_custom_endpoint", {
       app_type: appType,
-      app: appType,
-      appType,
       provider_id: providerId,
-      providerId,
       url,
     });
   },
@@ -63,10 +53,7 @@ export const vscodeApi = {
   ): Promise<void> {
     await invoke("remove_custom_endpoint", {
       app_type: appType,
-      app: appType,
-      appType,
       provider_id: providerId,
-      providerId,
       url,
     });
   },
@@ -78,10 +65,7 @@ export const vscodeApi = {
   ): Promise<void> {
     await invoke("update_endpoint_last_used", {
       app_type: appType,
-      app: appType,
-      appType,
       provider_id: providerId,
-      providerId,
       url,
     });
   },