增加与ai大模型对话

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

@@ -0,0 +1,44 @@
+package com.huimv.employment.controller.mp;
+
+import com.huimv.employment.common.web.R;
+import com.huimv.employment.security.LoginUser;
+import com.huimv.employment.security.LoginUserHolder;
+import com.huimv.employment.service.agent.AgentChatService;
+import com.huimv.employment.service.agent.dto.AgentMessageRequest;
+import com.huimv.employment.service.agent.dto.AgentMessageResponse;
+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.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 小程序智能体对话接口。
+ * <p>
+ * 封装大模型 Chat Completions 调用，返回统一 {@link R} 格式；底层复用 {@code fe-integration} 的 KB 代理。
+ * </p>
+ */
+@RestController
+@RequestMapping("/api/v1/mp/agent")
+@Tag(name = "智能体", description = "AI 对话，需 JWT 鉴权")
+@SecurityRequirement(name = "Authorization")
+public class AgentController {
+
+    private final AgentChatService agentChatService;
+
+    public AgentController(AgentChatService agentChatService) {
+        this.agentChatService = agentChatService;
+    }
+
+    @PostMapping("/messages")
+    @Operation(summary = "发送消息并获取 AI 回复")
+    public R<AgentMessageResponse> sendMessage(@Validated @RequestBody AgentMessageRequest request) {
+        LoginUser loginUser = LoginUserHolder.require();
+        AgentMessageResponse response = agentChatService.chat(
+                loginUser.getUserId(), loginUser.getUserType(), request);
+        return R.ok(response);
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.huimv.employment.controller.mp;
+
+import com.huimv.employment.integration.kb.KbOpenAiProxyService;
+import com.huimv.employment.integration.kb.SseStreamSupport;
+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.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+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>
+ */
+@RestController
+@RequestMapping("/api/v1/mp/ai")
+@Tag(name = "AI 对话", description = "OpenAI 兼容代理，需 JWT 鉴权")
+@SecurityRequirement(name = "Authorization")
+public class AiProxyController {
+
+    private final KbOpenAiProxyService kbOpenAiProxyService;
+
+    public AiProxyController(KbOpenAiProxyService kbOpenAiProxyService) {
+        this.kbOpenAiProxyService = kbOpenAiProxyService;
+    }
+
+    @GetMapping("/models")
+    @Operation(summary = "获取可用模型列表（OpenAI 兼容）")
+    public ResponseEntity<byte[]> models() {
+        return kbOpenAiProxyService.listModels();
+    }
+
+    @PostMapping(value = "/chat/completions", consumes = MediaType.APPLICATION_JSON_VALUE)
+    @Operation(summary = "对话补全（OpenAI 兼容，支持 SSE 流式）")
+    public void chatCompletions(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;
+        }
+        ResponseEntity<byte[]> upstream = kbOpenAiProxyService.chatCompletions(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());
+        }
+        byte[] respBody = upstream.getBody();
+        if (respBody != null && respBody.length > 0) {
+            response.getOutputStream().write(respBody);
+        }
+    }
+}

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

@@ -41,3 +41,13 @@ fe:
       template-code: ${ALIYUN_SMS_TEMPLATE_CODE:}
       template-param-name: code
       endpoint: dysmsapi.aliyuncs.com
+  kb:
+    enabled: true
+    scheme: http
+    host: harrison1.iask.in
+    port: 9107
+    api-key: ${FE_KB_API_KEY:}
+    default-model: default
+    connect-timeout-ms: 15000
+    read-timeout-ms: 120000
+    stream-read-timeout-ms: 300000

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

@@ -9,6 +9,8 @@ spring:
 fe:
   sms:
     mock-enabled: true
+  kb:
+    enabled: false
 
 springdoc:
   api-docs:

huimv-employment/fe-common/src/main/java/com/huimv/employment/common/exception/ErrorCode.java

@@ -51,6 +51,12 @@ public enum ErrorCode {
     /** 企业：仅 enterprise 身份可访问 */
     ENTERPRISE_ONLY(40303, "仅企业用户可访问"),
 
+    /** AI：大模型网关已关闭 */
+    AI_SERVICE_DISABLED(50301, "AI 服务未启用"),
+
+    /** AI：调用上游大模型失败 */
+    AI_SERVICE_FAILED(50003, "AI 服务调用失败，请稍后再试"),
+
     /** 通用：未预期的系统异常 */
     INTERNAL_ERROR(500, "系统繁忙，请稍后再试");
 

huimv-employment/fe-integration/src/main/java/com/huimv/employment/integration/config/IntegrationAutoConfiguration.java

@@ -1,5 +1,6 @@
 package com.huimv.employment.integration.config;
 
+import com.huimv.employment.integration.kb.KbApiProperties;
 import com.huimv.employment.integration.sms.SmsProperties;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Configuration;
@@ -8,6 +9,6 @@ import org.springframework.context.annotation.Configuration;
  * fe-integration 模块自动配置：注册第三方集成相关的配置属性类。
  */
 @Configuration
-@EnableConfigurationProperties(SmsProperties.class)
+@EnableConfigurationProperties({SmsProperties.class, KbApiProperties.class})
 public class IntegrationAutoConfiguration {
 }

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

@@ -0,0 +1,130 @@
+package com.huimv.employment.integration.kb;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * 大模型网关 HTTP 对接（OpenAI 兼容 {@code /v1/models}、{@code /v1/chat/completions}），绑定 {@code fe.kb.*}。
+ */
+@ConfigurationProperties(prefix = "fe.kb")
+public class KbApiProperties {
+
+    /** 是否启用远程调用（为 false 时接口返回业务错误，便于无对端环境） */
+    private boolean enabled = true;
+
+    private String scheme = "http";
+
+    private String host = "localhost";
+
+    private int port = 9107;
+
+    /** 访问令牌（配置原始 key，请求头自动加 Bearer 前缀） */
+    private String apiKey = "";
+
+    private String authHeaderName = "Authorization";
+
+    /** agent/messages 等非透传场景默认模型 */
+    private String defaultModel = "default";
+
+    private int connectTimeoutMs = 15000;
+
+    private int readTimeoutMs = 120000;
+
+    /** 对话流式 SSE（stream=true）读超时 */
+    private int streamReadTimeoutMs = 300000;
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    public String getScheme() {
+        return scheme;
+    }
+
+    public void setScheme(String scheme) {
+        this.scheme = scheme;
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public void setHost(String host) {
+        this.host = host;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public void setPort(int port) {
+        this.port = port;
+    }
+
+    public String getApiKey() {
+        return apiKey;
+    }
+
+    public void setApiKey(String apiKey) {
+        this.apiKey = apiKey;
+    }
+
+    public String getAuthHeaderName() {
+        return authHeaderName;
+    }
+
+    public void setAuthHeaderName(String authHeaderName) {
+        this.authHeaderName = authHeaderName;
+    }
+
+    public String getDefaultModel() {
+        return defaultModel;
+    }
+
+    public void setDefaultModel(String defaultModel) {
+        this.defaultModel = defaultModel;
+    }
+
+    public int getConnectTimeoutMs() {
+        return connectTimeoutMs;
+    }
+
+    public void setConnectTimeoutMs(int connectTimeoutMs) {
+        this.connectTimeoutMs = connectTimeoutMs;
+    }
+
+    public int getReadTimeoutMs() {
+        return readTimeoutMs;
+    }
+
+    public void setReadTimeoutMs(int readTimeoutMs) {
+        this.readTimeoutMs = readTimeoutMs;
+    }
+
+    public int getStreamReadTimeoutMs() {
+        return streamReadTimeoutMs;
+    }
+
+    public void setStreamReadTimeoutMs(int streamReadTimeoutMs) {
+        this.streamReadTimeoutMs = streamReadTimeoutMs;
+    }
+
+    /** 请求头鉴权值，默认 {@code Bearer {apiKey}}。 */
+    public String authHeaderValue() {
+        if (apiKey == null || apiKey.isEmpty()) {
+            return "";
+        }
+        String k = apiKey.trim();
+        if (k.regionMatches(true, 0, "Bearer ", 0, 7)) {
+            return k;
+        }
+        return "Bearer " + k;
+    }
+
+    public String baseUrl() {
+        return scheme + "://" + host + ":" + port;
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.huimv.employment.integration.kb;
+
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.client.SimpleClientHttpRequestFactory;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * 大模型网关 HTTP 客户端自动配置。
+ */
+@Configuration
+@EnableConfigurationProperties(KbApiProperties.class)
+public class KbAutoConfiguration {
+
+    @Bean("kbRestTemplate")
+    public RestTemplate kbRestTemplate(KbApiProperties properties) {
+        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
+        factory.setConnectTimeout(properties.getConnectTimeoutMs());
+        factory.setReadTimeout(properties.getReadTimeoutMs());
+        return new RestTemplate(factory);
+    }
+}

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

@@ -0,0 +1,20 @@
+package com.huimv.employment.integration.kb;
+
+import org.springframework.http.ResponseEntity;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * 大模型 OpenAI 兼容接口转发（{@code /v1/models}、{@code /v1/chat/completions}）。
+ */
+public interface KbOpenAiProxyService {
+
+    ResponseEntity<byte[]> listModels();
+
+    ResponseEntity<byte[]> chatCompletions(byte[] requestBody);
+
+    boolean isStreamRequest(byte[] requestBody);
+
+    void streamChatCompletions(byte[] requestBody, OutputStream output) throws IOException;
+}

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

@@ -0,0 +1,192 @@
+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;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StreamUtils;
+import org.springframework.util.StringUtils;
+import org.springframework.web.client.HttpStatusCodeException;
+import org.springframework.web.client.RestTemplate;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * 将 OpenAI 兼容对话/模型列表接口转发至上游大模型网关。
+ */
+@Service
+public class KbOpenAiProxyServiceImpl implements KbOpenAiProxyService {
+
+    private static final String PATH_MODELS = "/v1/models";
+    private static final String PATH_CHAT = "/v1/chat/completions";
+
+    private final KbApiProperties properties;
+    private final RestTemplate restTemplate;
+    private final ObjectMapper objectMapper;
+
+    public KbOpenAiProxyServiceImpl(KbApiProperties properties,
+                                    @Qualifier("kbRestTemplate") RestTemplate restTemplate,
+                                    ObjectMapper objectMapper) {
+        this.properties = properties;
+        this.restTemplate = restTemplate;
+        this.objectMapper = objectMapper;
+    }
+
+    @Override
+    public ResponseEntity<byte[]> listModels() {
+        ensureReady();
+        try {
+            ResponseEntity<byte[]> upstream = restTemplate.exchange(
+                    properties.baseUrl() + PATH_MODELS,
+                    HttpMethod.GET,
+                    new HttpEntity<>(upstreamAuthHeaders()),
+                    byte[].class);
+            return forward(upstream);
+        } catch (HttpStatusCodeException ex) {
+            return forwardError(ex);
+        }
+    }
+
+    @Override
+    public ResponseEntity<byte[]> chatCompletions(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, "请求体不能为空");
+        }
+        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());
+            conn.setDoOutput(true);
+            try (OutputStream upstreamOut = conn.getOutputStream()) {
+                upstreamOut.write(requestBody);
+            }
+            int status = conn.getResponseCode();
+            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);
+                        }
+                    }
+                } else {
+                    SseStreamSupport.pipeWithFlush(input, output);
+                }
+            }
+        } finally {
+            if (input != null) {
+                try {
+                    input.close();
+                } catch (IOException ignored) {
+                    // ignore
+                }
+            }
+            if (conn != null) {
+                conn.disconnect();
+            }
+        }
+    }
+
+    @Override
+    public boolean isStreamRequest(byte[] requestBody) {
+        if (requestBody == null || requestBody.length == 0) {
+            return false;
+        }
+        try {
+            JsonNode root = objectMapper.readTree(requestBody);
+            JsonNode stream = root.get("stream");
+            return stream != null && stream.asBoolean(false);
+        } catch (Exception ex) {
+            return false;
+        }
+    }
+
+    private HttpURLConnection openUpstreamConnection(int contentLength) throws IOException {
+        URL url = new URL(properties.baseUrl() + PATH_CHAT);
+        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+        conn.setRequestMethod("POST");
+        conn.setConnectTimeout(properties.getConnectTimeoutMs());
+        conn.setReadTimeout(properties.getStreamReadTimeoutMs());
+        conn.setFixedLengthStreamingMode(contentLength);
+        return conn;
+    }
+
+    private void ensureReady() {
+        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() {
+        HttpHeaders headers = new HttpHeaders();
+        headers.add(properties.getAuthHeaderName(), properties.authHeaderValue());
+        return headers;
+    }
+
+    private ResponseEntity<byte[]> forward(ResponseEntity<byte[]> upstream) {
+        HttpHeaders headers = new HttpHeaders();
+        MediaType contentType = upstream.getHeaders().getContentType();
+        if (contentType != null) {
+            headers.setContentType(contentType);
+        } else {
+            headers.setContentType(MediaType.APPLICATION_JSON);
+        }
+        return new ResponseEntity<>(upstream.getBody(), headers, upstream.getStatusCode());
+    }
+
+    private ResponseEntity<byte[]> forwardError(HttpStatusCodeException ex) {
+        HttpHeaders headers = new HttpHeaders();
+        MediaType contentType = ex.getResponseHeaders() != null ? ex.getResponseHeaders().getContentType() : null;
+        if (contentType != null) {
+            headers.setContentType(contentType);
+        } else {
+            headers.setContentType(MediaType.APPLICATION_JSON);
+        }
+        byte[] body = ex.getResponseBodyAsByteArray();
+        return new ResponseEntity<>(body, headers, ex.getStatusCode());
+    }
+}

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

@@ -0,0 +1,57 @@
+package com.huimv.employment.integration.kb;
+
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Server-Sent Events（SSE）响应头与流式写出工具。
+ */
+public final class SseStreamSupport {
+
+    private static final int PIPE_BUFFER_SIZE = 4096;
+
+    private SseStreamSupport() {
+    }
+
+    public static void prepareSseResponse(HttpServletResponse response) {
+        response.setStatus(HttpServletResponse.SC_OK);
+        response.setContentType(MediaType.TEXT_EVENT_STREAM_VALUE);
+        response.setCharacterEncoding(StandardCharsets.UTF_8.name());
+        response.setHeader(HttpHeaders.CACHE_CONTROL, "no-cache, no-store, must-revalidate");
+        response.setHeader(HttpHeaders.PRAGMA, "no-cache");
+        response.setHeader(HttpHeaders.EXPIRES, "0");
+        response.setHeader(HttpHeaders.CONNECTION, "keep-alive");
+        response.setHeader("X-Accel-Buffering", "no");
+    }
+
+    public static void pipeWithFlush(InputStream input, OutputStream output) throws IOException {
+        if (input == null) {
+            return;
+        }
+        byte[] buffer = new byte[PIPE_BUFFER_SIZE];
+        int read;
+        while ((read = input.read(buffer)) != -1) {
+            output.write(buffer, 0, read);
+            output.flush();
+        }
+    }
+
+    public static void writeDataEvent(OutputStream output, String dataPayload) throws IOException {
+        if (dataPayload == null) {
+            return;
+        }
+        String line = "data: " + dataPayload + "\n\n";
+        output.write(line.getBytes(StandardCharsets.UTF_8));
+        output.flush();
+    }
+
+    public static void writeDoneEvent(OutputStream output) throws IOException {
+        writeDataEvent(output, "[DONE]");
+    }
+}

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

@@ -0,0 +1,114 @@
+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;
+import com.huimv.employment.common.exception.BizException;
+import com.huimv.employment.common.exception.ErrorCode;
+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 调用。
+ */
+@Service
+public class AgentChatService {
+
+    private static final String SYSTEM_PROMPT =
+            "你是灵活用工智能助手，帮助企业主解答用工规范、成本测算、登记流程等问题。回答应简洁、专业、可操作。";
+
+    private final KbOpenAiProxyService kbOpenAiProxyService;
+    private final KbApiProperties kbApiProperties;
+    private final ObjectMapper objectMapper;
+
+    public AgentChatService(KbOpenAiProxyService kbOpenAiProxyService,
+                            KbApiProperties kbApiProperties,
+                            ObjectMapper objectMapper) {
+        this.kbOpenAiProxyService = kbOpenAiProxyService;
+        this.kbApiProperties = kbApiProperties;
+        this.objectMapper = objectMapper;
+    }
+
+    public AgentMessageResponse chat(Long userId, String userType, AgentMessageRequest request) {
+        String conversationId = StringUtils.hasText(request.getConversationId())
+                ? request.getConversationId()
+                : UUID.randomUUID().toString().replace("-", "");
+
+        byte[] body = buildChatRequest(request.getMessage());
+        ResponseEntity<byte[]> upstream = kbOpenAiProxyService.chatCompletions(body);
+        if (!upstream.getStatusCode().is2xxSuccessful()) {
+            throw new BizException(ErrorCode.AI_SERVICE_FAILED, extractUpstreamError(upstream));
+        }
+
+        String reply = parseReply(upstream.getBody());
+        AgentMessageResponse response = new AgentMessageResponse();
+        response.setReply(reply);
+        response.setConversationId(conversationId);
+        return response;
+    }
+
+    private byte[] buildChatRequest(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);
+
+            ObjectNode user = messages.addObject();
+            user.put("role", "user");
+            user.put("content", userMessage);
+
+            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;
+    }
+}

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

@@ -0,0 +1,42 @@
+package com.huimv.employment.service.agent.dto;
+
+import javax.validation.constraints.NotBlank;
+
+/**
+ * 小程序智能体对话请求。
+ */
+public class AgentMessageRequest {
+
+    /** 企业 ID（可选，预留多企业场景） */
+    private Long enterpriseId;
+
+    /** 会话 ID，不传则自动生成 */
+    private String conversationId;
+
+    @NotBlank(message = "消息内容不能为空")
+    private String message;
+
+    public Long getEnterpriseId() {
+        return enterpriseId;
+    }
+
+    public void setEnterpriseId(Long enterpriseId) {
+        this.enterpriseId = enterpriseId;
+    }
+
+    public String getConversationId() {
+        return conversationId;
+    }
+
+    public void setConversationId(String conversationId) {
+        this.conversationId = conversationId;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+}

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

@@ -0,0 +1,51 @@
+package com.huimv.employment.service.agent.dto;
+
+/**
+ * 小程序智能体对话响应。
+ */
+public class AgentMessageResponse {
+
+    /** AI 回复文本 */
+    private String reply;
+
+    /** 会话 ID */
+    private String conversationId;
+
+    /** 下一步动作（如 show_employment_draft），一期可为空 */
+    private String nextAction;
+
+    /** 关联草稿 ID，一期可为空 */
+    private String draftId;
+
+    public String getReply() {
+        return reply;
+    }
+
+    public void setReply(String reply) {
+        this.reply = reply;
+    }
+
+    public String getConversationId() {
+        return conversationId;
+    }
+
+    public void setConversationId(String conversationId) {
+        this.conversationId = conversationId;
+    }
+
+    public String getNextAction() {
+        return nextAction;
+    }
+
+    public void setNextAction(String nextAction) {
+        this.nextAction = nextAction;
+    }
+
+    public String getDraftId() {
+        return draftId;
+    }
+
+    public void setDraftId(String draftId) {
+        this.draftId = draftId;
+    }
+}