Plan-and-Execute，从边做边看到先计划再执行

观察到候选文档
  ↓
读取文档
  ↓
观察到 package script 线索
  ↓
继续读取 script
  ↓
回答用户

用户目标
  ↓
Planner 生成计划
  ↓
Executor 执行当前步骤
  ↓
得到 Observation
  ↓
Replanner 更新计划
  ↓
继续执行，直到可以回答

1. 先搜索和 Agent 执行模式相关的教程资料

content/tutorials/p1-02-minimal-loop.md
content/tutorials/p2-03-tool-calling.md
content/tutorials/p2-04-react.md
content/tutorials/p2-05-plan-and-execute.md

2. 读取最小 Agent Loop 章节
3. 读取 Tool Calling 章节
4. 读取 ReAct 章节
5. 读取 Plan-and-Execute 章节

type Plan = {
  goal: string;
  steps: PlanStep[];
  finalAnswer: string | null;
};
 
type PlanStep = {
  id: string;
  title: string;
  status: "pending" | "done" | "skipped";
  action: PlanAction;
  evidence: string[];
};

OPENAI_API_KEY=your_openai_api_key_here
OPENAI_MODEL=gpt-5-mini

pnpm example examples/05-plan-and-execute/plan-and-execute-agent.ts

调研这个教程项目里目前已经讲了哪些 Agent 执行模式，并整理它们分别适合什么场景。

const tutorialNotes = [
  {
    path: "content/tutorials/p1-02-minimal-loop.md",
    title: "从零写一个最小 Agent Loop",
    summary: "Agent 的核心是状态、模型、动作、观察和停止条件组成的循环。",
  },
  {
    path: "content/tutorials/p2-03-tool-calling.md",
    title: "Tool Calling，给 Agent 行动力",
    summary: "Tool Calling 把外部能力暴露成模型可请求的动作接口。",
  },
  {
    path: "content/tutorials/p2-04-react.md",
    title: "ReAct，让 Agent 学会边想边做",
    summary: "ReAct 让模型在每一轮根据新的 observation 决定下一步 action。",
  },
  {
    path: "content/tutorials/p2-05-plan-and-execute.md",
    title: "Plan-and-Execute，从边做边看到先计划再执行",
    summary: "Plan-and-Execute 先把长任务拆成计划，再逐步执行和重规划。",
  },
];

async function searchTutorials(input: Record<string, string>): Promise<ToolResult> {
  const query = String(input.query ?? "").trim().toLowerCase();
  const queryWords = query.split(/\s+/).filter(Boolean);
 
  const matches = tutorialNotes.filter((note) => {
    const haystack = [note.path, note.title, note.summary, note.content]
      .join(" ")
      .toLowerCase();
 
    return queryWords.some((word) => haystack.includes(word));
  });
 
  const results = matches.length > 0 ? matches : tutorialNotes;
 
  return {
    ok: true,
    summary: `找到 ${results.length} 篇可能相关的教程资料。`,
    content: results
      .map((note) => `${note.path}: ${note.title} - ${note.summary}`)
      .join("\n"),
  };
}

async function readTutorial(input: Record<string, string>): Promise<ToolResult> {
  const filePath = String(input.path ?? "").trim();
  const note = tutorialNotes.find((item) => item.path === filePath);
 
  if (!note) {
    return {
      ok: false,
      summary: `没有找到教程资料：${filePath}`,
      content: "请先搜索可用教程路径，再读取其中一个路径。",
    };
  }
 
  return {
    ok: true,
    summary: `已读取 ${note.path}。`,
    content: `${note.title}\n${note.content}`,
  };
}

async function createPlan(goal: string): Promise<Plan> {
  const plan = await requestJson<Plan>([
    {
      role: "system",
      content:
        "你是一个规划器。请把用户目标拆成可执行计划。只返回 JSON，不要返回 Markdown。计划必须先搜索资料，再根据搜索结果由 replanner 决定要读哪些资料。",
    },
    {
      role: "user",
      content: `用户目标：${goal}`,
    },
  ]);
 
  return normalizePlan(plan, goal);
}

async function executeNextStep(plan: Plan): Promise<Observation | null> {
  const step = plan.steps.find((item) => item.status === "pending");
 
  if (!step) {
    return null;
  }
 
  const result = await runAction(step.action);
 
  return {
    stepId: step.id,
    action: step.action.name,
    result,
  };
}

async function replan(plan: Plan, observation: Observation): Promise<Plan> {
  const updatedPlan = await requestJson<Plan>([
    {
      role: "system",
      content:
        "你是一个重规划器。你会收到当前计划和刚刚的 observation。请更新计划：把刚执行的 step 标记为 done 或 skipped，把 observation 中有用的信息写进 evidence；如果还需要资料，就追加新的 pending step；如果已经足够回答，就设置 finalAnswer。",
    },
    {
      role: "user",
      content: JSON.stringify({ plan, observation }, null, 2),
    },
  ]);
 
  return normalizePlan(updatedPlan, plan.goal);
}

async function runPlanAndExecuteAgent(goal: string) {
  let plan = await createPlan(goal);
 
  for (let turn = 1; turn <= maxSteps; turn += 1) {
    if (plan.finalAnswer) {
      return plan;
    }
 
    const observation = await executeNextStep(plan);
 
    if (!observation) {
      throw new Error("计划没有 pending step，也没有 finalAnswer。");
    }
 
    plan = await replan(plan, observation);
  }
 
  throw new Error(`Plan-and-Execute stopped after ${maxSteps} steps.`);
}

messages -> model -> tool call -> tool result -> messages

plan -> execute step -> observation -> updated plan

Goal:
调研这个教程项目里目前已经讲了哪些 Agent 执行模式，并整理它们分别适合什么场景。
 
Current Plan:
pending step-1: 搜索与 Agent 执行模式相关的教程资料
 
Execute: step-1
Action: searchTutorials
Action Input: {"query":"Agent 执行模式"}
 
Observation:
找到 4 篇可能相关的教程资料。
 
Current Plan:
done step-1: 搜索与 Agent 执行模式相关的教程资料
pending step-2: 读取最小 Agent Loop 章节
pending step-3: 读取 Tool Calling 章节
pending step-4: 读取 ReAct 章节
pending step-5: 读取 Plan-and-Execute 章节