agent-management/backend/src/main/java/com/agent/management/engine/hermes/HermesBridgeClient.java

package com.agent.management.engine.hermes;

import com.agent.management.config.HermesProperties;
import com.agent.management.engine.ExecutionLog;
import com.agent.management.engine.HermesRunResult;
import com.agent.management.engine.NodeStreamSink;
import com.agent.management.service.HermesErrorPatternService;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Component;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Stream;

/**
 * Hermes Bridge HTTP 客户端。
 * 调用 Python Bridge 的 /run 端点，解析 SSE 流式响应。
 * 仅在 hermes.enabled=true 时激活。
 */
@Slf4j
@Component
@ConditionalOnProperty(name = "hermes.enabled", havingValue = "true")
public class HermesBridgeClient {

    /**
     * LLM/智能体调用专用 logger：
     * 由 logback-spring.xml 中 LLM_HTTP logger 配置为 DEBUG 级别，仅写入独立日志文件，不输出到控制台。
     */
    private static final Logger LLM_HTTP = LoggerFactory.getLogger("LLM_HTTP");

    private final HermesProperties properties;
    private final ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 错误响应嗅探服务（方案 B）。
     *
     * <p>使用 {@link Autowired#required(boolean)} 标记为非必需：
     * 测试场景或 Hermes 关闭场景下允许为 null，{@code #parseSseResponse} 会跳过嗅探。</p>
     */
    private final HermesErrorPatternService errorPatternService;

    @Autowired
    public HermesBridgeClient(HermesProperties properties,
                              @Autowired(required = false) HermesErrorPatternService errorPatternService) {
        this.properties = properties;
        this.errorPatternService = errorPatternService;
    }

    /**
     * 兼容旧调用方与测试：保留无嗅探服务的构造器。
     */
    public HermesBridgeClient(HermesProperties properties) {
        this(properties, null);
    }

    /**
     * 调用 Hermes Agent 执行任务。
     *
     * @param systemPrompt 系统提示（如 SKILL.md 内容）
     * @param userMessage  用户消息
     * @param maxIterations 最大工具调用轮次
     * @return 执行结果（含最终回复和执行日志）
     */
    public HermesRunResult run(String systemPrompt, String userMessage, int maxIterations) throws Exception {
        return run(systemPrompt, userMessage, maxIterations, null, null, null, null);
    }

    /**
     * 调用 Hermes Agent 执行任务（可指定 HERMES_HOME 与工作目录）。
     *
     * @param systemPrompt 系统提示（如 SKILL.md 内容）
     * @param userMessage  用户消息
     * @param maxIterations 最大工具调用轮次
     * @param hermesHome   本次运行使用的 HERMES_HOME 路径（其下应含 skills 子目录）；
     *                     为 null/空则使用 Bridge 启动时的默认值
     * @param workingDir   agent 工具调用的实际工作目录（终端、文件读写以它为根）；
     *                     为 null/空则使用 Bridge 子进程的启动目录
     * @return 执行结果（含最终回复和执行日志）
     */
    public HermesRunResult run(String systemPrompt, String userMessage, int maxIterations,
                                String hermesHome, String workingDir) throws Exception {
        return run(systemPrompt, userMessage, maxIterations, hermesHome, workingDir, null, null);
    }

    /**
     * 调用 Hermes Agent 执行任务（流式回调版本）。
     *
     * <p>当 {@code sink} 非 null 时：</p>
     * <ul>
     *   <li>{@code text} 事件实时通过 sink 推送，不再写入 logs（避免节点完成后重复显示）</li>
     *   <li>{@code tool_start/tool_end} 事件同时进 logs 和 sink（结构化记录 + 实时反馈）</li>
     * </ul>
     *
     * @param nodeId       调用方节点 ID（写入 sink 用），可为 null
     * @param sink         流式回调，可为 null（退化为旧同步收集行为）
     */
    public HermesRunResult run(String systemPrompt, String userMessage, int maxIterations,
                                String hermesHome, String workingDir,
                                String nodeId, NodeStreamSink sink) throws Exception {
        return run(systemPrompt, userMessage, maxIterations, hermesHome, workingDir, nodeId, sink, null);
    }

    /**
     * 调用 Hermes Agent 执行任务（完整版，可指定 sessionId）。
     *
     * <p>sessionId 用于隔离 Hermes 的 terminal / file 环境工作目录，
     * 避免同一 Bridge 进程内不同 workflow run 共享 "default" 环境导致 cwd 错误。</p>
     *
     * @param sessionId    会话/任务标识（建议 workflowRunId + "_" + nodeId）
     */
    public HermesRunResult run(String systemPrompt, String userMessage, int maxIterations,
                                String hermesHome, String workingDir,
                                String nodeId, NodeStreamSink sink, String sessionId) throws Exception {
        return run(systemPrompt, userMessage, maxIterations, hermesHome, workingDir,
                nodeId, sink, sessionId, null);
    }

    /**
     * 调用 Hermes Agent 执行任务（完整版，可指定模型配置）。
     *
     * <p>modelConfig 非空时，Bridge 会优先使用其中的 base_url/api_key/model_name
     * 创建/复用 AIAgent，从而支持按节点选择不同的模型。</p>
     *
     * @param modelConfig 模型配置（modelId/baseUrl/apiKey/modelName），可为 null
     */
    public HermesRunResult run(String systemPrompt, String userMessage, int maxIterations,
                                String hermesHome, String workingDir,
                                String nodeId, NodeStreamSink sink, String sessionId,
                                Map<String, String> modelConfig) throws Exception {
        String url = "http://127.0.0.1:" + properties.getBridge().getPort() + "/run";

        // 未显式指定时回落到固定 HERMES_HOME（hermes.bridge.home），
        // 保证 Bridge 侧 agent 池缓存键与技能扫描目录稳定一致
        String effectiveHermesHome = (hermesHome != null && !hermesHome.isBlank())
                ? hermesHome
                : properties.getBridge().getResolvedHome().toString();

        Map<String, Object> body = new ConcurrentHashMap<>();
        body.put("user_message", userMessage);
        body.put("max_iterations", maxIterations);
        // 注入「可用技能列表 + 高效执行策略」前置 prompt，减少 LLM 猜名失败与上下文膨胀
        String enhancedSystemPrompt = buildEnhancedSystemPrompt(effectiveHermesHome, systemPrompt);
        if (enhancedSystemPrompt != null && !enhancedSystemPrompt.isBlank()) {
            body.put("system_prompt", enhancedSystemPrompt);
        }
        body.put("hermes_home", effectiveHermesHome);
        if (workingDir != null && !workingDir.isBlank()) {
            body.put("working_dir", workingDir);
        }
        if (sessionId != null && !sessionId.isBlank()) {
            body.put("session_id", sessionId);
        }
        if (modelConfig != null) {
            if (modelConfig.get("modelId") != null && !modelConfig.get("modelId").isBlank()) {
                body.put("model_id", modelConfig.get("modelId"));
            }
            if (modelConfig.get("baseUrl") != null && !modelConfig.get("baseUrl").isBlank()) {
                body.put("base_url", modelConfig.get("baseUrl"));
            }
            if (modelConfig.get("apiKey") != null && !modelConfig.get("apiKey").isBlank()) {
                body.put("api_key", modelConfig.get("apiKey"));
            }
            if (modelConfig.get("modelName") != null && !modelConfig.get("modelName").isBlank()) {
                body.put("model_name", modelConfig.get("modelName"));
            }
        }

        byte[] bodyBytes = objectMapper.writeValueAsBytes(body);

        HttpURLConnection conn = (HttpURLConnection) URI.create(url).toURL().openConnection();
        conn.setRequestMethod("POST");
        conn.setDoOutput(true);
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setRequestProperty("Accept", "text/event-stream");
        // M5: 注入 X-Bridge-Token 共享密钥，由 Bridge 端校验
        String authToken = properties.getBridge().getAuthToken();
        if (authToken != null && !authToken.isBlank()) {
            conn.setRequestProperty("X-Bridge-Token", authToken);
        }
        conn.setConnectTimeout(10000);
        conn.setReadTimeout(300000);

        // === 请求 DEBUG 日志（仅写入 LLM 日志文件，不输出到控制台） ===
        LLM_HTTP.debug("[Hermes-REQ] ========== 请求开始 ==========");
        LLM_HTTP.debug("[Hermes-REQ] POST {}", url);
        LLM_HTTP.debug("[Hermes-REQ] nodeId={}, sessionId={}, maxIterations={}", nodeId, sessionId, maxIterations);
        LLM_HTTP.debug("[Hermes-REQ] Body ({} bytes): {}", bodyBytes.length, new String(bodyBytes, StandardCharsets.UTF_8));

        long startTime = System.currentTimeMillis();
        conn.getOutputStream().write(bodyBytes);
        conn.getOutputStream().flush();

        int responseCode = conn.getResponseCode();
        // connectMs = 建立连接 + 写出 body + 收到 HTTP 响应头的时间
        // （注意：SSE 的响应头几乎立刻到达，body 还在流式传输，所以这里耗时很短）
        long connectMs = System.currentTimeMillis() - startTime;
        if (responseCode != 200) {
            String error;
            try (var reader = new BufferedReader(new InputStreamReader(conn.getErrorStream(), StandardCharsets.UTF_8))) {
                StringBuilder sb = new StringBuilder();
                String line;
                while ((line = reader.readLine()) != null) sb.append(line);
                error = sb.toString();
            }
            long totalMs = connectMs;
            LLM_HTTP.debug("[Hermes-RESP] HTTP {} (total={}ms), error: {}", responseCode, totalMs, error);
            throw new RuntimeException("Hermes Bridge 返回 HTTP " + responseCode + ": " + error);
        }

        long streamStart = System.currentTimeMillis();
        HermesRunResult result = parseSseResponse(conn, nodeId, sink);
        // streamMs = 读取 SSE 流式 body 的耗时（这才是真正的 Agent 执行时间，包含所有 LLM 调用与工具循环）
        long streamMs = System.currentTimeMillis() - streamStart;
        long totalMs = System.currentTimeMillis() - startTime;

        // === 响应 DEBUG 日志（分别记录连接耗时与流式读取耗时，便于定位卡点） ===
        LLM_HTTP.debug("[Hermes-RESP] HTTP 200, connect={}ms, stream={}ms, total={}ms, finalText 长度={}, logs 数={}",
                connectMs, streamMs, totalMs,
                result.getFinalText() == null ? 0 : result.getFinalText().length(),
                result.getLogs() == null ? 0 : result.getLogs().size());
        LLM_HTTP.debug("[Hermes-RESP] finalText: {}", result.getFinalText());
        LLM_HTTP.debug("[Hermes-RESP] ========== 请求结束 ==========");
        return result;
    }

    /**
     * 解析 SSE 响应流，收集日志并提取最终回复。
     * 若 sink 非 null：thinking 通过 sink 实时推送（不进 logs），工具事件同时进 logs 和 sink。
     * 若 sink 为 null：thinking 进 logs（兼容旧行为）。
     */
    private HermesRunResult parseSseResponse(HttpURLConnection conn, String nodeId, NodeStreamSink sink) throws Exception {
        StringBuilder finalResponse = new StringBuilder();
        List<ExecutionLog> logs = new ArrayList<>();

        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {

            String eventType = "";
            String line;
            while ((line = reader.readLine()) != null) {
                if (line.startsWith("event: ")) {
                    eventType = line.substring(7).trim();
                } else if (line.startsWith("data: ")) {
                    String dataJson = line.substring(6);
                    JsonNode data = objectMapper.readTree(dataJson);

                    switch (eventType) {
                        case "tool_start" -> {
                            String tool = data.path("tool").asText("?");
                            String args = data.has("args") ? objectMapper.writeValueAsString(data.get("args")) : null;
                            String argsTrunc = truncate(args, 500);
                            logs.add(ExecutionLog.toolCall(tool, argsTrunc));
                            if (sink != null) {
                                try {
                                    sink.emit(nodeId, "tool_call", argsTrunc, tool);
                                } catch (Exception ex) {
                                    log.warn("[Hermes] sink 推送 tool_call 失败: {}", ex.getMessage());
                                }
                            }
                            log.debug("[Hermes] 工具调用: {}", tool);
                        }
                        case "tool_end" -> {
                            String tool = data.path("tool").asText("?");
                            String summary = data.path("result_summary").asText("");
                            String summaryTrunc = truncate(summary, 500);
                            logs.add(ExecutionLog.toolResult(tool, summaryTrunc));
                            if (sink != null) {
                                try {
                                    sink.emit(nodeId, "tool_result", summaryTrunc, tool);
                                } catch (Exception ex) {
                                    log.warn("[Hermes] sink 推送 tool_result 失败: {}", ex.getMessage());
                                }
                            }
                            log.debug("[Hermes] 工具完成: {}", tool);
                        }
                        case "text" -> {
                            String delta = data.path("content").asText("");
                            if (!delta.isEmpty()) {
                                // thinking 既要实时推送（流式 UI），也要进入 logs（运行记录可回放）
                                logs.add(ExecutionLog.thinking(delta));
                                if (sink != null) {
                                    try {
                                        sink.emit(nodeId, "thinking", delta, null);
                                    } catch (Exception ex) {
                                        log.warn("[Hermes] sink 推送 thinking 失败: {}", ex.getMessage());
                                    }
                                }
                            }
                        }
                        case "done" -> finalResponse.append(data.path("content").asText(""));
                        case "error" -> {
                            String msg = data.path("message").asText("未知错误");
                            logs.add(ExecutionLog.error(msg));
                            throw new RuntimeException("Hermes Agent 执行错误: " + msg);
                        }
                        default -> {}
                    }
                    eventType = "";
                }
            }
        }

        String finalText = finalResponse.toString();

        // B: 错误响应嗅探 —— Hermes Agent / hermes-agent 底层把 LLM 失败描述当作 final_response 返回，
        // 这里通过可配置模式列表识别 4xx/限流/认证失败等典型错误，命中即抛 HermesErrorResponseException，
        // 由 HermesAgentExecutor / HermesSmartActionExecutor 转化为 NodeExecutionResult.failed
        if (errorPatternService != null) {
            HermesErrorPatternService.ErrorDetectionResult detection = errorPatternService.isErrorResponse(finalText);
            if (detection.isError()) {
                String errMsg = String.format("Hermes Agent 响应被识别为错误（命中模式「%s」）: %s",
                        detection.getMatchedPatternName(), truncate(finalText, 200));
                LLM_HTTP.warn("[Hermes-RESP] 错误响应嗅探命中: pattern={}, response(截断)={}",
                        detection.getMatchedPatternName(), truncate(finalText, 500));
                throw new HermesErrorResponseException(errMsg, detection.getMatchedPatternName());
            }
        }

        return new HermesRunResult(finalText, logs);
    }

    private String truncate(String text, int maxLen) {
        if (text == null) return null;
        return text.length() <= maxLen ? text : text.substring(0, maxLen) + "...";
    }

    /**
     * 高效执行策略前置 prompt。
     *
     * <p>用于解决 Hermes Agent 执行慢的几个根因（基于日志分析）：</p>
     * <ul>
     *   <li>② LLM 猜错技能名导致无效工具调用（readme-gen / git-commit-log-gen 等不存在）</li>
     *   <li>③ 中间轮次过度消化工具结果，每轮都生成几百 token 的「思考总结」</li>
     *   <li>④ read_file 整个大文件导致 in= token 雪球式膨胀（23k→50k）</li>
     *   <li>⑤ 探索完成后仍在循环验证，多出 2-3 轮无意义 LLM 调用</li>
     * </ul>
     *
     * <p>这是「软优化」——通过 prompt 引导 LLM 自主控制上下文，而非硬性截断。
     * 对比修改 hermes-agent 内部的 trajectory_compressor，这种方式风险最低、维护成本最小。</p>
     */
    private static final String EFFICIENCY_PROMPT_TEMPLATE =
            "=== 执行策略提示（必须严格遵守）===\n\n" +
            "## 可用技能（skill_view 调用时请使用精确名，禁止猜测）\n%s\n\n" +
            "## 技能根目录（构造脚本路径时必须使用，禁止凭记忆猜测）\n" +
            "所有技能文件位于：%s\n" +
            "技能的脚本/资源绝对路径 = 上述根目录 + /技能名/技能内相对路径，" +
            "例如技能 foo 的 scripts/run.py 的绝对路径为「技能根目录/foo/scripts/run.py」。\n" +
            "SKILL.md 中的相对路径均相对于该技能自身目录；terminal 的工作目录不是技能目录，" +
            "执行脚本前必须先按此规则拼接出完整绝对路径。\n\n" +
            "## 高效执行原则\n" +
            "1. 一次性产出：明确目标后，应一次性生成所有需要的文件/输出，" +
            "不要每完成一个小步骤就停下来生成中间总结，避免多消耗 1 轮 LLM 调用。\n" +
            "2. 摘要工具优先：当文件较大（>200 行）时，优先使用 head_file / search_files / grep " +
            "等摘要工具定位关键内容，避免直接 read_file 整个大文件——上下文膨胀会让后续每一轮都更慢。\n" +
            "3. 控制探索深度：达到目标即停止，不要重复读取已知信息、反复验证；" +
            "任务完成后用一句话告知「已完成」，不要生成冗长总结报告。\n" +
            "4. 工具结果复用：上一轮已经读到的内容，本轮不要重复读取；" +
            "如需引用，直接基于已读内容作答。\n\n" +
            "## 注意\n" +
            "上述原则是「在合适场景下」的优化指引。当任务确实需要逐项探索（如多文件批量分析）时，" +
            "可按需展开；但不要为了「显得认真」而增加无意义的中间步骤。\n";

    /**
     * 在原始 system_prompt 前追加「执行策略提示」。
     *
     * @param hermesHome  本次运行的 HERMES_HOME（其下应有 skills 子目录），用于扫描可用技能列表
     * @param basePrompt  调用方提供的原始 system_prompt（如 SKILL.md 内容），可为 null
     * @return 增强后的 system_prompt；若 basePrompt 为空且无可用技能列表，返回 null（不发 system_prompt）
     */
    private String buildEnhancedSystemPrompt(String hermesHome, String basePrompt) {
        String skillsList = scanAvailableSkills(hermesHome);
        String skillsRoot = Paths.get(hermesHome, "skills").toString();
        String efficiencySection = String.format(EFFICIENCY_PROMPT_TEMPLATE, skillsList, skillsRoot);

        if (basePrompt == null || basePrompt.isBlank()) {
            return efficiencySection;
        }
        return efficiencySection + "\n---\n\n" + basePrompt;
    }

    /**
     * 扫描 HERMES_HOME/skills 目录，返回逗号分隔的技能 folderName 列表。
     * 扫描失败时返回占位文案（不影响主流程）。
     *
     * <p>每次扫描开销很小（单次 Files.list，几十毫秒级），相对于 Hermes 整体上百秒的耗时可以忽略，
     * 因此不做缓存——这也避免了「运行时新增技能但缓存未更新」的问题。</p>
     */
    private String scanAvailableSkills(String hermesHome) {
        if (hermesHome == null || hermesHome.isBlank()) {
            return "（未提供 hermes_home，无法列出）";
        }
        Path skillsDir = Paths.get(hermesHome, "skills");
        if (!Files.isDirectory(skillsDir)) {
            return "（skills 目录不存在于 " + skillsDir + "）";
        }
        List<String> names = new ArrayList<>();
        try (Stream<Path> entries = Files.list(skillsDir)) {
            entries.filter(Files::isDirectory)
                    .map(p -> p.getFileName().toString())
                    .filter(s -> !s.startsWith(".") && !s.equals("__pycache__"))
                    .sorted()
                    .forEach(names::add);
        } catch (IOException e) {
            log.warn("[HermesBridgeClient] 扫描技能目录失败: {}", e.getMessage());
            return "（扫描失败: " + e.getMessage() + "）";
        }
        if (names.isEmpty()) {
            return "（无）";
        }
        return String.join(", ", names);
    }

    /**
     * 通知 Bridge 清空技能索引缓存与 Agent 池，使新同步的技能立即生效。
     * 由 HermesSkillSyncService 在技能写时同步后调用；失败仅记录日志，不影响主流程。
     */
    public void invalidateSkillsCache() {
        String url = "http://127.0.0.1:" + properties.getBridge().getPort() + "/skills/invalidate";
        try {
            HttpURLConnection conn = (HttpURLConnection) URI.create(url).toURL().openConnection();
            conn.setRequestMethod("POST");
            String authToken = properties.getBridge().getAuthToken();
            if (authToken != null && !authToken.isBlank()) {
                conn.setRequestProperty("X-Bridge-Token", authToken);
            }
            conn.setConnectTimeout(3000);
            conn.setReadTimeout(5000);
            int code = conn.getResponseCode();
            if (code != 200) {
                log.warn("[HermesBridgeClient] /skills/invalidate 返回非 200: {}", code);
            } else {
                log.info("[HermesBridgeClient] Bridge 技能缓存已失效");
            }
            conn.disconnect();
        } catch (Exception e) {
            // Bridge 未启动或不可达时静默降级：下次 Bridge 重启后进程级缓存自然重建
            log.warn("[HermesBridgeClient] 调用 /skills/invalidate 失败（Bridge 可能未就绪）: {}", e.getMessage());
        }
    }
}