# SimpleToolHalluBench 核心评估逻辑
# NTA场景：工具集为空，模型不应调用任何工具
# DT场景：只有干扰工具，模型应拒绝调用

def evaluate_tool_selection_hallucination(model_output, available_tools):
    called_tools = extract_tool_calls(model_output)
    hallucinated = []
    for tool in called_tools:
        if tool.name not in available_tools:
            hallucinated.append(tool)  # 调用了不存在的工具

    r_nta = len(hallucinated) / max(len(called_tools), 1)
    # 理想值: r_nta = 0.0 (无幻觉调用)
    # 实测前沿模型: r_nta ≈ 0.12-0.35
    return hallucination_rate

# 生产级参数验证管线（三层防御）
from jsonschema import validate, ValidationError
from typing import Any, Dict

class ToolCallValidator:
    def __init__(self, tool_registry):
        self.registry = tool_registry
        self.schema_cache = {}  # 缓存编译后的Schema

    def validate_call(self, tool_name: str, args: Dict[str, Any]) -> tuple:
        """三层参数验证：类型→约束→语义"""
        schema = self.registry.get_schema(tool_name)

        # 第一层：JSON Schema严格验证
        try:
            validate(instance=args, schema=schema)
        except ValidationError as e:
            return (False, f"Schema violation: {e.message}")

        # 第二层：业务约束验证
        # 枚举值是否合法、数值范围是否合理
        constraint_errors = self._check_constraints(args, schema)
        if constraint_errors:
            return (False, constraint_errors)

        # 第三层：语义一致性验证（轻量LLM校验）
        # "预订明天的会议" → 日期参数是否确实是未来日期
        semantic_result = self._semantic_check(tool_name, args)

        return (True, "valid") if not semantic_result else (False, semantic_result)

# 可解性检测器的训练数据构造
# 正例：有合适工具的任务 → 生成工具调用
# 反例：无合适工具的任务 → 输出 "UNSOLVABLE" + 原因

solvability_training_examples = [
    {
        "task": "查询北京明天的天气",
        "tools": ["weather_api", "calendar_api"],
        "expected": {"solvable": True, "plan": "call weather_api(city='Beijing', date=tomorrow)"},
    },
    {
        "task": "预订一张去火星的机票",
        "tools": ["flight_booking_api", "hotel_api"],
        "expected": {"solvable": False, "reason": "No tool available for interplanetary travel"},
    },
]

# TIM检测与量化
def measure_tool_induced_myopia(model, task, tools_available):
    """比较有工具和无工具条件下的推理深度"""

    # 无工具条件：模型必须纯推理
    result_no_tool = model.solve(task, tools=[])
    reasoning_depth_no_tool = analyze_reasoning_chain(result_no_tool)

    # 有工具条件：模型可选择使用工具
    result_with_tool = model.solve(task, tools=tools_available)
    reasoning_depth_with_tool = analyze_reasoning_chain(result_with_tool)

    # TIM指标：推理深度的相对缩减
    tim_score = 1 - (reasoning_depth_with_tool / reasoning_depth_no_tool)

    # tim_score > 0.3 表示显著的工具诱发近视
    # 实测：RL增强推理模型 tim_score ≈ 0.25-0.45
    return tim_score

# 工具绕行检测：轨迹审计框架
class ToolBypassDetector:
    def __init__(self, tool_registry, observability_tracer):
        self.registry = tool_registry
        self.tracer = observability_tracer

    def audit_trajectory(self, agent_trace):
        """审计完整Agent轨迹，检测工具绕行"""
        bypass_events = []

        for i, step in enumerate(agent_trace.steps):
            # 检查：模型声称有工具结果但无实际调用记录
            if step.claims_tool_result and not step.has_actual_invocation:
                bypass_events.append({
                    "step": i,
                    "type": "SIMULATED_RESULT",
                    "claimed_tool": step.claimed_tool_name,
                    "confidence": self._detect_confidence(step),
                })

            # 检查：工具结果与预期不符（可能被篡改）
            if step.has_actual_invocation:
                actual_result = self.tracer.get_actual_result(step.call_id)
                if not self._results_match(step.reported_result, actual_result):
                    bypass_events.append({
                        "step": i,
                        "type": "RESULT_TAMPERING",
                        "severity": "CRITICAL",
                    })

        return bypass_events

graph TB
    subgraph "七层工具调用可靠性栈"
        L1["第1层: Schema预验证<br/>JSON Schema strict模式<br/>捕获40%格式错误"]
        L2["第2层: 可解性门控<br/>任务是否可解判断<br/>拦截不可解任务"]
        L3["第3层: 约束解码<br/>推理时强制合法输出<br/>参数错误<1%"]
        L4["第4层: 调用证明<br/>可验证的调用元数据<br/>检测工具绕行"]
        L5["第5层: 超时预算与熔断<br/>每工具独立超时<br/>防止级联失败"]
        L6["第6层: 轨迹审计<br/>多步调用链完整性<br/>12-20%定位精度→>90%"]
        L7["第7层: 自验证采样<br/>N条轨迹一致性校验<br/>精度-成本权衡"]
    end

    L1 --> L2 --> L3 --> L4 --> L5 --> L6 --> L7

    style L1 fill:#e8f5e9
    style L2 fill:#fff3e0
    style L3 fill:#e3f2fd
    style L4 fill:#fce4ec
    style L5 fill:#f3e5f5
    style L6 fill:#e0f7fa
    style L7 fill:#fff8e1

# 工具结果压缩策略
def compress_tool_result(result, max_tokens=500):
    """智能压缩工具返回结果，降低14-70% Token"""
    compressed = {}
    for key, value in result.items():
        if isinstance(value, str) and len(value) > 200:
            # 截断长字符串，保留前后关键部分
            compressed[key] = value[:100] + "...[truncated]..." + value[-50:]
        elif isinstance(value, list) and len(value) > 5:
            # 列表只保留前3项 + 总数摘要
            compressed[key] = value[:3] + [f"... and {len(value)-3} more items"]
        elif isinstance(value, dict) and len(value) > 10:
            # 大字典只保留值最大的5个键
            top_keys = sorted(value, key=lambda k: len(str(value[k])), reverse=True)[:5]
            compressed[key] = {k: value[k] for k in top_keys}
        else:
            compressed[key] = value
    return compressed

graph LR
    subgraph "第1周 (低预算)"
        A1["Schema预验证"]
        A2["超时预算+熔断"]
        A3["结构化输出模式"]
    end

    subgraph "第2-3周 (中预算)"
        B1["约束解码集成"]
        B2["可解性门控"]
        B3["工具结果压缩"]
    end

    subgraph "第4-6周 (高预算)"
        C1["调用证明系统"]
        C2["轨迹审计框架"]
        C3["自验证采样管线"]
    end

    A1 --> B1 --> C1
    A2 --> B2 --> C2
    A3 --> B3 --> C3