Merge branch 'master' of http://oa.sccehui.com:6101/cmc-coding/cmc-oa

oa-back/ruoyi-admin/src/main/resources/application.yml

@@ -8,16 +8,16 @@ cmc:
   copyrightYear: 2023
   # 文件路径 示例（ Windows配置D:/ruoyi/uploadPath，Linux配置 /home/ruoyi/uploadPath）
 #  profile: /home/cmc/Java-server/综合办公
-#  profile: /home/cmc/projects/cmc-oa
-  profile: D:/ruoyi/uploadPath
+  profile: /home/cmc/projects/cmc-oa
+#  profile: D:/ruoyi/uploadPath
   # 获取ip地址开关
   addressEnabled: false
   # 验证码类型 math 数字计算 char 字符验证
   captchaType: math
   llmService:
-    url: http://192.168.28.196:8000/v1/chat/completions
+    url: http://192.168.31.11:8000/v1/chat/completions
   milvusService:
-    url: http://192.168.28.196:19530
+    url: http://192.168.31.11:19530 
 
 # 开发环境配置
 server:

oa-back/ruoyi-agent/pom.xml

@@ -128,26 +128,16 @@
             </plugin>
 
             <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-assembly-plugin</artifactId>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>2.7.18</version>
                 <configuration>
-                    <finalName>${project.name}</finalName>
-                    <appendAssemblyId>false</appendAssemblyId>
-                    <descriptorRefs>
-                        <descriptorRef>jar-with-dependencies</descriptorRef>
-                    </descriptorRefs>
-                    <archive>
-                        <manifest>
-                            <mainClass>webapp.HelloApp</mainClass>
-                        </manifest>
-                    </archive>
+                    <mainClass>com.ruoyi.agent.RuoYiAgentApplication</mainClass>
                 </configuration>
                 <executions>
                     <execution>
-                        <id>make-assembly</id>
-                        <phase>package</phase>
                         <goals>
-                            <goal>single</goal>
+                            <goal>repackage</goal>
                         </goals>
                     </execution>
                 </executions>

oa-back/ruoyi-agent/src/main/java/com/ruoyi/agent/service/impl/McpServiceImpl.java

@@ -126,6 +126,24 @@ public class McpServiceImpl implements IMcpService {
             return executeQuery(sqlString);
     }
 
+    /**
+      * 获取所有表名列表
+      */
+     @ToolMapping(description = "获取数据库中所有表名列表")
+     public JSONArray GetAllTableNames()
+     {
+             return getAllTableNames();
+     }
+
+     /**
+      * 获取指定表的结构信息
+      */
+     @ToolMapping(description = "获取指定表的结构信息")
+     public JSONObject GetTableStructure(@Param(description = "表名") String tableName)
+     {
+             return getTableStructure(tableName);
+     }
+
     public JSONArray executeQuery(String sql) {
         JSONArray result = new JSONArray();
 
@@ -720,4 +738,90 @@ public class McpServiceImpl implements IMcpService {
         }
     }
 
+    /**
+     * 获取表结构信息
+     */
+    private JSONObject getTableStructure(String tableName) {
+        JSONObject result = new JSONObject();
+        
+        try {
+            Class.forName("com.mysql.cj.jdbc.Driver");
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("MySQL 驱动未找到", e);
+        }
+
+        try (Connection conn = DriverManager.getConnection(Solon.cfg().getProperty("cmc.mysqlService.jdbcUrl"),Solon.cfg().getProperty("cmc.mysqlService.username"), Solon.cfg().getProperty("cmc.mysqlService.password"))) {
+            
+            DatabaseMetaData metaData = conn.getMetaData();
+            
+            ResultSet columns = metaData.getColumns(null, null, tableName, null);
+            JSONArray columnsInfo = new JSONArray();
+            
+            while (columns.next()) {
+                JSONObject column = new JSONObject();
+                column.put("columnName", columns.getString("COLUMN_NAME"));
+                column.put("dataType", columns.getString("TYPE_NAME"));
+                column.put("columnSize", columns.getString("COLUMN_SIZE"));
+                column.put("isNullable", columns.getString("IS_NULLABLE"));
+                column.put("columnComment", columns.getString("REMARKS"));
+                columnsInfo.add(column);
+            }
+            columns.close();
+            
+            ResultSet primaryKeys = metaData.getPrimaryKeys(null, null, tableName);
+            JSONArray primaryKeyColumns = new JSONArray();
+            
+            while (primaryKeys.next()) {
+                primaryKeyColumns.add(primaryKeys.getString("COLUMN_NAME"));
+            }
+            primaryKeys.close();
+            
+            result.put("tableName", tableName);
+            result.put("columns", columnsInfo);
+            result.put("primaryKey", primaryKeyColumns);
+            
+        } catch (SQLException e) {
+            throw new RuntimeException("获取表结构失败: " + tableName, e);
+        }
+        
+        return result;
+    }
+
+    /**
+     * 获取所有表名列表（只包含cmc、sys和files开头的表）
+     */
+    private JSONArray getAllTableNames() {
+        JSONArray tableNames = new JSONArray();
+        
+        try {
+            Class.forName("com.mysql.cj.jdbc.Driver");
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("MySQL 驱动未找到", e);
+        }
+
+        try (Connection conn = DriverManager.getConnection(Solon.cfg().getProperty("cmc.mysqlService.jdbcUrl"),Solon.cfg().getProperty("cmc.mysqlService.username"), Solon.cfg().getProperty("cmc.mysqlService.password"))) {
+            
+            DatabaseMetaData metaData = conn.getMetaData();
+            ResultSet tables = metaData.getTables(null, null, null, new String[]{"TABLE"});
+            
+            while (tables.next()) {
+                String tableName = tables.getString("TABLE_NAME");
+                String tableComment = tables.getString("REMARKS");
+                // 只获取cmc、sys和files开头的表
+                if (tableName.startsWith("cmc") || tableName.startsWith("sys") || tableName.startsWith("files")) {
+                    JSONObject tableInfo = new JSONObject();
+                    tableInfo.put("tableName", tableName);
+                    tableInfo.put("tableComment", tableComment != null ? tableComment : "");
+                    tableNames.add(tableInfo);
+                }
+            }
+            tables.close();
+            
+        } catch (SQLException e) {
+            throw new RuntimeException("获取表名列表失败", e);
+        }
+        
+        return tableNames;
+    }
+
 }

oa-back/ruoyi-agent/src/main/resources/application.yml

@@ -4,9 +4,9 @@ cmc:
   #  profile: /home/cmc/projects/cmc-llm
   profile: /home/cmc/projects/cmc-oa
   llmService:
-    url: http://192.168.28.196:8000/v1/chat/completions
+    url: http://192.168.31.11:8000/v1/chat/completions
   milvusService:
-    url: http://192.168.28.196:19530
+    url: http://192.168.31.11:19530 
   mysqlService:
     jdbcUrl: jdbc:mysql://localhost:3306/cmc_oa?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true
     username: root

oa-back/ruoyi-llm/src/main/java/com/ruoyi/web/llm/service/impl/SessionServiceImpl.java

@@ -1,7 +1,6 @@
 package com.ruoyi.web.llm.service.impl;
 
 import com.alibaba.fastjson2.JSONObject;
-import com.ruoyi.common.config.RuoYiConfig;
 import com.ruoyi.llm.domain.CmcChat;
 import com.ruoyi.llm.service.ICmcChatService;
 import com.ruoyi.web.llm.service.ILangChainMilvusService;
@@ -20,10 +19,6 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 
-import java.io.BufferedReader;
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -42,7 +37,7 @@ public class SessionServiceImpl implements ISessionService {
     @Override
     public Flux<String> answer(String topicId, String question) {
         McpClientProvider clientProvider = McpClientProvider.builder()
-                .channel(McpChannel.STREAMABLE_STATELESS )
+                .channel(McpChannel.STREAMABLE_STATELESS)
                 .url("http://localhost:8087/mcp/sse")
                 .build();
         ChatModel chatModel = ChatModel.of(llmServiceUrl)
@@ -59,122 +54,192 @@ public class SessionServiceImpl implements ISessionService {
             messages.add(ChatMessage.ofAssistant(chat.getOutput()));
         }
 
-        // 读取SQL文件
-        StringBuilder sqlContent = new StringBuilder();
-        File sqlStructure = new File(RuoYiConfig.getProfile() + "/cmc_oa.sql");
-        try (BufferedReader br = new BufferedReader(new FileReader(sqlStructure))) {
-            String line;
-            while ((line = br.readLine()) != null) {
-                sqlContent.append(line).append("\n");
-            }
-        } catch (IOException e) {
-            System.out.println("读取SQL文件失败");
-        }
+        // 第一步：调用 GetAllTableNames 获取所有表名
+        String step1Prompt = "你是一个MySQL专家。请调用 GetAllTableNames 工具获取数据库中所有表名列表。";
+        messages.add(ChatMessage.ofUser(step1Prompt));
+        ChatSession session1 = InMemoryChatSession.builder().messages(messages).build();
+        Prompt prompt1 = Prompt.of(step1Prompt).attrPut("session", session1);
 
-        // 优化prompt：明确要求不输出任何中间标记
-        String prompt = "你是一个MySQL专家。根据以下OA系统表结构信息：  \n" +
-                sqlContent + " \n" +
-                "用户查询：  \n"+
-                question  + " \n"+
-                "你可以使用SQLQuery工具来查询OA系统数据。  \n" +
-                "SQLQuery工具功能：执行SQL查询语句，获取OA系统数据  \n" +
-                "工具参数：sqlString（需要执行的SQL语句，格式为[SQL语句]）  \n" +
-                "要求：  \n" +
-                "1. 根据用户查询需求，决定是否需要查询数据  \n" +
-                "2. 如果需要查询数据，调用SQLQuery工具并传入正确的SQL语句  \n" +
-                "3. 生成标准MYSQL查询语句，根据语义和字段类型使用COUNT/SUM/AVG等聚合函数  \n" +
-                "4. 如果单表字段不满足查询需求，根据OA系统表结构信息进行多张表连接查询  \n" +
-                "5. 如果字段值由逗号隔开，根据OA系统表结构信息进行多张表连接查询，采用concat方式多值匹配  \n" +
-                "6. 给生成的字段取一个简短的中文名称  \n" +
-                "7. **重要：输出格式要求**  \n" +
-                "   - 不要输出任何思考过程  \n" +
-                "   - 所有输出必须是完整的句子  \n" +
-                "   - 不要输出'查询结果'、'正在生成回答'等中间提示  \n" +
-                "   - 直接输出最终回答内容  \n" +
-                "   - 如果使用工具，工具调用和结果处理对用户透明，用户只看到最终答案  \n";
+        Flux<ChatResponse> chatResponse = chatModel.prompt(prompt1).stream();
+        Flux<String> contentFlux = chatResponse
+                .concatMap(resp -> {
+                    try {
+                        // 执行第一步：获取所有表名
+                        String toolCall1 = "{\"name\": \"GetAllTableNames\", \"arguments\": {}}";
+                        String toolResult1 = clientProvider.callTool("GetAllTableNames", new JSONObject()).getContent();
 
-        messages.add(ChatMessage.ofUser(prompt));
-        ChatSession chatSession = InMemoryChatSession.builder().messages(messages).build();
-        Prompt wholePrompt = Prompt.of(prompt).attrPut("session", chatSession);
+                        // 第二步：模型分析表名，找到相关表
+                        List<ChatMessage> messages2 = new ArrayList<>(messages);
+                        messages2.add(ChatMessage.ofAssistant("<tool_call>" + toolCall1 + "</tool_call>"));
+                        messages2.add(ChatMessage.ofUser(toolResult1));
 
-        Flux<ChatResponse> chatResponse = chatModel.prompt(wholePrompt).stream();
+                        String step2Prompt = "请分析以下表名列表，找出与" + question + "相关的表。\n\n" +
+                        "**输出格式要求**：\n" +
+                        "- 如果需要数据库查询，请以固定格式输出：以\"相关表：\" 开头，中间用英文逗号隔开，以英文句号结尾\n" +
+                        "- 如果不需要进行数据库查询，请直接回答。\n\n" + toolResult1;
+                        messages2.add(ChatMessage.ofUser(step2Prompt));
+                        ChatSession session2 = InMemoryChatSession.builder().messages(messages2).build();
 
-        // 使用StringBuilder缓存完整响应，用于检测工具调用
-        StringBuilder fullResponseBuilder = new StringBuilder();
-        // 标记是否已经处理过工具调用
-        boolean[] toolCallProcessed = {false};
-        // 输出过滤状态：用于抑制 tool_call 区块（对用户不可见）
-        StreamFilterState filterState = new StreamFilterState();
+                        // 生成第二步的响应
+                        return chatModel.prompt(Prompt.of(step2Prompt).attrPut("session", session2))
+                                .stream()
+                                .concatMap(resp1 -> {
+                                    try {
+                                        String content2 = resp1.getContent();
 
-        Flux<String> contentFlux = chatResponse
-                .concatMap(resp -> {
-                    String content = resp.getContent();
+                                        // 提取相关表名（从模型响应中提取）
+                                        String relevantTables = extractRelevantTables(content2);
 
-                    // 先累积原始内容，用于 tool_call 检测
-                    fullResponseBuilder.append(content);
-                    String currentFullContent = fullResponseBuilder.toString();
+                                        // 检查是否需要继续执行（如果包含工具调用或明确需要数据库查询）
+                                        if (relevantTables.equals("")) {
+                                            // 不需要数据库查询，直接返回最终回答
+                                            return Flux.just(content2)
+                                                    .map(this::toSseDataFrame)
+                                                    .concatWith(Flux.just("data: [DONE]\n\n"));
+                                        }
 
-                    // 1) 优先处理工具调用：检测到闭合的 <tool_call>...</tool_call> 后，静默调用工具并流式输出最终答案
-                    if (!toolCallProcessed[0]
-                            && currentFullContent.contains("<tool_call>")
-                            && currentFullContent.contains("</tool_call>")) {
-                        toolCallProcessed[0] = true;
-                        // 进入“最终回答阶段”前重置过滤状态
-                        filterState.reset();
-                        try {
-                            // 提取工具调用内容
-                            int start = currentFullContent.indexOf("<tool_call>");
-                            int end = currentFullContent.indexOf("</tool_call>");
-                            if (start < 0 || end < 0 || end <= start) {
-                                throw new IllegalStateException("未找到完整的 <tool_call>...</tool_call> 区块");
-                            }
-                            String toolContent = currentFullContent.substring(start + "<tool_call>".length(), end).trim();
-                            JSONObject jsonObject = JSONObject.parseObject(toolContent);
-                            String name = jsonObject.getString("name");
-                            JSONObject arguments = jsonObject.getJSONObject("arguments");
-                            String toolResult = "";
-                            try {
-                                // 调用工具
-                                toolResult = clientProvider.callTool(name, arguments).getContent();
-                            } catch (Exception e) {
-                                return Flux.just("抱歉，系统执行查询时遇到问题，请稍后重试。");
-                            } finally {
-                                clientProvider.close();
-                            }
+                                        // 第三步：调用 GetTableStructure 获取相关表的结构
+                                        List<ChatMessage> messages3 = new ArrayList<>(messages2);
+                                        messages3.add(ChatMessage.ofAssistant(content2));
 
-                            // 生成最终回答 - 不添加任何中间提示
-                            String finalPrompt = "基于以下查询结果，直接回答用户问题：\n" +
-                                    "查询结果：\n" + toolResult + "\n\n" +
-                                    "用户问题：\n" + question + "\n\n" +
-                                    "要求：\n" +
-                                    "1. 直接给出最终答案，不要输出任何中间过程\n" +
-                                    "2. 不要输出'查询结果'、'根据查询结果'等前缀\n" +
-                                    "3. 用完整的中文句子回答，语言自然流畅\n" +
-                                    "4. 如果查询结果为空，如实说明";
+                                        // 执行第三步：获取表结构
+                                        StringBuilder tableStructures = new StringBuilder();
+                                        for (String tableName : relevantTables.split(",")) {
+                                            tableName = tableName.trim();
+                                            if (!tableName.isEmpty()) {
+                                                JSONObject args = new JSONObject();
+                                                args.put("tableName", tableName);
+                                                String toolResult3 = clientProvider.callTool("GetTableStructure", args)
+                                                        .getContent();
+                                                tableStructures.append("表：").append(tableName).append("\n")
+                                                        .append(toolResult3)
+                                                        .append("\n\n");
+                                            }
+                                        }
 
-                            return chatModel.prompt(finalPrompt).stream()
-                                    .map(ChatResponse::getContent)
-                                    .filter(answer -> answer != null && !answer.isEmpty());
+                                        // 第四步：模型生成 SQL 查询
+                                        List<ChatMessage> messages4 = new ArrayList<>(messages3);
+                                        messages4.add(ChatMessage.ofAssistant(
+                                                "<tool_call>{\"name\": \"GetTableStructure\", \"arguments\": {\"tableName\": \"employee\"}}</tool_call>"));
+                                        messages4.add(ChatMessage.ofUser(tableStructures.toString()));
 
-                        } catch (Exception e) {
-                            return Flux.just("抱歉，系统执行查询时遇到问题，请稍后重试。");
-                        }
-                    }
+                                        String step4Prompt = "请根据以下表结构，生成" + question + "的SQL语句：\n\n"
+                                                + tableStructures.toString();
+                                        messages4.add(ChatMessage.ofUser(step4Prompt));
 
-                    // 2) 对用户可见输出：统一用“容错状态机”剥离<tool_call> 区块
-                    //    不再使用“未闭合 tool_call 就整段屏蔽”的策略，避免吞掉真正回答。
-                    String visible = filterVisibleChunk(content, filterState);
-                    return visible.isEmpty() ? Flux.empty() : Flux.just(visible);
-                });
+                                        // 生成第四步的响应
+                                        return chatModel
+                                                .prompt(Prompt.of(step4Prompt).attrPut("session",
+                                                        InMemoryChatSession.builder().messages(messages4).build()))
+                                                .stream()
+                                                .concatMap(resp2 -> {
+                                                    try {
+                                                        String content4 = resp2.getContent();
+
+                                                        // 提取 SQL 语句
+                                                        String sqlQuery = extractSqlFromContent(content4);
+
+                                                        // 第五步：调用 SQLQuery 执行查询
+                                                        List<ChatMessage> messages5 = new ArrayList<>(messages4);
+                                                        messages5.add(ChatMessage.ofAssistant(content4));
+
+                                                        // 执行第五步：执行 SQL 查询
+                                                        JSONObject sqlArgs = new JSONObject();
+                                                        sqlArgs.put("sqlString", sqlQuery);
+                                                        String toolResult5 = clientProvider
+                                                                .callTool("SQLQuery", sqlArgs)
+                                                                .getContent();
+
+                                                        // 第六步：模型生成最终回答
+                                                        List<ChatMessage> messages6 = new ArrayList<>(messages5);
+                                                        messages6.add(ChatMessage.ofAssistant(
+                                                                "<tool_call>{\"name\": \"SQLQuery\", \"arguments\": {\"sqlString\": \""
+                                                                        + sqlQuery + "\"}}</tool_call>"));
+                                                        messages6.add(ChatMessage.ofUser(toolResult5));
 
+                                                        String step6Prompt = "请根据以下查询结果，生成关于" + question + "的最终回答：\n\n"
+                                                                + toolResult5;
+                                                        messages6.add(ChatMessage.ofUser(step6Prompt));
+
+                                                        // 生成第六步的响应（流式）
+                                                        return chatModel
+                                                                .prompt(Prompt.of(step6Prompt).attrPut("session",
+                                                                        InMemoryChatSession.builder()
+                                                                                .messages(messages6)
+                                                                                .build()))
+                                                                .stream()
+                                                                .map(resp3 -> resp3.getContent())
+                                                                .filter(answer -> answer != null && !answer.isEmpty());
+                                                    } catch (Exception e) {
+                                                        return Flux.just("抱歉，系统执行查询时遇到问题，请稍后重试。")
+                                                                .map(this::toSseDataFrame)
+                                                                .concatWith(Flux.just("data: [DONE]\n\n"));
+                                                    }
+                                                });
+                                    } catch (Exception e) {
+                                        return Flux.just("抱歉，系统执行查询时遇到问题，请稍后重试。")
+                                                .map(this::toSseDataFrame)
+                                                .concatWith(Flux.just("data: [DONE]\n\n"));
+                                    }
+                                });
+                    } catch (Exception e) {
+                        return Flux.just("抱歉，系统执行查询时遇到问题，请稍后重试。")
+                                .map(this::toSseDataFrame)
+                                .concatWith(Flux.just("data: [DONE]\n\n"));
+                    }
+                });
         // 手工拼接 SSE 帧，绕过 ServerSentEvent 编码差异；并在末尾发送 [DONE]
         Flux<String> sseFlux = contentFlux
                 .map(this::toSseDataFrame)
                 .concatWith(Flux.just("data: [DONE]\n\n"));
-
         return sseFlux;
     }
 
+    /**
+     * 从模型响应中提取相关表名
+     */
+    private String extractRelevantTables(String content) {
+        // 简化处理，实际应该根据模型输出格式提取
+        // 假设模型会返回类似 "相关表：employee, department"
+        if (content.contains("相关表：")) {
+            int start = content.indexOf("相关表：") + 4;
+            int end = content.indexOf(".", start);
+            if (end > start) {
+                String tables = content.substring(start, end).trim();
+                // 限制相关表最多只保留10个
+                String[] tableNames = tables.split(",");
+                if (tableNames.length > 10) {
+                    StringBuilder limitedTables = new StringBuilder();
+                    for (int i = 0; i < 10; i++) {
+                        if (i > 0) {
+                            limitedTables.append(",");
+                        }
+                        limitedTables.append(tableNames[i].trim());
+                    }
+                    return limitedTables.toString();
+                }
+                return tables;
+            }
+        }
+        // 默认返回可能相关的表
+        return "";
+    }
+
+    /**
+     * 从模型响应中提取 SQL 语句
+     */
+    private String extractSqlFromContent(String content) {
+        // 简化处理，实际应该根据模型输出格式提取
+        if (content.contains("SELECT")) {
+            int start = content.indexOf("SELECT");
+            int end = content.indexOf(";", start);
+            if (end > start) {
+                return content.substring(start, end + 1);
+            }
+        }
+        return "";
+    }
+
     @Override
     public Flux<AssistantMessage> answerWithDocument(String topicId, String chatId, String question) throws Exception {
         return langChainMilvusService.generateAnswerWithDocument(topicId, chatId, question);
@@ -204,66 +269,4 @@ public class SessionServiceImpl implements ISessionService {
         return sb.toString();
     }
 
-    private static final class StreamFilterState {
-        boolean inToolCall = false;
-
-        void reset() {
-            inToolCall = false;
-        }
-    }
-
-    /**
-     * 对用户可见输出过滤：
-     * - 丢弃 <tool_call>...</tool_call> 内容（容错：缺失 </tool_call> 时，遇到空行分隔则自动退出 tool_call）
-     * 说明：工具调用检测/执行仍基于原始累积文本，不依赖该过滤器。
-     */
-    private String filterVisibleChunk(String chunk, StreamFilterState st) {
-        if (chunk == null || chunk.isEmpty()) {
-            return "";
-        }
-        String s = chunk.replace("\r\n", "\n");
-        StringBuilder out = new StringBuilder(s.length());
-        int i = 0;
-        while (i < s.length()) {
-            // 在 tool_call 内：优先寻找 </tool_call>；找不到则容错以空行分隔退出
-            if (st.inToolCall) {
-                int end = s.indexOf("</tool_call>", i);
-                if (end >= 0) {
-                    st.inToolCall = false;
-                    i = end + "</tool_call>".length();
-                    continue;
-                }
-                int sep = s.indexOf("\n\n", i);
-                if (sep >= 0) {
-                    st.inToolCall = false;
-                    i = sep + 2;
-                    continue;
-                }
-                // 剩余都认为在 tool_call 内
-                break;
-            }
-
-            // 不在任何区块内：找下一个起始标签
-            int nextTool = s.indexOf("<tool_call>", i);
-            int next;
-            if (nextTool == -1) {
-                out.append(s.substring(i));
-                break;
-            } else {
-                next = nextTool;
-            }
-
-            if (next > i) {
-                out.append(s, i, next);
-            }
-            st.inToolCall = true;
-            i = next + "<tool_call>".length();
-        }
-
-        // 兜底移除残留标签字面量（避免显示到前端）
-        return out.toString()
-                .replace("<tool_call>", "")
-                .replace("</tool_call>", "");
-    }
-
 }