flzxsqc-demo 1.4.21 → 1.4.25

package/agent-backend/pom.xml

@@ -71,6 +71,21 @@
             <groupId>com.fasterxml.jackson.dataformat</groupId>
             <artifactId>jackson-dataformat-yaml</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.commonmark</groupId>
+            <artifactId>commonmark</artifactId>
+            <version>0.21.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.commonmark</groupId>
+            <artifactId>commonmark-ext-gfm-tables</artifactId>
+            <version>0.21.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi-ooxml</artifactId>
+            <version>5.5.1</version>
+        </dependency>
         <!-- Optional: logback and log4j binding -->
         <dependency>
             <groupId>org.springframework.boot</groupId>

package/agent-backend/src/main/java/com/example/agent/application/harness/requirements/SkillQuestionRequirementService.java

@@ -79,12 +79,19 @@ public class SkillQuestionRequirementService {
         }
         boolean needsConfirmation = Boolean.TRUE.equals(template.get("confirmation_required")) || hasDefaultRequiringConfirmation(elements, defaultsUsed);
         if (needsConfirmation) {
-            return RequirementCheckResult.needsConfirmation(confirmationQuestion(extracted), extracted, defaultsUsed);
+            return RequirementCheckResult.needsConfirmation(confirmationQuestion(extracted, defaultsUsed, primarySkill), extracted, defaultsUsed);
         }
         extracted.put("confirmed", true);
         return RequirementCheckResult.ready(extracted);
     }
 
+    public String analysisSummary(RequirementCheckResult check, SkillDefinition primarySkill) {
+        if (check == null) {
+            return "已完成原始需求分析，将按原始需求开始后续分析。";
+        }
+        return analysisSummary(check.requirements(), check.defaultsUsed(), check.missing(), primarySkill);
+    }
+
     private Map<String, Object> extractWithLlm(String query, SkillDefinition primarySkill, Map<String, Object> template) {
         ChatMessage system = new ChatMessage();
         system.setRole(ChatRole.SYSTEM);
@@ -168,15 +175,78 @@ public class SkillQuestionRequirementService {
         return false;
     }
 
-    private String confirmationQuestion(Map<String, Object> extracted) {
-        StringBuilder builder = new StringBuilder("我将按以下要素开始长耗时分析，请确认是否继续：");
+    private String confirmationQuestion(Map<String, Object> extracted,
+                                        List<Map<String, Object>> defaultsUsed,
+                                        SkillDefinition primarySkill) {
+        return analysisSummary(extracted, defaultsUsed, new ArrayList<String>(), primarySkill)
+                + "\n请确认是否继续？";
+    }
+
+    private String analysisSummary(Map<String, Object> extracted,
+                                   List<Map<String, Object>> defaultsUsed,
+                                   List<String> missing,
+                                   SkillDefinition primarySkill) {
+        StringBuilder builder = new StringBuilder("已完成原始需求分析，将按以下要素开始后续分析：");
         appendAnalysisTargets(builder, extracted);
-        builder.append("\n- 时间范围：").append(stringValue(extracted.get("time_range")));
-        builder.append("\n- 数据范围：").append(stringValue(extracted.get("data_scope")));
-        builder.append("\n- 输出形式：").append(stringValue(extracted.get("output_type")));
+        builder.append("\n- 时间范围：").append(displayValue(extracted.get("time_range")));
+        builder.append("\n- 数据范围：").append(displayValue(extracted.get("data_scope")));
+        builder.append("\n- 输出形式：").append(displayValue(extracted.get("output_type")));
+        appendDefaultsUsed(builder, defaultsUsed, primarySkill);
+        appendMissingElements(builder, missing, primarySkill);
         return builder.toString();
     }
 
+    private void appendDefaultsUsed(StringBuilder builder,
+                                    List<Map<String, Object>> defaultsUsed,
+                                    SkillDefinition primarySkill) {
+        if (defaultsUsed == null || defaultsUsed.isEmpty()) {
+            return;
+        }
+        List<String> values = new ArrayList<String>();
+        for (Map<String, Object> used : defaultsUsed) {
+            String key = stringValue(used.get("key"));
+            values.add(elementName(primarySkill, key) + "=" + displayValue(used.get("value")));
+        }
+        builder.append("\n- 已采用默认值：").append(String.join("、", values));
+    }
+
+    private void appendMissingElements(StringBuilder builder,
+                                       List<String> missing,
+                                       SkillDefinition primarySkill) {
+        if (missing == null || missing.isEmpty()) {
+            return;
+        }
+        List<String> names = new ArrayList<String>();
+        for (String key : missing) {
+            names.add(elementName(primarySkill, key));
+        }
+        builder.append("\n- 未识别项：").append(String.join("、", names));
+        builder.append("（将以原始用户需求作为分析目标继续）");
+    }
+
+    private String elementName(SkillDefinition primarySkill, String key) {
+        Map<String, Object> template = primarySkill == null ? null : primarySkill.getQuestionRequirements();
+        Object rawElements = template == null ? null : template.get("required_elements");
+        if (rawElements instanceof List) {
+            for (Object item : (List<?>) rawElements) {
+                if (!(item instanceof Map)) {
+                    continue;
+                }
+                Map<?, ?> element = (Map<?, ?>) item;
+                if (key != null && key.equals(stringValue(element.get("key")))) {
+                    String name = stringValue(element.get("name"));
+                    return name == null ? key : name;
+                }
+            }
+        }
+        return key == null ? "未知要素" : key;
+    }
+
+    private String displayValue(Object value) {
+        String text = stringValue(value);
+        return text == null || text.trim().isEmpty() ? "未识别" : text;
+    }
+
     private void normalizeAnalysisTargets(Map<String, Object> extracted, String query) {
         List<String> targets = targetList(extracted.get("analysis_targets"));
         if (targets.isEmpty() && looksLikeMultiTargetRequest(query)) {
@@ -308,7 +378,7 @@ public class SkillQuestionRequirementService {
             builder.append("\n- 分析目标：").append(targets.get(0));
             return;
         }
-        builder.append("\n- 分析目标：").append(stringValue(extracted.get("analysis_target")));
+        builder.append("\n- 分析目标：").append(displayValue(extracted.get("analysis_target")));
     }
 
     private List<String> targetList(Object raw) {

package/agent-backend/src/main/java/com/example/agent/application/service/AgentWaitingFlowService.java

@@ -15,6 +15,7 @@ import com.example.agent.domain.model.SkillDefinition;
 import com.example.agent.domain.model.chat.ChatMessage;
 import com.example.agent.domain.model.chat.ChatRole;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
 import java.time.Instant;
@@ -40,6 +41,9 @@ public class AgentWaitingFlowService {
     private final HarnessWorkflowService harnessWorkflowService;
     private final HarnessMetricsService harnessMetricsService;
 
+    @Value("${agent.analysis.requirement-feedback.interaction-enabled:false}")
+    private boolean requirementFeedbackInteractionEnabled;
+
     public AgentSession askForZeroDataLoopConfirmation(AgentSession session, AgentTurn turn) {
         CompletionDecision decision = finalAnswerGuardService.zeroDataLoopDecision(session);
         if (decision == null) {
@@ -175,6 +179,11 @@ public class AgentWaitingFlowService {
                 requirementSkill,
                 session.getGlobalContext()
         );
+        // This kill switch bypasses only the up-front requirement prompt; later safety waits remain unchanged.
+        if (!requirementFeedbackInteractionEnabled) {
+            autoContinueQuestionRequirements(session, turn, requirementSkill, check);
+            return null;
+        }
         if (!check.needsUserInput()) {
             putAnalysisRequirements(session, check.requirements());
             harnessWorkflowService.finished(session.getSessionId(), turn.getTurnId(), HarnessPhase.QUESTION_REQUIREMENT_VALIDATION, "SUCCEEDED");
@@ -208,6 +217,39 @@ public class AgentWaitingFlowService {
         return session;
     }
 
+    private void autoContinueQuestionRequirements(AgentSession session,
+                                                  AgentTurn turn,
+                                                  SkillDefinition requirementSkill,
+                                                  SkillQuestionRequirementService.RequirementCheckResult check) {
+        Map<String, Object> requirements = check.requirements() == null
+                ? new LinkedHashMap<String, Object>()
+                : new LinkedHashMap<String, Object>(check.requirements());
+        if (isBlank(requirements.get("analysis_target"))) {
+            requirements.put("analysis_target", session.getQuery());
+        }
+        requirements.put("confirmed", true);
+        putAnalysisRequirements(session, requirements);
+
+        String summary = skillQuestionRequirementService.analysisSummary(check, requirementSkill);
+        ChatMessage assistant = new ChatMessage();
+        assistant.setRole(ChatRole.ASSISTANT);
+        assistant.setContent(summary);
+        session.getTranscript().add(assistant);
+        session.setLatestAnswer(summary);
+        sessionStore.save(session);
+        runtimeEventBus.publish(session.getSessionId(), turn.getTurnId(), RuntimeEventType.ASSISTANT_MESSAGE, payload(
+                "content", summary,
+                "messageType", "REQUIREMENT_ANALYSIS",
+                "terminal", false
+        ));
+        harnessWorkflowService.finished(
+                session.getSessionId(),
+                turn.getTurnId(),
+                HarnessPhase.QUESTION_REQUIREMENT_VALIDATION,
+                "AUTO_CONTINUED"
+        );
+    }
+
     private SkillDefinition questionRequirementSkill(List<SkillDefinition> skills) {
         for (SkillDefinition skill : skills) {
             if (skill == null || skill.getQuestionRequirements() == null) {
@@ -317,6 +359,10 @@ public class AgentWaitingFlowService {
         session.setGlobalContext(globalContext);
     }
 
+    private boolean isBlank(Object value) {
+        return value == null || String.valueOf(value).trim().isEmpty();
+    }
+
     private Map<String, Object> payload(Object... items) {
         Map<String, Object> payload = new HashMap<String, Object>();
         for (int i = 0; i + 1 < items.length; i += 2) {