@Component                                         // ① 注册为 Spring Bean
@Description("Get current weather...")             // ② 提供描述给 LLM
public class WeatherTool implements Function<WeatherTool.Request, WeatherTool.Response> {
    @Override
    public Response apply(Request request) { ... } // ③ 实现 apply()
}

.toolNames("weatherTool")
    ↓
Spring AI 从 ApplicationContext 按 Bean name 找到 WeatherTool
    ↓
反射 Request 的字段（city: String），自动生成 JSON Schema：
  { "type": "object", "properties": { "city": { "type": "string" } } }
    ↓
把 [工具名 + @Description + JSON Schema] 作为 tools 数组发给 OpenAI API

{
  "tools": [{
    "type": "function",
    "function": {
      "name": "weatherTool",
      "description": "Get current weather information for a city. Input: city name",
      "parameters": {
        "type": "object",
        "properties": { "city": { "type": "string" } },
        "required": ["city"]
      }
    }
  }]
}

OpenAI 返回：
  { "finish_reason": "tool_calls",
    "tool_calls": [{ "name": "weatherTool", "arguments": "{\"city\":\"beijing\"}" }] }
    ↓
Spring AI 解析 arguments JSON → 反序列化为 WeatherTool.Request("beijing")
    ↓
调用 weatherTool.apply(request)       ← AOP 在这里拦截（ToolExecutionAspect）
    ↓
把 Response 序列化为 JSON 作为 tool message 塞回对话
    ↓
再次调用 LLM（带上 tool result）
    ↓
LLM 返回 finish_reason = "stop" → 循环终止

代码调用 .call().content()
    │
    ▼  HTTP Request #1 ──────────────────────────────►  OpenAI
       { messages: [...], tools: [weatherTool, calculatorTool] }
                                                        LLM 决定调工具
    ◄────────────────────────────────────────────────
       { finish_reason: "tool_calls",
         tool_calls: [{ name: "weatherTool", args: {"city":"beijing"} }] }
    │
    ▼  Spring AI 本地执行 weatherTool.apply(...)  （不走网络）
    │
    ▼  HTTP Request #2 ──────────────────────────────►  OpenAI
       { messages: [...原始消息..., tool_call结果] }
                                                        LLM 总结答案
    ◄────────────────────────────────────────────────
       { finish_reason: "stop",
         content: "北京今天多云，12°C" }
    │
    ▼
返回给代码："北京今天多云，12°C"

// 靠 prompt 要求，LLM 不保证遵守，需要自己 extractJson()
String raw = chatClient.prompt().user(prompt).call().content();

// 优雅写法：直接用 .entity()
List<PlanStep> plan = chatClient.prompt()
    .user(prompt)
    .call()
    .entity(new ParameterizedTypeReference<List<PlanStep>>() {});

import org.springframework.ai.openai.api.ResponseFormat;

OpenAiChatOptions options = OpenAiChatOptions.builder()
    .responseFormat(ResponseFormat.builder()
        .type(ResponseFormat.Type.JSON_SCHEMA)   // 关键
        .jsonSchema(ResponseFormat.JsonSchema.builder()
            .name("PlanStepList")
            .schema(converter.getJsonSchemaMap())
            .strict(true)                        // 严格模式，100% 强制遵守
            .build())
        .build())
    .temperature(0.3)
    .build();

spring:
  ai:
    openai:
      api-key: ${DEEPSEEK_API_KEY}
      base-url: https://api.deepseek.com   # 换 base-url
      chat:
        options:
          model: deepseek-chat             # deepseek-chat = V3

LLM 收到消息
  ↓
LLM 返回 tool_call（要调 weatherTool）→ 执行工具 → 把结果塞回给 LLM
  ↓
LLM 再次推理
  ↓
LLM 返回 stop_reason = "stop"（不再调工具）→ 循环退出
  ↑
这一步就是"判断完毕"，由 LLM 决定，Spring AI 识别 finish_reason

// AgentOrchestrator.java
+ String.format("%n请在回复中简短说明每次工具调用的原因。最多调用工具 %d 次。", maxSteps);

// 这无法限制循环次数！
List<AgentStep> steps = StepCollector.collect();  // .call() 已经返回，循环已结束
if (steps.size() >= maxSteps) { ... }             // 为时已晚

// ToolExecutionAspect.java
@Around("execution(* com.dawn.ai.agent.tools.*.apply(..))")
public Object captureStep(ProceedingJoinPoint pjp) throws Throwable {
    int stepNum = StepCollector.nextStepNumber();

    // 超限时不执行工具，返回停止信号给 LLM
    if (stepNum > StepCollector.getMaxSteps()) {
        log.warn("[ReAct] 已达到 maxSteps 上限，返回终止信号");
        return "已达到最大工具调用次数限制，请根据已有信息直接给出最终答案，不要再调用工具。";
    }

    // 正常执行
    long start = System.currentTimeMillis();
    Object result = pjp.proceed();
    // ...
}