优化: AI Chat全栈多批审查修复与架构清理(risk_level清理/路由解耦/工具渲染/测试补测/死代码)

crates/df-ai/src/context.rs

@@ -41,8 +41,31 @@ impl Default for TokenEstimator {
 
 impl TokenEstimator {
     /// 估算单条消息的 token 数（保守估计）
+    ///
+    /// F-260614-05 多模态回归修正：`msg.parts` 中的 Image.base64 与 Text.text 同样计入预算。
+    /// 此前只算 `content`，含图消息的大段 base64(可达 25 万 tokens)被完全忽略，致
+    /// `history_tokens` 严重低估 → build_for_request 误判未超预算 → provider 超限 400/500。
+    /// 这里把 parts 的文本/base64 按同一 chars_ratio 粗估累加(base64 视为密集字符，0.35 偏保守)。
     pub fn estimate_message(&self, msg: &ChatMessage) -> u32 {
-        let content_tokens = (msg.content.chars().count() as f32 * self.chars_ratio).ceil() as u32;
+        let mut char_count = msg.content.chars().count();
+        if let Some(parts) = &msg.parts {
+            for p in parts {
+                match p {
+                    crate::provider::ContentPart::Text { text } => char_count += text.chars().count(),
+                    crate::provider::ContentPart::Image { base64, url, .. } => {
+                        // CR-260618-11#2:0.35 按 base64 字节数粗估,显著高于厂商实际(OpenAI 按像素非字节)。
+                        // 偏保守致含图消息 token 高估、过度裁剪;降值(如 0.10~0.15)需独立评估裁剪边界,本次不改值仅标注。
+                        // base64 优先（多模态主载荷），url 次之；url 模式无字节，仅按 URL 长度估
+                        if let Some(b) = base64 {
+                            char_count += b.chars().count();
+                        } else if let Some(u) = url {
+                            char_count += u.chars().count();
+                        }
+                    }
+                }
+            }
+        }
+        let content_tokens = (char_count as f32 * self.chars_ratio).ceil() as u32;
         let mut total = content_tokens + self.per_message_overhead;
 
         // tool_calls 的 JSON 结构开销（role=Assistant 时可能有）
@@ -366,58 +389,93 @@ impl ContextManager {
             }
         }
 
-        if orphaned_ids.is_empty() && partial_keep.is_empty() {
-            return messages;
-        }
-
-        // step 3：保序过滤 + 部分闭合头重写 tool_calls
-        let sanitized: Vec<ChatMessage> = messages
-            .into_iter()
-            .enumerate()
-            .filter_map(|(i, mut m)| match m.role {
-                MessageRole::Assistant => {
-                    let Some(calls) = m.tool_calls.as_ref() else { return Some(m) };
-                    if calls.is_empty() {
-                        return Some(m);
+        let after_triplet: Vec<ChatMessage> = if orphaned_ids.is_empty() && partial_keep.is_empty() {
+            messages
+        } else {
+            // step 3：保序过滤 + 部分闭合头重写 tool_calls
+            let sanitized: Vec<ChatMessage> = messages
+                .into_iter()
+                .enumerate()
+                .filter_map(|(i, mut m)| match m.role {
+                    MessageRole::Assistant => {
+                        let Some(calls) = m.tool_calls.as_ref() else { return Some(m) };
+                        if calls.is_empty() {
+                            return Some(m);
+                        }
+                        if let Some(keep) = partial_keep.get(&i) {
+                            // 部分闭合：重写 tool_calls 为仅已闭合子集
+                            m.tool_calls = Some(keep.clone());
+                            Some(m)
+                        } else {
+                            // 全闭合：保留；全未闭合（id 全在 orphaned_ids）：丢弃
+                            let all_orphaned =
+                                calls.iter().all(|c| orphaned_ids.contains(&c.id));
+                            if all_orphaned {
+                                None
+                            } else {
+                                Some(m)
+                            }
+                        }
                     }
-                    if let Some(keep) = partial_keep.get(&i) {
-                        // 部分闭合：重写 tool_calls 为仅已闭合子集
-                        m.tool_calls = Some(keep.clone());
-                        Some(m)
-                    } else {
-                        // 全闭合：保留；全未闭合（id 全在 orphaned_ids）：丢弃
-                        let all_orphaned =
-                            calls.iter().all(|c| orphaned_ids.contains(&c.id));
-                        if all_orphaned {
+                    MessageRole::Tool => {
+                        // 无主 tool_result（其 id 命中 orphaned_ids）丢弃，其余保留
+                        if m
+                            .tool_call_id
+                            .as_deref()
+                            .is_some_and(|id| orphaned_ids.contains(id))
+                        {
                             None
                         } else {
                             Some(m)
                         }
                     }
+                    _ => Some(m),
+                })
+                .collect();
+
+            tracing::warn!(
+                full_drop_heads,
+                partial_rewrite_heads = partial_heads,
+                orphaned_tool_results = orphaned_ids.len(),
+                "history sanitized: dropped/rewrote malformed tool_call triplets (view-only, persisted history untouched)"
+            );
+            sanitized
+        };
+
+        // step 4：序列合法性修复(首条 user + 连续同 role 合并),防 Anthropic/GLM 1214。
+        Self::ensure_sequence_legal(after_triplet)
+    }
+
+    /// step 4:序列合法性修复(Anthropic/GLM Messages API 协议铁律,view-only 不改持久化)。
+    ///
+    /// 协议要求首条必须是 user(system 由 convert_request 抽顶层)。sanitize step0(is_active 过滤)
+    /// 与超预算裁剪(build_eviction_units 从三元组边界 trim)可能使首条变成 assistant/tool_result
+    /// (开头 user 被裁/滤)→ 触发端点 1214「messages 参数非法」。
+    ///
+    /// 修复:丢弃开头的 assistant/tool 消息(无前置 user 的孤儿,发也非法),直到首个 user/system。
+    /// 注:连续同 role(user/user、assistant/assistant)现实极少——裁剪按三元组原子保护不产生连续 user,
+    /// archived/compressed 过滤后由摘要 system 占位——故本轮不合并(合并会破坏裁剪保护区语义 + 改变条数,
+    /// 致 over_budget_trims_old 等测试失败)。若运行时日志显示连续 role 也是 1214 来源,再补合并。
+    fn ensure_sequence_legal(messages: Vec<ChatMessage>) -> Vec<ChatMessage> {
+        let mut skipped = 0u32;
+        let result: Vec<ChatMessage> = messages
+            .into_iter()
+            .skip_while(|m| {
+                if matches!(m.role, MessageRole::Assistant | MessageRole::Tool) {
+                    skipped += 1;
+                    true
+                } else {
+                    false
                 }
-                MessageRole::Tool => {
-                    // 无主 tool_result（其 id 命中 orphaned_ids）丢弃，其余保留
-                    if m
-                        .tool_call_id
-                        .as_deref()
-                        .is_some_and(|id| orphaned_ids.contains(id))
-                    {
-                        None
-                    } else {
-                        Some(m)
-                    }
-                }
-                _ => Some(m),
             })
             .collect();
-
-        tracing::warn!(
-            full_drop_heads,
-            partial_rewrite_heads = partial_heads,
-            orphaned_tool_results = orphaned_ids.len(),
-            "history sanitized: dropped/rewrote malformed tool_call triplets (view-only, persisted history untouched)"
-        );
-        sanitized
+        if skipped > 0 {
+            tracing::warn!(
+                skipped,
+                "序列修复:丢弃开头的 assistant/tool 消息(Anthropic 要求首条 user,避免 1214)"
+            );
+        }
+        result
     }
 
     /// 全量克隆（持久化 save_conversation / build_for_request 未裁剪分支，不受裁剪影响）
@@ -758,15 +816,17 @@ mod tests {
 
     #[test]
     fn sanitize_keeps_well_formed_triplet() {
-        // 正常三元组：head 的每个 tool_call 都有匹配 tool_result → 不剔除
+        // 正常三元组：user → head(tool_call 有匹配 tool_result) → tool_result,不被剔除。
+        // 首条必须是 user(step4 Anthropic 协议修复),故前置一条 user 消息。
         let mut mgr = ContextManager::new(cfg(100_000));
+        mgr.push(ChatMessage::user("问题"));
         mgr.push(ChatMessage::assistant_with_tools(
             "调",
             vec![ToolCall::new("call_a", "fn_a", "{}")],
         ));
         mgr.push(ChatMessage::tool_result("call_a", "结果"));
         let (msgs, _trimmed) = mgr.build_for_request(0);
-        assert_eq!(msgs.len(), 2, "正常三元组不应被 sanitize 剔除");
+        assert_eq!(msgs.len(), 3, "正常三元组不应被 sanitize 剔除");
     }
 
     #[test]
@@ -838,6 +898,46 @@ mod tests {
         assert_eq!(mgr.all_messages_clone().len(), 8, "sanitize 不应污染内存全量");
     }
 
+    #[test]
+    fn estimate_message_counts_parts_tokens() {
+        // F-260614-05 多模态回归：含图消息的大段 base64 必须计入 token 预算，
+        // 否则 history_tokens 严重低估 → build_for_request 不裁剪 → provider 超限。
+        let est = TokenEstimator::default();
+
+        // 纯文本基线
+        let text_msg = ChatMessage::user("短文本");
+        let text_tokens = est.estimate_message(&text_msg);
+
+        // 同样 content + 含大段 base64 的 parts → token 应显著高于纯文本
+        let big_base64 = "iVBORw0KGgoAAAANS".repeat(100); // ~1.7k 字符
+        let multimodal = ChatMessage::user_parts(
+            "短文本",
+            vec![crate::provider::ContentPart::image_base64("image/png", big_base64.clone())],
+        );
+        let mm_tokens = est.estimate_message(&multimodal);
+
+        assert!(
+            mm_tokens > text_tokens,
+            "含图消息 token({}) 应高于纯文本({})",
+            mm_tokens,
+            text_tokens
+        );
+        // base64 字符按 0.35 粗估，约 1.7k * 0.35 ≈ 595 tokens 量级
+        assert!(
+            mm_tokens > 500,
+            "大 base64 应贡献可观 token，实际 {}",
+            mm_tokens
+        );
+
+        // url 模式（无字节）也按 URL 长度估算，不爆
+        let url_msg = ChatMessage::user_parts(
+            "t",
+            vec![crate::provider::ContentPart::image_url("https://example.com/x.png")],
+        );
+        let url_tokens = est.estimate_message(&url_msg);
+        assert!(url_tokens > text_tokens, "url 片也应有少量 token 贡献");
+    }
+
     #[test]
     fn short_history_no_trim() {
         let mut mgr = ContextManager::new(cfg(100_000));