package com.vincent.rsf.server.ai.service.mcp;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.vincent.rsf.server.ai.constant.AiMcpConstants;
|
import com.vincent.rsf.server.ai.constant.AiSceneCode;
|
import com.vincent.rsf.server.ai.model.AiDiagnosticToolResult;
|
import com.vincent.rsf.server.ai.model.AiMcpToolDescriptor;
|
import com.vincent.rsf.server.ai.model.AiPromptContext;
|
import com.vincent.rsf.server.ai.service.provider.AiDiagnosticDataProvider;
|
import com.vincent.rsf.server.system.entity.AiDiagnosticToolConfig;
|
import com.vincent.rsf.server.system.entity.AiMcpMount;
|
import com.vincent.rsf.server.system.service.AiDiagnosticToolConfigService;
|
import com.vincent.rsf.server.system.service.AiMcpMountService;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.Resource;
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
@Service
|
public class AiMcpRegistryService {
|
|
private static final long EXTERNAL_TOOL_CACHE_TTL_MS = 30000L;
|
|
private final List<AiDiagnosticDataProvider> providers;
|
private final Map<String, CachedTools> externalToolCache = new ConcurrentHashMap<>();
|
|
@Resource
|
private AiMcpMountService aiMcpMountService;
|
@Resource
|
private AiDiagnosticToolConfigService aiDiagnosticToolConfigService;
|
@Resource
|
private AiMcpHttpClient aiMcpHttpClient;
|
@Resource
|
private AiMcpSseClient aiMcpSseClient;
|
@Resource
|
private AiMcpPayloadMapper aiMcpPayloadMapper;
|
|
public AiMcpRegistryService(List<AiDiagnosticDataProvider> providers) {
|
this.providers = providers == null ? new ArrayList<>() : providers;
|
}
|
|
/**
|
* 枚举租户下可见的 MCP 工具目录。
|
* 包括内部工具和所有启用中的外部挂载工具。
|
*/
|
public List<AiMcpToolDescriptor> listTools(Long tenantId, Long mountId) {
|
List<AiMcpToolDescriptor> output = new ArrayList<>();
|
List<AiMcpMount> mounts;
|
if (mountId == null) {
|
mounts = aiMcpMountService.list(new LambdaQueryWrapper<AiMcpMount>()
|
.eq(AiMcpMount::getTenantId, tenantId)
|
.eq(AiMcpMount::getEnabledFlag, 1)
|
.eq(AiMcpMount::getStatus, 1)
|
.orderByAsc(AiMcpMount::getMountCode, AiMcpMount::getId));
|
} else {
|
mounts = new ArrayList<>();
|
AiMcpMount mount = aiMcpMountService.getTenantMount(tenantId, mountId);
|
if (mount != null && Integer.valueOf(1).equals(mount.getEnabledFlag()) && Integer.valueOf(1).equals(mount.getStatus())) {
|
mounts.add(mount);
|
}
|
}
|
for (AiMcpMount mount : mounts) {
|
try {
|
if (AiMcpConstants.TRANSPORT_INTERNAL.equalsIgnoreCase(mount.getTransportType())) {
|
output.addAll(buildInternalTools(tenantId, mount));
|
} else if (AiMcpConstants.TRANSPORT_HTTP.equalsIgnoreCase(mount.getTransportType())) {
|
output.addAll(loadCachedExternalTools(tenantId, mount));
|
} else if (AiMcpConstants.TRANSPORT_SSE.equalsIgnoreCase(mount.getTransportType())) {
|
output.addAll(loadCachedExternalTools(tenantId, mount));
|
}
|
} catch (Exception ignore) {
|
}
|
}
|
return output;
|
}
|
|
/**
|
* 仅返回系统内置工具目录。
|
*/
|
public List<AiMcpToolDescriptor> listInternalTools(Long tenantId) {
|
AiMcpMount mount = aiMcpMountService.getTenantMountByCode(tenantId, AiMcpConstants.DEFAULT_LOCAL_MOUNT_CODE);
|
if (mount == null || !Integer.valueOf(1).equals(mount.getEnabledFlag()) || !Integer.valueOf(1).equals(mount.getStatus())) {
|
return new ArrayList<>();
|
}
|
return buildInternalTools(tenantId, mount);
|
}
|
|
/**
|
* 测试指定挂载的连通性与工具发现能力，并把结果回写到挂载测试状态字段。
|
*/
|
public Map<String, Object> testMount(Long tenantId, Long mountId) {
|
AiMcpMount mount = aiMcpMountService.getTenantMount(tenantId, mountId);
|
if (mount == null) {
|
throw new IllegalArgumentException("MCP挂载不存在");
|
}
|
Map<String, Object> payload = new LinkedHashMap<>();
|
payload.put("mountCode", mount.getMountCode());
|
payload.put("transportType", mount.getTransportType());
|
if (AiMcpConstants.TRANSPORT_INTERNAL.equalsIgnoreCase(mount.getTransportType())) {
|
List<AiMcpToolDescriptor> tools = buildInternalTools(tenantId, mount);
|
payload.put("success", true);
|
payload.put("toolCount", tools.size());
|
payload.put("tools", tools);
|
updateTestState(mount, 1, "内部工具挂载正常", tools.size());
|
return payload;
|
}
|
ExternalToolsResult testResult = loadExternalToolsWithTransport(mount);
|
List<AiMcpToolDescriptor> tools = testResult.tools;
|
payload.put("success", true);
|
payload.put("toolCount", tools.size());
|
payload.put("tools", tools);
|
payload.put("resolvedTransportType", testResult.transportType);
|
payload.put("recommendedTransportType", testResult.transportType);
|
payload.put("message", buildExternalSuccessMessage(testResult.transportType, tools.size()));
|
updateTestState(mount, 1, String.valueOf(payload.get("message")), tools.size());
|
return payload;
|
}
|
|
/**
|
* 以“预览”模式执行一次工具调用，便于后台页面调试工具返回内容。
|
*/
|
public AiDiagnosticToolResult previewTool(Long tenantId, String mountCode, String toolCode, String sceneCode, String question) {
|
AiMcpMount mount = aiMcpMountService.getTenantMountByCode(tenantId, mountCode);
|
if (mount == null) {
|
throw new IllegalArgumentException("MCP挂载不存在");
|
}
|
AiPromptContext context = new AiPromptContext()
|
.setTenantId(tenantId)
|
.setSceneCode(sceneCode == null || sceneCode.trim().isEmpty() ? AiSceneCode.SYSTEM_DIAGNOSE : sceneCode)
|
.setQuestion(question == null || question.trim().isEmpty() ? "请执行一次MCP工具预览" : question);
|
if (AiMcpConstants.TRANSPORT_HTTP.equalsIgnoreCase(mount.getTransportType())
|
|| AiMcpConstants.TRANSPORT_SSE.equalsIgnoreCase(mount.getTransportType())) {
|
return executeExternalTool(mount, toolCode, context, buildToolArguments(context, null));
|
}
|
return executeInternalTool(mountCode, toolCode, context);
|
}
|
|
/**
|
* 根据工具描述符执行一次工具调用。
|
*/
|
public AiDiagnosticToolResult executeTool(Long tenantId, AiMcpToolDescriptor descriptor, AiPromptContext context) {
|
if (descriptor == null) {
|
throw new IllegalArgumentException("MCP工具不存在");
|
}
|
if (AiMcpConstants.TRANSPORT_HTTP.equalsIgnoreCase(descriptor.getTransportType())
|
|| AiMcpConstants.TRANSPORT_SSE.equalsIgnoreCase(descriptor.getTransportType())) {
|
AiMcpMount mount = aiMcpMountService.getTenantMountByCode(tenantId, descriptor.getMountCode());
|
if (mount == null) {
|
throw new IllegalArgumentException("MCP挂载不存在");
|
}
|
return executeExternalTool(mount, descriptor.getToolCode(), context, buildToolArguments(context, descriptor));
|
}
|
return executeInternalTool(descriptor.getMountCode(), descriptor.getToolCode(), context);
|
}
|
|
/**
|
* 根据完整 MCP 工具名执行一次工具调用，通常供协议层直接使用。
|
*/
|
public AiDiagnosticToolResult executeTool(Long tenantId, String mcpToolName, AiPromptContext context, Map<String, Object> arguments) {
|
AiMcpToolDescriptor descriptor = findDescriptor(tenantId, mcpToolName);
|
if (descriptor == null) {
|
throw new IllegalArgumentException("MCP工具不存在");
|
}
|
if (AiMcpConstants.TRANSPORT_HTTP.equalsIgnoreCase(descriptor.getTransportType())
|
|| AiMcpConstants.TRANSPORT_SSE.equalsIgnoreCase(descriptor.getTransportType())) {
|
AiMcpMount mount = aiMcpMountService.getTenantMountByCode(tenantId, descriptor.getMountCode());
|
if (mount == null) {
|
throw new IllegalArgumentException("MCP挂载不存在");
|
}
|
return executeExternalTool(mount, descriptor.getToolCode(), context, arguments);
|
}
|
return executeInternalTool(descriptor.getMountCode(), descriptor.getToolCode(), context);
|
}
|
|
/**
|
* 确保租户存在默认本地 MCP 挂载。
|
*/
|
public void ensureDefaultMount(Long tenantId, Long userId) {
|
if (aiMcpMountService.getTenantMountByCode(tenantId, AiMcpConstants.DEFAULT_LOCAL_MOUNT_CODE) != null) {
|
return;
|
}
|
Date now = new Date();
|
AiMcpMount mount = new AiMcpMount()
|
.setUuid(String.valueOf(System.currentTimeMillis()))
|
.setName(AiMcpConstants.DEFAULT_LOCAL_MOUNT_NAME)
|
.setMountCode(AiMcpConstants.DEFAULT_LOCAL_MOUNT_CODE)
|
.setTransportType(AiMcpConstants.TRANSPORT_INTERNAL)
|
.setUrl("/ai/mcp")
|
.setEnabledFlag(1)
|
.setTimeoutMs(10000)
|
.setStatus(1)
|
.setDeleted(0)
|
.setTenantId(tenantId)
|
.setCreateBy(userId)
|
.setCreateTime(now)
|
.setUpdateBy(userId)
|
.setUpdateTime(now)
|
.setMemo("默认挂载当前 WMS AI 内置工具集合");
|
aiMcpMountService.save(mount);
|
}
|
|
/**
|
* 为内部工具结果补齐挂载编码和标准 MCP 工具名。
|
*/
|
public AiDiagnosticToolResult decorateResult(AiDiagnosticToolResult result) {
|
if (result == null) {
|
return null;
|
}
|
return decorateResult(result, AiMcpConstants.DEFAULT_LOCAL_MOUNT_CODE, findProvider(result.getToolCode()));
|
}
|
|
private AiDiagnosticToolResult decorateResult(AiDiagnosticToolResult result, String mountCode, AiDiagnosticDataProvider provider) {
|
String actualMountCode = mountCode == null || mountCode.trim().isEmpty() ? AiMcpConstants.DEFAULT_LOCAL_MOUNT_CODE : mountCode;
|
result.setMountCode(actualMountCode);
|
result.setMcpToolName(aiMcpPayloadMapper.buildMcpToolName(actualMountCode, result.getToolCode()));
|
if ((result.getToolName() == null || result.getToolName().trim().isEmpty()) && provider != null) {
|
result.setToolName(provider.getToolName());
|
}
|
return result;
|
}
|
|
/**
|
* 按当前租户的工具配置生成内部 MCP 工具目录。
|
*/
|
private List<AiMcpToolDescriptor> buildInternalTools(Long tenantId, AiMcpMount mount) {
|
Map<String, AiDiagnosticToolConfig> configMap = buildInternalConfigMap(tenantId);
|
List<AiDiagnosticDataProvider> sortedProviders = new ArrayList<>(providers);
|
sortedProviders.sort(Comparator.comparingInt(AiDiagnosticDataProvider::getOrder));
|
List<AiMcpToolDescriptor> output = new ArrayList<>();
|
for (AiDiagnosticDataProvider provider : sortedProviders) {
|
AiDiagnosticToolConfig config = configMap.get(provider.getToolCode());
|
String usageScope = aiMcpPayloadMapper.resolveUsageScope(
|
config == null ? null : config.getSceneCode(),
|
config == null ? 1 : config.getEnabledFlag(),
|
config == null ? null : config.getUsageScope()
|
);
|
output.add(new AiMcpToolDescriptor()
|
.setMountCode(mount.getMountCode())
|
.setMountName(mount.getName())
|
.setToolCode(provider.getToolCode())
|
.setMcpToolName(aiMcpPayloadMapper.buildMcpToolName(mount.getMountCode(), provider.getToolCode()))
|
.setToolName(provider.getToolName())
|
.setSceneCode(aiMcpPayloadMapper.resolveSceneCode(usageScope))
|
.setDescription(provider.getDefaultToolPrompt())
|
.setEnabledFlag(AiMcpConstants.USAGE_SCOPE_DISABLED.equals(usageScope) ? 0 : (config == null ? 1 : config.getEnabledFlag()))
|
.setPriority(config == null ? provider.getOrder() : config.getPriority())
|
.setToolPrompt(config == null ? provider.getDefaultToolPrompt() : config.getToolPrompt())
|
.setUsageScope(usageScope)
|
.setTransportType(mount.getTransportType())
|
.setInputSchema(aiMcpPayloadMapper.defaultInputSchema(true)));
|
}
|
return output;
|
}
|
|
/**
|
* 为内置工具目录选择一条最合适的有效配置。
|
* 目录层只有一条工具描述，因此这里优先保留启用且状态正常的配置，
|
* 并优先选择“聊天与诊断都可用”的配置，再退回到“仅诊断”配置。
|
*/
|
private Map<String, AiDiagnosticToolConfig> buildInternalConfigMap(Long tenantId) {
|
Map<String, AiDiagnosticToolConfig> configMap = new LinkedHashMap<>();
|
for (AiDiagnosticToolConfig item : aiDiagnosticToolConfigService.listTenantConfigs(tenantId)) {
|
if (item == null || !Integer.valueOf(1).equals(item.getStatus())) {
|
continue;
|
}
|
AiDiagnosticToolConfig existed = configMap.get(item.getToolCode());
|
if (existed == null || preferInternalConfig(item, existed)) {
|
configMap.put(item.getToolCode(), item);
|
}
|
}
|
return configMap;
|
}
|
|
/**
|
* 内置工具目录优先展示用途更广的配置，其次比较优先级。
|
*/
|
private boolean preferInternalConfig(AiDiagnosticToolConfig candidate, AiDiagnosticToolConfig current) {
|
String candidateUsageScope = aiMcpPayloadMapper.resolveUsageScope(
|
candidate.getSceneCode(),
|
candidate.getEnabledFlag(),
|
candidate.getUsageScope()
|
);
|
String currentUsageScope = aiMcpPayloadMapper.resolveUsageScope(
|
current.getSceneCode(),
|
current.getEnabledFlag(),
|
current.getUsageScope()
|
);
|
int candidateRank = usageScopeRank(candidateUsageScope);
|
int currentRank = usageScopeRank(currentUsageScope);
|
if (candidateRank != currentRank) {
|
return candidateRank < currentRank;
|
}
|
Integer candidatePriority = candidate.getPriority() == null ? Integer.MAX_VALUE : candidate.getPriority();
|
Integer currentPriority = current.getPriority() == null ? Integer.MAX_VALUE : current.getPriority();
|
return candidatePriority < currentPriority;
|
}
|
|
private int usageScopeRank(String usageScope) {
|
if (AiMcpConstants.USAGE_SCOPE_CHAT_AND_DIAGNOSE.equals(usageScope)) {
|
return 0;
|
}
|
if (AiMcpConstants.USAGE_SCOPE_DIAGNOSE_ONLY.equals(usageScope)) {
|
return 1;
|
}
|
return 2;
|
}
|
|
/**
|
* 按工具编码定位内部工具实现。
|
*/
|
private AiDiagnosticDataProvider findProvider(String toolCode) {
|
for (AiDiagnosticDataProvider provider : providers) {
|
if (provider.getToolCode().equals(toolCode)) {
|
return provider;
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 更新挂载测试结果和工具数量，并清理缓存。
|
*/
|
private void updateTestState(AiMcpMount mount, Integer result, String message, Integer toolCount) {
|
mount.setLastTestResult(result);
|
mount.setLastTestMessage(message);
|
mount.setLastToolCount(toolCount);
|
mount.setLastTestTime(new Date());
|
mount.setUpdateTime(new Date());
|
aiMcpMountService.updateById(mount);
|
if (mount.getId() != null) {
|
externalToolCache.remove(buildCacheKey(mount.getTenantId(), mount));
|
}
|
}
|
|
/**
|
* 执行内部 MCP 工具。
|
*/
|
private AiDiagnosticToolResult executeInternalTool(String mountCode, String toolCode, AiPromptContext context) {
|
AiDiagnosticDataProvider provider = findProvider(toolCode);
|
if (provider == null) {
|
throw new IllegalArgumentException("MCP工具不存在");
|
}
|
AiDiagnosticToolResult result = provider.buildDiagnosticData(context);
|
if (result == null) {
|
return new AiDiagnosticToolResult()
|
.setToolCode(toolCode)
|
.setMountCode(mountCode)
|
.setMcpToolName(aiMcpPayloadMapper.buildMcpToolName(mountCode, toolCode))
|
.setToolName(provider.getToolName())
|
.setSeverity("WARN")
|
.setSummaryText("工具没有返回结果");
|
}
|
return decorateResult(result, mountCode, provider);
|
}
|
|
/**
|
* 执行外部 MCP 工具，并补齐本地系统所需的统一字段。
|
*/
|
private AiDiagnosticToolResult executeExternalTool(AiMcpMount mount, String toolCode,
|
AiPromptContext context, Map<String, Object> arguments) {
|
ExternalToolCallResult callResult = callExternalTool(mount, toolCode, arguments);
|
AiDiagnosticToolResult result = callResult.result;
|
return result
|
.setToolCode(toolCode)
|
.setMountCode(mount.getMountCode())
|
.setMcpToolName(aiMcpPayloadMapper.buildMcpToolName(mount.getMountCode(), toolCode))
|
.setToolName(result.getToolName() == null || result.getToolName().trim().isEmpty() ? toolCode : result.getToolName())
|
.setRawMeta(result.getRawMeta() == null ? new LinkedHashMap<String, Object>() : result.getRawMeta());
|
}
|
|
/**
|
* 真正加载外部工具目录，不带缓存。
|
*/
|
private List<AiMcpToolDescriptor> loadExternalTools(AiMcpMount mount) {
|
return loadExternalToolsWithTransport(mount).tools;
|
}
|
|
/**
|
* 带短期缓存地加载外部工具目录，避免同一挂载在短时间内重复握手。
|
*/
|
private List<AiMcpToolDescriptor> loadCachedExternalTools(Long tenantId, AiMcpMount mount) {
|
String cacheKey = buildCacheKey(tenantId, mount);
|
CachedTools cached = externalToolCache.get(cacheKey);
|
long now = System.currentTimeMillis();
|
if (cached != null && cached.expireAt > now) {
|
return new ArrayList<>(cached.tools);
|
}
|
List<AiMcpToolDescriptor> tools = loadExternalTools(mount);
|
externalToolCache.put(cacheKey, new CachedTools(new ArrayList<>(tools), now + EXTERNAL_TOOL_CACHE_TTL_MS));
|
return tools;
|
}
|
|
/**
|
* 生成外部工具目录缓存 key。
|
*/
|
private String buildCacheKey(Long tenantId, AiMcpMount mount) {
|
return String.valueOf(tenantId) + ":" + mount.getId() + ":" + (mount.getUpdateTime() == null ? 0L : mount.getUpdateTime().getTime());
|
}
|
|
/**
|
* 按完整 MCP 工具名反查工具描述符。
|
*/
|
private AiMcpToolDescriptor findDescriptor(Long tenantId, String mcpToolName) {
|
for (AiMcpToolDescriptor descriptor : listTools(tenantId, null)) {
|
if (descriptor != null && mcpToolName.equals(descriptor.getMcpToolName())) {
|
return descriptor;
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 根据上下文和工具信息构造远程调用参数。
|
*/
|
private Map<String, Object> buildToolArguments(AiPromptContext context, AiMcpToolDescriptor descriptor) {
|
Map<String, Object> arguments = new LinkedHashMap<>();
|
if (context != null) {
|
arguments.put("tenantId", context.getTenantId());
|
arguments.put("sceneCode", context.getSceneCode());
|
arguments.put("question", context.getQuestion());
|
arguments.put("sessionId", context.getSessionId());
|
}
|
if (descriptor != null) {
|
arguments.put("toolName", descriptor.getToolName());
|
arguments.put("mountCode", descriptor.getMountCode());
|
}
|
return arguments;
|
}
|
|
/**
|
* 生成外部挂载测试成功文案。
|
*/
|
private String buildExternalSuccessMessage(String transportType, int toolCount) {
|
String prefix = AiMcpConstants.TRANSPORT_SSE.equalsIgnoreCase(transportType)
|
? "远程SSE MCP工具加载成功"
|
: "远程Streamable HTTP MCP工具加载成功";
|
return prefix + "，发现 " + toolCount + " 个工具";
|
}
|
|
/**
|
* 根据挂载配置选择 HTTP / SSE 客户端去加载外部工具目录。
|
* AUTO 模式会依次尝试 Streamable HTTP 和 SSE。
|
*/
|
private ExternalToolsResult loadExternalToolsWithTransport(AiMcpMount mount) {
|
if (AiMcpConstants.TRANSPORT_SSE.equalsIgnoreCase(mount.getTransportType())) {
|
return new ExternalToolsResult(AiMcpConstants.TRANSPORT_SSE, aiMcpSseClient.listTools(mount));
|
}
|
if (AiMcpConstants.TRANSPORT_HTTP.equalsIgnoreCase(mount.getTransportType())) {
|
return new ExternalToolsResult(AiMcpConstants.TRANSPORT_HTTP, aiMcpHttpClient.listTools(mount));
|
}
|
List<String> errors = new ArrayList<>();
|
try {
|
return new ExternalToolsResult(AiMcpConstants.TRANSPORT_HTTP, aiMcpHttpClient.listTools(copyMountWithTransport(mount, AiMcpConstants.TRANSPORT_HTTP)));
|
} catch (Exception e) {
|
errors.add("HTTP: " + e.getMessage());
|
}
|
try {
|
return new ExternalToolsResult(AiMcpConstants.TRANSPORT_SSE, aiMcpSseClient.listTools(copyMountWithTransport(mount, AiMcpConstants.TRANSPORT_SSE)));
|
} catch (Exception e) {
|
errors.add("SSE: " + e.getMessage());
|
}
|
throw new IllegalStateException(String.join("；", errors));
|
}
|
|
/**
|
* 根据挂载配置选择 HTTP / SSE 客户端执行远程工具。
|
*/
|
private ExternalToolCallResult callExternalTool(AiMcpMount mount, String toolCode, Map<String, Object> arguments) {
|
if (AiMcpConstants.TRANSPORT_SSE.equalsIgnoreCase(mount.getTransportType())) {
|
return new ExternalToolCallResult(AiMcpConstants.TRANSPORT_SSE, aiMcpSseClient.callTool(mount, toolCode, arguments));
|
}
|
if (AiMcpConstants.TRANSPORT_HTTP.equalsIgnoreCase(mount.getTransportType())) {
|
return new ExternalToolCallResult(AiMcpConstants.TRANSPORT_HTTP, aiMcpHttpClient.callTool(mount, toolCode, arguments));
|
}
|
List<String> errors = new ArrayList<>();
|
try {
|
return new ExternalToolCallResult(
|
AiMcpConstants.TRANSPORT_HTTP,
|
aiMcpHttpClient.callTool(copyMountWithTransport(mount, AiMcpConstants.TRANSPORT_HTTP), toolCode, arguments)
|
);
|
} catch (Exception e) {
|
errors.add("HTTP: " + e.getMessage());
|
}
|
try {
|
return new ExternalToolCallResult(
|
AiMcpConstants.TRANSPORT_SSE,
|
aiMcpSseClient.callTool(copyMountWithTransport(mount, AiMcpConstants.TRANSPORT_SSE), toolCode, arguments)
|
);
|
} catch (Exception e) {
|
errors.add("SSE: " + e.getMessage());
|
}
|
throw new IllegalStateException(String.join("；", errors));
|
}
|
|
/**
|
* 复制一份挂载对象，并覆盖指定传输协议，供 AUTO 探测流程使用。
|
*/
|
private AiMcpMount copyMountWithTransport(AiMcpMount mount, String transportType) {
|
return new AiMcpMount()
|
.setId(mount.getId())
|
.setUuid(mount.getUuid())
|
.setName(mount.getName())
|
.setMountCode(mount.getMountCode())
|
.setTransportType(transportType)
|
.setUrl(mount.getUrl())
|
.setAuthType(mount.getAuthType())
|
.setAuthValue(mount.getAuthValue())
|
.setUsageScope(mount.getUsageScope())
|
.setEnabledFlag(mount.getEnabledFlag())
|
.setTimeoutMs(mount.getTimeoutMs())
|
.setStatus(mount.getStatus())
|
.setTenantId(mount.getTenantId())
|
.setCreateBy(mount.getCreateBy())
|
.setCreateTime(mount.getCreateTime())
|
.setUpdateBy(mount.getUpdateBy())
|
.setUpdateTime(mount.getUpdateTime())
|
.setMemo(mount.getMemo());
|
}
|
|
private static class CachedTools {
|
private final List<AiMcpToolDescriptor> tools;
|
private final long expireAt;
|
|
/**
|
* 保存一次外部工具目录缓存内容及其失效时间。
|
*/
|
private CachedTools(List<AiMcpToolDescriptor> tools, long expireAt) {
|
this.tools = tools;
|
this.expireAt = expireAt;
|
}
|
}
|
|
private static class ExternalToolsResult {
|
private final String transportType;
|
private final List<AiMcpToolDescriptor> tools;
|
|
/**
|
* 保存一次外部工具目录加载结果及实际命中的传输协议。
|
*/
|
private ExternalToolsResult(String transportType, List<AiMcpToolDescriptor> tools) {
|
this.transportType = transportType;
|
this.tools = tools;
|
}
|
}
|
|
private static class ExternalToolCallResult {
|
private final String transportType;
|
private final AiDiagnosticToolResult result;
|
|
/**
|
* 保存一次外部工具调用结果及实际命中的传输协议。
|
*/
|
private ExternalToolCallResult(String transportType, AiDiagnosticToolResult result) {
|
this.transportType = transportType;
|
this.result = result;
|
}
|
}
|
}
|
