From 933cba13dfbbab4af2c2dfad41ffe8e3da987cbe Mon Sep 17 00:00:00 2001 From: dsdbb520 <100010406+dsdbb520@users.noreply.github.com> Date: Thu, 19 Nov 2026 20:16:54 +0800 Subject: [PATCH] fix(usage): merge equally priced reasoning tiers and seed Gemini 4 Neon (#8845) Merge reasoning-effort variants into their base model row in usage statistics when all four token prices (input, output, cache read, cache write) match and the base model has an exact price. Filters, daily rollups and the first-token median use the same grouping; request logs keep the raw model name. Also seed Gemini 4 Neon pricing and attribute Antigravity Orchestrator (Neon) planner steps to it. Co-authored-by: dsdbb520 <100010406+dsdbb520@users.noreply.github.com> Co-authored-by: funkpopo --- docs/user-manual/en/4-proxy/4.4-usage.md | 2 +- docs/user-manual/ja/4-proxy/4.4-usage.md | 2 +- docs/user-manual/zh/4-proxy/4.4-usage.md | 2 +- src-tauri/src/database/schema.rs | 11 + src-tauri/src/database/tests.rs | 26 + src-tauri/src/services/session_usage_agy.rs | 13 +- .../session_usage_agy/native_models.rs | 23 +- .../session_usage_agy/orchestrator_tests.rs | 82 +++ src-tauri/src/services/usage_stats.rs | 689 +++++++++++++++--- 9 files changed, 753 insertions(+), 97 deletions(-) diff --git a/docs/user-manual/en/4-proxy/4.4-usage.md b/docs/user-manual/en/4-proxy/4.4-usage.md index 4094322a8..71413c839 100644 --- a/docs/user-manual/en/4-proxy/4.4-usage.md +++ b/docs/user-manual/en/4-proxy/4.4-usage.md @@ -41,7 +41,7 @@ Depending on which data source you use, the prerequisites differ: ### Antigravity Orchestrator -Orchestrator alternates between a planner (Carbon or Argon) and the Hydrogen worker in one conversation. CC Switch attributes each response using its generation in the native `conversations/.db` (and attributes worker steps tagged `gemini-flash-worker-agy` in transcripts to Hydrogen even when the native database is absent), while retaining the selected Orchestrator mode or worker role alias as the request model. Costs use the configured API prices for those models; they do not represent Google AI subscription charges or quota consumption. +Orchestrator alternates between a planner (Carbon, Argon, or Neon) and the Hydrogen worker in one conversation. CC Switch attributes each response using its generation in the native `conversations/.db` (and attributes worker steps tagged `gemini-flash-worker-agy` in transcripts to Hydrogen even when the native database is absent), while retaining the selected Orchestrator mode or worker role alias as the request model. Costs use the configured API prices for those models; they do not represent Google AI subscription charges or quota consumption. `gemini-4-hydrogen-orchestrator` (native display name `Gemini 4 Hydrogen (Orchestrator)`) and retained `gemini-flash-worker-agy` log rows use the `gemini-4-hydrogen` price when no exact price is configured. A custom price for either ID takes precedence. Logs retain the stored model ID, and the existing missing-cost backfill can price retained details without rebuilding sessions. diff --git a/docs/user-manual/ja/4-proxy/4.4-usage.md b/docs/user-manual/ja/4-proxy/4.4-usage.md index abc849449..32f7dc253 100644 --- a/docs/user-manual/ja/4-proxy/4.4-usage.md +++ b/docs/user-manual/ja/4-proxy/4.4-usage.md @@ -41,7 +41,7 @@ ### Antigravity Orchestrator -Orchestrator は 1 つの会話の中で、計画用のモデル(Carbon または Argon)と実行用のモデル Hydrogen を交互に使います。使用量を取り込むとき、CC Switch はネイティブの `conversations/.db` に残る生成ごとのモデル記録をもとに集計を分け(トランスクリプトの実行ステップに記録される `gemini-flash-worker-agy` はネイティブのデータベースがない場合でも Hydrogen に割り当てます)、リクエストモデルには選択した Orchestrator モードまたは実行ロールの別名をそのまま残します。費用は各モデルに設定された API 単価での見積もりで、Google AI サブスクリプションの実際の請求やクォータ消費を表すものではありません。 +Orchestrator は 1 つの会話の中で、計画用のモデル(Carbon、Argon、または Neon)と実行用のモデル Hydrogen を交互に使います。使用量を取り込むとき、CC Switch はネイティブの `conversations/.db` に残る生成ごとのモデル記録をもとに集計を分け(トランスクリプトの実行ステップに記録される `gemini-flash-worker-agy` はネイティブのデータベースがない場合でも Hydrogen に割り当てます)、リクエストモデルには選択した Orchestrator モードまたは実行ロールの別名をそのまま残します。費用は各モデルに設定された API 単価での見積もりで、Google AI サブスクリプションの実際の請求やクォータ消費を表すものではありません。 `gemini-4-hydrogen-orchestrator`(ネイティブの表示名は `Gemini 4 Hydrogen (Orchestrator)`)およびログに残っている `gemini-flash-worker-agy` の明細は、専用の価格が設定されていない場合 `gemini-4-hydrogen` の価格を使います。それぞれの ID にカスタム価格を設定した場合はそちらが優先されます。ログには保存されたモデル ID が残り、まだ残っている未計算の明細は既存の補完処理で費用が計算されるため、セッションを作り直す必要はありません。 diff --git a/docs/user-manual/zh/4-proxy/4.4-usage.md b/docs/user-manual/zh/4-proxy/4.4-usage.md index eff08772b..e3a2d52bd 100644 --- a/docs/user-manual/zh/4-proxy/4.4-usage.md +++ b/docs/user-manual/zh/4-proxy/4.4-usage.md @@ -41,7 +41,7 @@ ### Antigravity Orchestrator -Orchestrator 会在同一会话中交替使用规划模型(Carbon 或 Argon)和执行模型 Hydrogen。导入用量时,CC Switch 按原生 `conversations/.db` 中逐次生成的模型记录拆分统计(转录中直接标记为 `gemini-flash-worker-agy` 的执行步在缺少原生库时也会归属到 Hydrogen),并在请求模型中保留所选的 Orchestrator 模式或执行角色别名。费用使用对应模型的已配置 API 单价估算,不代表 Google AI 订阅的实际扣费或配额消耗。 +Orchestrator 会在同一会话中交替使用规划模型(Carbon、Argon 或 Neon)和执行模型 Hydrogen。导入用量时,CC Switch 按原生 `conversations/.db` 中逐次生成的模型记录拆分统计(转录中直接标记为 `gemini-flash-worker-agy` 的执行步在缺少原生库时也会归属到 Hydrogen),并在请求模型中保留所选的 Orchestrator 模式或执行角色别名。费用使用对应模型的已配置 API 单价估算,不代表 Google AI 订阅的实际扣费或配额消耗。 `gemini-4-hydrogen-orchestrator`(原生显示名 `Gemini 4 Hydrogen (Orchestrator)`)以及数据库中保留的 `gemini-flash-worker-agy` 明细在没有独立定价时,使用 `gemini-4-hydrogen` 的价格;对应 ID 的自定义价格优先。日志保留原模型名,仍保留的未计价明细会通过现有补价流程补算,无需重建会话。 diff --git a/src-tauri/src/database/schema.rs b/src-tauri/src/database/schema.rs index ba7f1c09b..a64d03c6a 100644 --- a/src-tauri/src/database/schema.rs +++ b/src-tauri/src/database/schema.rs @@ -2253,6 +2253,17 @@ impl Database { ("gpt-4o", "GPT-4o", "2.50", "10", "1.25", "0"), ("gpt-4o-mini", "GPT-4o Mini", "0.15", "0.60", "0.075", "0"), // Gemini 4 系列 + // 来源:https://ai.google.dev/gemini-api/docs/pricing#gemini-4-neon + // 标准档(Global):输入 3.00 / 输出 15.00(含思考)/ 缓存读 0.15(仅隐式缓存,写入记 0), + // 与 models.dev google/gemini-4-neon 一致。 + ( + "gemini-4-neon", + "Gemini 4 Neon", + "3.00", + "15.00", + "0.15", + "0", + ), // 来源:https://ai.google.dev/gemini-api/docs/pricing#gemini-4-argon // 录的是标准档介绍价(2026-10-15 抓取):输入 2.00 / 输出 10.00 / 上下文缓存读 0.10 // (缓存仅支持隐式,不支持显式写入,cache_creation 记 0,与其他 Gemini 条目口径一致)。 diff --git a/src-tauri/src/database/tests.rs b/src-tauri/src/database/tests.rs index 731358ca4..76b711b63 100644 --- a/src-tauri/src/database/tests.rs +++ b/src-tauri/src/database/tests.rs @@ -1376,6 +1376,32 @@ fn model_pricing_seed_includes_glm_5_3_flash() { ); } +#[test] +fn model_pricing_seed_includes_gemini_4_neon() { + let db = Database::memory().expect("create memory db"); + let conn = db.conn.lock().expect("lock conn"); + + let price: (String, String, String, String) = conn + .query_row( + "SELECT input_cost_per_million, output_cost_per_million, + cache_read_cost_per_million, cache_creation_cost_per_million + FROM model_pricing WHERE model_id = 'gemini-4-neon'", + [], + |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)), + ) + .expect("query Gemini 4 Neon price"); + + assert_eq!( + price, + ( + "3.00".to_string(), + "15.00".to_string(), + "0.15".to_string(), + "0".to_string(), + ) + ); +} + #[test] fn model_pricing_seed_includes_gemini_4_argon() { let db = Database::memory().expect("create memory db"); diff --git a/src-tauri/src/services/session_usage_agy.rs b/src-tauri/src/services/session_usage_agy.rs index d8f743422..cdc3a07a7 100644 --- a/src-tauri/src/services/session_usage_agy.rs +++ b/src-tauri/src/services/session_usage_agy.rs @@ -56,9 +56,9 @@ fn sync_agy_usage_from_files( }; let modified = metadata_modified_nanos(&metadata); let size = metadata.len() as i64; - // Invalidate pre-Orchestrator / pre-worker-alias cursors once, including unchanged, - // already timed history. - let native_state = format!("v3:{}", native_models::native_state_fingerprint(&path)); + // Invalidate pre-Orchestrator / pre-worker-alias / pre-Neon-Orchestrator cursors once, + // including unchanged, already timed history. + let native_state = format!("v4:{}", native_models::native_state_fingerprint(&path)); if cursor.is_some_and(|c| { c.last_modified == modified && c.last_byte_offset == Some(size) @@ -133,9 +133,12 @@ fn model_id_of(display: &str) -> String { /// Multi-model modes, not evidence of the model used for an individual response. /// Display name and native alias of the same mode map to the same planner. fn orchestrator_mode(model: &str) -> Option<&'static str> { - match model_id_of(model).as_str() { + match model_id_of(model.trim()).to_ascii_lowercase().as_str() { "orchestrator-carbon" | "gemini-pro-orchestrator" => Some("carbon"), - "orchestrator-argon" | "gemini-pro-orchestrator-argon" => Some("argon"), + "orchestrator-argon" + | "gemini-pro-orchestrator-argon" + | "gemini-pro-orchestrator-g1-pro" => Some("argon"), + "orchestrator-neon" | "gemini-pro-orchestrator-neon" => Some("neon"), _ => None, } } diff --git a/src-tauri/src/services/session_usage_agy/native_models.rs b/src-tauri/src/services/session_usage_agy/native_models.rs index 70263775e..c551fb3e3 100644 --- a/src-tauri/src/services/session_usage_agy/native_models.rs +++ b/src-tauri/src/services/session_usage_agy/native_models.rs @@ -212,7 +212,10 @@ fn read_generations(path: &Path, steps: &[u64]) -> rusqlite::Result Some("gemini-4-carbon"), - Some("gemini-pro-orchestrator-argon") => Some("gemini-4-argon"), + Some("gemini-pro-orchestrator-argon" | "gemini-pro-orchestrator-g1-pro") => { + Some("gemini-4-argon") + } + Some("gemini-pro-orchestrator-neon") => Some("gemini-4-neon"), Some("gemini-flash-worker-agy") => Some("gemini-4-hydrogen"), _ => None, }; @@ -329,6 +332,8 @@ mod tests { (5, 2, "gemini-pro-orchestrator-argon"), (7, 3, "future-worker"), (9, 4, "gemini-flash-worker-agy"), + (11, 5, "gemini-pro-orchestrator-neon"), + (13, 6, "gemini-pro-orchestrator-g1-pro"), ], ); set_test_generation( @@ -355,12 +360,26 @@ mod tests { "gemini-flash-worker-agy", &test_model_id("gemini-4-hydrogen-high"), ); - let models = read_models(&path, &[1, 3, 5, 7, 9]).unwrap(); + set_test_generation( + &conn, + 5, + "gemini-pro-orchestrator-neon", + &test_model_id("Orchestrator (Neon)"), + ); + set_test_generation( + &conn, + 6, + "gemini-pro-orchestrator-g1-pro", + &test_model_id("Orchestrator (Argon)"), + ); + let models = read_models(&path, &[1, 3, 5, 7, 9, 11, 13]).unwrap(); assert_eq!(models[&1], "gemini-4-carbon"); assert_eq!(models[&3], "gemini-4-hydrogen"); assert_eq!(models[&5], "gemini-4-argon"); assert_eq!(models[&7], "future-worker"); assert_eq!(models[&9], "gemini-4-hydrogen-high"); + assert_eq!(models[&11], "gemini-4-neon"); + assert_eq!(models[&13], "gemini-4-argon"); } #[test] diff --git a/src-tauri/src/services/session_usage_agy/orchestrator_tests.rs b/src-tauri/src/services/session_usage_agy/orchestrator_tests.rs index 306cb8127..992db9e18 100644 --- a/src-tauri/src/services/session_usage_agy/orchestrator_tests.rs +++ b/src-tauri/src/services/session_usage_agy/orchestrator_tests.rs @@ -605,3 +605,85 @@ fn cli_worker_does_not_inherit_stale_direct_hydrogen_selection_across_rewind() { "2.325", ); } + +#[test] +fn orchestrator_neon_and_g1_pro_aliases_attribute_and_reparse_after_v3_cursor() { + if crate::config::sqlite_unsupported_in_temp_dir() { + return; + } + for (mode, planner, expected_model, expected_cost) in [ + ( + "Orchestrator (Neon)", + "gemini-pro-orchestrator-neon", + "gemini-4-neon", + "4.65", + ), + ( + "gemini-pro-orchestrator-neon", + "gemini-pro-orchestrator-neon", + "gemini-4-neon", + "4.65", + ), + ( + "Orchestrator (Argon)", + "gemini-pro-orchestrator-g1-pro", + "gemini-4-argon", + "3.1", + ), + ( + "gemini-pro-orchestrator-g1-pro", + "gemini-pro-orchestrator-g1-pro", + "gemini-4-argon", + "3.1", + ), + ] { + let dir = tempfile::tempdir().unwrap(); + std::fs::create_dir(dir.path().join("conversations")).unwrap(); + let source = dir + .path() + .join("brain/session/.system_generated/logs/transcript_full.jsonl"); + std::fs::create_dir_all(source.parent().unwrap()).unwrap(); + let rows = rows(mode); + let text = rows + .iter() + .map(Value::to_string) + .collect::>() + .join("\n"); + std::fs::write(&source, text).unwrap(); + let native_conn = native(&dir.path().join("conversations/session.db"), planner, mode); + drop(native_conn); + + let db = Database::memory().unwrap(); + let files = || vec![("session".into(), source.clone())]; + let initial = sync_agy_usage_from_files(&db, files()).unwrap(); + assert_eq!((initial.imported, initial.skipped), (2, 0), "{mode}"); + assert_price(&db, 1, expected_model, mode, expected_cost); + assert_price(&db, 3, "gemini-4-hydrogen", mode, "2.325"); + + // Simulate v3: cursor with previously unrecognized planner alias stored at $0. + { + let conn = db.conn.lock().unwrap(); + conn.execute( + "UPDATE proxy_request_logs + SET model=?1, input_cost_usd='0', output_cost_usd='0', + cache_read_cost_usd='0', total_cost_usd='0' + WHERE request_id='agy:session:1'", + [planner], + ) + .unwrap(); + conn.execute( + "UPDATE session_log_sync SET parser_state=?1", + [format!( + "v3:{}", + native_models::native_state_fingerprint(&source) + )], + ) + .unwrap(); + } + let upgraded = sync_agy_usage_from_files(&db, files()).unwrap(); + assert_eq!((upgraded.imported, upgraded.skipped), (1, 1), "{mode}"); + assert_price(&db, 1, expected_model, mode, expected_cost); + let steady = sync_agy_usage_from_files(&db, files()).unwrap(); + assert_eq!((steady.imported, steady.skipped), (0, 0), "{mode}"); + } +} diff --git a/src-tauri/src/services/usage_stats.rs b/src-tauri/src/services/usage_stats.rs index dca5a1693..3e1c18ac3 100644 --- a/src-tauri/src/services/usage_stats.rs +++ b/src-tauri/src/services/usage_stats.rs @@ -448,8 +448,7 @@ fn providers_join(log_alias: &str, provider_alias: &str) -> String { } /// SQL 标量表达式:行的「有效计价模型」—— pricing_model 非空优先,NULL/'' 回落 -/// model。这是 `get_model_stats` 的分组键,也是 Dashboard 模型筛选的匹配口径: -/// 筛选值来自模型统计列表,两边必须用同一表达式才能选得中。 +/// model。统计展示可合并同价的推理档位,原始请求仍保留此计价基准。 fn effective_model_sql(alias: &str) -> String { format!("COALESCE(NULLIF({alias}.pricing_model, ''), {alias}.model)") } @@ -508,7 +507,13 @@ struct UsageFilter<'a> { impl UsageFilter<'_> { /// 追加筛选条件。传了 `provider_name` 时 FROM 里必须有 [`Self::join`](或同样的 /// `LEFT JOIN providers`),否则 `{provider_alias}.name` 无法解析。 - fn push_to(&self, conditions: &mut SqlWhere, log_alias: &str, provider_alias: &str) { + fn push_to( + &self, + conn: &Connection, + conditions: &mut SqlWhere, + log_alias: &str, + provider_alias: &str, + ) -> Result<(), AppError> { if let Some(app_type) = self.app_type { let column = format!("{log_alias}.app_type"); conditions.push( @@ -523,11 +528,26 @@ impl UsageFilter<'_> { ); } if let Some(model) = self.model { - conditions.push( - format!("{} = ?", effective_model_sql(log_alias)), - model.to_string(), - ); + let expr = effective_model_sql(log_alias); + let suffixes = merged_reasoning_suffixes_for_filter(conn, model)?; + if suffixes.is_empty() { + conditions.push(format!("{expr} = ?"), model.to_string()); + } else { + let char_len = i64::try_from(model.chars().count()).unwrap_or(i64::MAX); + let placeholders = vec!["?"; suffixes.len()].join(", "); + conditions.push_condition(format!( + "({expr} = ? OR (SUBSTR({expr}, 1, ?) = ? AND LOWER(SUBSTR({expr}, ?)) IN ({placeholders})))" + )); + conditions.params.push(Box::new(model.to_string())); + conditions.params.push(Box::new(char_len)); + conditions.params.push(Box::new(model.to_string())); + conditions.params.push(Box::new(char_len.saturating_add(1))); + for suffix in suffixes { + conditions.params.push(Box::new(suffix)); + } + } } + Ok(()) } /// 只有按 Provider 筛选时才需要连 providers 表。 @@ -556,19 +576,79 @@ impl UsageFilter<'_> { if let Some(end) = end_date { conditions.push("l.created_at <= ?", end); } - self.push_to(&mut conditions, "l", "p"); + self.push_to(conn, &mut conditions, "l", "p")?; Ok(conditions) } /// 汇总表 `r`(providers 别名 `p2`):只算被范围完整覆盖的本地自然日,再加筛选。 - fn rollup_where(&self, bounds: &RollupDateBounds) -> SqlWhere { + fn rollup_where( + &self, + conn: &Connection, + bounds: &RollupDateBounds, + ) -> Result { let mut conditions = SqlWhere::default(); push_rollup_date_filters(&mut conditions, "r.date", bounds); - self.push_to(&mut conditions, "r", "p2"); - conditions + self.push_to(conn, &mut conditions, "r", "p2")?; + Ok(conditions) } } +/// 仅合并四项 token 单价完全一致且基础模型本身有明确价格的推理档位; +/// 缺失基础定价、或任意一项存在自定义差价时保持独立。 +fn statistics_model(conn: &Connection, model: &str) -> Result { + let targets = reasoning_tier_merge_targets(model); + if targets.is_empty() { + return Ok(model.to_string()); + } + let parse = |row: (String, String, String, String)| { + ModelPricing::from_strings(&row.0, &row.1, &row.2, &row.3).ok() + }; + let Some(pricing) = find_model_pricing_row(conn, model)?.and_then(parse) else { + return Ok(model.to_string()); + }; + for target in targets { + if let Some(base_pricing) = find_direct_model_pricing_row(conn, target)?.and_then(parse) { + if pricing.input_cost_per_million == base_pricing.input_cost_per_million + && pricing.output_cost_per_million == base_pricing.output_cost_per_million + && pricing.cache_read_cost_per_million == base_pricing.cache_read_cost_per_million + && pricing.cache_creation_cost_per_million + == base_pricing.cache_creation_cost_per_million + { + return Ok(target.to_string()); + } + } + } + Ok(model.to_string()) +} + +fn merged_reasoning_suffixes_for_filter( + conn: &Connection, + model: &str, +) -> Result, AppError> { + if statistics_model(conn, model)? != model { + return Ok(Vec::new()); + } + let mut candidate_suffixes: Vec = REASONING_EFFORT_SUFFIXES + .iter() + .map(|s| (*s).to_string()) + .collect(); + let tiered_probe = format!("{model}-tiered"); + if strip_statistics_tiered_suffix(&tiered_probe).is_some() { + candidate_suffixes.push("-tiered".to_string()); + for effort in REASONING_EFFORT_SUFFIXES { + candidate_suffixes.push(format!("-tiered{effort}")); + } + } + let mut matched = Vec::new(); + for suffix in candidate_suffixes { + let variant = format!("{model}{suffix}"); + if statistics_model(conn, &variant)? == model { + matched.push(suffix); + } + } + Ok(matched) +} + /// 跨来源去重的模型匹配条件。 /// /// 常规路径按上游回显模型匹配。仅 Codex 会话允许再匹配代理记录的请求模型: @@ -1084,7 +1164,8 @@ impl Database { // Only include rolled-up rows for full local days that are fully covered by the range. let rollup_bounds = compute_rollup_date_bounds(start_date, end_date)?; - let (rollup_where, rollup_params) = filter.rollup_where(&rollup_bounds).into_where(); + let (rollup_where, rollup_params) = + filter.rollup_where(&conn, &rollup_bounds)?.into_where(); let rollup_join = filter.join("r", "p2"); let fresh_input_detail = fresh_input_sql("l"); @@ -1190,7 +1271,8 @@ impl Database { let detail_join = filter.join("l", "p"); let rollup_bounds = compute_rollup_date_bounds(start_date, end_date)?; - let (rollup_where, rollup_params) = filter.rollup_where(&rollup_bounds).into_where(); + let (rollup_where, rollup_params) = + filter.rollup_where(&conn, &rollup_bounds)?.into_where(); let rollup_join = filter.join("r", "p2"); let fresh_input_detail = fresh_input_sql("l"); @@ -1330,7 +1412,7 @@ impl Database { } let mut extra = SqlWhere::default(); - filter.push_to(&mut extra, "l", "p"); + filter.push_to(&conn, &mut extra, "l", "p")?; let (extra_filter, extra_params) = extra.into_and(); let detail_join = filter.join("l", "p"); @@ -1424,7 +1506,7 @@ impl Database { let bucket_count = (end_day.signed_duration_since(start_day).num_days() + 1) as usize; let mut extra = SqlWhere::default(); - filter.push_to(&mut extra, "l", "p"); + filter.push_to(&conn, &mut extra, "l", "p")?; let (extra_filter, extra_params) = extra.into_and(); let detail_join = filter.join("l", "p"); @@ -1481,7 +1563,8 @@ impl Database { } let rollup_bounds = compute_rollup_date_bounds(Some(start_ts), Some(end_ts))?; - let (rollup_where, rollup_params) = filter.rollup_where(&rollup_bounds).into_where(); + let (rollup_where, rollup_params) = + filter.rollup_where(&conn, &rollup_bounds)?.into_where(); let rollup_join = filter.join("r", "p2"); let fresh_input_rollup = fresh_input_sql("r"); @@ -1589,7 +1672,7 @@ impl Database { model, }; let mut detail = SqlWhere::default(); - filter.push_to(&mut detail, "l", "p"); + filter.push_to(&conn, &mut detail, "l", "p")?; let (detail_where, detail_params) = detail.into_where(); let detail_join = filter.join("l", "p"); let detail_param_refs: Vec<&dyn rusqlite::ToSql> = @@ -1606,7 +1689,7 @@ impl Database { .transpose()?; let mut rollup = SqlWhere::default(); - filter.push_to(&mut rollup, "r", "p2"); + filter.push_to(&conn, &mut rollup, "r", "p2")?; let (rollup_where, rollup_params) = rollup.into_where(); let rollup_join = filter.join("r", "p2"); let rollup_param_refs: Vec<&dyn rusqlite::ToSql> = @@ -1651,7 +1734,8 @@ impl Database { .into_where(); let rollup_bounds = compute_rollup_date_bounds(start_date, end_date)?; - let (rollup_where, rollup_params) = filter.rollup_where(&rollup_bounds).into_where(); + let (rollup_where, rollup_params) = + filter.rollup_where(&conn, &rollup_bounds)?.into_where(); // UNION detail logs + rollup data, then aggregate let detail_pname = provider_name_coalesce("l", "p"); @@ -1800,7 +1884,8 @@ impl Database { let detail_join = filter.join("l", "p"); let rollup_bounds = compute_rollup_date_bounds(start_date, end_date)?; - let (rollup_where, rollup_params) = filter.rollup_where(&rollup_bounds).into_where(); + let (rollup_where, rollup_params) = + filter.rollup_where(&conn, &rollup_bounds)?.into_where(); let rollup_join = filter.join("r", "p2"); // UNION detail logs + rollup data @@ -1859,70 +1944,108 @@ impl Database { ORDER BY total_cost DESC" ); - let (first_token_ms, est_first_token_ms) = { - let detail_refs: Vec<&dyn rusqlite::ToSql> = - detail_params.iter().map(|p| p.as_ref()).collect(); - let from_sql = format!("FROM proxy_request_logs l {detail_join}"); - let medians = |eligible_sql: String| { - first_token_medians( - &conn, - &detail_model, - &from_sql, - &detail_where, - &eligible_sql, - &detail_refs, - ) - }; - ( - medians(first_token_eligible_sql("l"))?, - medians(est_first_token_eligible_sql("l"))?, + let mut stmt = conn.prepare(&sql)?; + let mut params: Vec<&dyn rusqlite::ToSql> = + detail_params.iter().map(|p| p.as_ref()).collect(); + params.extend(rollup_params.iter().map(|p| p.as_ref())); + let rows = stmt.query_map(params.as_slice(), |row| { + Ok(( + row.get::<_, String>(0)?, + row.get::<_, i64>(1)?.max(0) as u64, + row.get::<_, i64>(2)?.max(0) as u64, + row.get::<_, f64>(3)?, + row.get::<_, i64>(4)?.max(0) as u64, + row.get::<_, i64>(5)?.max(0) as u64, + row.get::<_, i64>(6)?.max(0) as u64, + row.get::<_, i64>(7)?.max(0) as u64, + row.get::<_, i64>(8)?.max(0) as u64, + )) + })?; + let mut grouped: HashMap = HashMap::new(); + let mut model_cases = Vec::new(); + for row in rows { + let (raw, count, tokens, cost, successes, output, ms, est_output, est_ms) = row?; + let model = statistics_model(&conn, &raw)?; + if model != raw { + // 来自数据库的模型名作为 SQL 字符串字面量使用。 + model_cases.push(format!( + "WHEN '{}' THEN '{}'", + raw.replace('\'', "''"), + model.replace('\'', "''") + )); + } + let (stats, total_cost, success_count) = + grouped.entry(model.clone()).or_insert_with(|| { + ( + ModelStats { + model, + request_count: 0, + total_tokens: 0, + total_cost: String::new(), + avg_cost_per_request: String::new(), + success_rate: 0.0, + speed_output_tokens: 0, + speed_generation_ms: 0, + est_speed_output_tokens: 0, + est_speed_duration_ms: 0, + first_token_median_ms: None, + est_first_token_median_ms: None, + }, + 0.0, + 0, + ) + }); + stats.request_count += count; + stats.total_tokens += tokens; + stats.speed_output_tokens += output; + stats.speed_generation_ms += ms; + stats.est_speed_output_tokens += est_output; + stats.est_speed_duration_ms += est_ms; + *total_cost += cost; + *success_count += successes; + } + + // 首字时间按合并后的全部样本取中位数,不能平均各档位的中位数。 + let median_model = if model_cases.is_empty() { + detail_model + } else { + format!( + "CASE {detail_model} {} ELSE {detail_model} END", + model_cases.join(" ") ) }; - - let mut stmt = conn.prepare(&sql)?; - let mut params: Vec> = detail_params; - params.extend(rollup_params); - let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect(); - let row_mapper = |row: &rusqlite::Row| { - let request_count: i64 = row.get(1)?; - let model: String = row.get(0)?; - let first_token_median_ms = first_token_ms.get(&model).copied(); - let est_first_token_median_ms = est_first_token_ms.get(&model).copied(); - let total_cost: f64 = row.get(3)?; - let avg_cost = if request_count > 0 { - total_cost / request_count as f64 - } else { - 0.0 - }; - let success_count: i64 = row.get(4)?; - let success_rate = if request_count > 0 { - (success_count as f32 / request_count as f32) * 100.0 - } else { - 0.0 - }; - - Ok(ModelStats { - model, - request_count: request_count as u64, - total_tokens: row.get::<_, i64>(2)? as u64, - total_cost: format!("{total_cost:.6}"), - avg_cost_per_request: format!("{avg_cost:.6}"), - success_rate, - speed_output_tokens: row.get::<_, i64>(5)?.max(0) as u64, - speed_generation_ms: row.get::<_, i64>(6)?.max(0) as u64, - est_speed_output_tokens: row.get::<_, i64>(7)?.max(0) as u64, - est_speed_duration_ms: row.get::<_, i64>(8)?.max(0) as u64, - first_token_median_ms, - est_first_token_median_ms, - }) + let detail_refs: Vec<&dyn rusqlite::ToSql> = + detail_params.iter().map(|p| p.as_ref()).collect(); + let from_sql = format!("FROM proxy_request_logs l {detail_join}"); + let medians = |eligible_sql: String| { + first_token_medians( + &conn, + &median_model, + &from_sql, + &detail_where, + &eligible_sql, + &detail_refs, + ) }; - - let rows = stmt.query_map(param_refs.as_slice(), row_mapper)?; - - let mut stats = Vec::new(); - for row in rows { - stats.push(row?); - } + let first_token_ms = medians(first_token_eligible_sql("l"))?; + let est_first_token_ms = medians(est_first_token_eligible_sql("l"))?; + let mut stats: Vec<_> = grouped + .into_values() + .map(|(mut stat, cost, successes)| { + stat.total_cost = format!("{cost:.6}"); + if stat.request_count > 0 { + stat.avg_cost_per_request = format!("{:.6}", cost / stat.request_count as f64); + stat.success_rate = successes as f32 / stat.request_count as f32 * 100.0; + } else { + stat.avg_cost_per_request = "0.000000".to_string(); + } + stat.first_token_median_ms = first_token_ms.get(&stat.model).copied(); + stat.est_first_token_median_ms = est_first_token_ms.get(&stat.model).copied(); + (stat, cost) + }) + .collect(); + stats.sort_by(|a, b| b.1.total_cmp(&a.1).then_with(|| a.0.model.cmp(&b.0.model))); + let stats = stats.into_iter().map(|(stat, _)| stat).collect(); Ok(stats) } @@ -1951,7 +2074,7 @@ impl Database { // 应用仅过滤口径折叠 claude-desktop→claude;行投影仍返回原始 app_type, // 详情面板据此展示真实入口(路由接管账单审计需要)。Provider/模型与 Dashboard // 顶部下拉筛选同口径(会话占位行如 "Claude (Session)" 也能命中)。 - filter.push_to(&mut conditions, "l", "p"); + filter.push_to(&conn, &mut conditions, "l", "p")?; if let Some(status) = filters.status_code { conditions.push("l.status_code = ?", status as i64); } @@ -2345,6 +2468,53 @@ struct PricingCandidate { allow_prefix_match: bool, } +/// 直接定价查询:只认精确匹配及命名空间/版本/日期/点号标准化后的精确匹配, +/// 不走推理档位回退,也不走 `LIKE 'base-%'` 前缀匹配,避免缺失基础定价时借用邻近档位价格。 +fn find_direct_model_pricing_row( + conn: &Connection, + model_id: &str, +) -> Result, AppError> { + let cleaned = clean_model_id_for_pricing(model_id); + if is_placeholder_pricing_model(&cleaned) { + return Ok(None); + } + + let mut candidates = Vec::new(); + let mut queue = VecDeque::from([cleaned]); + while let Some(candidate) = queue.pop_front() { + if candidate.is_empty() || candidates.iter().any(|existing| existing == &candidate) { + continue; + } + candidates.push(candidate.clone()); + if let Some(stripped) = strip_known_model_namespace(&candidate) { + queue.push_back(stripped); + } + if let Some(stripped) = strip_claude_desktop_non_anthropic_prefix(&candidate) { + queue.push_back(stripped); + } + if let Some(stripped) = strip_bedrock_model_version_suffix(&candidate) { + queue.push_back(stripped); + } + if candidate.starts_with("claude-") + && candidate.contains('.') + && strip_claude_desktop_non_anthropic_prefix(&candidate).is_none() + { + queue.push_back(candidate.replace('.', "-")); + } + if let Some(stripped) = strip_model_date_suffix(&candidate) { + queue.push_back(stripped); + } + } + + for candidate in &candidates { + if let Some(row) = query_model_pricing_exact(conn, candidate)? { + return Ok(Some(row)); + } + } + + Ok(None) +} + pub(crate) fn find_model_pricing_row( conn: &Connection, model_id: &str, @@ -2689,17 +2859,56 @@ fn strip_model_date_suffix(model_id: &str) -> Option { None } +const REASONING_EFFORT_SUFFIXES: &[&str] = &["-minimal", "-low", "-medium", "-high", "-xhigh"]; + +fn strip_ascii_case_insensitive_suffix<'a>(s: &'a str, suffix: &str) -> Option<&'a str> { + if s.len() <= suffix.len() { + return None; + } + let split = s.len() - suffix.len(); + if !s.is_char_boundary(split) { + return None; + } + s[split..] + .eq_ignore_ascii_case(suffix) + .then_some(&s[..split]) +} + fn strip_reasoning_effort_suffix(model_id: &str) -> Option { - for suffix in ["-minimal", "-low", "-medium", "-high", "-xhigh"] { - if let Some(stripped) = model_id.strip_suffix(suffix) { - if !stripped.is_empty() { - return Some(stripped.to_string()); - } + for suffix in REASONING_EFFORT_SUFFIXES { + if let Some(stripped) = strip_ascii_case_insensitive_suffix(model_id, suffix) { + return Some(stripped.to_string()); } } None } +fn strip_statistics_tiered_suffix(model_id: &str) -> Option<&str> { + let stripped = strip_ascii_case_insensitive_suffix(model_id, "-tiered")?; + let tail = model_id.rsplit_once('/').map_or(model_id, |(_, r)| r); + let lower_tail = tail.to_ascii_lowercase(); + let normalized_tail = strip_known_model_namespace(&lower_tail).unwrap_or(lower_tail); + let is_known_tiered = normalized_tail == "gemini-4-hydrogen-tiered" + || strip_gemini_flash_tiered_suffix(&normalized_tail).is_some(); + is_known_tiered.then_some(stripped) +} + +fn reasoning_tier_merge_targets(model_id: &str) -> Vec<&str> { + let mut targets = Vec::new(); + let after_effort = REASONING_EFFORT_SUFFIXES + .iter() + .find_map(|suffix| strip_ascii_case_insensitive_suffix(model_id, suffix)); + if let Some(base_after_effort) = after_effort { + if let Some(base_after_tiered) = strip_statistics_tiered_suffix(base_after_effort) { + targets.push(base_after_tiered); + } + targets.push(base_after_effort); + } else if let Some(base_after_tiered) = strip_statistics_tiered_suffix(model_id) { + targets.push(base_after_tiered); + } + targets +} + fn strip_gemini_flash_tiered_suffix(model_id: &str) -> Option { let version = model_id .strip_prefix("gemini-")? @@ -6855,4 +7064,310 @@ mod tests { ); Ok(()) } + + #[test] + fn test_reasoning_statistics_require_equal_prices_and_known_base() -> Result<(), AppError> { + let db = Database::memory()?; + let conn = lock_conn!(db.conn); + conn.execute( + "INSERT OR REPLACE INTO model_pricing VALUES + ('gemini-3.8-flash', 'Flash', '0.75', '3.75', '0.075', '0'), + ('gemini-3.8-flash-high', 'High', '0.750', '3.750', '0.0750', '0.0'), + ('gemini-3.8-flash-low', 'Low', '0.75', '3.75', '0.15', '0'), + ('gemini-3.8-flash-minimal', 'Minimal', '0.75', '3.75', '0.075', '1'), + ('gemini-9-pro-low', 'Nine Low', '1', '5', '0.1', '0'), + ('gemini-9-pro-high', 'Nine High', '2', '10', '0.2', '0'), + ('claude-opus-5-5', 'Opus', '4', '20', '0.2', '5')", + [], + )?; + + for (model, expected) in [ + ("gemini-3.8-flash-high", "gemini-3.8-flash"), + ("gemini-3.8-flash-medium", "gemini-3.8-flash"), + ("gemini-3.8-flash-tiered", "gemini-3.8-flash"), + ("gemini-3.8-flash-tiered-high", "gemini-3.8-flash"), + ("models/gemini-3.8-flash-tiered", "models/gemini-3.8-flash"), + ("google/GEMINI-3.8-FLASH-TIERED", "google/GEMINI-3.8-FLASH"), + ("gemini-4-hydrogen-high", "gemini-4-hydrogen"), + ("gemini-4-hydrogen-tiered", "gemini-4-hydrogen"), + ("gemini-4-hydrogen-tiered-high", "gemini-4-hydrogen"), + ( + "models/gemini-4-hydrogen-tiered-HIGH", + "models/gemini-4-hydrogen", + ), + ("gemini-4-neon-high", "gemini-4-neon"), + ("gemini-4-neon-xhigh", "gemini-4-neon"), + ("claude-opus-5.5-medium", "claude-opus-5.5"), + ("GPT-5.5-HIGH", "GPT-5.5"), + ] { + assert_eq!(statistics_model(&conn, model)?, expected, "{model}"); + } + + // 缺失基础模型定价(gemini-9-pro、devstral、magistral、gemini-3.1-flash)绝不能通过前缀匹配合并; + // 自定义差价、Flash Lite 与未知模型同样保持独立。 + for model in [ + "gemini-3.8-flash-low", + "gemini-3.8-flash-minimal", + "gemini-9-pro-low", + "gemini-9-pro-medium", + "gemini-9-pro-high", + "devstral-medium", + "magistral-medium", + "missing-high", + "gemini-3.5-flash-lite", + "gemini-3.1-flash-tiered", + "custom-tiered", + ] { + assert_eq!(statistics_model(&conn, model)?, model, "{model}"); + } + + // 输入或输出差价同样不能合并。 + for column in ["input_cost_per_million", "output_cost_per_million"] { + conn.execute( + &format!( + "UPDATE model_pricing SET {column} = '99' WHERE model_id = 'gemini-3.8-flash-high'" + ), + [], + )?; + assert_eq!( + statistics_model(&conn, "gemini-3.8-flash-high")?, + "gemini-3.8-flash-high" + ); + conn.execute( + "UPDATE model_pricing SET input_cost_per_million = '0.75', output_cost_per_million = '3.75' WHERE model_id = 'gemini-3.8-flash-high'", + [], + )?; + } + + // 为 `-tiered` 单独配置差价后,`-tiered` 保持独立,`-tiered-high` 只合并到 `-tiered`。 + conn.execute( + "INSERT OR REPLACE INTO model_pricing VALUES + ('gemini-4-hydrogen-tiered', 'Custom Hydrogen Tiered', '2', '10', '0.1', '0')", + [], + )?; + assert_eq!( + statistics_model(&conn, "gemini-4-hydrogen-tiered")?, + "gemini-4-hydrogen-tiered" + ); + assert_eq!( + statistics_model(&conn, "gemini-4-hydrogen-tiered-high")?, + "gemini-4-hydrogen-tiered" + ); + Ok(()) + } + + #[test] + fn test_flash_and_hydrogen_tiered_pricing_backfill_and_grouping() -> Result<(), AppError> { + let db = Database::memory()?; + { + let conn = lock_conn!(db.conn); + for (id, model) in [ + ("flash-tiered", "gemini-3.8-flash-tiered"), + ("flash-medium", "gemini-3.8-flash-medium"), + ("h-tiered-high", "gemini-4-hydrogen-tiered-high"), + ("h-low", "gemini-4-hydrogen-low"), + ("neon-high", "gemini-4-neon-high"), + ] { + insert_usage_log( + &conn, + id, + "agy", + "_agy_session", + model, + "agy_session", + 1000, + 100, + 200, + 0, + 0, + 200, + "0", + )?; + } + } + assert_eq!( + db.backfill_missing_usage_costs_for_model("gemini-3.8-flash")?, + 2 + ); + assert_eq!( + db.backfill_missing_usage_costs_for_model("gemini-4-hydrogen")?, + 2 + ); + assert_eq!( + db.backfill_missing_usage_costs_for_model("gemini-4-neon")?, + 1 + ); + + let flash_stats = + db.get_model_stats(None, None, Some("agy"), None, Some("gemini-3.8-flash"))?; + assert_eq!(flash_stats.len(), 1); + assert_eq!(flash_stats[0].model, "gemini-3.8-flash"); + assert_eq!(flash_stats[0].request_count, 2); + assert_eq!(flash_stats[0].total_cost, "0.001650"); + + let hydrogen_stats = + db.get_model_stats(None, None, Some("agy"), None, Some("gemini-4-hydrogen"))?; + assert_eq!(hydrogen_stats.len(), 1); + assert_eq!(hydrogen_stats[0].model, "gemini-4-hydrogen"); + assert_eq!(hydrogen_stats[0].request_count, 2); + assert_eq!(hydrogen_stats[0].total_cost, "0.003300"); + + let neon_stats = + db.get_model_stats(None, None, Some("agy"), None, Some("gemini-4-neon"))?; + assert_eq!(neon_stats.len(), 1); + assert_eq!(neon_stats[0].model, "gemini-4-neon"); + assert_eq!(neon_stats[0].request_count, 1); + assert_eq!(neon_stats[0].total_cost, "0.003300"); + + let detail = db + .get_request_detail("flash-tiered")? + .expect("tiered request"); + assert_eq!(detail.model, "gemini-3.8-flash-tiered"); + assert_eq!(detail.total_cost_usd, "0.000825"); + Ok(()) + } + + #[test] + fn test_merged_reasoning_models_keep_totals_filters_and_pooled_medians() -> Result<(), AppError> + { + let db = Database::memory()?; + let ts = local_ts(2026, 6, 10, 12, 0, 0); + { + let conn = lock_conn!(db.conn); + // 样本分布在三个档位:base=[10]、high=[20, 30]、medium=[1000, 2000, 3000]。 + // 全样本合并中位数 = (30 + 1000) / 2 = 515; + // 各档位中位数 [10, 25, 2000] 的中位数 = 25、均值 = 678、加权均值 = 1010,互不相同。 + for (id, model, first, cost) in [ + ("base", "gemini-4-argon", 10, "1"), + ("high-1", "gemini-4-argon-high", 20, "2"), + ("high-2", "gemini-4-argon-HIGH", 30, "3"), + ("medium-1", "gemini-4-argon-medium", 1000, "4"), + ("medium-2", "gemini-4-argon-medium", 2000, "5"), + ("medium-3", "gemini-4-argon-medium", 3000, "6"), + ] { + insert_usage_log( + &conn, + id, + "agy", + "_agy_session", + model, + "proxy", + ts, + 100, + 200, + 0, + 0, + 200, + cost, + )?; + conn.execute( + "UPDATE proxy_request_logs SET first_token_ms = ?1, latency_ms = ?1 + 1000 WHERE request_id = ?2", + params![first, id], + )?; + } + conn.execute( + "UPDATE proxy_request_logs SET model = 'routed-alias', pricing_model = 'gemini-4-argon-medium' WHERE request_id = 'medium-1'", + [], + )?; + conn.execute( + "INSERT INTO usage_daily_rollups ( + date, app_type, provider_id, model, request_count, success_count, + input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, + total_cost_usd, avg_latency_ms + ) VALUES ('2026-06-08', 'agy', '_agy_session', 'gemini-4-argon-high', 2, 1, 200, 400, 0, 0, '5', 1000)", + [], + )?; + // 带前缀的 `-tiered` 也要支持合并及筛选回查。 + insert_usage_log( + &conn, + "prefixed-tiered", + "agy", + "_agy_session", + "models/gemini-3.8-flash-tiered", + "agy_session", + ts, + 100, + 200, + 0, + 0, + 200, + "1", + )?; + } + + let stats = db.get_model_stats(None, None, Some("agy"), None, None)?; + assert_eq!(stats.len(), 2); + let stat = stats + .iter() + .find(|s| s.model == "gemini-4-argon") + .expect("merged argon stat"); + assert_eq!(stat.request_count, 8); + assert_eq!(stat.total_tokens, 2400); + assert_eq!(stat.total_cost, "26.000000"); + assert_eq!(stat.avg_cost_per_request, "3.250000"); + assert!((stat.success_rate - 700.0 / 8.0).abs() < 0.001); + assert_eq!(stat.speed_output_tokens, 1200); + assert_eq!(stat.speed_generation_ms, 6000); + assert_eq!(stat.first_token_median_ms, Some(515)); + + let model = Some("gemini-4-argon"); + let summary = db.get_usage_summary(None, None, Some("agy"), None, model)?; + assert_eq!(summary.total_requests, 8); + assert_eq!(summary.total_cost, "26.000000"); + assert_eq!( + db.get_usage_summary_by_app(None, None, None, model)?[0] + .summary + .total_requests, + 8 + ); + assert_eq!( + db.get_provider_stats(None, None, Some("agy"), None, model)?[0].request_count, + 8 + ); + assert_eq!( + db.get_model_stats(None, None, Some("agy"), None, model)?[0].request_count, + 8 + ); + assert_eq!( + db.get_first_usage_date(Some("agy"), None, model)? + .as_deref(), + Some("2026-06-08") + ); + let trends = db.get_daily_trends( + Some(local_ts(2026, 6, 8, 0, 0, 0)), + Some(ts + 1), + Some("agy"), + None, + model, + )?; + assert_eq!(trends.iter().map(|t| t.request_count).sum::(), 8); + let hourly = + db.get_daily_trends(Some(ts - 3600), Some(ts + 1), Some("agy"), None, model)?; + assert_eq!(hourly.iter().map(|t| t.request_count).sum::(), 6); + let logs = db.get_request_logs( + &LogFilters { + model: model.map(str::to_string), + ..Default::default() + }, + 0, + 10, + )?; + assert_eq!(logs.total, 6); + assert!(logs.data.iter().any(|l| l.model == "gemini-4-argon-high")); + assert!(logs.data.iter().any(|l| l.model == "gemini-4-argon-HIGH")); + assert!(logs.data.iter().any(|l| l.model == "routed-alias")); + + // `models/` 前缀的 `-tiered` 合并与筛选闭环。 + let prefixed = db.get_model_stats( + None, + None, + Some("agy"), + None, + Some("models/gemini-3.8-flash"), + )?; + assert_eq!(prefixed.len(), 1); + assert_eq!(prefixed[0].model, "models/gemini-3.8-flash"); + assert_eq!(prefixed[0].request_count, 1); + Ok(()) + } }