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

qianbao
1 parent 834944fa
Showing 7 changed files with 331 additions and 38 deletions
src/main/java/com/xly/agent/SystemPromptGenerator.java
src/main/java/com/xly/entity/ParamRule.java
src/main/java/com/xly/entity/ToolMeta.java
src/main/java/com/xly/mapper/ToolMetaMapper.java
src/main/java/com/xly/service/XlyErpService.java
src/main/java/com/xly/tool/DynamicToolProvider.java
src/main/java/com/xly/util/JsonUtils.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;
+import com.xly.entity.ParamRule;
+import com.xly.entity.UserSceneSession;
+
+import java.util.List;
+
+public class SystemPromptGenerator {
+
+    public static String generate(String toolName, UserSceneSession session) {
+        StringBuilder sb = new StringBuilder();
+
+        sb.append("你是一个无情的参数提取器，不是聊天助手。\n\n");
+        sb.append("【核心任务】\n");
+        sb.append("从用户输入中提取参数，并立即调用工具 ").append(toolName).append("。\n\n");
+        sb.append("【绝对指令】\n");
+        sb.append("1. 严禁与用户对话，严禁输出任何纯文本回复。\n");
+        sb.append("2. 无论参数缺失多么严重，都必须直接调用工具，缺失字段填空字符串或0。\n");
+        sb.append("3. 不要引导用户，后端程序会处理引导逻辑。\n\n");
+        sb.append("【参数提取规则】\n");
+        sb.append("用户输入格式为 \"参数名: 值\" 或 \"参数名 值\"，你必须识别参数名并提取对应的值。\n\n");
+        sb.append("【可提取的参数列表】\n");
+        List<ParamRule> dynamicParamRuleAll = session.getCurrentTool().getParamRuleListAll();
+        // 从参数定义中提取
+        for (ParamRule paramRule : dynamicParamRuleAll) {
+            sb.append("- ").append(paramRule.getSParam()).append("\n");
+        }
+        sb.append("\n【提取示例】\n");
+        // 动态生成示例（取前3个参数作为示例）
+        int count = 0;
+        for (ParamRule paramRule : dynamicParamRuleAll) {
+            if (count++ >= 3) break;
+            sb.append("- 用户输入 \"").append(paramRule.getSParam()).append(": {值}\" → 提取 ").append(paramRule.getSParam()).append("\n");
+        }
+
+        if(ObjectUtil.isNotEmpty(session.getArgs())){
+            sb.append("【已提取参数】\n");
+            sb.append(JSON.toJSONString(session.getArgs(), JSONWriter.Feature.PrettyFormat));
+        }
+        sb.append("\n【工具调用规则】\n");
+        sb.append("1. 每次只调用一次工具\n");
+        sb.append("2. 调用后立即停止，不要重复调用\n");
+        sb.append("3. 不要总结，不要回复用户，只调用工具");
+
+        return sb.toString();
+    }
+}
 \ No newline at end of file
@@ -14,6 +14,7 @@ import java.time.LocalDateTime;
 @Data
 public class ParamRule {
     private Integer iOrder;
+    private String sId;
     private String sParamValue;
     private String sParentId;
     private String sParam;
@@ -28,5 +29,9 @@ public class ParamRule {
     private Boolean bTipModel;
     private Boolean bEmpty;
     private Boolean bConfirmAfter;
+    private String sDynamicParamRuleSql;
+    private String sDynamicParam;
+    private String sDynamicParamName;
+    private Boolean bDynamicParam = false;
  
 }
@@ -46,6 +46,7 @@ public class ToolMeta {
     private List<ParamRule> paramRuleList;//模型
     private List<ParamRule> paramRuleListCheck;//需要校验
     private List<ParamRule> paramRuleListAll;//所有的
+    private List<ParamRule> dynamicParamRule;//动态参数
     private LocalDateTime tMakeDate;
     private String sVectorfiled;
     private String sVectorjson;
@@ -15,5 +15,4 @@ public interface ToolMetaMapper {
     // XML配置方式
     @Select("SELECT A.* FROM ai_tool AS A order by iOrder")
     List<ToolMeta> findAll();
-
 }
 \ No newline at end of file
@@ -362,6 +362,11 @@ public class XlyErpService {
                     //重新生成新的aiAgent拿新的aiAgent 做选择
                     aiAgent = createConfirmeAgent(session);
                 }
+                //存在动态参数需要重新定义引导语
+                if(ObjectUtil.isNotEmpty(session.getCurrentTool())&&ObjectUtil.isNotEmpty(session.getCurrentTool().getDynamicParamRule())){
+                    sSystemPrompt =  SystemPromptGenerator.generate(session.getCurrentTool().getSMethodName(),session);
+                    aiAgent = createConfirmeAgent(session);
+                }
                 Result<String> rs = aiAgent.chat(userId, input,sSystemPrompt);
                 sResponMessage = rs.content();
             }
@@ -954,7 +959,7 @@ public class XlyErpService {
                     executors.put(one.getToolSpecification(),one.getToolExecutor());
                 });
             }
-
+//            operableChatMemoryProvider.clearSpecifiedMemory(session.getUserId());
             aiAgent = AiServices.builder(ErpAiAgent.class)
                     .chatModel(chatModel)
                     .chatMemoryProvider(operableChatMemoryProvider)
@@ -974,13 +979,18 @@ public class XlyErpService {
         if(ObjectUtil.isNotEmpty(dataList)){
             dataList.forEach(one->{
                 immediateReturnToolNames.add(one.getsName());
-                executors.put(one.getToolSpecification(),one.getToolExecutor());
+                if(ObjectUtil.isNotEmpty(session.getCurrentTool()) && ObjectUtil.isNotEmpty(session.getCurrentTool().getDynamicParamRule())){
+                    ToolSpecification spec = dynamicToolProvider.buildToolSpecification(session.getCurrentTool());
+                    session.getCurrentTool().setDynamicParamRule(new ArrayList<>());
+                    executors.put(spec,one.getToolExecutor());
+                }else{
+                    executors.put(one.getToolSpecification(),one.getToolExecutor());
+                }
             });
         }
-        ChatMemory chatMemory = operableChatMemoryProvider.get(session.getUserId());
+        operableChatMemoryProvider.clearSpecifiedMemory(session.getUserId());
         ErpAiAgent aiAgent = AiServices.builder(ErpAiAgent.class)
                 .chatModel(chatModel)
-                .chatMemory(chatMemory)
                 .chatMemoryProvider(operableChatMemoryProvider)
                 .tools(executors,immediateReturnToolNames)
                 .build();
 package com.xly.tool;
  
  
+import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.BooleanUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONArray;
 import cn.hutool.json.JSONUtil;
 import com.alibaba.fastjson2.JSONObject;
 import com.fasterxml.jackson.core.type.TypeReference;
  
 import com.fasterxml.jackson.databind.ObjectMapper;
  
-import com.xly.agent.AgentSystemPrompt;
 import com.xly.config.OperableChatMemoryProvider;
 import com.xly.constant.*;
 import com.xly.entity.*;
 import com.xly.exception.dto.BusinessException;
-import com.xly.exception.dto.DataException;
 import com.xly.mapper.ParamRuleMapper;
 import com.xly.mapper.ToolMetaMapper;
 import com.xly.service.DynamicExeDbService;
@@ -25,27 +25,22 @@ import com.xly.util.*;
 import dev.langchain4j.agent.tool.*;
  
 import dev.langchain4j.data.message.*;
-
-import dev.langchain4j.memory.ChatMemory;
-
 import dev.langchain4j.model.chat.request.json.JsonObjectSchema;
-import dev.langchain4j.model.chat.request.json.JsonSchema;
 import dev.langchain4j.service.tool.*;
  
  
-import lombok.Getter;
 import lombok.RequiredArgsConstructor;
  
-import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
  
-import org.apache.ibatis.javassist.expr.NewArray;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
  
 import java.util.*;
  
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
  
@@ -188,8 +183,13 @@ public class DynamicToolProvider implements ToolProvider {
             if(ObjectUtil.isEmpty(args)) args = new HashMap<>();
             Map<String, Object> finalArgs = args;
             argsNew.forEach((k, v)->{
-                //获取对应的英文参数
-                List<ParamRule> data = meta.getParamRuleList().stream().filter(one->one.getSParam().equals(k)).collect(Collectors.toUnmodifiableList());
+                //需要移除的老的参数
+                List<ParamRule> data = meta.getParamRuleList().stream().filter(
+                        one-> one.getSParam().equals(k)
+                        && ObjectUtil.isNotEmpty(v)
+                        && !"0".equals(v)
+                        && !"\"\"".equals(v)
+                ).collect(Collectors.toUnmodifiableList());
                 if(ObjectUtil.isNotEmpty(data) && data.size()>0){
                     finalArgs.remove(data.get(0).getSParamValue());
                     finalArgs.remove(data.get(0).getSParam());
@@ -198,7 +198,6 @@ public class DynamicToolProvider implements ToolProvider {
                     finalArgs.put(k,v);
                 }
             });
-
             // 2 【补全动态参数】动态参数补全
             try{
                 args = applyValues(args, meta.getParamRuleListCheck());
@@ -213,6 +212,19 @@ public class DynamicToolProvider implements ToolProvider {
             // 2.1 【自动补全】应用参数的默认值
             List<ParamRule> paramRuleData = meta.getParamRuleListAll();
             args = applyDefaultValues(args, paramRuleData);
+            //存入已采集参数
+            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));
+            }
             //客户选择行号转sSLaveId
             if(ObjectUtil.isNotEmpty(args)
                     &&(
@@ -222,6 +234,7 @@ public class DynamicToolProvider implements ToolProvider {
             ){
                 doSetSlaveIdToArgs( args, session);
             }
+            //存入已采集参数
             session.setArgs(args);
             // 3. 【自动校验】检查必填项
             List<String> missing = checkRequiredParams(args, paramRuleData);
@@ -238,6 +251,192 @@ public class DynamicToolProvider implements ToolProvider {
         };
     }
  
+    /***
+     * @Author 钱豹
+     * @Date 22:50 2026/6/28
+     * @Param [args, session]
+     * @return void
+     * @Description 获取动态参数
+     **/
+    private List<ParamRule> doSetParamgetArgsAfter(Map<String,Object> argsNew,UserSceneSession session){
+        //获取当前方法
+        ToolMeta tool = session.getCurrentTool();
+        Map<String, Object> argsOld = session.getArgs();
+        Map<String, Object> args = DeepCopyUtils.deepCopy(argsNew);
+        if(ObjectUtil.isEmpty(argsOld)){
+            argsOld = new HashMap<>();
+        }
+        //根据新录入的参数获取规则
+        AtomicReference<List<ParamRule>> paramRuleDataAll = new AtomicReference<>(tool.getParamRuleListAll());
+        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())
+        ).collect(Collectors.toUnmodifiableList());
+        List<ParamRule> dynamicParamRule = new ArrayList<>();
+        //为空的时候需要重新插入 不为空 表示之前已经放过了
+        if(ObjectUtil.isNotEmpty(paramRuleData)){
+            Map<String, Object> finalArgsOld = argsOld;
+            paramRuleData.forEach(one->{
+                //根据新参数获取需要填写参数
+                Map<String,Object> searMap = new HashMap<>();
+                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());
+                List<ParamRule> paramRuleList = tool.getParamRuleList().stream().filter(d->
+                        !one.getSParam().equals(d.getSDynamicParam())
+                                ||(one.getSParam().equals(d.getSDynamicParam()) && one.getSParamValue().equals(d.getSParamValue()))
+                ).collect(Collectors.toUnmodifiableList());
+                List<ParamRule> paramRuleListCheck = tool.getParamRuleListCheck().stream().filter(d->
+                        !one.getSParam().equals(d.getSDynamicParam())
+                                ||(one.getSParam().equals(d.getSDynamicParam()) && one.getSParamValue().equals(d.getSParamValue()))
+                ).collect(Collectors.toUnmodifiableList());
+                paramRuleDataAllNew = deduplicateByParamValue(paramRuleDataAllNew);
+                paramRuleList = deduplicateByParamValue(paramRuleList);
+                paramRuleListCheck = deduplicateByParamValue(paramRuleListCheck);
+                session.getCurrentTool().setParamRuleList(paramRuleList);
+                session.getCurrentTool().setParamRuleListAll(paramRuleDataAllNew);
+                session.getCurrentTool().setParamRuleListCheck(paramRuleListCheck);
+//                paramRuleDataAll.set(paramRuleDataAllNew);
+                List<ParamRule> paramRuleDataD = paramRuleDataAll.get().stream().filter(d-> searMap.get(one.getSParam()).equals(d.getSDynamicParam())).collect(Collectors.toUnmodifiableList());
+                //如果不存在的加入方法参数中
+                if(ObjectUtil.isEmpty(paramRuleDataD)){
+                    String sValue = searMap.get(one.getSParam()).toString();
+                    List<String> addValue = new ArrayList<>();
+                    if(JSONUtil.isTypeJSONArray(sValue)){
+                        addValue = JSONUtil.toList(sValue,String.class);
+                    }else{
+                        addValue.add(sValue);
+                    }
+                    for(String sVaule:addValue){
+                        searMap.put("sRuleId",one.getSId());
+                        searMap.put("sTooId",one.getSParentId());
+                        searMap.put("sParam",one.getSParam());
+                        searMap.put("sParamValue",sVaule);
+//                        searMap.put("sParamValue",one.getSParamValue());
+                        searMap.put("sParamName",one.getSParam());
+                        String sSql = one.getSDynamicParamRuleSql();
+                        searMap.put("argsNew",JSONObject.toJSONString(args));
+                        searMap.put("argsAll",JSONObject.toJSONString(finalArgsOld));
+                        //如果不是SELECT 开头
+                        List<Map<String,Object>> selectData = new ArrayList<>();
+                        List<Map<String,Object>> dynamicParamRuleOne = new ArrayList<>();
+                        if(sSql.replaceAll(" ","").toLowerCase().startsWith("select")
+                                || sSql.replaceAll(" ","").toLowerCase().startsWith("call")){
+                            selectData = this.dynamicExeDbService.findSql(searMap, sSql);
+                            String sData = (ObjectUtil.isNotEmpty(selectData)
+                                    && ObjectUtil.isNotEmpty(selectData.get(0).get("sData")))?selectData.get(0).get("sData").toString():StrUtil.EMPTY;
+                            if(ObjectUtil.isNotEmpty(sData)){
+                                dynamicParamRuleOne = JsonUtils.toList(sData,Map.class);
+                            }
+                        }else{
+                            //表示过程走自定义参数
+
+                        }
+                        if(ObjectUtil.isNotEmpty(dynamicParamRuleOne)){
+                            //转换成BEAN
+                            //添加到方法中去
+                            List<ParamRule> paramRuleDataAllAdd = tool.getParamRuleListAll().stream().collect(Collectors.toList());
+                            List<ParamRule> paramRuleListAdd = tool.getParamRuleList().stream().collect(Collectors.toList());
+                            List<ParamRule> paramRuleListCheckAdd = tool.getParamRuleListCheck().stream().collect(Collectors.toList());
+                            if(ObjectUtil.isEmpty(paramRuleDataAllAdd)){
+                                paramRuleDataAllAdd = new ArrayList<>();
+                            }
+                            if(ObjectUtil.isEmpty(paramRuleListAdd)){
+                                paramRuleListAdd = new ArrayList<>();
+                            }
+                            if(ObjectUtil.isEmpty(paramRuleListCheckAdd)){
+                                paramRuleListCheckAdd = new ArrayList<>();
+                            }
+                            List<ParamRule> finalParamRuleDataAllAdd = paramRuleDataAllAdd;
+                            List<ParamRule> finalParamRuleListAdd = paramRuleListAdd;
+                            List<ParamRule> finalParamRuleListCheckAdd = paramRuleListCheckAdd;
+                            dynamicParamRuleOne.forEach(dynamicParamRuleData->{
+                                ParamRule paramRule =  BeanUtil.toBean(dynamicParamRuleData,ParamRule.class);
+                                dynamicParamRule.add(paramRule);
+                                try{
+                                    finalParamRuleDataAllAdd.add(paramRule);
+                                    finalParamRuleListAdd.add(paramRule);
+                                    if(paramRule.getBEmpty()){
+                                        finalParamRuleListCheckAdd.add(paramRule);
+                                    }
+                                }catch (Exception e){
+                                    e.printStackTrace();
+                                }
+                            });
+                            if(ObjectUtil.isNotEmpty(paramRuleDataAllAdd)){
+                                paramRuleDataAllAdd = deduplicateByParamValue(paramRuleDataAllAdd);
+                                session.getCurrentTool().setParamRuleListAll(paramRuleDataAllAdd);
+                            }
+                            if(ObjectUtil.isNotEmpty(paramRuleListAdd)){
+                                paramRuleListAdd = deduplicateByParamValue(paramRuleListAdd);
+                                session.getCurrentTool().setParamRuleList(paramRuleListAdd);
+                            }
+                            if(ObjectUtil.isNotEmpty(paramRuleListCheckAdd)){
+                                paramRuleListCheckAdd = deduplicateByParamValue(paramRuleListCheckAdd);
+                                session.getCurrentTool().setParamRuleListCheck(paramRuleListCheckAdd);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return dynamicParamRule;
+    }
+    /***
+     * @Author 钱豹
+     * @Date 0:58 2026/7/2
+     * @Param [source, one]
+     * @return java.util.List<com.xly.entity.ParamRule>
+     * @Description 去重
+     **/
+    private List<ParamRule> deduplicateByParamValue(List<ParamRule> source) {
+        if (source == null || source.isEmpty()) {
+            return new ArrayList<>();
+        }
+        return source.stream()
+                .collect(Collectors.toMap(
+                        ParamRule::getSParamValue,  // 根据 sParamValue 去重
+                        Function.identity(),
+                        (existing, replacement) -> existing  // 保留第一个
+                ))
+                .values()
+                .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){
         Map<Integer,Map<String,Object>> data  = session.getCurrentRowData();
         List<String> sSlaveIds = new ArrayList<>();
@@ -335,7 +534,7 @@ public class DynamicToolProvider implements ToolProvider {
     }
  
  
-    private ToolSpecification buildToolSpecification(ToolMeta meta) {
+    public ToolSpecification buildToolSpecification(ToolMeta meta) {
         ToolSpecification.Builder builder = ToolSpecification.builder()
                 .name(meta.getSMethodNo());
  
@@ -373,7 +572,7 @@ public class DynamicToolProvider implements ToolProvider {
                 if (paramDesc == null || paramDesc.isEmpty()) {
                     continue;
                 }
-                String sRuleCost = getConstMeg(paramRule);
+//                String sRuleCost = getConstMeg(paramRule);
                 switch (paramType.toLowerCase()) {
                     case "string":
                         schemaBuilder.addStringProperty(paramDesc, paramDesc);
@@ -522,7 +721,6 @@ public class DynamicToolProvider implements ToolProvider {
             argsOld = new HashMap<>();
         }
         Map<String, Object> args = session.getArgs();
-
         List<String> missing = checkRequiredParams(args, paramRuleDataCheck);
         if (!missing.isEmpty()) {
             String askMsg = buildAskUserMessage(meta, missing,args);
@@ -635,7 +833,7 @@ public class DynamicToolProvider implements ToolProvider {
         markdown.append("请确认是否执行").append(sName).append("操作？请回复:&emsp;&emsp;").append("**<a href=\"#\" data-action=\"reset\" data-text=\"确认\">确认</a>**").append("&emsp;")
                 .append("**<a href=\"#\" data-action=\"reset\"  data-text=\"取消\">取消</a>**");
     }
-
+    //添加参数 中英文
     private Map<String, Object> transformationArgs(Map<String, Object> args, List<ParamRule> paramDefs) {
         Map<String, Object> result = new HashMap<>(args);
         paramDefs.forEach(pd->{
@@ -643,7 +841,7 @@ public class DynamicToolProvider implements ToolProvider {
             String sValue = pd.getSParamValue();
             Boolean bCheck = result.containsKey(name) && ObjectUtil.isNotEmpty(result.get(name));
             Boolean bCheck2 = result.containsKey(sValue) && ObjectUtil.isNotEmpty(result.get(sValue));
-            if (!bCheck2 && bCheck ) {
+            if (!bCheck2 && bCheck) {
                 result.put(sValue,args.get(name));
             }
             if(RuleCode.CONST.getCode().equals(pd.getSRule()) && ObjectUtil.isNotEmpty(result.get(sValue))){
@@ -658,7 +856,6 @@ public class DynamicToolProvider implements ToolProvider {
         });
         return result;
     }
-
     private Map<String, Object> applyValues(Map<String, Object> args, List<ParamRule> paramDefsCheck) {
         Map<String, Object> result = new HashMap<>(args);
         result = transformationArgs( result, paramDefsCheck);
@@ -762,29 +959,45 @@ public class DynamicToolProvider implements ToolProvider {
  
     private List<String> checkRequiredParams(Map<String, Object> args, List<ParamRule> paramDefs) {
         Map<String,Object> returnMap = transformationArgs( args, paramDefs);
-        return paramDefs.stream()
-                .filter(pd -> Boolean.TRUE.equals(pd.getBEmpty()) && pd.getBTipModel())
-                .filter(pd -> checkMiss( returnMap, pd))
-                .map(ParamRule::getSParam)
+        List<ParamRule> paramDefsCheck = paramDefs.stream()
+                .filter(pd -> !"sDynamicPart".equals(pd.getSParamValue())).collect(Collectors.toUnmodifiableList());
+              paramDefsCheck = paramDefsCheck.stream()
+                .filter(pd -> Boolean.TRUE.equals(pd.getBEmpty()) && pd.getBTipModel()).collect(Collectors.toUnmodifiableList());
+              paramDefsCheck = paramDefsCheck.stream()
+                .filter(pd -> checkMiss( returnMap, pd)).collect(Collectors.toUnmodifiableList());
+        return paramDefsCheck.stream().map(ParamRule::getSParam)
                 .toList();
     }
  
+    /***
+     * @Author 钱豹
+     * @Date 13:53 2026/7/1
+     * @Param [returnMap, pd]
+     * @return java.lang.Boolean
+     * @Description 校验是否参数缺失
+     **/
     private Boolean checkMiss(Map<String,Object> returnMap,ParamRule pd) {
         if(ObjectUtil.isEmpty(returnMap)){
             returnMap = new HashMap<>();
         }
-        Boolean bBhcs = (ObjectUtil.isEmpty(returnMap.get(pd.getSParam())));
-        Boolean bDbZero = false;
-        if(pd.getSParamValue().startsWith("d")){
-            try{
-                String sParam = pd.getSParam().toString();
-                Object sParamV = returnMap.get(sParam);
-                bDbZero = (ObjectUtil.isEmpty(sParamV) || 0 ==Double.valueOf(sParamV.toString()));
-            }catch (Exception e){
-                bDbZero = true;
+        if(pd.getBEmpty()){
+            if(pd.getSParamValue().startsWith("d") && returnMap.get(pd.getSParam()) instanceof Number) {
+                try {
+                    String sParam = pd.getSParam().toString();
+                    Object sParamV = returnMap.get(sParam);
+                    return (ObjectUtil.isEmpty(sParamV) || 0 == Double.valueOf(sParamV.toString()));
+                } catch (Exception e) {
+                    return true;
+                }
+            }else{
+                try {
+                    return ObjectUtil.isEmpty(returnMap.get(pd.getSParam())) && ObjectUtil.isEmpty(returnMap.get(pd.getSParamValue()));
+                } catch (Exception e) {
+                    return true;
+                }
             }
         }
-        return  bDbZero || bBhcs  || (!returnMap.containsKey(pd.getSParamValue()) || (ObjectUtil.isEmpty(returnMap.get(pd.getSParamValue()))));
+        return false;
     }
  
     /***
@@ -837,6 +1050,14 @@ 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();
@@ -1297,6 +1518,9 @@ public class DynamicToolProvider implements ToolProvider {
         StringBuilder sb = new StringBuilder();
         sb.append("缺少参数请补全：\n");
         List<ParamRule> paramRuleData = meta.getParamRuleList();
+        if(ObjectUtil.isNotEmpty(meta.getDynamicParamRule())){
+            paramRuleData.addAll(meta.getDynamicParamRule());
+        }
         for (String name : missing) {
             paramRuleData.stream()
                     .filter(pd -> pd.getSParam().equals(name))
@@ -6,6 +6,7 @@ import com.fasterxml.jackson.databind.type.TypeFactory;
  
 import java.io.IOException;
 import java.util.List;
+import java.util.Map;
  
 public class JsonUtils {
  
@@ -21,7 +22,7 @@ public class JsonUtils {
     }
  
     // JSON字符串转List
-    public static <T> List<T> toList(String json, Class<T> clazz) {
+    public static <T> List<T> toList(String json, Class<Map> clazz) {
         try {
             CollectionType listType = TypeFactory.defaultInstance()
                     .constructCollectionType(List.class, clazz);