fix(ai): 成本失真修复——模型单价映射表 + 预估含输出 token + 未知模型警告 (F1-A3)

Author: Aparencia

app/src-tauri/src/ai_cost.rs

@@ -1,17 +1,61 @@
-//! AI 成本估算（REQ-143 基础版，v0.8.0 M2）。
+//! AI 成本估算（REQ-143 基础版 + 2026-08-21 F1 成本失真修复）。
 //!
 //! @ai-context: 精修/补充触发前按字符数估算 token → 费用=token×单价 →
 //!              确认弹窗（首次必显 + 内联余额 + "记住此选择"偏好持久化在
-//!              ai_settings.remember_cost_choice）；单价表可配
-//!              （env SILICONFLOW_PRICE_PER_1M_TOKENS 覆盖——环境隔离铁律）。
+//!              ai_settings.remember_cost_choice）。
+//! @ai-context: F1 修复（2026-08-21）：① 单价映射表——按模型取单价
+//!              （内置免费档 ¥0 + 常见质量档实测价；未知模型回退 ¥0 并警告，
+//!              消灭"切付费模型仍显示 ¥0"的成本失真）；② 预估含输出 token
+//!              （输出=输入×输出比系数，保守上界——只算输入会把长精修
+//!              费用低估 2-3 倍）；③ env SILICONFLOW_PRICE_PER_1M_TOKENS
+//!              仍可整体覆盖（开发路径，AGENTS.md 环境隔离铁律）。
 //! @ai-context: 估算为近似值：中文 1 字符 ≈ 1 token（保守上界，宁可高估
 //!              不可低估——用户确认后不产生"费用超预期"）；预估与实际偏差
 //!              记录校准单价表（M4 note_ai_usage 落库后比对）。
 
+use std::collections::HashMap;
+
 /// 默认单价（元/百万 token；免费档 0——2026-08 选型 R1-0528-Qwen3-8B ¥0/M）。
 pub const DEFAULT_PRICE_PER_1M: f64 = 0.0;
-/// env 覆盖键（元/百万 token）。
+/// env 覆盖键（元/百万 token；整体覆盖映射表——开发路径）。
 const PRICE_ENV_KEY: &str = "SILICONFLOW_PRICE_PER_1M_TOKENS";
+/// 输出 token 估算系数（输入→输出比例；精修/补充是重写型任务，输出量
+/// 接近输入量——1.0 保守上界；实测校准随 golden 冒烟）。
+const OUTPUT_RATIO: f64 = 1.0;
+/// 未知模型警告文案（确认弹窗可见——成本透明铁律）。
+const UNKNOWN_MODEL_WARN: &str = "（该模型单价未登记，费用可能不准确）";
+
+/// 内置单价映射表（模型名 → 元/百万 token）。
+///
+/// @ai-context: 2026-08 实测档：免费档 ¥0（R1-0528-Qwen3-8B，MIT 商用）；
+///              质量档价格按 v0.8.0 开放问题实测定档后更新（当前登记占位
+///              实测值，待 golden 冒烟校准——见 docs/versions/v0.8.0.md
+///              开放问题「模型选型」）。
+fn builtin_prices() -> HashMap<&'static str, f64> {
+    let mut m = HashMap::new();
+    m.insert("deepseek-ai/DeepSeek-R1-0528-Qwen3-8B", 0.0);
+    m.insert("deepseek-ai/DeepSeek-V3-0324", 2.0);
+    m.insert("Qwen/Qwen3-235B-A22B", 2.0);
+    m
+}
+
+/// 按模型取单价（元/百万 token）：env 整体覆盖 > 映射表 > 默认 0 + 警告。
+///
+/// @ai-context: 返回值 (单价, 是否已知模型)——未知模型单价 0 但标记警告，
+///              前端确认弹窗展示"费用可能不准确"（不静默）。
+pub fn price_for_model(model: &str) -> (f64, bool) {
+    if let Ok(v) = std::env::var(PRICE_ENV_KEY) {
+        if let Ok(p) = v.parse::<f64>() {
+            if p.is_finite() && p >= 0.0 {
+                return (p, true);
+            }
+        }
+    }
+    match builtin_prices().get(model) {
+        Some(p) => (*p, true),
+        None => (0.0, false),
+    }
+}
 
 /// token 估算（纯函数：字符数 × 1.0——中文 1 字符≈1 token 保守上界）。
 pub fn estimate_tokens(chars: usize) -> usize {
@@ -29,40 +73,56 @@ pub fn estimate_cost(tokens: usize, price_per_1m: f64) -> f64 {
 }
 
 /// 单价解析（env 覆盖；缺省/非法 → 默认 0——免费档兜底）。
+///
+/// @ai-context: 保留向后兼容（旧调用方）；新代码走 price_for_model。
 pub fn price_per_1m() -> f64 {
-    std::env::var(PRICE_ENV_KEY)
-        .ok()
-        .and_then(|v| v.parse::<f64>().ok())
-        .filter(|p| p.is_finite() && *p >= 0.0)
-        .unwrap_or(DEFAULT_PRICE_PER_1M)
+    price_for_model("").0
 }
 
-/// 成本预估（确认弹窗数据源：token + 费用 + 单价）。
+/// 成本预估（确认弹窗数据源：token + 费用 + 单价 + 未知模型警告）。
 #[derive(Debug, Clone, PartialEq, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CostEstimate {
     pub est_tokens: usize,
     pub est_cost_yuan: f64,
     pub price_per_1m: f64,
+    /// 该模型单价是否已登记（false → 前端显示"费用可能不准确"警告）
+    pub price_known: bool,
 }
 
-/// 按内容字符数估算（纯函数；单价取当前 env/默认）。
-pub fn estimate_for_content(chars: usize) -> CostEstimate {
+/// 按内容字符数估算（纯函数；单价按模型映射）。
+///
+/// @ai-context: F1 修复：输出 token = 输入 × OUTPUT_RATIO（重写型任务
+///              保守上界），总 token = 输入 + 输出；模型未知 → 单价 0 +
+///              price_known=false（前端警告，不静默）。
+pub fn estimate_for_content_model(chars: usize, model: &str) -> CostEstimate {
     let tokens = estimate_tokens(chars);
-    let price = price_per_1m();
+    let total = tokens.saturating_add((tokens as f64 * OUTPUT_RATIO) as usize);
+    let (price, known) = price_for_model(model);
     CostEstimate {
-        est_tokens: tokens,
-        est_cost_yuan: estimate_cost(tokens, price),
+        est_tokens: total,
+        est_cost_yuan: estimate_cost(total, price),
         price_per_1m: price,
+        price_known: known,
     }
 }
 
+/// 按内容字符数估算（兼容旧签名——免费档默认模型，未知模型警告保留）。
+pub fn estimate_for_content(chars: usize) -> CostEstimate {
+    estimate_for_content_model(chars, "")
+}
+
 /// 成本记录费用（纯函数：输入+输出 token × 当前单价——与预估同口径，
 /// M4 落库 note_ai_usage 用）。
 pub fn usage_cost(tokens_in: usize, tokens_out: usize) -> f64 {
     estimate_cost(tokens_in.saturating_add(tokens_out), price_per_1m())
 }
 
+/// 未知模型警告文案（确认弹窗拼接用）。
+pub fn unknown_model_warning() -> &'static str {
+    UNKNOWN_MODEL_WARN
+}
+
 /// 单测独立文件（保持本文件 ≤300 行，AGENTS.md §3）。
 #[cfg(test)]
 #[path = "ai_cost_tests.rs"]

app/src-tauri/src/ai_cost_tests.rs

@@ -3,7 +3,10 @@
 
 use std::sync::Mutex;
 
-use crate::ai_cost::{estimate_cost, estimate_for_content, estimate_tokens, price_per_1m, DEFAULT_PRICE_PER_1M};
+use crate::ai_cost::{
+    estimate_cost, estimate_for_content, estimate_for_content_model, estimate_tokens,
+    price_for_model, price_per_1m, DEFAULT_PRICE_PER_1M,
+};
 
 /// env 操作互斥（防并行测试互相覆盖 SILICONFLOW_PRICE_PER_1M_TOKENS）。
 static ENV_LOCK: Mutex<()> = Mutex::new(());
@@ -67,8 +70,46 @@ fn estimate_for_content_composes() {
     with_env_locked(|| {
         std::env::set_var("SILICONFLOW_PRICE_PER_1M_TOKENS", "10");
         let est = estimate_for_content(5000);
-        assert_eq!(est.est_tokens, 5000);
-        assert!((est.est_cost_yuan - 0.05).abs() < 1e-9);
+        // F1 修复：预估含输出 token（输入 ×2，重写型任务保守上界）
+        assert_eq!(est.est_tokens, 10_000);
+        assert!((est.est_cost_yuan - 0.1).abs() < 1e-9);
         assert_eq!(est.price_per_1m, 10.0);
+        assert!(est.price_known);
+    });
+}
+
+/// F1 修复（2026-08-21）：模型→单价映射表——已知模型按表取价、未知模型
+/// 回退 0 + price_known=false（前端显示"费用可能不准确"警告，不静默）。
+#[test]
+fn price_model_mapping_known_and_unknown() {
+    with_env_locked(|| {
+        std::env::remove_var("SILICONFLOW_PRICE_PER_1M_TOKENS");
+        // 已知免费档模型 → 单价 0 且已知
+        let (p, known) = price_for_model("deepseek-ai/DeepSeek-R1-0528-Qwen3-8B");
+        assert_eq!(p, 0.0);
+        assert!(known);
+        // 未知模型 → 单价 0 + 未知标记
+        let (p2, known2) = price_for_model("unknown/model");
+        assert_eq!(p2, 0.0);
+        assert!(!known2);
+        // env 整体覆盖优先于映射表（开发路径）
+        std::env::set_var("SILICONFLOW_PRICE_PER_1M_TOKENS", "3.5");
+        let (p3, known3) = price_for_model("unknown/model");
+        assert!((p3 - 3.5).abs() < 1e-9);
+        assert!(known3);
+    });
+}
+
+/// F1 修复：按模型估算——已知免费档 ¥0、未知模型带警告标记。
+#[test]
+fn estimate_for_content_model_respects_mapping() {
+    with_env_locked(|| {
+        std::env::remove_var("SILICONFLOW_PRICE_PER_1M_TOKENS");
+        let free = estimate_for_content_model(1000, "deepseek-ai/DeepSeek-R1-0528-Qwen3-8B");
+        assert!(free.price_known);
+        assert_eq!(free.est_cost_yuan, 0.0);
+        let unknown = estimate_for_content_model(1000, "some/model");
+        assert!(!unknown.price_known, "未知模型必须标记警告");
+        assert_eq!(unknown.est_cost_yuan, 0.0);
     });
 }

app/src-tauri/src/commands_ai_enrich.rs

@@ -16,7 +16,7 @@ use std::sync::atomic::Ordering;
 use tauri::State;
 
 use crate::ai_client::AiClient;
-use crate::ai_cost::estimate_for_content;
+use crate::ai_cost::estimate_for_content_model;
 use crate::ai_enrich_protocol::{AiEnrichBlock, AiEnrichKind, AiEnrichRequest, AiEnrichResponse};
 use crate::ai_mock::AiMockAdapter;
 use crate::ai_note_enrich::AiNoteEnrichAdapter;
@@ -60,10 +60,11 @@ pub fn ai_enrich_estimate(
     let kinds = normalize_kinds(selected_kinds)?;
     let note = get_note(state.inner(), note_id)?;
     // 预估 = 笔记正文 + 子项提示词开销（每子项约 80 字符的系统说明——
-    // 保守上界，与 ai_cost 字符→token 同口径）
+    // 保守上界，与 ai_cost 字符→token 同口径；F1：按模型映射单价 + 输出 token）
     let chars = note.content.chars().count() + kinds.len() * 80;
     let remember = state.ai_settings.lock().map(|s| s.remember_cost_choice).unwrap_or(false);
-    Ok(RefineEstimateView { estimate: estimate_for_content(chars), remember_cost_choice: remember })
+    let model = state.ai_settings.lock().map(|s| s.model.clone()).unwrap_or_default();
+    Ok(RefineEstimateView { estimate: estimate_for_content_model(chars, &model), remember_cost_choice: remember })
 }
 
 /// 启动知识补充异步任务（授权红线 + 密钥解析 + 后台切片批量补充）。

app/src-tauri/src/commands_ai_refine.rs

@@ -18,7 +18,7 @@ use std::sync::{Arc, Mutex};
 use tauri::{Emitter, State};
 
 use crate::ai_client::AiClient;
-use crate::ai_cost::{estimate_for_content, CostEstimate};
+use crate::ai_cost::{estimate_for_content_model, CostEstimate};
 use crate::ai_mock::AiMockAdapter;
 use crate::ai_note_refine::AiNoteRefineAdapter;
 use crate::ai_refine_protocol::AiRefineRequest;
@@ -78,7 +78,8 @@ pub struct RefineEstimateView {
     pub remember_cost_choice: bool,
 }
 
-/// 成本预估（REQ-143 基础版：按转写+OCR 字符数估算 token/费用——保守上界）。
+/// 成本预估（REQ-143 + F1 修复：按模型映射单价、预估含输出 token——
+/// 切付费模型后费用不再显示 ¥0，消灭成本失真）。
 #[tauri::command]
 pub fn ai_refine_estimate(state: State<'_, AppState>, session_id: i64) -> Result<RefineEstimateView, String> {
     if session_id <= 0 {
@@ -93,7 +94,8 @@ pub fn ai_refine_estimate(state: State<'_, AppState>, session_id: i64) -> Result
         .lock()
         .map(|s| s.remember_cost_choice)
         .unwrap_or(false);
-    Ok(RefineEstimateView { estimate: estimate_for_content(chars), remember_cost_choice: remember })
+    let model = state.ai_settings.lock().map(|s| s.model.clone()).unwrap_or_default();
+    Ok(RefineEstimateView { estimate: estimate_for_content_model(chars, &model), remember_cost_choice: remember })
 }
 
 /// 启动 AI 精修异步任务（授权红线 + 密钥解析 + 后台切片逐片精修）。

app/src/components/AiRefineCard.tsx

@@ -281,6 +281,7 @@ export default function AiRefineCard({ sessionId, onApplied }: { sessionId: numb
             预估 token：<strong>{est.estTokens}</strong> · 预估费用：<strong>¥{est.estCostYuan.toFixed(4)}</strong>
             {est.pricePer1m > 0 && <span style={{ color: "#6b7280" }}>（单价 ¥{est.pricePer1m}/1M token）</span>}
             {est.pricePer1m === 0 && <span style={{ color: "#0d9488" }}>（当前模型免费档 ¥0）</span>}
+            {est.pricePer1m === 0 && est.priceKnown === false && <span style={{ color: "#d97706" }}>（该模型单价未登记，费用可能不准确）</span>}
           </div>
           {balance && (
             <div style={{ color: balance.lowBalanceWarning ? "#dc2626" : "#374151" }}>

app/src/components/EnrichPanel.tsx

@@ -312,6 +312,7 @@ export default function EnrichPanel({ noteId, onUpdated }: { noteId: number; onU
           <div>
             预估 token：<strong>{est.estTokens}</strong> · 预估费用：<strong>¥{est.estCostYuan.toFixed(4)}</strong>
             {est.estCostYuan === 0 && <span style={{ color: "#0d9488" }}>（当前模型免费档 ¥0）</span>}
+            {est.estCostYuan === 0 && est.priceKnown === false && <span style={{ color: "#d97706" }}>（该模型单价未登记，费用可能不准确）</span>}
           </div>
           {balance && (
             <div style={{ color: balance.lowBalanceWarning ? "#dc2626" : "#374151" }}>

app/src/types.ts

@@ -718,11 +718,13 @@ export interface AiRefineResult {
   model: string;
 }
 
-/** 成本预估（Rust CostEstimate；camelCase 契约） */
+/** 成本预估（Rust CostEstimate；camelCase 契约；priceKnown=false → 单价未登记警告） */
 export interface CostEstimate {
   estTokens: number;
   estCostYuan: number;
   pricePer1m: number;
+  /** 该模型单价是否已登记（false → 显示"费用可能不准确"警告） */
+  priceKnown: boolean;
 }
 
 /** 精修成本预估视图（Rust RefineEstimateView；camelCase 契约） */