blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
zhou zhou
13 小时以前 1d0ab9996661fdc66037870d4b98037f2dfa079a 
 rsf-server/src/main/java/com/vincent/rsf/server/ai/service/impl/AiChatServiceImpl.java


@@ -14,6 +14,7 @@


import com.vincent.rsf.server.ai.dto.AiChatSessionDto;


import com.vincent.rsf.server.ai.dto.AiChatSessionPinRequest;


import com.vincent.rsf.server.ai.dto.AiChatSessionRenameRequest;


import com.vincent.rsf.server.ai.dto.AiChatToolEventDto;


import com.vincent.rsf.server.ai.dto.AiResolvedConfig;


import com.vincent.rsf.server.ai.entity.AiParam;


import com.vincent.rsf.server.ai.entity.AiPrompt;


@@ -34,6 +35,7 @@


import org.springframework.ai.chat.metadata.ChatResponseMetadata;


import org.springframework.ai.chat.metadata.Usage;


import org.springframework.ai.chat.model.ChatResponse;


import org.springframework.ai.chat.model.ToolContext;


import org.springframework.ai.chat.prompt.Prompt;


import org.springframework.ai.model.tool.DefaultToolCallingManager;


import org.springframework.ai.model.tool.ToolCallingManager;


@@ -66,6 +68,7 @@


import java.util.concurrent.CompletableFuture;


import java.util.concurrent.Executor;


import java.util.concurrent.atomic.AtomicReference;


import java.util.concurrent.atomic.AtomicLong;




@Slf4j


@Service


@@ -144,6 +147,7 @@


        String requestId = request.getRequestId();


        long startedAt = System.currentTimeMillis();


        AtomicReference<Long> firstTokenAtRef = new AtomicReference<>();


        AtomicLong toolCallSequence = new AtomicLong(0);


        Long sessionId = request.getSessionId();


        String model = null;


        try {


@@ -182,9 +186,13 @@


                log.info("AI chat started, requestId={}, userId={}, tenantId={}, sessionId={}, model={}",


                        requestId, userId, tenantId, session.getId(), resolvedModel);




                ToolCallback[] observableToolCallbacks = wrapToolCallbacks(


                        runtime.getToolCallbacks(), emitter, requestId, session.getId(), toolCallSequence


                );


                Prompt prompt = new Prompt(


                        buildPromptMessages(memory, mergedMessages, config.getPrompt(), request.getMetadata()),


                        buildChatOptions(config.getAiParam(), runtime.getToolCallbacks(), userId, request.getMetadata())


                        buildChatOptions(config.getAiParam(), observableToolCallbacks, userId, tenantId,


                                requestId, session.getId(), request.getMetadata())


                );


                OpenAiChatModel chatModel = createChatModel(config.getAiParam());


                if (Boolean.FALSE.equals(config.getAiParam().getStreamingEnabled())) {


@@ -392,7 +400,8 @@


                .build();


    }




    private OpenAiChatOptions buildChatOptions(AiParam aiParam, ToolCallback[] toolCallbacks, Long userId, Map<String, Object> metadata) {


    private OpenAiChatOptions buildChatOptions(AiParam aiParam, ToolCallback[] toolCallbacks, Long userId, Long tenantId,


                                               String requestId, Long sessionId, Map<String, Object> metadata) {


        if (userId == null) {


            throw buildAiException("AI_AUTH_USER_MISSING", AiErrorCategory.AUTH, "OPTIONS_BUILD", "当前登录用户不存在", null);


        }


@@ -404,16 +413,41 @@


                .streamUsage(true)


                .user(String.valueOf(userId));


        if (!Cools.isEmpty(toolCallbacks)) {


            builder.toolCallbacks(Arrays.asList(toolCallbacks));


            builder.toolCallbacks(Arrays.stream(toolCallbacks).toList());


        }


        Map<String, Object> toolContext = new LinkedHashMap<>();


        toolContext.put("userId", userId);


        toolContext.put("tenantId", tenantId);


        toolContext.put("requestId", requestId);


        toolContext.put("sessionId", sessionId);


        Map<String, String> metadataMap = new LinkedHashMap<>();


        if (metadata != null) {


            metadata.forEach((key, value) -> metadataMap.put(key, value == null ? "" : String.valueOf(value)));


            metadata.forEach((key, value) -> {


                String normalized = value == null ? "" : String.valueOf(value);


                metadataMap.put(key, normalized);


                toolContext.put(key, normalized);


            });


        }


        builder.toolContext(toolContext);


        if (!metadataMap.isEmpty()) {


            builder.metadata(metadataMap);


        }


        return builder.build();


    }




    private ToolCallback[] wrapToolCallbacks(ToolCallback[] toolCallbacks, SseEmitter emitter, String requestId,


                                             Long sessionId, AtomicLong toolCallSequence) {


        if (Cools.isEmpty(toolCallbacks)) {


            return toolCallbacks;


        }


        List<ToolCallback> wrappedCallbacks = new ArrayList<>();


        for (ToolCallback callback : toolCallbacks) {


            if (callback == null) {


                continue;


            }


            wrappedCallbacks.add(new ObservableToolCallback(callback, emitter, requestId, sessionId, toolCallSequence));


        }


        return wrappedCallbacks.toArray(new ToolCallback[0]);


    }




    private List<Message> buildPromptMessages(AiChatMemoryDto memory, List<AiChatMessageDto> sourceMessages, AiPrompt aiPrompt, Map<String, Object> metadata) {


@@ -516,6 +550,17 @@


        return response.getResult().getOutput().getText();


    }




    private String summarizeToolPayload(String content, int maxLength) {


        if (!StringUtils.hasText(content)) {


            return null;


        }


        String normalized = content.trim()


                .replace("\r", " ")


                .replace("\n", " ")


                .replaceAll("\\s+", " ");


        return normalized.length() > maxLength ? normalized.substring(0, maxLength) : normalized;


    }




    private void emitDone(SseEmitter emitter, String requestId, ChatResponseMetadata metadata, String fallbackModel, Long sessionId, long startedAt, Long firstTokenAt) {


        Usage usage = metadata == null ? null : metadata.getUsage();


        emitStrict(emitter, "done", AiChatDoneDto.builder()


@@ -584,4 +629,81 @@


        }


        return false;


    }




    private class ObservableToolCallback implements ToolCallback {




        private final ToolCallback delegate;


        private final SseEmitter emitter;


        private final String requestId;


        private final Long sessionId;


        private final AtomicLong toolCallSequence;




        private ObservableToolCallback(ToolCallback delegate, SseEmitter emitter, String requestId,


                                       Long sessionId, AtomicLong toolCallSequence) {


            this.delegate = delegate;


            this.emitter = emitter;


            this.requestId = requestId;


            this.sessionId = sessionId;


            this.toolCallSequence = toolCallSequence;


        }




        @Override


        public org.springframework.ai.tool.definition.ToolDefinition getToolDefinition() {


            return delegate.getToolDefinition();


        }




        @Override


        public org.springframework.ai.tool.metadata.ToolMetadata getToolMetadata() {


            return delegate.getToolMetadata();


        }




        @Override


        public String call(String toolInput) {


            return call(toolInput, null);


        }




        @Override


        public String call(String toolInput, ToolContext toolContext) {


            String toolName = delegate.getToolDefinition() == null ? "unknown" : delegate.getToolDefinition().name();


            String toolCallId = requestId + "-tool-" + toolCallSequence.incrementAndGet();


            long startedAt = System.currentTimeMillis();


            emitSafely(emitter, "tool_start", AiChatToolEventDto.builder()


                    .requestId(requestId)


                    .sessionId(sessionId)


                    .toolCallId(toolCallId)


                    .toolName(toolName)


                    .status("STARTED")


                    .inputSummary(summarizeToolPayload(toolInput, 400))


                    .timestamp(startedAt)


                    .build());


            try {


                String output = toolContext == null ? delegate.call(toolInput) : delegate.call(toolInput, toolContext);


                emitSafely(emitter, "tool_result", AiChatToolEventDto.builder()


                        .requestId(requestId)


                        .sessionId(sessionId)


                        .toolCallId(toolCallId)


                        .toolName(toolName)


                        .status("COMPLETED")


                        .inputSummary(summarizeToolPayload(toolInput, 400))


                        .outputSummary(summarizeToolPayload(output, 600))


                        .durationMs(System.currentTimeMillis() - startedAt)


                        .timestamp(System.currentTimeMillis())


                        .build());


                return output;


            } catch (RuntimeException e) {


                emitSafely(emitter, "tool_error", AiChatToolEventDto.builder()


                        .requestId(requestId)


                        .sessionId(sessionId)


                        .toolCallId(toolCallId)


                        .toolName(toolName)


                        .status("FAILED")


                        .inputSummary(summarizeToolPayload(toolInput, 400))


                        .errorMessage(e.getMessage())


                        .durationMs(System.currentTimeMillis() - startedAt)


                        .timestamp(System.currentTimeMillis())


                        .build());


                throw e;


            }


        }


    }


}