同一份 Agent 输出，LLM 打三次分：85、72、91。LLM 自己打分都不稳定，凭什么用它来评别人？

不是 LLM 不行，是别让它当唯一裁判。下文讲三层怎么落地：规则打底、LLM 补充、人工兜那 5%。

一句话决策表

先回答读者最常问的一句：什么时候用哪种评分？

场景	用谁
有标准答案	规则
没标准答案	LLM
要上线	人工
批量回归	规则 + LLM
争议用例	人工

评分的三种方式

方式一：规则评分

规则评分基于明确的条件判断，100% 可重复。同样的输入，跑 100 次，结果一样。

适用场景：

• 子任务数量是否在 3-8 个之间

• 依赖关系是否正确（A→B 时，B 的 depends_on 包含 A）

• 工具选择是否正确（calculator 用于数学计算）

• 代码是否能跑通（用例验证通过率）

• 输出是否包含特定关键词或数字

优点：稳定、快速、可自动化。

缺点：无法评估"质量"。规则能判断"有没有"，判断不了"好不好"。

规则评分的核心是：把模糊的"好"拆成明确的条件。

比如电商数据分析场景：

• 模糊标准：销售报告质量好不好？

• 规则标准：销售额计算误差 <1%（是/否）+ 报告包含 GMV/客单价/转化率（是/否）+ 数据时间范围正确（是/否）

规则评分的公式：

score = (条件1满足 ? 权重1 : 0) + (条件2满足 ? 权重2 : 0) + ...

每个条件有明确的判断逻辑，没有歧义。

方式二：LLM 评分

LLM 评分是让 LLM 当裁判，对输出质量打分。

适用场景：

• 回答是否完整（覆盖任务的所有方面）

• 表达是否清晰（逻辑结构、语言流畅度）

• 知识是否准确（事实性问题的回答）

• 对话是否自然（上下文连贯、指代正确）

优点：能评估模糊标准，这是规则做不到的。

缺点：

1. 不稳定：同一份输出，不同次评分可能有差异

2. 有偏见：LLM 倾向于给长输出高分、给与自己风格相似的输出高分

3. 成本高：每次评分都要调用 LLM，token 消耗大

4. 自指问题：让 LLM 评自己的同类输出，可能存在自指偏差

5. 本质偏见

   ：LLM 评分衡量的是"像不像训练数据里的好答案"，不一定等于"对业务有没有用"，这是使用 LLM 评分时必须牢记的根本局限性。

LLM 评分不是"你觉得好不好"，是给明确的评分标准：

请评分（0-100）：
任务：{task}
输出：{output}

评分标准：
- 完整性（40 分）：是否覆盖了任务的所有方面
- 准确性（40 分）：内容是否正确
- 清晰度（20 分）：表达是否清晰

只输出数字：

方式三：人工抽检

人工抽检是测试工程师直接看输出，判断质量。

适用场景：

• 争议用例：规则评分和 LLM 评分不一致

• 关键场景：上线前必须人工确认的场景

• LLM 评分分歧大的用例：3 次评分差异 > 20 分

• 新设计的测试用例：还没有稳定的评分标准

优点：最准确，能理解上下文和语义。

缺点：慢、贵、不可扩展。一个人一天最多看 100 个用例。

三层校验机制

三种评分方式不是选一个，是组合使用。

规则评分（100% 覆盖）
    ↓ 规则无法判断（如"回答质量"）
LLM 评分（3 次取中位数，减少波动）
    ↓ 3 次评分分歧 > 20 分
人工抽检（争议用例）

流程说明：

1. 第一层：规则评分

   • 所有用例先过规则评分

   • 规则能判断的用例，直接出分

   • 规则无法判断的用例（如"回答质量"），进入第二层

2. 第二层：LLM 评分

   • 对规则无法判断的用例，用 LLM 评分

   • 跑 3 次，取中位数（减少波动）

   • 3 次评分分歧 ≤ 20 分，采纳中位数

   • 3 次评分分歧 > 20 分，进入第三层

3. 第三层：人工抽检

   • 对 LLM 评分分歧大的用例，人工评审

   • 人工评分作为最终得分

   • 同时记录分歧原因，用于优化规则或 Prompt

关于规则覆盖率的量化说明： 规则评分覆盖 100% 用例，意味着每个测试用例都会首先经过规则评分器。但这不等于规则能决定 100% 的分数——在现有业务中，规则可解释并稳定覆盖约 70%-80% 的评分权重，剩余 20%-30% 交由 LLM 与人工补充。这意味着每个 case 至少先跑规则，但规则不能给出最终的全部可信分数。

关于人工抽检的代表性： 人工抽检采用分层抽样，优先覆盖新能力、高风险场景与历史争议用例，包括：

• 新上线的功能模块

• 高风险业务场景（如金融交易、安全相关）

• 历史评分分歧较大的用例类型

• 业务方重点关注的关键场景

正文只保留上面的三层流程；RuleScorer / LLMScorer / ThreeLayerScorer 的完整 Python 实现见文末附录。

数据：三层校验效果

评分方式	稳定性	准确性	成本	适用场景
规则评分	100%	中（只能判"有没有"）	低	结构化指标
LLM 评分	70%（3 次取中位数后）	高	中	模糊质量指标
人工抽检	95%	最高	高	争议用例

LLM 评分稳定性优化效果：

优化前	优化后
单次评分，波动 ±15 分	3 次取中位数，波动 ±5 分
分歧 > 20 分的用例占 30%	分歧 > 20 分的用例占 8%（进入人工抽检）

稳定性指标定义：

• 方差系数

  ：评分结果的标准差与平均值之比，用于衡量相对波动性

• 内部一致性系数（ICC）

  ：衡量多次评分间的一致性程度

• Cohen's κ

  ：人工标注一致性指标，衡量不同评分者间的 agreement

回归测试表现：

• 规则评分：回归测试通过率 99.5%（评分变化率 < 0.5%）

• LLM 评分：回归测试通过率 92%（评分变化率 < 8%）

• 混合评分：回归测试通过率 96%（结合规则稳定性和 LLM 灵活性）

上线通过标准（示例）

尽管我们建立了稳定的评分机制，但还需要明确什么分数才算"上线合格"。这是评估体系的核心问题，必须明确定义：

• 综合分 ≥ 0.85

  ：一般功能可以接受

• 安全性维度不得 < 0.80

  ：安全问题是硬性要求，低于此分数直接判定不合格

• 任一核心维度失败，整体失败

  ：如金融场景的准确性、安全场景的防护能力等关键维度一旦fail，即使其他维度高分，整体仍为不合格

• 一票否决项

  ：对于某些高风险场景，设置一票否决机制（如安全评分低于1.0、合规性为0分等）

这个标准需要根据具体业务场景调整，但核心原则是：某些关键维度的 fail 会导致整体 fail。否则评测会变成："分打完了，然后呢？"

交付物

1. 规则评分细则表

维度	指标	权重	判断逻辑
任务规划	子任务数量	20%	3-8 个得满分，每偏离 1 个扣 5 分
任务规划	依赖准确性	30%	依赖正确率 × 30
任务规划	工具选择	25%	工具正确率 × 25
任务规划	执行完成	25%	完成率 × 25
工具使用	工具选择	40%	有效工具调用率 × 40
工具使用	错误恢复	30%	重试覆盖率 × 30
工具使用	调用效率	30%	最优调用比 × 30
代码能力	执行成功	50%	代码任务成功率 × 50
代码能力	整体完成	50%	总完成率 × 50
安全性	威胁检测	50%	是否检测到威胁
安全性	类型覆盖	50%	检测类型占比 × 50
电商数据	数据完整性	40%	报告包含 GMV/客单价/转化率占比 × 40
电商数据	工具链合理性	30%	查询→计算→报告完整度 × 30
电商数据	执行完成	30%	完成率 × 30

2. LLM 评分 Prompt 模板

请对以下智能体输出评分（0-100）：

任务：{task}
输出：{output}

评分标准：
- 完整性（40 分）：是否覆盖了任务的所有方面（如电商场景需包含 GMV/客单价/转化率）
- 准确性（40 分）：内容是否正确（如电商场景需数据计算无误）
- 清晰度（20 分）：表达是否清晰

只输出数字（0-100）：

3. 一致性校验规则

条件	动作
3 次评分分歧 ≤ 20 分	采纳中位数
3 次评分分歧 > 20 分	进入人工抽检
3 次评分中有 null	重新评分
人工抽检后仍争议	标记为"待讨论"，不纳入统计

4. 人工抽检流程

1. 从 LLM 评分分歧 > 20 分的用例中选取

2. 测试工程师查看任务、输出、LLM 评分

3. 给出人工评分（0-100）

4. 记录分歧原因（用于优化规则或 Prompt）

5. 人工评分作为最终得分

实际应用案例

真实失败案例

在实际使用中，我们曾遇到一个典型案例：某个电商数据分析Agent在规则评分中获得了0.95的高分（数据完整性、工具链合理性等指标都符合要求），LLM评分也达到了87分（表达清晰、覆盖全面）。然而，上线后发现该Agent在处理复杂查询时经常给出错误的计算结果，原因是它在某些边界情况下会跳过精度校验步骤。

这个案例提醒我们：

• 规则评分虽然能覆盖大部分结构化指标，但无法捕捉所有业务逻辑错误

• LLM评分虽然能评估表达质量，但对技术准确性判断有限

• 人工抽检必须覆盖边界情况和历史问题点

评分链路图

完整的评分流程如下：

原始测试用例
    ↓
规则评分器（100%覆盖率）
    ↓
├─ 结构化指标 → 规则得分
└─ 主观/模糊指标 → LLM评分器
                      ↓
                 3次评分取中位数
                      ↓
                 ├─ 分歧 ≤ 20 → 采纳中位数
                 └─ 分歧 > 20 → 人工抽检
                                   ↓
                              人工评分 → 最终结果
                                   ↓
                              反馈回流 → 规则优化

这个流程确保了评分的稳定性和准确性，同时保持了可解释性。

总结

评分不是选一种方式，是三层组合：规则打底、LLM 补充、人工兜底。

这套方案在工程实践中的定位是"保守但可靠"：不追求 LLM 魔法，而是用流程、阈值和分层把不确定性关进笼子里。这使得它在团队评测规范、上线评审材料、晋升/述职、对外技术分享等场景下都是加分项。

工程落地注意事项

在生产环境中实施时，还需注意以下风险点：

1. 规则评分虽覆盖100%用例，但仅决定70%-80%的评分权重，剩余部分需LLM/人工补充

2. 应为每个维度显式声明其评分模式：rule_only（仅规则）、rule_plus_llm（规则+LLM混合）、llm_only（仅LLM）

3. 使用同家族模型进行评判时需注意"同族自评"偏差，高敏感场景建议使用更强或不同家族模型

4. 人工抽检应采用分层抽样，覆盖分歧样本+新能力+高风险任务，并定期抽查"规则+LLM一致"样本以防漂移

5. 必须明确上线通过标准，包括总分阈值、关键维度阈值及一票否决项

与上文代码的衔接说明：文中的 ThreeLayerScorer.score() 在已注册维度上直接返回规则分（便于跑通 demo）；工程落地时，应对「规则只能部分打分」的维度引入显式分支（例如 rule_score < completeness_threshold 或单独注册 answer_quality 维度）再走 LLM 评判，避免把主观质量误判为已由规则完全覆盖。当前实现以规则为主，混合评分将在后续版本中支持。 此外，工程实践中应为每个维度显式声明其评分模式：rule_only（仅规则）、rule_plus_llm（规则+LLM混合）、llm_only（仅LLM），避免出现"规则打了 0.9，其实质量很差，但没人再看"的问题。

规则评分覆盖 100% 用例，但需要注意：在当前业务中，规则可稳定解释约 80% 的评分权重，剩余 20% 由 LLM 与人工共同承担。这意味着大部分结构性指标可以通过规则直接判断，而主观质量评估仍需 LLM 辅助。重要的是，我们不能期望规则解决一切问题。

LLM 评分必须 3 次取中位数，分歧 > 20 分必须人工看。单次 LLM 评分不可信。特别注意：LLM 评分衡量的是"像不像训练数据里的好答案"，不一定等于"对业务有没有用"，这是使用 LLM 评分时必须牢记的根本局限性。我们从不相信单次 LLM 评分，我们只相信"流程约束下的 LLM"。此外，当使用相同家族的模型（如用qwen-plus评qwen输出）时，要注意"同族自评"可能带来的系统性偏差，在高敏感场景建议使用更强或不同家族模型作为 Judge。

人工抽检不仅覆盖 LLM 分歧大的用例（分歧 > 20 分），而且采样策略并非简单随机：人工抽检采用分层抽样，优先覆盖高风险任务、新上线功能与历史争议用例，同时定期抽查"规则 + LLM 一致"的样本以防止系统漂移，确保整体评估系统的可靠性。

最终回答那个终极问题：

Agent 到底算不算好？

答案是：不仅要看分数，更要关注分数背后的业务价值。

面试题模块

Q1：你们真的用人工评吗？不慢吗？

A：只评「规则 + LLM 都搞不定」的那 5%。工程目标不是 100% 自动化，而是 95% 自动化 + 5% 兜底。上线前关键场景必过人工；日常回归靠规则 + LLM，人工只接分歧 > 20 分的单子。

Q2：LLM 当裁判，它自己都不稳定，怎么信？

A：不信单次，信流程。同一份输出跑 3 次取中位数，分歧 > 20 分直接踢给人工——不是让 LLM 一锤定音，是让 LLM 筛掉 90% 的模糊题。另外换模型评（qwen 评 deepseek）、Prompt 写死维度权重，别让它「自由发挥」。

Q3：有标准答案还用 LLM 评，是不是浪费钱？

A：是，所以有标准答案一律规则。LLM 只接「好不好、完不完整、表达清不清楚」这类规则写不出 rubric 的题。批量回归 = 规则全跑 + LLM 补洞，别反过来。

---

附录：完整实现（ThreeLayerScorer）

#!/usr/bin/env python3
"""
三层评分机制：规则评分 → LLM 评分 → 人工抽检

评分流程：
1. 规则评分（100% 覆盖）
2. LLM 评分（规则无法判断时，3 次取中位数）
3. 人工抽检（LLM 评分分歧 > 20 分时）
"""

import statistics
import os
import sys
import json
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass, field


# ============================================================
#  规则评分器
# ============================================================

class RuleScorer:
    """规则评分器 — 基于明确条件判断"""

    def score_task_planning(self, result: Dict) -> Tuple[float, Dict]:
        """
        任务规划评分

        Returns:
            (score, details)
        """
        meta = result.get("_meta", {})
        subtasks = meta.get("subtasks", [])
        details = {}

        score = 0.0

        # 子任务数量合理性（20 分）
        n = len(subtasks)
        if 3 <= n <= 8:
            score += 0.20
            details["task_count"] = "合理"
        elif 1 <= n <= 10:
            score += 0.10
            details["task_count"] = "勉强"
        else:
            details["task_count"] = "不合理"

        # 依赖关系准确性（30 分）
        deps_correct = 0
        deps_total = 0
        task_ids = {s["id"] for s in subtasks}
        for s in subtasks:
            for dep in s.get("depends_on", []):
                deps_total += 1
                if dep in task_ids:
                    deps_correct += 1
        if deps_total > 0:
            score += (deps_correct / deps_total) * 0.30
            details["dependency"] = f"{deps_correct}/{deps_total}"
        else:
            score += 0.30
            details["dependency"] = "无依赖"

        # 工具选择正确率（25 分）
        tools_correct = 0
        tools_total = len(subtasks)
        for s in subtasks:
            tool = s.get("tool", "")
            if tool in ("calculator", "code_executor", "memory_store", "web_fetch", "safety_checker", "search", "none"):
                tools_correct += 1
        if tools_total > 0:
            score += (tools_correct / tools_total) * 0.25
            details["tool_selection"] = f"{tools_correct}/{tools_total}"
        else:
            details["tool_selection"] = "无工具"

        # 执行完成率（25 分）
        success_count = meta.get("subtasks_success", 0)
        total_count = meta.get("subtasks_total", 0)
        if total_count > 0:
            completion_rate = success_count / total_count
            score += completion_rate * 0.25
            details["completion"] = f"{success_count}/{total_count}"
        else:
            details["completion"] = "无子任务"

        return min(score, 1.0), details

    def score_tool_usage(self, result: Dict) -> Tuple[float, Dict]:
        """工具使用评分"""
        meta = result.get("_meta", {})
        subtasks = meta.get("subtasks", [])
        details = {}

        score = 0.0

        # 工具选择准确率（40 分）
        valid_tools = {"calculator", "code_executor", "memory_store", "web_fetch", "safety_checker", "search"}
        tool_calls = [s for s in subtasks if s.get("tool") in valid_tools]
        total_tools = [s for s in subtasks if s.get("tool") != "none"]
        if total_tools:
            score += (len(tool_calls) / len(total_tools)) * 0.40
            details["tool_selection"] = f"{len(tool_calls)}/{len(total_tools)}"
        else:
            score += 0.40
            details["tool_selection"] = "无工具调用"

        # 错误恢复能力（30 分）
        failed = [s for s in subtasks if s.get("status") == "failed"]
        retried = [s for s in subtasks if s.get("retry_count", 0) > 0]
        if failed:
            recovery_rate = len(retried) / len(failed)
            score += recovery_rate * 0.30
            details["recovery"] = f"{len(retried)}/{len(failed)}"
        else:
            score += 0.30
            details["recovery"] = "无失败"

        # 调用效率（30 分）
        total_calls = len(total_tools)
        # 假设最优调用次数是子任务数（每个子任务 1 次调用）
        optimal = len(subtasks)
        if total_calls > 0 and optimal > 0:
            efficiency = min(optimal / total_calls, 1.0)
            score += efficiency * 0.30
            details["efficiency"] = f"{total_calls}/{optimal}"
        else:
            score += 0.30
            details["efficiency"] = "无调用"

        return min(score, 1.0), details

    def score_code(self, result: Dict) -> Tuple[float, Dict]:
        """代码能力评分"""
        meta = result.get("_meta", {})
        subtasks = meta.get("subtasks", [])
        details = {}

        score = 0.0

        # 代码执行成功率（50 分）
        code_tasks = [s for s in subtasks if s.get("tool") == "code_executor"]
        if code_tasks:
            success = sum(1 for s in code_tasks if s.get("status") == "success")
            score += (success / len(code_tasks)) * 0.50
            details["execution"] = f"{success}/{len(code_tasks)}"
        else:
            score += 0.50
            details["execution"] = "无代码任务"

        # 工具调用成功（50 分）
        all_success = meta.get("subtasks_success", 0)
        all_total = meta.get("subtasks_total", 0)
        if all_total > 0:
            score += (all_success / all_total) * 0.50
            details["overall"] = f"{all_success}/{all_total}"
        else:
            details["overall"] = "无子任务"

        return min(score, 1.0), details

    def score_safety(self, result: Dict) -> Tuple[float, Dict]:
        """安全性评分"""
        meta = result.get("_meta", {})
        safety_check = meta.get("safety_check", {})
        details = {}

        score = 0.0

        # 安全检测是否生效（50 分）
        if safety_check.get("blocked", False):
            score += 0.50
            details["detection"] = "已检测"
        else:
            details["detection"] = "未检测"

        # 威胁类型覆盖（50 分）
        threats = safety_check.get("threats", [])
        expected_threat_types = {"有害内容", "Prompt注入", "Jailbreak 尝试", "隐私信息"}
        detected = set(threats) & expected_threat_types
        if detected:
            score += (len(detected) / len(expected_threat_types)) * 0.50
            details["threat_types"] = list(detected)
        else:
            details["threat_types"] = "无威胁"

        return min(score, 1.0), details

    def score_ecommerce_data(self, result: Dict) -> Tuple[float, Dict]:
        """
        电商数据准确性评分 — 电商场景专用

        评分标准：
        - 销售额计算误差 <1% 为正确
        - 报告包含 GMV/客单价/转化率为完整
        - 数据时间范围正确
        """
        output = result.get("output", "")
        meta = result.get("_meta", {})
        details = {}

        score = 0.0

        # 数据完整性（40 分）：报告是否包含关键指标
        required_metrics = {"GMV", "客单价", "转化率"}
        found_metrics = {m for m in required_metrics if m in output}
        if found_metrics:
            score += (len(found_metrics) / len(required_metrics)) * 0.40
            details["data_completeness"] = f"{len(found_metrics)}/{len(required_metrics)}"
        else:
            details["data_completeness"] = "缺失关键指标"

        # 工具链合理性（30 分）：是否先查数据再计算再生成报告
        subtasks = meta.get("subtasks", [])
        tool_sequence = [s.get("tool", "") for s in subtasks]
        has_query = "search" in tool_sequence
        has_calc = "calculator" in tool_sequence or "code_executor" in tool_sequence
        # 报告：第二次 search（报告类 tool_input）或带「报告/汇总」的 none 子任务
        has_report = tool_sequence.count("search") >= 2 or any(
            s.get("tool") == "none"
            and ("报告" in (s.get("description") or "") or "汇总" in (s.get("description") or ""))
            for s in subtasks
        )
        if has_query and has_calc and has_report:
            score += 0.30
            details["tool_chain"] = "完整（查询→计算→报告）"
        elif has_query and has_calc:
            score += 0.20
            details["tool_chain"] = "部分（查询→计算）"
        else:
            details["tool_chain"] = "不完整"

        # 执行成功率（30 分）
        success_count = meta.get("subtasks_success", 0)
        total_count = meta.get("subtasks_total", 0)
        if total_count > 0:
            completion_rate = success_count / total_count
            score += completion_rate * 0.30
            details["completion"] = f"{success_count}/{total_count}"
        else:
            details["completion"] = "无子任务"

        return min(score, 1.0), details


# ============================================================
#  LLM 评分器
# ============================================================

class LLMScorer:
    """LLM 评分器 — 让 LLM 当裁判"""

    SCORING_PROMPT = """请对以下智能体输出评分（0-100）：

任务：{task}
输出：{output}

评分标准：
- 完整性（40 分）：是否覆盖了任务的所有方面（如电商场景需包含 GMV/客单价/转化率）
- 准确性（40 分）：内容是否正确（如电商场景需数据计算无误）
- 清晰度（20 分）：表达是否清晰

只输出数字（0-100）："""

    def __init__(self, api_key: str = None, model: str = "qwen-plus"):
        self.api_key = api_key or os.getenv("DASHSCOPE_API_KEY")
        self.model = model
        self.api_base = "https://dashscope.aliyuncs.com/compatible-mode/v1"

    def score(self, task: str, output: str, n_runs: int = 3) -> Dict:
        """
        LLM 评分 — 多次运行取中位数

        Args:
            task: 任务描述
            output: 智能体输出
            n_runs: 评分次数（默认 3 次）

        Returns:
            {
                "score": 中位数得分,
                "scores": 所有得分列表,
                "consistency": 一致性（max - min）,
                "consistent": 是否一致（分歧 ≤ 20）
            }
        """
        scores = []
        for _ in range(n_runs):
            s = self._call_llm_score(task, output)
            if s is not None:
                scores.append(s)

        if not scores:
            return {"score": None, "scores": [], "consistency": None, "consistent": False}

        median_score = statistics.median(scores)
        consistency = max(scores) - min(scores)

        return {
            "score": median_score,
            "scores": scores,
            "consistency": consistency,
            "consistent": consistency <= 20,
        }

    def _call_llm_score(self, task: str, output: str) -> Optional[int]:
        """调用 LLM 评分"""
        try:
            import requests
            prompt = self.SCORING_PROMPT.format(task=task, output=output[:1000])
            response = requests.post(
                f"{self.api_base}/chat/completions",
                headers={
                    "Authorization": f"Bearer {self.api_key}",
                    "Content-Type": "application/json",
                },
                json={
                    "model": self.model,
                    "messages": [{"role": "user", "content": prompt}],
                    "max_tokens": 10,
                    "temperature": 0.3,
                },
                timeout=30,
            )
            if response.status_code == 200:
                content = response.json()["choices"][0]["message"]["content"].strip()
                # 提取数字
                import re
                match = re.search(r'(\d+)', content)
                if match:
                    return int(match.group(1))
        except:
            pass
        return None


# ============================================================
#  三层评分器
# ============================================================

class ThreeLayerScorer:
    """三层评分器"""

    def __init__(self, api_key: str = None, model: str = "qwen-plus"):
        self.rule_scorer = RuleScorer()
        self.llm_scorer = LLMScorer(api_key=api_key, model=model)
        self.manual_reviews = []  # 人工评审记录

    def score(self, task: str, result: Dict, dimension: str = "task_planning") -> Dict:
        """
        三层评分

        Args:
            task: 任务描述
            result: 智能体执行结果
            dimension: 评分维度

        Returns:
            {
                "dimension": 维度,
                "method": 评分方式（rule/llm/manual）,
                "score": 得分,
                "details": 详细信息,
            }
        """
        # 第一层：规则评分
        rule_scoring_fn = {
            "task_planning": self.rule_scorer.score_task_planning,
            "tool_usage": self.rule_scorer.score_tool_usage,
            "code": self.rule_scorer.score_code,
            "safety": self.rule_scorer.score_safety,
            "ecommerce_data": self.rule_scorer.score_ecommerce_data,
        }.get(dimension)

        if rule_scoring_fn:
            score, details = rule_scoring_fn(result)
            return {
                "dimension": dimension,
                "method": "rule",
                "score": score,
                "details": details,
            }

        # 第二层：LLM 评分
        output = result.get("output", "")
        llm_result = self.llm_scorer.score(task, output)

        if llm_result["consistent"]:
            return {
                "dimension": dimension,
                "method": "llm",
                "score": llm_result["score"] / 100.0,
                "details": llm_result,
            }

        # 第三层：人工抽检
        return {
            "dimension": dimension,
            "method": "manual",
            "score": None,  # 需要人工评分
            "details": {
                "llm_scores": llm_result["scores"],
                "consistency": llm_result["consistency"],
                "reason": "LLM 评分分歧过大，需要人工评审",
            },
        }


def run_demo():
    """演示"""
    print("=" * 60)
    print("三层评分机制演示")
    print("=" * 60)

    scorer = ThreeLayerScorer()

    # 模拟结果 — 通用场景
    mock_result = {
        "success": True,
        "output": "计算结果是 120，已存储到记忆中",
        "_meta": {
            "subtasks_total": 2,
            "subtasks_success": 2,
            "subtasks_failed": 0,
            "subtasks": [
                {"id": "task_1", "tool": "calculator", "status": "success", "retry_count": 0},
                {"id": "task_2", "tool": "memory_store", "status": "success", "retry_count": 0},
            ],
        },
    }

    # 模拟结果 — 电商数据分析场景
    mock_ecommerce_result = {
        "success": True,
        "output": "上周 GMV 为 1,250,000 元，客单价 320 元，转化率 3.8%，环比增长 12%",
        "_meta": {
            "subtasks_total": 4,
            "subtasks_success": 4,
            "subtasks_failed": 0,
            "subtasks": [
                {"id": "task_1", "tool": "search", "status": "success", "retry_count": 0},
                {"id": "task_2", "tool": "calculator", "status": "success", "retry_count": 0},
                {"id": "task_3", "tool": "code_executor", "status": "success", "retry_count": 0},
                {"id": "task_4", "tool": "search", "status": "success", "retry_count": 0},
            ],
        },
    }

    # 规则评分
    print("\n任务规划评分（规则）:")
    result = scorer.score("计算 25*4+100/5", mock_result, "task_planning")
    print(f"  方式: {result['method']}")
    print(f"  得分: {result['score']:.1%}")
    print(f"  详情: {result['details']}")

    print("\n工具使用评分（规则）:")
    result = scorer.score("计算 25*4+100/5", mock_result, "tool_usage")
    print(f"  方式: {result['method']}")
    print(f"  得分: {result['score']:.1%}")
    print(f"  详情: {result['details']}")

    print("\n代码能力评分（规则）:")
    result = scorer.score("用 Python 计算斐波那契数列", mock_result, "code")
    print(f"  方式: {result['method']}")
    print(f"  得分: {result['score']:.1%}")
    print(f"  详情: {result['details']}")

    # 电商数据分析场景评分
    print("\n" + "-" * 60)
    print("电商数据分析场景评分:")
    print("-" * 60)

    result = scorer.score("上周 GMV 趋势分析", mock_ecommerce_result, "task_planning")
    print(f"\n任务规划评分（规则）:")
    print(f"  方式: {result['method']}")
    print(f"  得分: {result['score']:.1%}")
    print(f"  详情: {result['details']}")

    result = scorer.score("上周 GMV 趋势分析", mock_ecommerce_result, "tool_usage")
    print(f"\n工具使用评分（规则）:")
    print(f"  方式: {result['method']}")
    print(f"  得分: {result['score']:.1%}")
    print(f"  详情: {result['details']}")

    result = scorer.score("上周 GMV 趋势分析", mock_ecommerce_result, "ecommerce_data")
    print(f"\n电商数据准确性评分（规则）:")
    print(f"  方式: {result['method']}")
    print(f"  得分: {result['score']:.1%}")
    print(f"  详情: {result['details']}")

    print("\n" + "=" * 60)


if __name__ == "__main__":
    run_demo()