feat: add Token Plan quota query for Kimi, Zhipu GLM, and MiniMax

Add a new "Token Plan" template type in the usage query panel that
natively queries quota/usage from Chinese coding plan providers
(Kimi For Coding, Zhipu GLM, MiniMax) without requiring custom scripts.

- Rust backend: new coding_plan service with provider-specific API
  queries (Kimi /v1/usages, Zhipu /api/monitor/usage/quota/limit,
  MiniMax /coding_plan/remains) normalized into UsageResult
- Frontend: Token Plan template in UsageScriptModal with auto-detection
  of provider based on ANTHROPIC_BASE_URL pattern matching
- Follows the same pattern as GitHub Copilot template (dedicated API
  path in queryProviderUsage, no JS script needed)

src-tauri/src/commands/coding_plan.rs

@@ -0,0 +1,9 @@
+use crate::services::subscription::SubscriptionQuota;
+
+#[tauri::command]
+pub async fn get_coding_plan_quota(
+    base_url: String,
+    api_key: String,
+) -> Result<SubscriptionQuota, String> {
+    crate::services::coding_plan::get_coding_plan_quota(&base_url, &api_key).await
+}

src-tauri/src/commands/mod.rs

@@ -1,6 +1,7 @@
 #![allow(non_snake_case)]
 
 mod auth;
+mod coding_plan;
 mod config;
 mod copilot;
 mod deeplink;
@@ -30,6 +31,7 @@ mod webdav_sync;
 mod workspace;
 
 pub use auth::*;
+pub use coding_plan::*;
 pub use config::*;
 pub use copilot::*;
 pub use deeplink::*;

src-tauri/src/commands/provider.rs

@@ -13,6 +13,7 @@ use std::str::FromStr;
 
 // 常量定义
 const TEMPLATE_TYPE_GITHUB_COPILOT: &str = "github_copilot";
+const TEMPLATE_TYPE_TOKEN_PLAN: &str = "token_plan";
 const COPILOT_UNIT_PREMIUM: &str = "requests";
 
 /// 获取所有供应商
@@ -158,29 +159,25 @@ pub async fn queryProviderUsage(
 ) -> Result<crate::provider::UsageResult, String> {
     let app_type = AppType::from_str(&app).map_err(|e| e.to_string())?;
 
-    // 检查是否为 GitHub Copilot 模板类型，并解析绑定账号
-    let (is_copilot_template, copilot_account_id) = {
-        let providers = state
-            .db
-            .get_all_providers(app_type.as_str())
-            .map_err(|e| format!("Failed to get providers: {e}"))?;
+    // 从数据库读取供应商信息，检查特殊模板类型
+    let providers = state
+        .db
+        .get_all_providers(app_type.as_str())
+        .map_err(|e| format!("Failed to get providers: {e}"))?;
+    let provider = providers.get(&providerId);
+    let usage_script = provider
+        .and_then(|p| p.meta.as_ref())
+        .and_then(|m| m.usage_script.as_ref());
+    let template_type = usage_script
+        .and_then(|s| s.template_type.as_deref())
+        .unwrap_or("");
 
-        let provider = providers.get(&providerId);
-        let is_copilot = provider
-            .and_then(|p| p.meta.as_ref())
-            .and_then(|m| m.usage_script.as_ref())
-            .and_then(|s| s.template_type.as_ref())
-            .map(|t| t == TEMPLATE_TYPE_GITHUB_COPILOT)
-            .unwrap_or(false);
-        let account_id = provider
+    // ── GitHub Copilot 专用路径 ──
+    if template_type == TEMPLATE_TYPE_GITHUB_COPILOT {
+        let copilot_account_id = provider
             .and_then(|p| p.meta.as_ref())
             .and_then(|m| m.managed_account_id_for(TEMPLATE_TYPE_GITHUB_COPILOT));
 
-        (is_copilot, account_id)
-    };
-
-    if is_copilot_template {
-        // 使用 Copilot 专用 API
         let auth_manager = copilot_state.0.read().await;
         let usage = match copilot_account_id.as_deref() {
             Some(account_id) => auth_manager
@@ -211,6 +208,67 @@ pub async fn queryProviderUsage(
         });
     }
 
+    // ── Coding Plan 专用路径 ──
+    if template_type == TEMPLATE_TYPE_TOKEN_PLAN {
+        // 从供应商配置中提取 API Key 和 Base URL
+        let settings_config = provider
+            .map(|p| &p.settings_config)
+            .cloned()
+            .unwrap_or_default();
+        let env = settings_config.get("env");
+        let base_url = env
+            .and_then(|e| e.get("ANTHROPIC_BASE_URL"))
+            .and_then(|v| v.as_str())
+            .unwrap_or("");
+        let api_key = env
+            .and_then(|e| {
+                e.get("ANTHROPIC_AUTH_TOKEN")
+                    .or_else(|| e.get("ANTHROPIC_API_KEY"))
+            })
+            .and_then(|v| v.as_str())
+            .unwrap_or("");
+
+        let quota = crate::services::coding_plan::get_coding_plan_quota(base_url, api_key)
+            .await
+            .map_err(|e| format!("Failed to query coding plan: {e}"))?;
+
+        // 将 SubscriptionQuota 转换为 UsageResult
+        if !quota.success {
+            return Ok(crate::provider::UsageResult {
+                success: false,
+                data: None,
+                error: quota.error,
+            });
+        }
+
+        let data: Vec<crate::provider::UsageData> = quota
+            .tiers
+            .iter()
+            .map(|tier| {
+                let total = 100.0;
+                let used = tier.utilization;
+                let remaining = total - used;
+                crate::provider::UsageData {
+                    plan_name: Some(tier.name.clone()),
+                    remaining: Some(remaining),
+                    total: Some(total),
+                    used: Some(used),
+                    unit: Some("%".to_string()),
+                    is_valid: Some(true),
+                    invalid_message: None,
+                    extra: tier.resets_at.clone(),
+                }
+            })
+            .collect();
+
+        return Ok(crate::provider::UsageResult {
+            success: true,
+            data: if data.is_empty() { None } else { Some(data) },
+            error: None,
+        });
+    }
+
+    // ── 通用 JS 脚本路径 ──
     ProviderService::query_usage(state.inner(), app_type, &providerId)
         .await
         .map_err(|e| e.to_string())

src-tauri/src/deeplink/provider.rs

@@ -229,6 +229,7 @@ fn build_provider_meta(request: &DeepLinkImportRequest) -> Result<Option<Provide
         user_id: request.usage_user_id.clone(),
         template_type: None, // Deeplink providers don't specify template type (will use backward compatibility logic)
         auto_query_interval: request.usage_auto_interval,
+        coding_plan_provider: None,
     };
 
     Ok(Some(ProviderMeta {

src-tauri/src/lib.rs

@@ -892,6 +892,7 @@ pub fn run() {
             commands::testUsageScript,
             // subscription quota
             commands::get_subscription_quota,
+            commands::get_coding_plan_quota,
             // New MCP via config.json (SSOT)
             commands::get_mcp_config,
             commands::upsert_mcp_server_in_config,

src-tauri/src/provider.rs

@@ -106,6 +106,10 @@ pub struct UsageScript {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(rename = "autoQueryInterval")]
     pub auto_query_interval: Option<u64>,
+    /// Coding Plan 供应商标识（如 "kimi", "zhipu", "minimax"）
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "codingPlanProvider")]
+    pub coding_plan_provider: Option<String>,
 }
 
 /// 用量数据

src-tauri/src/services/coding_plan.rs

@@ -0,0 +1,425 @@
+//! 国产 Token Plan 额度查询服务
+//!
+//! 支持 Kimi For Coding、智谱 GLM、MiniMax 的 Token Plan 额度查询。
+//! 复用 subscription 模块的 SubscriptionQuota / QuotaTier 类型。
+
+use super::subscription::{CredentialStatus, QuotaTier, SubscriptionQuota};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+// ── 供应商检测 ──────────────────────────────────────────────
+
+enum CodingPlanProvider {
+    Kimi,
+    ZhipuCn,
+    ZhipuEn,
+    MiniMaxCn,
+    MiniMaxEn,
+}
+
+fn detect_provider(base_url: &str) -> Option<CodingPlanProvider> {
+    let url = base_url.to_lowercase();
+    if url.contains("api.kimi.com/coding") {
+        Some(CodingPlanProvider::Kimi)
+    } else if url.contains("open.bigmodel.cn") || url.contains("bigmodel.cn") {
+        Some(CodingPlanProvider::ZhipuCn)
+    } else if url.contains("api.z.ai") {
+        Some(CodingPlanProvider::ZhipuEn)
+    } else if url.contains("api.minimaxi.com") {
+        Some(CodingPlanProvider::MiniMaxCn)
+    } else if url.contains("api.minimax.io") {
+        Some(CodingPlanProvider::MiniMaxEn)
+    } else {
+        None
+    }
+}
+
+fn now_millis() -> i64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as i64
+}
+
+fn millis_to_iso8601(ms: i64) -> Option<String> {
+    let secs = ms / 1000;
+    let nsecs = ((ms % 1000) * 1_000_000) as u32;
+    chrono::DateTime::from_timestamp(secs, nsecs).map(|dt| dt.to_rfc3339())
+}
+
+fn make_error(msg: String) -> SubscriptionQuota {
+    SubscriptionQuota {
+        tool: "coding_plan".to_string(),
+        credential_status: CredentialStatus::Valid,
+        credential_message: None,
+        success: false,
+        tiers: vec![],
+        extra_usage: None,
+        error: Some(msg),
+        queried_at: Some(now_millis()),
+    }
+}
+
+// ── Kimi For Coding ─────────────────────────────────────────
+
+async fn query_kimi(api_key: &str) -> SubscriptionQuota {
+    let client = crate::proxy::http_client::get();
+
+    let resp = client
+        .get("https://api.kimi.com/coding/v1/usages")
+        .header("Authorization", format!("Bearer {api_key}"))
+        .header("Accept", "application/json")
+        .timeout(std::time::Duration::from_secs(10))
+        .send()
+        .await;
+
+    let resp = match resp {
+        Ok(r) => r,
+        Err(e) => return make_error(format!("Network error: {e}")),
+    };
+
+    let status = resp.status();
+    if status == reqwest::StatusCode::UNAUTHORIZED || status == reqwest::StatusCode::FORBIDDEN {
+        return SubscriptionQuota {
+            tool: "coding_plan".to_string(),
+            credential_status: CredentialStatus::Expired,
+            credential_message: Some("Invalid API key".to_string()),
+            success: false,
+            tiers: vec![],
+            extra_usage: None,
+            error: Some(format!("Authentication failed (HTTP {status})")),
+            queried_at: Some(now_millis()),
+        };
+    }
+
+    if !status.is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return make_error(format!("API error (HTTP {status}): {body}"));
+    }
+
+    let body: serde_json::Value = match resp.json().await {
+        Ok(v) => v,
+        Err(e) => return make_error(format!("Failed to parse response: {e}")),
+    };
+
+    let mut tiers = Vec::new();
+
+    // 总体用量（周限额）
+    if let Some(usage) = body.get("usage") {
+        let used = usage.get("used").and_then(|v| v.as_f64()).unwrap_or(0.0);
+        let limit = usage.get("limit").and_then(|v| v.as_f64()).unwrap_or(1.0);
+        let resets_at = usage
+            .get("reset_at")
+            .or_else(|| usage.get("resetAt"))
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+
+        let utilization = if limit > 0.0 {
+            (used / limit) * 100.0
+        } else {
+            0.0
+        };
+        tiers.push(QuotaTier {
+            name: "weekly_limit".to_string(),
+            utilization,
+            resets_at,
+        });
+    }
+
+    // 会话限额（5 小时窗口）
+    if let Some(limits) = body.get("limits").and_then(|v| v.as_array()) {
+        for limit_item in limits {
+            if let Some(detail) = limit_item.get("detail") {
+                let used = detail.get("used").and_then(|v| v.as_f64()).unwrap_or(0.0);
+                let limit = detail.get("limit").and_then(|v| v.as_f64()).unwrap_or(1.0);
+                let resets_at = detail
+                    .get("reset_at")
+                    .or_else(|| detail.get("resetAt"))
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.to_string());
+
+                let utilization = if limit > 0.0 {
+                    (used / limit) * 100.0
+                } else {
+                    0.0
+                };
+                tiers.push(QuotaTier {
+                    name: "session_limit".to_string(),
+                    utilization,
+                    resets_at,
+                });
+            }
+        }
+    }
+
+    SubscriptionQuota {
+        tool: "coding_plan".to_string(),
+        credential_status: CredentialStatus::Valid,
+        credential_message: None,
+        success: true,
+        tiers,
+        extra_usage: None,
+        error: None,
+        queried_at: Some(now_millis()),
+    }
+}
+
+// ── 智谱 GLM ────────────────────────────────────────────────
+
+async fn query_zhipu(api_key: &str) -> SubscriptionQuota {
+    let client = crate::proxy::http_client::get();
+
+    // 统一走 api.z.ai 国际站（中国站 bigmodel.cn 有反爬机制）
+    let resp = client
+        .get("https://api.z.ai/api/monitor/usage/quota/limit")
+        .header("Authorization", api_key) // 注意：智谱不加 Bearer 前缀
+        .header("Content-Type", "application/json")
+        .header("Accept-Language", "en-US,en")
+        .timeout(std::time::Duration::from_secs(10))
+        .send()
+        .await;
+
+    let resp = match resp {
+        Ok(r) => r,
+        Err(e) => return make_error(format!("Network error: {e}")),
+    };
+
+    let status = resp.status();
+    if status == reqwest::StatusCode::UNAUTHORIZED || status == reqwest::StatusCode::FORBIDDEN {
+        return SubscriptionQuota {
+            tool: "coding_plan".to_string(),
+            credential_status: CredentialStatus::Expired,
+            credential_message: Some("Invalid API key".to_string()),
+            success: false,
+            tiers: vec![],
+            extra_usage: None,
+            error: Some(format!("Authentication failed (HTTP {status})")),
+            queried_at: Some(now_millis()),
+        };
+    }
+
+    if !status.is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return make_error(format!("API error (HTTP {status}): {body}"));
+    }
+
+    let body: serde_json::Value = match resp.json().await {
+        Ok(v) => v,
+        Err(e) => return make_error(format!("Failed to parse response: {e}")),
+    };
+
+    // 检查业务级别错误
+    if body.get("success").and_then(|v| v.as_bool()) == Some(false) {
+        let msg = body
+            .get("msg")
+            .and_then(|v| v.as_str())
+            .unwrap_or("Unknown error");
+        return make_error(format!("API error: {msg}"));
+    }
+
+    let data = match body.get("data") {
+        Some(d) => d,
+        None => return make_error("Missing 'data' field in response".to_string()),
+    };
+
+    let mut tiers = Vec::new();
+
+    if let Some(limits) = data.get("limits").and_then(|v| v.as_array()) {
+        for limit_item in limits {
+            let limit_type = limit_item
+                .get("type")
+                .and_then(|v| v.as_str())
+                .unwrap_or("");
+            let percentage = limit_item
+                .get("percentage")
+                .and_then(|v| v.as_f64())
+                .unwrap_or(0.0);
+            let next_reset = limit_item
+                .get("nextResetTime")
+                .and_then(|v| v.as_i64())
+                .and_then(millis_to_iso8601);
+
+            let tier_name = match limit_type {
+                "TOKENS_LIMIT" => "tokens_limit",
+                "TIME_LIMIT" => "mcp_limit",
+                _ => continue,
+            };
+
+            tiers.push(QuotaTier {
+                name: tier_name.to_string(),
+                utilization: percentage,
+                resets_at: next_reset,
+            });
+        }
+    }
+
+    // 套餐等级存入 credential_message
+    let level = data
+        .get("level")
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string());
+
+    SubscriptionQuota {
+        tool: "coding_plan".to_string(),
+        credential_status: CredentialStatus::Valid,
+        credential_message: level,
+        success: true,
+        tiers,
+        extra_usage: None,
+        error: None,
+        queried_at: Some(now_millis()),
+    }
+}
+
+// ── MiniMax ─────────────────────────────────────────────────
+
+async fn query_minimax(api_key: &str, is_cn: bool) -> SubscriptionQuota {
+    let client = crate::proxy::http_client::get();
+
+    let api_domain = if is_cn {
+        "api.minimaxi.com"
+    } else {
+        "api.minimax.io"
+    };
+    let url = format!("https://{api_domain}/v1/api/openplatform/coding_plan/remains");
+
+    let resp = client
+        .get(&url)
+        .header("Authorization", format!("Bearer {api_key}"))
+        .header("Content-Type", "application/json")
+        .timeout(std::time::Duration::from_secs(10))
+        .send()
+        .await;
+
+    let resp = match resp {
+        Ok(r) => r,
+        Err(e) => return make_error(format!("Network error: {e}")),
+    };
+
+    let status = resp.status();
+    if status == reqwest::StatusCode::UNAUTHORIZED || status == reqwest::StatusCode::FORBIDDEN {
+        return SubscriptionQuota {
+            tool: "coding_plan".to_string(),
+            credential_status: CredentialStatus::Expired,
+            credential_message: Some("Invalid API key".to_string()),
+            success: false,
+            tiers: vec![],
+            extra_usage: None,
+            error: Some(format!("Authentication failed (HTTP {status})")),
+            queried_at: Some(now_millis()),
+        };
+    }
+
+    if !status.is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return make_error(format!("API error (HTTP {status}): {body}"));
+    }
+
+    let body: serde_json::Value = match resp.json().await {
+        Ok(v) => v,
+        Err(e) => return make_error(format!("Failed to parse response: {e}")),
+    };
+
+    // 检查业务级别错误
+    if let Some(base_resp) = body.get("base_resp") {
+        let status_code = base_resp
+            .get("status_code")
+            .and_then(|v| v.as_i64())
+            .unwrap_or(-1);
+        if status_code != 0 {
+            let msg = base_resp
+                .get("status_msg")
+                .and_then(|v| v.as_str())
+                .unwrap_or("Unknown error");
+            return make_error(format!("API error (code {status_code}): {msg}"));
+        }
+    }
+
+    let mut tiers = Vec::new();
+
+    if let Some(model_remains) = body.get("model_remains").and_then(|v| v.as_array()) {
+        for item in model_remains {
+            let model_name = item
+                .get("model_name")
+                .and_then(|v| v.as_str())
+                .unwrap_or("unknown");
+            let total = item
+                .get("current_interval_total_count")
+                .and_then(|v| v.as_f64())
+                .unwrap_or(0.0);
+            // 注意：current_interval_usage_count 名字有误导，实际是"剩余量"
+            let remaining = item
+                .get("current_interval_usage_count")
+                .and_then(|v| v.as_f64())
+                .unwrap_or(0.0);
+            let end_time = item.get("end_time").and_then(|v| v.as_i64());
+
+            let utilization = if total > 0.0 {
+                ((total - remaining) / total) * 100.0
+            } else {
+                0.0
+            };
+
+            tiers.push(QuotaTier {
+                name: model_name.to_string(),
+                utilization,
+                resets_at: end_time.and_then(millis_to_iso8601),
+            });
+        }
+    }
+
+    SubscriptionQuota {
+        tool: "coding_plan".to_string(),
+        credential_status: CredentialStatus::Valid,
+        credential_message: None,
+        success: true,
+        tiers,
+        extra_usage: None,
+        error: None,
+        queried_at: Some(now_millis()),
+    }
+}
+
+// ── 公开入口 ────────────────────────────────────────────────
+
+pub async fn get_coding_plan_quota(
+    base_url: &str,
+    api_key: &str,
+) -> Result<SubscriptionQuota, String> {
+    if api_key.trim().is_empty() {
+        return Ok(SubscriptionQuota {
+            tool: "coding_plan".to_string(),
+            credential_status: CredentialStatus::NotFound,
+            credential_message: None,
+            success: false,
+            tiers: vec![],
+            extra_usage: None,
+            error: None,
+            queried_at: None,
+        });
+    }
+
+    let provider = match detect_provider(base_url) {
+        Some(p) => p,
+        None => {
+            return Ok(SubscriptionQuota {
+                tool: "coding_plan".to_string(),
+                credential_status: CredentialStatus::NotFound,
+                credential_message: None,
+                success: false,
+                tiers: vec![],
+                extra_usage: None,
+                error: None,
+                queried_at: None,
+            })
+        }
+    };
+
+    let quota = match provider {
+        CodingPlanProvider::Kimi => query_kimi(api_key).await,
+        CodingPlanProvider::ZhipuCn | CodingPlanProvider::ZhipuEn => query_zhipu(api_key).await,
+        CodingPlanProvider::MiniMaxCn => query_minimax(api_key, true).await,
+        CodingPlanProvider::MiniMaxEn => query_minimax(api_key, false).await,
+    };
+
+    Ok(quota)
+}

src-tauri/src/services/mod.rs

@@ -1,3 +1,4 @@
+pub mod coding_plan;
 pub mod config;
 pub mod env_checker;
 pub mod env_manager;