请读取 README.md，并告诉我项目名。

const readCall: ToolCall = {
  type: "toolCall",
  id: "call-1",
  name: "read",
  arguments: { path: "README.md" },
};

const firstAnswer = assistantMessage([
  text("我先读取项目说明。"),
  readCall,
], "toolUse");

const readResult: ToolResultMessage = {
  role: "toolResult",
  toolCallId: "call-1",
  toolName: "read",
  content: [text("# tiny-pi\nA small agent runtime.")],
  isError: false,
  timestamp: 3,
};

const finalAnswer = assistantMessage([
  text("项目名是 tiny-pi。"),
], "stop");

user          请读取 README.md，并告诉我项目名。
assistant     我先读取项目说明。 + read(call-1, README.md)
toolResult    call-1 → # tiny-pi ...
assistant     项目名是 tiny-pi。

request 1: [user]
    ↓ model.stream()
assistant(toolUse, call-1)
    ↓ read(README.md)
toolResult(call-1, "# tiny-pi ...")
    ↓ append to messages
request 2: [user, assistant, toolResult]
    ↓ model.stream()
assistant(stop, "项目名是 tiny-pi。")

const messages = structuredClone(options.context.messages);

options.context.messages  [user]
messages                  [user]

const stream = options.model.stream(
  {
    systemPrompt: options.context.systemPrompt,
    messages,
    tools: options.tools.definitions(),
  },
  { signal: options.signal },
);

for await (const event of stream) {
  emit(options, { type: "model_event", event });
}
const assistant = await stream.result();
messages.push(assistant);
emit(options, { type: "assistant_message", message: assistant });

start
text_delta       "我先读取项目说明。"
toolcall_delta   '{"path":"README.md"}'
toolcall_end     call-1
done             toolUse

{
  reason: "stop",
  messages: [user, assistant],
  steps: 1,
}

const calls = assistant.content.filter(
  (block): block is ToolCall => block.type === "toolCall",
);

const executeToolCall: ToolExecutor =
  options.executeToolCall ??
  ((call, context) =>
    executeCoreToolCall(call, options.tools, context));

const result = await executeToolCall(readCall, {
  signal: options.signal,
  reportProgress: (content) => {
    emit(options, {
      type: "tool_progress",
      callId: readCall.id,
      content,
    });
  },
});
emit(options, { type: "tool_end", result });

追加前  [user, assistant(call-1)]
追加后  [user, assistant(call-1), toolResult(call-1)]

model requests  2
tool executions 1
steps           2
reason          stop
roles           user → assistant → toolResult → assistant

model_event(start)
model_event(text_delta)
model_event(toolcall_delta)
model_event(toolcall_end)
model_event(done: toolUse)
assistant_message(toolUse)
tool_start(call-1)
tool_end(call-1)
model_event(start)
model_event(text_delta)
model_event(done: stop)
assistant_message(stop)
turn_end(stop)

assistant_message(length, read(call-1))
executor 调用次数          0
messages 追加              toolResult(call-1, skipped: true, reason: length)
tool_skipped               toolResult(call-1)
finish("length", 1)        → turn_end(length), steps: 1

{
  role: "toolResult",
  toolCallId: "call-1",
  toolName: "read",
  content: [text(
    "Tool call was not executed because the model response was truncated.",
  )],
  details: { skipped: true, reason: "length" },
  isError: true,
}

const results = await Promise.all(
  calls.map(async (call) => {
    const result = await executeOne(call);
    emit(options, { type: "tool_end", result });
    return result;
  }),
);

tool_end(fast-call) → tool_end(slow-call)

toolResult(slow-call) → toolResult(fast-call)

for (let steps = 1; steps <= maxSteps; steps += 1) {
  // 第 steps 次请求尚未发起；此前已经完成 steps - 1 次模型请求。
  if (options.signal?.aborted) {
    return finish("aborted", steps - 1);
  }

  // 从这里发起并收集第 steps 次 model.stream()。
  // 当前请求完成以后，本轮终态返回的计数就是 steps。
  // ...
}

reason          maxSteps
steps           1
model requests  1
messages        user → assistant(call-1) → toolResult(call-1)

正确  executionCount = 0，产生两条 tool_skipped
错误  executionCount = 2，两个工具都已经开始执行