增加与ai大模型对话

huimv-employment/fe-api/src/main/java/com/huimv/employment/controller/mp/AiProxyController.java

@@ -1,72 +1,86 @@
 package com.huimv.employment.controller.mp;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.huimv.employment.integration.kb.KbOpenAiProxyService;
 import com.huimv.employment.integration.kb.SseStreamSupport;
+import com.huimv.employment.security.LoginUser;
+import com.huimv.employment.security.LoginUserHolder;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.security.SecurityRequirement;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.util.StreamUtils;
+import org.springframework.util.StringUtils;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestHeader;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
-import java.nio.charset.StandardCharsets;
 
 /**
- * 大模型 OpenAI 兼容接口代理（小程序 JWT 鉴权，上游由服务端 fe.kb.api-key 鉴权）。
- * <p>
- * 支持 {@code stream=true} 的 SSE 流式响应，请求/响应体与 OpenAI Chat Completions 规范一致。
- * </p>
+ * 智能体网关代理（小程序 JWT 鉴权；上游暂不需要 api-key）。
  */
 @RestController
 @RequestMapping("/api/v1/mp/ai")
-@Tag(name = "AI 对话", description = "OpenAI 兼容代理，需 JWT 鉴权")
+@Tag(name = "AI 对话", description = "智能体网关代理，需 JWT 鉴权")
 @SecurityRequirement(name = "Authorization")
 public class AiProxyController {
 
+    private static final String HEADER_AGENT_ID = "X-Agent-Id";
+
     private final KbOpenAiProxyService kbOpenAiProxyService;
+    private final ObjectMapper objectMapper;
 
-    public AiProxyController(KbOpenAiProxyService kbOpenAiProxyService) {
+    public AiProxyController(KbOpenAiProxyService kbOpenAiProxyService, ObjectMapper objectMapper) {
         this.kbOpenAiProxyService = kbOpenAiProxyService;
+        this.objectMapper = objectMapper;
     }
 
     @GetMapping("/version")
-    @Operation(summary = "获取版本信息", description = "OpenAI 兼容 GET /api/version，透传上游 KB 服务响应。")
+    @Operation(summary = "获取版本信息", description = "透传上游 GET /api/version，用于健康检查。")
     public ResponseEntity<byte[]> getVersion() {
         return kbOpenAiProxyService.getVersion();
     }
 
     @PostMapping(value = "/console/chat", consumes = MediaType.APPLICATION_JSON_VALUE)
-    @Operation(summary = "对话补全（OpenAI 兼容）",
-            description = "请求/响应体与 OpenAI Chat Completions 规范一致，透传上游 KB 服务。"
-                    + "请求体示例：{\"model\":\"gpt-4\",\"messages\":[{\"role\":\"user\",\"content\":\"你好\"}],\"stream\":false}"
-                    + "；stream=true 时返回 text/event-stream SSE 流式响应。")
-    public void consoleChat(HttpServletRequest request, HttpServletResponse response) throws IOException {
-        byte[] body = StreamUtils.copyToByteArray(request.getInputStream());
-        if (kbOpenAiProxyService.isStreamRequest(body)) {
-            SseStreamSupport.prepareSseResponse(response);
-            kbOpenAiProxyService.streamChatCompletions(body, response.getOutputStream());
-            response.flushBuffer();
-            return;
+    @Operation(summary = "智能体对话（SSE 流式）",
+            description = "透传上游 POST /api/console/chat，固定返回 text/event-stream。"
+                    + "请求体示例：{\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"你好\"}]}],"
+                    + "\"session_id\":\"demo-001\",\"user_id\":\"1001\",\"channel\":\"console\"}。"
+                    + "未传 user_id 时自动填充当前登录用户 ID；未传 channel 时默认为 console。"
+                    + "可选请求头 X-Agent-Id，默认 default。")
+    public void consoleChat(HttpServletRequest request,
+                            HttpServletResponse response,
+                            @RequestHeader(value = HEADER_AGENT_ID, required = false) String agentId) throws IOException {
+        byte[] body = enrichConsoleChatBody(StreamUtils.copyToByteArray(request.getInputStream()));
+        SseStreamSupport.prepareSseResponse(response);
+        kbOpenAiProxyService.streamConsoleChat(body, agentId, response.getOutputStream());
+        response.flushBuffer();
+    }
+
+    private byte[] enrichConsoleChatBody(byte[] body) throws IOException {
+        if (body == null || body.length == 0) {
+            return body;
+        }
+        JsonNode root = objectMapper.readTree(body);
+        if (!(root instanceof ObjectNode)) {
+            return body;
         }
-        ResponseEntity<byte[]> upstream = kbOpenAiProxyService.consoleChat(body);
-        response.setStatus(upstream.getStatusCodeValue());
-        MediaType contentType = upstream.getHeaders().getContentType();
-        if (contentType != null) {
-            response.setContentType(contentType.toString());
-        } else {
-            response.setContentType(MediaType.APPLICATION_JSON_VALUE);
-            response.setCharacterEncoding(StandardCharsets.UTF_8.name());
+        ObjectNode objectNode = (ObjectNode) root;
+        if (!StringUtils.hasText(objectNode.path("user_id").asText(null))) {
+            LoginUser loginUser = LoginUserHolder.require();
+            objectNode.put("user_id", String.valueOf(loginUser.getUserId()));
         }
-        byte[] respBody = upstream.getBody();
-        if (respBody != null && respBody.length > 0) {
-            response.getOutputStream().write(respBody);
+        if (!StringUtils.hasText(objectNode.path("channel").asText(null))) {
+            objectNode.put("channel", "console");
         }
+        return objectMapper.writeValueAsBytes(objectNode);
     }
 }

huimv-employment/fe-api/src/main/resources/application.yml

@@ -57,8 +57,8 @@ fe:
     scheme: http
     host: harrison1.iask.in
     port: 9188
-    api-key: ${FE_KB_API_KEY:}
     default-model: default
+    default-agent-id: default
     default-knowledge-base: default
     file-url-base: ""
     upload-path: ${FE_KB_UPLOAD_PATH:}

huimv-employment/fe-integration/src/main/java/com/huimv/employment/integration/kb/ConsoleChatSseParser.java

@@ -0,0 +1,72 @@
+package com.huimv.employment.integration.kb;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.huimv.employment.common.exception.BizException;
+import com.huimv.employment.common.exception.ErrorCode;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * 解析 {@code POST /api/console/chat} 返回的 SSE 事件，提取 assistant 文本。
+ */
+public final class ConsoleChatSseParser {
+
+    private ConsoleChatSseParser() {
+    }
+
+    public static String extractAssistantText(InputStream sseStream, ObjectMapper objectMapper) throws IOException {
+        if (sseStream == null) {
+            throw new BizException(ErrorCode.AI_SERVICE_FAILED, "大模型返回空响应");
+        }
+        StringBuilder full = new StringBuilder();
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(sseStream, StandardCharsets.UTF_8))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                if (!line.startsWith("data: ")) {
+                    continue;
+                }
+                String payload = line.substring(6).trim();
+                if (payload.isEmpty() || "[DONE]".equals(payload)) {
+                    continue;
+                }
+                JsonNode data = objectMapper.readTree(payload);
+                JsonNode error = data.get("error");
+                if (error != null && !error.isNull()) {
+                    String message = error.path("message").asText("大模型返回错误");
+                    throw new BizException(ErrorCode.AI_SERVICE_FAILED, message);
+                }
+                JsonNode output = data.get("output");
+                if (output == null || !output.isArray()) {
+                    continue;
+                }
+                for (JsonNode item : output) {
+                    if (!"assistant".equals(item.path("role").asText())) {
+                        continue;
+                    }
+                    JsonNode contents = item.get("content");
+                    if (contents == null || !contents.isArray()) {
+                        continue;
+                    }
+                    for (JsonNode content : contents) {
+                        if ("text".equals(content.path("type").asText()) && content.has("text")) {
+                            full.append(content.get("text").asText(""));
+                        }
+                    }
+                }
+            }
+        } catch (BizException ex) {
+            throw ex;
+        } catch (Exception ex) {
+            throw new BizException(ErrorCode.AI_SERVICE_FAILED, "解析大模型 SSE 响应失败");
+        }
+        if (full.length() == 0) {
+            throw new BizException(ErrorCode.AI_SERVICE_FAILED, "大模型未返回有效内容");
+        }
+        return full.toString();
+    }
+}

huimv-employment/fe-integration/src/main/java/com/huimv/employment/integration/kb/KbApiProperties.java

@@ -1,6 +1,7 @@
 package com.huimv.employment.integration.kb;
 
 import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.http.HttpHeaders;
 
 /**
  * 大模型网关 HTTP 对接（知识库 {@code /api/v1/kb/**}、对话 {@code /v1/models}、{@code /v1/chat/completions}），绑定 {@code fe.kb.*}。
@@ -17,7 +18,7 @@ public class KbApiProperties {
 
     private int port = 9107;
 
-    /** 访问令牌（配置原始 key，请求头自动加 Bearer 前缀） */
+    /** 访问令牌（暂不需要；外网远程访问时再配置 fe.kb.api-key） */
     private String apiKey = "";
 
     private String authHeaderName = "Authorization";
@@ -33,6 +34,9 @@ public class KbApiProperties {
     /** agent/messages 等非透传场景默认模型 */
     private String defaultModel = "default";
 
+    /** 上游 {@code X-Agent-Id} 默认值（见智能体接口文档） */
+    private String defaultAgentId = "default";
+
     /**
      * Markdown 模板与生成文件根目录（对应若依 ruoyi.profile）。
      * 为空时 {@link KbMarkdownGenerator} 不可用。
@@ -132,6 +136,14 @@ public class KbApiProperties {
         this.defaultModel = defaultModel;
     }
 
+    public String getDefaultAgentId() {
+        return defaultAgentId;
+    }
+
+    public void setDefaultAgentId(String defaultAgentId) {
+        this.defaultAgentId = defaultAgentId;
+    }
+
     public String getUploadPath() {
         return uploadPath;
     }
@@ -196,6 +208,18 @@ public class KbApiProperties {
         this.retryIntervalMs = retryIntervalMs;
     }
 
+    /** 是否配置了上游 Bearer 鉴权。 */
+    public boolean hasUpstreamAuth() {
+        return apiKey != null && !apiKey.trim().isEmpty();
+    }
+
+    /** 配置了 api-key 时写入 Authorization 请求头。 */
+    public void applyAuthHeader(HttpHeaders headers) {
+        if (hasUpstreamAuth()) {
+            headers.add(authHeaderName, authHeaderValue());
+        }
+    }
+
     /** 请求头鉴权值，默认 {@code Bearer {apiKey}}。 */
     public String authHeaderValue() {
         if (apiKey == null || apiKey.isEmpty()) {

huimv-employment/fe-integration/src/main/java/com/huimv/employment/integration/kb/KbOpenAiProxyService.java

@@ -6,15 +6,13 @@ import java.io.IOException;
 import java.io.OutputStream;
 
 /**
- * 大模型 OpenAI 兼容接口转发（{@code /api/version}、{@code /api/console/chat}）。
+ * 智能体网关转发（{@code GET /api/version}、{@code POST /api/console/chat}）。
  */
 public interface KbOpenAiProxyService {
 
     ResponseEntity<byte[]> getVersion();
 
-    ResponseEntity<byte[]> consoleChat(byte[] requestBody);
+    void streamConsoleChat(byte[] requestBody, String agentId, OutputStream output) throws IOException;
 
-    boolean isStreamRequest(byte[] requestBody);
-
-    void streamChatCompletions(byte[] requestBody, OutputStream output) throws IOException;
+    String collectConsoleChatReply(byte[] requestBody, String agentId);
 }

huimv-employment/fe-integration/src/main/java/com/huimv/employment/integration/kb/KbOpenAiProxyServiceImpl.java

@@ -1,7 +1,5 @@
 package com.huimv.employment.integration.kb;
 
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
 import com.huimv.employment.common.exception.BizException;
 import com.huimv.employment.common.exception.ErrorCode;
 import org.springframework.beans.factory.annotation.Qualifier;
@@ -24,21 +22,22 @@ import java.net.URL;
 import java.nio.charset.StandardCharsets;
 
 /**
- * 将 OpenAI 兼容对话/模型列表接口转发至上游大模型网关。
+ * 将智能体 {@code /api/version}、{@code /api/console/chat} 转发至上游网关。
  */
 @Service
 public class KbOpenAiProxyServiceImpl implements KbOpenAiProxyService {
 
+    private static final String HEADER_AGENT_ID = "X-Agent-Id";
     private static final String PATH_VERSION = "/api/version";
     private static final String PATH_CHAT = "/api/console/chat";
 
     private final KbApiProperties properties;
     private final RestTemplate restTemplate;
-    private final ObjectMapper objectMapper;
+    private final com.fasterxml.jackson.databind.ObjectMapper objectMapper;
 
     public KbOpenAiProxyServiceImpl(KbApiProperties properties,
                                     @Qualifier("kbRestTemplate") RestTemplate restTemplate,
-                                    ObjectMapper objectMapper) {
+                                    com.fasterxml.jackson.databind.ObjectMapper objectMapper) {
         this.properties = properties;
         this.restTemplate = restTemplate;
         this.objectMapper = objectMapper;
@@ -46,12 +45,12 @@ public class KbOpenAiProxyServiceImpl implements KbOpenAiProxyService {
 
     @Override
     public ResponseEntity<byte[]> getVersion() {
-        ensureReady();
+        ensureEnabled();
         try {
             ResponseEntity<byte[]> upstream = restTemplate.exchange(
                     properties.baseUrl() + PATH_VERSION,
                     HttpMethod.GET,
-                    new HttpEntity<>(upstreamAuthHeaders()),
+                    new HttpEntity<>(upstreamHeaders(null, false)),
                     byte[].class);
             return forward(upstream);
         } catch (HttpStatusCodeException ex) {
@@ -60,38 +59,16 @@ public class KbOpenAiProxyServiceImpl implements KbOpenAiProxyService {
     }
 
     @Override
-    public ResponseEntity<byte[]> consoleChat(byte[] requestBody) {
-        ensureReady();
-        if (requestBody == null || requestBody.length == 0) {
-            throw new BizException(ErrorCode.BAD_REQUEST, "请求体不能为空");
-        }
-        try {
-            HttpHeaders headers = upstreamAuthHeaders();
-            headers.setContentType(MediaType.APPLICATION_JSON);
-            ResponseEntity<byte[]> upstream = restTemplate.exchange(
-                    properties.baseUrl() + PATH_CHAT,
-                    HttpMethod.POST,
-                    new HttpEntity<>(requestBody, headers),
-                    byte[].class);
-            return forward(upstream);
-        } catch (HttpStatusCodeException ex) {
-            return forwardError(ex);
-        }
-    }
-
-    @Override
-    public void streamChatCompletions(byte[] requestBody, OutputStream output) throws IOException {
-        ensureReady();
-        if (requestBody == null || requestBody.length == 0) {
-            throw new BizException(ErrorCode.BAD_REQUEST, "请求体不能为空");
-        }
+    public void streamConsoleChat(byte[] requestBody, String agentId, OutputStream output) throws IOException {
+        ensureEnabled();
+        validateRequestBody(requestBody);
         HttpURLConnection conn = null;
         InputStream input = null;
         try {
             conn = openUpstreamConnection(requestBody.length);
             conn.setRequestProperty(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
             conn.setRequestProperty(HttpHeaders.ACCEPT, MediaType.TEXT_EVENT_STREAM_VALUE);
-            conn.setRequestProperty(properties.getAuthHeaderName(), properties.authHeaderValue());
+            applyUpstreamAuth(conn, agentId);
             conn.setDoOutput(true);
             try (OutputStream upstreamOut = conn.getOutputStream()) {
                 upstreamOut.write(requestBody);
@@ -100,16 +77,7 @@ public class KbOpenAiProxyServiceImpl implements KbOpenAiProxyService {
             input = status >= 400 ? conn.getErrorStream() : conn.getInputStream();
             if (input != null) {
                 if (status >= 400) {
-                    byte[] errBytes = StreamUtils.copyToByteArray(input);
-                    if (errBytes.length > 0) {
-                        String errText = new String(errBytes, StandardCharsets.UTF_8).trim();
-                        if (errText.startsWith("data:") || errText.contains("\n\n")) {
-                            output.write(errBytes);
-                            output.flush();
-                        } else {
-                            SseStreamSupport.writeDataEvent(output, errText);
-                        }
-                    }
+                    writeUpstreamError(output, input);
                 } else {
                     SseStreamSupport.pipeWithFlush(input, output);
                 }
@@ -129,16 +97,41 @@ public class KbOpenAiProxyServiceImpl implements KbOpenAiProxyService {
     }
 
     @Override
-    public boolean isStreamRequest(byte[] requestBody) {
-        if (requestBody == null || requestBody.length == 0) {
-            return false;
-        }
+    public String collectConsoleChatReply(byte[] requestBody, String agentId) {
+        ensureEnabled();
+        validateRequestBody(requestBody);
+        HttpURLConnection conn = null;
+        InputStream input = null;
         try {
-            JsonNode root = objectMapper.readTree(requestBody);
-            JsonNode stream = root.get("stream");
-            return stream != null && stream.asBoolean(false);
+            conn = openUpstreamConnection(requestBody.length);
+            conn.setRequestProperty(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
+            conn.setRequestProperty(HttpHeaders.ACCEPT, MediaType.TEXT_EVENT_STREAM_VALUE);
+            applyUpstreamAuth(conn, agentId);
+            conn.setDoOutput(true);
+            try (OutputStream upstreamOut = conn.getOutputStream()) {
+                upstreamOut.write(requestBody);
+            }
+            int status = conn.getResponseCode();
+            input = status >= 400 ? conn.getErrorStream() : conn.getInputStream();
+            if (status >= 400) {
+                throw upstreamHttpError(status, input);
+            }
+            return ConsoleChatSseParser.extractAssistantText(input, objectMapper);
+        } catch (BizException ex) {
+            throw ex;
         } catch (Exception ex) {
-            return false;
+            throw new BizException(ErrorCode.AI_SERVICE_FAILED, "调用大模型失败");
+        } finally {
+            if (input != null) {
+                try {
+                    input.close();
+                } catch (IOException ignored) {
+                    // ignore
+                }
+            }
+            if (conn != null) {
+                conn.disconnect();
+            }
         }
     }
 
@@ -152,18 +145,72 @@ public class KbOpenAiProxyServiceImpl implements KbOpenAiProxyService {
         return conn;
     }
 
-    private void ensureReady() {
+    private void applyUpstreamAuth(HttpURLConnection conn, String agentId) {
+        conn.setRequestProperty(HEADER_AGENT_ID, resolveAgentId(agentId));
+        if (properties.hasUpstreamAuth()) {
+            conn.setRequestProperty(properties.getAuthHeaderName(), properties.authHeaderValue());
+        }
+    }
+
+    private void writeUpstreamError(OutputStream output, InputStream input) throws IOException {
+        byte[] errBytes = StreamUtils.copyToByteArray(input);
+        if (errBytes.length == 0) {
+            return;
+        }
+        String errText = new String(errBytes, StandardCharsets.UTF_8).trim();
+        if (errText.startsWith("data:") || errText.contains("\n\n")) {
+            output.write(errBytes);
+            output.flush();
+        } else {
+            SseStreamSupport.writeDataEvent(output, errText);
+        }
+    }
+
+    private BizException upstreamHttpError(int status, InputStream input) throws IOException {
+        if (input != null) {
+            byte[] errBytes = StreamUtils.copyToByteArray(input);
+            if (errBytes.length > 0) {
+                String errText = new String(errBytes, StandardCharsets.UTF_8).trim();
+                if (status == 401) {
+                    String hint = properties.hasUpstreamAuth()
+                            ? "大模型鉴权失败，请检查 fe.kb.api-key"
+                            : "大模型鉴权失败";
+                    return new BizException(ErrorCode.AI_SERVICE_FAILED, hint);
+                }
+                return new BizException(ErrorCode.AI_SERVICE_FAILED,
+                        errText.length() > 200 ? errText.substring(0, 200) : errText);
+            }
+        }
+        return new BizException(ErrorCode.AI_SERVICE_FAILED, "上游返回 HTTP " + status);
+    }
+
+    private String resolveAgentId(String agentId) {
+        if (StringUtils.hasText(agentId)) {
+            return agentId.trim();
+        }
+        return StringUtils.hasText(properties.getDefaultAgentId())
+                ? properties.getDefaultAgentId().trim()
+                : "default";
+    }
+
+    private void validateRequestBody(byte[] requestBody) {
+        if (requestBody == null || requestBody.length == 0) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "请求体不能为空");
+        }
+    }
+
+    private void ensureEnabled() {
         if (!properties.isEnabled()) {
             throw new BizException(ErrorCode.AI_SERVICE_DISABLED);
         }
-        if (!StringUtils.hasText(properties.getApiKey())) {
-            throw new BizException(ErrorCode.AI_SERVICE_FAILED, "未配置大模型访问密钥 fe.kb.api-key");
-        }
     }
 
-    private HttpHeaders upstreamAuthHeaders() {
+    private HttpHeaders upstreamHeaders(String agentId, boolean requireAgentId) {
         HttpHeaders headers = new HttpHeaders();
-        headers.add(properties.getAuthHeaderName(), properties.authHeaderValue());
+        properties.applyAuthHeader(headers);
+        if (requireAgentId) {
+            headers.add(HEADER_AGENT_ID, resolveAgentId(agentId));
+        }
         return headers;
     }
 

huimv-employment/fe-integration/src/main/java/com/huimv/employment/integration/kb/KnowledgeBaseClientImpl.java

@@ -82,7 +82,7 @@ public class KnowledgeBaseClientImpl implements KnowledgeBaseClient {
     private String postMultipart(MultiValueMap<String, Object> body) {
         String url = properties.baseUrl() + "/api/v1/kb/files";
         HttpHeaders headers = new HttpHeaders();
-        headers.add(properties.getAuthHeaderName(), properties.authHeaderValue());
+        properties.applyAuthHeader(headers);
         HttpEntity<MultiValueMap<String, Object>> entity = new HttpEntity<>(body, headers);
         String raw = executeWithRetry("知识库上传", () -> {
             try {
@@ -114,7 +114,7 @@ public class KnowledgeBaseClientImpl implements KnowledgeBaseClient {
         }
         String url = properties.baseUrl() + "/api/v1/kb/files/" + encodePathSegment(kbDocId);
         HttpHeaders headers = new HttpHeaders();
-        headers.add(properties.getAuthHeaderName(), properties.authHeaderValue());
+        properties.applyAuthHeader(headers);
         HttpEntity<Void> entity = new HttpEntity<>(headers);
         executeWithRetry("知识库删除", () -> {
             try {
@@ -324,8 +324,5 @@ public class KnowledgeBaseClientImpl implements KnowledgeBaseClient {
         if (!properties.isEnabled()) {
             throw new BizException(ErrorCode.KB_SERVICE_DISABLED);
         }
-        if (!StringUtils.hasText(properties.getApiKey())) {
-            throw new BizException(ErrorCode.KB_SERVICE_FAILED, "未配置知识库访问密钥 fe.kb.api-key");
-        }
     }
 }

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/agent/AgentChatService.java

@@ -1,6 +1,5 @@
 package com.huimv.employment.service.agent;
 
-import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
@@ -10,16 +9,13 @@ import com.huimv.employment.integration.kb.KbApiProperties;
 import com.huimv.employment.integration.kb.KbOpenAiProxyService;
 import com.huimv.employment.service.agent.dto.AgentMessageRequest;
 import com.huimv.employment.service.agent.dto.AgentMessageResponse;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 
-import java.nio.charset.StandardCharsets;
 import java.util.UUID;
 
 /**
- * 小程序智能体对话：封装 OpenAI Chat Completions 调用。
+ * 小程序智能体对话：封装 {@code POST /api/console/chat} 调用。
  */
 @Service
 public class AgentChatService {
@@ -44,71 +40,34 @@ public class AgentChatService {
                 ? request.getConversationId()
                 : UUID.randomUUID().toString().replace("-", "");
 
-        byte[] body = buildChatRequest(request.getMessage());
-        ResponseEntity<byte[]> upstream = kbOpenAiProxyService.consoleChat(body);
-        if (!upstream.getStatusCode().is2xxSuccessful()) {
-            throw new BizException(ErrorCode.AI_SERVICE_FAILED, extractUpstreamError(upstream));
-        }
+        byte[] body = buildChatRequest(userId, conversationId, request.getMessage());
+        String reply = kbOpenAiProxyService.collectConsoleChatReply(body, kbApiProperties.getDefaultAgentId());
 
-        String reply = parseReply(upstream.getBody());
         AgentMessageResponse response = new AgentMessageResponse();
         response.setReply(reply);
         response.setConversationId(conversationId);
         return response;
     }
 
-    private byte[] buildChatRequest(String userMessage) {
+    private byte[] buildChatRequest(Long userId, String sessionId, String userMessage) {
         try {
             ObjectNode root = objectMapper.createObjectNode();
-            root.put("model", kbApiProperties.getDefaultModel());
-            root.put("stream", false);
 
-            ArrayNode messages = root.putArray("messages");
-            ObjectNode system = messages.addObject();
-            system.put("role", "system");
-            system.put("content", SYSTEM_PROMPT);
+            ArrayNode input = root.putArray("input");
+            ObjectNode userMsg = input.addObject();
+            userMsg.put("role", "user");
+            ArrayNode userContent = userMsg.putArray("content");
+            ObjectNode userText = userContent.addObject();
+            userText.put("type", "text");
+            userText.put("text", SYSTEM_PROMPT + "\n\n" + userMessage);
 
-            ObjectNode user = messages.addObject();
-            user.put("role", "user");
-            user.put("content", userMessage);
+            root.put("session_id", sessionId);
+            root.put("user_id", String.valueOf(userId));
+            root.put("channel", "console");
 
             return objectMapper.writeValueAsBytes(root);
         } catch (Exception ex) {
             throw new BizException(ErrorCode.INTERNAL_ERROR);
         }
     }
-
-    private String parseReply(byte[] body) {
-        if (body == null || body.length == 0) {
-            throw new BizException(ErrorCode.AI_SERVICE_FAILED, "大模型返回空响应");
-        }
-        try {
-            JsonNode root = objectMapper.readTree(body);
-            JsonNode choices = root.get("choices");
-            if (choices == null || !choices.isArray() || choices.isEmpty()) {
-                throw new BizException(ErrorCode.AI_SERVICE_FAILED, "大模型响应格式异常");
-            }
-            JsonNode content = choices.get(0).path("message").path("content");
-            if (content.isMissingNode() || !StringUtils.hasText(content.asText())) {
-                throw new BizException(ErrorCode.AI_SERVICE_FAILED, "大模型未返回有效内容");
-            }
-            return content.asText();
-        } catch (BizException ex) {
-            throw ex;
-        } catch (Exception ex) {
-            throw new BizException(ErrorCode.AI_SERVICE_FAILED, "解析大模型响应失败");
-        }
-    }
-
-    private String extractUpstreamError(ResponseEntity<byte[]> upstream) {
-        byte[] body = upstream.getBody();
-        if (body == null || body.length == 0) {
-            return "上游返回 HTTP " + upstream.getStatusCode().value();
-        }
-        String text = new String(body, StandardCharsets.UTF_8);
-        if (upstream.getStatusCode() == HttpStatus.UNAUTHORIZED) {
-            return "大模型鉴权失败，请检查 fe.kb.api-key";
-        }
-        return text.length() > 200 ? text.substring(0, 200) : text;
-    }
 }