feat:接入OpenRouter token计价 (#3)

* feat:接入OpenRouter token计价

* feat:同步Token计价设计稿

* fix: serialize OpenRouter pricing cache refresh

Agent-Logs-Url: https://github.com/JialinLiu-codedance/ai-usage/sessions/675620e3-7a39-4cfe-bc34-3fbc969d1247

Co-authored-by: JialinLiu-codedance <218696320+JialinLiu-codedance@users.noreply.github.com>

* chore: simplify openrouter refresh error handling

Agent-Logs-Url: https://github.com/JialinLiu-codedance/ai-usage/sessions/675620e3-7a39-4cfe-bc34-3fbc969d1247

Co-authored-by: JialinLiu-codedance <218696320+JialinLiu-codedance@users.noreply.github.com>

* chore: remove unintended generated schema file

Agent-Logs-Url: https://github.com/JialinLiu-codedance/ai-usage/sessions/675620e3-7a39-4cfe-bc34-3fbc969d1247

Co-authored-by: JialinLiu-codedance <218696320+JialinLiu-codedance@users.noreply.github.com>

* fix:避免OpenRouter并发刷新误报警告

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: JialinLiu-codedance <218696320+JialinLiu-codedance@users.noreply.github.com>

Author: JialinLiu-codedance

UI.pen

@@ -13,7 +13,7 @@ use crate::{
         CUSTOM_USAGE_WINDOW_DAYS, PROVIDER_ANTHROPIC, PROVIDER_COPILOT, PROVIDER_GLM,
         PROVIDER_KIMI, PROVIDER_MINIMAX, PROVIDER_OPENAI,
     },
-    notifications, oauth, pr_kpi, provider, secrets, settings,
+    notifications, oauth, openrouter_pricing, pr_kpi, provider, secrets, settings,
     state::StateStore,
     storage,
 };
@@ -31,13 +31,18 @@ use tauri_plugin_autostart::ManagerExt;
 const SNAPSHOTS_FILE: &str = "snapshots.json";
 const TOKEN_USAGE_CACHE_FILE: &str = "local-token-usage-cache.json";
 const TOKEN_USAGE_CACHE_UPDATED_EVENT: &str = "local-token-usage-cache-updated";
+const OPENROUTER_PRICING_CACHE_FILE: &str = "openrouter-pricing-cache.json";
+const OPENROUTER_PRICING_CACHE_MAX_AGE_HOURS: i64 = 24;
+const OPENROUTER_PRICING_REFRESH_IN_PROGRESS_ERROR: &str =
+    "OpenRouter 价格缓存正在刷新，请稍后再试";
 const GIT_USAGE_CACHE_FILE: &str = "git-usage-cache.json";
 const GIT_USAGE_CACHE_UPDATED_EVENT: &str = "git-usage-cache-updated";
 const GIT_BRANCH_MANAGEMENT_CACHE_FILE: &str = "git-branch-management-cache.json";
 const GIT_BRANCH_MANAGEMENT_CACHE_UPDATED_EVENT: &str = "git-branch-management-cache-updated";
 const PR_KPI_CACHE_FILE: &str = "pr-kpi-cache.json";
 const PR_KPI_CACHE_UPDATED_EVENT: &str = "pr-kpi-cache-updated";
 static TOKEN_USAGE_CACHE_REFRESHING: AtomicBool = AtomicBool::new(false);
+static OPENROUTER_PRICING_CACHE_REFRESHING: AtomicBool = AtomicBool::new(false);
 static GIT_USAGE_CACHE_REFRESHING: AtomicBool = AtomicBool::new(false);
 static GIT_BRANCH_MANAGEMENT_CACHE_REFRESHING: AtomicBool = AtomicBool::new(false);
 static PR_KPI_CACHE_REFRESHING: AtomicBool = AtomicBool::new(false);
@@ -206,6 +211,33 @@ pub fn save_settings(app: AppHandle, input: SaveSettingsInput) -> Result<AppSett
     get_settings(app)
 }
 
+#[tauri::command]
+pub fn save_openrouter_model_override(
+    app: AppHandle,
+    local_model: String,
+    openrouter_model_id: Option<String>,
+) -> Result<AppSettings, String> {
+    let settings = settings::save_openrouter_model_override(&app, local_model, openrouter_model_id)?;
+    let _ = app.emit(TOKEN_USAGE_CACHE_UPDATED_EVENT, ());
+    Ok(settings)
+}
+
+#[tauri::command]
+pub async fn get_openrouter_model_ids(app: AppHandle) -> Result<Vec<String>, String> {
+    if let Ok(Some(catalog)) = read_openrouter_pricing_cache(&app) {
+        if openrouter_pricing_cache_is_stale(&catalog) {
+            start_openrouter_pricing_cache_refresh(app.clone());
+        }
+        return Ok(catalog.model_ids());
+    }
+
+    match refresh_openrouter_pricing_cache(app).await {
+        Ok(catalog) => Ok(catalog.model_ids()),
+        Err(error) if is_openrouter_pricing_refresh_in_progress(&error) => Ok(Vec::new()),
+        Err(error) => Err(error),
+    }
+}
+
 #[tauri::command]
 pub async fn get_local_proxy_settings(
     app: AppHandle,
@@ -657,13 +689,19 @@ pub fn get_local_token_usage(
         }
 
         if let Some(cache) = cache.filter(|cache| cache.covers_custom_range(start_date, end_date)) {
-            return Ok(cache.custom_report(start_date, end_date));
+            return Ok(apply_cached_openrouter_pricing(
+                &app,
+                cache.custom_report(start_date, end_date),
+            ));
         }
 
-        return Ok(local_usage::pending_custom_report(
-            start_date,
-            end_date,
-            Some("Token 用量缓存正在后台生成，完成后会自动更新".into()),
+        return Ok(apply_cached_openrouter_pricing(
+            &app,
+            local_usage::pending_custom_report(
+                start_date,
+                end_date,
+                Some("Token 用量缓存正在后台生成，完成后会自动更新".into()),
+            ),
         ));
     }
 
@@ -680,12 +718,15 @@ pub fn get_local_token_usage(
     }
 
     if let Some(cache) = cache {
-        return Ok(cache.report(range));
+        return Ok(apply_cached_openrouter_pricing(&app, cache.report(range)));
     }
 
-    Ok(local_usage::pending_report(
-        range,
-        Some("Token 用量缓存正在后台生成，完成后会自动更新".into()),
+    Ok(apply_cached_openrouter_pricing(
+        &app,
+        local_usage::pending_report(
+            range,
+            Some("Token 用量缓存正在后台生成，完成后会自动更新".into()),
+        ),
     ))
 }
 
@@ -700,18 +741,22 @@ pub async fn refresh_local_token_usage(
         end_date,
     } = resolved
     {
-        let cache = refresh_local_token_usage_cache(app, true).await?;
+        let cache = refresh_local_token_usage_cache(app.clone(), true).await?;
         if !cache.covers_custom_range(start_date, end_date) {
             return Err("Token 用量缓存刷新后仍未准备好".into());
         }
-        return Ok(cache.custom_report(start_date, end_date));
+        return Ok(apply_refreshed_openrouter_pricing(
+            app,
+            cache.custom_report(start_date, end_date),
+        )
+        .await);
     }
 
     let ResolvedUsageRange::Preset(range) = resolved else {
         unreachable!("custom usage range returned above");
     };
-    let cache = refresh_local_token_usage_cache(app, true).await?;
-    Ok(cache.report(range))
+    let cache = refresh_local_token_usage_cache(app.clone(), true).await?;
+    Ok(apply_refreshed_openrouter_pricing(app, cache.report(range)).await)
 }
 
 #[tauri::command]
@@ -1208,6 +1253,21 @@ fn start_local_token_usage_cache_refresh(app: AppHandle) {
     });
 }
 
+fn start_openrouter_pricing_cache_refresh(app: AppHandle) {
+    tauri::async_runtime::spawn(async move {
+        match refresh_openrouter_pricing_cache(app.clone()).await {
+            Ok(_) => {
+                let _ = app.emit(TOKEN_USAGE_CACHE_UPDATED_EVENT, ());
+            }
+            Err(error) => {
+                if !is_openrouter_pricing_refresh_in_progress(&error) {
+                    eprintln!("OpenRouter pricing cache refresh failed: {error}");
+                }
+            }
+        }
+    });
+}
+
 fn start_git_usage_cache_refresh(app: AppHandle) {
     tauri::async_runtime::spawn(async move {
         match refresh_git_usage_cache(app, true).await {
@@ -1256,6 +1316,45 @@ async fn refresh_local_token_usage_cache(
     Ok(cache)
 }
 
+async fn apply_refreshed_openrouter_pricing(
+    app: AppHandle,
+    report: LocalTokenUsageReport,
+) -> LocalTokenUsageReport {
+    let model_overrides = settings::load_settings(&app)
+        .map(|settings| settings.openrouter_model_overrides)
+        .unwrap_or_default();
+    match refresh_openrouter_pricing_cache(app.clone()).await {
+        Ok(catalog) => openrouter_pricing::apply_pricing_to_report_with_overrides(
+            report,
+            Some(&catalog),
+            None,
+            &model_overrides,
+        ),
+        Err(error) => {
+            let cached = read_openrouter_pricing_cache(&app).ok().flatten();
+            let warning = openrouter_pricing_refresh_warning(&error);
+            openrouter_pricing::apply_pricing_to_report_with_overrides(
+                report,
+                cached.as_ref(),
+                warning,
+                &model_overrides,
+            )
+        }
+    }
+}
+
+async fn refresh_openrouter_pricing_cache(
+    app: AppHandle,
+) -> Result<openrouter_pricing::OpenRouterPricingCatalog, String> {
+    let _guard = claim_openrouter_pricing_refresh()?;
+    let catalog =
+        tauri::async_runtime::spawn_blocking(openrouter_pricing::fetch_openrouter_pricing_catalog)
+            .await
+            .map_err(|error| format!("OpenRouter 价格缓存任务失败: {error}"))??;
+    storage::write_json(&app, OPENROUTER_PRICING_CACHE_FILE, &catalog)?;
+    Ok(catalog)
+}
+
 async fn refresh_git_usage_cache(
     app: AppHandle,
     emit_update: bool,
@@ -1366,6 +1465,34 @@ fn claim_local_token_usage_refresh() -> Result<LocalTokenUsageRefreshGuard, Stri
     Ok(LocalTokenUsageRefreshGuard)
 }
 
+#[derive(Debug)]
+struct OpenRouterPricingRefreshGuard;
+
+impl Drop for OpenRouterPricingRefreshGuard {
+    fn drop(&mut self) {
+        OPENROUTER_PRICING_CACHE_REFRESHING.store(false, Ordering::Release);
+    }
+}
+
+fn claim_openrouter_pricing_refresh() -> Result<OpenRouterPricingRefreshGuard, String> {
+    if OPENROUTER_PRICING_CACHE_REFRESHING.swap(true, Ordering::AcqRel) {
+        return Err(OPENROUTER_PRICING_REFRESH_IN_PROGRESS_ERROR.into());
+    }
+    Ok(OpenRouterPricingRefreshGuard)
+}
+
+fn is_openrouter_pricing_refresh_in_progress(error: &str) -> bool {
+    error == OPENROUTER_PRICING_REFRESH_IN_PROGRESS_ERROR
+}
+
+fn openrouter_pricing_refresh_warning(error: &str) -> Option<String> {
+    if is_openrouter_pricing_refresh_in_progress(error) {
+        None
+    } else {
+        Some(format!("OpenRouter 价格刷新失败: {error}"))
+    }
+}
+
 #[derive(Debug)]
 struct GitUsageRefreshGuard;
 
@@ -1713,6 +1840,49 @@ fn read_local_token_usage_cache(
     storage::read_json::<local_usage::LocalTokenUsageCache>(app, TOKEN_USAGE_CACHE_FILE)
 }
 
+fn read_openrouter_pricing_cache(
+    app: &AppHandle,
+) -> Result<Option<openrouter_pricing::OpenRouterPricingCatalog>, String> {
+    storage::read_json::<openrouter_pricing::OpenRouterPricingCatalog>(
+        app,
+        OPENROUTER_PRICING_CACHE_FILE,
+    )
+}
+
+fn apply_cached_openrouter_pricing(
+    app: &AppHandle,
+    report: LocalTokenUsageReport,
+) -> LocalTokenUsageReport {
+    let model_overrides = settings::load_settings(app)
+        .map(|settings| settings.openrouter_model_overrides)
+        .unwrap_or_default();
+    match read_openrouter_pricing_cache(app) {
+        Ok(Some(catalog)) => {
+            if openrouter_pricing_cache_is_stale(&catalog) {
+                start_openrouter_pricing_cache_refresh(app.clone());
+            }
+            openrouter_pricing::apply_pricing_to_report_with_overrides(
+                report,
+                Some(&catalog),
+                None,
+                &model_overrides,
+            )
+        }
+        Ok(None) => {
+            start_openrouter_pricing_cache_refresh(app.clone());
+            openrouter_pricing::apply_pricing_to_report(report, None, None)
+        }
+        Err(error) => {
+            start_openrouter_pricing_cache_refresh(app.clone());
+            openrouter_pricing::apply_pricing_to_report(
+                report,
+                None,
+                Some(format!("读取 OpenRouter 价格缓存失败: {error}")),
+            )
+        }
+    }
+}
+
 fn read_git_usage_cache(app: &AppHandle) -> Result<Option<git_usage::GitUsageCache>, String> {
     storage::read_json::<git_usage::GitUsageCache>(app, GIT_USAGE_CACHE_FILE)
 }
@@ -1737,6 +1907,10 @@ fn local_token_usage_cache_is_stale(
     (Utc::now() - cache.generated_at).num_minutes() >= max_age_minutes
 }
 
+fn openrouter_pricing_cache_is_stale(cache: &openrouter_pricing::OpenRouterPricingCatalog) -> bool {
+    (Utc::now() - cache.generated_at).num_hours() >= OPENROUTER_PRICING_CACHE_MAX_AGE_HOURS
+}
+
 fn git_usage_cache_is_stale(
     cache: &git_usage::GitUsageCache,
     max_age_minutes: i64,
@@ -2283,6 +2457,33 @@ mod tests {
         assert!(claim_git_usage_refresh().is_ok());
     }
 
+    #[test]
+    fn openrouter_pricing_refresh_guard_rejects_parallel_refreshes_and_releases() {
+        let guard = claim_openrouter_pricing_refresh().unwrap();
+
+        let error = claim_openrouter_pricing_refresh().unwrap_err();
+
+        assert_eq!(error, OPENROUTER_PRICING_REFRESH_IN_PROGRESS_ERROR);
+        drop(guard);
+        assert!(claim_openrouter_pricing_refresh().is_ok());
+    }
+
+    #[test]
+    fn openrouter_pricing_refresh_in_progress_does_not_create_warning() {
+        assert_eq!(
+            openrouter_pricing_refresh_warning(OPENROUTER_PRICING_REFRESH_IN_PROGRESS_ERROR),
+            None
+        );
+    }
+
+    #[test]
+    fn openrouter_pricing_refresh_errors_still_create_warning() {
+        assert_eq!(
+            openrouter_pricing_refresh_warning("network failed"),
+            Some("OpenRouter 价格刷新失败: network failed".to_string())
+        );
+    }
+
     #[test]
     fn git_usage_cache_is_stale_when_root_path_changes() {
         let now = chrono::Utc::now();