feat(ai): 内嵌 AI 对话——纯聊天（流式/停止/重发）+ 精修轨迹对话视图（REQ-224~230，v0.16.0）

Author: Aparencia

app/src-tauri/src/ai_chat.rs

@@ -0,0 +1,154 @@
+//! AI 对话纯函数层（REQ-224/225/230，v0.16.0）。
+//!
+//! @ai-context: 本模块只含"无副作用"的原子逻辑（消息组装 / SSE 行解析 /
+//!              轨迹序列化 / 取消标志）——业务编排在 command 层，网络在
+//!              ai_chat_stream.rs，存储在 db_ai_chat.rs；纯函数 AAA 单测
+//!              （AGENTS.md §3.5 测试纪律）。
+//! @ai-context: 轨迹（AiTurn）= 每次 LLM 调用的提示词与回答全文——"AI 任务
+//!              对话视图"数据源（REQ-230 用户裁决：能看提示词和回答）。
+//!              vision 调用只记图数占位（base64 不入库：图在本机会话图库，
+//!              入库会使体积翻数倍且冗余同图）。
+
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use serde::{Deserialize, Serialize};
+
+/// 聊天消息角色（OpenAI 兼容白名单——防任意 role 注入，防御性编程）。
+#[derive(Debug, Clone, PartialEq)]
+pub enum ChatRole {
+    /// 保留（system 由 build_messages 单独注入——角色不落库不旁路）
+    #[allow(dead_code)]
+    System,
+    User,
+    Assistant,
+}
+
+impl ChatRole {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            ChatRole::System => "system",
+            ChatRole::User => "user",
+            ChatRole::Assistant => "assistant",
+        }
+    }
+}
+
+/// 历史消息输入（组装前的最小结构——不耦合 DB 行，纯函数可单测）。
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChatMessageInput {
+    pub role: ChatRole,
+    pub content: String,
+}
+
+impl ChatMessageInput {
+    /// 便捷构造（测试/未来上下文注入层使用）
+    #[allow(dead_code)]
+    pub fn user(content: impl Into<String>) -> Self {
+        Self { role: ChatRole::User, content: content.into() }
+    }
+}
+
+/// 组装 OpenAI messages 数组（system 置顶；history 仅 user/assistant）。
+///
+/// @ai-context: 多轮对话历史一律截断到最近 MAX_HISTORY 条（防长会话 token
+///              失控；超出后第一条 user 摘要占比仍递减——MVP 不做摘要压缩，
+///              与 v0.8 精修"切片 + 片间摘要"策略同思路，后续再议）。
+pub const MAX_HISTORY: usize = 30;
+
+pub fn build_messages(system: &str, history: &[ChatMessageInput]) -> Vec<serde_json::Value> {
+    let mut out = Vec::with_capacity(history.len() + 1);
+    if !system.trim().is_empty() {
+        out.push(serde_json::json!({ "role": "system", "content": system }));
+    }
+    let tail_start = history.len().saturating_sub(MAX_HISTORY);
+    for m in &history[tail_start..] {
+        out.push(serde_json::json!({ "role": m.role.as_str(), "content": m.content }));
+    }
+    out
+}
+
+/// SSE 行解析结果。
+#[derive(Debug, Clone, PartialEq)]
+pub enum SseEvent {
+    /// 增量文本（choices[0].delta.content）
+    Delta(String),
+    /// 流结束标记 `data: [DONE]`
+    Done,
+    /// 非 data 行 / 空增量 / 畸形 JSON（跳过不失败——服务商行尾差异容错）
+    Ignore,
+}
+
+/// 解析一行 SSE（`data: {json}` 或 `data: [DONE]`）。
+///
+/// @ai-context: 流式响应各服务商末 chunk 的 usage/finish_reason 字段不一致
+///              （OpenAI 单独 usage chunk / DeepSeek 附在末 chunk / 无），
+///              本解析只取 delta.content；用量另由非流式兜底与账单口径处理。
+pub fn parse_sse_line(line: &str) -> SseEvent {
+    let line = line.trim();
+    if line.is_empty() {
+        return SseEvent::Ignore;
+    }
+    let Some(payload) = line.strip_prefix("data:") else {
+        return SseEvent::Ignore;
+    };
+    let payload = payload.trim();
+    if payload == "[DONE]" {
+        return SseEvent::Done;
+    }
+    let Ok(v) = serde_json::from_str::<serde_json::Value>(payload) else {
+        return SseEvent::Ignore;
+    };
+    let delta = v["choices"][0]["delta"]["content"].as_str().unwrap_or("");
+    if delta.is_empty() {
+        SseEvent::Ignore
+    } else {
+        SseEvent::Delta(delta.to_string())
+    }
+}
+
+/// 一次 LLM 调用的完整轨迹（提示词 + 回答全文）。
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiTurn {
+    /// 片序（1 起；失败片无轨迹——任务卡已显失败片数）
+    pub turn: usize,
+    /// 组装后的 system 提示词（模板构建结果，非模板原文）
+    pub system: String,
+    /// user 请求文本（精修=AiRefineRequest JSON；vision 附图数占位）
+    pub user: String,
+    /// 模型回答（结构化响应 JSON；原始返回即 JSON）
+    pub response: String,
+}
+
+/// 轨迹 → JSON（落库 trajectory_json 列；失败返回 None 由调用方降级不写）。
+pub fn trajectory_to_json(turns: &[AiTurn]) -> Option<String> {
+    serde_json::to_string(turns).ok()
+}
+
+/// JSON → 轨迹（旧任务/损坏数据 → None，视图诚实提示"无轨迹存档"）。
+pub fn trajectory_from_json(s: &str) -> Option<Vec<AiTurn>> {
+    serde_json::from_str(s).ok()
+}
+
+/// 流取消标志（Arc 共享；chat_cancel 置位 → 流循环每 chunk 检查）。
+#[derive(Debug, Default, Clone)]
+pub struct CancelFlag(Arc<AtomicBool>);
+
+impl CancelFlag {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn cancel(&self) {
+        self.0.store(true, Ordering::Relaxed);
+    }
+
+    pub fn is_cancelled(&self) -> bool {
+        self.0.load(Ordering::Relaxed)
+    }
+}
+
+#[cfg(test)]
+#[path = "ai_chat_tests.rs"]
+mod tests;

app/src-tauri/src/ai_chat_stream.rs

@@ -0,0 +1,170 @@
+//! AI 对话流式发送（REQ-225，v0.16.0）。
+//!
+//! @ai-context: 纯聊天走 `stream: true` SSE——逐 delta 经 Tauri Channel 推给
+//!              前端（打字效果 + 可停止）。与 ai_client.rs 的阻塞式
+//!              post_completions（精修/补充用）分居：流式**不自动重试**
+//!              （重试=重复生成，聊天天然由用户"重发"触发；精修幂等才重试）。
+//! @ai-context: usage 口径各家不一（末 chunk 附带 / 独立 chunk / 无）——本层
+//!              只"看见则存"（最后一个带 usage 的 data 行），看不见则为 None
+//!              （前端仅显示 token（如获知）与估算成本，不阻塞会话）。
+
+use std::io::{BufRead, BufReader};
+
+use serde::Serialize;
+
+use crate::ai_chat::{CancelFlag, SseEvent, parse_sse_line};
+use crate::ai_client::{AiClient, AiClientError, chat_completions_url};
+
+/// 流式事件（Tauri Channel 载荷契约——kind 标签，前端按 kind 分发）。
+#[derive(Debug, Clone, PartialEq, Serialize)]
+#[serde(tag = "kind", rename_all = "snake_case", rename_all_fields = "camelCase")]
+pub enum ChatStreamEvent {
+    /// 增量文本（流式打字）
+    Chunk { delta: String },
+    /// 流正常结束（附用量 JSON 原样——含 token/成本口径的原始数据）
+    Done { content: String, usage_json: Option<String> },
+    /// 失败（AiClientError 六类归一；前端映射 + 重试按钮）
+    Failed { error_kind: String, message: String },
+    /// 用户取消（content=已生成文本；消息落库标 aborted）
+    Aborted { content: String },
+}
+
+impl From<&AiClientError> for ChatStreamEvent {
+    fn from(e: &AiClientError) -> Self {
+        ChatStreamEvent::Failed { error_kind: e.kind().to_string(), message: e.to_string() }
+    }
+}
+
+impl AiClientError {
+    /// 错误类别标签（前端映射 + 任务失败四类契约复用）。
+    pub fn kind(&self) -> &'static str {
+        match self {
+            AiClientError::Auth(_) => "auth",
+            AiClientError::Network(_) => "network",
+            AiClientError::Balance(_) => "balance",
+            AiClientError::Quota(_) => "quota",
+            AiClientError::Server(_) => "server",
+            AiClientError::Parse(_) => "parse",
+        }
+    }
+}
+
+/// 流式结果（content/usage/是否取消——command 层落库口径）。
+#[derive(Debug)]
+pub struct StreamOutcome {
+    pub content: String,
+    pub usage_json: Option<String>,
+    pub cancelled: bool,
+}
+
+/// 发送流式 chat/completions（SSE），逐 delta 回调 emit。
+///
+/// @ai-context: 取消语义：每读一行检查 CancelFlag（Arc 共享——chat_cancel
+///              命令置位）；响应头未到时的取消由 HTTP 超时兜底（不做
+///              abort transport——ureq 无取消句柄，超时后命令层重试/重发）。
+///              emit 为 FnMut 无返回：Channel 发送失败（前端已关）由
+///              command 层静默降级（不阻断落库，数据不丢）。
+pub fn stream_chat(
+    client: &AiClient,
+    messages: &[serde_json::Value],
+    cancel: &CancelFlag,
+    mut emit: impl FnMut(ChatStreamEvent),
+) -> Result<StreamOutcome, AiClientError> {
+    if !client.config.is_local && client.config.api_key.trim().is_empty() {
+        return Err(AiClientError::Auth(
+            "未配置 API 密钥（设置页保存或配置环境变量）".to_string(),
+        ));
+    }
+    let mut payload = serde_json::json!({
+        "model": client.config.model,
+        "messages": messages,
+        "temperature": 0.7,
+        "max_tokens": client.config.max_tokens,
+        "stream": true,
+    });
+    // R1 系推理模型：关闭思考标签（与 build_chat_payload 同款约束——保持
+    // 输出稳定；DeepSeek-R1 在线端点会输出 reasoning_content 占 delta）
+    if client.config.model.to_lowercase().contains("r1") {
+        payload["no_think"] = serde_json::json!(true);
+    }
+    let url = chat_completions_url(&client.config.base_url);
+    let agent = ureq::AgentBuilder::new()
+        .timeout(std::time::Duration::from_secs(client.config.timeout_secs.max(5)))
+        .build();
+    let resp = agent
+        .post(&url)
+        .set("Content-Type", "application/json")
+        .set("Authorization", &format!("Bearer {}", client.config.api_key.trim()))
+        .send_string(&payload.to_string())
+        .map_err(map_status)?;
+    let reader = BufReader::new(resp.into_reader());
+    let mut content = String::new();
+    let mut usage_json: Option<String> = None;
+    let mut cancelled = false;
+    for line in reader.lines() {
+        if cancel.is_cancelled() {
+            cancelled = true;
+            break;
+        }
+        let line = match line {
+            Ok(l) => l,
+            Err(_) => break, // 传输中途断流：以已累积内容为准（无 usage）
+        };
+        match parse_sse_line(&line) {
+            SseEvent::Delta(d) => {
+                content.push_str(&d);
+                emit(ChatStreamEvent::Chunk { delta: d });
+            }
+            SseEvent::Done => break,
+            SseEvent::Ignore => {
+                // usage 可能挂在非 delta 的 data 行（OpenAI 兼容末 chunk）
+                if let Some(usage) = extract_usage(&line) {
+                    usage_json = Some(usage);
+                }
+            }
+        }
+    }
+    Ok(StreamOutcome { content, usage_json, cancelled })
+}
+
+/// 从 data 行提取 usage（纯函数；无 usage → None）。
+pub fn extract_usage(line: &str) -> Option<String> {
+    let line = line.trim();
+    let payload = line.strip_prefix("data:")?.trim();
+    let v: serde_json::Value = serde_json::from_str(payload).ok()?;
+    let u = v.get("usage")?;
+    if u.is_null() {
+        None
+    } else {
+        serde_json::to_string(u).ok()
+    }
+}
+
+/// HTTP 状态 → AiClientError（与 post_completions 同归一口径——四下一致）。
+fn map_status(e: ureq::Error) -> AiClientError {
+    match e {
+        ureq::Error::Status(401, _) => AiClientError::Auth(
+            "API 密钥无效（HTTP 401）——请检查设置页密钥或环境变量".to_string(),
+        ),
+        ureq::Error::Status(403, _) => AiClientError::Auth(
+            "API 密钥无权限（HTTP 403）——账号未开通该模型或额度受限".to_string(),
+        ),
+        ureq::Error::Status(402, _) => {
+            AiClientError::Balance("账户余额不足（请充值或切换免费档模型）".to_string())
+        }
+        ureq::Error::Status(429, _) => {
+            AiClientError::Quota("请求过频或配额耗尽（HTTP 429）".to_string())
+        }
+        ureq::Error::Status(code, _) if code >= 500 => {
+            AiClientError::Server(format!("服务端错误 HTTP {}", code))
+        }
+        ureq::Error::Status(code, _) => {
+            AiClientError::Network(format!("请求被拒绝 HTTP {}（不重试）", code))
+        }
+        e => AiClientError::Network(format!("传输错误: {}", e)),
+    }
+}
+
+#[cfg(test)]
+#[path = "ai_chat_stream_tests.rs"]
+mod tests;