feat(provider): add individual test and proxy config for providers

Add support for provider-specific model test and proxy configurations:

- Add ProviderTestConfig and ProviderProxyConfig types in Rust and TypeScript
- Create ProviderAdvancedConfig component with collapsible panels
- Update stream_check service to merge provider config with global config
- Proxy config UI follows global proxy style (single URL input)

Provider-level configs stored in meta field, no database schema changes needed.

src-tauri/src/provider.rs

@@ -142,6 +142,55 @@ pub struct UsageResult {
     pub error: Option<String>,
 }
 
+/// 供应商单独的模型测试配置
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ProviderTestConfig {
+    /// 是否启用单独配置（false 时使用全局配置）
+    #[serde(default)]
+    pub enabled: bool,
+    /// 测试用的模型名称（覆盖全局配置）
+    #[serde(rename = "testModel", skip_serializing_if = "Option::is_none")]
+    pub test_model: Option<String>,
+    /// 超时时间（秒）
+    #[serde(rename = "timeoutSecs", skip_serializing_if = "Option::is_none")]
+    pub timeout_secs: Option<u64>,
+    /// 测试提示词
+    #[serde(rename = "testPrompt", skip_serializing_if = "Option::is_none")]
+    pub test_prompt: Option<String>,
+    /// 降级阈值（毫秒）
+    #[serde(
+        rename = "degradedThresholdMs",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub degraded_threshold_ms: Option<u64>,
+    /// 最大重试次数
+    #[serde(rename = "maxRetries", skip_serializing_if = "Option::is_none")]
+    pub max_retries: Option<u32>,
+}
+
+/// 供应商单独的代理配置
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ProviderProxyConfig {
+    /// 是否启用单独配置（false 时使用全局/系统代理）
+    #[serde(default)]
+    pub enabled: bool,
+    /// 代理类型：http, https, socks5
+    #[serde(rename = "proxyType", skip_serializing_if = "Option::is_none")]
+    pub proxy_type: Option<String>,
+    /// 代理主机
+    #[serde(rename = "proxyHost", skip_serializing_if = "Option::is_none")]
+    pub proxy_host: Option<String>,
+    /// 代理端口
+    #[serde(rename = "proxyPort", skip_serializing_if = "Option::is_none")]
+    pub proxy_port: Option<u16>,
+    /// 代理用户名（可选）
+    #[serde(rename = "proxyUsername", skip_serializing_if = "Option::is_none")]
+    pub proxy_username: Option<String>,
+    /// 代理密码（可选）
+    #[serde(rename = "proxyPassword", skip_serializing_if = "Option::is_none")]
+    pub proxy_password: Option<String>,
+}
+
 /// 供应商元数据
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct ProviderMeta {
@@ -172,6 +221,12 @@ pub struct ProviderMeta {
     /// 每月消费限额（USD）
     #[serde(rename = "limitMonthlyUsd", skip_serializing_if = "Option::is_none")]
     pub limit_monthly_usd: Option<String>,
+    /// 供应商单独的模型测试配置
+    #[serde(rename = "testConfig", skip_serializing_if = "Option::is_none")]
+    pub test_config: Option<ProviderTestConfig>,
+    /// 供应商单独的代理配置
+    #[serde(rename = "proxyConfig", skip_serializing_if = "Option::is_none")]
+    pub proxy_config: Option<ProviderProxyConfig>,
 }
 
 impl ProviderManager {

src-tauri/src/services/stream_check.rs

@@ -78,15 +78,19 @@ pub struct StreamCheckService;
 
 impl StreamCheckService {
     /// 执行流式健康检查（带重试）
+    ///
+    /// 如果 Provider 配置了单独的测试配置（meta.testConfig），则使用该配置覆盖全局配置
     pub async fn check_with_retry(
         app_type: &AppType,
         provider: &Provider,
         config: &StreamCheckConfig,
     ) -> Result<StreamCheckResult, AppError> {
+        // 合并供应商单独配置和全局配置
+        let effective_config = Self::merge_provider_config(provider, config);
         let mut last_result = None;
 
-        for attempt in 0..=config.max_retries {
-            let result = Self::check_once(app_type, provider, config).await;
+        for attempt in 0..=effective_config.max_retries {
+            let result = Self::check_once(app_type, provider, &effective_config).await;
 
             match &result {
                 Ok(r) if r.success => {
@@ -97,7 +101,7 @@ impl StreamCheckService {
                 }
                 Ok(r) => {
                     // 失败但非异常，判断是否重试
-                    if Self::should_retry(&r.message) && attempt < config.max_retries {
+                    if Self::should_retry(&r.message) && attempt < effective_config.max_retries {
                         last_result = Some(r.clone());
                         continue;
                     }
@@ -107,7 +111,8 @@ impl StreamCheckService {
                     });
                 }
                 Err(e) => {
-                    if Self::should_retry(&e.to_string()) && attempt < config.max_retries {
+                    if Self::should_retry(&e.to_string()) && attempt < effective_config.max_retries
+                    {
                         continue;
                     }
                     return Err(AppError::Message(e.to_string()));
@@ -123,10 +128,51 @@ impl StreamCheckService {
             http_status: None,
             model_used: String::new(),
             tested_at: chrono::Utc::now().timestamp(),
-            retry_count: config.max_retries,
+            retry_count: effective_config.max_retries,
         }))
     }
 
+    /// 合并供应商单独配置和全局配置
+    ///
+    /// 如果供应商配置了 meta.testConfig 且 enabled 为 true，则使用供应商配置覆盖全局配置
+    fn merge_provider_config(
+        provider: &Provider,
+        global_config: &StreamCheckConfig,
+    ) -> StreamCheckConfig {
+        let test_config = provider
+            .meta
+            .as_ref()
+            .and_then(|m| m.test_config.as_ref())
+            .filter(|tc| tc.enabled);
+
+        match test_config {
+            Some(tc) => StreamCheckConfig {
+                timeout_secs: tc.timeout_secs.unwrap_or(global_config.timeout_secs),
+                max_retries: tc.max_retries.unwrap_or(global_config.max_retries),
+                degraded_threshold_ms: tc
+                    .degraded_threshold_ms
+                    .unwrap_or(global_config.degraded_threshold_ms),
+                claude_model: tc
+                    .test_model
+                    .clone()
+                    .unwrap_or_else(|| global_config.claude_model.clone()),
+                codex_model: tc
+                    .test_model
+                    .clone()
+                    .unwrap_or_else(|| global_config.codex_model.clone()),
+                gemini_model: tc
+                    .test_model
+                    .clone()
+                    .unwrap_or_else(|| global_config.gemini_model.clone()),
+                test_prompt: tc
+                    .test_prompt
+                    .clone()
+                    .unwrap_or_else(|| global_config.test_prompt.clone()),
+            },
+            None => global_config.clone(),
+        }
+    }
+
     /// 单次流式检查
     async fn check_once(
         app_type: &AppType,