Nanobrowser 源代码解析：多智能体采集循环——Executor 如何驱动 Planner + Navigator 爬取多页

export class Executor {
  private readonly navigator: NavigatorAgent;
  private readonly planner: PlannerAgent;
  private readonly context: AgentContext;
  private tasks: string[] = [];
 
  constructor(
    task: string, taskId: string,
    browserContext: BrowserContext,
    navigatorLLM: BaseChatModel,
    extraArgs?: Partial<ExecutorExtraArgs>,
  ) {
    const plannerLLM = extraArgs?.plannerLLM ?? navigatorLLM;
    const messageManager = new MessageManager();
    const context = new AgentContext(taskId, browserContext, messageManager, ...);
 
    this.navigatorPrompt = new NavigatorPrompt(context.options.maxActionsPerStep);
    this.plannerPrompt = new PlannerPrompt();
 
    const actionBuilder = new ActionBuilder(context, extractorLLM);
    const actionRegistry = new NavigatorActionRegistry(actionBuilder.buildDefaultActions());
 
    this.navigator = new NavigatorAgent(actionRegistry, { chatLLM: navigatorLLM, context, prompt: this.navigatorPrompt });
    this.planner = new PlannerAgent({ chatLLM: plannerLLM, context, prompt: this.plannerPrompt });
  }
}

async execute(): Promise<void> {
  const context = this.context;
  context.nSteps = 0;
  const allowedMaxSteps = this.context.options.maxSteps;
 
  let step = 0;
  let latestPlanOutput = null;
  let navigatorDone = false;
 
  for (step = 0; step < allowedMaxSteps; step++) {
    // 检查是否被暂停或取消
    if (await this.shouldStop()) break;
 
    // Planner 周期性执行
    if (this.planner
        && (step % context.options.planningInterval === 0 || navigatorDone)) {
      navigatorDone = false;
      latestPlanOutput = await this.runPlanner();
      if (this.checkTaskCompletion(latestPlanOutput)) break;
    }
 
    // Navigator 执行一步
    navigatorDone = await this.navigate();
  }
 
  // 完成状态判定
  if (latestPlanOutput?.result?.done) {
    // 任务完成
  } else if (step >= allowedMaxSteps) {
    // 超过最大步数
  }
}

加载图表中...

private async runPlanner(): Promise<AgentOutput<PlannerOutput> | null> {
  try {
    // 把当前浏览器状态添加到记忆中
    let positionForPlan = 0;
    if (this.tasks.length > 1 || this.context.nSteps > 0) {
      await this.navigator.addStateMessageToMemory();
      positionForPlan = this.context.messageManager.length() - 1;
    } else {
      positionForPlan = this.context.messageManager.length();
    }
 
    // 执行 Planner 智能体
    const planOutput = await this.planner.execute();
    if (planOutput.result) {
      // 把规划结果写入消息历史
      this.context.messageManager.addPlan(
        JSON.stringify(planOutput.result), positionForPlan
      );
    }
    return planOutput;
  } catch (error) {
    // 特定错误类型直接抛出
    if (error instanceof ChatModelAuthError || error instanceof RequestCancelledError || ...) {
      throw error;
    }
    // 其他错误计入连续失败
    context.consecutiveFailures++;
    if (context.consecutiveFailures >= context.options.maxFailures) {
      throw new MaxFailuresReachedError(...);
    }
    return null;
  }
}

private async navigate(): Promise<boolean> {
  try {
    if (context.paused || context.stopped) return false;
 
    const navOutput = await this.navigator.execute();
    if (context.paused || context.stopped) return false;
 
    context.nSteps++;
    if (navOutput.error) throw new Error(navOutput.error);
 
    context.consecutiveFailures = 0;
    if (navOutput.result?.done) return true;
  } catch (error) {
    // 同样处理连续失败
    context.consecutiveFailures++;
    if (context.consecutiveFailures >= context.options.maxFailures) {
      throw new MaxFailuresReachedError(...);
    }
  }
  return false;
}

// Planner 调用：添加规划结果
messageManager.addPlan(JSON.stringify(planOutput), positionForPlan);
 
// Navigator 调用：添加浏览器状态
await navigator.addStateMessageToMemory();
 
// 获取当前消息历史（Planner 和 Navigator 都用到）
const messages = messageManager.getMessages();

[系统提示] → [初始任务] → [状态 1] → [Action 结果 1] → [状态 2] → [Planner 规划 1] → [状态 3] → ...

批量采集中的类似策略：
  每采集 10 个页面后，检查一次当前进度（类似 Planner）
  每采集 1 个页面，执行数据提取（类似 Navigator）
  如果中间出错超过 3 次，放弃当前批次（类似 maxFailures）