添加未清选择改成动态引导语

qianbao
1 parent 1b14dc87
Showing 7 changed files with 332 additions and 206 deletions
src/main/java/com/xly/agent/SystemPromptGenerator.java
src/main/java/com/xly/constant/ReturnTypeCode.java
src/main/java/com/xly/entity/ParamRule.java
src/main/java/com/xly/entity/ToolMeta.java
src/main/java/com/xly/service/QuoService.java
src/main/java/com/xly/service/XlyErpService.java
src/main/java/com/xly/tool/DynamicToolProvider.java
 package com.xly.agent;
 import cn.hutool.core.util.ObjectUtil;
-import cn.hutool.json.JSONConfig;
-import cn.hutool.json.JSONUtil;
 import com.alibaba.fastjson2.JSON;
 import com.alibaba.fastjson2.JSONObject;
 import com.alibaba.fastjson2.JSONWriter;
@@ -10,6 +8,7 @@ import com.xly.entity.ParamRule;
 import com.xly.entity.UserSceneSession;
 import java.util.List;
+import java.util.stream.Collectors;
 public class SystemPromptGenerator {
@@ -50,4 +49,64 @@ public class SystemPromptGenerator {
         return sb.toString();
     }
+
+    /**
+     * 缺失参数统一提示模板：强制AI调用自定义方法，一次性回填所有参数
+     */
+    public static String buildMissParamPrompt(UserSceneSession session, List<ParamRule> paramRuleDataMiss) {
+        String methodNo = session.getCurrentTool().getSMethodNo();
+        // 1. 拼接缺失参数的描述（增加“参数名”和“英文名”的对应，方便模型映射）
+        String paramDesc = paramRuleDataMiss.stream()
+                .map(p -> String.format("- 参数名：%s (对应字段: %s)，示例值：%s",
+                        p.getSParam(), p.getSParamValue(), p.getSExampleValue()))
+                .collect(Collectors.joining("\n"));
+        // 但根据你的需求，其实 prompt 里并不需要强行插入一个空的 JSON 片段，
+        // 直接告诉模型去“合并”即可。
+        return String.format("""
+            请你根据用户最新的输入，补充缺失的参数，并带着【所有完整参数】立即发起工具调用。
+            
+            【核心执行规则】
+            1. **参数合并（至关重要）**：你必须保留上一轮对话中已经获取的参数（如 sSlaveId, operateType 等），并将用户本次提供的新参数与旧参数合并。
+            2. **必须调用工具**：必须调用工具 `%s`。绝对禁止直接输出 JSON 文本，也绝对禁止向用户反问或索要信息。
+            3. **完整调用**：请直接生成包含所有参数的 tool_calls 请求。
+            【已获取数据】
+            %s
+            【当前缺失的参数说明】
+            %s
+            """, methodNo,JSONObject.toJSONString(session.getArgs()), paramDesc);
+    }
+
+    public static String buildDynamicSystemPrompt(UserSceneSession session) {
+        // 获取当前工具编号（用于 JSON 的 name 字段）
+        String methodNo = session.getCurrentTool().getSMethodNo();
+        return """
+            【极强约束·必须执行】
+            1. 禁止说话！禁止解释！
+            2. 必须调用工具！
+            3. 只输出标准工具调用JSON！
+            
+            ### 任务背景 ###
+            用户会输入自然语言指令（如“第1行确认”、“全部合并”等）。
+            你的任务是：解析出【操作类型】和【目标行号】。
+            
+            ### 解析规则（必须严格遵守） ###
+            
+            1. **操作类型 (operateType)**：
+               - 如果用户说“全部确认”、“生成多个单据”，识别为："全部确认"
+               - 如果用户说“合并确认”、“生成一个单据”，识别为："合并确认"
+               - 其他情况，默认为："单行确认"
+            
+            2. **行号提取 (rowNumbers)**：
+               - 单选：如“第5行”，提取为 [5]
+               - 多选：如“第1、3、5行”，提取为 [1, 3, 5]
+               - 范围：如“第2到4行”，提取为 [2, 3, 4]
+               - 全选：如“全部”、“所有”，提取为 ["ALL"]
+            
+            ### 输出格式规范 ###
+            请直接输出以下 JSON（不要任何 Markdown 格式，不要 ```json）：
+            {"name": "%s", "parameters": {"operateType": "解析出的类型", "rowNumbers": [行号数组或"ALL"]}}
+            
+            """.formatted(methodNo);
+    }
+
 }
 \ No newline at end of file
@@ -14,6 +14,7 @@ public enum ReturnTypeCode {
     // 成功
     HTML("html", "html"),
+    JSON("JSON", "JSON"),
     STREAM("stream", "stream"),
     MAKEDOWN("makedown", "makedown");
@@ -3,6 +3,8 @@ package com.xly.entity;
 import lombok.Data;
 import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
 /***
  * @Author 钱豹
@@ -32,6 +34,9 @@ public class ParamRule {
     private String sDynamicParamRuleSql;
     private String sDynamicParam;
     private String sDynamicParamName;
+    private String sGroup;
+    private Object sParamConfigValue;
+    private Boolean bStandardParam;
     private Boolean bDynamicParam = false;
 }
@@ -53,5 +53,6 @@ public class ToolMeta {
     private String sVectorfiledAll;
     private String sVectorfiledShow;
     private Boolean sQue = false;
+    private Boolean bQuo = false;
 }
+package com.xly.service;
+
+import cn.hutool.core.text.CharSequenceUtil;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONUtil;
+import com.alibaba.fastjson2.JSONObject;
+import com.xly.agent.SystemPromptGenerator;
+import com.xly.constant.ErrorCode;
+import com.xly.constant.ProcedureConstant;
+import com.xly.entity.ParamRule;
+import com.xly.entity.ToolMeta;
+import com.xly.entity.UserSceneSession;
+import com.xly.exception.dto.BusinessException;
+import com.xly.mapper.DynamicExeDbMapper;
+import com.xly.util.DeepCopyUtils;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/***
+ * @Author 钱豹
+ * @Date 0:06 2026/7/7
+ * @Param
+ * @return
+ * @Description 报价业务类
+ **/
+@Slf4j
+@Service("quoService")
+@RequiredArgsConstructor
+public class QuoService {
+
+
+    /***
+     * @Author 钱豹
+     * @Date 1:25 2026/7/7
+     * @Param [argsNew, session, dynamicParamRule]
+     * @return java.util.Map<java.lang.String,java.lang.Object>
+     * @Description 报价获取参数组装
+     **/
+    public Map<String,Object> getQuoData(Map<String,Object> argsNew, UserSceneSession session, List<ParamRule> dynamicParamRule){
+        //获取当前方法
+        Map<String,Object> retData = new HashMap<>();
+        ToolMeta meta = session.getCurrentTool();
+        //放入方法动态参数中
+        meta.setDynamicParamRule(dynamicParamRule);
+        session.setCurrentTool(meta);
+        Map<String, Object> argsOld = session.getArgs();
+        Map<String, Object> args = DeepCopyUtils.deepCopy(argsNew);
+        if(ObjectUtil.isEmpty(argsOld)){
+            argsOld = new HashMap<>();
+        }
+        argsOld.putAll(args);
+        session.setArgs(argsOld);
+        List<ParamRule> dataAll = session.getCurrentTool().getParamRuleListAll();
+        //获取产品的参数
+        List<ParamRule> dataProduct = dataAll.stream().filter(one-> "产品".equals(one.getSGroup()) && !one.getBDynamicParam() ).collect(Collectors.toUnmodifiableList());
+        List<ParamRule> dataPart = dataAll.stream().filter(one-> "部件".equals(one.getSGroup()) && !one.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
+        List<ParamRule> datasDynamicPart = dataAll.stream().filter(one-> "sDynamicPart".equals(one.getSParamValue()) && !one.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
+        List<Map<String,Object>> sAll = new ArrayList<>();
+        List<Map<String,Object>> productList = new ArrayList<>();
+        Map<String, Object> finalArgsOld = argsOld;
+        dataProduct.forEach(p->{
+            Map<String,Object> product = new HashMap<>();
+            String sValue = ObjectUtil.isNotEmpty(finalArgsOld.get(p.getSParam()))? finalArgsOld.get(p.getSParam()).toString():(ObjectUtil.isNotEmpty(finalArgsOld.get(p.getSParam()))? finalArgsOld.get(p.getSParam()).toString():StrUtil.EMPTY);
+            product.put("sName",p.getSParamValue());
+            product.put("showName",p.getSParam());
+            product.put("bEmpty",p.getBEmpty());
+            product.put("sValue", sValue);
+            product.put("sParamMissMemo", p.getSParamMissMemo()==null?StrUtil.EMPTY:p.getSParamMissMemo());
+            product.put("iOrder", p.getIOrder());
+            product.put("sParamConfigValue",p.getSParamConfigValue()==null?StrUtil.EMPTY:p.getSParamConfigValue());
+            productList.add(product);
+        });
+        List<Map<String,Object>> partList = new ArrayList<>();
+        dataPart.forEach(p->{
+            Map<String,Object> part = new HashMap<>();
+            String sValue = ObjectUtil.isNotEmpty(finalArgsOld.get(p.getSParam()))?finalArgsOld.get(p.getSParam()).toString():(ObjectUtil.isNotEmpty(finalArgsOld.get(p.getSParam()))? finalArgsOld.get(p.getSParam()).toString():StrUtil.EMPTY);
+            part.put("sPartName",p.getSParam().split("-")[0]);
+            part.put("sName",p.getSParamValue());
+            part.put("showName",p.getSParam());
+            part.put("bEmpty",p.getBEmpty());
+            part.put("sValue", sValue);
+            part.put("iOrder", p.getIOrder());
+            part.put("sParamMissMemo", p.getSParamMissMemo()==null?StrUtil.EMPTY:p.getSParamMissMemo());
+            part.put("sParamConfigValue",p.getSParamConfigValue()==null?StrUtil.EMPTY:p.getSParamConfigValue());
+            //获取动态参数
+            if(ObjectUtil.isNotEmpty(sValue)){
+                List<ParamRule> dataParamDynamic = dataAll.stream().filter(d -> sValue.equals(d.getSDynamicParam()) && p.getSParamValue().equals(d.getSDynamicParamName())&&d.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
+                if(ObjectUtil.isNotEmpty(dataParamDynamic)){
+                    List<Map<String,Object>> dynamicData = new ArrayList<>();
+                    dataParamDynamic.forEach(dynamic->{
+                        Map<String,Object> dynamicOne = new HashMap<>();
+                        String dynamicValue = ObjectUtil.isNotEmpty(finalArgsOld.get(dynamic.getSParam()))?finalArgsOld.get(dynamic.getSParam()).toString():(ObjectUtil.isNotEmpty(finalArgsOld.get(dynamic.getSParam()))? finalArgsOld.get(dynamic.getSParam()).toString():StrUtil.EMPTY);
+                        dynamicOne.put("sName",dynamic.getSParamValue());
+                        dynamicOne.put("showName",dynamic.getSParam());
+                        dynamicOne.put("bEmpty",dynamic.getBEmpty());
+                        dynamicOne.put("sValue", dynamicValue);
+                        dynamicOne.put("iOrder", dynamic.getIOrder());
+                        dynamicOne.put("sParamMissMemo", dynamic.getSParamMissMemo()==null?StrUtil.EMPTY:dynamic.getSParamMissMemo());
+                        dynamicOne.put("sParamConfigValue",dynamic.getSParamConfigValue()==null?StrUtil.EMPTY:dynamic.getSParamConfigValue());
+                        //获取动态参数
+                        dynamicData.add(dynamicOne);
+                    });
+                    sAll.addAll(dynamicData);
+                    part.put("dynamicData",dynamicData);
+                }
+            }
+
+            partList.add(part);
+        });
+        //动态部件
+        if(ObjectUtil.isNotEmpty(datasDynamicPart)){
+            String datasDynamicPartValue = ObjectUtil.isNotEmpty(finalArgsOld.get("sDynamicPart"))? finalArgsOld.get("sDynamicPart").toString(): StrUtil.EMPTY;
+//                    :(ObjectUtil.isNotEmpty(finalArgsOld.get(p.getSParam()))? finalArgsOld.get(p.getSParam()).toString():StrUtil.EMPTY);
+            if(StrUtil.isNotEmpty(datasDynamicPartValue)){
+                List<String> datasDynamicPartArray = Collections.singletonList(JSONObject.parseObject(datasDynamicPartValue, String.class));
+                datasDynamicPartArray.forEach(one->{
+                    List<ParamRule> dataPartDynamic = dataAll.stream().filter(d -> one.equals(d.getSDynamicParam()) && "sDynamicPart".equals(d.getSDynamicParamName())&&d.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
+                    if(ObjectUtil.isNotEmpty(dataPartDynamic)){
+                        dataPartDynamic.forEach(dynamic->{
+                            Map<String,Object> part = new HashMap<>();
+                            String sValue = ObjectUtil.isNotEmpty(finalArgsOld.get(dynamic.getSParam()))?finalArgsOld.get(dynamic.getSParam()).toString():(ObjectUtil.isNotEmpty(finalArgsOld.get(dynamic.getSParam()))? finalArgsOld.get(dynamic.getSParam()).toString():StrUtil.EMPTY);
+                            part.put("sPartName",one);
+                            part.put("sName",dynamic.getSParamValue());
+                            part.put("showName",dynamic.getSParam());
+                            part.put("bEmpty",dynamic.getBEmpty());
+                            part.put("sValue", sValue);
+                            part.put("iOrder", dynamic.getIOrder());
+                            part.put("sParamConfigValue",dynamic.getSParamConfigValue());
+                            part.put("sParamMissMemo", dynamic.getSParamMissMemo());
+                            //获取动态参数
+                            if(ObjectUtil.isNotEmpty(sValue)){
+                                List<ParamRule> dataParamDynamic = dataAll.stream().filter(d -> sValue.equals(d.getSDynamicParam()) && dynamic.getSParamValue().equals(d.getSDynamicParamName())&&d.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
+                                if(ObjectUtil.isNotEmpty(dataParamDynamic)){
+                                    List<Map<String,Object>> dynamicData = new ArrayList<>();
+                                    dataParamDynamic.forEach(dynamicD->{
+                                        Map<String,Object> dynamicOne = new HashMap<>();
+                                        String dynamicValue = ObjectUtil.isNotEmpty(finalArgsOld.get(dynamicD.getSParam()))?finalArgsOld.get(dynamicD.getSParam()).toString():(ObjectUtil.isNotEmpty(finalArgsOld.get(dynamicD.getSParam()))? finalArgsOld.get(dynamicD.getSParam()).toString():StrUtil.EMPTY);
+                                        dynamicOne.put("sName",dynamicD.getSParamValue());
+                                        dynamicOne.put("showName",dynamicD.getSParam());
+                                        dynamicOne.put("bEmpty",dynamicD.getBEmpty());
+                                        dynamicOne.put("sValue", dynamicValue);
+                                        dynamicOne.put("iOrder", dynamicD.getIOrder());
+                                        dynamicOne.put("sParamMissMemo", dynamicD.getSParamMissMemo()==null?StrUtil.EMPTY:dynamicD.getSParamMissMemo());
+                                        dynamicOne.put("sParamConfigValue",dynamicD.getSParamConfigValue()==null?StrUtil.EMPTY:dynamicD.getSParamConfigValue());
+                                        //获取动态参数
+                                        dynamicData.add(dynamicOne);
+                                    });
+                                    sAll.addAll(dynamicData);
+                                    part.put("dynamicData",dynamicData);
+                                }
+                            }
+                            partList.add(part);
+                        });
+                    }
+                });
+            }
+        }
+        sAll.addAll(productList);
+        sAll.addAll(partList);
+        retData.put("sAll",sAll);
+        retData.put("product",productList);
+        retData.put("partList",partList);
+        return retData;
+    }
+
+}
 \ No newline at end of file
@@ -311,6 +311,7 @@ public class XlyErpService {
         String sceneName = StrUtil.EMPTY;
         String methodName = StrUtil.EMPTY;
         UserSceneSession session=null;
+        String sReturnType = ReturnTypeCode.HTML.getCode();
         try {
             // 0. 预处理用户输入：去空格、转小写（方便匹配）
             String input= InputPreprocessor.preprocessWithCommons(userInput);
@@ -363,7 +364,9 @@ public class XlyErpService {
                     aiAgent = createConfirmeAgent(session);
                 }
                 //存在动态参数需要重新定义引导语
-                if(ObjectUtil.isNotEmpty(session.getCurrentTool())&&ObjectUtil.isNotEmpty(session.getCurrentTool().getDynamicParamRule())){
+                if(ObjectUtil.isNotEmpty(session.getCurrentTool())
+                        && ObjectUtil.isNotEmpty(session.getCurrentTool().getDynamicParamRule())
+                ){
                     sSystemPrompt =  SystemPromptGenerator.generate(session.getCurrentTool().getSMethodName(),session);
                     aiAgent = createConfirmeAgent(session);
                 }
@@ -376,9 +379,10 @@ public class XlyErpService {
             ){
                 input = session.getCurrentTool().getSMethodName()+","+input;
             }
+            sReturnType = (session!=null && ObjectUtil.isNotEmpty(session.getCurrentTool()) && session.getCurrentTool().getBQuo())?ReturnTypeCode.JSON.getCode():ReturnTypeCode.HTML.getCode();
             //动态方法或返回需要提示的信息
             if(ObjectUtil.isNotEmpty(session.getSFunPrompts())){
-                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText(session.getSFunPrompts()).sReturnType(ReturnTypeCode.HTML.getCode()).build();
+                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText(session.getSFunPrompts()).sReturnType(sReturnType).build();
             }
 //          1.找到方法并且本方法带表结构描述时，需要调用 自然语言转SQL智能体
             if((ObjectUtil.isNotEmpty(session.getCurrentTool())
@@ -408,7 +412,7 @@ public class XlyErpService {
                  session.setDbType("G");
                  sResponMessage = getDynamicTableSql(session, input, userId, userInput,0,StrUtil.EMPTY,StrUtil.EMPTY,"0",StrUtil.EMPTY, aiAgent,sCleanSql);
 //                }
-                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText(sResponMessage).sReturnType(ReturnTypeCode.HTML.getCode()).dbType(session.getDbType()).dbCach(session.getDbCach()).build();
+                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText(sResponMessage).sReturnType(sReturnType).dbType(session.getDbType()).dbCach(session.getDbCach()).build();
             } else if (ObjectUtil.isNotEmpty(session.getCurrentTool())) {
                 //2.处理工具参数采集结束后业务逻辑处理
                 //调用方法,参数缺失部分提示，就直接使用方法返回的
@@ -420,16 +424,16 @@ public class XlyErpService {
                     .sCopyToSrcId(session.getSCopyToSrcId())
                     .dbType(session.getDbType())
                     .dbCach(session.getDbCach())
-                    .sReturnType(ReturnTypeCode.HTML.getCode())
+                    .sReturnType(sReturnType)
                     .build();
             }else if(session.getCurrentScene()== null ){
-                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText("当前场景:没有选择 退回当前场景 请输入 "+ CommonConstant.RESET + sResponMessage).dbType(session.getDbType()).dbCach(session.getDbCach()).sReturnType(ReturnTypeCode.HTML.getCode()).build();
+                return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText("当前场景:没有选择 退回当前场景 请输入 "+ CommonConstant.RESET + sResponMessage).dbType(session.getDbType()).dbCach(session.getDbCach()).sReturnType(sReturnType).build();
             }else{
                 return getChatiAgent (input, session);
             }
         } catch (Exception e) {
             e.printStackTrace();
-            return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText("系统异常：" + e.getMessage() + "，请稍后重试！").dbType(session.getDbType()).dbCach(session.getDbCach()).sReturnType(ReturnTypeCode.HTML.getCode()).build();
+            return AiResponseDTO.builder().sSceneName(sceneName).sMethodName(methodName).aiText("系统异常：" + e.getMessage() + "，请稍后重试！").dbType(session.getDbType()).dbCach(session.getDbCach()).sReturnType(sReturnType).build();
         }finally {
             //5.执行工具方法后，清除记忆
             if(session !=null && session.getBCleanMemory()){
@@ -13,6 +13,7 @@ import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.xly.agent.SystemPromptGenerator;
 import com.xly.config.OperableChatMemoryProvider;
 import com.xly.constant.*;
 import com.xly.entity.*;
@@ -20,6 +21,7 @@ import com.xly.exception.dto.BusinessException;
 import com.xly.mapper.ParamRuleMapper;
 import com.xly.mapper.ToolMetaMapper;
 import com.xly.service.DynamicExeDbService;
+import com.xly.service.QuoService;
 import com.xly.service.UserSceneSessionService;
 import com.xly.util.*;
 import dev.langchain4j.agent.tool.*;
@@ -52,6 +54,7 @@ public class DynamicToolProvider implements ToolProvider {
     private final ObjectMapper objectMapper;
     private final ToolMetaMapper toolMetaMapper;
     private final ParamRuleMapper paramRuleMapper;
+    private final QuoService quoService;
     private final DynamicExeDbService dynamicExeDbService;
     private final OperableChatMemoryProvider operableChatMemoryProvider;
@@ -186,9 +189,9 @@ public class DynamicToolProvider implements ToolProvider {
                 //需要移除的老的参数
                 List<ParamRule> data = meta.getParamRuleList().stream().filter(
                         one-> one.getSParam().equals(k)
-                        && ObjectUtil.isNotEmpty(v)
-                        && !"0".equals(v)
-                        && !"\"\"".equals(v)
+                                && ObjectUtil.isNotEmpty(v)
+                                && !"0".equals(v)
+                                && !"\"\"".equals(v)
                 ).collect(Collectors.toUnmodifiableList());
                 if(ObjectUtil.isNotEmpty(data) && data.size()>0){
                     finalArgs.remove(data.get(0).getSParamValue());
@@ -205,7 +208,6 @@ public class DynamicToolProvider implements ToolProvider {
                 log.error("返回信息",e);
                 String askMsg = e.getMessage();
                 session.setSFunPrompts(askMsg);
-                addSystemMessage(session, askMsg);
                 // 需要提问用户 → 抛异常停止循环
                 throw new RuntimeException(askMsg);
             }
@@ -215,35 +217,36 @@ public class DynamicToolProvider implements ToolProvider {
             //存入已采集参数
             session.setArgs(args);
             // 2.1.1 根据当前获取的新参数判断是否存在有值必填例如动态参数、动态部件
-            List<ParamRule> dynamicParamRule = doSetParamgetArgsAfter(args, session);
-            if(ObjectUtil.isNotEmpty(dynamicParamRule)){
-                String askMsg = hasDynamicParamRule(argsNew, session,dynamicParamRule);
-                session.getCurrentTool().setDynamicParamRule(dynamicParamRule);
-                //此处修改动态参数
-                session.setSFunPrompts(askMsg);
-                addSystemMessage(session, askMsg);
-                // 需要提问用户 → 抛异常停止循环
-                return String.valueOf(successResult(toolExecutionRequest, askMsg));
+            if(meta.getBQuo()){
+                List<ParamRule> dynamicParamRule = doSetParamgetArgsAfter(args, session);
+                if(ObjectUtil.isNotEmpty(dynamicParamRule)){
+                    Map<String,Object> data = quoService.getQuoData( argsNew,  session,  dynamicParamRule);
+                    data.remove("sAll");
+                    data.put("bTs",true);
+                    String askMsg = JSONObject.toJSONString(data);
+                    session.setSFunPrompts(askMsg);
+                    String sSystemPrompt = SystemPromptGenerator.buildMissParamPrompt(session,dynamicParamRule);
+                    session.setSSystemPrompt(sSystemPrompt);
+                    // 需要提问用户 → 抛异常停止循环
+                    return String.valueOf(successResult(toolExecutionRequest, askMsg));
+                }
             }
+
             //客户选择行号转sSLaveId
             if(ObjectUtil.isNotEmpty(args)
                     &&(
                     (args.containsKey("rowNumbers") && ObjectUtil.isNotEmpty(args.get("rowNumbers")))
-                    || (args.containsKey("operateType") &&  "全部确认".equals(args.get("operateType")))
-                   )&& ObjectUtil.isNotEmpty(session.getCurrentRowData())
+                            || (args.containsKey("operateType") &&  "全部确认".equals(args.get("operateType")))
+            )&& ObjectUtil.isNotEmpty(session.getCurrentRowData())
             ){
                 doSetSlaveIdToArgs( args, session);
             }
             //存入已采集参数
             session.setArgs(args);
-            // 3. 【自动校验】检查必填项
-            List<String> missing = checkRequiredParams(args, paramRuleData);
-            if (!missing.isEmpty()) {
-                // 4.1 参数缺失，生成“提问”消息，直接返给客户
-                String askMsg = buildAskUserMessage(meta, missing,args);
-                session.setSFunPrompts(askMsg);
-                addSystemMessage(session, askMsg);
-                return String.valueOf(successResult(toolExecutionRequest, askMsg));
+            //获取是否缺失参数
+            String askMsg = getMissParamMsg( meta, session, args);
+            if(ObjectUtil.isNotEmpty(askMsg)){
+                return askMsg;
             }
             // ====================== 返回时带终止指令 ======================
             String resp = JSONUtil.toJsonStr(args) ;
@@ -271,7 +274,7 @@ public class DynamicToolProvider implements ToolProvider {
         List<ParamRule> paramRuleData = tool.getParamRuleListAll();
         paramRuleData = paramRuleData.stream().filter(one->
                 ( ObjectUtil.isNotEmpty(args.get(one.getSParam()))  ||ObjectUtil.isNotEmpty(args.get(one.getSParamValue())))
-                && ObjectUtil.isNotEmpty(one.getSDynamicParamRuleSql())
+                        && ObjectUtil.isNotEmpty(one.getSDynamicParamRuleSql())
         ).collect(Collectors.toUnmodifiableList());
         List<ParamRule> dynamicParamRule = new ArrayList<>();
         //为空的时候需要重新插入 不为空 表示之前已经放过了
@@ -283,9 +286,9 @@ public class DynamicToolProvider implements ToolProvider {
                 searMap.putAll(args);
                 //新参数如果值变了移除掉之前插入的
                 List<ParamRule> paramRuleDataAllNew = paramRuleDataAll.get().stream().filter(d->
-                                !one.getSParam().equals(d.getSDynamicParam())
-                               ||(one.getSParam().equals(d.getSDynamicParam()) && one.getSParamValue().equals(d.getSParamValue()))
-                        ).collect(Collectors.toUnmodifiableList());
+                        !one.getSParam().equals(d.getSDynamicParam())
+                                ||(one.getSParam().equals(d.getSDynamicParam()) && one.getSParamValue().equals(d.getSParamValue()))
+                ).collect(Collectors.toUnmodifiableList());
                 List<ParamRule> paramRuleList = tool.getParamRuleList().stream().filter(d->
                         !one.getSParam().equals(d.getSDynamicParam())
                                 ||(one.getSParam().equals(d.getSDynamicParam()) && one.getSParamValue().equals(d.getSParamValue()))
@@ -334,7 +337,6 @@ public class DynamicToolProvider implements ToolProvider {
                             }
                         }else{
                             //表示过程走自定义参数
-
                         }
                         if(ObjectUtil.isNotEmpty(dynamicParamRuleOne)){
                             //转换成BEAN
@@ -407,34 +409,6 @@ public class DynamicToolProvider implements ToolProvider {
                 .stream()
                 .collect(Collectors.toList());
     }
-    /***
-     * @Author 钱豹
-     * @Date 23:35 2026/6/28
-     * @Param [argsNew, session]
-     * @return java.util.List<com.xly.entity.ParamRule>
-     * @Description 存在动态参数返回提示
-     **/
-    private String hasDynamicParamRule(Map<String,Object> argsNew,UserSceneSession session,List<ParamRule> dynamicParamRule){
-        //获取当前方法
-        ToolMeta meta = session.getCurrentTool();
-        meta.setDynamicParamRule(dynamicParamRule);
-        session.setCurrentTool(meta);
-        Map<String, Object> argsOld = session.getArgs();
-        Map<String, Object> args = DeepCopyUtils.deepCopy(argsNew);
-        if(ObjectUtil.isEmpty(argsOld)){
-            argsOld = new HashMap<>();
-        }
-        argsOld.putAll(args);
-        //根据获取的参数获取数据
-        List<String> dynamicParamRuleTs =  dynamicParamRule.stream().map(ParamRule::getSParam).toList();
-        session.setArgs(argsOld);
-        String askMsg = buildAskUserMessage(meta, dynamicParamRuleTs,args);
-        session.setSFunPrompts(askMsg);
-        String sSystemPrompt = buildMissParamPrompt(session,dynamicParamRule);
-        session.setSSystemPrompt(sSystemPrompt);
-        addSystemMessage(session, askMsg);
-        return askMsg;
-    }
     private void doSetSlaveIdToArgs(Map<String,Object> args,UserSceneSession session){
@@ -545,14 +519,6 @@ public class DynamicToolProvider implements ToolProvider {
                 2. 只要方法返回结果，必须停止调用
                 3. 当用户输入包含【数据确认】、确认数据、确认、第*条数据确认时，必须调用本工具
             """;
-//        String forceToolPrompt = """
-//            【工具调用规则】
-//                1. 每个自定义方法最多只能调用 1 次
-//                2. 只要方法返回结果，必须停止调用
-//                3. 禁止重复调用同一个方法
-//                4. 禁止无意义循环调用
-//                5. 当用户输入包含【数据确认】、确认数据、确认、第*条数据确认时，必须调用本工具
-//            """;
         stoolDesc.append(forceToolPrompt);
         if (ObjectUtil.isNotEmpty(meta.getStoolDesc())) {
             stoolDesc.append("MethodNo:").append(meta.getSMethodNo())
@@ -661,6 +627,8 @@ public class DynamicToolProvider implements ToolProvider {
             });
             sb.delete(sb.length()-1,sb.length());
             paramRule.setSRuleTs(sb.toString());
+            //存入动态配置
+            paramRule.setSParamConfigValue(constMap);
             return sb.toString();
         }
         return StrUtil.EMPTY;
@@ -678,6 +646,7 @@ public class DynamicToolProvider implements ToolProvider {
         if(ObjectUtil.isEmpty(data)){
             return StrUtil.EMPTY;
         }
+
         if(data.get(0).containsKey("sGroupName")){
             Map<Object, List<Map<String, Object>>> groupData = data.stream()
                     .collect(Collectors.groupingBy(map -> map.get("sGroupName")));
@@ -691,12 +660,16 @@ public class DynamicToolProvider implements ToolProvider {
                     sb.append(",");
                 }
             });
+            //放入动态配置值
+            paramRule.setSParamConfigValue(groupData);
         }else{
             data.forEach(one->{
                 if(ObjectUtil.isNotEmpty(one.get(paramRule.getSParamValue()))){
                     sb.append(one.get(paramRule.getSParamValue())).append("/");
                 }
             });
+            //放入动态配置值
+            paramRule.setSParamConfigValue(data);
         }
         if(ObjectUtil.isNotEmpty(sb)){
             sb.delete(sb.length()-1,sb.length());
@@ -712,22 +685,47 @@ public class DynamicToolProvider implements ToolProvider {
         return paramRuleDataAll;
     }
+    //校验是否缺失参数
+    private String getMissParamMsg(ToolMeta meta,UserSceneSession session, Map<String, Object> args){
+        if(meta.getBQuo()){
+            List<ParamRule> dataParamDynamic = session.getCurrentTool().getParamRuleListAll().stream().filter(d ->
+                    d.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
+            Map<String,Object> data = quoService.getQuoData(args, session, dataParamDynamic);
+            List<Map<String,Object>> sAll = (List<Map<String, Object>>) data.get("sAll");
+            List<Map<String,Object>> sEmpty = sAll.stream().filter(one-> BooleanUtil.toBoolean(one.get("bEmpty").toString())
+                    && (ObjectUtil.isEmpty(one.get("sValue")) || "0".equals(one.get("sValue")))).collect(Collectors.toUnmodifiableList());
+            if(ObjectUtil.isNotEmpty(sEmpty)){
+                data.remove("sAll");
+                data.put("bTs",true);
+                String askMsg = JSONObject.toJSONString(data);
+                session.setSFunPrompts(askMsg);
+                String sSystemPrompt = SystemPromptGenerator.buildMissParamPrompt(session,dataParamDynamic);
+                session.setSSystemPrompt(sSystemPrompt);
+                // 需要提问用户 → 抛异常停止循环
+                return askMsg;
+            }
+        }else{
+            List<String> missing = checkRequiredParams(args, meta.getParamRuleListCheck());
+            if (!missing.isEmpty()) {
+                String askMsg = buildAskUserMessage(meta, missing,args);
+                return askMsg;
+            }
+        }
+        return null;
+    }
     public String doDynamicTool(ToolMeta meta,UserSceneSession session) {
         List<ParamRule> paramRuleData = meta.getParamRuleListAll();
-        List<ParamRule> paramRuleDataCheck = meta.getParamRuleListCheck();
         Map<String, Object> argsOld = session.getArgs();
         if(ObjectUtil.isEmpty(argsOld)){
             argsOld = new HashMap<>();
         }
         Map<String, Object> args = session.getArgs();
-        List<String> missing = checkRequiredParams(args, paramRuleDataCheck);
-        if (!missing.isEmpty()) {
-            String askMsg = buildAskUserMessage(meta, missing,args);
-            addSystemMessage(session, askMsg);
+        //获取是否缺失参数
+        String askMsg = getMissParamMsg( meta, session, args);
+        if(ObjectUtil.isNotEmpty(askMsg)){
             return askMsg;
         }
-
         List<ChatMessage> chatMessage = operableChatMemoryProvider.getCurrentChatMessages(session.getUserId());
         ChatMessage userMessage = getLastUserMessage(chatMessage);
         String input = "";
@@ -750,12 +748,11 @@ public class DynamicToolProvider implements ToolProvider {
                 //合并已选择数据
                 argsOld.putAll(args);
                 session.setArgs(argsOld);
-                String askMsg = buildAskUserMessage(meta, missingAfter,args);
+                askMsg = buildAskUserMessage(meta, missingAfter,args);
                 session.setSFunPrompts(askMsg);
                 List<ParamRule> paramRuleDataMiss = getMissParamRuleAfter(args, paramRuleData);
-                String sSystemPrompt = buildMissParamPrompt(session,paramRuleDataMiss);
+                String sSystemPrompt = SystemPromptGenerator.buildMissParamPrompt(session,paramRuleDataMiss);
                 session.setSSystemPrompt(sSystemPrompt);
-                addSystemMessage(session, askMsg);
                 return askMsg;
             }
             return executeTool(meta, args, paramRuleData, session.getUserId(), session);
@@ -764,7 +761,7 @@ public class DynamicToolProvider implements ToolProvider {
         String askconfirmMsg =StrUtil.EMPTY;
         if(4== meta.getIBizType() || meta.getIBizType()==5){
             askconfirmMsg = doGetFromData( meta,args,session);
-            String sSystemPrompt = buildDynamicSystemPrompt(session);
+            String sSystemPrompt = SystemPromptGenerator.buildDynamicSystemPrompt(session);
             session.setSSystemPrompt(sSystemPrompt);
             return executeWithConfirmation(askconfirmMsg, session, meta);
         }else{
@@ -961,9 +958,9 @@ public class DynamicToolProvider implements ToolProvider {
         Map<String,Object> returnMap = transformationArgs( args, paramDefs);
         List<ParamRule> paramDefsCheck = paramDefs.stream()
                 .filter(pd -> !"sDynamicPart".equals(pd.getSParamValue())).collect(Collectors.toUnmodifiableList());
-              paramDefsCheck = paramDefsCheck.stream()
+        paramDefsCheck = paramDefsCheck.stream()
                 .filter(pd -> Boolean.TRUE.equals(pd.getBEmpty()) && pd.getBTipModel()).collect(Collectors.toUnmodifiableList());
-              paramDefsCheck = paramDefsCheck.stream()
+        paramDefsCheck = paramDefsCheck.stream()
                 .filter(pd -> checkMiss( returnMap, pd)).collect(Collectors.toUnmodifiableList());
         return paramDefsCheck.stream().map(ParamRule::getSParam)
                 .toList();
@@ -1024,10 +1021,10 @@ public class DynamicToolProvider implements ToolProvider {
     private List<ParamRule> getMissParamRuleAfter(Map<String, Object> args, List<ParamRule> paramDefs) {
         Map<String,Object> returnMap = transformationArgs( args, paramDefs);
         return paramDefs.stream()
-                    .filter(pd ->  ObjectUtil.isNotEmpty(pd.getBConfirmAfter()) && BooleanUtil.toBoolean(pd.getBConfirmAfter().toString()))
-                    .filter(pd -> (!returnMap.containsKey(pd.getSParam()) || (ObjectUtil.isEmpty(returnMap.get(pd.getSParam()))))
+                .filter(pd ->  ObjectUtil.isNotEmpty(pd.getBConfirmAfter()) && BooleanUtil.toBoolean(pd.getBConfirmAfter().toString()))
+                .filter(pd -> (!returnMap.containsKey(pd.getSParam()) || (ObjectUtil.isEmpty(returnMap.get(pd.getSParam()))))
                         && (!returnMap.containsKey(pd.getSParamValue()) || (ObjectUtil.isEmpty(returnMap.get(pd.getSParamValue()))))
-                    )
+                )
                 .toList();
     }
@@ -1050,14 +1047,7 @@ public class DynamicToolProvider implements ToolProvider {
         return sReturn;
     }
-    //参数进行处理
-    private void doArgs(ToolMeta meta, Map<String, Object> args,List<ParamRule> paramDefs) {
-        List<ParamRule> paramDefsD = paramDefs.stream().filter(one-> ObjectUtil.isNotEmpty(one.getSDynamicParamRuleSql())).collect(Collectors.toUnmodifiableList());
-
-
-
-    }
-
+    //执行工具后
     private String executeToolAfter(ToolMeta meta, Map<String, Object> args,List<ParamRule> paramDefs,UserSceneSession session) {
         String sBizContent = meta.getSBizContent();
         Integer iBizType = meta.getIBizType();
@@ -1084,7 +1074,6 @@ public class DynamicToolProvider implements ToolProvider {
                     sessA.remove("sSlaveId");
                     sessA.remove("operateType");
                     session.setArgs(sessA);
-                    addSystemMessage(session, sMsg);
                     throw new BusinessException(-1,sMsg);
                 }
                 List<Map<String,Object>> sRowData = doGetFromDataWq( meta,  args, session);
@@ -1095,8 +1084,6 @@ public class DynamicToolProvider implements ToolProvider {
                     sessA.remove("sSlaveId");
                     sessA.remove("operateType");
                     session.setArgs(sessA);
-                    //插入AI记忆
-                    addSystemMessage(session, sMsg);
                     throw new BusinessException(-1,sMsg);
                 }
                 Map<String,Object> dataOne = DeepCopyUtils.deepCopy(args);
@@ -1150,7 +1137,6 @@ public class DynamicToolProvider implements ToolProvider {
                 } else {
                     String sMsgText = "未找到对应的数据";
                     session.setSFunPrompts(sMsgText);
-                    addSystemMessage(session, sMsgText);
                     throw new BusinessException(-1,sMsgText);
                 }
             }
@@ -1161,12 +1147,6 @@ public class DynamicToolProvider implements ToolProvider {
         return "操作成功";
     }
-    private void addSystemMessage(UserSceneSession session,String sMsg){
-//        if(ObjectUtil.isNotEmpty(operableChatMemoryProvider) && ObjectUtil.isNotEmpty(operableChatMemoryProvider.get(session.getUserId()))){
-//            operableChatMemoryProvider.get(session.getUserId()).add(SystemMessage.from("上一次工具调用失败。原因：" + sMsg + "。请根据用户意图修正参数，并再次调用工具。"));
-//        }
-    }
-
     private List<Map<String,Object>> doGetFromDataWq(ToolMeta meta, Map<String, Object> args,UserSceneSession session){
         String sUrl = meta.getSendUrl();
         Map<String,Object> sBody = new HashMap<>();
@@ -1367,103 +1347,6 @@ public class DynamicToolProvider implements ToolProvider {
         return markdown.toString();
     }
-
-    /**
-     * 缺失参数统一提示模板：强制AI调用自定义方法，一次性回填所有参数
-     */
-    public String buildMissParamPrompt(UserSceneSession session, List<ParamRule> paramRuleDataMiss) {
-        String methodNo = session.getCurrentTool().getSMethodNo();
-        // 1. 拼接缺失参数的描述（增加“参数名”和“英文名”的对应，方便模型映射）
-        String paramDesc = paramRuleDataMiss.stream()
-                .map(p -> String.format("- 参数名：%s (对应字段: %s)，示例值：%s",
-                        p.getSParam(), p.getSParamValue(), p.getSExampleValue()))
-                .collect(Collectors.joining("\n"));
-        // 但根据你的需求，其实 prompt 里并不需要强行插入一个空的 JSON 片段，
-        // 直接告诉模型去“合并”即可。
-        return String.format("""
-            请你根据用户最新的输入，补充缺失的参数，并带着【所有完整参数】立即发起工具调用。
-            
-            【核心执行规则】
-            1. **参数合并（至关重要）**：你必须保留上一轮对话中已经获取的参数（如 sSlaveId, operateType 等），并将用户本次提供的新参数与旧参数合并。
-            2. **必须调用工具**：必须调用工具 `%s`。绝对禁止直接输出 JSON 文本，也绝对禁止向用户反问或索要信息。
-            3. **完整调用**：请直接生成包含所有参数的 tool_calls 请求。
-            【已获取数据】
-            %s
-            【当前缺失的参数说明】
-            %s
-            """, methodNo,JSONObject.toJSONString(session.getArgs()), paramDesc);
-    }
-
-    public String buildDynamicSystemPrompt(UserSceneSession session) {
-        // 获取当前工具编号（用于 JSON 的 name 字段）
-        String methodNo = session.getCurrentTool().getSMethodNo();
-        return """
-            【极强约束·必须执行】
-            1. 禁止说话！禁止解释！
-            2. 必须调用工具！
-            3. 只输出标准工具调用JSON！
-            
-            ### 任务背景 ###
-            用户会输入自然语言指令（如“第1行确认”、“全部合并”等）。
-            你的任务是：解析出【操作类型】和【目标行号】。
-            
-            ### 解析规则（必须严格遵守） ###
-            
-            1. **操作类型 (operateType)**：
-               - 如果用户说“全部确认”、“生成多个单据”，识别为："全部确认"
-               - 如果用户说“合并确认”、“生成一个单据”，识别为："合并确认"
-               - 其他情况，默认为："单行确认"
-            
-            2. **行号提取 (rowNumbers)**：
-               - 单选：如“第5行”，提取为 [5]
-               - 多选：如“第1、3、5行”，提取为 [1, 3, 5]
-               - 范围：如“第2到4行”，提取为 [2, 3, 4]
-               - 全选：如“全部”、“所有”，提取为 ["ALL"]
-            
-            ### 输出格式规范 ###
-            请直接输出以下 JSON（不要任何 Markdown 格式，不要 ```json）：
-            {"name": "%s", "parameters": {"operateType": "解析出的类型", "rowNumbers": [行号数组或"ALL"]}}
-            
-            """.formatted(methodNo);
-    }
-//    public String buildDynamicSystemPrompt(UserSceneSession session) {
-//        // 获取当前工具编号
-//        String methodNo = session.getCurrentTool().getSMethodNo();
-//        // 格式化表格数据（保持缩进，方便模型阅读）
-//        String rowJson = JSONUtil.toJsonPrettyStr(session.getCurrentRowData());
-//
-//        return """
-//        【极强约束·必须执行】
-//        1. 禁止说话！禁止解释！
-//        2. 必须调用工具！
-//        3. 只输出标准工具调用JSON！
-//
-//        ### 任务背景 ###
-//        用户会输入类似“第5行确认”或“确认第3条”的指令。
-//        你的任务是：解析行号 -> 在下方表格中找到对应行 -> 提取 sSlaveId -> 调用工具。
-//
-//        ### 数据源（表格 key 是行号） ###
-//        %s
-//
-//        ### 防错黄金法则（必须严格遵守） ###
-//        1. **查找阶段**：不要凭空编造 ID。必须先在“思考步骤”中明确写出：
-//           “用户输入是[xx]，提取行号[N] -> 查找表格 Key=[N] -> 对应的 sSlaveId 是 [这里填入表格里的完整数字]”
-//        2. **复制阶段**：sSlaveId 是一长串数字，请务必**直接复制**表格中的原始值，不要加省略号(...)，不要改变数字。
-//        3. **输出阶段**：只有确认复制无误后，才在 JSON 的 sSlaveId 字段中填入该值。
-//
-//        ### 输出格式规范 ###
-//        {"name": "%s", "parameters": {"operateType": "单行确认", "sSlaveId": "在这里填入你从表格中复制的ID"}}
-//
-//        ### 执行流程（一步一步来） ###
-//        1. **解析**：阅读用户输入，确定他想操作的是第几行（N）。
-//        2. **思考**：在回复的第一行，写出你的查找过程（例如：用户要求第5行...）。
-//        3. **JSON**：换行后，输出最终的工具调用 JSON。
-//
-//        【警告】
-//        如果用户要求的行号在表格中不存在，请返回错误信息，不要调用工具。
-//        """.formatted(rowJson, methodNo);
-//    }
-
     private List<Map<String, Object>> findFieldNameByChinese(List<Map<String, Object>> sAIshowfieldShow,List<Map<String, Object>> rows){
         Map<String,String> keyMappings = new HashMap<>();
         List<String> selectedKeys = new ArrayList<>();
@@ -1596,9 +1479,9 @@ public class DynamicToolProvider implements ToolProvider {
         return check  || userResponse.contains("生成")
                 || userResponse.contains("确认")
                 || (ObjectUtil.isNotEmpty(session.getArgs())
-                    && session.getArgs().containsKey("operateType")
-                    && session.getArgs().containsKey("sSlaveId")
-                    && ObjectUtil.isNotEmpty(session.getArgs().get("sSlaveId"))
-                );
+                && session.getArgs().containsKey("operateType")
+                && session.getArgs().containsKey("sSlaveId")
+                && ObjectUtil.isNotEmpty(session.getArgs().get("sSlaveId"))
+        );
     }
 }
 \ No newline at end of file