Agent 设计模式 11：Plan-and-Execute：先规划，再执行

public interface Planner {

    @SystemMessage("""
           你是一个任务规划专家。请将用户的任务分解为详细的执行步骤。

           输出格式必须是严格的JSON格式：
           {
               "plan_name": "任务名称",
               "steps": [
                   {
                       "step_number": 1,
                       "description": "步骤描述",
                       "tool": "使用的工具名称",
                       "parameters": {"参数名": "参数值"}
                   }
               ],
               "expected_output": "预期输出"
           }

           可用工具列表：
           1. add - 两数相加
           2. getWeather - 天气查询
           3. calculateCircleArea - 计算圆的面积
           4. getCurrentDateTime - 获取当前时间
           5. calculateCuboidVolume - 计算长方体体积
           6. multiply - 两数相乘
           7. divide - 两数相除
           8. queryExpressOrder - 查询快递单
           9. queryRefundProgress - 查询退款进度
          """)
    @UserMessage("问：{{request}}")
    @Agent("基于用户提供的问题生成计划")
    String createPlan(@V("request") String request);
}

public interface Executor {

    @SystemMessage("""
            你是一个任务执行器。根据给定的步骤执行任务。
            
            每次只执行一个步骤，然后等待下一个指令。
            执行完成后，报告结果和下一步建议。
            
            输出格式：
            步骤 {n}: [工具名称]
            输入: {参数}
            输出: {结果}
            状态: [成功/失败]
            
            如果步骤失败，请说明原因和建议。
            """)
    @UserMessage("{{step}}")
    @Agent("基于用户提供的问题生成计划")
    String executeStep(@V("step") String step);
}

/**
 * @author junmingyang
 */
public class Coordinator {

    private final Planner planner;
    private final Executor executor;
    private final SampleTools tools;
    private final Map<String, Object> context;


    public Coordinator(ChatModel model, SampleTools tools) {

        this.tools = tools;
        this.context = new HashMap<>();

        //创建规划器
        this.planner = AgenticServices.agentBuilder(Planner.class)
                .chatModel(model)
                .chatMemoryProvider(memoryId -> MessageWindowChatMemory.withMaxMessages(15))
                // 如果明确知道工具的列表，可以显式提供，这里就无需再绑定,以减少token使用
                //.tools(this.tools)
                .build();

        //创建执行器
        this.executor = AgenticServices.agentBuilder(Executor.class)
                .chatModel(model)
                .chatMemoryProvider(memoryId -> MessageWindowChatMemory.withMaxMessages(15))
                .tools(this.tools)
                .build();
    }


    public Map<String, Object> executeTask(String task) {
        System.out.println("\n" + "=".repeat(80));
        System.out.println("🎯 任务: " + task);
        System.out.println("=".repeat(80));

        Map<String, Object> result = new LinkedHashMap<>();
        result.put("task", task);
        result.put("start_time", LocalDateTime.now().toString());

        try {
            // 阶段1: 规划
            System.out.println("\n📋 阶段1: 任务规划");
            System.out.println("-".repeat(40));
            String planJson = planner.createPlan(task);
            System.out.println("生成的计划:\n" + planJson);

            // 解析计划（简化版，实际应该使用JSON解析）
            List<Map<String, String>> steps = parsePlan(planJson);
            result.put("plan", steps);

            // 阶段2: 执行
            System.out.println("\n⚡ 阶段2: 执行计划");
            System.out.println("-".repeat(40));

            List<Map<String, Object>> executionResults = new ArrayList<>();

            for (int i = 0; i < steps.size(); i++) {
                Map<String, String> step = steps.get(i);
                System.out.printf("\n📝 步骤 %d/%d: %s%n",
                        i + 1, steps.size(), step.get("description"));

                // 构建步骤指令
                String stepInstruction = buildStepInstruction(step);

                // 执行步骤
                String stepResult = executor.executeStep(stepInstruction);
                System.out.println("执行结果:\n" + stepResult);

                // 保存结果
                Map<String, Object> stepResultMap = new HashMap<>();
                stepResultMap.put("step_number", i + 1);
                stepResultMap.put("description", step.get("description"));
                stepResultMap.put("tool", step.get("tool"));
                stepResultMap.put("result", stepResult);
                executionResults.add(stepResultMap);

                // 更新上下文
                updateContext(task, step, stepResult);

                // 短暂暂停，避免过快执行
                Thread.sleep(1000);
            }

            result.put("execution_results", executionResults);
            result.put("status", "completed");

        } catch (Exception e) {
            System.err.println("❌ 任务执行失败: " + e.getMessage());
            result.put("status", "failed");
            result.put("error", e.getMessage());
        }

        result.put("end_time", LocalDateTime.now().toString());
        return result;
    }

    private List<Map<String, String>> parsePlan(String planJson) {
        // 简化的计划解析（实际应用中应该使用完整的JSON解析）
        List<Map<String, String>> steps = new ArrayList<>();

        // 使用正则表达式提取步骤信息
        Pattern stepPattern = Pattern.compile(
                "\"step_number\":\\s*(\\d+).*?" +
                        "\"description\":\\s*\"([^\"]+)\".*?" +
                        "\"tool\":\\s*\"([^\"]+)\"",
                Pattern.DOTALL
        );

        Matcher matcher = stepPattern.matcher(planJson);
        while (matcher.find()) {
            Map<String, String> step = new HashMap<>();
            step.put("step_number", matcher.group(1));
            step.put("description", matcher.group(2));
            step.put("tool", matcher.group(3));
            steps.add(step);
        }

        // 如果没有匹配到，创建默认步骤
        if (steps.isEmpty()) {
            Map<String, String> defaultStep = new HashMap<>();
            defaultStep.put("step_number", "1");
            defaultStep.put("description", "执行任务: " + planJson);
            defaultStep.put("tool", "analyzeText");
            steps.add(defaultStep);
        }

        return steps;
    }

    private String buildStepInstruction(Map<String, String> step) {
        return String.format(
                "执行步骤 %s:\n" +
                        "描述: %s\n" +
                        "工具: %s\n" +
                        "请使用指定工具完成此步骤。",
                step.get("step_number"),
                step.get("description"),
                step.get("tool")
        );
    }

    private void updateContext(String task, Map<String, String> step, String result) {
        // 将步骤结果存入上下文，供后续步骤使用（可选)
        String key = MurmurHash.murmur3_32Hash(task) + "_step_" + step.get("step_number") + "_result";
        context.put(key, result);
    }

    public void printContext() {
        System.out.println("-".repeat(50) + "\n上下文: ");
        context.forEach((key, value) -> System.out.println(key + " => \n" + value + "\n" + "-".repeat(30)));
    }
}

@SpringBootApplication
public class PlanAndExecuteApplication {

    public static void main(String[] args) throws IOException {
        ConfigurableApplicationContext context = SpringApplication.run(AgentDesignPatternApplication.class, args);
        ChatModel model = context.getBean("ollamaChatModel", ChatModel.class);
        SampleTools sampleTools = context.getBean("sampleTools", SampleTools.class);

        String[] testTasks = {
                "计算 15 加上 27 等于多少？",
                "北京现在的天气怎么样？",
                "计算半径为5的圆的面积",
                "现在是几点？",
                "计算长方体的体积，长10，宽5，高3",
                "帮我算一下 (25 × 4) ÷ 2 等于多少？",
                "快递单123456,现在到哪了？",
                "我的订单56789,退款到账了没？"
        };

        Coordinator coordinator = new Coordinator(model, sampleTools);

        for (int i = 0; i < testTasks.length; i++) {
            System.out.printf("\n📦 测试用例 %d/%d%n", i + 1, testTasks.length);

            Map<String, Object> result = coordinator.executeTask(testTasks[i]);

            // 打印总结
            System.out.println("\n✅ 任务完成总结:");
            System.out.println("-".repeat(40));
            System.out.println("任务: " + result.get("task"));
            System.out.println("状态: " + result.get("status"));
            System.out.println("耗时: " + calculateDuration(
                    (String) result.get("start_time"),
                    (String) result.get("end_time")
            ));

            if (result.containsKey("execution_results")) {
                @SuppressWarnings("unchecked")
                List<Map<String, Object>> executions =
                        (List<Map<String, Object>>) result.get("execution_results");
                System.out.println("执行步骤数: " + executions.size());
            }

            System.out.println("=".repeat(60));

            // 任务间暂停
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        coordinator.printContext();
    }


    private static String calculateDuration(String start, String end) {
        try {
            LocalDateTime startTime = LocalDateTime.parse(start);
            LocalDateTime endTime = LocalDateTime.parse(end);
            Duration duration = Duration.between(startTime, endTime);
            return String.format("%d秒", duration.getSeconds());
        } catch (Exception e) {
            return "未知";
        }
    }
}