package com.vincent.rsf.server.ai.service.impl;
|
|
import com.fasterxml.jackson.databind.JsonNode;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.vincent.rsf.framework.exception.CoolException;
|
import com.vincent.rsf.server.ai.config.AiDefaults;
|
import com.vincent.rsf.server.ai.dto.AiParamValidateResultDto;
|
import com.vincent.rsf.server.ai.entity.AiParam;
|
import lombok.extern.slf4j.Slf4j;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Component;
|
import org.springframework.http.MediaType;
|
import org.springframework.http.ResponseEntity;
|
import org.springframework.http.client.SimpleClientHttpRequestFactory;
|
import org.springframework.util.StringUtils;
|
import org.springframework.web.client.RestClient;
|
import org.springframework.web.client.RestClientResponseException;
|
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
@Component
|
@Slf4j
|
@RequiredArgsConstructor
|
public class AiParamValidationSupport {
|
|
private static final String PROBE_MESSAGE = "请回复 OK";
|
private static final int MAX_DETAIL_TEXT_LENGTH = 8000;
|
|
private final ObjectMapper objectMapper;
|
|
/**
|
* 对一份 AI 参数草稿做真实连通性校验。
|
* 校验方式不是简单判断字段非空，而是直接构造聊天模型并发起一次最小探测调用，
|
* 用返回结果和耗时生成前端可展示的校验报告。
|
*/
|
public AiParamValidateResultDto validate(AiParam aiParam) {
|
long startedAt = System.currentTimeMillis();
|
ValidationRequestContext context = buildValidationRequestContext(aiParam);
|
try {
|
ValidationResponseSnapshot responseSnapshot = executeValidation(context);
|
String assistantText = extractAssistantText(responseSnapshot.responseBody());
|
if (!StringUtils.hasText(assistantText)) {
|
throw new CoolException("模型已连接，但未返回有效响应");
|
}
|
long elapsedMs = System.currentTimeMillis() - startedAt;
|
String detail = buildValidationDetail(
|
context.requestUrl(),
|
context.requestBody(),
|
responseSnapshot.statusCode(),
|
responseSnapshot.responseBody(),
|
assistantText,
|
null
|
);
|
log.info("AI 参数草稿校验成功, model={}, requestUrl={}, responseStatus={}",
|
aiParam.getModel(), context.requestUrl(), responseSnapshot.statusCode());
|
return AiParamValidateResultDto.builder()
|
.status(AiDefaults.PARAM_VALIDATE_VALID)
|
.message("模型连通成功")
|
.detail(detail)
|
.model(aiParam.getModel())
|
.elapsedMs(elapsedMs)
|
.validatedAt(formatDate(new Date()))
|
.requestUrl(context.requestUrl())
|
.requestBody(context.requestBody())
|
.responseStatus(responseSnapshot.statusCode())
|
.responseBody(abbreviate(responseSnapshot.responseBody()))
|
.build();
|
} catch (Exception e) {
|
long elapsedMs = System.currentTimeMillis() - startedAt;
|
ValidationErrorSnapshot errorSnapshot = extractErrorSnapshot(e);
|
String message = e instanceof CoolException
|
? e.getMessage()
|
: "模型验证失败: " + firstNonBlank(
|
extractResponseErrorMessage(errorSnapshot.responseBody()),
|
errorSnapshot.errorMessage(),
|
e.getMessage());
|
String detail = buildValidationDetail(
|
context.requestUrl(),
|
context.requestBody(),
|
errorSnapshot.statusCode(),
|
errorSnapshot.responseBody(),
|
null,
|
e
|
);
|
log.warn("AI 参数草稿校验失败, model={}, requestUrl={}, responseStatus={}, error={}",
|
aiParam.getModel(), context.requestUrl(), errorSnapshot.statusCode(), errorSnapshot.errorMessage(), e);
|
return AiParamValidateResultDto.builder()
|
.status(AiDefaults.PARAM_VALIDATE_INVALID)
|
.message(message)
|
.detail(detail)
|
.model(aiParam.getModel())
|
.elapsedMs(elapsedMs)
|
.validatedAt(formatDate(new Date()))
|
.requestUrl(context.requestUrl())
|
.requestBody(context.requestBody())
|
.responseStatus(errorSnapshot.statusCode())
|
.responseBody(abbreviate(errorSnapshot.responseBody()))
|
.build();
|
}
|
}
|
|
private ValidationRequestContext buildValidationRequestContext(AiParam aiParam) {
|
AiOpenAiApiSupport.EndpointConfig endpointConfig = AiOpenAiApiSupport.resolveEndpointConfig(aiParam.getBaseUrl());
|
String requestUrl = endpointConfig.baseUrl() + endpointConfig.completionsPath();
|
Map<String, Object> requestBody = new LinkedHashMap<>();
|
requestBody.put("model", aiParam.getModel());
|
requestBody.put("messages", List.of(Map.of("role", "user", "content", PROBE_MESSAGE)));
|
requestBody.put("stream", false);
|
if (aiParam.getTemperature() != null) {
|
requestBody.put("temperature", aiParam.getTemperature());
|
}
|
if (aiParam.getTopP() != null) {
|
requestBody.put("top_p", aiParam.getTopP());
|
}
|
if (aiParam.getMaxTokens() != null) {
|
requestBody.put("max_tokens", aiParam.getMaxTokens());
|
}
|
return new ValidationRequestContext(
|
buildRestClient(aiParam),
|
requestUrl,
|
requestBody,
|
toPrettyJson(requestBody)
|
);
|
}
|
|
private RestClient buildRestClient(AiParam aiParam) {
|
int timeoutMs = aiParam.getTimeoutMs() == null ? AiDefaults.DEFAULT_TIMEOUT_MS : aiParam.getTimeoutMs();
|
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
|
requestFactory.setConnectTimeout(timeoutMs);
|
requestFactory.setReadTimeout(timeoutMs);
|
return RestClient.builder()
|
.requestFactory(requestFactory)
|
.defaultHeader("Authorization", "Bearer " + aiParam.getApiKey())
|
.build();
|
}
|
|
private ValidationResponseSnapshot executeValidation(ValidationRequestContext context) {
|
ResponseEntity<String> responseEntity = context.restClient().post()
|
.uri(context.requestUrl())
|
.contentType(MediaType.APPLICATION_JSON)
|
.accept(MediaType.APPLICATION_JSON)
|
.body(context.requestBodyMap())
|
.retrieve()
|
.toEntity(String.class);
|
return new ValidationResponseSnapshot(
|
responseEntity.getStatusCode().value(),
|
responseEntity.getBody()
|
);
|
}
|
|
private String extractAssistantText(String responseBody) {
|
if (!StringUtils.hasText(responseBody)) {
|
return "";
|
}
|
try {
|
JsonNode root = objectMapper.readTree(responseBody);
|
List<JsonNode> candidates = List.of(
|
root.at("/choices/0/message/content"),
|
root.at("/choices/0/text"),
|
root.at("/output_text"),
|
root.at("/output/0/content/0/text")
|
);
|
for (JsonNode candidate : candidates) {
|
String text = flattenText(candidate);
|
if (StringUtils.hasText(text)) {
|
return text;
|
}
|
}
|
} catch (Exception e) {
|
log.debug("解析 AI 参数草稿校验响应失败: {}", e.getMessage());
|
}
|
return "";
|
}
|
|
private String flattenText(JsonNode node) {
|
if (node == null || node.isMissingNode() || node.isNull()) {
|
return "";
|
}
|
if (node.isTextual()) {
|
return node.asText();
|
}
|
if (node.isArray()) {
|
List<String> parts = new ArrayList<>();
|
for (JsonNode item : node) {
|
String text = flattenText(item);
|
if (StringUtils.hasText(text)) {
|
parts.add(text);
|
}
|
}
|
return String.join("\n", parts).trim();
|
}
|
if (node.isObject()) {
|
String text = flattenText(node.get("text"));
|
if (StringUtils.hasText(text)) {
|
return text;
|
}
|
text = flattenText(node.get("content"));
|
if (StringUtils.hasText(text)) {
|
return text;
|
}
|
}
|
return "";
|
}
|
|
private ValidationErrorSnapshot extractErrorSnapshot(Throwable throwable) {
|
RestClientResponseException responseException = findResponseException(throwable);
|
if (responseException != null) {
|
return new ValidationErrorSnapshot(
|
responseException.getStatusCode().value(),
|
responseException.getResponseBodyAsString(),
|
rootMessage(throwable)
|
);
|
}
|
return new ValidationErrorSnapshot(null, null, rootMessage(throwable));
|
}
|
|
private RestClientResponseException findResponseException(Throwable throwable) {
|
Throwable current = throwable;
|
while (current != null) {
|
if (current instanceof RestClientResponseException responseException) {
|
return responseException;
|
}
|
current = current.getCause();
|
}
|
return null;
|
}
|
|
private String extractResponseErrorMessage(String responseBody) {
|
if (!StringUtils.hasText(responseBody)) {
|
return "";
|
}
|
try {
|
JsonNode root = objectMapper.readTree(responseBody);
|
List<JsonNode> candidates = List.of(
|
root.at("/error/message"),
|
root.at("/message"),
|
root.at("/detail")
|
);
|
for (JsonNode candidate : candidates) {
|
String text = flattenText(candidate);
|
if (StringUtils.hasText(text)) {
|
return text;
|
}
|
}
|
} catch (Exception e) {
|
log.debug("解析 AI 参数草稿校验错误响应失败: {}", e.getMessage());
|
}
|
return "";
|
}
|
|
private String buildValidationDetail(String requestUrl,
|
String requestBody,
|
Integer responseStatus,
|
String responseBody,
|
String assistantText,
|
Throwable throwable) {
|
List<String> sections = new ArrayList<>();
|
sections.add("请求 URL:\n" + defaultText(requestUrl));
|
sections.add("请求体:\n" + defaultText(requestBody));
|
sections.add("HTTP 状态:\n" + (responseStatus == null ? "--" : responseStatus));
|
if (StringUtils.hasText(assistantText)) {
|
sections.add("解析结果:\n" + abbreviate(assistantText));
|
}
|
sections.add("响应结果:\n" + defaultText(abbreviate(responseBody)));
|
if (throwable != null) {
|
sections.add("异常类型:\n" + throwable.getClass().getName());
|
sections.add("异常信息:\n" + defaultText(rootMessage(throwable)));
|
}
|
return String.join("\n\n", sections);
|
}
|
|
private String toPrettyJson(Object value) {
|
try {
|
return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(value);
|
} catch (Exception e) {
|
return String.valueOf(value);
|
}
|
}
|
|
private String rootMessage(Throwable throwable) {
|
Throwable current = throwable;
|
while (current != null && current.getCause() != null) {
|
current = current.getCause();
|
}
|
return current == null ? "" : current.getMessage();
|
}
|
|
private String defaultText(String value) {
|
return StringUtils.hasText(value) ? value : "--";
|
}
|
|
private String firstNonBlank(String... values) {
|
for (String value : values) {
|
if (StringUtils.hasText(value)) {
|
return value;
|
}
|
}
|
return "";
|
}
|
|
private String abbreviate(String value) {
|
if (!StringUtils.hasText(value)) {
|
return value;
|
}
|
if (value.length() <= MAX_DETAIL_TEXT_LENGTH) {
|
return value;
|
}
|
return value.substring(0, MAX_DETAIL_TEXT_LENGTH) + "\n...（已截断）";
|
}
|
|
private String formatDate(Date date) {
|
/** 统一输出给前端的校验时间格式。 */
|
return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
|
}
|
|
private record ValidationRequestContext(RestClient restClient,
|
String requestUrl,
|
Map<String, Object> requestBodyMap,
|
String requestBody) {
|
}
|
|
private record ValidationResponseSnapshot(int statusCode, String responseBody) {
|
}
|
|
private record ValidationErrorSnapshot(Integer statusCode, String responseBody, String errorMessage) {
|
}
|
}
|
