Playground

{
    "mcpServers": {
        "github": {
            "command": "npx",
            "args": [
                "/c",
                "npx",
                "-y",
                "@modelcontextprotocol/server-github"
            ],
            "env": {
                "GITHUB_PERSONAL_ACCESS_TOKEN": "your_github_token"
            }
        }
    }
}

resources
├── application-dev.yml
├── application-prod.yml
├── application.yml
├── banner.txt
├── db
├── logback-spring.xml
├── mcp-config.yml
├── mcp-libs
├── models.yaml
└── rag

{
    "mcpServers": {
        "weather": {
            "command": "java",
            "args": [
                "-Dspring.ai.mcp.server.stdio=true",
                "-Dspring.main.web-application-type=none",
                "-Dlogging.pattern.console=",
                "-jar",
                "D:\\open_sources\\spring-ai-alibaba-examples\\spring-ai-alibaba-mcp-example\\spring-ai-alibaba-mcp-build-example\\mcp-stdio-server-example\\target\\mcp-stdio-server-example-1.0.0.jar"
            ],
            "env": {}
        }
    }
}

<dependencies>

    <!-- This dependency is required when implementing Chat Memory functionality -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- playground text summarization functionality relies on tika to parse various input texts -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-tika-document-reader</artifactId>
        <version>${spring-ai.version}</version>
    </dependency>

    <!-- Spring AI MCP client related dependencies-->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-mcp-client</artifactId>
        <version>${spring-ai.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-autoconfigure-mcp-client</artifactId>
        <version>${spring-ai.version}</version>
    </dependency>

  <!-- Spring AI OpenAI Starter -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-starter-model-openai</artifactId>
        <version>${spring-ai.version}</version>
    </dependency>

    <!-- Spring AI RAG markdown text reading and parsing -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-markdown-document-reader</artifactId>
        <version>${spring-ai.version}</version>
    </dependency>

    <!-- Spring AI Vector Database Advisors -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-advisors-vector-store</artifactId>
        <version>${spring-ai.version}</version>
    </dependency>

    <!-- Spring AI Alibaba DashScope starter -->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
        <version>${spring-ai-alibaba.version}</version>
    </dependency>

    <!-- Spring AI Alibaba Memory implementation -->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-starter-memory</artifactId>
        <version>${spring-ai-alibaba.version}</version>
    </dependency>

    <!-- Spring AI Alibaba analyticdb vector database integration -->
    <dependency>
        <groupId>com.alibaba.cloud.ai</groupId>
        <artifactId>spring-ai-alibaba-starter-store-analyticdb</artifactId>
        <version>${spring-ai-alibaba.version}</version>
    </dependency>

    <!-- DB, providing storage support for ChatMemory and playground -->
    <dependency>
        <groupId>org.xerial</groupId>
        <artifactId>sqlite-jdbc</artifactId>
        <version>${sqlite-jdbc.version}</version>
    </dependency>

    <dependency>
        <groupId>org.hibernate.orm</groupId>
        <artifactId>hibernate-community-dialects</artifactId>
        <version>${hibernate.version}</version>
    </dependency>

    <!-- Playground observability integration -->
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-tracing-bridge-brave</artifactId>
        <version>${micrometr.version}</version>
        <exclusions>
            <exclusion>
                <artifactId>slf4j-api</artifactId>
                <groupId>org.slf4j</groupId>
            </exclusion>
        </exclusions>
    </dependency>

</dependencies>

<!-- Spring AI and Spring AI Alibaba dependency management -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud.ai</groupId>
            <artifactId>spring-ai-alibaba-bom</artifactId>
            <version>${spring-ai-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-bom</artifactId>
            <version>${spring-ai.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

@Bean
CommandLineRunner ingestTermOfServiceToVectorStore(VectorStoreDelegate vectorStoreDelegate) {
    return args -> {
       String type = System.getenv("VECTOR_STORE_TYPE");
       VectorStoreInitializer initializer = new VectorStoreInitializer();
       initializer.init(vectorStoreDelegate.getVectorStore(type));
    };
}

public class VectorStoreDelegate {

    private VectorStore simpleVectorStore;

    private VectorStore analyticdbVectorStore;

    public VectorStoreDelegate(VectorStore simpleVectorStore, VectorStore analyticdbVectorStore) {
       this.simpleVectorStore = simpleVectorStore;
       this.analyticdbVectorStore = analyticdbVectorStore;
    }

    public VectorStore getVectorStore(String vectorStoreType) {

       if (Objects.equals(vectorStoreType, "analyticdb") && analyticdbVectorStore != null) {
          return analyticdbVectorStore;
       }

       return simpleVectorStore;
    }
}

public void init(VectorStore vectorStore) throws Exception {
    List<MarkdownDocumentReader> markdownDocumentReaderList = loadMarkdownDocuments();

    int size = 0;
    if (markdownDocumentReaderList.isEmpty()) {
        logger.warn("No markdown documents found in the directory.");
        return;
    }

    logger.debug("Start to load markdown documents into vector store......");
    for (MarkdownDocumentReader markdownDocumentReader : markdownDocumentReaderList) {
        List<Document> documents = new TokenTextSplitter(2000, 1024, 10, 10000, true).transform(markdownDocumentReader.get());
        size += documents.size();

        // Split documents list into sublists with a maximum of 25 elements
        for (int i = 0; i < documents.size(); i += 25) {
            int end = Math.min(i + 25, documents.size());
            List<Document> subList = documents.subList(i, end);
            vectorStore.add(subList);
        }
    }
    logger.debug("Load markdown documents into vector store successfully. Load {} documents.", size);
}

@Service
public class SAARAGService {

    private final ChatClient client;

    private final VectorStoreDelegate vectorStoreDelegate;

    private String vectorStoreType;

    public SAARAGService(
          VectorStoreDelegate vectorStoreDelegate,
          SimpleLoggerAdvisor simpleLoggerAdvisor,
          MessageChatMemoryAdvisor messageChatMemoryAdvisor,
          @Qualifier("dashscopeChatModel") ChatModel chatModel,
          @Qualifier("systemPromptTemplate") PromptTemplate systemPromptTemplate
    ) {
       this.vectorStoreType = System.getenv("VECTOR_STORE_TYPE");
       this.vectorStoreDelegate = vectorStoreDelegate;
       this.client = ChatClient.builder(chatModel)
             .defaultSystem(
                   systemPromptTemplate.getTemplate()
             ).defaultAdvisors(
                   messageChatMemoryAdvisor,
                   simpleLoggerAdvisor
             ).build();
    }

    public Flux<String> ragChat(String chatId, String prompt) {

       return client.prompt()
             .user(prompt)
             .advisors(memoryAdvisor -> memoryAdvisor
                   .param(ChatMemory.CONVERSATION_ID, chatId)
             ).advisors(
                   QuestionAnswerAdvisor
                         .builder(vectorStoreDelegate.getVectorStore(vectorStoreType))
                         .searchRequest(
                               SearchRequest.builder()
                                     // TODO all documents retrieved from ADB are under 0.1
//                                   .similarityThreshold(0.6d)
                                     .topK(6)
                                     .build()
                         )
                         .build()
             ).stream()
             .content();
    }

}

public GenericSearchResult search(String query) {

    // String encodeQ = URLEncoder.encode(query, StandardCharsets.UTF_8);
    ResponseEntity<GenericSearchResult> resultResponseEntity = run(query);

    return genericSearchResult(resultResponseEntity);
}

private ResponseEntity<GenericSearchResult> run(String query) {

    return this.restClient.get()
        .uri(
        "/search/genericSearch?query={query}&timeRange={timeRange}",
        query,
        TIME_RANGE
    ).retrieve()
        .toEntity(GenericSearchResult.class);
}

}

public List<Document> getData(GenericSearchResult respData) throws URISyntaxException {

    List<Document> documents = new ArrayList<>();

    Map<String, Object> metadata = getQueryMetadata(respData);

    for (ScorePageItem pageItem : respData.getPageItems()) {

      Map<String, Object> pageItemMetadata = getPageItemMetadata(pageItem);
      Double score = getScore(pageItem);
      String text = getText(pageItem);

      if (Objects.equals("", text)) {

        Media media = getMedia(pageItem);
        Document document = new Document.Builder()
            .metadata(metadata)
            .metadata(pageItemMetadata)
            .media(media)
            .score(score)
            .build();

        documents.add(document);
        break;
      }

      Document document = new Document.Builder()
          .metadata(metadata)
          .metadata(pageItemMetadata)
          .text(text)
          .score(score)
          .build();

      documents.add(document);
    }

    return documents;
  }

  private Double getScore(ScorePageItem pageItem) {

    return pageItem.getScore();
  }

  // .... omitted data cleaning code

  // Limit the number of documents for web search to improve response speed
  public List<Document> limitResults(List<Document> documents, int minResults) {

    int limit = Math.min(documents.size(), minResults);

    return documents.subList(0, limit);
  }

}

public SAAWebSearchService(
       DataClean dataCleaner,
       QueryExpander queryExpander,
       IQSSearchEngine searchEngine,
       QueryTransformer queryTransformer,
       SimpleLoggerAdvisor simpleLoggerAdvisor,
       @Qualifier("dashscopeChatModel") ChatModel chatModel,
       @Qualifier("queryArgumentPromptTemplate") PromptTemplate queryArgumentPromptTemplate
) {

    this.queryTransformer = queryTransformer;
    this.queryExpander = queryExpander;
    this.queryArgumentPromptTemplate = queryArgumentPromptTemplate;

    // reasoning content for DeepSeek-r1 is integrated into the output
    this.reasoningContentAdvisor = new ReasoningContentAdvisor(1);

    // Build chatClient
    this.chatClient = ChatClient.builder(chatModel)
          .defaultOptions(
                DashScopeChatOptions.builder()
                      .withModel(DEFAULT_WEB_SEARCH_MODEL)
                      // whether to enable incremental output in stream mode
                      .withIncrementalOutput(true)
                      .build())
          .build();

    // logging
    this.simpleLoggerAdvisor = simpleLoggerAdvisor;

    this.webSearchRetriever = WebSearchRetriever.builder()
          .searchEngine(searchEngine)
          .dataCleaner(dataCleaner)
          .maxResults(2)
          .build();
}

//Handle user input
public Flux<String> chat(String prompt) {

    return chatClient.prompt()
          .advisors(
             createRetrievalAugmentationAdvisor(),
             reasoningContentAdvisor,
             simpleLoggerAdvisor
          ).user(prompt)
          .stream()
          .content();
}

private RetrievalAugmentationAdvisor createRetrievalAugmentationAdvisor() {

    return RetrievalAugmentationAdvisor.builder()
          .documentRetriever(webSearchRetriever)
          .queryTransformers(queryTransformer)
          .queryAugmenter(
                new CustomContextQueryAugmenter(
                      queryArgumentPromptTemplate,
                      null,
                      true)
          ).queryExpander(queryExpander)
          .documentJoiner(new ConcatenationDocumentJoiner())
          .build();
}

@Component
public class CustomMcpStdioTransportConfigurationBeanPostProcessor implements BeanPostProcessor {

  private static final Logger logger = LoggerFactory.getLogger(CustomMcpStdioTransportConfigurationBeanPostProcessor.class);

  private final ObjectMapper objectMapper;

  private final McpStdioClientProperties mcpStdioClientProperties;

  public CustomMcpStdioTransportConfigurationBeanPostProcessor(
      ObjectMapper objectMapper,
      McpStdioClientProperties mcpStdioClientProperties
  ) {
    this.objectMapper = objectMapper;
    this.mcpStdioClientProperties = mcpStdioClientProperties;
  }

  @NotNull
  @Override
  public Object postProcessAfterInitialization(@NotNull Object bean, @NotNull String beanName) throws BeansException {

    if (bean instanceof StdioTransportAutoConfiguration) {

      logger.debug("Enhancing McpStdioTransportConfiguration bean start: {}", beanName);

      McpServerConfig mcpServerConfig;
      try {
        mcpServerConfig = McpServerUtils.getMcpServerConfig();

        // Handle the jar relative path issue in the configuration file.
        for (Map.Entry<String, McpStdioClientProperties.Parameters> entry : mcpServerConfig.getMcpServers()
            .entrySet()) {

          if (entry.getValue() != null && entry.getValue().command().startsWith("java")) {

            McpStdioClientProperties.Parameters serverConfig = entry.getValue();
            String oldMcpLibsPath = McpServerUtils.getLibsPath(serverConfig.args());
            String rewriteMcpLibsAbsPath = getMcpLibsAbsPath(McpServerUtils.getLibsPath(serverConfig.args()));
            if (rewriteMcpLibsAbsPath != null) {
              serverConfig.args().remove(oldMcpLibsPath);
              serverConfig.args().add(rewriteMcpLibsAbsPath);
            }
          }
        }

        String msc = objectMapper.writeValueAsString(mcpServerConfig);
        logger.debug("Registry McpServer config: {}", msc);

        // write mcp client
        mcpStdioClientProperties.setServersConfiguration(new ByteArrayResource(msc.getBytes()));
        ((StdioTransportAutoConfiguration) bean).stdioTransports(this.mcpStdioClientProperties);
      }
      catch (IOException e) {
        throw new SAAAppException(e.getMessage());
      }

      logger.debug("Enhancing McpStdioTransportConfiguration bean end: {}", beanName);
    }

    return bean;
  }

}

public static McpServerConfig getMcpServerConfig() throws IOException {

    ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
    InputStream resourceAsStream = ModelsUtils.class.getClassLoader().getResourceAsStream(MCP_CONFIG_FILE_PATH);

    McpServerConfig mcpServerConfig = mapper.readValue(resourceAsStream, McpServerConfig.class);
    mcpServerConfig.getMcpServers().forEach((key, parameters) -> {
       Map<String, String> env = parameters.env();
       if (Objects.nonNull(env)) {
          env.entrySet().stream()
                .filter(entry -> entry.getValue() != null && !entry.getValue().isEmpty() &&
                      entry.getValue().startsWith("${") && entry.getValue().endsWith("}"))
                .forEach(entry -> {
                   String envKey = entry.getValue().substring(2, entry.getValue().length() - 1);
                   String envValue = System.getenv(envKey);
                   // allow env is null.
                   if (envValue != null && !envValue.isEmpty()) {
                      env.put(entry.getKey(), envValue);
                   }
                });
       }
    });


    return mcpServerConfig;
}

public class McpServer {

  private String id;

  private String name;

  private String desc;

  private Map<String, String> env;

  private List<Tools> toolList;
}

public class SyncMcpToolCallbackWrapper {

  private final SyncMcpToolCallback callback;

  public SyncMcpToolCallbackWrapper(SyncMcpToolCallback callback) {
    this.callback = callback;
  }

  public McpSyncClient getMcpClient() {

    try {
      Field field = SyncMcpToolCallback.class.getDeclaredField("mcpClient");
      field.setAccessible(true);
      return (McpSyncClient) field.get(callback);
    } catch (NoSuchFieldException | IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }

}

public static void initMcpServerContainer(ToolCallbackProvider toolCallbackProvider) throws IOException {

    McpServerConfig mcpServerConfig = McpServerUtils.getMcpServerConfig();
    Map<String, String> mcpServerDescMap = initMcpServerDescMap();

    mcpServerConfig.getMcpServers().forEach((key, parameters) -> {

        List<McpServer.Tools> toolsList = new ArrayList<>();
        for (ToolCallback toolCallback : toolCallbackProvider.getToolCallbacks()) {

            // todo: can't get mcp client, use wrapper for now
            SyncMcpToolCallback mcpToolCallback = (SyncMcpToolCallback) toolCallback;
            SyncMcpToolCallbackWrapper syncMcpToolCallbackWrapper = new SyncMcpToolCallbackWrapper(mcpToolCallback);
            String currentMcpServerName = syncMcpToolCallbackWrapper.getMcpClient().getServerInfo().name();

            // aggregate mcp server tools by mcp server name
            if (Objects.equals(key, currentMcpServerName)) {
                McpServer.Tools tool = new McpServer.Tools();
                tool.setDesc(toolCallback.getToolDefinition().description());
                tool.setName(toolCallback.getToolDefinition().name());
                tool.setParams(toolCallback.getToolDefinition().inputSchema());

                toolsList.add(tool);
            }
        }

        McpServerContainer.addServer(McpServer.builder()
                                     .id(getId())
                                     .name(key)
                                     .env(parameters.env())
                                     .desc(mcpServerDescMap.get(key))
                                     .toolList(toolsList)
                                     .build()
                                    );
    });

}

public class ToolCallResp {

    /**
     * Tool execution status
     */
    private ToolState status;

    /**
     * Tool Name
     */
    private String toolName;

    /**
     * Tool execution parameters
     */
    private String toolParameters;

    /**
     * Tool execution result
     */
    private String toolResult;

    /**
     * Tool execution start timestamp
     */
    private LocalDateTime toolStartTime;

    /**
     * Tool execution end timestamp
     */
    private LocalDateTime toolEndTime;

    /**
     * Tool execution error message
     */
    private String errorMessage;

    /**
     * Tool execution input
     */
    private String toolInput;

    /**
     * Tool execution time cost
     */
    private Long toolCostTime;
    /**
     * Tool intermediate result returned by the tool
     */
    private String toolResponse;
}

@Service
public class SAAMcpService {

  private final ChatClient chatClient;

  private final ObjectMapper objectMapper;

  private final ToolCallbackProvider tools;

  private final ToolCallingManager toolCallingManager;

  private final McpStdioClientProperties mcpStdioClientProperties;

  private static final Logger logger = LoggerFactory.getLogger(SAAMcpService.class);

  public SAAMcpService(
      ObjectMapper objectMapper,
      ToolCallbackProvider tools,
      SimpleLoggerAdvisor simpleLoggerAdvisor,
      ToolCallingManager toolCallingManager,
      McpStdioClientProperties mcpStdioClientProperties,
      @Qualifier("openAiChatModel") ChatModel chatModel
  ) throws IOException {

    this.objectMapper = objectMapper;
    this.mcpStdioClientProperties = mcpStdioClientProperties;

    // Initialize chat client with non-blocking configuration
    this.chatClient = ChatClient.builder(chatModel)
        .defaultAdvisors(
            simpleLoggerAdvisor
        ).defaultToolCallbacks(tools)
        .build();
    this.tools = tools;
    this.toolCallingManager = toolCallingManager;

    McpServerUtils.initMcpServerContainer(tools);
  }

  public ToolCallResp chat(String prompt) {

    // manual run tools flag
    ChatOptions chatOptions = ToolCallingChatOptions.builder()
        .toolCallbacks(tools.getToolCallbacks())
        .internalToolExecutionEnabled(false)
        .build();

    ChatResponse response = chatClient.prompt(new Prompt(prompt, chatOptions))
        .call().chatResponse();

    logger.debug("ChatResponse: {}", response);
    assert response != null;
    List<AssistantMessage.ToolCall> toolCalls = response.getResult().getOutput().getToolCalls();
    logger.debug("ToolCalls: {}", toolCalls);
    String responseByLLm = response.getResult().getOutput().getText();
    logger.debug("Response by LLM: {}", responseByLLm);

    // execute tools with no chat memory messages.
    var tcr = ToolCallResp.TCR();
    if (!toolCalls.isEmpty()) {

      tcr = ToolCallResp.startExecute(
          responseByLLm,
          toolCalls.get(0).name(),
          toolCalls.get(0).arguments()
      );
      tcr.setToolParameters(toolCalls.get(0).arguments());
      logger.debug("Start ToolCallResp: {}", tcr);
      ToolExecutionResult toolExecutionResult = null;

      try {
        toolExecutionResult = toolCallingManager.executeToolCalls(new Prompt(prompt, chatOptions), response);

        tcr.setToolEndTime(LocalDateTime.now());
      }
      catch (Exception e) {

        tcr.setStatus(ToolCallResp.ToolState.FAILURE);
        tcr.setErrorMessage(e.getMessage());
        tcr.setToolEndTime(LocalDateTime.now());
        tcr.setToolCostTime((long) (tcr.getToolEndTime().getNano() - tcr.getToolStartTime().getNano()));
        logger.error("Error ToolCallResp: {}, msg: {}", tcr, e.getMessage());
        // throw new RuntimeException("Tool execution failed, please check the logs for details.");
      }

      String llmCallResponse = "";
      if (Objects.nonNull(toolExecutionResult)) {
        ChatResponse finalResponse = chatClient.prompt().messages(toolExecutionResult.conversationHistory())
            .call().chatResponse();
        if (finalResponse != null) {
          llmCallResponse = finalResponse.getResult().getOutput().getText();
        }

        StringBuilder sb = new StringBuilder();
        toolExecutionResult.conversationHistory().stream()
            .filter(message -> message instanceof ToolResponseMessage)
            .forEach(message -> {
              ToolResponseMessage toolResponseMessage = (ToolResponseMessage) message;
              toolResponseMessage.getResponses().forEach(tooResponse -> {
                sb.append(tooResponse.responseData());
              });
            });
        tcr.setToolResponse(sb.toString());
      }

      tcr.setStatus(ToolCallResp.ToolState.SUCCESS);
      tcr.setToolResult(llmCallResponse);
      tcr.setToolCostTime((long) (tcr.getToolEndTime().getNano() - tcr.getToolStartTime().getNano()));
      logger.debug("End ToolCallResp: {}", tcr);
    }
    else {
      logger.debug("ToolCalls is empty, no tool execution needed.");
      tcr.setToolResult(responseByLLm);
    }

    return tcr;
  }

  public ToolCallResp run(String id, Map<String, String> envs, String prompt) throws IOException {

    Optional<McpServer> runMcpServer = McpServerContainer.getServerById(id);
    if (runMcpServer.isEmpty()) {
      logger.error("McpServer not found, id: {}", id);
      return ToolCallResp.TCR();
    }

    String runMcpServerName = runMcpServer.get().getName();
    var mcpServerConfig = McpServerUtils.getMcpServerConfig();
    McpStdioClientProperties.Parameters parameters = new McpStdioClientProperties.Parameters(
        mcpServerConfig.getMcpServers().get(runMcpServerName).command(),
        mcpServerConfig.getMcpServers().get(runMcpServerName).args(),
        envs
    );

    if (parameters.command().startsWith("java")) {
      String oldMcpLibsPath = McpServerUtils.getLibsPath(parameters.args());
      String rewriteMcpLibsAbsPath = getMcpLibsAbsPath(McpServerUtils.getLibsPath(parameters.args()));

      parameters.args().remove(oldMcpLibsPath);
      parameters.args().add(rewriteMcpLibsAbsPath);
    }

    String mcpServerConfigJSON = objectMapper.writeValueAsString(mcpServerConfig);
    mcpStdioClientProperties.setServersConfiguration(new ByteArrayResource(mcpServerConfigJSON.getBytes()));

    return chat(prompt);
  }

}

public List<ToolCallback> getTools() {

    return List.of(buildBaiduTranslateTools(), buildBaiduMapTools());
}

private ToolCallback buildBaiduTranslateTools() {

    return FunctionToolCallback
          .builder(
                "BaiduTranslateService",
                new BaiduTranslateTools(ak, sk, restClientbuilder, responseErrorHandler)
          ).description("Baidu translation function for general text translation.")
          .inputSchema(
                """
                      {
                         "type": "object",
                         "properties": {
                            "Request": {
                               "type": "object",
                               "properties": {
                                  "q": {
                                     "type": "string",
                                     "description": "Content that needs to be translated."
                                  },
                                  "from": {
                                     "type": "string",
                                     "description": "Source language that needs to be translated."
                                  },
                                  "to": {
                                     "type": "string",
                                     "description": "Target language to translate into."
                                  }
                               },
                               "required": ["q", "from", "to"],
                               "description": "Request object to translate text to a target language."
                            },
                            "Response": {
                               "type": "object",
                               "properties": {
                                  "translatedText": {
                                     "type": "string",
                                     "description": "The translated text."
                                  }
                               },
                               "required": ["translatedText"],
                               "description": "Response object for the translation function, containing the translated text."
                            }
                         },
                         "required": ["Request", "Response"]
                      }
                      """
          ).inputType(BaiduTranslateTools.BaiduTranslateToolRequest.class)
          .toolMetadata(ToolMetadata.builder().returnDirect(false).build())
          .build();
}

public class SAAToolsService {

  private static final Logger logger = LoggerFactory.getLogger(SAAToolsService.class);

  private final ChatClient chatClient;

  private final ToolCallingManager toolCallingManager;

  private final ToolsInit toolsInit;

  public SAAToolsService(
      ToolsInit toolsInit,
      ToolCallingManager toolCallingManager,
      SimpleLoggerAdvisor simpleLoggerAdvisor,
      MessageChatMemoryAdvisor messageChatMemoryAdvisor,
      @Qualifier("openAiChatModel") ChatModel chatModel
  ) {

    this.toolsInit = toolsInit;
    this.toolCallingManager = toolCallingManager;

    this.chatClient = ChatClient.builder(chatModel)
        .defaultAdvisors(
            simpleLoggerAdvisor
//            messageChatMemoryAdvisor
        ).build();
  }

  public ToolCallResp chat(String prompt) {

    // manual run tools flag
    ChatOptions chatOptions = ToolCallingChatOptions.builder()
        .toolCallbacks(toolsInit.getTools())
        .internalToolExecutionEnabled(false)
        .build();
    Prompt userPrompt = new Prompt(prompt, chatOptions);

    ChatResponse response = chatClient.prompt(userPrompt)
        .call().chatResponse();

    logger.debug("ChatResponse: {}", response);
    assert response != null;
    List<AssistantMessage.ToolCall> toolCalls = response.getResult().getOutput().getToolCalls();
    logger.debug("ToolCalls: {}", toolCalls);
    String responseByLLm = response.getResult().getOutput().getText();
    logger.debug("Response by LLM: {}", responseByLLm);

    // execute tools with no chat memory messages.
    var tcr = ToolCallResp.TCR();
    if (!toolCalls.isEmpty()) {

      tcr = ToolCallResp.startExecute(
          responseByLLm,
          toolCalls.get(0).name(),
          toolCalls.get(0).arguments()
      );
      logger.debug("Start ToolCallResp: {}", tcr);
      ToolExecutionResult toolExecutionResult = null;

      try {
        toolExecutionResult = toolCallingManager.executeToolCalls(new Prompt(prompt, chatOptions), response);

        tcr.setToolEndTime(LocalDateTime.now());
      }
      catch (Exception e) {

        tcr.setStatus(ToolCallResp.ToolState.FAILURE);
        tcr.setErrorMessage(e.getMessage());
        tcr.setToolEndTime(LocalDateTime.now());
        tcr.setToolCostTime((long) (tcr.getToolEndTime().getNano() - tcr.getToolStartTime().getNano()));
        logger.error("Error ToolCallResp: {}, msg: {}", tcr, e.getMessage());
        // throw new RuntimeException("Tool execution failed, please check the logs for details.");
      }

      String llmCallResponse = "";
      if (Objects.nonNull(toolExecutionResult)) {
//        ToolResponseMessage toolResponseMessage = (ToolResponseMessage) toolExecutionResult.conversationHistory()
//            .get(toolExecutionResult.conversationHistory().size() - 1);
//        llmCallResponse = toolResponseMessage.getResponses().get(0).responseData();
        ChatResponse finalResponse = chatClient.prompt().messages(toolExecutionResult.conversationHistory()).call().chatResponse();
        llmCallResponse = finalResponse.getResult().getOutput().getText();
      }

      tcr.setStatus(ToolCallResp.ToolState.SUCCESS);
      tcr.setToolResult(llmCallResponse);
      tcr.setToolCostTime((long) (tcr.getToolEndTime().getNano() - tcr.getToolStartTime().getNano()));
      logger.debug("End ToolCallResp: {}", tcr);
    }
    else {
      logger.debug("ToolCalls is empty, no tool execution needed.");
      tcr.setToolResult(responseByLLm);
    }

    return tcr;
  }

}

/**
 * Handle the complete message sending process
 * @param text - Message text
 * @param sendRequest - Function to send the request
 * @param createMessage - Function to create the message object
 */
const processSendMessage = async <T extends BaseMessage>({
    text,
    sendRequest,
    createMessage,
}: {
    text: string;
    sendRequest: (text: string, timestamp: number, message: T) => Promise<void>;
    createMessage: (text: string, timestamp: number) => T;
}) => {
    if (!text.trim() || !activeConversation) return;

    const userTimestamp = Date.now();
    const userMessage = createMessage(text, userTimestamp);

    // Store user data locally on the client. In production environments, this step can be omitted and handled by the server
    updateActiveConversation({
        ...activeConversation,
        messages: [
        ...activeConversation.messages,
        userMessage,
    ] as T[],
    });

    try {
        await sendRequest(text, userTimestamp, userMessage);
    } catch (error) {
        console.error("error:", error);
    }
};

/**
 * Get custom rendering configuration
 * @param style - css styles
 */
const getMarkdownRenderConfig = (styles: Record<string, string>) => {

  return {
    div: ({ children }) => {
        return <pre className={styles.codeBlock}>{children}</pre>
    },
    code: ({ children, className }) => {
        return <code className={styles.codeInline}>{children}</code>
    },
    think: ({ children }) => {
        return  <div className={styles.thinkTag}>{children}</div>;
    },
    tool: ({ children }) => {
        return <div className={styles.toolTag}>{children}</div>;
    },
  };
};