用户请求 → 规划模块生成步骤列表
           ↓
        执行循环（对每个步骤）:
           ↓
          调用工具（第1层：重试最多3次，指数退避）
          /         \
        成功       失败
        ↓           ↓
     输出结果     第2层：尝试替代工具？
                    /       \
                  成功      失败
                   ↓        ↓
                输出结果   第3层：尝试LLM修复返回数据？
                           /            \
                         成功           失败
                          ↓             ↓
                       输出结果       第4层：上报错误+暂停步骤
                                      ↓
                                   规划模块调整后续计划

import time
from typing import Any, Dict, List, Optional

class RobustExecutor:
    def __init__(self, tools: Dict[str, Any], max_retries=3, retry_delay=1.0):
        self.tools = tools
        self.max_retries = max_retries
        self.retry_delay = retry_delay
        self.memory = []  # 短期记忆：执行记录
        self.long_term_rules = []  # 长期记忆：失败模式规则

    def call_tool(self, tool_name: str, params: Dict[str, Any]) -> Any:
        # 第1层：重试
        for attempt in range(self.max_retries):
            try:
                tool = self.tools[tool_name]
                result = tool(**params)
                self.memory.append((tool_name, params, "success", result))
                return result
            except Exception as e:
                self.memory.append((tool_name, params, f"retry_{attempt+1}", str(e)))
                if attempt < self.max_retries - 1:
                    time.sleep(self.retry_delay * (2 ** attempt))
        # 第2层：降级
        fallback = self._find_fallback(tool_name)
        if fallback:
            return self.call_tool(fallback, params)
        # 第3层：修复（尝试用LLM纠正错误输出）
        repaired = self._try_fix_with_llm(tool_name, params)
        if repaired:
            return repaired
        # 第4层：上报
        error_info = {"tool": tool_name, "params": params, "memory": self.memory[-3:]}
        raise ExecutionError(error_info)

    def _find_fallback(self, tool_name: str) -> Optional[str]:
        # 简单映射：天气API失败 -> 用气象站静态数据
        fallbacks = {"weather_api": "weather_static"}
        return fallbacks.get(tool_name)

    def _try_fix_with_llm(self, tool_name: str, params: Dict[str, Any]) -> Optional[str]:
        # 假设工具返回了乱码，用LLM猜测正确结果（简单示例）
        prompt = f"工具{tool_name}调用失败，参数{params}。请推测可能的结果。"
        response = llm.generate(prompt)
        if response and "unknown" not in response.lower():
            return response
        return None

    def reflect_and_update_rules(self):
        # 任务结束后分析短期记忆，提取失败模式
        failures = [m for m in self.memory if m[2].startswith("retry") or m[2]=="failure"]
        # 简单规则：如果某工具连续3次失败，记录为低优先级
        # 实际应用可用更复杂聚类
        if len(failures) >= 3:
            rule = f"{failures[0][0]} 近期失败率高，优先使用备用工具"
            self.long_term_rules.append(rule)
            # 也可以将规则写入向量库

class ExecutionError(Exception):
    pass

tools = {
    "search_web": lambda q: f"模拟搜索结果：{q}",
    "weather_api": lambda loc: (_ for _ in ()).throw(Exception("API超时")),  # 故意失败
    "weather_static": lambda loc: "气温25°C"
}
executor = RobustExecutor(tools)
try:
    result = executor.call_tool("weather_api", {"loc": "Beijing"})
    print(result)
except ExecutionError as e:
    print("所有尝试失败，详细信息：", e.error_info)