Agent Loop 其实不复杂：模型只负责点名，循环负责手和脚

输入：messages + tools 菜单
输出：一段 content，和 / 或一组 tool call
然后连接断开

Thought: 我需要看目录
Action: bash
Action Input: ls -la

{
  "model": "deepseek-chat",
  "messages": [{"role": "user", "content": "列出当前目录"}],
  "tools": [{
    "type": "function",
    "function": {
      "name": "bash",
      "description": "在工作区执行一条 shell 命令",
      "parameters": {
        "type": "object",
        "properties": {"command": {"type": "string"}},
        "required": ["command"]
      }
    }
  }],
  "stream": true
}

用户 → 问模型 → 有结构化 tool call？
              否 → 把 content 给用户，停
              是 → 本地 / 沙箱执行 → 结果写回历史 → 再问模型

provider   一次 HTTP。只负责把流式碎片收成 text / tool-call / finish
session    只追加事件。发给模型的 messages 是现推的，不另存一份
loop       while：有 tool call 就执行并继续，没有就停

class BlockAssembler:
    def __init__(self) -> None:
        self.text_parts: list[str] = []
        self.tool_calls: list[dict] = []
        self.finish = {"kind": "completed"}

    def push(self, chunk: dict) -> None:
        kind = chunk["type"]
        if kind == "text":
            self.text_parts.append(chunk.get("content") or "")
        elif kind == "tool-call":
            self.tool_calls.append({
                "id": chunk.get("id") or "",
                "type": "function",
                "function": {
                    "name": chunk.get("name") or "",
                    "arguments": chunk.get("arguments") or "{}",
                },
            })
        elif kind == "finish":
            self.finish = {"kind": chunk.get("kind") or "completed"}

    def assistant_message(self) -> dict:
        text = "".join(self.text_parts)
        message = {"role": "assistant", "content": text or None}
        if self.tool_calls:
            message["tool_calls"] = self.tool_calls
        return message

def derive_messages(events: list) -> list[dict]:
    messages = []
    for event in events:
        if event["type"] == "user/message":
            messages.append({"role": "user", "content": event["text"]})
        elif event["type"] == "assistant/message":
            messages.append(dict(event["message"]))
        elif event["type"] == "tool/result":
            messages.append({
                "role": "tool",
                "tool_call_id": event["call_id"],
                "content": event["text"],
            })
    return messages

async def step_once(session, provider, tools) -> dict | None:
    request = build_request(session, tools)          # messages=derive_messages(), tools=schema
    assembler = BlockAssembler()
    async for chunk in provider.stream(request):
        session.append("assistant/chunk", chunk)
        assembler.push(chunk)

    if assembler.finish["kind"] == "error":
        return {"kind": "error"}

    message = assembler.assistant_message()
    session.append("assistant/message", message)

    if assembler.finish["kind"] == "max-tokens":
        return {"kind": "max-tokens"}                 # 参数可能被截断，不要执行

    tool_calls = message.get("tool_calls") or []
    if not tool_calls:
        return {"kind": "completed"}

    await run_tools(session, tools, tool_calls)       # 本地 invoke，追加 tool/result
    return None                                       # 让外层再走一步

async def turn(session, provider, tools, user_text: str) -> None:
    session.append("user/message", {"text": user_text})
    for _ in range(MAX_STEPS):
        ended = await step_once(session, provider, tools)
        if ended is not None:
            return
    session.append("turn/end", {"kind": "max-steps"})

step 1  请求：[user] + tools 菜单
        模型：tool-call bash {"command": "ls -la"}     ← 只是声明
        本地：真的执行 ls，写入 tool/result

step 2  请求：[user, assistant+tool_calls, tool 结果] + 同一份菜单
        模型：根据 ls 输出写回答，或再点一次工具