0606

admin

2025-06-06 9cd825aea53fa5ba0cda1485464af027e27f0ce4

 aiflowy-modules/aiflowy-module-ai/src/main/java/tech/aiflowy/ai/entity/AiPluginFunction.java

@@ -11,16 +11,16 @@
import com.mybatisflex.core.query.QueryWrapper;
import tech.aiflowy.ai.mapper.AiPluginMapper;
import tech.aiflowy.ai.service.AiPluginToolService;
import tech.aiflowy.common.ai.util.NestedParamConverter;
import tech.aiflowy.common.ai.util.PluginHttpClient;
import tech.aiflowy.common.ai.util.PluginParam;
import tech.aiflowy.common.ai.util.PluginParamConverter;
import tech.aiflowy.common.domain.Result;
import tech.aiflowy.common.util.SpringContextUtil;

import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;

public class AiPluginFunction  implements Function {

@@ -164,42 +164,145 @@
                params.add(pluginParam);
            }
        }
        List<PluginParam> pluginParams = PluginParamConverter.convertFromJson(aiPluginTool.getInputData());
        Map<String, Object> nestedParams = NestedParamConverter.convertToNestedParamMap(pluginParams);

        // 准备存放不同位置的参数
        List<PluginParam> queryParams = new ArrayList<>();
        List<PluginParam> bodyParams = new ArrayList<>();
        List<PluginParam> headerParams = new ArrayList<>();
        List<PluginParam> pathParams = new ArrayList<>();

        List<Map<String, Object>> dataList = getDataList(aiPluginTool.getInputData());
        // 遍历嵌套参数
        for (Map.Entry<String, Object> entry : nestedParams.entrySet()) {
            String paramName = entry.getKey();

        // 遍历插件工具定义的参数列表
        for (Map<String, Object> paramDef : dataList) {
            String paramName = (String) paramDef.get("name");
            // 获取原始参数定义
            PluginParam originalParam = findOriginalParam(pluginParams, paramName);
            if (originalParam == null || !originalParam.isEnabled()) {
                continue;
            }

            // 检查大模型返回的参数中是否包含当前参数
            // 创建参数副本以避免修改原始定义
            PluginParam requestParam = new PluginParam();
            requestParam.setName(originalParam.getName());
            requestParam.setDescription(originalParam.getDescription());
            requestParam.setRequired(originalParam.isRequired());
            requestParam.setType(originalParam.getType());
            requestParam.setEnabled(originalParam.isEnabled());
            requestParam.setMethod(originalParam.getMethod());

            // 优先级: argsMap值 < 参数默认值
            if (argsMap != null && argsMap.containsKey(paramName)) {
                PluginParam pluginParam = new PluginParam();
                pluginParam.setName(paramName);
                pluginParam.setDescription((String) paramDef.get("description"));
                pluginParam.setRequired((boolean) paramDef.get("required"));
                pluginParam.setType((String) paramDef.get("type"));
                pluginParam.setMethod((String) paramDef.get("method"));
                pluginParam.setEnabled((boolean) paramDef.get("enabled"));
                // 使用大模型返回的值，而不是默认值
                pluginParam.setDefaultValue(argsMap.get(paramName));
                // 1. 优先检查是否有有效的默认值
                if (hasValidDefaultValue(originalParam.getDefaultValue())) {
                    // 使用默认值
                    requestParam.setDefaultValue(originalParam.getDefaultValue());
                } else {
                    // 使用大模型返回的值
                    requestParam.setDefaultValue(argsMap.get(paramName));
                }
            } else if (hasValidDefaultValue(originalParam.getDefaultValue())) {
                // 2. 没有传参但默认值有效时使用默认值
                requestParam.setDefaultValue(originalParam.getDefaultValue());
            }
            // 3. 其他情况（无传参且无有效默认值）保持null

                params.add(pluginParam);
            } else if ((boolean) paramDef.get("required")) {
                // 如果是必填参数但大模型没有返回，使用默认值或抛出异常
                PluginParam pluginParam = new PluginParam();
                pluginParam.setName(paramName);
                pluginParam.setDescription((String) paramDef.get("description"));
                pluginParam.setRequired(true);
                pluginParam.setMethod((String) paramDef.get("method"));
                pluginParam.setEnabled((boolean) paramDef.get("enabled"));
                pluginParam.setType((String) paramDef.get("type"));
                pluginParam.setDefaultValue(paramDef.get("defaultValue"));
                params.add(pluginParam);
            // 根据method分类参数
            switch (originalParam.getMethod().toLowerCase()) {
                case "query":
                    queryParams.add(requestParam);
                    break;
                case "body":
                    bodyParams.add(requestParam);
                    break;
                case "header":
                    headerParams.add(requestParam);
                    break;
                case "path":
                    pathParams.add(requestParam);
                    break;
            }
        }

        JSONObject result = PluginHttpClient.sendRequest(url, method, headersMap, params);
        // 合并所有参数
        List<PluginParam> allParams = new ArrayList<>();
        allParams.addAll(pathParams);
        allParams.addAll(queryParams);
        allParams.addAll(bodyParams);
        allParams.addAll(headerParams);
        allParams.addAll(params);

        // 发送请求
        JSONObject result = PluginHttpClient.sendRequest(url, method, headersMap, allParams);
        return result;
    }

    // 辅助方法：根据参数名查找原始参数定义
    private PluginParam findOriginalParam(List<PluginParam> params, String name) {
        for (PluginParam param : params) {
            if (name.equals(param.getName())) {
                return param;
            }
        }
        return null;
    }

    // 添加辅助方法判断默认值是否有效
    private boolean hasValidDefaultValue(Object defaultValue) {
        if (defaultValue == null) {
            return false;
        }

        // 字符串类型检查
        if (defaultValue instanceof CharSequence) {
            return !((CharSequence) defaultValue).toString().trim().isEmpty();
        }

        // 集合/数组类型检查
        if (defaultValue instanceof Collection) {
            return !((Collection<?>) defaultValue).isEmpty();
        }
        if (defaultValue instanceof Map) {
            return !((Map<?, ?>) defaultValue).isEmpty();
        }
        if (defaultValue.getClass().isArray()) {
            return Array.getLength(defaultValue) > 0;
        }

        // 其他类型直接认为有效
        return true;
    }

    private void processParamWithChildren(Map<String, Object> paramDef, Map<String, Object> argsMap, List<PluginParam> params) {
        boolean enabled = (boolean) paramDef.get("enabled");
        if (!enabled){
            return;
        }
        String paramName = (String) paramDef.get("name");
        PluginParam pluginParam = new PluginParam();
        pluginParam.setName(paramName);
        pluginParam.setDescription((String) paramDef.get("description"));
        pluginParam.setRequired((boolean) paramDef.get("required"));
        pluginParam.setType((String) paramDef.get("type"));
        pluginParam.setEnabled((boolean) paramDef.get("enabled"));
        pluginParam.setMethod((String) paramDef.get("method"));

        // 如果用户传了值，就用用户的值；否则用默认值
        if (paramDef.get("defaultValue") != null && !"".equals(paramDef.get("defaultValue"))) {
            pluginParam.setDefaultValue(paramDef.get("defaultValue"));
        } else if (argsMap != null && paramDef.get("name").equals(paramName) && paramDef.get("defaultValue") != null) {
            pluginParam.setDefaultValue(argsMap.get(paramName));
        }

        params.add(pluginParam);

        // 处理 children
        List<Map<String, Object>> children = (List<Map<String, Object>>) paramDef.get("children");
        if (children != null) {
            for (Map<String, Object> child : children) {
                processParamWithChildren(child, argsMap, params);
            }
        }
    }
}