Agent 到底在循环什么：30 行代码看穿运行时

// 普通对话：问一次，答一次
resp, _ := client.ChatCompletion(ctx, "北京天气怎么样？")
fmt.Println(resp)  // "我无法访问实时数据..."

loop {
    1. 调用大模型（带当前对话历史）
    2. 大模型返回：要么是最终回答，要么是"我要调工具"
    3. 如果是最终回答 → 跳出循环，返回给用户
    4. 如果是工具调用 → 执行工具，把结果加入历史，回到 1
}

func SimpleAgent(client *openai.Client, input string, tools map[string]func(string) string) string {
    messages := []openai.Message{
        {Role: "system", Content: "你是一个助手。需要时调用工具。"},
        {Role: "user", Content: input},
    }

    for turn := 0; turn < 10; turn++ {  // 最多 10 轮，防死循环
        // 1. 调用大模型
        resp, _ := client.CreateChatCompletion(ctx, messages, toolDefs)
        msg := resp.Choices[0].Message

        // 2. 模型没有要调工具 → 最终回答
        if len(msg.ToolCalls) == 0 {
            return msg.Content
        }

        // 3. 模型要调工具 → 执行每个工具调用
        messages = append(messages, msg)  // 把模型的工具调用意图加入历史
        for _, call := range msg.ToolCalls {
            result := tools[call.Function.Name](call.Function.Arguments)
            messages = append(messages, openai.Message{
                Role: "tool",
                Content: result,
                ToolCallID: call.ID,
            })
        }
        // 4. 回到循环顶部，带着工具结果再调一次模型
    }
    return "（超过最大轮次）"
}

// agents/run.go:109
func Run(ctx context.Context, agent *Agent, input any, opts RunOptions) (*RunResult, error) {
    // ... 装配 runner 状态（trace、session、预算）...
    return r.loop(ctx, agent, modelInput)
}

// agents/run.go:236（简化）
for turn := startTurn; ; turn++ {
    // ① 预算与取消检查
    if turn > maxTurns { return MaxTurnsError }
    if ctx.Err() != nil { return ctx.Err() }

    // ② 解析当前 Agent 的"配方"（模型、工具、指令）
    model := resolveModel(agent, opts)
    tools := enabledTools(agent)

    // ③ 调用大模型
    resp, err := model.GetResponse(ctx, ModelRequest{...})

    // ④ 解析响应 + 执行工具 + 决定下一步
    processed := processModelResponse(resp, ...)
    step := executeToolsAndSideEffects(ctx, processed, ...)

    // ⑤ 根据下一步动作分支
    switch step.NextStep {
    case stepFinalOutput:   // 模型给最终答案了 → 返回
        return result
    case stepRunAgain:      // 还有工具要调 → 继续循环
        continue
    case stepHandoff:       // 切换到另一个 Agent → 换 agent 继续
        agent = step.NewAgent
    case stepInterruption:  // 工具调用需要人工审批 → 暂停
        return interruptedResult
    }
}

// agents/run.go:10
const DefaultMaxTurns = 10

// agents/run.go:110
maxTurns := DefaultMaxTurns
if opts.MaxTurns > 0 {
    maxTurns = opts.MaxTurns
}

// agents/run.go:237
if turn > maxTurns {
    return nil, &MaxTurnsError{...}
}

// 调用大模型时附上工具定义
toolDefs := []openai.Tool{{
    Type: "function",
    Function: openai.FunctionDef{
        Name: "get_weather",
        Description: "查询某个城市的天气",
        Parameters: jsonSchemaOfWeatherArgs,  // {"type":"object","properties":{"city":...}}
    },
}}
resp, _ := client.CreateChatCompletion(ctx, messages, toolDefs)

{
  "tool_calls": [{
    "id": "call_abc123",
    "function": {"name": "get_weather", "arguments": "{\"city\":\"北京\"}"}
  }]
}

// mini-claude-code/agent.go 的 Run 方法骨架
for turn := 1; turn <= a.MaxTurns; turn++ {           // ① 预算检查(MaxTurns=15)
    assistantMsg, _, err := a.Client.ChatStream(...)  // ② 调模型
    history = append(history, assistantMsg)           // ③ 记住自己说过什么
    if len(assistantMsg.ToolCalls) == 0 {
        return assistantMsg.Content                    // ④ 最终答案,返回
    }
    for _, call := range assistantMsg.ToolCalls {
        result := a.executeTool(call)                  // ⑤ 执行工具
        history = append(history, NewToolMsg(call.ID, result))  // ⑥ 结果回喂
    }
    // 回到 ②,带着工具结果再调模型
}