while (true) {
  msg = callLLM(messages)          // ① 问模型：下一步干嘛？
  if (msg.没有工具调用) break       // ② 模型交卷 → 收工
  results = runTools(msg.toolCalls) // ③ 替模型干活
  messages.push(msg, ...results)   // ④ 干活结果写回上下文
}                                  // ↻ 回到①，直到模型不再要工具

async function runLoop(ctx, cfg, signal, emit) {
  let firstTurn = true;
  let pending = await cfg.getSteeringMessages();  // ⓪ 启动前先看有没有插队
  while (true) {                                   // ── 外环：follow-up ──
    let moreTools = true;
    while (moreTools || pending.length > 0) {      // ── 内环：工具 + steering ──
      emit({ type: "turn_start" });
      ctx.messages.push(...pending); pending = [];  // ① 注入插话（在 LLM 调用前！）
      const msg = await streamAssistantResponse(ctx, cfg, emit); // ② 调 LLM
      if (msg.stopReason === "error" || msg.stopReason === "aborted")
        return emit({ type: "agent_end" });        // ③ 失败即终止，不吞错
      const calls = msg.content.filter(c => c.type === "toolCall");
      moreTools = false;
      if (calls.length) {
        const batch = msg.stopReason === "length"     // ④ 截断的参数不可信
          ? await failAllToolCalls(calls, emit)
          : await executeToolCalls(ctx, msg, cfg, emit);
        ctx.messages.push(...batch.messages);        // ⑤ 结果写回上下文
        moreTools = !batch.terminate;                // ⑥ 整批 terminate 可提前收工
      }
      emit({ type: "turn_end", message: msg });
      await cfg.prepareNextTurn?.(…)                // ⑦ 每 turn 后可换模型/换上下文
      if (await cfg.shouldStopAfterTurn?(…)) return; // ⑧ 外部闸门
      pending = await cfg.getSteeringMessages();    // ⑨ 再偷看一眼有没有新插话
    }
    const followUps = await cfg.getFollowUpMessages();
    if (followUps.length) { pending = followUps; continue; } // ── 外环续命 ──
    break;                                          // 真没活了 → agent_end
  }
}

模型想生成的参数    { "command": "rm -rf ./build/tmp" }
撞上限后被截成      { "command": "rm -rf ./" }
                    ↑ 解析器视角：语法完全合法，一声不吭
                    实际语义：「删一个子目录」→「删当前目录下所有东西」

async function streamAssistantResponse(context, config, …) {
  let messages = context.messages;
  if (config.transformContext)                       // 可选：内部宽类型的最后一道加工
    messages = await config.transformContext(messages, signal);
  const llmMessages = await config.convertToLlm(messages);  // 必需：收窄成三种角色
  const response = await streamFunction(config.model, {
    systemPrompt: context.systemPrompt,
    messages: llmMessages,
    tools: context.tools,
  }, { apiKey: await config.getApiKey?.(config.model.provider), … });
  // 之后就是对流的 switch：start/text_delta/toolcall_delta/done …
  // 每个增量事件都会更新 partialMessage 并 emit message_update
}

if (this.isStreaming) {
  if (!options?.streamingBehavior)
    throw new Error("Agent is already processing. Specify " +
      "streamingBehavior ('steer' or 'followUp') to queue the message.");
  if (options.streamingBehavior === "followUp")
    await this._queueFollowUp(expandedText, images);
  else
    await this_queueSteer(expandedText, images);
  return;
}

async _runAgentPrompt(messages) {
  await this.agent.prompt(messages);
  // prompt 返回 ≠ 真结束：可能刚做完一次自愈，需要 continue 再入
  while (await this._handlePostAgentRun()) {
    await this.agent.continue();   // 重试 / 溢出压缩 / agent_end 处理器塞的新消息
  }
}