Administrator / xlyAi

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.JSONUtil;
import com.alibaba.fastjson2.JSONObject;
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.*;
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.*;

import dev.langchain4j.data.message.*;
import dev.langchain4j.model.chat.request.json.JsonObjectSchema;
import dev.langchain4j.service.tool.*;


import lombok.RequiredArgsConstructor;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

@Slf4j
@Service
@RequiredArgsConstructor
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;

    private final Map<String, ToolSpecificationHolder> toolCache = new ConcurrentHashMap<>();
    public final Map<String, String> sSceneIdMap = new ConcurrentHashMap<>();
    public final Map<String, List<ToolSpecificationHolder>> sceneToolCacheMap = new ConcurrentHashMap<>();
    private final List<ParamRule> paramRuleDataAll = new ArrayList<>();

    @Value("${erp.baseurl}")
    private String baseUrl;

    public void cleanAllToolProvider() {
        toolCache.clear();
        sceneToolCacheMap.clear();
        paramRuleDataAll.clear();
    }

    @jakarta.annotation.PostConstruct
    public void init() {
        List<ToolMeta> metas = toolMetaMapper.findAll();
        for (ToolMeta meta : metas) {
            try {
                doSetToolAIshowfieldShow(meta);
                ToolSpecification spec = buildToolSpecification(meta);
                ToolExecutor executor = createToolExecutor(meta);
                toolCache.put(meta.getSMethodNo(), new ToolSpecificationHolder(spec, executor,meta.getSMethodNo(),meta.getSMethodName()));
                log.info("已加载动态工具：{}", meta.getSMethodNo());
                String sceneId = meta.getSSceneId();
                List<ToolSpecificationHolder> dataList = new ArrayList<>();
                if(ObjectUtil.isNotEmpty(sceneToolCacheMap.get(sceneId))) {
                    dataList = sceneToolCacheMap.get(sceneId);
                }
                dataList.add(new ToolSpecificationHolder(spec, executor,meta.getSMethodNo(),meta.getSMethodName()));
                sceneToolCacheMap.put(sceneId, dataList);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("构建工具失败，sMethodNo={}", meta.getSMethodNo(), e);
            }
        }
    }

    @Override
    public ToolProviderResult provideTools(ToolProviderRequest request) {
        String sUserId = request.chatMemoryId().toString();
        Map<ToolSpecification, ToolExecutor> executors = new HashMap<>();
        UserSceneSession session = UserSceneSessionService.USER_SCENE_SESSION_CACHE.get(sUserId);

        // ====================== 防重复调用核心拦截 ======================
        if (session != null && (session.getToolExecuted() || StrUtil.isNotBlank(session.getSFunPrompts()))) {
            log.info("工具已执行/等待用户回复，禁止提供工具");
            return ToolProviderResult.builder().build();
        }

        List<ToolSpecificationHolder> datalist = new ArrayList<>();
        List<ToolMeta> toolMetaAll = new ArrayList<>();

        if(session.getCurrentTool() != null){
            toolMetaAll.add(session.getCurrentTool());
            log.info("使用 currentTool: {}", session.getCurrentTool().getSMethodNo());
        } else {
            toolMetaAll = session.getAuthTool();
        }

        if(ObjectUtil.isNotEmpty(toolMetaAll)){
            toolMetaAll = toolMetaAll.stream()
                    .filter(to -> to.getSSceneId().equals(sSceneIdMap.get(sUserId)))
                    .collect(Collectors.toUnmodifiableList());

            if(ObjectUtil.isNotEmpty(toolMetaAll)){
                toolMetaAll.forEach(to -> {
                    ToolSpecificationHolder holder = toolCache.get(to.getSMethodNo());
                    if (holder != null) {
                        datalist.add(holder);
                        log.debug("添加工具到提供器: {}", to.getSMethodNo());
                    } else {
                        log.warn("工具缓存缺失: {}", to.getSMethodNo());
                    }
                });
            }
        }

        datalist.forEach(holder -> {
            executors.put(holder.getToolSpecification(), holder.getToolExecutor());
        });
        log.info("provideTools 返回工具数量: {}", executors.size());
        return ToolProviderResult.builder().addAll(executors).build();
    }


    /***
     * @Author 钱豹
     * @Date 23:59 2026/5/17
     * @Param [meta]
     * @return dev.langchain4j.service.tool.ToolExecutor
     * @Description  AI  自动调用工具执行方法
     **/
    private ToolExecutor createToolExecutor(ToolMeta meta) {
        log.info("创建工具执行器: {}", meta.getSMethodNo());

        return (toolExecutionRequest, memoryId) -> {
            log.info("===== 工具执行器开始执行 =====");
            log.info("工具编号: {}", meta.getSMethodNo());
            log.info("工具名称: {}", meta.getSMethodName());
            log.info("memoryId: {}", memoryId);
            log.info("请求参数: {}", toolExecutionRequest.arguments());
            UserSceneSession session = UserSceneSessionService.USER_SCENE_SESSION_CACHE.get(memoryId.toString());
            session.setCurrentTool(meta);

            // ====================== 防重复调用：立即上锁 ======================
            session.setToolExecuted(true);
            if (StrUtil.isNotBlank(session.getSFunPrompts())) {
                // 关键：返回 工具执行失败 = 框架强制停止循环
//                throw new IllegalStateException("STOP_INVOCATION: 任务已完成，停止调用");
                return "【任务已完成】请勿重复调用工具，请直接总结结果回复用户:"+session.getSFunPrompts();
            }
            //解析参数失败
            Map<String, Object> argsNew;
            try {
                argsNew = objectMapper.readValue(toolExecutionRequest.arguments(), new TypeReference<>() {});
                log.info("解析后的参数: {}", argsNew);
            } catch (Exception e) {
                log.error("参数解析失败", e);
                // 抛异常
                throw new RuntimeException("参数解析失败，请重新输入");
            }

            //获取之前获取的参数
            Map<String, Object> args = session.getArgs();
            if(ObjectUtil.isEmpty(args)) args = new HashMap<>();
            Map<String, Object> finalArgs = args;
            argsNew.forEach((k, v)->{
                if(Validator.isValid(v)){
                    finalArgs.put(k,v);
                }
            });
            if(argsNew.containsKey("删除动态部件")){
                argsNew.put("sDynamicPartDel",argsNew.get("删除动态部件"));
            }
            if(!argsNew.containsKey("sDynamicPartDel")){
                finalArgs.remove("sDynamicPartDel");
                finalArgs.remove("删除动态部件");
            }
            // 2 【补全动态参数】动态参数补全
            try{
                args = applyValues(args, meta.getParamRuleListCheck());
            }catch (Exception e){
                log.error("返回信息",e);
                String askMsg = e.getMessage();
                session.setSFunPrompts(askMsg);
                // 需要提问用户 → 抛异常停止循环
                throw new RuntimeException(askMsg);
            }
            // 2.1 【自动补全】应用参数的默认值
            List<ParamRule> paramRuleData = meta.getParamRuleListAll();
            args = applyDefaultValues(args, paramRuleData);
            //客户选择行号转sSLaveId
            if(ObjectUtil.isNotEmpty(args)
                    &&(
                    (args.containsKey("rowNumbers") && ObjectUtil.isNotEmpty(args.get("rowNumbers")))
                            || (args.containsKey("operateType") &&  "全部确认".equals(args.get("operateType")))
            )&& ObjectUtil.isNotEmpty(session.getCurrentRowData())
            ){
                doSetSlaveIdToArgs( args, session);
            }
            //存入已采集参数
            session.setArgs(args);
            // 2.1.1 根据当前获取的新参数判断是否存在有值必填例如动态参数、动态部件
            if(meta.getBQuo()){
                List<ParamRule> dynamicParamRule = doSetParamgetArgsAfter(args, session);
                if(ObjectUtil.isNotEmpty(dynamicParamRule)){
//                    Map<String,Object> data = quoService.getQuoData( args,  session);
                    session.getCurrentTool().setDynamicParamRule(dynamicParamRule);
//                    String sSystemPrompt = SystemPromptGenerator.buildMissParamPrompt(session,dynamicParamRule);
//                    session.setSSystemPrompt(sSystemPrompt);
                }
            }
            //获取是否缺失参数
            String askMsg = getMissParamMsg( meta, session, args);
            if(ObjectUtil.isNotEmpty(askMsg)){
                return askMsg;
            }
            String resp = StrUtil.EMPTY;
            if(session.getCurrentTool().getBQuo()){
                resp  = JSONUtil.toJsonStr(session.getQuoData());
                session.setSFunPrompts(resp);
                session.getCurrentTool().setDynamicParamRule(null);
                return resp;
            }else{
                resp = JSONUtil.toJsonStr(args) ;
            }
            // ====================== 返回时带终止指令 ======================
            return String.valueOf(successResult(toolExecutionRequest, resp));
        };
    }

    /***
     * @Author 钱豹
     * @Date 22:50 2026/6/28
     * @Param [args, session]
     * @return void
     * @Description 获取动态参数
     **/
    private List<ParamRule> doSetParamgetArgsAfter(Map<String, Object> argsNew, UserSceneSession session) {
        List<ParamRule> dynamicParamRule = new ArrayList<>();
        try {
            ToolMeta tool = session.getCurrentTool();
            Map<String, Object> argsOld = session.getArgs();
            Map<String, Object> args = DeepCopyUtils.deepCopy(argsNew);

            if (ObjectUtil.isEmpty(argsOld)) {
                argsOld = new HashMap<>();
            }

            List<ParamRule> paramRuleDataAll = tool.getParamRuleListAll();

            // 1. 获取动态参数规则
            List<ParamRule> paramRuleData = paramRuleDataAll.stream()
                    .filter(one -> (ObjectUtil.isNotEmpty(args.get(one.getSParam()))
                            || ObjectUtil.isNotEmpty(args.get(one.getSParamValue())))
                            && ObjectUtil.isNotEmpty(one.getSDynamicParamRuleSql())
                            && !"sDynamicPart".equals(one.getSParamValue())
                            && !"sDynamicPartDel".equals(one.getSParamValue())
                    )
                    .collect(Collectors.toList());
            List<ParamRule> paramRuleDataAllNew = new ArrayList<>(paramRuleDataAll);
            // 2. 处理非动态参数
            if (ObjectUtil.isNotEmpty(paramRuleData)) {
                Map<String, Object> finalArgsOld = argsOld;

                for (ParamRule one : paramRuleData) {
                    Map<String, Object> searMap = new HashMap<>(args);
                    paramRuleDataAllNew.removeIf(d ->
                            one.getSParam().equals(d.getSDynamicParam())
                                    && one.getSParamValue().equals(d.getSParamValue())
                    );

                    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) {
                        List<ParamRule> paramRuleDataD = paramRuleDataAllNew.stream()
                                .filter(d -> d.getBDynamicParam()
                                        && sVaule.equals(d.getSDynamicParam())
                                        && one.getSParam().equals(d.getSDynamicParamName()))
                                .collect(Collectors.toList());

                        // 如果不存在，则添加
                        if (ObjectUtil.isEmpty(paramRuleDataD)) {
                            searMap.put("sRuleId", one.getSId());
                            searMap.put("sTooId", one.getSParentId());
                            searMap.put("sParam", one.getSParam());
                            searMap.put("sParamValue", sVaule);
                            searMap.put("sParamName", one.getSParam());
                            searMap.put("argsNew", JSONObject.toJSONString(args));
                            searMap.put("argsAll", JSONObject.toJSONString(finalArgsOld));

                            String sSql = one.getSDynamicParamRuleSql();
                            List<Map<String, Object>> dynamicParamRuleOne = new ArrayList<>();

                            if (sSql.replaceAll(" ", "").toLowerCase().startsWith("select")
                                    || sSql.replaceAll(" ", "").toLowerCase().startsWith("call")) {
                                try {
                                    List<Map<String, Object>> selectData =
                                            this.dynamicExeDbService.findSql(searMap, sSql);
                                    if (ObjectUtil.isNotEmpty(selectData)) {
                                        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);
                                        }
                                    }
                                } catch (Exception e) {
                                    log.error("执行动态参数SQL失败", e);
                                }
                            }

                            if (ObjectUtil.isNotEmpty(dynamicParamRuleOne)) {
                                for (Map<String, Object> dynamicParamRuleData : dynamicParamRuleOne) {
                                    ParamRule paramRule = BeanUtil.toBean(dynamicParamRuleData, ParamRule.class);
                                    if (!RuleCode.CONST.getCode().equals(paramRule.getSRule())
                                            && ObjectUtil.isNotEmpty(paramRule.getSParamConfig())
                                            && JSONUtil.isTypeJSON(paramRule.getSParamConfig())) {
                                        try {
                                            getConstMeg(paramRule);
                                        } catch (Exception e) {
                                            log.error("获取常量配置失败", e);
                                        }
                                    }
                                    dynamicParamRule.add(paramRule);
                                }
                            }
                        }
                    }
                }
            }

            // 3. 处理动态部件
            List<ParamRule> sDynamicPart = paramRuleDataAll.stream()
                    .filter(one -> "sDynamicPart".equals(one.getSParamValue()))
                    .collect(Collectors.toList());
            // 3. 处理动态部件
            List<ParamRule> sDynamicPartDel = paramRuleDataAll.stream()
                    .filter(one -> "sDynamicPartDel".equals(one.getSParamValue()))
                    .collect(Collectors.toList());
            //移除的动态部件
            List<String> sDynamicPartDelValue = new ArrayList<>();
            if(ObjectUtil.isNotEmpty(sDynamicPartDel)){
                ParamRule sDynamicPartOneDel = sDynamicPartDel.get(0);
                String sValueDel = ObjectUtil.isNotEmpty(args.get(sDynamicPartOneDel.getSParam()))
                        ? args.get(sDynamicPartOneDel.getSParam()).toString()
                        : StrUtil.EMPTY;
                if (ObjectUtil.isNotEmpty(sValueDel)) {
                    if (JSONUtil.isTypeJSONArray(sValueDel)) {
                        sDynamicPartDelValue = JSONUtil.toList(sValueDel, String.class);
                    } else {
                        sDynamicPartDelValue.add(sValueDel);
                    }
                }
            }
            //新增部件
            if (ObjectUtil.isNotEmpty(sDynamicPart)
                    && ObjectUtil.isNotEmpty(sDynamicPart.get(0))
                    && ObjectUtil.isNotEmpty(sDynamicPart.get(0).getSParam())) {

                ParamRule sDynamicPartOne = sDynamicPart.get(0);
                String sValue = ObjectUtil.isNotEmpty(args.get(sDynamicPartOne.getSParam()))
                        ? args.get(sDynamicPartOne.getSParam()).toString()
                        : StrUtil.EMPTY;

                if (ObjectUtil.isNotEmpty(sValue)) {
                    List<String> addValueAdd = new ArrayList<>();
                    List<String> addValueOld = new ArrayList<>();
                    Object sOldVal =  session.getArgs().get(sDynamicPart.get(0).getSParam());
                    if(ObjectUtil.isNotEmpty(sOldVal)){
                        if (JSONUtil.isTypeJSONArray(sValue)) {
                            addValueOld = JSONUtil.toList(sValue, String.class);
                        } else {
                            addValueOld.add(sValue);
                        }
                    }

                    if (JSONUtil.isTypeJSONArray(sValue)) {
                        addValueAdd = JSONUtil.toList(sValue, String.class);
                    } else {
                        addValueAdd.add(sValue);
                    }
                    addValueOld.addAll(addValueAdd);
                    addValueOld = new ArrayList<>(new LinkedHashSet<>(addValueOld));

                    //新增部件不在删除部件中的
                    List<String> finalSDynamicPartDelValue = sDynamicPartDelValue;
                    List<String> addValue = addValueOld.stream().filter(one-> !finalSDynamicPartDelValue.contains(one)).collect(Collectors.toList());
                    //反写值取SESSION
                    session.getArgs().put(sDynamicPart.get(0).getSParam(),JSONUtil.toJsonStr(addValue));
                    session.getArgs().put(sDynamicPart.get(0).getSParamValue(),JSONUtil.toJsonStr(addValue));
                    //收集当前有效的动态部件值
                    List<String> validDynamicPartValues = new ArrayList<>();
                    for (String sVal : addValue) {
                        if(!finalSDynamicPartDelValue.contains(sVal)){
                            validDynamicPartValues.add(sVal);
                        }
                        boolean exists = paramRuleDataAllNew.stream()
                                .anyMatch(d -> sVal.equals(d.getSDynamicParam()));
                        if (!exists) {
                            // 获取部件标准参数
                            List<ParamRule> sDynamicPartCheckAddCopy = paramRuleDataAll.stream()
                                    .filter(d -> ObjectUtil.isNotEmpty(d.getSGroup())
                                            && !d.getBDynamicParam()
                                            && d.getSGroup().equals("部件")
                                            && d.getBStandardParam())
                                    .map(d -> {
                                        ParamRule copy = new ParamRule();
                                        BeanUtils.copyProperties(d, copy);

                                        // 设置动态参数
                                        String paramName = d.getSParam().split("-").length > 1
                                                ? d.getSParam().split("-")[1]
                                                : d.getSParam().split("-")[0];
                                        copy.setSParam(sVal + "-" + paramName);

                                        // 拼音转换
                                        String firstLetters = "";
                                        try {
                                            firstLetters = PinyinUtil.convertToPinyin(sVal);
                                        } catch (Exception e) {
                                            log.warn("拼音转换失败: {}", sVal);
                                            firstLetters = sVal.substring(0, 1).toUpperCase();
                                        }
                                        copy.setSParamValue(firstLetters + d.getSParamValue());
                                        copy.setIOrder(d.getIOrder() + 100000);
                                        copy.setBDynamicParam(true);
                                        copy.setSDynamicParam(sVal);
                                        copy.setSDynamicParamName("sDynamicPart");
                                        return copy;
                                    })
                                    .collect(Collectors.toList());

                            if (ObjectUtil.isNotEmpty(sDynamicPartCheckAddCopy)) {
                                paramRuleDataAllNew.addAll(sDynamicPartCheckAddCopy);
                                log.info("添加了 {} 个动态部件参数，sVal={}",
                                        sDynamicPartCheckAddCopy.size(), sVal);
                            }
                        } else {
                            log.info("动态部件已存在，跳过: {}", sVal);
                        }
                    }
                    // 移除不在 addValue 中的动态部件
                    paramRuleDataAllNew = paramRuleDataAllNew.stream()
                        .filter(p -> {
                            // 如果不是动态部件参数，保留
                            if (!p.getBDynamicParam() || !"sDynamicPart".equals(p.getSDynamicParamName())) {
                                return true;
                            }
                            // 如果是动态部件参数，检查是否在有效值列表中
                            return validDynamicPartValues.contains(p.getSDynamicParam());
                        })
                        .collect(Collectors.toList());
                    log.info("移除无效动态部件后，列表大小: {}", paramRuleDataAllNew.size());
                }else{
                    //移除不是动态部件的
                    paramRuleDataAllNew = paramRuleDataAllNew.stream()
                            .filter(p -> !p.getBDynamicParam() || !"sDynamicPart".equals(p.getSDynamicParamName()))
                            .collect(Collectors.toList());
                    log.info("sValue为空，移除所有动态部件");
                }
            }
            // 4. 合并所有参数
            List<ParamRule> dataAll = new ArrayList<>(paramRuleDataAllNew);
            dataAll.addAll(dynamicParamRule);

            // 5. 去重并设置
            List<ParamRule> dynamicParamRuleAll = Validator.deduplicateByParamValue(dataAll);
            List<ParamRule> paramRuleList = dynamicParamRuleAll.stream()
                    .filter(one -> one.getBTipModel())
                    .collect(Collectors.toList());
            List<ParamRule> paramRuleListCheck = dynamicParamRuleAll.stream()
                    .filter(one -> one.getBEmpty())
                    .collect(Collectors.toList());

            session.getCurrentTool().setParamRuleListAll(dynamicParamRuleAll);
            session.getCurrentTool().setParamRuleListCheck(paramRuleListCheck);
            session.getCurrentTool().setParamRuleList(paramRuleList);

        } catch (Exception e) {
            e.printStackTrace();
            log.error("获取动态参数失败: {}", e.getMessage(), e);
        }

        return dynamicParamRule;
    }

    private void doSetSlaveIdToArgs(Map<String,Object> args,UserSceneSession session){
        Map<Integer,Map<String,Object>> data  = session.getCurrentRowData();
        List<String> sSlaveIds = new ArrayList<>();
        try{
            if(args.containsKey("operateType") &&  "全部确认".equals(args.get("operateType"))){
                data.forEach((k,v)->{
                    sSlaveIds.add(v.get("sSlaveId").toString());
                });
                return;
            }
            List<Integer> rowNumbers = (List<Integer>) args.get("rowNumbers");
            rowNumbers.forEach(one->{
                try{
                    sSlaveIds.add(data.get(one).get("sSlaveId").toString());
                }catch (Exception e){
                }
            });

        }finally {
            args.put("sSlaveId",String.join(",",sSlaveIds));
            args.remove("rowNumbers");
        }
    }

    private void doSetToolAIshowfieldShow(ToolMeta meta){
        String sToolId = meta.getSId();
        List<ParamRule> paramRuleData = getParamRuleDataAll();
        List<ParamRule> paramRuleListAll = paramRuleData.stream().filter(one-> sToolId.equals(one.getSParentId())).collect(Collectors.toUnmodifiableList());
        List<ParamRule> paramRuleList = paramRuleListAll.stream().filter(one-> one.getBTipModel()).collect(Collectors.toUnmodifiableList());
        List<ParamRule> paramRuleListCheck = paramRuleListAll.stream().filter(one->one.getBEmpty()).collect(Collectors.toUnmodifiableList());
        paramRuleList = ObjectUtil.isNotEmpty(paramRuleList)?paramRuleList:new ArrayList<>();
        if((meta.getIBizType()==4 || meta.getIBizType()==5)
                && ObjectUtil.isNotEmpty(meta.getSAIshowfield())
                && ObjectUtil.isNotEmpty(meta.getSSrcFormId())
        ){
            String[] sAIshowfield = meta.getSAIshowfield().split(",");
            List<String> mutableList  = Arrays.asList(sAIshowfield);
            List<String> sAIshowfieldArry = new ArrayList<>(mutableList);
            sAIshowfieldArry.add("sSlaveId");
            String sSrcFormId = meta.getSSrcFormId();
            StringBuffer sSql =new StringBuffer().append("SELECT 10000 AS iOrderShow,A.sChinese AS label,A.sName,A.sControlName,B.sId AS sFormcustomId,A.sName AS sId  FROM gdsconfigformslave AS A ")
                    .append("JOIN gdsconfigformmaster AS B ON A.sParentId = B.sId ")
                    .append("WHERE B.sParentId = #{sSrcFormId} AND A.sName <> '' AND INSTR(A.sControlName,'Btn')=0 AND (A.bVisible = 1 OR A.sName =#{sName}) ");
            Map<String,Object> searMap = new HashMap<>();
            searMap.put("sSrcFormId",sSrcFormId);
            searMap.put("sName","sSlaveId");
            List<Map<String,Object>> sAIshowfieldShowAll = dynamicExeDbService.findSql(searMap,sSql.toString());
            if(ObjectUtil.isNotEmpty(sAIshowfieldShowAll)){
                sAIshowfieldShowAll = sAIshowfieldShowAll.stream().filter(m-> sAIshowfieldArry.contains(m.get("sName").toString())).collect(Collectors.toUnmodifiableList());
                sAIshowfieldShowAll.forEach(one->{
                    one.put("iOrderShow",sAIshowfieldArry.indexOf(one.get("sName").toString())+1);
                });
                List<Map<String,Object>> sAIshowfieldShowData = new ArrayList<>();
                sAIshowfieldShowData.addAll(sAIshowfieldShowAll);
                sAIshowfieldShowData.sort(Comparator.comparing(h -> Integer.valueOf(h.get("iOrderShow").toString())));
                meta.setSAIshowfieldShow(sAIshowfieldShowData);
            }
            List<ParamRule> paramRuleListNew = new ArrayList<>(paramRuleList);
            for(int i=0;i<sAIshowfieldShowAll.size();i++){
                Map<String,Object> sAIshowfieldShow =  sAIshowfieldShowAll.get(i);
                List<ParamRule> one = paramRuleList.stream().filter(m->m.getSParamValue().equals(sAIshowfieldShow.get("sName"))).collect(Collectors.toUnmodifiableList());
                if(ObjectUtil.isEmpty(one)){
                    ParamRule pr = new ParamRule();
                    pr.setIOrder(i+1);
                    pr.setSParamValue(sAIshowfieldShowAll.get(i).get("sName").toString());
                    pr.setSParam(sAIshowfieldShowAll.get(i).get("label").toString());
                    pr.setBEmpty(false);
                    pr.setSType(getDefType(sAIshowfieldShowAll.get(i).get("sName").toString()));
                    if("sSlaveId".equals(sAIshowfieldShowAll.get(i).get("sName"))){
                        pr.setSParam("sSlaveId");
                    }
                    pr.setBTipModel(true);
                    paramRuleListNew.add(pr);
                }
            }
            String sendUrl = baseUrl + UrlErpConstant.getBusinessDataByFormcustomId;
            sendUrl = StrUtil.format(sendUrl,sAIshowfieldShowAll.get(0).get("sFormcustomId"),sSrcFormId);
            meta.setSendUrl(sendUrl);
            paramRuleList = paramRuleListNew;
            paramRuleListCheck = paramRuleListNew;
            paramRuleListAll = paramRuleListNew;
        }
        List<ParamRule> paramRuleListNew = new ArrayList<>(paramRuleList);
        meta.setParamRuleList(paramRuleListNew);
        meta.setParamRuleListCheck(paramRuleListCheck);
        meta.setParamRuleListAll(paramRuleListAll);
    }

    private String getDefType(String sColumn){
        if(sColumn.startsWith("d")){
            return "double";
        }else{
            return "string";
        }
    }


    public ToolSpecification buildToolSpecification(ToolMeta meta) {
        ToolSpecification.Builder builder = ToolSpecification.builder()
                .name(meta.getSMethodNo());

        StringBuffer stoolDesc = new StringBuffer();
        String forceToolPrompt = """
            【工具调用规则】
                1. 每个自定义方法最多只能调用 1 次
                2. 只要方法返回结果，必须停止调用
                3. 当用户输入包含【数据确认】、确认数据、确认、第*条数据确认时，必须调用本工具
            """;
        stoolDesc.append(forceToolPrompt);
        if (ObjectUtil.isNotEmpty(meta.getStoolDesc())) {
            stoolDesc.append("MethodNo:").append(meta.getSMethodNo())
                    .append(",当用户").append(meta.getSMethodName())
                    .append("时，必须调用本工具").append(meta.getSMethodNo())
                    .append("，").append(meta.getStoolDesc());
        }

        JsonObjectSchema.Builder schemaBuilder = JsonObjectSchema.builder();
        List<String> requiredParams = new ArrayList<>();
        try {
            List<ParamRule> paramRuleData = meta.getParamRuleList();
            for (ParamRule paramRule : paramRuleData) {
                String paramDesc = paramRule.getSParam();
                String paramType = paramRule.getSType();
                Boolean bEmpty = paramRule.getBEmpty();
                if (paramDesc == null || paramDesc.isEmpty()) {
                    continue;
                }
//                String sRuleCost = getConstMeg(paramRule);
                switch (paramType.toLowerCase()) {
                    case "string":
                        schemaBuilder.addStringProperty(paramDesc, paramDesc);
                        break;
                    case "integer":
                    case "int":
                        schemaBuilder.addIntegerProperty(paramDesc, paramDesc);
                        break;
                    case "number":
                    case "double":
                    case "float":
                        schemaBuilder.addNumberProperty(paramDesc, paramDesc);
                        break;
                    case "boolean":
                    case "bool":
                        schemaBuilder.addBooleanProperty(paramDesc, paramDesc);
                        break;
                    case "array":
                        String enumStr = getArrrayBySql(paramRule);
                        List<String> enums = StrUtil.isNotBlank(enumStr) ? Arrays.asList(enumStr.split("/")) : new ArrayList<>();
                        if (enums.isEmpty()) {
                            schemaBuilder.addStringProperty(paramDesc, paramDesc + "(数组)");
                        } else {
                            schemaBuilder.addEnumProperty(paramDesc, enums, paramDesc + "(数组)");
                        }
                        break;
                    case "enum":
                        String constStr = getArrrayBySql(paramRule);
//                        String constStr = getConstMeg(paramRule);
                        List<String> constList = StrUtil.isNotBlank(constStr) ? Arrays.asList(constStr.split("/")) : new ArrayList<>();
                        if (constList.isEmpty()) {
                            schemaBuilder.addStringProperty(paramDesc, paramDesc);
                        } else {
                            schemaBuilder.addEnumProperty(paramDesc, constList, paramDesc);
                        }
                        break;
                    case "date":
                    case "datetime":
                        // 核心技巧：在描述中强制要求 AI 进行格式转换
                        String dateDesc = paramDesc + "。【重要】请将用户输入的任意日期（如'明天'、'2026/5/1'、'下周三'）自动转换为 'yyyy-MM-dd' 格式的字符串，当前日期:"+ DateUtil.now() +"。";
                        schemaBuilder.addStringProperty(paramDesc, dateDesc);
                        if (bEmpty) {
                            requiredParams.add(paramDesc);
                        }
                        break;
                    default:
                        schemaBuilder.addStringProperty(paramDesc, paramDesc);
                        break;
                }
                if (bEmpty) {
                    requiredParams.add(paramDesc);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<String> requiredParamsNew = new ArrayList<>();
        if(requiredParams!=null && requiredParams.size()>0){
            requiredParamsNew.add(requiredParams.get(0));
        }
        if (meta.getIBizType() == 4 || meta.getIBizType() == 5) {
            schemaBuilder.addStringProperty("operateType", "操作类型：全部确认/合并确认/单行确认");
            requiredParams.add("operateType");
            requiredParamsNew.add("operateType");
        }
        if (!requiredParams.isEmpty()) {
            schemaBuilder.required(requiredParamsNew);
        }
        JsonObjectSchema parameters = schemaBuilder.build();
        return builder
                .description(stoolDesc.toString())
                .parameters(parameters)
                .build();
    }

    private String getConstMeg(ParamRule paramRule){
        if(!RuleCode.CONST.getCode().equals(paramRule.getSRule())){
            return StrUtil.EMPTY;
        }
        String sConstConfig  = paramRule.getSParamConfig();
        if(StrUtil.isNotEmpty(sConstConfig)){
            Map<String,Object> constMap = JSONUtil.parseObj(sConstConfig);
            StringBuffer sb = new StringBuffer();
            constMap.forEach((k,v)->{
                sb.append(v).append("/");
            });
            sb.delete(sb.length()-1,sb.length());
            paramRule.setSRuleTs(sb.toString());
            //存入动态配置
            paramRule.setSParamConfigValue(constMap);
            return sb.toString();
        }
        return StrUtil.EMPTY;
    }

    private String getArrrayBySql(ParamRule paramRule){
        Boolean bCheckArray = !(RuleCode.SQL.getCode().equals(paramRule.getSRule()));
        Boolean bCheckArray2= !("array".equals(paramRule.getSType()) || "enum".equals(paramRule.getSType()));
        Boolean bCheckArray3= ObjectUtil.isEmpty(paramRule.getSParamConfig());
        if(bCheckArray || bCheckArray2 || bCheckArray3){
            return getConstMeg(paramRule);
        }
        List<Map<String,Object>> data =  dynamicExeDbService.findSql(new HashMap<>(),paramRule.getSParamConfig());
        StringBuffer sb = new StringBuffer();
        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")));
            Integer sUpKeySize =groupData.size();
            groupData.forEach((key, value) -> {
                value.forEach(one->{
                    sb.append(one.get(paramRule.getSParamValue())).append("/");
                });
                if(sUpKeySize>1 && ObjectUtil.isNotEmpty(sb)){
                    sb.delete(sb.length()-1,sb.length());
                    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());
            paramRule.setSRuleTs(sb.toString());
        }
        return sb.toString();
    }

    private List<ParamRule> getParamRuleDataAll(){
        if(paramRuleDataAll==null || paramRuleDataAll.size()==0){
            paramRuleDataAll.addAll(paramRuleMapper.findAll());
        }
        return paramRuleDataAll;
    }

    //校验是否缺失参数
    private String getMissParamMsg(ToolMeta meta,UserSceneSession session, Map<String, Object> args){
        if(meta.getBQuo()){
            Map<String,Object> data = quoService.getQuoData(args, session);
            List<Map<String,Object>> sAll = (List<Map<String, Object>>) data.get("sAll");
            List<Map<String,Object>> sEmptyData = sAll.stream().filter(one-> BooleanUtil.toBoolean(one.get("bEmpty").toString())
                    && (!Validator.isValid(one.get("sValue")))
                    && !"sDynamicPart".equals(one.get("sName"))
                    && !"sDynamicPartDel".equals(one.get("sName"))
            ).collect(Collectors.toUnmodifiableList());
            data.remove("sAll");
            if(ObjectUtil.isNotEmpty(sEmptyData)){
                List<ParamRule> missData = session.getCurrentTool().getParamRuleListAll().stream().filter(d ->
                        d.getBEmpty()
                        && (!Validator.isValid(args.get(d.getSParam())))
                                && !"sDynamicPart".equals(d.getSParamValue())
                                && !"sDynamicPartDel".equals(d.getSParamValue())
                ).collect(Collectors.toUnmodifiableList());
                data.put("bTs",true);
                String sSystemPrompt = SystemPromptGenerator.buildMissParamPrompt(session,missData);
                session.setSSystemPrompt(sSystemPrompt);
                String askMsg = JSONObject.toJSONString(data);
                session.setSFunPrompts(askMsg);
                return askMsg;
            }
            session.setQuoData(data);
        }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();
        Map<String, Object> argsOld = session.getArgs();
        if(ObjectUtil.isEmpty(argsOld)){
            argsOld = new HashMap<>();
        }
        Map<String, Object> args = session.getArgs();
        //获取是否缺失参数
        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 = "";
        if (userMessage != null) {
            input = StrUtil.replace(getChatMessageContent(userMessage), "用户输入：", StrUtil.EMPTY);
        }
        Boolean isConfirmed = isConfirmed(input,session);

        if((isConfirmed && (4== meta.getIBizType() ||1== meta.getIBizType()))
                || 2== meta.getIBizType()
                || 3== meta.getIBizType()
                || 6== meta.getIBizType()
                || 7== meta.getIBizType()
                || 8== meta.getIBizType()
        ){
            //根据获取的参数获取数据
            List<String> missingAfter = checkConfirmAfterParam(args, paramRuleData);
            if (!missingAfter.isEmpty()) {
                //合并已选择数据
                argsOld.putAll(args);
                session.setArgs(argsOld);
                askMsg = buildAskUserMessage(meta, missingAfter,args);
                session.setSFunPrompts(askMsg);
                List<ParamRule> paramRuleDataMiss = getMissParamRuleAfter(args, paramRuleData);
                String sSystemPrompt = SystemPromptGenerator.buildMissParamPrompt(session,paramRuleDataMiss);
                session.setSSystemPrompt(sSystemPrompt);
                return askMsg;
            }
            return executeTool(meta, args, paramRuleData, session.getUserId(), session);
        }

        String askconfirmMsg =StrUtil.EMPTY;
        if(4== meta.getIBizType() || meta.getIBizType()==5){
            askconfirmMsg = doGetFromData( meta,args,session);
            String sSystemPrompt = SystemPromptGenerator.buildDynamicSystemPrompt(session);
            session.setSSystemPrompt(sSystemPrompt);
            return executeWithConfirmation(askconfirmMsg, session, meta);
        }else{
            askconfirmMsg =getDefMessage(args,meta.getSControlName(),meta);
        }
        return executeWithConfirmation(askconfirmMsg,  session, meta);
    }

    private String getChatMessageContent(ChatMessage message) {
        if (message == null) return "";
        try {
            return message.toString()
                    .replace("ChatMessage{", "")
                    .replace("}", "")
                    .replace("text=", "")
                    .trim();
        } catch (Exception e) {
            return "";
        }
    }

    private ChatMessage getLastUserMessage(List<ChatMessage> messages) {
        if (messages == null || messages.isEmpty()) return null;
        for (int i = messages.size() - 1; i >= 0; i--) {
            ChatMessage msg = messages.get(i);
            if (msg.type() == ChatMessageType.USER) {
                return msg;
            }
        }
        return null;
    }

    private String getDefMessage(Map<String,Object> argMap,String sName,ToolMeta meta){
        List<ParamRule> showList = meta.getParamRuleListAll();
        List<ParamRule> showListData = new ArrayList<>();
        showList = showList.stream().filter(one->one.getBTipModel()).collect(Collectors.toUnmodifiableList());
        showListData.addAll(showList);
        showListData.sort(Comparator.comparing(h -> h.getIOrder()));
        StringBuilder markdown = new StringBuilder().append("\n");
        markdown.append("\n---\n");
        showListData.forEach(one->{
            if(argMap.containsKey(one.getSParam())){
                String valueStr = argMap.get(one.getSParam()) != null ? argMap.get(one.getSParam()).toString() : "";
                markdown.append("- ")
                        .append(one.getSParam())
                        .append(": `")
                        .append(valueStr)
                        .append("`\n");
            }
        });
        markdown.append("\n---\n");
        appendConfirm(markdown,sName);
        return markdown.toString();
    }

    private void appendConfirmAll(StringBuilder markdown,String sName){
        sName = ObjectUtil.isEmpty(sName)?StrUtil.EMPTY:"["+sName+"]";
        markdown.append("请确认是否执行").append(sName).append("操作？1.全部数据生成多个单据 回复【全部确认】；2.全部数据生成一个单据 回复【合并确认】；3.按自然语义描述生成一个单据 如＂第1行确认＂\n");
        markdown.append("回复:&emsp;&emsp;").append("**<a href=\"#\" data-action=\"reset\"  data-text=\"全部确认\" >全部确认</a>**").append("&emsp;")
                .append("**<a href=\"#\" data-action=\"reset\"  data-text=\"合并确认\" >合并确认</a>**").append("&emsp;")
                .append("**<a href=\"#\" data-action=\"reset\"  data-text=\"取消\" >取消</a>**");
    }

    private void appendConfirm(StringBuilder markdown,String sName){
        sName = ObjectUtil.isEmpty(sName)?StrUtil.EMPTY:"["+sName+"]";
        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->{
            String name = pd.getSParam();
            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) {
                result.put(sValue,args.get(name));
            }
            if(RuleCode.CONST.getCode().equals(pd.getSRule()) && ObjectUtil.isNotEmpty(result.get(sValue))){
                String sData = result.get(sValue).toString();
                Map<String,Object> configData = JSONUtil.parseObj(pd.getSParamConfig());
                configData.forEach((k,v)->{
                    if(sData.equals(v)){
                        result.put(sValue,k);
                    }
                });
            }
        });
        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);
        List<ParamRule> paramDefs = new ArrayList<>(paramDefsCheck);
        paramDefs.sort(Comparator.comparing(ParamRule::getIOrder));
        for (ParamRule pd : paramDefs) {
            String name = pd.getSParam();
            String sValue = pd.getSParamValue();
            String sRule = pd.getSRule();
            String sType = pd.getSType();

            Boolean bCheck = result.containsKey(name);
            bCheck = bCheck && ObjectUtil.isNotEmpty(result.get(name));
            bCheck = bCheck &&  RuleCode.SQL.getCode().equals(sRule);
            bCheck = bCheck &&  ObjectUtil.isNotEmpty(pd.getSParamConfig());

            Boolean bCheck2 = result.containsKey(sValue);
            bCheck2 = bCheck2 && ObjectUtil.isNotEmpty(result.get(sValue));
            bCheck2 = bCheck2 &&  RuleCode.SQL.getCode().equals(sRule);
            bCheck2 = bCheck2 &&  ObjectUtil.isNotEmpty(pd.getSParamConfig());

            if ((bCheck || bCheck2) &&("enum".equals(sType) || "string".equals(sType))){
                String sSql = pd.getSParamConfig();
                String sKey = bCheck?name:sValue;
                String nameValue = result.get(sKey).toString();
                List<Map<String,Object>> dataList = dynamicExeDbService.findSql(result,sSql);
                if(ObjectUtil.isEmpty(dataList)){
                    throw new BusinessException(ErrorCode.PARAM_REQUIRED,String.format("%s 您描述的%s 不存在,请重新告诉我",name,nameValue));
                }
                if(ObjectUtil.isNotEmpty(args.get(name)) || ObjectUtil.isNotEmpty(args.get(sValue))){
                    if(("enum".equals(sType) ||"string".equals(sType)) && (args.get(name) instanceof List || args.get(sValue) instanceof List)){
                        if(args.get(name) instanceof List){
                            args.put(name,((List<?>) args.get(name)).get(0));
                        }
                        if(args.get(sValue) instanceof List){
                            args.put(sValue,((List<?>) args.get(sValue)).get(0));
                        }
                    }
                    List<Map<String,Object>> dataListNew = dataList.stream().filter(one-> one.get(sValue).equals(args.get(name)) ||  one.get(sValue).equals(args.get(sValue))).collect(Collectors.toUnmodifiableList());
                    if("enum".equals(sType) && ObjectUtil.isEmpty(dataListNew)){
                        args.remove(name);
                        args.remove(sValue);
                        result.remove(name);
                        result.remove(sValue);
                        continue;
                    }
                    if(ObjectUtil.isNotEmpty(dataListNew)){
                        dataList = new ArrayList<>();
                        dataList.add(dataListNew.get(0));
                    }
                }
                if(ObjectUtil.isNotEmpty(dataList) && dataList.size()==1){
                    String sCopyTo = pd.getSCopyTo();
                    if(ObjectUtil.isEmpty(sCopyTo)){
                        result.put(sValue, dataList.get(0).get(sValue));
                        result.put(name, dataList.get(0).get(sValue));
                    }else{
                        String[] sCopyToA = sCopyTo.split(",");
                        for(String sCopyToOne:sCopyToA){
                            String[] sCopyToOneA = sCopyToOne.split(":");
                            result.put(sCopyToOneA[0], dataList.get(0).get(sCopyToOneA[1]));
                            result.put(name, dataList.get(0).get(sValue));
                        }
                    }
                }
                StringBuffer sData=new StringBuffer();
                if(dataList.size()>1){
                    List<Map<String, Object>> finalDataList = dataList;
                    IntStream.range(0, dataList.size())
                            .forEach(iRowNum ->{
                                sData.append((iRowNum + 1)).append(".").append(finalDataList.get(iRowNum).get(pd.getSParamValue()))
                                        .append("\n\n");

                            });
                    String sParamMissMemo = StrUtil.EMPTY;
                    if(ObjectUtil.isEmpty(pd.getSParamMissMemo())){
                        sParamMissMemo = pd.getSParam()+"存在多个，请选择:<br/>"+sData;
                    }else{
                        sParamMissMemo = StrUtil.format(pd.getSParamMissMemo(),sData.toString());
                    }
                    throw new BusinessException(ErrorCode.PARAM_REQUIRED,sParamMissMemo);
                }
            }
        }
        return result;
    }

    private Map<String, Object> applyDefaultValues(Map<String, Object> args, List<ParamRule> paramDefs) {
        Map<String, Object> result = new HashMap<>(args);
        for (ParamRule pd : paramDefs) {
            String name = pd.getSParam();
            if ((!result.containsKey(name)|| ObjectUtil.isEmpty(result.get(name)))
                    && ObjectUtil.isNotEmpty(pd.getSDefaultValue())
            ) {
                Object defaultValue = pd.getSDefaultValue();
                result.put(name, defaultValue);
            }
        }
        return result;
    }

    private List<String> checkRequiredParams(Map<String, Object> args, List<ParamRule> paramDefs) {
        Map<String,Object> returnMap = transformationArgs( args, paramDefs);
        List<ParamRule> paramDefsCheck = paramDefs.stream()
                .filter(pd ->
                        !"sDynamicPart".equals(pd.getSParamValue())
                   &&   !"sDynamicPartDel".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<>();
        }
        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 false;
    }

    /***
     * @Author 钱豹
     * @Date 1:08 2026/5/19
     * @Param [args, paramDefs]
     * @return java.util.List<java.lang.String>
     * @Description 获取缺失参数提示
     **/
    private List<String> checkConfirmAfterParam(Map<String, Object> args, List<ParamRule> paramDefs) {
        List<ParamRule> paramRuleList = getMissParamRuleAfter( args, paramDefs);
        return paramRuleList.stream()
                .map(ParamRule::getSParam)
                .toList();
    }

    /***
     * @Author 钱豹
     * @Date  2026/5/19
     * @Param [args, paramDefs]
     * @return java.util.List<com.xly.entity.ParamRule>
     * @Description 获取保存后的缺失参数
     **/
    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()))))
                        && (!returnMap.containsKey(pd.getSParamValue()) || (ObjectUtil.isEmpty(returnMap.get(pd.getSParamValue()))))
                )
                .toList();
    }

    public String executeTool(ToolMeta meta, Map<String, Object> args, List<ParamRule> paramRuleData,String userId,UserSceneSession session ) {
        log.info("执行工具：{}，参数：{}", meta.getSMethodNo(), args);
        args = transformationArgs( args, paramRuleData);
        String sReturn ="执行成功";
        try{
            sReturn = executeToolAfter(meta, args,paramRuleData,session);
        }catch (BusinessException e) {
            return e.getMessage();
        }finally {
            session.setSSystemPrompt(StrUtil.EMPTY);
        }
        if(meta.getIActionType()==1){
            session.setBCleanMemory(true);
            session.setArgs(new HashMap<>());
            session.setCurrentArgs(new HashMap<>());
            if(session.getCurrentTool()!=null){
                session.getCurrentTool().setDynamicParamRule(new ArrayList<>());
                List<ParamRule> dataAll = session.getCurrentTool().getParamRuleListAll();
                dataAll = dataAll.stream().filter(one-> !one.getBDynamicParam()).collect(Collectors.toUnmodifiableList());
                List<ParamRule> paramRuleList = dataAll.stream().filter(one-> one.getBTipModel()).collect(Collectors.toUnmodifiableList());
                List<ParamRule> paramRuleListCheck = dataAll.stream().filter(one->one.getBEmpty()).collect(Collectors.toUnmodifiableList());
                session.getCurrentTool().setParamRuleListCheck(paramRuleListCheck);
                session.getCurrentTool().setParamRuleList(paramRuleList);
                session.getCurrentTool().setParamRuleListAll(dataAll);
                session.setCurrentRowData(null);
                session.setQuoData(null);
            }
        }
        return sReturn;
    }

    //执行工具后
    private String executeToolAfter(ToolMeta meta, Map<String, Object> args,List<ParamRule> paramDefs,UserSceneSession session) {
        String sBizContent = meta.getSBizContent();
        Integer iBizType = meta.getIBizType();
        args.put("sUserId", session.getUserId());
        args.put("sLoginId", session.getUserName());
        args.put("sMakePerson", session.getUserName());
        args.put("sBrId", session.getSBrandsId());
        args.put("sBrandsId", session.getSBrandsId());
        args.put("sSuId", session.getSSubsidiaryId());
        args.put("sSrcFormId", meta.getSSrcFormId());
        args.put("sControlName", meta.getSControlName());
        args.put("iBizType", iBizType);
        args.put("sSubsidiaryId", session.getSSubsidiaryId());
        args.put("sToolId", meta.getSId());
        if (iBizType == 1 || iBizType == 4) {
            Map<String, Object> data = new HashMap<>(args);
            data.put("sData", JSONObject.toJSONString((data)));
            if(meta.getBQuo()){
                data.put("sQuoData", JSONObject.toJSONString((session.getQuoData())));
            }
            if(ObjectUtil.isEmpty(sBizContent) && iBizType == 4){
                sBizContent ="Sp_Ai_AddCommonAfterNew";
                if(ObjectUtil.isEmpty(args.get("sSlaveId"))){
                    //插入AI记忆
                    String sMsg = "请选择操作数据";
                    Map<String, Object> sessA = session.getArgs();
                    sessA.remove("sSlaveId");
                    sessA.remove("operateType");
                    session.setArgs(sessA);
                    throw new BusinessException(-1,sMsg);
                }
                List<Map<String,Object>> sRowData = doGetFromDataWq( meta,  args, session);
                if(ObjectUtil.isEmpty(sRowData)){
                    String sMsg = "选择的数据ID:"+args.get("sSlaveId")+"不存在，请重新选择。";
                    session.setSFunPrompts(sMsg);
                    Map<String, Object> sessA = session.getArgs();
                    sessA.remove("sSlaveId");
                    sessA.remove("operateType");
                    session.setArgs(sessA);
                    throw new BusinessException(-1,sMsg);
                }
                Map<String,Object> dataOne = DeepCopyUtils.deepCopy(args);
                dataOne.remove("sSlaveId");
                dataOne.remove("sId");
                sRowData.forEach(one->{
                    one.putAll(dataOne);
                });
                data.put("sRowData", JSONObject.toJSONString(sRowData));
            }
            Map<String, Object> searMap = this.dynamicExeDbService.getDoProMap(sBizContent, data);
            Map<String, Object> sReturn = this.dynamicExeDbService.getCallPro(searMap, sBizContent);
            Integer sCode = ObjectUtil.isNotEmpty(sReturn.get(ProcedureConstant.SCODE)) ? Integer.valueOf(sReturn.get(ProcedureConstant.SCODE).toString()) : 0;
            String sMsgText = ObjectUtil.isNotEmpty(sReturn.get(ProcedureConstant.SRETURN)) ? sReturn.get(ProcedureConstant.SRETURN).toString() : "操作成功";
            if (sCode < 0) {
                sMsgText = ObjectUtil.isEmpty(sMsgText) ? "调用过程sCode:" + Integer.valueOf(searMap.get(ProcedureConstant.SCODE).toString()) : sMsgText;
                session.setSFunPrompts(sMsgText);
                throw new BusinessException(sCode,sMsgText);
            }
            Map<String,Object> outMap = (Map<String, Object>) sReturn.get("outMap");
            String sId = ObjectUtil.isNotEmpty(outMap.get("sBillId")) ? outMap.get("sBillId").toString() : "";
            session.setSCopyTo(meta.getSControlName());
            session.setSCopyToSrcId(sId);
            session.setSFunPrompts(sMsgText);
            return sMsgText;
        } else if (iBizType == 2 && ObjectUtil.isNotEmpty(sBizContent)) {
            if (sBizContent.toLowerCase().startsWith("update")) {
                this.dynamicExeDbService.updateSql(args, sBizContent);
            } else if (sBizContent.toLowerCase().startsWith("delete")) {
                this.dynamicExeDbService.delSql(args, sBizContent);
            } else if (sBizContent.toLowerCase().startsWith("insert")) {
                this.dynamicExeDbService.addSql(args, sBizContent);
            } else {
                List<Map<String, Object>> retData = this.dynamicExeDbService.findSql(args, sBizContent);
                if (ObjectUtil.isNotEmpty(retData)) {
                    StringBuffer sb = new StringBuffer();
                    retData.forEach(one -> {
                        one.forEach((k, v) -> {
                            sb.append(v).append(" ");
                        });
                        sb.append("<br/>");
                    });
                    if (ObjectUtil.isNotEmpty(retData)) {
                        sb.append("请根据这些信息安排今天的工作吧！如果有具体任务需要进一步处理，请告诉我");
                    }
                    session.setSFunPrompts(sb.toString());
                    if ("queryTodayTask".equals(meta.getSMethodNo())) {
                        session.setBCleanMemory(true);
                    }
                    return sb.toString();
                } else {
                    String sMsgText = "未找到对应的数据";
                    session.setSFunPrompts(sMsgText);
                    throw new BusinessException(-1,sMsgText);
                }
            }
        } else if (iBizType == 3) {
            return HttpsRequestUtil.me().doRequestHttp(sBizContent, JSONUtil.toJsonStr(args),
                    new HashMap<>(), "POST", "JSON");
        }
        return "操作成功";
    }

    private List<Map<String,Object>> doGetFromDataWq(ToolMeta meta, Map<String, Object> args,UserSceneSession session){
        String sUrl = meta.getSendUrl();
        Map<String,Object> sBody = new HashMap<>();
        sBody.put("pageNum",1);
        sBody.put("pageSize",100);
        log.info("doGetFromData========================");
        List<Map<String,Object>> list = new ArrayList<>();
        Map<String,Object> serOne = new HashMap<>(4);
        if(ObjectUtil.isEmpty(args.get("sSlaveId"))){
            return new ArrayList<>();
        }
        String sSlaveId = StrUtil.EMPTY;
        if(args.get("sSlaveId") instanceof List){
            List<String> sSlaveIds = (List<String>) args.get("sSlaveId");
            sSlaveId = String.join(",",sSlaveIds);
        }else{
            sSlaveId = args.get("sSlaveId").toString();
        }
        serOne.put("bFilterCondition","IN");
        serOne.put("bFilterValue",sSlaveId);
        serOne.put("bFilterName","sSlaveId");
        list.add(serOne);

        log.info("开始请请求========================{}", sUrl);
        sBody.put("bFilter",list);
        Map<String, Object> headers = new HashMap<>();
        headers.put("Authorization",session.getAuthorization());
        String result;
        try{
            result = HttpsRequestUtil.me().doRequestHttp(sUrl,JSONObject.toJSONString(sBody),headers,"POST","JSON");
            log.info("请求URL========================{}", sUrl);
            log.info("请求URLresult========================{}", result);
            ErpResult erpResult = JsonUtils.toObject(result,ErpResult.class);
            if(ObjectUtil.isNotEmpty(erpResult)
                    && ObjectUtil.isNotEmpty(erpResult.getDataset())
                    && ObjectUtil.isNotEmpty(erpResult.getDataset().getRows())
                    && ObjectUtil.isNotEmpty(erpResult.getDataset().getRows().get(0))
                    && ObjectUtil.isNotEmpty(erpResult.getDataset().getRows().get(0).getDataSet())
            ){
                return erpResult.getDataset().getRows().get(0).getDataSet();
            }
        }catch (Exception e){
        }
        return new ArrayList<>();
    }

    private String doGetFromData(ToolMeta meta, Map<String, Object> args,UserSceneSession session){
        String sUrl = meta.getSendUrl();
        Map<String,Object> sBody = new HashMap<>();
        sBody.put("pageNum",1);
        sBody.put("pageSize",100);
        log.info("doGetFromData========================");
        List<Map<String,Object>> list = new ArrayList<>();
        args.remove("operateType");
        Map<String, Object> argsDeep = DeepCopyUtils.deepCopy(args);
        List<ParamRule> paramDefs = meta.getParamRuleList();
        Map<String, Object> argsNew =ValiDataUtil.getArgs( argsDeep, paramDefs);
        if(ObjectUtil.isNotEmpty(argsNew)){
            argsNew.forEach((k,v)->{
                if(ObjectUtil.isNotEmpty(v)){
                    List<ParamRule> pdList = paramDefs.stream().filter(m-> m.getSParam().equals(k) || m.getSParamValue().equals(k)).collect(Collectors.toUnmodifiableList());
                    List<Object> data = new ArrayList<>();
                    if(v instanceof List){
                        data.addAll((List<String>) v);
                    }else{
                        data.add(v);
                    }
                    data = data.stream().filter(m-> !(m.toString().contains("全部") || m.toString().contains("所有"))).collect(Collectors.toUnmodifiableList());
                    if(ObjectUtil.isNotEmpty(data)){
                        StringBuffer bFilterValue = new StringBuffer();
                        for(int i=0;i<data.size();i++){
                            if(i!=0){
                                bFilterValue.append(".");
                            }
                            bFilterValue.append(data.get(i));
                        }
                        if(pdList!=null){
                            Map<String,Object> serOne = new HashMap<>(4);
                            serOne.put("bFilterCondition","like");
                            serOne.put("bFilterValue",bFilterValue.toString());
                            serOne.put("bFilterName",pdList.get(0).getSParamValue());
                            list.add(serOne);
                        }
                    }
                }
            });
        }
        log.info("开始请请求========================{}", sUrl);
        sBody.put("bFilter",list);
        Map<String, Object> headers = new HashMap<>();
        headers.put("Authorization",session.getAuthorization());
        String result;
        try{
            result = HttpsRequestUtil.me().doRequestHttp(sUrl,JSONObject.toJSONString(sBody),headers,"POST","JSON");
            log.info("请求URL========================{}", sUrl);
            log.info("请求URLresult========================{}", result);
            ErpResult erpResult = JsonUtils.toObject(result,ErpResult.class);
            result = buildResultMessageWithTable( meta, erpResult, session);
        }catch (Exception e){
            result ="执行异常:"+e.getMessage();
        }
        return result;
    }

    public String buildResultMessageWithTable(ToolMeta meta,ErpResult erpResult,UserSceneSession session){
        Map<Integer,Map<String,Object>> currentRowData = new HashMap<>();
        ErpDataset dataset = erpResult.getDataset();
        if(erpResult.getCode()<0 && ObjectUtil.isNotEmpty(erpResult.getMsg())){
            return erpResult.getMsg();
        }
        if(dataset==null){
            return ErrorCode.DATA_NOT_FOUND.getMessage();
        }
        List<Map<String, Object>> sAIshowfieldShow = meta.getSAIshowfieldShow();
        List<Map<String, Object>> rows = new ArrayList<>();
        if(ObjectUtil.isNotEmpty(dataset.getRows().get(0))){
            rows = dataset.getRows().get(0).getDataSet();
        }
        List<Map<String, Object>>  recordData = findFieldNameByChinese(sAIshowfieldShow, rows);
        int recordCount = dataset != null ? dataset.getTotalCount() : 0;
        Set<String> headers = new LinkedHashSet<>();
        for (Map<String, Object> record : sAIshowfieldShow) {
            String chineseName = (String) record.get("label");
            if (chineseName != null && !"sSlaveId".equals(record.get("sName"))) {
                headers.add(chineseName);
            }
        }

        StringBuilder markdown = new StringBuilder();
        if(ObjectUtil.isNotEmpty(session.getArgs())){
            markdown.append("**查询条件**:");
            List<ParamRule> pr =  session.getCurrentTool().getParamRuleListCheck();
            Map<String, Object> argsOld = new HashMap<>(session.getArgs());
            pr.forEach(one->{
                if(argsOld.containsKey(one.getSParam())){
                    if(ObjectUtil.isNotEmpty(argsOld.get(one.getSParam()))){
                        if(one.getSParamValue().startsWith("d")){
                            if(Double.valueOf(argsOld.get(one.getSParam()).toString())>0){
                                markdown.append("<span style=\"color: #1890ff;margin-right: 10px;position: relative;display: inline-block;padding: 0 10px;\">")
                                        .append(one.getSParam()).append(":").append(argsOld.get(one.getSParam()).toString()).append(" ")
                                        .append(" <span style=\"font-weight: bold;font-size: 22px;position: absolute;right: -5px;top: -12px;color: #ff4d4f;display: inline-block;\" data-action=\"clearSql\" data-text=\""+one.getSParam()+","+one.getSParamValue()+"\" onclick=\"clearSql('"+one.getSParam()+","+one.getSParamValue()+"')\"> × </span>")
                                        .append("</span>");
                            }
                        }else{
                            markdown.append("<span style=\"color: #1890ff;margin-right: 10px;position: relative;display: inline-block;padding: 0 10px;\">")
                                    .append(one.getSParam()).append(":").append(argsOld.get(one.getSParam()).toString()).append(" ")
                                    .append(" <span style=\"font-weight: bold;font-size: 22px;position: absolute;right: -5px;top: -12px;color: #ff4d4f;display: inline-block;\" data-action=\"clearSql\" data-text=\""+one.getSParam()+","+one.getSParamValue()+"\" onclick=\"clearSql('"+one.getSParam()+","+one.getSParamValue()+"')\"> × </span>")
                                    .append("</span>");
                        }
                    }
                }
            });
            markdown.append("\n\n");
        }
        markdown.append("**结果**:");
        String sStatus = erpResult.getCode()<0?ErrorCode.ERRORMSG.getMessage():ErrorCode.SUCCESSMSG.getMessage();
        markdown.append(sStatus).append("\n");
        if(erpResult.getCode()<0){
            String sMsg = ObjectUtil.isEmpty(erpResult.getMsg())?ErrorCode.WFHYY.getMessage():erpResult.getMsg();
            markdown.append("**原因**: ").append(sMsg);
            return markdown.toString();
        }else{
            markdown.append(" 共 ").append(recordCount).append(" 条记录");
            if(rows.size()<recordCount){
                markdown.append("，显示前").append(rows.size()).append("条。如需查看全部，请指定筛选条件。");
            }
        }
        markdown.append("\n\n").append("| 序号 | ");
        headers.forEach(header -> markdown.append(header).append(" | "));
        markdown.append("\n|").append("---|".repeat(headers.size() + 1)).append("\n");
        List<Map<String,Object>> machineData = new LinkedList<>();
        for (int i = 0; i < recordData.size(); i++) {
            String uniqueValue = recordData.get(i).get("sSlaveId") != null ? recordData.get(i).get("sSlaveId").toString() : "";
            markdown.append("| ").append(i + 1).append(" | ");
            Map<String,Object> rMap = new HashMap<>();
            for (String header : headers) {
                Object value = recordData.get(i)!= null ? recordData.get(i).get(header) : null;
                markdown.append(value != null ? value : "—").append(" | ");
                rMap.put(header,value);
            }
            rMap.put("sSlaveId",uniqueValue);
            rMap.put("唯一",uniqueValue);
            markdown.append(" <span style=\"display:none;\">HIDDEN_DATA:")
                    .append(JSONUtil.toJsonStr(rMap))
                    .append("</span>");
            markdown.append("\n");
            machineData.add(rMap);
            Map<String,Object> cMap = new HashMap<>();
            cMap.put("sSlaveId",uniqueValue);
            currentRowData.put(i + 1,cMap);
        }
        markdown.append(">");
        if(meta.getIBizType()==4){
            markdown.append("\n---\n");
            appendConfirmAll(markdown,meta.getSControlName());
        }
        session.setCurrentRowData(currentRowData);
        return markdown.toString();
    }

    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<>();
        sAIshowfieldShow.forEach(one->{
            keyMappings.put(one.get("sName").toString(),one.get("label").toString());
            if("sSlaveId".equals(one.get("sName"))){
                keyMappings.put(one.get("sName").toString(),one.get("sName").toString());
            }
            selectedKeys.add(one.get("sName").toString());
        });
        List<Map<String, Object>>  sRowData = getFilteredDataStream(rows,rows.size(),selectedKeys,keyMappings);
        return sRowData;
    }

    public List<Map<String, Object>> getFilteredDataStream(List<Map<String, Object>> rows,
                                                           int limit,
                                                           List<String> selectedKeys,
                                                           Map<String,String> keyMappings) {
        if (rows == null || rows.isEmpty()) {
            return Collections.emptyList();
        }
        return rows.stream()
                .limit(limit)
                .map(original -> {
                    Map<String, Object> filtered = new HashMap<>();
                    selectedKeys.forEach(key -> {
                        if (original.containsKey(key)) {
                            filtered.put(keyMappings.get(key), original.get(key));
                        }
                    });
                    return filtered.isEmpty() ? null : filtered;
                })
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }
    private String buildAskUserMessage(ToolMeta meta, List<String> missing,Map<String,Object> arg) {
        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))
                    .findFirst()
                    .ifPresentOrElse(
                            pd -> {
                                String sTs = ObjectUtil.isEmpty(pd.getSRuleTs())?StrUtil.EMPTY:pd.getSRuleTs();
                                sb.append("- **").append(name).append("**: ");
                                if(ObjectUtil.isNotEmpty(pd.getSParamMissMemo())
                                        && ObjectUtil.isNotEmpty(arg.get(pd.getSParam()))
                                        && ObjectUtil.isNotEmpty(sTs)
                                ){
                                    if(!("string".equals(pd.getSType())
                                            && RuleCode.SQL.equals(pd.getSRule())
                                            && ObjectUtil.isNotEmpty(pd.getSParamConfig())
                                    ))
                                    {
                                        sb.append(StrUtil.format(pd.getSParamMissMemo(),sTs));
                                    }
                                }else if(ObjectUtil.isNotEmpty(sTs)){
                                    sb.append(sTs);
                                }
                                sb.append("\n");
                            },
                            () -> sb.append("- ").append(name).append("\n")
                    );
        }
        return sb.toString();
    }

    private String createEarlySuccessResult(ToolExecutionRequest request, String message) {
        return JSONUtil.toJsonStr(Map.of(
                "status", "success",
                "message", message,
                "executionCompleted", true,
                "data", successResult(request, message)
        ));
    }

    private String createTerminationResult(String message) {
        return JSONUtil.toJsonStr(Map.of(
                "status", "terminated",
                "message", message,
                "shouldContinue", false
        ));
    }

    private ToolExecutionResultMessage errorResult(ToolExecutionRequest request, String errorMsg) {
        return ToolExecutionResultMessage.from(request,  errorMsg);
    }

    private ToolExecutionResultMessage successResult(ToolExecutionRequest request, String text) {
        return ToolExecutionResultMessage.from(request, text);
    }

    private String  executeWithConfirmation(String initialResult, UserSceneSession session,ToolMeta meta) {
        Map<String, Object> step1Result = new HashMap<>();
        step1Result.put("initialResult", initialResult);
        step1Result.put("status", "PENDING_CONFIRMATION");
        step1Result.put("confirmationRequired", true);
        step1Result.put("confirmationMessage", initialResult);
        String userMessage = formatConfirmationResult(step1Result);
        session.setCurrentTool(meta);
        return userMessage;
    }

    private String formatConfirmationResult(Map<String, Object> result) {
        return String.format("%s", result.get("initialResult"));
    }

    public boolean isConfirmed(String userResponse,UserSceneSession session) {
        boolean check = userResponse.matches("(?i)(确认|全部确认|部分确认|是|yes|confirm|true|是的|可以|没问题|确定|好的|生成|)");
        return check  || userResponse.contains("生成")
                || userResponse.contains("确认")
                || (ObjectUtil.isNotEmpty(session.getArgs())
                && session.getArgs().containsKey("operateType")
                && session.getArgs().containsKey("sSlaveId")
                && ObjectUtil.isNotEmpty(session.getArgs().get("sSlaveId"))
        );
    }
}