flowchart TD
    A[用户输入] --> B[规划阶段]
    B --> C[前置条件校验]
    C -- 通过 --> D[工具调用]
    C -- 不通过 --> E[错误上报并进入人工审批]
    D --> F[结果验证]
    F -- 有效 --> G[更新记忆]
    F -- 无效/异常 --> H[重试策略]
    H -- 重试次数 < 阈值 --> D
    H -- 重试次数 >= 阈值 --> I[全局异常记录]
    I --> J[触发通知/人工介入]
    G --> K[继续下一步]
    K --> L[循环直到完成或终止]
    L -- 完成 --> M[结果输出+审计摘要]
    L -- 终止 --> N[部分结果+失败原因日志]

def semantic_check(tool_name: str, arguments: dict, context: str) -> bool:
    # 用轻量LLM或固定规则检查参数是否符合上下文
    if tool_name == "send_email":
        expected_recipients = extract_expected_recipients(context)
        if arguments["to"] not in expected_recipients:
            return False
    return True

RETRY_MAP = {
    "rate_limit": (3, 2.0),      # (最大重试次数, 退避秒数)
    "timeout": (2, 5.0),
    "server_error": (1, 0.0),
    "client_error_4xx": (0, 0.0)  # 不重试，直接上报
}

async def request_human_approval(step_info: dict) -> dict:
    # 将步骤信息推送到消息队列或WebSocket
    await notify_human({"task_id": step_info["task_id"], "question": step_info["question"]})
    # 阻塞等待回复（或超时超时默认拒绝）
    response = await wait_for_human(step_info["task_id"], timeout=120)
    return response

import json
import datetime

class AgentWithAudit:
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = {t.name: t for t in tools}
        self.audit_log = []

    async def execute(self, user_input: str):
        plan = await self.llm.plan(user_input)
        task_id = f"task_{datetime.datetime.utcnow().timestamp()}"
        for step in plan.steps:
            tool = self.tools.get(step.tool_name)
            if not tool:
                self._log_entry(task_id, step, "error", f"Tool {step.tool_name} not found")
                raise ValueError(f"Unknown tool: {step.tool_name}")

            # 前置校验
            if not await self._semantic_check(step.tool_name, step.args, plan.context):
                self._log_entry(task_id, step, "blocked", "Semantic check failed")
                # 进入人工审批
                approved = await self._request_human_approval(step)
                if not approved:
                    self._log_entry(task_id, step, "rejected", "Human rejected")
                    return

            # 执行并重试逻辑
            retries = 0
            max_retries = 2
            while retries <= max_retries:
                try:
                    result = await tool.call(**step.args, timeout=10)
                    # 结果验证
                    if not self._validate_result(tool, result):
                        raise ValueError("Result validation failed")
                    self._log_entry(task_id, step, "success", result)
                    break
                except Exception as e:
                    retries += 1
                    if retries > max_retries:
                        self._log_entry(task_id, step, "failed", str(e))
                        await self._notify_human(step, e)
                        break
                    else:
                        self._log_entry(task_id, step, "retry", f"Attempt {retries}: {e}")
                        await asyncio.sleep(2 ** retries)

        return self._build_report(task_id)

    def _log_entry(self, task_id, step, status, detail):
        self.audit_log.append({
            "task_id": task_id,
            "step_id": step.id,
            "tool": step.tool_name,
            "input": step.args,
            "status": status,
            "detail": str(detail)[:500],
            "timestamp": datetime.datetime.utcnow().isoformat()
        })