// Few-shot CoT 的 Prompt 模板
String fewShotCoT = """
    问题：一个商店有 45 个苹果，卖掉了 1/3，又进货 12 个，现在有多少？
    
    思考过程：
    1. 商店原有 45 个苹果
    2. 卖掉 1/3：45 × 1/3 = 15 个
    3. 剩下：45 - 15 = 30 个
    4. 又进货 12 个：30 + 12 = 42 个
    
    答案：42 个苹果
    
    问题：%s
    
    思考过程：
    """;

// Zero-shot CoT 的 Prompt 模板
String zeroShotCoT = """
    问题：%s
    
    让我们一步步思考这个问题：
    """;

@Component
public class CoTReasoningAgent {

    private final ChatClient chatClient;

    public CoTReasoningAgent(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    /**
     * Zero-shot CoT：通过提示词让模型自行展开推理链
     */
    public String thinkStepByStep(String question) {
        return chatClient.prompt()
            .user(question + "\n\n让我们一步步思考这个问题，先分析题目，然后列出解题步骤，最后给出答案。")
            .call()
            .content();
    }

    /**
     * Few-shot CoT：提供推理示例，引导模型模仿推理模式
     */
    public String thinkWithExamples(String question, List<QAExample> examples) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("请参考以下示例的推理方式来回答问题：\n\n");
        
        for (QAExample ex : examples) {
            prompt.append("问：").append(ex.question()).append("\n");
            prompt.append("思考过程：").append(ex.reasoning()).append("\n");
            prompt.append("答：").append(ex.answer()).append("\n\n");
        }
        
        prompt.append("问：").append(question).append("\n");
        prompt.append("思考过程：");
        
        return chatClient.prompt()
            .user(prompt.toString())
            .call()
            .content();
    }
}

record QAExample(String question, String reasoning, String answer) {}

@Component
public class SelfConsistencyAgent {

    private final ChatClient chatClient;
    
    // 采样次数——通常 5-10 次就能获得很好的效果
    private static final int SAMPLE_COUNT = 7;

    public SelfConsistencyAgent(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    /**
     * Self-Consistency 推理：多次 CoT 采样 + 多数投票
     */
    public ConsistencyResult reasonWithConsistency(String question) {
        // 并行采样多条推理路径
        List<String> reasoningPaths = new ArrayList<>();
        
        for (int i = 0; i < SAMPLE_COUNT; i++) {
            String reasoning = chatClient.prompt()
                .user(buildCoTPrompt(question))
                .options(ChatOptions.builder()
                    .temperature(0.7)  // 需要一定的随机性来获得多样化的推理路径
                    .build())
                .call()
                .content();
            reasoningPaths.add(reasoning);
        }
        
        // 从每条路径中提取最终答案
        List<String> answers = reasoningPaths.stream()
            .map(this::extractFinalAnswer)
            .toList();
        
        // 多数投票
        String majorityAnswer = answers.stream()
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
            .entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .map(Map.Entry::getKey)
            .orElse("无法确定");
        
        // 计算一致性得分
        long maxVotes = answers.stream()
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
            .values().stream()
            .max(Long::compareTo)
            .orElse(0L);
        
        double confidence = (double) maxVotes / SAMPLE_COUNT;
        
        return new ConsistencyResult(majorityAnswer, confidence, reasoningPaths);
    }
    
    private String buildCoTPrompt(String question) {
        return "问题：" + question + "\n\n"
            + "请一步步思考这个问题，最后用"最终答案：XXX"的格式给出答案。";
    }
    
    private String extractFinalAnswer(String reasoning) {
        // 尝试从推理文本中提取"最终答案："后面的内容
        Pattern pattern = Pattern.compile("最终答案[：:]\\s*(.+?)(?:\\n|$)");
        Matcher matcher = pattern.matcher(reasoning);
        if (matcher.find()) {
            return matcher.group(1).trim();
        }
        // 备选：取最后一行作为答案
        String[] lines = reasoning.split("\n");
        return lines[lines.length - 1].trim();
    }
}

record ConsistencyResult(
    String answer, 
    double confidence, 
    List<String> reasoningPaths
) {}

@Component
public class TreeOfThoughtsReasoner {

    private final ChatClient chatClient;
    
    // 每层最多保留的候选思路数
    private static final int BRANCHING_FACTOR = 3;
    // 最大搜索深度
    private static final int MAX_DEPTH = 4;
    // 评估阈值：低于此分数的分支会被剪枝
    private static final double PRUNE_THRESHOLD = 0.4;

    public TreeOfThoughtsReasoner(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    /**
     * Tree of Thoughts 推理：生成多条推理分支，评估并选择最优路径
     */
    public ToTResult solveWithTreeOfThoughts(String problem) {
        // 初始思路生成
        List<ThoughtNode> rootChildren = generateThoughts(problem, null, BRANCHING_FACTOR);
        
        // BFS 搜索最优路径
        PriorityQueue<ThoughtNode> frontier = new PriorityQueue<>(
            Comparator.comparingDouble(ThoughtNode::score).reversed()
        );
        frontier.addAll(rootChildren);
        
        ThoughtNode bestLeaf = null;
        int depth = 0;
        
        while (!frontier.isEmpty() && depth < MAX_DEPTH) {
            ThoughtNode current = frontier.poll();
            
            // 评估当前节点是否已经是有效答案
            double terminalScore = evaluateTerminal(current);
            if (terminalScore > 0.8) {
                bestLeaf = current;
                break;
            }
            
            // 生成子思路
            List<ThoughtNode> children = generateThoughts(
                problem, current, BRANCHING_FACTOR
            );
            
            // 剪枝：只保留高分分支
            for (ThoughtNode child : children) {
                if (child.score() > PRUNE_THRESHOLD) {
                    frontier.add(child);
                }
            }
            
            if (bestLeaf == null || current.score() > bestLeaf.score()) {
                bestLeaf = current;
            }
            
            depth++;
        }
        
        // 回溯最优路径
        List<String> bestPath = reconstructPath(bestLeaf);
        
        return new ToTResult(
            bestLeaf.content(),
            bestLeaf.score(),
            bestPath
        );
    }

    /**
     * 生成候选思路：给定当前状态，生成 N 个可能的下一步推理
     */
    private List<ThoughtNode> generateThoughts(String problem, ThoughtNode current, int n) {
        String context = current != null 
            ? "问题：" + problem + "\n\n当前推理过程：\n" + reconstructPathText(current)
            : "问题：" + problem;
        
        String prompt = context + "\n\n"
            + "请生成 " + n + " 个不同的下一步推理思路。"
            + "每个思路用 [思路N] 开头标记，包含具体的推理内容。\n"
            + "要求：思路之间要有明显差异，不要只改措辞。";
        
        String response = chatClient.prompt()
            .user(prompt)
            .options(ChatOptions.builder().temperature(0.8).build())
            .call()
            .content();
        
        // 解析多个思路
        List<String> thoughts = parseMultipleThoughts(response, n);
        
        // 为每个思路生成评估分数
        return thoughts.stream()
            .map(thought -> {
                double score = evaluateThought(problem, thought, current);
                return new ThoughtNode(thought, score, current);
            })
            .toList();
    }

    /**
     * 评估某个思路的质量（0-1 分）
     */
    private double evaluateThought(String problem, String thought, ThoughtNode parent) {
        String prompt = """
            请评估以下推理思路的质量，给出 0-10 分的评分。
            
            原始问题：%s
            
            推理思路：%s
            
            评分标准：
            - 逻辑是否正确（3分）
            - 是否朝着正确方向推进（3分）  
            - 推理步骤是否清晰（2分）
            - 是否有明显的错误或偏题（2分）
            
            请只输出一个数字分数（0-10），不要解释。
            """.formatted(problem, thought);
        
        String scoreText = chatClient.prompt()
            .user(prompt)
            .options(ChatOptions.builder().temperature(0.1).build())
            .call()
            .content();
        
        try {
            return Double.parseDouble(scoreText.replaceAll("[^0-9.]", "")) / 10.0;
        } catch (NumberFormatException e) {
            return 0.5; // 解析失败时给中间分
        }
    }

    /**
     * 评估叶子节点是否已经是有效答案
     */
    private double evaluateTerminal(ThoughtNode node) {
        // 简单启发式：内容中包含"答案"、"结论"等关键词则可能是最终答案
        String content = node.content().toLowerCase();
        if (content.contains("答案") || content.contains("结论") || content.contains("因此")) {
            return node.score();
        }
        return 0.0;
    }
    
    private List<String> reconstructPath(ThoughtNode node) {
        List<String> path = new ArrayList<>();
        ThoughtNode current = node;
        while (current != null) {
            path.add(0, current.content());
            current = current.parent();
        }
        return path;
    }
    
    private String reconstructPathText(ThoughtNode node) {
        return String.join("\n→ ", reconstructPath(node));
    }
    
    private List<String> parseMultipleThoughts(String response, int expected) {
        // 按 [思路N] 标记分割
        String[] parts = response.split("\\[思路\\d+\\]");
        List<String> thoughts = Arrays.stream(parts)
            .map(String::trim)
            .filter(s -> !s.isEmpty())
            .collect(Collectors.toList());
        return thoughts.size() >= expected 
            ? thoughts.subList(0, expected) 
            : thoughts;
    }
}

record ThoughtNode(
    String content, 
    double score, 
    ThoughtNode parent  // 用于回溯路径
) {}

record ToTResult(
    String answer, 
    double confidence, 
    List<String> reasoningPath
) {}

@Component
public class ReflexionAgent {

    private final ChatClient chatClient;
    private static final int MAX_RETRIES = 3;

    public ReflexionAgent(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    /**
     * Reflexion 推理：生成→评估→反思→修正 的闭环
     */
    public ReflexionResult solveWithReflection(String problem) {
        List<ReflectionAttempt> attempts = new ArrayList<>();
        String previousReflection = null;
        
        for (int attempt = 0; attempt < MAX_RETRIES; attempt++) {
            // 第一步：生成推理和答案
            String reasoning = generateReasoning(problem, previousReflection);
            String answer = extractAnswer(reasoning);
            
            // 第二步：自我评估
            String evaluation = selfEvaluate(problem, reasoning, answer);
            
            // 第三步：判断是否需要修正
            if (evaluation.contains("正确") || evaluation.contains("无需修正")) {
                attempts.add(new ReflectionAttempt(reasoning, answer, evaluation, null));
                return new ReflexionResult(answer, true, attempts);
            }
            
            // 第四步：反思错误原因
            String reflection = reflectOnError(problem, reasoning, answer, evaluation);
            previousReflection = reflection;
            
            attempts.add(new ReflectionAttempt(reasoning, answer, evaluation, reflection));
        }
        
        // 达到最大重试次数，返回最后一次的答案
        ReflectionAttempt last = attempts.get(attempts.size() - 1);
        return new ReflexionResult(last.answer(), false, attempts);
    }

    private String generateReasoning(String problem, String previousReflection) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("问题：").append(problem).append("\n\n");
        
        if (previousReflection != null) {
            prompt.append("你之前犯了以下错误，请注意避免：\n");
            prompt.append(previousReflection).append("\n\n");
        }
        
        prompt.append("请仔细思考并给出推理过程和最终答案。");
        
        return chatClient.prompt()
            .user(prompt.toString())
            .call()
            .content();
    }

    private String selfEvaluate(String problem, String reasoning, String answer) {
        String prompt = """
            请仔细检查以下推理过程和答案是否正确。
            
            问题：%s
            
            推理过程：
            %s
            
            给出的答案：%s
            
            请检查：
            1. 每一步推理是否逻辑正确
            2. 计算是否有误
            3. 是否遗漏了重要条件
            4. 最终答案是否合理
            
            如果完全正确，回复"正确，无需修正"。
            如果有错误，详细指出错误在哪一步、错的原因是什么。
            """.formatted(problem, reasoning, answer);
        
        return chatClient.prompt()
            .user(prompt)
            .options(ChatOptions.builder().temperature(0.1).build())
            .call()
            .content();
    }

    private String reflectOnError(String problem, String reasoning, String answer, String evaluation) {
        String prompt = """
            你的推理出现了错误。请深入反思错误的根本原因。
            
            问题：%s
            你的推理：%s
            你的答案：%s
            错误分析：%s
            
            请回答：
            1. 错误的根本原因是什么（不只是表面原因）
            2. 你在推理过程中忽略了什么
            3. 下次遇到类似问题，应该注意什么
            
            用简洁的要点列出反思结论。
            """.formatted(problem, reasoning, answer, evaluation);
        
        return chatClient.prompt()
            .user(prompt)
            .call()
            .content();
    }
    
    private String extractAnswer(String reasoning) {
        Pattern pattern = Pattern.compile("(?:答案|结论|最终结果)[：:]\\s*(.+?)(?:\\n|$)");
        Matcher matcher = pattern.matcher(reasoning);
        if (matcher.find()) {
            return matcher.group(1).trim();
        }
        String[] lines = reasoning.split("\n");
        return lines[lines.length - 1].trim();
    }
}

record ReflectionAttempt(
    String reasoning, 
    String answer, 
    String evaluation, 
    String reflection
) {}

record ReflexionResult(
    String answer, 
    boolean converged, 
    List<ReflectionAttempt> attempts
) {}

@Component
public class ReasoningModelAgent {

    private final ChatClient openAIClient;
    private final ChatClient deepSeekClient;

    public ReasoningModelAgent(
            ChatClient.Builder builder,
            @Qualifier("openai") ChatClient openaiBuilder,
            @Qualifier("deepseek") ChatClient deepseekBuilder) {
        this.openAIClient = openaiBuilder;
        this.deepSeekClient = deepseekBuilder;
    }

    /**
     * 使用 OpenAI o3-mini 进行推理
     * reasoning_effort: low / medium / high
     * 控制模型内部推理的"努力程度"
     */
    public String reasonWithOpenAI(String question, ReasoningEffort effort) {
        return openAIClient.prompt()
            .user(question)
            .options(ChatOptions.builder()
                .model("o3-mini")
                // o3-mini 支持 reasoning_effort 参数
                // low: 快速但浅层的推理（适合简单问题）
                // medium: 平衡推理深度和速度
                // high: 深度推理（适合复杂数学、编程题）
                .build())
            .call()
            .content();
    }

    /**
     * 使用 DeepSeek-R1 进行推理
     * R1 的思维链是隐式的（不输出中间推理过程）
     * 但可以通过 API 参数获取思维链
     */
    public String reasonWithDeepSeekR1(String question) {
        return deepSeekClient.prompt()
            .user(question)
            .options(ChatOptions.builder()
                .model("deepseek-reasoner")
                .temperature(0.6) // R1 推荐 temperature
                .build())
            .call()
            .content();
    }

    /**
     * 混合推理策略：先用推理模型思考，再用快模型总结
     * 适用于需要深度分析但输出简洁的场景
     */
    public String deepThinkThenSummarize(String question) {
        // 第一步：用推理模型进行深度思考
        String deepReasoning = openAIClient.prompt()
            .user("请深入分析以下问题，给出详细的推理过程：\n\n" + question)
            .options(ChatOptions.builder().model("o3-mini").build())
            .call()
            .content();
        
        // 第二步：用快模型精炼输出
        String summary = openAIClient.prompt()
            .user("""
                以下是一段深度分析的结果。请提炼出核心结论，用简洁清晰的语言重新组织。
                要求：保留关键洞察，去掉冗余的推理细节，让非专业人士也能理解。
                
                分析内容：
                %s
                """.formatted(deepReasoning))
            .options(ChatOptions.builder()
                .model("gpt-4o-mini") // 快速、便宜
                .temperature(0.3)
                .build())
            .call()
            .content();
        
        return summary;
    }
}

enum ReasoningEffort {
    LOW, MEDIUM, HIGH
}

@Component
public class AdaptiveReasoningAdvisor implements CallAdvisor {

    private final ChatClient chatClient;
    
    // 复杂度评估阈值
    private static final double COMPLEXITY_THRESHOLD_HIGH = 0.8;
    private static final double COMPLEXITY_THRESHOLD_MEDIUM = 0.5;

    public AdaptiveReasoningAdvisor(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    @Override
    public String getName() {
        return "AdaptiveReasoningAdvisor";
    }

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public AdvisedResponse aroundCall(AdvisedRequest request, CallChain chain) {
        String userMessage = request.userText();
        
        // 评估问题复杂度
        double complexity = assessComplexity(userMessage);
        
        if (complexity > COMPLEXITY_THRESHOLD_HIGH) {
            // 高复杂度：使用推理模型
            String result = chatClient.prompt()
                .user(userMessage)
                .options(ChatOptions.builder().model("o3-mini").build())
                .call()
                .content();
            return new AdvisedResponse(
                new ChatResponse(List.of(new Generation(result))),
                request.adviseContext()
            );
        } else if (complexity > COMPLEXITY_THRESHOLD_MEDIUM) {
            // 中复杂度：使用 CoT
            String cotPrompt = userMessage + "\n\n让我们一步步思考这个问题。";
            AdvisedRequest newRequest = AdvisedRequest.from(request)
                .withUserText(cotPrompt)
                .build();
            return chain.nextAroundCall(newRequest);
        } else {
            // 低复杂度：直接回答
            return chain.nextAroundCall(request);
        }
    }

    /**
     * 评估问题复杂度（0-1）
     * 基于启发式规则：关键词、问题长度、是否涉及计算等
     */
    private double assessComplexity(String question) {
        double score = 0.0;
        
        // 长度因子
        if (question.length() > 200) score += 0.2;
        
        // 复杂关键词
        String[] complexKeywords = {"证明", "分析", "设计", "比较", "评估", "优化", "为什么", "如果", "假设"};
        for (String keyword : complexKeywords) {
            if (question.contains(keyword)) score += 0.1;
        }
        
        // 数学/编程关键词
        String[] mathKeywords = {"计算", "公式", "算法", "方程", "概率", "代码", "实现"};
        for (String keyword : mathKeywords) {
            if (question.contains(keyword)) score += 0.15;
        }
        
        return Math.min(score, 1.0);
    }
}

/**
 * 三级推理架构：
 * Level 0: 直接回答（快速、低成本）
 * Level 1: CoT 推理（中速、中成本）
 * Level 2: 推理模型（慢速、高成本，最高准确率）
 * 
 * 按问题复杂度动态选择，同时支持用户手动升级
 */
@Component
public class TieredReasoningService {

    private final ChatClient fastModel;    // gpt-4o-mini
    private final ChatClient smartModel;   // gpt-4o
    private final ChatClient reasoner;     // o3-mini

    public TieredReasoningService(
            @Qualifier("fast") ChatClient fastModel,
            @Qualifier("smart") ChatClient smartModel,
            @Qualifier("reasoner") ChatClient reasoner) {
        this.fastModel = fastModel;
        this.smartModel = smartModel;
        this.reasoner = reasoner;
    }

    public ReasoningResponse answer(String question, int level) {
        return switch (level) {
            case 0 -> directAnswer(question);
            case 1 -> cotReasoning(question);
            case 2 -> deepReasoning(question);
            default -> directAnswer(question);
        };
    }

    private ReasoningResponse directAnswer(String question) {
        String answer = fastModel.prompt()
            .user(question)
            .call()
            .content();
        return new ReasoningResponse(answer, "direct", 0);
    }

    private ReasoningResponse cotReasoning(String question) {
        String answer = smartModel.prompt()
            .user(question + "\n\n请一步步思考后回答。")
            .call()
            .content();
        return new ReasoningResponse(answer, "cot", 1);
    }

    private ReasoningResponse deepReasoning(String question) {
        String answer = reasoner.prompt()
            .user(question)
            .call()
            .content();
        return new ReasoningResponse(answer, "reasoning_model", 2);
    }
}

record ReasoningResponse(String answer, String strategy, int level) {}

/**
 * 带记忆的推理 Agent
 * 推理过程中自动检索相关历史经验
 */
@Component
public class MemoryAwareReasoner {

    private final ChatClient chatClient;
    private final ChatMemory memory;

    public MemoryAwareReasoner(ChatClient.Builder builder, ChatMemory memory) {
        this.chatClient = builder.build();
        this.memory = memory;
    }

    public String reasonWithMemory(String sessionId, String question) {
        // 检索相关历史对话
        List<Message> history = memory.get(sessionId, 10);
        
        // 检索相关的推理经验（之前的反思结论）
        String relevantExperience = findRelevantExperience(question, history);
        
        String prompt = """
            历史对话：
            %s
            
            相关经验：
            %s
            
            当前问题：%s
            
            请结合历史对话和相关经验，一步步推理回答当前问题。
            """.formatted(
                formatHistory(history),
                relevantExperience != null ? relevantExperience : "无",
                question
            );
        
        String answer = chatClient.prompt()
            .user(prompt)
            .call()
            .content();
        
        // 将本次推理过程存入记忆
        memory.add(sessionId, List.of(
            new UserMessage(question),
            new AssistantMessage(answer)
        ));
        
        return answer;
    }
    
    private String findRelevantExperience(String question, List<Message> history) {
        // 在历史对话中搜索包含"反思"、"教训"、"注意"等关键词的内容
        return history.stream()
            .filter(m -> m instanceof AssistantMessage)
            .map(Message::getContent)
            .filter(content -> content.contains("反思") || content.contains("教训") || content.contains("注意"))
            .findFirst()
            .orElse(null);
    }
    
    private String formatHistory(List<Message> messages) {
        return messages.stream()
            .map(m -> (m instanceof UserMessage ? "用户：" : "AI：") + m.getContent())
            .collect(Collectors.joining("\n"));
    }
}

/**
 * 推理驱动的工具选择
 * 不是直接让模型选工具，而是先推理"我需要什么"，再选工具
 */
@Component
public class ReasoningToolSelector {

    private final ChatClient chatClient;
    private final List<ToolDefinition> availableTools;

    public ReasoningToolSelector(ChatClient.Builder builder, List<ToolDefinition> tools) {
        this.chatClient = builder.build();
        this.availableTools = tools;
    }

    /**
     * 推理式工具选择：
     * 第一步：分析需要什么信息
     * 第二步：匹配最合适的工具
     * 第三步：构造正确的参数
     */
    public ToolCallDecision selectTool(String task, String context) {
        // 构建工具目录
        String toolCatalog = availableTools.stream()
            .map(t -> "- %s: %s".formatted(t.name(), t.description()))
            .collect(Collectors.joining("\n"));
        
        String prompt = """
            任务：%s
            
            上下文：%s
            
            可用工具：
            %s
            
            请先分析：
            1. 完成这个任务需要什么信息？
            2. 现有的上下文中已经有哪些信息？
            3. 还缺少什么信息？
            4. 哪个工具能提供缺少的信息？
            
            然后给出你的工具调用决策（JSON 格式）：
            {"tool": "工具名", "reasoning": "选择原因", "params": {"key": "value"}}
            """.formatted(task, context, toolCatalog);
        
        String decision = chatClient.prompt()
            .user(prompt)
            .call()
            .content();
        
        return parseDecision(decision);
    }
    
    private ToolCallDecision parseDecision(String json) {
        // 解析 JSON 决策
        ObjectMapper mapper = new ObjectMapper();
        try {
            return mapper.readValue(extractJson(json), ToolCallDecision.class);
        } catch (Exception e) {
            return new ToolCallDecision("unknown", "解析失败", Map.of());
        }
    }
    
    private String extractJson(String text) {
        int start = text.indexOf('{');
        int end = text.lastIndexOf('}');
        return (start >= 0 && end > start) ? text.substring(start, end + 1) : "{}";
    }
}

record ToolCallDecision(String tool, String reasoning, Map<String, Object> params) {}
record ToolDefinition(String name, String description, Map<String, Object> parameterSchema) {}

/**
 * 推理驱动的冲突解决器
 * 当多个 Agent 的输出不一致时，通过推理选出最佳答案
 */
@Component
public class ReasoningConflictResolver {

    private final ChatClient judgeClient;

    public ReasoningConflictResolver(ChatClient.Builder builder) {
        this.judgeClient = builder.build();
    }

    /**
     * 收到多个 Agent 的回答后，通过推理选择最佳答案
     */
    public ConflictResolution resolve(String question, List<AgentAnswer> answers) {
        StringBuilder prompt = new StringBuilder();
        prompt.append("问题：").append(question).append("\n\n");
        prompt.append("以下是不同 Agent 的回答：\n\n");
        
        for (int i = 0; i < answers.size(); i++) {
            AgentAnswer a = answers.get(i);
            prompt.append("Agent ").append(a.agentName()).append(" 的回答：\n");
            prompt.append(a.answer()).append("\n");
            if (a.reasoning() != null) {
                prompt.append("推理过程：").append(a.reasoning()).append("\n");
            }
            prompt.append("\n");
        }
        
        prompt.append("""
            请作为裁判，分析每个回答的质量：
            1. 逐个检查推理过程是否逻辑正确
            2. 检查是否有事实性错误
            3. 比较不同回答之间的差异
            4. 选出最准确、最完整的回答
            5. 如果所有回答都有问题，给出你的独立分析
            
            输出格式：
            最佳答案: Agent名称
            分析: 你的详细分析
            """);
        
        String judgment = judgeClient.prompt()
            .user(prompt.toString())
            .options(ChatOptions.builder().model("o3-mini").build())
            .call()
            .content();
        
        String bestAgent = extractBestAgent(judgment, answers);
        
        return new ConflictResolution(bestAgent, judgment);
    }
    
    private String extractBestAgent(String judgment, List<AgentAnswer> answers) {
        for (AgentAnswer a : answers) {
            if (judgment.contains(a.agentName())) {
                return a.agentName();
            }
        }
        return "judge"; // 裁判给出了独立答案
    }
}

record AgentAnswer(String agentName, String answer, String reasoning) {}
record ConflictResolution(String winnerAgent, String analysis) {}