增加与ai大模型对话

huimv-employment/fe-api/src/main/java/com/huimv/employment/config/AsyncConfiguration.java

@@ -0,0 +1,9 @@
+package com.huimv.employment.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableAsync;
+
+@Configuration
+@EnableAsync
+public class AsyncConfiguration {
+}

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

@@ -0,0 +1,16 @@
+package com.huimv.employment.integration.kb;
+
+/**
+ * 调用智能体意图分类接口（v2 §6.4.5，BE → Agent）。
+ */
+public interface KbIntentClassificationClient {
+
+    /**
+     * 对用户消息进行意图分类。
+     *
+     * @param userMessage 用户首条消息
+     * @param agentId     智能体标识，可为 null
+     * @return 分类结果 summary；上游不可用时返回 {@code null} 以触发本地兜底
+     */
+    String classify(String userMessage, String agentId);
+}

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

@@ -0,0 +1,100 @@
+package com.huimv.employment.integration.kb;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+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.StringUtils;
+import org.springframework.web.client.RestClientException;
+import org.springframework.web.client.RestTemplate;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * 转发至智能体 {@code POST /api/mcp/conversation/classify-intent}。
+ */
+@Service
+public class KbIntentClassificationClientImpl implements KbIntentClassificationClient {
+
+    private static final Logger log = LoggerFactory.getLogger(KbIntentClassificationClientImpl.class);
+
+    private static final String HEADER_AGENT_ID = "X-Agent-Id";
+    private static final String PATH_CLASSIFY = "/api/mcp/conversation/classify-intent";
+
+    private final KbApiProperties properties;
+    private final RestTemplate restTemplate;
+    private final ObjectMapper objectMapper;
+
+    public KbIntentClassificationClientImpl(KbApiProperties properties,
+                                              @Qualifier("kbRestTemplate") RestTemplate restTemplate,
+                                              ObjectMapper objectMapper) {
+        this.properties = properties;
+        this.restTemplate = restTemplate;
+        this.objectMapper = objectMapper;
+    }
+
+    @Override
+    public String classify(String userMessage, String agentId) {
+        if (!properties.isEnabled() || !StringUtils.hasText(userMessage)) {
+            return null;
+        }
+        try {
+            Map<String, Object> body = new LinkedHashMap<>();
+            body.put("user_message", userMessage.trim());
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            properties.applyAuthHeader(headers);
+            headers.add(HEADER_AGENT_ID, resolveAgentId(agentId));
+            ResponseEntity<String> response = restTemplate.exchange(
+                    properties.baseUrl() + PATH_CLASSIFY,
+                    HttpMethod.POST,
+                    new HttpEntity<>(body, headers),
+                    String.class);
+            return parseSummary(response.getBody());
+        } catch (RestClientException ex) {
+            log.debug("上游意图分类不可用，将使用本地兜底：{}", ex.getMessage());
+            return null;
+        } catch (Exception ex) {
+            log.warn("解析上游意图分类响应失败：{}", ex.getMessage());
+            return null;
+        }
+    }
+
+    private String parseSummary(String raw) throws Exception {
+        if (!StringUtils.hasText(raw)) {
+            return null;
+        }
+        JsonNode root = objectMapper.readTree(raw.trim());
+        JsonNode data = root.path("data");
+        if (!data.isMissingNode() && data.has("summary")) {
+            return textValue(data.get("summary"));
+        }
+        if (root.has("summary")) {
+            return textValue(root.get("summary"));
+        }
+        return null;
+    }
+
+    private static String textValue(JsonNode node) {
+        if (node == null || node.isNull()) {
+            return null;
+        }
+        String text = node.asText(null);
+        return StringUtils.hasText(text) ? text.trim() : null;
+    }
+
+    private String resolveAgentId(String agentId) {
+        if (StringUtils.hasText(agentId)) {
+            return agentId.trim();
+        }
+        return properties.getDefaultAgentId();
+    }
+}

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/conversation/ConversationChatService.java

@@ -19,15 +19,18 @@ public class ConversationChatService {
 
     private final ConversationService conversationService;
     private final ConversationMessageService conversationMessageService;
+    private final ConversationIntentService conversationIntentService;
     private final KbOpenAiProxyService kbOpenAiProxyService;
     private final ObjectMapper objectMapper;
 
     public ConversationChatService(ConversationService conversationService,
                                    ConversationMessageService conversationMessageService,
+                                   ConversationIntentService conversationIntentService,
                                    KbOpenAiProxyService kbOpenAiProxyService,
                                    ObjectMapper objectMapper) {
         this.conversationService = conversationService;
         this.conversationMessageService = conversationMessageService;
+        this.conversationIntentService = conversationIntentService;
         this.kbOpenAiProxyService = kbOpenAiProxyService;
         this.objectMapper = objectMapper;
     }
@@ -41,7 +44,12 @@ public class ConversationChatService {
         String userText = request.getMessage().trim();
         byte[] upstreamBody = buildUpstreamBody(conversation, userId, userText);
 
-        conversationMessageService.saveUserMessage(conversation.getId(), userText);
+        boolean firstUserMessage = conversationMessageService.isFirstUserMessage(conversation.getId());
+        conversationMessageService.saveUserMessage(conversation.getId(), userText, !firstUserMessage);
+        if (firstUserMessage) {
+            conversationIntentService.classifyAndUpdateTitleAsync(
+                    conversation.getConversationNo(), userText, agentId);
+        }
         String assistantText = kbOpenAiProxyService.streamConsoleChatCollecting(
                 upstreamBody, agentId, output, objectMapper);
         conversationMessageService.saveAssistantMessage(conversation.getId(), assistantText);

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/conversation/ConversationIntentClassifier.java

@@ -0,0 +1,63 @@
+package com.huimv.employment.service.conversation;
+
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+/**
+ * 本地意图分类兜底（上游智能体不可用时使用）。
+ */
+@Component
+public class ConversationIntentClassifier {
+
+    private static final String TYPE_EMPLOYMENT = "employment";
+    private static final String TYPE_KNOWLEDGE = "knowledge";
+    private static final String TYPE_ORDER = "order";
+    private static final String TYPE_COST = "cost";
+    private static final String TYPE_ATTENDANCE = "attendance";
+    private static final String TYPE_EMERGENCY = "emergency";
+
+    public String classify(String userMessage) {
+        if (!StringUtils.hasText(userMessage)) {
+            return TYPE_EMPLOYMENT;
+        }
+        String text = userMessage.trim();
+
+        if (containsAny(text, "紧急", "事故", "工伤", "投诉")) {
+            return TYPE_EMERGENCY;
+        }
+        if (containsAny(text, "考勤", "打卡", "签到", "到岗")) {
+            return TYPE_ATTENDANCE;
+        }
+        if (containsAny(text, "订单", "进度", "流程", "到哪", "状态")) {
+            return TYPE_ORDER;
+        }
+        if (containsAny(text, "成本", "测算", "工资", "发薪", "发工资", "多少钱", "费用", "税")) {
+            return TYPE_COST;
+        }
+        if (containsAny(text, "政策", "合规", "怎么", "什么是", "如何", "规定")) {
+            return TYPE_KNOWLEDGE;
+        }
+        if (containsAny(text, "招", "招聘", "搬运", "临时工", "用工", "小时工", "仓库", "人数")) {
+            return TYPE_EMPLOYMENT;
+        }
+        return summarizeAsOther(text);
+    }
+
+    private static boolean containsAny(String text, String... keywords) {
+        for (String keyword : keywords) {
+            if (text.contains(keyword)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /** other 类型：截取 4-12 字作为自定义摘要 */
+    private static String summarizeAsOther(String text) {
+        String normalized = text.replaceAll("\\s+", "");
+        if (normalized.length() <= 12) {
+            return normalized;
+        }
+        return normalized.substring(0, 12);
+    }
+}

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/conversation/ConversationIntentService.java

@@ -0,0 +1,123 @@
+package com.huimv.employment.service.conversation;
+
+import com.huimv.employment.dao.entity.FeConversation;
+import com.huimv.employment.dao.mapper.FeConversationMapper;
+import com.huimv.employment.integration.kb.KbIntentClassificationClient;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import java.time.LocalDateTime;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * 会话意图分类与标题更新（v2 §2.3）。
+ * <p>分类能力在智能体侧；本服务仅作为客户端调用智能体 {@code classify-intent}，并落库更新会话标题。</p>
+ */
+@Service
+public class ConversationIntentService {
+
+    private static final Logger log = LoggerFactory.getLogger(ConversationIntentService.class);
+
+    private static final Set<String> STANDARD_INTENTS = Collections.unmodifiableSet(new HashSet<>(Arrays.asList(
+            "employment", "knowledge", "order", "cost", "attendance", "emergency"
+    )));
+
+    private final ConversationService conversationService;
+    private final FeConversationMapper feConversationMapper;
+    private final KbIntentClassificationClient kbIntentClassificationClient;
+    private final ConversationIntentClassifier conversationIntentClassifier;
+
+    public ConversationIntentService(ConversationService conversationService,
+                                       FeConversationMapper feConversationMapper,
+                                       KbIntentClassificationClient kbIntentClassificationClient,
+                                       ConversationIntentClassifier conversationIntentClassifier) {
+        this.conversationService = conversationService;
+        this.feConversationMapper = feConversationMapper;
+        this.kbIntentClassificationClient = kbIntentClassificationClient;
+        this.conversationIntentClassifier = conversationIntentClassifier;
+    }
+
+    /**
+     * 首条消息后异步分类并更新标题，不阻塞主对话流。
+     */
+    @Async
+    public void classifyAndUpdateTitleAsync(String sessionId, String userMessage, String agentId) {
+        try {
+            classifyAndUpdateTitle(sessionId, userMessage, agentId);
+        } catch (Exception ex) {
+            log.warn("异步意图分类失败 sessionId={}: {}", sessionId, ex.getMessage());
+        }
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    void classifyAndUpdateTitle(String sessionId, String userMessage, String agentId) {
+        FeConversation conversation = conversationService.requireBySessionId(sessionId);
+        String summary = resolveSummary(userMessage, agentId);
+        applyClassification(conversation, summary, userMessage);
+    }
+
+    private String resolveSummary(String userMessage, String agentId) {
+        String upstream = kbIntentClassificationClient.classify(userMessage, agentId);
+        if (StringUtils.hasText(upstream)) {
+            return upstream.trim();
+        }
+        return conversationIntentClassifier.classify(userMessage);
+    }
+
+    private void applyClassification(FeConversation conversation, String summary, String userMessage) {
+        String chatType = resolveChatType(summary);
+        String title = resolveTitle(summary, userMessage);
+
+        FeConversation update = new FeConversation();
+        update.setId(conversation.getId());
+        update.setChatType(chatType);
+        update.setTitle(title);
+        update.setUpdateTime(LocalDateTime.now());
+        feConversationMapper.updateById(update);
+        log.debug("会话 {} 意图分类完成 summary={} title={}", conversation.getConversationNo(), summary, title);
+    }
+
+    private String resolveChatType(String summary) {
+        if (STANDARD_INTENTS.contains(summary)) {
+            return summary;
+        }
+        return "employment";
+    }
+
+    private String resolveTitle(String summary, String userMessage) {
+        if (!STANDARD_INTENTS.contains(summary)) {
+            return truncateTitle(summary);
+        }
+        switch (summary) {
+            case "employment":
+                return truncateTitle(StringUtils.hasText(userMessage) ? userMessage : "用工需求咨询");
+            case "knowledge":
+                return "知识咨询";
+            case "order":
+                return "订单管理";
+            case "cost":
+                return truncateTitle(StringUtils.hasText(userMessage) ? userMessage : "成本测算");
+            case "attendance":
+                return "现场考勤";
+            case "emergency":
+                return "紧急事件";
+            default:
+                return truncateTitle(userMessage);
+        }
+    }
+
+    private static String truncateTitle(String text) {
+        if (!StringUtils.hasText(text)) {
+            return null;
+        }
+        String trimmed = text.trim();
+        return trimmed.length() <= 200 ? trimmed : trimmed.substring(0, 200);
+    }
+}

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/conversation/ConversationMessageService.java

@@ -63,11 +63,30 @@ public class ConversationMessageService {
 
     @Transactional(rollbackFor = Exception.class)
     public void saveUserMessage(Long conversationId, String userText) {
+        saveUserMessage(conversationId, userText, true);
+    }
+
+    /**
+     * @param refreshTitle 为 false 时仅刷新 last_message_at，标题由意图分类异步写入
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public void saveUserMessage(Long conversationId, String userText, boolean refreshTitle) {
         if (conversationId == null || !StringUtils.hasText(userText)) {
             return;
         }
         insertMessage(conversationId, ROLE_USER, userText.trim());
-        conversationService.refreshAfterMessage(conversationId, userText);
+        conversationService.refreshAfterMessage(conversationId, refreshTitle ? userText : null);
+    }
+
+    /** 当前会话是否尚无 user 消息（用于首条消息意图分类） */
+    public boolean isFirstUserMessage(Long conversationId) {
+        if (conversationId == null) {
+            return false;
+        }
+        Long count = feConversationMessageMapper.selectCount(new LambdaQueryWrapper<FeConversationMessage>()
+                .eq(FeConversationMessage::getConversationId, conversationId)
+                .eq(FeConversationMessage::getRole, ROLE_USER));
+        return count == null || count == 0L;
     }
 
     @Transactional(rollbackFor = Exception.class)