function agent_w_detour(task, max_detours=5):
    memory = initialize_memory()
    plan = planner.plan(task)  # 初始计划：步骤列表
    for detour_count in range(max_detours+1):
        for step in plan:
            try:
                result = executor.execute(step)
                memory.record_success(step, result)
            catch Failure:
                memory.record_failure(step, error_info)
                # 进入 detour 模式
                new_plan = detour_planner.replan(
                    original_task=task,
                    done_steps=memory.completed_steps,
                    failed_step=step,
                    failure_reason=error_info,
                    context=memory.dump()
                )
                # 如果 new_plan 为空，表示无法恢复
                if new_plan is None:
                    return Failure(step)
                plan = new_plan  # 用新计划替换剩余旧计划
                break  # 跳出当前循环，从新计划的第一步重新执行
        else:
            # 所有步骤执行成功
            return Success(memory.final_result)
    return Failure("超过最大 detour 次数")

import json

class AgentWithDetour:
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = tools
        self.memory = []  # list of {step_index, tool, input, output, status}

    def run(self, task, max_detours=3):
        self.memory = []
        plan = self._plan(task, [])  # 初始规划
        detour_used = 0

        while plan and detour_used <= max_detours:
            plan, detour_used = self._execute_plan(plan, detour_used)
            if plan is None:
                return {"status": "failed", "message": "plan is None from planner"}
            # 如果 plan 为空但失败，说明所有步骤成功
            if not plan:
                return {"status": "success", "result": self.memory[-1]["output"]}
            # plan 非空表示有步骤未完成，继续循环
        return {"status": "failed", "message": "exceeded max detours"}

    def _execute_plan(self, plan, detour_count):
        for idx, step in enumerate(plan):
            tool_name = step["tool"]
            tool_input = step["input"]
            try:
                tool_fn = self.tools[tool_name]
                result = tool_fn(tool_input)
                self.memory.append({
                    "step": step,
                    "status": "success",
                    "output": result
                })
            except Exception as e:
                error_info = str(e)
                self.memory.append({
                    "step": step,
                    "status": "failed",
                    "error": error_info
                })
                # 进入 detour
                detour_count += 1
                if detour_count > max_detours:
                    return None, detour_count
                # 用记忆管理器构造上下文
                context = self._build_context()
                new_plan = self._replan(task, step, error_info, context)
                # 返回新计划，并跳出循环
                return new_plan, detour_count
        # 所有步骤完成
        return None, detour_count

    def _replan(self, task, failed_step, error_info, context):
        prompt = f"""
原始任务：{task}
你之前已经完成了以下步骤：{json.dumps(context['done_steps'], indent=2)}
但在执行步骤 {json.dumps(failed_step)} 时遇到了错误：{error_info}
请基于已有成果，生成从当前节点继续的后续计划，只输出一个 JSON 数组，每个元素包含 'tool' 和 'input'。不要修改已完成的部分。如果任务不可能，输出空数组。
"""
        response = self.llm.chat(prompt)  # 假设返回 JSON 字符串
        try:
            new_plan = json.loads(response)
            if isinstance(new_plan, list):
                return new_plan
        except:
            return None
        return None

tools = {
    "search": lambda q: "mock result",
    "calc": lambda expr: eval(expr)
}
agent = AgentWithDetour(openai_chat, tools)
result = agent.run("计算地球到月球的距离（公里）并搜索确认")