From 7b298a51d0fb9153c4e054bab28bf99dde3ed409 Mon Sep 17 00:00:00 2001
From: fudawei <fudawei@yunlizhihui.com>
Date: Sun, 8 Feb 2026 14:17:14 +0800
Subject: [PATCH 1/3] =?UTF-8?q?feat:=20=E5=A2=9E=E5=8A=A0=E5=B7=A5?=
 =?UTF-8?q?=E5=85=B7=E8=B0=83=E7=94=A8=E7=9A=84=E5=90=8E=E5=8F=B0=E5=92=8C?=
 =?UTF-8?q?=E5=89=8D=E7=AB=AF=E5=B1=95=E7=A4=BA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../src/components/run/ToolCallingView.vue    | 263 +++++++++++++++
 data-agent-frontend/src/services/graph.ts     |   3 +
 data-agent-frontend/src/views/AgentRun.vue    | 201 ++++++++---
 data-agent-management/pom.xml                 |   6 +
 .../dataagent/controller/GraphController.java |  14 +-
 .../ai/dataagent/dto/tool/ToolCallDTO.java    |  15 +
 .../interceptor/ToolsInterceptor.java         |  72 ++++
 .../ai/dataagent/prompt/PromptConstant.java   |   5 +
 .../ai/dataagent/prompt/PromptHelper.java     |   6 +
 .../aimodelconfig/ReactAgentRegistry.java     |  65 ++++
 .../service/aimodelconfig/ToolFactory.java    |  54 +++
 .../service/graph/Context/StreamContext.java  |   2 +
 .../service/react/ReactAgentService.java      |  29 ++
 .../service/react/ReactAgentServiceImpl.java  | 313 ++++++++++++++++++
 .../dataagent/tools/ListTableSchemaTool.java  | 179 ++++++++++
 .../tools/SequentialThinkingTool.java         | 240 ++++++++++++++
 .../ai/dataagent/tools/SqlExecuteTool.java    | 165 +++++++++
 .../ai/dataagent/tools/TodoWriteTool.java     | 244 ++++++++++++++
 .../prompts/default-data-analysis.txt         |  68 ++++
 pom.xml                                       |  20 +-
 20 files changed, 1910 insertions(+), 54 deletions(-)
 create mode 100644 data-agent-frontend/src/components/run/ToolCallingView.vue
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
 create mode 100644 data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
 create mode 100644 data-agent-management/src/main/resources/prompts/default-data-analysis.txt

diff --git a/data-agent-frontend/src/components/run/ToolCallingView.vue b/data-agent-frontend/src/components/run/ToolCallingView.vue
new file mode 100644
index 000000000..c347c6243
--- /dev/null
+++ b/data-agent-frontend/src/components/run/ToolCallingView.vue
@@ -0,0 +1,263 @@
+<!--
+ * Copyright 2025 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+-->
+
+<script setup lang="ts">
+  import { ref, computed } from 'vue';
+  import { Tools } from '@element-plus/icons-vue';
+  import MarkdownAgentContainer from './markdown/MarkdownAgentContainer.vue';
+
+  interface ToolCall {
+    toolName: string;
+    input: any;
+    output: any;
+  }
+
+  interface ResultData {
+    toolCalls?: ToolCall[];
+    [key: string]: any;
+  }
+
+  const props = defineProps<{
+    resultData: ResultData;
+  }>();
+
+  const activeNames = ref<string[]>([]);
+
+  const toolCalls = computed(() => {
+    const data = props.resultData;
+    if (!data) return [];
+
+    if (Array.isArray(data.toolCalls)) {
+      return data.toolCalls;
+    }
+
+    if (Array.isArray(data)) {
+      return data;
+    }
+
+    if (data.toolName && data.input !== undefined && data.output !== undefined) {
+      return [data];
+    }
+
+    return [];
+  });
+
+  const isSequentialThinking = (toolName: string): boolean => {
+    return toolName === 'sequential_thinking';
+  };
+
+  const formatJson = (data: any): string => {
+    if (typeof data === 'string') {
+      try {
+        return JSON.stringify(JSON.parse(data), null, 2);
+      } catch {
+        return data;
+      }
+    }
+    return JSON.stringify(data, null, 2);
+  };
+
+  const getThoughtContent = (input: any): string => {
+    if (typeof input === 'string') {
+      try {
+        const parsed = JSON.parse(input);
+        return parsed.thought || '';
+      } catch {
+        return '';
+      }
+    }
+    return input?.thought || '';
+  };
+
+  const getThoughtMetadata = (input: any): any => {
+    if (typeof input === 'string') {
+      try {
+        const parsed = JSON.parse(input);
+        return {
+          thought_number: parsed.thought_number,
+          total_thoughts: parsed.total_thoughts,
+          next_thought_needed: parsed.next_thought_needed,
+          needs_more_thoughts: parsed.needs_more_thoughts,
+        };
+      } catch {
+        return null;
+      }
+    }
+    return {
+      thought_number: input?.thought_number,
+      total_thoughts: input?.total_thoughts,
+      next_thought_needed: input?.next_thought_needed,
+      needs_more_thoughts: input?.needs_more_thoughts,
+    };
+  };
+</script>
+
+<template>
+  <div v-if="toolCalls.length > 0" class="tool-calling-container">
+    <el-collapse v-model="activeNames" class="tool-collapse">
+      <el-collapse-item
+        v-for="(toolCall, index) in toolCalls"
+        :key="index"
+        :name="String(index)"
+        class="tool-collapse-item"
+      >
+        <template #title>
+          <div class="tool-title">
+            <el-icon class="tool-icon"><Tools /></el-icon>
+            <span class="tool-name">{{ toolCall.toolName }}</span>
+          </div>
+        </template>
+
+        <div class="tool-content">
+          <div class="content-section">
+            <div class="section-title">输入参数 (Input)</div>
+            <div v-if="isSequentialThinking(toolCall.toolName)" class="sequential-thinking-content">
+              <div v-if="getThoughtMetadata(toolCall.input)" class="thought-metadata">
+                <span class="metadata-item">思考步骤: {{ getThoughtMetadata(toolCall.input)?.thought_number }} / {{ getThoughtMetadata(toolCall.input)?.total_thoughts }}</span>
+                <span class="metadata-item" :class="{ 'status-true': getThoughtMetadata(toolCall.input)?.next_thought_needed, 'status-false': !getThoughtMetadata(toolCall.input)?.next_thought_needed }">
+                  {{ getThoughtMetadata(toolCall.input)?.next_thought_needed ? '需要继续思考' : '思考完成' }}
+                </span>
+              </div>
+              <div class="thought-content">
+                <MarkdownAgentContainer :content="getThoughtContent(toolCall.input)" />
+              </div>
+            </div>
+            <pre v-else class="json-display">{{ formatJson(toolCall.input) }}</pre>
+          </div>
+
+          <div class="content-section">
+            <div class="section-title">输出参数 (Output)</div>
+            <pre class="json-display">{{ toolCall.output }}</pre>
+          </div>
+        </div>
+      </el-collapse-item>
+    </el-collapse>
+  </div>
+</template>
+
+<style scoped>
+  .tool-calling-container {
+    width: 100%;
+    margin: 12px 0;
+  }
+
+  .tool-collapse {
+    border: 1px solid #ebeef5;
+    border-radius: 4px;
+    overflow: hidden;
+  }
+
+  .tool-collapse-item {
+    border-bottom: 1px solid #ebeef5;
+  }
+
+  .tool-collapse-item:last-child {
+    border-bottom: none;
+  }
+
+  .tool-title {
+    display: flex;
+    align-items: center;
+    width: 100%;
+  }
+
+  .tool-icon {
+    margin-right: 8px;
+    color: #409eff;
+  }
+
+  .tool-name {
+    font-weight: 500;
+    color: #303133;
+    font-size: 14px;
+  }
+
+  .tool-content {
+    padding: 16px;
+    background-color: #fafafa;
+  }
+
+  .content-section {
+    margin-bottom: 16px;
+  }
+
+  .content-section:last-child {
+    margin-bottom: 0;
+  }
+
+  .section-title {
+    font-size: 13px;
+    font-weight: 600;
+    color: #606266;
+    margin-bottom: 8px;
+    padding-bottom: 4px;
+    border-bottom: 1px solid #e4e7ed;
+  }
+
+  .json-display {
+    background-color: #f5f7fa;
+    border: 1px solid #e4e7ed;
+    border-radius: 4px;
+    padding: 12px;
+    margin: 0;
+    font-size: 12px;
+    line-height: 1.5;
+    color: #303133;
+    overflow-x: auto;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+  }
+
+  .sequential-thinking-content {
+    background-color: #f5f7fa;
+    border: 1px solid #e4e7ed;
+    border-radius: 4px;
+    padding: 12px;
+  }
+
+  .thought-metadata {
+    display: flex;
+    gap: 12px;
+    margin-bottom: 12px;
+    padding-bottom: 8px;
+    border-bottom: 1px solid #e4e7ed;
+  }
+
+  .metadata-item {
+    font-size: 12px;
+    color: #606266;
+    padding: 2px 8px;
+    background-color: #e4e7ed;
+    border-radius: 3px;
+  }
+
+  .status-true {
+    background-color: #ecf5ff;
+    color: #409eff;
+  }
+
+  .status-false {
+    background-color: #f0f9ff;
+    color: #67c23a;
+  }
+
+  .thought-content {
+    padding: 8px;
+    background-color: #ffffff;
+    border-radius: 4px;
+    min-height: 40px;
+  }
+</style>
diff --git a/data-agent-frontend/src/services/graph.ts b/data-agent-frontend/src/services/graph.ts
index ef50143c2..80154019c 100644
--- a/data-agent-frontend/src/services/graph.ts
+++ b/data-agent-frontend/src/services/graph.ts
@@ -22,6 +22,7 @@ export interface GraphRequest {
   humanFeedbackContent?: string;
   rejectedPlan: boolean;
   nl2sqlOnly: boolean;
+  reactAgent: boolean;
 }
 
 export interface GraphNodeResponse {
@@ -42,6 +43,7 @@ export enum TextType {
   MARK_DOWN = 'MARK_DOWN',
   RESULT_SET = 'RESULT_SET',
   TEXT = 'TEXT',
+  TOOL_CALL_NODE = 'TOOL_CALL_NODE',
 }
 
 const API_BASE_URL = '/api';
@@ -71,6 +73,7 @@ class GraphService {
     params.append('humanFeedback', request.humanFeedback.toString());
     params.append('rejectedPlan', request.rejectedPlan.toString());
     params.append('nl2sqlOnly', request.nl2sqlOnly.toString());
+    params.append('reactAgent', request.reactAgent.toString());
 
     if (request.humanFeedbackContent) {
       params.append('humanFeedbackContent', request.humanFeedbackContent);
diff --git a/data-agent-frontend/src/views/AgentRun.vue b/data-agent-frontend/src/views/AgentRun.vue
index 1381af373..7d0a9a56a 100644
--- a/data-agent-frontend/src/views/AgentRun.vue
+++ b/data-agent-frontend/src/views/AgentRun.vue
@@ -64,6 +64,14 @@
                   :pageSize="resultSetDisplayConfig.pageSize"
                 />
               </div>
+              <!-- ToolCallNode消息 -->
+              <div v-else-if="message.messageType === 'tool-call-node'" class="agent-response-block">
+                <ToolCallingView
+                    v-if="message.content"
+                    :resultData="JSON.parse(message.content)"
+                />
+              </div>
+              <!-- Markdown报告消息 -->
               <div
                 v-else-if="message.messageType === 'markdown-report'"
                 class="markdown-report-message"
@@ -176,6 +184,22 @@
                       />
                     </div>
                   </div>
+                  <!-- 如果是工具调用节点 -->
+                  <div
+                      v-else-if="nodeBlock.length > 0
+                      && nodeBlock[0].nodeName === 'ToolCallNode'"
+                      class="agent-response-block"
+                  >
+                    <div class="agent-response-title">
+                      {{ nodeBlock[0].nodeName }}
+                    </div>
+                    <div class="agent-response-content">
+                      <ToolCallingView
+                          v-if="nodeBlock[0].text"
+                          :resultData="JSON.parse(nodeBlock[0].text)"
+                      />
+                    </div>
+                  </div>
                   <!-- 其他节点使用原来的 HTML 渲染方式 -->
                   <div v-else v-html="generateNodeHtml(nodeBlock)"></div>
                 </template>
@@ -228,15 +252,24 @@
                   >
                     <el-switch
                       v-model="requestOptions.humanFeedback"
-                      :disabled="requestOptions.nl2sqlOnly || isStreaming || showHumanFeedback"
+                      :disabled="requestOptions.nl2sqlOnly || requestOptions.reactAgent || isStreaming || showHumanFeedback"
                     />
                   </el-tooltip>
                 </div>
+                <div class="switch-item">
+                  <span class="switch-label">智能推理</span>
+                  <el-switch
+                      v-model="requestOptions.reactAgent"
+                      :disabled="isStreaming || showHumanFeedback"
+                      @change="handleReactAgentChange"
+                  />
+                </div>
+
                 <div class="switch-item">
                   <span class="switch-label">仅NL2SQL</span>
                   <el-switch
                     v-model="requestOptions.nl2sqlOnly"
-                    :disabled="isStreaming || showHumanFeedback"
+                    :disabled="requestOptions.reactAgent || isStreaming || showHumanFeedback"
                     @change="handleNl2sqlOnlyChange"
                   />
                 </div>
@@ -354,55 +387,51 @@
 </template>
 
 <script lang="ts">
-  import { ref, defineComponent, onMounted, nextTick, computed } from 'vue';
-  import { useRoute } from 'vue-router';
-  import { ElMessage } from 'element-plus';
-  import {
-    Loading,
-    Promotion,
-    Document,
-    Download,
-    CircleClose,
-    FullScreen,
-    Close,
-    ArrowDown,
-  } from '@element-plus/icons-vue';
-  import hljs from 'highlight.js';
-  import { marked } from 'marked';
-  import DOMPurify from 'dompurify';
-  import 'highlight.js/styles/github.css';
-  // 导入并注册语言
-  import sql from 'highlight.js/lib/languages/sql';
-  import python from 'highlight.js/lib/languages/python';
-  import json from 'highlight.js/lib/languages/json';
-
-  // 注册语言
+import {computed, defineComponent, nextTick, onMounted, ref} from 'vue';
+import {useRoute} from 'vue-router';
+import {ElMessage} from 'element-plus';
+import {
+  ArrowDown,
+  CircleClose,
+  Close,
+  Document,
+  Download,
+  FullScreen,
+  Loading,
+  Promotion,
+} from '@element-plus/icons-vue';
+import hljs from 'highlight.js';
+import {marked} from 'marked';
+import DOMPurify from 'dompurify';
+import 'highlight.js/styles/github.css';
+// 导入并注册语言
+import sql from 'highlight.js/lib/languages/sql';
+import python from 'highlight.js/lib/languages/python';
+import json from 'highlight.js/lib/languages/json';
+import BaseLayout from '@/layouts/BaseLayout.vue';
+import AgentService, {type Agent} from '@/services/agent';
+import ChatService, {type ChatMessage, type ChatSession} from '@/services/chat';
+import GraphService, {type GraphNodeResponse, type GraphRequest, TextType,} from '@/services/graph';
+import {
+  type ResultData,
+  type ResultSetData,
+  type ResultSetDisplayConfig,
+} from '@/services/resultSet';
+import {SessionRuntimeState, useSessionStateManager} from '@/services/sessionStateManager';
+import HumanFeedback from '@/components/run/HumanFeedback.vue';
+import ChatSessionSidebar from '@/components/run/ChatSessionSidebar.vue';
+import PresetQuestions from '@/components/run/PresetQuestions.vue';
+import MarkdownAgentContainer from '@/components/run/markdown';
+import ReportHtmlView from '@/components/run/ReportHtmlView.vue';
+import ResultSetDisplay from '@/components/run/ResultSetDisplay.vue';
+import ToolCallingView from '@/components/run/ToolCallingView.vue';
+
+// 注册语言
   hljs.registerLanguage('sql', sql);
   hljs.registerLanguage('python', python);
   hljs.registerLanguage('json', json);
-  import BaseLayout from '@/layouts/BaseLayout.vue';
-  import AgentService from '@/services/agent';
-  import ChatService, { type ChatSession, type ChatMessage } from '@/services/chat';
-  import GraphService, {
-    type GraphRequest,
-    type GraphNodeResponse,
-    TextType,
-  } from '@/services/graph';
-  import { type Agent } from '@/services/agent';
-  import {
-    type ResultData,
-    type ResultSetData,
-    type ResultSetDisplayConfig,
-  } from '@/services/resultSet';
-  import { SessionRuntimeState, useSessionStateManager } from '@/services/sessionStateManager';
-  import HumanFeedback from '@/components/run/HumanFeedback.vue';
-  import ChatSessionSidebar from '@/components/run/ChatSessionSidebar.vue';
-  import PresetQuestions from '@/components/run/PresetQuestions.vue';
-  import MarkdownAgentContainer from '@/components/run/markdown';
-  import ReportHtmlView from '@/components/run/ReportHtmlView.vue';
-  import ResultSetDisplay from '@/components/run/ResultSetDisplay.vue';
-
-  // 扩展Window接口以包含自定义方法
+
+// 扩展Window接口以包含自定义方法
   declare global {
     interface Window {
       copyTextToClipboard: (btn: HTMLElement) => void;
@@ -428,6 +457,7 @@
       MarkdownAgentContainer,
       ReportHtmlView,
       ResultSetDisplay,
+      ToolCallingView,
     },
     created() {
       window.copyTextToClipboard = btn => {
@@ -514,12 +544,23 @@
       const requestOptions = ref({
         humanFeedback: false,
         nl2sqlOnly: false,
+        reactAgent: false,
         reportFormat: 'markdown' as 'markdown' | 'html', // 'markdown' | 'html'，控制报告展示方式
       });
       const showReportFullscreen = ref(false);
       const fullscreenReportContent = ref('');
       const inputControlsCollapsed = ref(false);
 
+      // 监听智能推理开关变化
+      const handleReactAgentChange = (value: boolean) => {
+        if (value) {
+          // 当智能推理开启时，禁用人工反馈，并设为false
+          requestOptions.value.humanFeedback = false;
+          // 禁用NL2SQL开关
+          requestOptions.value.nl2sqlOnly = false;
+        }
+      };
+
       // 监听NL2SQL开关变化
       const handleNl2sqlOnlyChange = (value: boolean) => {
         if (value) {
@@ -609,11 +650,17 @@
             query: userInput.value,
             humanFeedback: requestOptions.value.humanFeedback,
             nl2sqlOnly: requestOptions.value.nl2sqlOnly,
+            reactAgent: requestOptions.value.reactAgent,
             rejectedPlan: false,
             humanFeedbackContent: null,
             threadId: sessionState.lastRequest?.threadId || null,
           };
 
+          if(request.reactAgent) {
+            // threadId 不能为空，如果为空则默认一个uuid
+            request.threadId = request.threadId || crypto.randomUUID();
+          }
+
           userInput.value = '';
 
           await sendGraphRequest(request, true);
@@ -663,6 +710,23 @@
                 console.error('解析结果集JSON失败:', error);
               }
             }
+            // 特殊处理ToolCallNode
+            if (node.length > 0 && node[0].textType === TextType.TOOL_CALL_NODE) {
+              try {
+                const aiMessage: ChatMessage = {
+                  sessionId,
+                  role: 'assistant',
+                  content: node[0].text, // 保存原始JSON数据
+                  messageType: 'tool-call-node', // 使用特殊的messageType
+                };
+                return ChatService.saveMessage(sessionId, aiMessage).catch(error => {
+                  console.error('保存AI消息失败:', error);
+                });
+              } catch (error) {
+                console.error('解析结果集JSON失败:', error);
+              }
+            }
+
 
             // 使用generateNodeHtml方法生成HTML代码，确保显示与保存一致
             const nodeHtml = generateNodeHtml(node);
@@ -769,7 +833,45 @@
                 };
                 sessionState.nodeBlocks.push([newBlock]);
                 currentBlockIndex = sessionState.nodeBlocks.length - 1;
-              } else {
+              }
+              else if (response.nodeName === 'ToolCallNode') {
+                const isNewNode: boolean =
+                    currentNodeName === null || response.nodeName !== currentNodeName;
+                if (isNewNode) {
+                  // 保存上一个节点的消息（如果有）
+                  if (currentBlockIndex >= 0 && sessionState.nodeBlocks[currentBlockIndex]) {
+                    const savePromise = saveNodeMessage(sessionState.nodeBlocks[currentBlockIndex]);
+                    pendingSavePromises.push(savePromise);
+                  }
+                  // 创建新的节点块
+                  const newBlock: GraphNodeResponse = {
+                    ...response,
+                    text: response.text,
+                    textType: TextType.TOOL_CALL_NODE
+                  };
+                  sessionState.nodeBlocks.push([newBlock]);
+                  currentBlockIndex = sessionState.nodeBlocks.length - 1;
+                  currentNodeName = response.nodeName;
+                }else {
+                  // 保存当前节点的消息（在添加新元素之前保存）
+                  if (currentBlockIndex >= 0 && sessionState.nodeBlocks[currentBlockIndex]) {
+                    const currentNodeCopy = [...sessionState.nodeBlocks[currentBlockIndex]];
+                    console.log('the save node is : ', currentNodeCopy);
+                    const savePromise = saveNodeMessage(currentNodeCopy);
+                    pendingSavePromises.push(savePromise);
+                  }
+                  // 创建新的节点块
+                  const newBlock: GraphNodeResponse = {
+                    ...response,
+                    text: response.text,
+                    textType: TextType.TOOL_CALL_NODE
+                  };
+                  sessionState.nodeBlocks.push([newBlock]);
+                  currentBlockIndex = sessionState.nodeBlocks.length - 1;
+                  currentNodeName = response.nodeName;
+                }
+              }
+              else {
                 // 处理其他节点（同步处理逻辑）
                 const isNewNode: boolean =
                   currentNodeName === null || response.nodeName !== currentNodeName;
@@ -1368,6 +1470,7 @@
         formatMessageContent,
         formatNodeContent,
         generateNodeHtml,
+        handleReactAgentChange,
         handleNl2sqlOnlyChange,
         openReportFullscreen,
         closeReportFullscreen,
diff --git a/data-agent-management/pom.xml b/data-agent-management/pom.xml
index 2371dd4ea..bf74f4f52 100644
--- a/data-agent-management/pom.xml
+++ b/data-agent-management/pom.xml
@@ -169,6 +169,12 @@
             <artifactId>commons-collections</artifactId>
         </dependency>
 
+        <!-- ReactAgent依赖 -->
+        <dependency>
+            <groupId>com.alibaba.cloud.ai</groupId>
+            <artifactId>spring-ai-alibaba-agent-framework</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>com.alibaba.cloud.ai</groupId>
             <artifactId>spring-ai-alibaba-graph-core</artifactId>
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java
index 53230cfe1..e1d14307b 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java
@@ -17,6 +17,7 @@
 
 import com.alibaba.cloud.ai.dataagent.dto.GraphRequest;
 import com.alibaba.cloud.ai.dataagent.service.graph.GraphService;
+import com.alibaba.cloud.ai.dataagent.service.react.ReactAgentService;
 import com.alibaba.cloud.ai.dataagent.vo.GraphNodeResponse;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.AllArgsConstructor;
@@ -43,13 +44,17 @@ public class GraphController {
 
 	private final GraphService graphService;
 
+	private final ReactAgentService reactAgentService;
+
 	@GetMapping(value = "/stream/search", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
 	public Flux<ServerSentEvent<GraphNodeResponse>> streamSearch(@RequestParam("agentId") String agentId,
 			@RequestParam(value = "threadId", required = false) String threadId, @RequestParam("query") String query,
 			@RequestParam(value = "humanFeedback", required = false) boolean humanFeedback,
 			@RequestParam(value = "humanFeedbackContent", required = false) String humanFeedbackContent,
 			@RequestParam(value = "rejectedPlan", required = false) boolean rejectedPlan,
-			@RequestParam(value = "nl2sqlOnly", required = false) boolean nl2sqlOnly, HttpServletResponse response) {
+			@RequestParam(value = "nl2sqlOnly", required = false) boolean nl2sqlOnly,
+			@RequestParam(value = "reactAgent", required = false) boolean reactAgent,
+			HttpServletResponse response) {
 		// Set SSE-related HTTP headers
 		response.setCharacterEncoding("UTF-8");
 		response.setContentType("text/event-stream");
@@ -69,7 +74,12 @@ public Flux<ServerSentEvent<GraphNodeResponse>> streamSearch(@RequestParam("agen
 			.rejectedPlan(rejectedPlan)
 			.nl2sqlOnly(nl2sqlOnly)
 			.build();
-		graphService.graphStreamProcess(sink, request);
+		if(reactAgent) {
+			//
+			reactAgentService.reactStreamProcess(sink, request);
+		}else {
+			graphService.graphStreamProcess(sink, request);
+		}
 
 		return sink.asFlux().filter(sse -> {
 			// 1. 如果 event 是 "complete" 或 "error"，直接放行（不管 text 是否为空）
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java
new file mode 100644
index 000000000..d67e6fbd5
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java
@@ -0,0 +1,15 @@
+package com.alibaba.cloud.ai.dataagent.dto.tool;
+
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ToolCallDTO {
+  private String toolName;
+  private String input;
+  private String output;
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
new file mode 100644
index 000000000..89f301cf1
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.cloud.ai.dataagent.interceptor;
+
+import com.alibaba.cloud.ai.graph.agent.interceptor.ToolCallHandler;
+import com.alibaba.cloud.ai.graph.agent.interceptor.ToolCallRequest;
+import com.alibaba.cloud.ai.graph.agent.interceptor.ToolCallResponse;
+import com.alibaba.cloud.ai.graph.agent.interceptor.ToolInterceptor;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+public class ToolsInterceptor extends ToolInterceptor {
+
+  public interface ToolCallCallback {
+
+    void onToolCall(String threadId, String toolName, String input, String output);
+  }
+
+  private final List<ToolCallCallback> callbacks = new ArrayList<>();
+
+  @Override
+  public ToolCallResponse interceptToolCall(ToolCallRequest request, ToolCallHandler handler) {
+    log.debug("ToolInterceptor: Tool {} is called!", request.getToolName());
+    String threadId = request.getContext().get("thread_id").toString();
+    String inputs = request.getArguments();
+    // 调用所有回调
+    log.debug(" the tool callback start, size: {}", callbacks.size());
+    ToolCallResponse response = handler.call(request);
+    String output = response.getResult();
+    // 调用所有回调
+    for (ToolCallCallback callback : callbacks) {
+      try {
+        callback.onToolCall(threadId, request.getToolName(), inputs, output);
+      } catch (Exception e) {
+        log.error("Error in tool call callback: {}", e.getMessage(), e);
+      }
+    }
+    return response;
+  }
+
+  @Override
+  public String getName() {
+    return "LogToolInterceptor";
+  }
+
+  public void addToolCallCallback(ToolCallCallback callback) {
+    log.info("add tool call callback: {}", callback);
+    callbacks.add(callback);
+  }
+
+  public void removeToolCallCallback(ToolCallCallback callback) {
+    callbacks.remove(callback);
+  }
+
+}
\ No newline at end of file
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptConstant.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptConstant.java
index 8c9030375..f3fd37412 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptConstant.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptConstant.java
@@ -96,4 +96,9 @@ public static PromptTemplate getDataViewAnalyzePromptTemplate() {
 		return new PromptTemplate(PromptLoader.loadPrompt("data-view-analyze"));
 	}
 
+	// default-data-analysis.txt
+	public static PromptTemplate getDefaultDataAnalysisPromptTemplate() {
+		return new PromptTemplate(PromptLoader.loadPrompt("default-data-analysis"));
+	}
+
 }
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptHelper.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptHelper.java
index 29d3a4984..a9913f101 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptHelper.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/prompt/PromptHelper.java
@@ -305,6 +305,12 @@ public static String buildEvidenceQueryRewritePrompt(String multiTurn, String la
 		return PromptConstant.getEvidenceQueryRewritePromptTemplate().render(params);
 	}
 
+	public static String buildDefaultDataAnalysisPrompt() {
+		Map<String, Object> params = new HashMap<>();
+		params.put("current_time", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+		return PromptConstant.getDefaultDataAnalysisPromptTemplate().render(params);
+	}
+
 	/**
 	 * 渲染优化提示词模板
 	 * @param optimizationPrompt 优化提示词模板
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java
new file mode 100644
index 000000000..8be65f900
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java
@@ -0,0 +1,65 @@
+package com.alibaba.cloud.ai.dataagent.service.aimodelconfig;
+
+import com.alibaba.cloud.ai.dataagent.dto.ModelConfigDTO;
+import com.alibaba.cloud.ai.dataagent.enums.ModelType;
+import com.alibaba.cloud.ai.dataagent.interceptor.ToolsInterceptor;
+import com.alibaba.cloud.ai.dataagent.prompt.PromptHelper;
+import com.alibaba.cloud.ai.graph.agent.ReactAgent;
+import com.alibaba.cloud.ai.graph.checkpoint.savers.MemorySaver;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ChatModel;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class ReactAgentRegistry {
+
+  private final DynamicModelFactory modelFactory;
+
+  private final ModelConfigDataService modelConfigDataService;
+
+
+  private final ToolFactory toolFactory;
+
+  private final ToolsInterceptor toolsInterceptor;
+
+  private volatile ReactAgent reactAgent;
+
+  // =========================================================
+  // 5. 构造ReactAgent
+  // =========================================================
+  public ReactAgent getReactAgent() {
+    if (reactAgent == null) {
+      synchronized (this) {
+        if (reactAgent == null) {
+          log.info("Initializing global ReactAgent...");
+          try {
+            ModelConfigDTO config = modelConfigDataService.getActiveConfigByType(ModelType.CHAT);
+            if (config != null) {
+              ChatModel chatModel = modelFactory.createChatModel(config);
+              // 核心：基于新 Model 创建新 Agent，彻底消除旧参数缓存
+              reactAgent = ReactAgent.builder()
+                  .name("sql-agent")
+                  .description(PromptHelper.buildDefaultDataAnalysisPrompt())
+                  .model(chatModel)
+                  .saver(new MemorySaver())
+                  .tools(toolFactory.getTools())
+                  .interceptors(toolsInterceptor)
+                  .build();
+            }
+          } catch (Exception e) {
+            log.error("Failed to initialize ReactAgent: {}", e.getMessage(), e);
+          }
+          // 兜底：如果还没初始化成功，抛出运行时异常，提示用户配置
+          if (reactAgent == null) {
+            throw new RuntimeException(
+                "No active CHAT model configured. Please configure it in the dashboard.");
+          }
+        }
+      }
+    }
+    return reactAgent;
+  }
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java
new file mode 100644
index 000000000..837944886
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.cloud.ai.dataagent.service.aimodelconfig;
+
+import com.alibaba.cloud.ai.dataagent.tools.ListTableSchemaTool;
+import com.alibaba.cloud.ai.dataagent.tools.SequentialThinkingTool;
+import com.alibaba.cloud.ai.dataagent.tools.SqlExecuteTool;
+import com.alibaba.cloud.ai.dataagent.tools.TodoWriteTool;
+import java.util.ArrayList;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@AllArgsConstructor
+@Component
+public class ToolFactory {
+
+  private final SequentialThinkingTool sequentialThinkingTool;
+
+  private final TodoWriteTool todoWriteTool;
+
+  private final ListTableSchemaTool listTablesTool;
+
+  private final SqlExecuteTool sqlExecuteTool;
+
+  private List<ToolCallback> tools = new ArrayList<>();
+
+  public List<ToolCallback> getTools() {
+    if (tools == null || tools.isEmpty()) {
+      // TODO 这里应该根据UI上的配置来觉得用哪些工具
+      tools.add(todoWriteTool.toolCallback());
+      tools.add(sequentialThinkingTool.toolCallback());
+      tools.add(listTablesTool.toolCallback());
+      tools.add(sqlExecuteTool.toolCallback());
+    }
+    return tools;
+  }
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/graph/Context/StreamContext.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/graph/Context/StreamContext.java
index d31bb85c9..ae17519da 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/graph/Context/StreamContext.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/graph/Context/StreamContext.java
@@ -39,6 +39,8 @@ public class StreamContext {
 
 	private TextType textType;
 
+	private String agentId;
+
 	/**
 	 * 标记是否已经清理，用于防止重复清理
 	 */
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java
new file mode 100644
index 000000000..1ce9037a9
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.cloud.ai.dataagent.service.react;
+
+import com.alibaba.cloud.ai.dataagent.dto.GraphRequest;
+import com.alibaba.cloud.ai.dataagent.vo.GraphNodeResponse;
+import org.springframework.http.codec.ServerSentEvent;
+import reactor.core.publisher.Sinks;
+
+public interface ReactAgentService {
+
+  void reactStreamProcess(Sinks.Many<ServerSentEvent<GraphNodeResponse>> sink, GraphRequest request);
+
+  void stopStreamProcessing(String threadId);
+
+}
\ No newline at end of file
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
new file mode 100644
index 000000000..b79035a1f
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
@@ -0,0 +1,313 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.cloud.ai.dataagent.service.react;
+
+import static com.alibaba.cloud.ai.dataagent.constant.Constant.STREAM_EVENT_COMPLETE;
+import static com.alibaba.cloud.ai.dataagent.constant.Constant.STREAM_EVENT_ERROR;
+
+import com.alibaba.cloud.ai.dataagent.dto.GraphRequest;
+import com.alibaba.cloud.ai.dataagent.dto.tool.ToolCallDTO;
+import com.alibaba.cloud.ai.dataagent.enums.TextType;
+import com.alibaba.cloud.ai.dataagent.interceptor.ToolsInterceptor;
+import com.alibaba.cloud.ai.dataagent.interceptor.ToolsInterceptor.ToolCallCallback;
+import com.alibaba.cloud.ai.dataagent.service.aimodelconfig.AiModelRegistry;
+import com.alibaba.cloud.ai.dataagent.service.aimodelconfig.ReactAgentRegistry;
+import com.alibaba.cloud.ai.dataagent.service.graph.Context.MultiTurnContextManager;
+import com.alibaba.cloud.ai.dataagent.service.graph.Context.StreamContext;
+import com.alibaba.cloud.ai.dataagent.util.JsonUtil;
+import com.alibaba.cloud.ai.dataagent.vo.GraphNodeResponse;
+import com.alibaba.cloud.ai.dataagent.workflow.node.PlannerNode;
+import com.alibaba.cloud.ai.graph.RunnableConfig;
+import com.alibaba.cloud.ai.graph.agent.ReactAgent;
+import com.alibaba.cloud.ai.graph.exception.GraphRunnerException;
+import com.alibaba.cloud.ai.graph.exception.GraphStateException;
+import com.alibaba.cloud.ai.graph.streaming.StreamingOutput;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import java.util.Date;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.codec.ServerSentEvent;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+import reactor.core.Disposable;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Sinks;
+
+@Slf4j
+@Service
+public class ReactAgentServiceImpl implements ReactAgentService {
+
+  private final ReactAgentRegistry reactAgentRegistry;
+  private final Map<String, StreamContext> streamContextMap = new ConcurrentHashMap<>();
+
+  private final ExecutorService executor;
+
+  private final MultiTurnContextManager multiTurnContextManager;
+
+  private final ToolsInterceptor toolsInterceptor;
+
+  public ReactAgentServiceImpl(ExecutorService executor,
+      ReactAgentRegistry reactAgentRegistry,
+      MultiTurnContextManager multiTurnContextManager,
+      ToolsInterceptor toolsInterceptor) throws GraphStateException {
+    this.executor = executor;
+    this.reactAgentRegistry = reactAgentRegistry;
+    this.multiTurnContextManager = multiTurnContextManager;
+    this.toolsInterceptor = toolsInterceptor;
+
+    // 添加工具调用回调
+    this.toolsInterceptor.addToolCallCallback(new ToolCallCallback() {
+      @Override
+      public void onToolCall(String threadId, String toolName, String input, String output) {
+        ReactAgentServiceImpl.this.handleToolCall(threadId, toolName, input, output);
+      }
+    });
+  }
+
+  @Override
+  public void reactStreamProcess(Sinks.Many<ServerSentEvent<GraphNodeResponse>> sink,
+      GraphRequest request){
+    String threadId = request.getThreadId();
+    String agentId = request.getAgentId();
+    String query = request.getQuery();
+
+    ReactAgent reactAgent = reactAgentRegistry.getReactAgent();
+    RunnableConfig config = RunnableConfig.builder().threadId(threadId)
+        .addMetadata("thread_id", threadId)
+        .addMetadata("agent_id", agentId)
+        .addMetadata("current_time", new Date().toString())
+        .build();
+    // 创建并存储 StreamContext
+    StreamContext context = streamContextMap.computeIfAbsent(threadId, k -> new StreamContext());
+    context.setSink(sink);
+    // 过滤掉开始和结束事件
+    Flux<?> nodeOutputFlux = null;
+    try {
+      nodeOutputFlux = reactAgent.stream(query, config)
+          .filter(nodeOutput -> !nodeOutput.isSTART() && !nodeOutput.isEND());
+    } catch (GraphRunnerException e) {
+      log.error("Error streaming node outputs for threadId: {}", threadId, e);
+      throw new RuntimeException(e);
+    }
+    subscribeToFlux(context, nodeOutputFlux, agentId, threadId);
+  }
+
+  @Override
+  public void stopStreamProcessing(String threadId) {
+    log.info("Stopping stream processing for threadId: {}", threadId);
+    StreamContext context = streamContextMap.remove(threadId);
+    if (context != null) {
+      context.cleanup();
+    }
+  }
+
+  /**
+   * 订阅 Flux 并原子性地设置 Disposable 线程安全：使用 synchronized 确保 Disposable 设置的原子性
+   *
+   * @param context        流式处理上下文
+   * @param nodeOutputFlux 节点输出流
+   * @param agentId        代理ID
+   * @param threadId       线程ID
+   */
+  private void subscribeToFlux(StreamContext context, Flux<?> nodeOutputFlux, String agentId,
+      String threadId) {
+    CompletableFuture.runAsync(() -> {
+      // 在订阅之前检查上下文是否仍然有效
+      if (context.isCleaned()) {
+        log.debug("StreamContext cleaned before subscription for threadId: {}", threadId);
+        return;
+      }
+      Disposable disposable = nodeOutputFlux.subscribe(
+          output -> handleNodeOutput(output, agentId, threadId),
+          error -> handleStreamError(agentId, threadId, error),
+          () -> handleStreamComplete(agentId, threadId));
+      // 原子性地设置 Disposable，如果已经清理则立即释放
+      synchronized (context) {
+        if (context.isCleaned()) {
+          // 如果已经清理，立即释放刚创建的 Disposable
+          if (disposable != null && !disposable.isDisposed()) {
+            disposable.dispose();
+          }
+        } else {
+          // 只有在未清理的情况下才设置 Disposable
+          context.setDisposable(disposable);
+        }
+      }
+    }, executor);
+  }
+
+  /**
+   * 处理节点输出
+   */
+  private void handleNodeOutput(Object nodeOutput, String agentId, String threadId) {
+    StreamContext context = streamContextMap.get(threadId);
+    // 检查是否已经停止处理
+    if (context == null || context.getSink() == null) {
+      log.debug("Stream processing already stopped for threadId: {}, skipping output", threadId);
+      return;
+    }
+    if (nodeOutput instanceof StreamingOutput streamingOutput) {
+      handleStreamNodeOutput(threadId, agentId, streamingOutput);
+    }
+  }
+
+  /**
+   * 处理流式错误 线程安全：使用 remove 操作确保只有一个线程能获取到 context
+   */
+  private void handleStreamError(String agentId, String threadId, Throwable error) {
+    log.error("Error in stream processing for threadId: {}: ", threadId, error);
+    StreamContext context = streamContextMap.remove(threadId);
+    if (context != null && !context.isCleaned() && context.getSink() != null) {
+      // 检查 sink 是否还有订阅者
+      if (context.getSink().currentSubscriberCount() > 0) {
+        context.getSink()
+            .tryEmitNext(ServerSentEvent
+                .builder(GraphNodeResponse.error(agentId, threadId,
+                    "Error in stream processing: " + error.getMessage()))
+                .event(STREAM_EVENT_ERROR)
+                .build());
+        context.getSink().tryEmitComplete();
+      }
+      // 清理资源（cleanup 内部已经保证只执行一次）
+      context.cleanup();
+    }
+  }
+
+  /**
+   * 处理流式完成 线程安全：使用 remove 操作确保只有一个线程能获取到 context
+   */
+  private void handleStreamComplete(String agentId, String threadId) {
+    log.info("Stream processing completed successfully for threadId: {}", threadId);
+    StreamContext context = streamContextMap.remove(threadId);
+    if (context != null && !context.isCleaned() && context.getSink() != null) {
+      if (context.getSink().currentSubscriberCount() > 0) {
+        context.getSink()
+            .tryEmitNext(ServerSentEvent.builder(GraphNodeResponse.complete(agentId, threadId))
+                .event(STREAM_EVENT_COMPLETE)
+                .build());
+        context.getSink().tryEmitComplete();
+      }
+      context.cleanup();
+    }
+  }
+
+
+  private void handleStreamNodeOutput(String threadId, String agentId, StreamingOutput output) {
+    StreamContext context = streamContextMap.get(threadId);
+    // 检查是否已经停止处理
+    if (context == null || context.getSink() == null) {
+      log.debug("Stream processing already stopped for threadId: {}, skipping output", threadId);
+      return;
+    }
+    String node = output.node();
+    String chunk = output.chunk();
+
+    if(RunnableConfig.AGENT_MODEL_NAME.equals(node)) {
+      log.debug("handleToolCall: threadId={}, toolName={}, input={}", threadId, node, chunk);
+      log.info("------- {}", output.message().getText());
+    }
+    log.debug("Received Stream output: node={}, chunk={}", node, chunk);
+
+    if (chunk == null || chunk.isEmpty()) {
+      return;
+    }
+
+    // 如果是文本标记符号，则更新文本类型
+    TextType originType = context.getTextType();
+    TextType textType;
+    boolean isTypeSign = false;
+    if (originType == null) {
+      textType = TextType.getTypeByStratSign(chunk);
+      if (textType != TextType.TEXT) {
+        isTypeSign = true;
+      }
+      context.setTextType(textType);
+    } else {
+      textType = TextType.getType(originType, chunk);
+      if (textType != originType) {
+        isTypeSign = true;
+      }
+      context.setTextType(textType);
+    }
+    // 文本标记符号不返回给前端
+    if (!isTypeSign) {
+      if (PlannerNode.class.getSimpleName().equals(node)) {
+        multiTurnContextManager.appendPlannerChunk(threadId, chunk);
+      }
+      GraphNodeResponse response = GraphNodeResponse.builder()
+          .agentId(agentId)
+          .threadId(threadId)
+          .nodeName(node)
+          .text(chunk)
+          .textType(textType)
+          .build();
+      // 检查发送是否成功，如果失败说明客户端已断开
+      Sinks.EmitResult result = context.getSink()
+          .tryEmitNext(ServerSentEvent.builder(response).build());
+      if (result.isFailure()) {
+        log.warn(
+            "Failed to emit data to sink for threadId: {}, result: {}. Stopping stream processing.",
+            threadId, result);
+        // 如果发送失败，停止处理
+        stopStreamProcessing(threadId);
+      }
+    }
+  }
+
+  /**
+   * 处理工具调用，将工具调用的输入和输出写出到流中
+   */
+  private void handleToolCall(String threadId, String toolName, String input, String output) {
+    log.debug("handleToolCall: threadId={}, toolName={}, input={}, output={}", threadId, toolName, input, output);
+    StreamContext context = streamContextMap.get(threadId);
+    // 检查是否已经停止处理
+    if (context == null || context.getSink() == null) {
+      log.debug("Stream processing already stopped for threadId: {}, skipping tool call output", threadId);
+      return;
+    }
+
+    try {
+      ToolCallDTO toolCallDTO = new ToolCallDTO(toolName, input, output);
+      // 创建 GraphNodeResponse
+      GraphNodeResponse response = GraphNodeResponse.builder()
+          .agentId(context.getAgentId())
+          .threadId(threadId)
+          .nodeName("ToolCallNode")
+          .text(JsonUtil.getObjectMapper().writeValueAsString(toolCallDTO))
+          .textType(TextType.JSON)
+          .build();
+
+      // 写出到流中
+      Sinks.EmitResult result = context.getSink()
+          .tryEmitNext(ServerSentEvent.builder(response).build());
+
+      if (result.isFailure()) {
+        log.warn(
+            "Failed to emit tool call data to sink for threadId: {}, result: {}. Stopping stream processing.",
+            threadId, result);
+        // 如果发送失败，停止处理
+        stopStreamProcessing(threadId);
+      }
+    } catch (Exception e) {
+      log.error("Error processing tool call: {}", e.getMessage(), e);
+    }
+  }
+
+
+}
\ No newline at end of file
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
new file mode 100644
index 000000000..f150406f0
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.cloud.ai.dataagent.tools;
+
+import com.alibaba.cloud.ai.dataagent.constant.DocumentMetadataConstant;
+import com.alibaba.cloud.ai.dataagent.mapper.AgentDatasourceMapper;
+import com.alibaba.cloud.ai.dataagent.service.schema.SchemaService;
+import com.fasterxml.jackson.annotation.JsonClassDescription;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyDescription;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiFunction;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.document.Document;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.function.FunctionToolCallback;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+@AllArgsConstructor
+@Slf4j
+@Component
+public class ListTableSchemaTool implements BiFunction<ListTableSchemaTool.Request, ToolContext, String> {
+
+  private final SchemaService schemaService;
+
+  private final AgentDatasourceMapper agentDatasourceMapper;
+
+  @Override
+  public String apply(Request request, ToolContext toolContext) {
+    log.info("========== List Table shema Tool Start ==========");
+
+    Long agentId = null;
+    if (toolContext.getContext().get("agent_id") != null) {
+      agentId = Long.parseLong((String) toolContext.getContext().get("agent_id"));
+    }
+    if (agentId == null) {
+      log.error("agent_id is null, please check the context");
+      return "Error listing table schemas: agent_id is null, please check the context.";
+    }
+    try {
+      // 查询 Agent 的激活数据源
+      Integer datasourceId = agentDatasourceMapper.selectActiveDatasourceIdByAgentId(agentId);
+
+      List<Document> tableDocuments = new ArrayList<>(
+          schemaService.getTableDocumentsByDatasource(datasourceId, request.query()));
+      // extract table names
+      List<String> recalledTableNames = extractTableName(tableDocuments);
+      List<Document> columnDocuments = schemaService.getColumnDocumentsByTableName(datasourceId,
+          recalledTableNames);
+      if (recalledTableNames.isEmpty()) {
+        log.info("No tables found in the database");
+        return "No tables found in the database.";
+      }
+      StringBuilder sb = new StringBuilder();
+      int index = 1;
+      for (String tableName : recalledTableNames) {
+        sb.append("## result").append(index).append(": \n");
+        sb.append(tableName).append("\n");
+        List<Document> columns = columnDocuments.stream()
+            .filter(p -> p.getMetadata().get(DocumentMetadataConstant.TABLE_NAME) != null
+                && p.getMetadata().get(DocumentMetadataConstant.TABLE_NAME).equals(tableName))
+            .toList();
+        if (!columns.isEmpty()) {
+          sb.append("  ---- Columns ----\n");
+        }
+        for (Document column : columns) {
+          String columnName = (String) column.getMetadata().get("name");
+          String columnComment = (String) column.getMetadata().get("description");
+          sb.append("      ").append(columnName);
+          if (StringUtils.hasText(columnComment)) {
+            sb.append("  comment: ").append(columnComment);
+          }
+          sb.append("\n");
+        }
+        index++;
+      }
+      log.info("Found {} tables: {}", recalledTableNames.size(), sb);
+      log.info("========== List Table schema Tool End ==========");
+      return sb.toString();
+    } catch (Exception e) {
+      log.error("Error listing tables", e);
+      return "Error listing tables: " + e.getMessage();
+    }
+  }
+
+  public ToolCallback toolCallback() {
+    return FunctionToolCallback.builder("list_table_schema", this)
+        .description(
+            """
+                # Semantic/vector search tool for retrieving relevant database table Schema from knowledge base based on business intent
+                This tool uses embeddings to understand the user's business-related query and find semantically relevant database table structure information, including table details and column specifications, to provide a foundation for subsequent SQL statement generation.
+                ## Purpose
+                Designed for retrieving database table Schema information aligned with user business needs, specifically to:
+                - Obtain table names and their Chinese names associated with the target business scenario
+                - Retrieve detailed column information including column names, data types, and Chinese names
+                - Provide accurate structural references to guide correct SQL statement drafting
+                - Identify all relevant tables and columns required to fulfill the user's data retrieval or analysis needs via SQL
+                The tool searches by business intent and data relevance rather than exact keyword matching, ensuring it captures all tables/columns related to the user's data request context.
+                ## What the Tool Does NOT Do
+                - Does NOT perform literal keyword-only matching without considering business contextual relevance
+                - Does NOT return actual business data records (only table and column structure metadata)
+                - Should NOT be used for conceptual explanations unrelated to database Schema
+                - Should NOT process queries that do not involve data retrieval or SQL generation requirements
+                - Does NOT generate SQL statements directly (only provides Schema information to support subsequent SQL creation)
+                ## Required Input Behavior
+                "query" must contain **well-formed semantic questions or intent statements** that clearly express the business data need and corresponding Schema retrieval requirement.
+                Each query should represent a **business data scenario, data analysis requirement, or specific data element need** that points to the database table structure needed, such as:
+                - Business process-related data scenarios (e.g., order creation, user payment)
+                - Specific data element tracking needs (e.g., user membership points, product inventory levels)
+                - Data analysis scope requirements (e.g., tables for monthly sales performance analysis)
+                - Contextual data association needs (e.g., tables linked to user delivery information)
+                Avoid:
+                - Isolated keyword lists without business context
+                - Raw unprocessed user messages that don't clarify Schema retrieval intent
+                - Full paragraphs of business logic description without explicit Schema focus
+                - Queries centered on business logic explanations rather than table structure needs
+                ## Examples of valid query shapes (not content):
+                - "Which tables store user order related data and their column structures?"
+                - "Retrieve Schema information of tables associated with user payment records"
+                - "What tables contain user delivery address fields, including column details?"
+                - "Get table structures for product inventory management scenarios"
+                - "Which tables are needed to analyze sales performance, along with their column specs?"
+                ## Parameters
+                - query (required): questions or intent statements.
+                  These should reflect the business data context and the specific Schema information you aim to retrieve.
+                ## Output
+                Returns chunks ranked by semantic relevance to the business intent, reranked when applicable.
+                Results contain structured database Schema information including:
+                - Table name
+                - Table Chinese name
+                - Column name
+                - Column data type
+                - Column Chinese name
+                The results are intended to provide clear, context-aligned structural references for subsequent SQL statement generation.
+                """)
+        .inputType(Request.class)
+        .build();
+  }
+
+  @JsonClassDescription("Request to list matched database tables and schema")
+  public record Request(
+      @JsonProperty(value = "query", required = true)
+      @JsonPropertyDescription("The search query to find relevant documentation. "
+          + "Be specific and include key terms related to your question.") String query) {
+
+  }
+
+  private static List<String> extractTableName(List<Document> tableDocuments) {
+    List<String> tableNames = new ArrayList<>();
+    // metadata中的name字段
+    for (Document document : tableDocuments) {
+      String name = (String) document.getMetadata().get("name");
+      if (name != null && !name.isEmpty()) {
+        tableNames.add(name);
+      }
+    }
+    log.info("At this SchemaRecallNode, Recall tables are: {}", tableNames);
+    return tableNames;
+
+  }
+
+}
\ No newline at end of file
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
new file mode 100644
index 000000000..56f133133
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
@@ -0,0 +1,240 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.cloud.ai.dataagent.tools;
+
+import com.fasterxml.jackson.annotation.JsonClassDescription;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyDescription;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiFunction;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.function.FunctionToolCallback;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@AllArgsConstructor
+@Component
+public class SequentialThinkingTool implements
+    BiFunction<SequentialThinkingTool.Request, ToolContext, String> {
+
+  private final List<Request> thoughtHistory = new ArrayList<>();
+  private final Map<String, List<Request>> branches = new HashMap<>();
+
+  @Override
+  public String apply(Request request, ToolContext toolContext) {
+    log.info("========== Sequential Thinking Tool Start ==========");
+
+    try {
+      // Validate input
+      if (!validate(request)) {
+        return "Validation failed: Invalid input parameters";
+      }
+
+      // Adjust totalThoughts if thoughtNumber exceeds it
+      if (request.thoughtNumber() > request.totalThoughts()) {
+        request = new Request(
+            request.thought(),
+            request.nextThoughtNeeded(),
+            request.thoughtNumber(),
+            request.thoughtNumber(), // Update totalThoughts
+            request.isRevision(),
+            request.revisesThought(),
+            request.branchFromThought(),
+            request.branchId(),
+            request.needsMoreThoughts()
+        );
+      }
+
+      // Add to thought history
+      thoughtHistory.add(request);
+
+      // Handle branching
+      if (request.branchFromThought() != null && request.branchId() != null && !request.branchId()
+          .isEmpty()) {
+        branches.computeIfAbsent(request.branchId(), k -> new ArrayList<>()).add(request);
+      }
+
+      log.info("[Tool][SequentialThinking] Thought: {}", request.thought());
+
+      // Prepare response data
+      List<String> branchKeys = new ArrayList<>(branches.keySet());
+      boolean incomplete = request.nextThoughtNeeded() || (request.needsMoreThoughts()!=null && request.needsMoreThoughts()) ||
+          request.thoughtNumber() < request.totalThoughts();
+
+      Map<String, Object> responseData = new HashMap<>();
+      responseData.put("thought_number", request.thoughtNumber());
+      responseData.put("total_thoughts", request.totalThoughts());
+      responseData.put("next_thought_needed", request.nextThoughtNeeded());
+      responseData.put("branches", branchKeys);
+      responseData.put("thought_history_length", thoughtHistory.size());
+      responseData.put("display_type", "thinking");
+      responseData.put("thought", request.thought());
+      responseData.put("incomplete_steps", incomplete);
+
+      log.info(
+          "[Tool][SequentialThinking] Execute completed - Thought {}/{}",
+          request.thoughtNumber(),
+          request.totalThoughts()
+      );
+
+      String outputMsg = "Thought process recorded";
+      if (incomplete) {
+        outputMsg = "Thought process recorded - unfinished steps remain, continue exploring and calling tools";
+      }
+
+      log.info("========== Sequential Thinking Tool End ==========");
+      return outputMsg;
+    } catch (Exception e) {
+      log.error("Error in sequential thinking tool", e);
+      return "Error in sequential thinking tool: " + e.getMessage();
+    }
+  }
+
+  public ToolCallback toolCallback() {
+    return FunctionToolCallback.builder("sequential_thinking", this)
+        .description(
+            """
+                A detailed tool for dynamic and reflective problem-solving through thoughts.
+                This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
+                Each thought can build on, question, or revise previous insights as understanding deepens.
+                ## When to Use This Tool
+                - Breaking down complex problems into steps
+                - Planning and design with room for revision
+                - Analysis that might need course correction
+                - Problems where the full scope might not be clear initially
+                - Problems that require a multi-step solution
+                - Tasks that need to maintain context over multiple steps
+                - Situations where irrelevant information needs to be filtered out
+                ## Typical Application Scenarios
+                This tool is particularly useful for data analysis workflows involving:
+                - Understanding user business intent from natural language queries
+                - Identifying relevant database tables and columns for the business scenario
+                - Planning SQL query structure based on data requirements
+                - Analyzing query results and extracting meaningful insights
+                - Iterating on SQL statements when results don't meet expectations
+                - Combining multiple data sources to answer complex questions
+                - Validating data quality and completeness before drawing conclusions
+                - Explaining analytical findings in business-friendly language
+                ## Key Features
+                - You can adjust total_thoughts up or down as you progress
+                - You can question or revise previous thoughts
+                - You can add more thoughts even after reaching what seemed like the end
+                - You can express uncertainty and explore alternative approaches
+                - Not every thought needs to build linearly - you can branch or backtrack
+                - Generates a solution hypothesis
+                - Verifies the hypothesis based on the Chain of Thought steps
+                - Repeats the process until satisfied
+                - Provides a correct answer
+                ## Parameters Explained
+                - **thought**: Your current thinking step, which can include:
+                  * Regular analytical steps
+                  * Revisions of previous thoughts
+                  * Questions about previous decisions
+                  * Realizations about needing more analysis
+                  * Changes in approach
+                  * Hypothesis generation
+                  * Hypothesis verification
+                  
+                  **CRITICAL - User-Friendly Thinking**: Write your thoughts in natural, user-friendly language. NEVER mention tool names (like "grep_chunks", "knowledge_search", "web_search", etc.) in your thinking process. Instead, describe your actions in plain language:
+                  - ❌ BAD: "I'll use list_table_schema to search for keywords, then sql_execute for semantic understanding"
+                  - ✅ GOOD: "I'll start by searching for key terms in the knowledge, then explore related concepts"
+                  - ❌ BAD: "After list_table_schema returns results, I'll use sql_execute"
+                  - ✅ GOOD: "After finding relevant documents, I'll search for semantically related content"
+                  
+                  Write thinking as if explaining your reasoning to a user, not documenting technical steps. Focus on WHAT you're trying to find and WHY, not HOW (which tools you'll use).
+                - **next_thought_needed**: True if you need more thinking, even if at what seemed like the end
+                - **thought_number**: Current number in sequence (can go beyond initial total if needed)
+                - **total_thoughts**: Current estimate of thoughts needed (can be adjusted up/down)
+                - **is_revision**: A boolean indicating if this thought revises previous thinking
+                - **revises_thought**: If is_revision is true, which thought number is being reconsidered
+                - **branch_from_thought**: If branching, which thought number is the branching point
+                - **branch_id**: Identifier for the current branch (if any)
+                - **needs_more_thoughts**: If reaching end but realizing more thoughts needed
+                """)
+        .inputType(Request.class)
+        .build();
+  }
+
+  @JsonClassDescription("Request for sequential thinking tool")
+  public record Request(
+      @JsonProperty(value = "thought", required = true)
+      @JsonPropertyDescription("Your current thinking step. Write in natural, user-friendly language. NEVER mention tool names (like \"list_table_schema\", \"sql_execute\", \"web_search\", etc.). Instead, describe actions in plain language (e.g., \"I'll search for key terms\" instead of \"I'll use list_table_schema\"). Focus on WHAT you're trying to find and WHY, not HOW (which tools you'll use).")
+      String thought,
+
+      @JsonProperty(value = "next_thought_needed", required = true)
+      @JsonPropertyDescription("Whether another thought step is needed")
+      boolean nextThoughtNeeded,
+
+      @JsonProperty(value = "thought_number", required = true)
+      @JsonPropertyDescription("Current thought number (numeric value, e.g., 1, 2, 3)")
+      int thoughtNumber,
+
+      @JsonProperty(value = "total_thoughts", required = true)
+      @JsonPropertyDescription("Estimated total thoughts needed (numeric value, e.g., 5, 10)")
+      int totalThoughts,
+
+      @JsonProperty(value = "is_revision")
+      @JsonPropertyDescription("Whether this revises previous thinking")
+      Boolean isRevision,
+
+      @JsonProperty(value = "revises_thought")
+      @JsonPropertyDescription("Which thought is being reconsidered")
+      Integer revisesThought,
+
+      @JsonProperty(value = "branch_from_thought")
+      @JsonPropertyDescription("Branching point thought number")
+      Integer branchFromThought,
+
+      @JsonProperty(value = "branch_id")
+      @JsonPropertyDescription("Branch identifier")
+      String branchId,
+
+      @JsonProperty(value = "needs_more_thoughts")
+      @JsonPropertyDescription("If more thoughts are needed")
+      Boolean needsMoreThoughts
+  ) {
+
+  }
+
+  private boolean validate(Request request) {
+    // Validate thought (required)
+    if (request.thought() == null || request.thought().isEmpty()) {
+      log.error("Invalid thought: must be a non-empty string");
+      return false;
+    }
+
+    // Validate thoughtNumber (required)
+    if (request.thoughtNumber() < 1) {
+      log.error("Invalid thoughtNumber: must be >= 1");
+      return false;
+    }
+
+    // Validate totalThoughts (required)
+    if (request.totalThoughts() < 1) {
+      log.error("Invalid totalThoughts: must be >= 1");
+      return false;
+    }
+
+    return true;
+  }
+
+}
\ No newline at end of file
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
new file mode 100644
index 000000000..34be14039
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.cloud.ai.dataagent.tools;
+
+import com.alibaba.cloud.ai.dataagent.bo.DbConfigBO;
+import com.alibaba.cloud.ai.dataagent.bo.schema.ResultSetBO;
+import com.alibaba.cloud.ai.dataagent.connector.DbQueryParameter;
+import com.alibaba.cloud.ai.dataagent.connector.accessor.Accessor;
+import com.alibaba.cloud.ai.dataagent.util.DatabaseUtil;
+import com.alibaba.cloud.ai.dataagent.util.JsonUtil;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyDescription;
+import java.util.function.BiFunction;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.function.FunctionToolCallback;
+import org.springframework.stereotype.Component;
+
+/**
+ * SQL执行工具，用于执行SQL查询并返回结果
+ * <p>
+ * 参考了 SqlExecuteNode.java 中的 SQL 执行逻辑
+ * </p>
+ */
+@Slf4j
+@AllArgsConstructor
+@Component
+public class SqlExecuteTool implements BiFunction<SqlExecuteTool.Request, ToolContext, String> {
+
+  private final DatabaseUtil databaseUtil;
+
+  @Override
+  public String apply(Request request, ToolContext toolContext) {
+    log.info("========== SQL Execute Tool Start ==========");
+
+    try {
+      // 验证输入
+      Long agentId = null;
+      if(toolContext.getContext().get("agent_id")!=null) {
+        agentId = Long.parseLong((String) toolContext.getContext().get("agent_id"));
+      }
+      if(agentId ==null) {
+        log.error("agent_id is null, please check the context");
+        return "Error listing tables: agent_id is null, please check the context.";
+      }
+
+      if (request.sql() == null || request.sql().isEmpty()) {
+        return "SQL statement is required";
+      }
+
+      // 获取数据库配置
+      DbConfigBO dbConfig = databaseUtil.getAgentDbConfig(agentId);
+      if (dbConfig == null) {
+        return "Database configuration not found for agent ID: " + agentId;
+      }
+
+      // 创建查询参数
+      DbQueryParameter dbQueryParameter = new DbQueryParameter();
+      dbQueryParameter.setSql(request.sql());
+      dbQueryParameter.setSchema(dbConfig.getSchema());
+
+      // 获取数据库访问器
+      Accessor dbAccessor = databaseUtil.getAgentAccessor(agentId);
+      if (dbAccessor == null) {
+        return "Database accessor not found for agent ID: " + agentId;
+      }
+
+      // 执行SQL查询
+      ResultSetBO resultSetBO = dbAccessor.executeSqlAndReturnObject(dbConfig, dbQueryParameter);
+
+      // 生成执行结果
+      String result = generateExecutionResult(request.sql(), resultSetBO);
+
+      log.info("========== SQL Execute Tool End ==========");
+      return result;
+    } catch (Exception e) {
+      log.error("Error executing SQL: {}", e.getMessage(), e);
+      return "Error executing SQL: " + e.getMessage();
+    }
+  }
+
+  /**
+   * 生成SQL执行结果
+   */
+  private String generateExecutionResult(String sql, ResultSetBO resultSetBO) throws Exception {
+    StringBuilder result = new StringBuilder();
+
+    result.append("# SQL执行结果\n\n");
+    result.append("## 执行的SQL\n");
+    result.append("```sql\n").append(sql).append("\n```\n\n");
+
+    if (resultSetBO != null) {
+      result.append("## 执行结果\n");
+      result.append("- 行数: ")
+          .append(resultSetBO.getData() != null ? resultSetBO.getData().size() : 0).append("\n\n");
+
+      if (resultSetBO.getData() != null && !resultSetBO.getData().isEmpty()) {
+        result.append("## 数据预览\n");
+        String resultJson = JsonUtil.getObjectMapper().writeValueAsString(resultSetBO.getData());
+        result.append("```json\n").append(resultJson).append("\n```\n");
+      }
+    } else {
+      result.append("## 执行结果\n");
+      result.append("- 无数据返回\n");
+    }
+
+    return result.toString();
+  }
+
+  /**
+   * SQL执行工具请求参数
+   */
+  public record Request(
+      @JsonProperty(value = "sql", required = true)
+      @JsonPropertyDescription("SQL statement to execute")
+      String sql
+  ) {
+
+  }
+
+  /**
+   * 获取工具回调
+   */
+  public ToolCallback toolCallback() {
+    return FunctionToolCallback.builder("execute_sql", this)
+        .description(
+            """
+                # SQL执行工具
+                用于执行SQL查询并返回结果。
+                ## 何时使用
+                - 当需要执行SQL查询以获取数据时
+                - 当需要验证SQL语句的正确性时
+                - 当需要获取数据库中的数据进行分析时
+                ## 输入参数
+                - `sql`: 要执行的SQL语句（必填）
+                - `agentId`: 代理ID，用于获取数据库配置（必填）
+                - `schema`: 数据库schema（可选）
+                ## 输出
+                - SQL执行结果，包括执行的SQL语句、列数、行数和数据预览
+                - 如果执行失败，返回错误信息
+                ## 注意事项
+                - 请确保SQL语句是有效的，否则会返回错误信息
+                - 请确保agentId是有效的，否则会返回错误信息
+                - 执行结果中的数据预览可能会被截断，仅用于参考
+                """)
+        .inputType(Request.class)
+        .build();
+  }
+
+}
\ No newline at end of file
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
new file mode 100644
index 000000000..53bbdb9ce
--- /dev/null
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
@@ -0,0 +1,244 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.alibaba.cloud.ai.dataagent.tools;
+
+import com.fasterxml.jackson.annotation.JsonClassDescription;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyDescription;
+import java.util.List;
+import java.util.function.BiFunction;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.chat.model.ToolContext;
+import org.springframework.ai.tool.ToolCallback;
+import org.springframework.ai.tool.function.FunctionToolCallback;
+import org.springframework.stereotype.Component;
+
+@Slf4j
+@AllArgsConstructor
+@Component
+public class TodoWriteTool implements BiFunction<TodoWriteTool.Request, ToolContext, String> {
+
+  @Override
+  public String apply(Request request, ToolContext toolContext) {
+    log.info("========== Todo Write Tool Start ==========");
+
+    try {
+      // Validate input
+      if (request.task() == null || request.task().isEmpty()) {
+        return "Task description is required";
+      }
+
+      if (request.steps() == null || request.steps().isEmpty()) {
+        return generateEmptyPlanOutput(request.task());
+      }
+
+      // Generate formatted output
+      String output = generatePlanOutput(request.task(), request.steps());
+
+      log.info("========== Todo Write Tool End ==========");
+      return output;
+    } catch (Exception e) {
+      log.error("Error in todo write tool", e);
+      return "Error in todo write tool: " + e.getMessage();
+    }
+  }
+
+  public ToolCallback toolCallback() {
+    return FunctionToolCallback.builder("todo_write", this)
+        .description(
+            """
+                Use this tool to create and manage a structured task list for retrieval and research tasks. This helps you track progress, organize complex retrieval operations, and demonstrate thoroughness to user.
+                **CRITICAL - Focus on Retrieval Tasks Only**:
+                - This tool is for tracking RETRIEVAL and RESEARCH tasks (e.g., searching knowledge bases, retrieving documents, gathering information)
+                - DO NOT include summary or synthesis tasks in todo_write - those are handled by thinking tool
+                - Examples of appropriate tasks: "Search for X in knowledge base", "Retrieve information about Y", "Compare A and B"
+                - Examples of tasks to EXCLUDE: "Summarize findings", "Generate final answer", "Synthesize results" - these are for thinking tool
+                ## When to Use This Tool
+                Use this tool proactively in these scenarios:
+                1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+                2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+                3. User explicitly requests todo list - When user directly asks you to use todo list
+                4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+                5. After receiving new instructions - Immediately capture user requirements as todos
+                6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+                7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+                ## When NOT to Use This Tool
+                Skip using this tool when:
+                1. There is only a single, straightforward task
+                2. The task is trivial and tracking it provides no organizational benefit
+                3. The task is purely conversational or informational
+                NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing task directly.
+                ## Task States and Management
+                1. **Task States**: Use these states to track progress:
+                  - pending: Task not yet started
+                  - in_progress: Currently working on (limit to ONE task at a time)
+                  - completed: Task finished successfully
+                2. **Task Management**:
+                  - Update task status in real-time as you work
+                  - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+                  - Only have ONE task in_progress at any time
+                  - Complete current tasks before starting new ones
+                  - Remove tasks that are no longer relevant from list entirely
+                3. **Task Completion Requirements**:
+                  - ONLY mark a task as completed when you have FULLY accomplished it
+                  - If you encounter errors, blockers, or cannot finish, keep task as in_progress
+                  - When blocked, create a new task describing what needs to be resolved
+                  - Never mark a task as completed if:
+                    - Tests are failing
+                    - Implementation is partial
+                    - You encountered unresolved errors
+                    - You couldn't find necessary files or dependencies
+                4. **Task Breakdown**:
+                  - Create specific, actionable RETRIEVAL tasks
+                  - Break complex retrieval needs into smaller, manageable steps
+                  - Use clear, descriptive task names focused on what to retrieve or research
+                  - **DO NOT include summary/synthesis tasks** - those are handled separately by thinking tool
+                **Important**: After completing all retrieval tasks in todo_write, use thinking tool to synthesize findings and generate final answer. The todo_write tool tracks WHAT to retrieve, while thinking tool handles HOW to synthesize and present information.
+                When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all retrieval requirements successfully.
+                """)
+        .inputType(Request.class)
+        .build();
+  }
+
+  @JsonClassDescription("Request for todo write tool")
+  public record Request(
+      @JsonProperty(value = "task", required = true)
+      @JsonPropertyDescription("The complex task or question you need to create a plan for")
+      String task,
+
+      @JsonProperty(value = "steps", required = true)
+      @JsonPropertyDescription("Array of research plan steps with status tracking")
+      List<PlanStep> steps
+  ) {
+
+  }
+
+  @JsonClassDescription("Plan step for todo write tool")
+  public record PlanStep(
+      @JsonProperty(value = "id", required = true)
+      @JsonPropertyDescription("Unique identifier for this step (e.g., 'step1', 'step2')")
+      String id,
+
+      @JsonProperty(value = "description", required = true)
+      @JsonPropertyDescription("Clear description of what to investigate or accomplish in this step")
+      String description,
+
+      @JsonProperty(value = "status", required = true)
+      @JsonPropertyDescription("Current status: pending (not started), in_progress (executing), completed (finished)")
+      String status
+  ) {
+
+  }
+
+  private String generateEmptyPlanOutput(String task) {
+    StringBuilder output = new StringBuilder();
+    output.append("计划已创建\n\n");
+    output.append("**任务**: ").append(task).append("\n\n");
+    output.append("注意：未提供具体步骤。建议创建3-7个检索任务以系统化研究。\n\n");
+    output.append("建议的检索流程（专注于检索任务，不包含总结）：\n");
+    output.append("1. 使用 grep_chunks 搜索关键词定位相关文档\n");
+    output.append("2. 使用 knowledge_search 进行语义搜索获取相关内容\n");
+    output.append("3. 使用 list_knowledge_chunks 获取关键文档的完整内容\n");
+    output.append("4. 使用 web_search 获取补充信息（如需要）\n");
+    output.append("\n注意：总结和综合由 thinking 工具处理，不要在此处添加总结任务。\n");
+    return output.toString();
+  }
+
+  private String generatePlanOutput(String task, List<PlanStep> steps) {
+    StringBuilder output = new StringBuilder();
+    output.append("计划已创建\n\n");
+    output.append("**任务**: ").append(task).append("\n\n");
+    output.append("**计划步骤**:\n\n");
+
+    // Count task statuses
+    int pendingCount = 0;
+    int inProgressCount = 0;
+    int completedCount = 0;
+    for (PlanStep step : steps) {
+      switch (step.status()) {
+        case "pending":
+          pendingCount++;
+          break;
+        case "in_progress":
+          inProgressCount++;
+          break;
+        case "completed":
+          completedCount++;
+          break;
+      }
+    }
+    int totalCount = steps.size();
+    int remainingCount = pendingCount + inProgressCount;
+
+    // Display all steps in order
+    for (int i = 0; i < steps.size(); i++) {
+      output.append(formatPlanStep(i + 1, steps.get(i)));
+    }
+
+    // Add summary and emphasis on remaining tasks
+    output.append("\n=== 任务进度 ===\n");
+    output.append("总计: ").append(totalCount).append(" 个任务\n");
+    output.append("✅ 已完成: ").append(completedCount).append(" 个\n");
+    output.append("🔄 进行中: ").append(inProgressCount).append(" 个\n");
+    output.append("⏳ 待处理: ").append(pendingCount).append(" 个\n");
+
+    output.append("\n=== ⚠️ 重要提醒 ===\n");
+    if (remainingCount > 0) {
+      output.append("**还有 ").append(remainingCount).append(" 个任务未完成！**\n\n");
+      output.append("**必须完成所有任务后才能总结或得出结论。**\n\n");
+      output.append("下一步操作：\n");
+      if (inProgressCount > 0) {
+        output.append("- 继续完成当前进行中的任务\n");
+      }
+      if (pendingCount > 0) {
+        output.append("- 开始处理 ").append(pendingCount).append(" 个待处理任务\n");
+        output.append("- 按顺序完成每个任务，不要跳过\n");
+      }
+      output.append("- 完成每个任务后，更新 todo_write 标记为 completed\n");
+      output.append("- 只有在所有任务完成后，才能生成最终总结\n");
+    } else {
+      output.append("✅ **所有任务已完成！**\n\n");
+      output.append("现在可以：\n");
+      output.append("- 综合所有任务的发现\n");
+      output.append("- 生成完整的最终答案或报告\n");
+      output.append("- 确保所有方面都已充分研究\n");
+    }
+
+    return output.toString();
+  }
+
+  private String formatPlanStep(int index, PlanStep step) {
+    String statusEmoji;
+    switch (step.status()) {
+      case "pending":
+        statusEmoji = "⏳";
+        break;
+      case "in_progress":
+        statusEmoji = "🔄";
+        break;
+      case "completed":
+        statusEmoji = "✅";
+        break;
+      default:
+        statusEmoji = "⏳";
+    }
+
+    return String.format("  %d. %s [%s] %s\n", index, statusEmoji, step.status(),
+        step.description());
+  }
+
+}
\ No newline at end of file
diff --git a/data-agent-management/src/main/resources/prompts/default-data-analysis.txt b/data-agent-management/src/main/resources/prompts/default-data-analysis.txt
new file mode 100644
index 000000000..b9b39ec38
--- /dev/null
+++ b/data-agent-management/src/main/resources/prompts/default-data-analysis.txt
@@ -0,0 +1,68 @@
+### Role
+You are an intelligent retrieval assistant powered by Progressive Agentic RAG. You operate in a multi-tenant environment with strictly isolated knowledge bases. Your core philosophy is "Evidence-First": you never rely on internal parametric knowledge but construct answers solely from verified data retrieved from the Knowledge Base (KB) or Web (if enabled).
+
+### Mission
+To deliver accurate, traceable, and verifiable answers by orchestrating a dynamic retrieval process. You must first gauge the information landscape through preliminary retrieval, then rigorously execute and reflect upon specific research tasks. **You prioritize "Deep Reading" over superficial scanning.**
+
+### Critical Constraints (ABSOLUTE RULES)
+1.  **NO Internal Knowledge:** You must behave as if your training data does not exist regarding facts.
+2.  **Mandatory Deep Read:** Whenever list_table_schema returns data you should read the result to get table schame, include table and column info, Do not rely on search snippets alone.
+3.  **KB First, Web Second:** Always exhaust KB strategies (including the Deep Read) before attempting Web Search (if enabled).
+4.  **Strict Plan Adherence:** If a todo_write plan exists, execute it sequentially. No skipping.
+5.  **Tool Privacy:** Never expose tool names to the user.
+
+### Workflow: The "Reconnaissance-Plan-Execute" Cycle
+
+#### Phase 1: Preliminary Reconnaissance (Mandatory Initial Step)
+Before answering or creating a plan, you MUST perform a "Deep Read" test of the KB to gain preliminary cognition.
+1.  **Search:** Execute list_table_schema based on core entities.
+2.  **DEEP READ (Crucial):** If the search returns IDs, you **MUST** call list_table_schema on the top relevant IDs to fetch their actual text.
+3.  **Analyze:** In your think block, evaluate the *full text* you just retrieved.
+  *   *Does this text fully answer the user?*
+  *   *Is the information complete or partial?*
+
+#### Phase 2: Strategic Decision & Planning
+Based on the **Deep Read** results from Phase 1:
+*   **Path A (Direct Answer):** If the full text provides sufficient, unambiguous evidence → Proceed to **Answer Generation**.
+*   **Path B (Complex Research):** If the query involves comparison, missing data, or the content requires synthesis → Use todo_write to formulate a Work Plan.
+  *   *Structure:* Break the problem into distinct retrieval tasks (e.g., "Deep read specs for Product A", "Deep read safety protocols").
+
+#### Phase 3: Disciplined Execution & Deep Reflection (The Loop)
+If in **Path B**, execute tasks in todo_write sequentially. For **EACH** task:
+1.  **Search:** Perform list_table_schema for the sub-task.
+2.  **MANDATORY Deep Reflection (in think):** Pause and evaluate the full text:
+  *   *Validity:* "Does this full text specifically address the sub-task?"
+  *   *Gap Analysis:* "Is anything missing? Is the information outdated? Is the information irrelevant?"
+  *   *Correction:* If insufficient, formulate a remedial action (e.g., "Search for synonym X", "Web Search if enabled") immediately.
+  *   *Completion:* Mark task as "completed" ONLY when evidence is secured.
+
+#### Phase 4: Final Synthesis
+Only when ALL todo_write tasks are "completed":
+*   Synthesize findings from the full text of all retrieved chunks.
+*   Check for consistency.
+*   Generate the final response.
+
+### Core Retrieval Strategy (Strict Sequence)
+For every retrieval attempt (Phase 1 or Phase 3), follow this exact chain:
+1.  **Semantic Expansion (list_table_schema):** Use vector search for context (filter by IDs from step 1 if applicable).
+2.  **Deep Contextualization (list_table_schema): MANDATORY.**
+  *   Rule: with knowledgebase_id you should call this tool.
+  *   Frequency: Call it frequently for multiple IDs to ensure you have the full results. **Do not be lazy; fetch the content.**
+3.  **Graph Exploration (query_knowledge_graph):** Optional for relationships.
+4.  **Web Fallback (web_search):** Use ONLY if Web Search is Enabled AND the Deep Read in Step 2 confirms the data is missing or irrelevant.
+
+### Tool Selection Guidelines
+*   **list_table_schema:** Your "Index". Use these to find *where* the table schema information might be.
+*   **todo_write:** Your "Manager". Tracks multi-step research.
+*   **think:** Your "Conscience". Use to plan and reflect the content returned by list_knowledge_chunks.
+*   **execute_sql:** Your "sql engine". Use to execute the sql and get results.
+
+### Final Output Standards
+*   **Definitive:** Based strictly on the "Deep Read" content.
+*   **Sourced(Inline, Proximate Citations):** All factual statements must include a citation immediately after the relevant claim—within the same sentence or paragraph where the fact appears: <kb doc="..." chunk_id="..." /> or <web url="..." title="..." /> (if from web).
+Citations may not be placed at the end of the answer. They must always be inserted inline, at the exact location where the referenced information is used ("proximate citation rule").
+*   **Structured:** Clear hierarchy and logic.
+*   **Rich Media (Markdown with Images):** When retrieved chunks contain images (indicated by the "images" field with URLs), you MUST include them in your response using standard Markdown image syntax: ![description](image_url). Place images at contextually appropriate positions within the answer to create a well-formatted, visually rich response. Images help users better understand the content, especially for diagrams, charts, screenshots, or visual explanations.
+
+### System Status
+Current Time: {current_time}
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 758ede4a7..440ad5b9c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
 
   <properties>
     <!-- Spring AI Alibaba Version -->
-    <spring-ai-alibaba.version>1.1.0.0</spring-ai-alibaba.version>
+    <spring-ai-alibaba.version>1.1.2.0</spring-ai-alibaba.version>
     <!-- Spring AI Alibaba DataAgent Version -->
     <revision>1.0.0-SNAPSHOT</revision>
     <!-- DashScope SDK Version -->
@@ -35,8 +35,8 @@
     <maven.compiler.target>${java.version}</maven.compiler.target>
 
     <!-- Spring version -->
-    <spring-ai.version>1.1.0</spring-ai.version>
-    <spring-boot.version>3.4.8</spring-boot.version>
+    <spring-ai.version>1.1.2</spring-ai.version>
+    <spring-boot.version>3.5.10</spring-boot.version>
     <springdoc-openapi.version>2.8.8</springdoc-openapi.version>
     <spring-javaformat-maven-plugin.version>0.0.39</spring-javaformat-maven-plugin.version>
     <mybatis.version>3.0.4</mybatis.version>
@@ -83,6 +83,20 @@
         <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>com.alibaba.cloud.ai</groupId>
+        <artifactId>spring-ai-alibaba-extensions-bom</artifactId>
+        <version>${spring-ai-alibaba.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
       <dependency>
         <groupId>com.github.docker-java</groupId>
         <artifactId>docker-java-bom</artifactId>

From e227a0158888e8ec8cdd4af8f7df3ca643b2a347 Mon Sep 17 00:00:00 2001
From: fudawei <fudawei@yunlizhihui.com>
Date: Sun, 8 Feb 2026 15:10:55 +0800
Subject: [PATCH 2/3] fix: fix the style bug in project

---
 .../src/components/run/ToolCallingView.vue    |  59 ++-
 data-agent-frontend/src/views/AgentRun.vue    | 136 ++---
 .../dataagent/controller/GraphController.java |   8 +-
 .../ai/dataagent/dto/tool/ToolCallDTO.java    |  26 +-
 .../interceptor/ToolsInterceptor.java         |  73 +--
 .../aimodelconfig/ReactAgentRegistry.java     |  96 ++--
 .../service/aimodelconfig/ToolFactory.java    |  31 +-
 .../service/react/ReactAgentService.java      |   6 +-
 .../service/react/ReactAgentServiceImpl.java  | 471 +++++++++---------
 .../dataagent/tools/ListTableSchemaTool.java  | 259 +++++-----
 .../tools/SequentialThinkingTool.java         | 387 +++++++-------
 .../ai/dataagent/tools/SqlExecuteTool.java    | 238 +++++----
 .../ai/dataagent/tools/TodoWriteTool.java     | 411 ++++++++-------
 13 files changed, 1118 insertions(+), 1083 deletions(-)

diff --git a/data-agent-frontend/src/components/run/ToolCallingView.vue b/data-agent-frontend/src/components/run/ToolCallingView.vue
index c347c6243..428564909 100644
--- a/data-agent-frontend/src/components/run/ToolCallingView.vue
+++ b/data-agent-frontend/src/components/run/ToolCallingView.vue
@@ -103,6 +103,22 @@
       needs_more_thoughts: input?.needs_more_thoughts,
     };
   };
+
+  const processOutputContent = (content: any): string => {
+    if (typeof content === 'string') {
+      // 检查是否是双引号包裹的字符串
+      if (content.startsWith('"') && content.endsWith('"')) {
+        try {
+          // 尝试使用 JSON.parse 解析
+          return JSON.parse(content);
+        } catch {
+          // 如果解析失败，去掉首尾的双引号
+          return content.substring(1, content.length - 1);
+        }
+      }
+    }
+    return content || '';
+  };
 </script>
 
 <template>
@@ -117,7 +133,7 @@
         <template #title>
           <div class="tool-title">
             <el-icon class="tool-icon"><Tools /></el-icon>
-            <span class="tool-name">{{ toolCall.toolName }}</span>
+            <span class="tool-name">调用工具 {{ toolCall.toolName }}</span>
           </div>
         </template>
 
@@ -126,9 +142,22 @@
             <div class="section-title">输入参数 (Input)</div>
             <div v-if="isSequentialThinking(toolCall.toolName)" class="sequential-thinking-content">
               <div v-if="getThoughtMetadata(toolCall.input)" class="thought-metadata">
-                <span class="metadata-item">思考步骤: {{ getThoughtMetadata(toolCall.input)?.thought_number }} / {{ getThoughtMetadata(toolCall.input)?.total_thoughts }}</span>
-                <span class="metadata-item" :class="{ 'status-true': getThoughtMetadata(toolCall.input)?.next_thought_needed, 'status-false': !getThoughtMetadata(toolCall.input)?.next_thought_needed }">
-                  {{ getThoughtMetadata(toolCall.input)?.next_thought_needed ? '需要继续思考' : '思考完成' }}
+                <span class="metadata-item">
+                  思考步骤: {{ getThoughtMetadata(toolCall.input)?.thought_number }} /
+                  {{ getThoughtMetadata(toolCall.input)?.total_thoughts }}
+                </span>
+                <span
+                  class="metadata-item"
+                  :class="{
+                    'status-true': getThoughtMetadata(toolCall.input)?.next_thought_needed,
+                    'status-false': !getThoughtMetadata(toolCall.input)?.next_thought_needed,
+                  }"
+                >
+                  {{
+                    getThoughtMetadata(toolCall.input)?.next_thought_needed
+                      ? '需要继续思考'
+                      : '思考完成'
+                  }}
                 </span>
               </div>
               <div class="thought-content">
@@ -140,7 +169,9 @@
 
           <div class="content-section">
             <div class="section-title">输出参数 (Output)</div>
-            <pre class="json-display">{{ toolCall.output }}</pre>
+            <div class="markdown-content">
+              <MarkdownAgentContainer :content="processOutputContent(toolCall.output)" />
+            </div>
           </div>
         </div>
       </el-collapse-item>
@@ -151,21 +182,18 @@
 <style scoped>
   .tool-calling-container {
     width: 100%;
-    margin: 12px 0;
+    margin: 0px 0;
   }
 
   .tool-collapse {
-    border: 1px solid #ebeef5;
     border-radius: 4px;
     overflow: hidden;
   }
 
   .tool-collapse-item {
-    border-bottom: 1px solid #ebeef5;
   }
 
   .tool-collapse-item:last-child {
-    border-bottom: none;
   }
 
   .tool-title {
@@ -175,6 +203,7 @@
   }
 
   .tool-icon {
+    margin-left: 8px;
     margin-right: 8px;
     color: #409eff;
   }
@@ -187,7 +216,6 @@
 
   .tool-content {
     padding: 16px;
-    background-color: #fafafa;
   }
 
   .content-section {
@@ -204,7 +232,6 @@
     color: #606266;
     margin-bottom: 8px;
     padding-bottom: 4px;
-    border-bottom: 1px solid #e4e7ed;
   }
 
   .json-display {
@@ -217,8 +244,10 @@
     line-height: 1.5;
     color: #303133;
     overflow-x: auto;
+    overflow-y: auto;
     white-space: pre-wrap;
     word-wrap: break-word;
+    max-height: 100px;
   }
 
   .sequential-thinking-content {
@@ -260,4 +289,12 @@
     border-radius: 4px;
     min-height: 40px;
   }
+
+  .markdown-content {
+    background-color: #f5f7fa;
+    border: 1px solid #e4e7ed;
+    border-radius: 4px;
+    padding: 12px;
+    min-height: 40px;
+  }
 </style>
diff --git a/data-agent-frontend/src/views/AgentRun.vue b/data-agent-frontend/src/views/AgentRun.vue
index 7d0a9a56a..e33e97ae3 100644
--- a/data-agent-frontend/src/views/AgentRun.vue
+++ b/data-agent-frontend/src/views/AgentRun.vue
@@ -65,11 +65,11 @@
                 />
               </div>
               <!-- ToolCallNode消息 -->
-              <div v-else-if="message.messageType === 'tool-call-node'" class="agent-response-block">
-                <ToolCallingView
-                    v-if="message.content"
-                    :resultData="JSON.parse(message.content)"
-                />
+              <div
+                v-else-if="message.messageType === 'tool-call-node'"
+                class="agent-response-block"
+              >
+                <ToolCallingView v-if="message.content" :resultData="JSON.parse(message.content)" />
               </div>
               <!-- Markdown报告消息 -->
               <div
@@ -186,17 +186,16 @@
                   </div>
                   <!-- 如果是工具调用节点 -->
                   <div
-                      v-else-if="nodeBlock.length > 0
-                      && nodeBlock[0].nodeName === 'ToolCallNode'"
-                      class="agent-response-block"
+                    v-else-if="nodeBlock.length > 0 && nodeBlock[0].nodeName === 'ToolCallNode'"
+                    class="agent-response-block"
                   >
                     <div class="agent-response-title">
                       {{ nodeBlock[0].nodeName }}
                     </div>
                     <div class="agent-response-content">
                       <ToolCallingView
-                          v-if="nodeBlock[0].text"
-                          :resultData="JSON.parse(nodeBlock[0].text)"
+                        v-if="nodeBlock[0].text"
+                        :resultData="JSON.parse(nodeBlock[0].text)"
                       />
                     </div>
                   </div>
@@ -252,16 +251,21 @@
                   >
                     <el-switch
                       v-model="requestOptions.humanFeedback"
-                      :disabled="requestOptions.nl2sqlOnly || requestOptions.reactAgent || isStreaming || showHumanFeedback"
+                      :disabled="
+                        requestOptions.nl2sqlOnly ||
+                        requestOptions.reactAgent ||
+                        isStreaming ||
+                        showHumanFeedback
+                      "
                     />
                   </el-tooltip>
                 </div>
                 <div class="switch-item">
                   <span class="switch-label">智能推理</span>
                   <el-switch
-                      v-model="requestOptions.reactAgent"
-                      :disabled="isStreaming || showHumanFeedback"
-                      @change="handleReactAgentChange"
+                    v-model="requestOptions.reactAgent"
+                    :disabled="isStreaming || showHumanFeedback"
+                    @change="handleReactAgentChange"
                   />
                 </div>
 
@@ -387,51 +391,55 @@
 </template>
 
 <script lang="ts">
-import {computed, defineComponent, nextTick, onMounted, ref} from 'vue';
-import {useRoute} from 'vue-router';
-import {ElMessage} from 'element-plus';
-import {
-  ArrowDown,
-  CircleClose,
-  Close,
-  Document,
-  Download,
-  FullScreen,
-  Loading,
-  Promotion,
-} from '@element-plus/icons-vue';
-import hljs from 'highlight.js';
-import {marked} from 'marked';
-import DOMPurify from 'dompurify';
-import 'highlight.js/styles/github.css';
-// 导入并注册语言
-import sql from 'highlight.js/lib/languages/sql';
-import python from 'highlight.js/lib/languages/python';
-import json from 'highlight.js/lib/languages/json';
-import BaseLayout from '@/layouts/BaseLayout.vue';
-import AgentService, {type Agent} from '@/services/agent';
-import ChatService, {type ChatMessage, type ChatSession} from '@/services/chat';
-import GraphService, {type GraphNodeResponse, type GraphRequest, TextType,} from '@/services/graph';
-import {
-  type ResultData,
-  type ResultSetData,
-  type ResultSetDisplayConfig,
-} from '@/services/resultSet';
-import {SessionRuntimeState, useSessionStateManager} from '@/services/sessionStateManager';
-import HumanFeedback from '@/components/run/HumanFeedback.vue';
-import ChatSessionSidebar from '@/components/run/ChatSessionSidebar.vue';
-import PresetQuestions from '@/components/run/PresetQuestions.vue';
-import MarkdownAgentContainer from '@/components/run/markdown';
-import ReportHtmlView from '@/components/run/ReportHtmlView.vue';
-import ResultSetDisplay from '@/components/run/ResultSetDisplay.vue';
-import ToolCallingView from '@/components/run/ToolCallingView.vue';
-
-// 注册语言
+  import { computed, defineComponent, nextTick, onMounted, ref } from 'vue';
+  import { useRoute } from 'vue-router';
+  import { ElMessage } from 'element-plus';
+  import {
+    ArrowDown,
+    CircleClose,
+    Close,
+    Document,
+    Download,
+    FullScreen,
+    Loading,
+    Promotion,
+  } from '@element-plus/icons-vue';
+  import hljs from 'highlight.js';
+  import { marked } from 'marked';
+  import DOMPurify from 'dompurify';
+  import 'highlight.js/styles/github.css';
+  // 导入并注册语言
+  import sql from 'highlight.js/lib/languages/sql';
+  import python from 'highlight.js/lib/languages/python';
+  import json from 'highlight.js/lib/languages/json';
+  import BaseLayout from '@/layouts/BaseLayout.vue';
+  import AgentService, { type Agent } from '@/services/agent';
+  import ChatService, { type ChatMessage, type ChatSession } from '@/services/chat';
+  import GraphService, {
+    type GraphNodeResponse,
+    type GraphRequest,
+    TextType,
+  } from '@/services/graph';
+  import {
+    type ResultData,
+    type ResultSetData,
+    type ResultSetDisplayConfig,
+  } from '@/services/resultSet';
+  import { SessionRuntimeState, useSessionStateManager } from '@/services/sessionStateManager';
+  import HumanFeedback from '@/components/run/HumanFeedback.vue';
+  import ChatSessionSidebar from '@/components/run/ChatSessionSidebar.vue';
+  import PresetQuestions from '@/components/run/PresetQuestions.vue';
+  import MarkdownAgentContainer from '@/components/run/markdown';
+  import ReportHtmlView from '@/components/run/ReportHtmlView.vue';
+  import ResultSetDisplay from '@/components/run/ResultSetDisplay.vue';
+  import ToolCallingView from '@/components/run/ToolCallingView.vue';
+
+  // 注册语言
   hljs.registerLanguage('sql', sql);
   hljs.registerLanguage('python', python);
   hljs.registerLanguage('json', json);
 
-// 扩展Window接口以包含自定义方法
+  // 扩展Window接口以包含自定义方法
   declare global {
     interface Window {
       copyTextToClipboard: (btn: HTMLElement) => void;
@@ -656,7 +664,7 @@ import ToolCallingView from '@/components/run/ToolCallingView.vue';
             threadId: sessionState.lastRequest?.threadId || null,
           };
 
-          if(request.reactAgent) {
+          if (request.reactAgent) {
             // threadId 不能为空，如果为空则默认一个uuid
             request.threadId = request.threadId || crypto.randomUUID();
           }
@@ -727,7 +735,6 @@ import ToolCallingView from '@/components/run/ToolCallingView.vue';
               }
             }
 
-
             // 使用generateNodeHtml方法生成HTML代码，确保显示与保存一致
             const nodeHtml = generateNodeHtml(node);
 
@@ -833,10 +840,9 @@ import ToolCallingView from '@/components/run/ToolCallingView.vue';
                 };
                 sessionState.nodeBlocks.push([newBlock]);
                 currentBlockIndex = sessionState.nodeBlocks.length - 1;
-              }
-              else if (response.nodeName === 'ToolCallNode') {
+              } else if (response.nodeName === 'ToolCallNode') {
                 const isNewNode: boolean =
-                    currentNodeName === null || response.nodeName !== currentNodeName;
+                  currentNodeName === null || response.nodeName !== currentNodeName;
                 if (isNewNode) {
                   // 保存上一个节点的消息（如果有）
                   if (currentBlockIndex >= 0 && sessionState.nodeBlocks[currentBlockIndex]) {
@@ -847,16 +853,15 @@ import ToolCallingView from '@/components/run/ToolCallingView.vue';
                   const newBlock: GraphNodeResponse = {
                     ...response,
                     text: response.text,
-                    textType: TextType.TOOL_CALL_NODE
+                    textType: TextType.TOOL_CALL_NODE,
                   };
                   sessionState.nodeBlocks.push([newBlock]);
                   currentBlockIndex = sessionState.nodeBlocks.length - 1;
                   currentNodeName = response.nodeName;
-                }else {
+                } else {
                   // 保存当前节点的消息（在添加新元素之前保存）
                   if (currentBlockIndex >= 0 && sessionState.nodeBlocks[currentBlockIndex]) {
                     const currentNodeCopy = [...sessionState.nodeBlocks[currentBlockIndex]];
-                    console.log('the save node is : ', currentNodeCopy);
                     const savePromise = saveNodeMessage(currentNodeCopy);
                     pendingSavePromises.push(savePromise);
                   }
@@ -864,14 +869,13 @@ import ToolCallingView from '@/components/run/ToolCallingView.vue';
                   const newBlock: GraphNodeResponse = {
                     ...response,
                     text: response.text,
-                    textType: TextType.TOOL_CALL_NODE
+                    textType: TextType.TOOL_CALL_NODE,
                   };
                   sessionState.nodeBlocks.push([newBlock]);
                   currentBlockIndex = sessionState.nodeBlocks.length - 1;
                   currentNodeName = response.nodeName;
                 }
-              }
-              else {
+              } else {
                 // 处理其他节点（同步处理逻辑）
                 const isNewNode: boolean =
                   currentNodeName === null || response.nodeName !== currentNodeName;
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java
index e1d14307b..3aa62a6ab 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/controller/GraphController.java
@@ -53,8 +53,7 @@ public Flux<ServerSentEvent<GraphNodeResponse>> streamSearch(@RequestParam("agen
 			@RequestParam(value = "humanFeedbackContent", required = false) String humanFeedbackContent,
 			@RequestParam(value = "rejectedPlan", required = false) boolean rejectedPlan,
 			@RequestParam(value = "nl2sqlOnly", required = false) boolean nl2sqlOnly,
-			@RequestParam(value = "reactAgent", required = false) boolean reactAgent,
-			HttpServletResponse response) {
+			@RequestParam(value = "reactAgent", required = false) boolean reactAgent, HttpServletResponse response) {
 		// Set SSE-related HTTP headers
 		response.setCharacterEncoding("UTF-8");
 		response.setContentType("text/event-stream");
@@ -74,10 +73,11 @@ public Flux<ServerSentEvent<GraphNodeResponse>> streamSearch(@RequestParam("agen
 			.rejectedPlan(rejectedPlan)
 			.nl2sqlOnly(nl2sqlOnly)
 			.build();
-		if(reactAgent) {
+		if (reactAgent) {
 			//
 			reactAgentService.reactStreamProcess(sink, request);
-		}else {
+		}
+		else {
 			graphService.graphStreamProcess(sink, request);
 		}
 
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java
index d67e6fbd5..fcd7a8e37 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/dto/tool/ToolCallDTO.java
@@ -1,6 +1,20 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package com.alibaba.cloud.ai.dataagent.dto.tool;
 
-
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -9,7 +23,11 @@
 @AllArgsConstructor
 @NoArgsConstructor
 public class ToolCallDTO {
-  private String toolName;
-  private String input;
-  private String output;
+
+	private String toolName;
+
+	private String input;
+
+	private String output;
+
 }
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
index 89f301cf1..1dcbee102 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
@@ -28,45 +28,48 @@
 @Component
 public class ToolsInterceptor extends ToolInterceptor {
 
-  public interface ToolCallCallback {
+	public interface ToolCallCallback {
 
-    void onToolCall(String threadId, String toolName, String input, String output);
-  }
+		void onToolCall(String threadId, String toolName, String input, String output);
 
-  private final List<ToolCallCallback> callbacks = new ArrayList<>();
+	}
 
-  @Override
-  public ToolCallResponse interceptToolCall(ToolCallRequest request, ToolCallHandler handler) {
-    log.debug("ToolInterceptor: Tool {} is called!", request.getToolName());
-    String threadId = request.getContext().get("thread_id").toString();
-    String inputs = request.getArguments();
-    // 调用所有回调
-    log.debug(" the tool callback start, size: {}", callbacks.size());
-    ToolCallResponse response = handler.call(request);
-    String output = response.getResult();
-    // 调用所有回调
-    for (ToolCallCallback callback : callbacks) {
-      try {
-        callback.onToolCall(threadId, request.getToolName(), inputs, output);
-      } catch (Exception e) {
-        log.error("Error in tool call callback: {}", e.getMessage(), e);
-      }
-    }
-    return response;
-  }
 
-  @Override
-  public String getName() {
-    return "LogToolInterceptor";
-  }
+	private final List<ToolCallCallback> callbacks = new ArrayList<>();
 
-  public void addToolCallCallback(ToolCallCallback callback) {
-    log.info("add tool call callback: {}", callback);
-    callbacks.add(callback);
-  }
+	@Override
+	public ToolCallResponse interceptToolCall(ToolCallRequest request, ToolCallHandler handler) {
+		log.debug("ToolInterceptor: Tool {} is called!", request.getToolName());
+		String threadId = request.getContext().get("thread_id").toString();
+		String inputs = request.getArguments();
+		// 调用所有回调
+		log.debug(" the tool callback start, size: {}", callbacks.size());
+		ToolCallResponse response = handler.call(request);
+		String output = response.getResult();
+		// 调用所有回调
+		for (ToolCallCallback callback : callbacks) {
+			try {
+				callback.onToolCall(threadId, request.getToolName(), inputs, output);
+			}
+			catch (Exception e) {
+				log.error("Error in tool call callback: {}", e.getMessage(), e);
+			}
+		}
+		return response;
+	}
 
-  public void removeToolCallCallback(ToolCallCallback callback) {
-    callbacks.remove(callback);
-  }
+	@Override
+	public String getName() {
+		return "LogToolInterceptor";
+	}
 
-}
\ No newline at end of file
+	public void addToolCallCallback(ToolCallCallback callback) {
+		log.debug("add tool call callback: {}", callback);
+		callbacks.add(callback);
+	}
+
+	public void removeToolCallCallback(ToolCallCallback callback) {
+		callbacks.remove(callback);
+	}
+
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java
index 8be65f900..a966ee756 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ReactAgentRegistry.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package com.alibaba.cloud.ai.dataagent.service.aimodelconfig;
 
 import com.alibaba.cloud.ai.dataagent.dto.ModelConfigDTO;
@@ -16,50 +31,51 @@
 @RequiredArgsConstructor
 public class ReactAgentRegistry {
 
-  private final DynamicModelFactory modelFactory;
+	private final DynamicModelFactory modelFactory;
 
-  private final ModelConfigDataService modelConfigDataService;
+	private final ModelConfigDataService modelConfigDataService;
 
+	private final ToolFactory toolFactory;
 
-  private final ToolFactory toolFactory;
+	private final ToolsInterceptor toolsInterceptor;
 
-  private final ToolsInterceptor toolsInterceptor;
+	private volatile ReactAgent reactAgent;
 
-  private volatile ReactAgent reactAgent;
+	// =========================================================
+	// 5. 构造ReactAgent
+	// =========================================================
+	public ReactAgent getReactAgent() {
+		if (reactAgent == null) {
+			synchronized (this) {
+				if (reactAgent == null) {
+					log.info("Initializing global ReactAgent...");
+					try {
+						ModelConfigDTO config = modelConfigDataService.getActiveConfigByType(ModelType.CHAT);
+						if (config != null) {
+							ChatModel chatModel = modelFactory.createChatModel(config);
+							// 核心：基于新 Model 创建新 Agent，彻底消除旧参数缓存
+							reactAgent = ReactAgent.builder()
+								.name("sql-agent")
+								.description(PromptHelper.buildDefaultDataAnalysisPrompt())
+								.model(chatModel)
+								.saver(new MemorySaver())
+								.tools(toolFactory.getTools())
+								.interceptors(toolsInterceptor)
+								.build();
+						}
+					}
+					catch (Exception e) {
+						log.error("Failed to initialize ReactAgent: {}", e.getMessage(), e);
+					}
+					// 兜底：如果还没初始化成功，抛出运行时异常，提示用户配置
+					if (reactAgent == null) {
+						throw new RuntimeException(
+								"No active CHAT model configured. Please configure it in the dashboard.");
+					}
+				}
+			}
+		}
+		return reactAgent;
+	}
 
-  // =========================================================
-  // 5. 构造ReactAgent
-  // =========================================================
-  public ReactAgent getReactAgent() {
-    if (reactAgent == null) {
-      synchronized (this) {
-        if (reactAgent == null) {
-          log.info("Initializing global ReactAgent...");
-          try {
-            ModelConfigDTO config = modelConfigDataService.getActiveConfigByType(ModelType.CHAT);
-            if (config != null) {
-              ChatModel chatModel = modelFactory.createChatModel(config);
-              // 核心：基于新 Model 创建新 Agent，彻底消除旧参数缓存
-              reactAgent = ReactAgent.builder()
-                  .name("sql-agent")
-                  .description(PromptHelper.buildDefaultDataAnalysisPrompt())
-                  .model(chatModel)
-                  .saver(new MemorySaver())
-                  .tools(toolFactory.getTools())
-                  .interceptors(toolsInterceptor)
-                  .build();
-            }
-          } catch (Exception e) {
-            log.error("Failed to initialize ReactAgent: {}", e.getMessage(), e);
-          }
-          // 兜底：如果还没初始化成功，抛出运行时异常，提示用户配置
-          if (reactAgent == null) {
-            throw new RuntimeException(
-                "No active CHAT model configured. Please configure it in the dashboard.");
-          }
-        }
-      }
-    }
-    return reactAgent;
-  }
 }
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java
index 837944886..f978389be 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/aimodelconfig/ToolFactory.java
@@ -31,24 +31,25 @@
 @Component
 public class ToolFactory {
 
-  private final SequentialThinkingTool sequentialThinkingTool;
+	private final SequentialThinkingTool sequentialThinkingTool;
 
-  private final TodoWriteTool todoWriteTool;
+	private final TodoWriteTool todoWriteTool;
 
-  private final ListTableSchemaTool listTablesTool;
+	private final ListTableSchemaTool listTablesTool;
 
-  private final SqlExecuteTool sqlExecuteTool;
+	private final SqlExecuteTool sqlExecuteTool;
 
-  private List<ToolCallback> tools = new ArrayList<>();
+	private List<ToolCallback> tools = new ArrayList<>();
+
+	public List<ToolCallback> getTools() {
+		if (tools == null || tools.isEmpty()) {
+			// TODO 这里应该根据UI上的配置来觉得用哪些工具
+			tools.add(todoWriteTool.toolCallback());
+			tools.add(sequentialThinkingTool.toolCallback());
+			tools.add(listTablesTool.toolCallback());
+			tools.add(sqlExecuteTool.toolCallback());
+		}
+		return tools;
+	}
 
-  public List<ToolCallback> getTools() {
-    if (tools == null || tools.isEmpty()) {
-      // TODO 这里应该根据UI上的配置来觉得用哪些工具
-      tools.add(todoWriteTool.toolCallback());
-      tools.add(sequentialThinkingTool.toolCallback());
-      tools.add(listTablesTool.toolCallback());
-      tools.add(sqlExecuteTool.toolCallback());
-    }
-    return tools;
-  }
 }
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java
index 1ce9037a9..b90f74a33 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentService.java
@@ -22,8 +22,8 @@
 
 public interface ReactAgentService {
 
-  void reactStreamProcess(Sinks.Many<ServerSentEvent<GraphNodeResponse>> sink, GraphRequest request);
+	void reactStreamProcess(Sinks.Many<ServerSentEvent<GraphNodeResponse>> sink, GraphRequest request);
 
-  void stopStreamProcessing(String threadId);
+	void stopStreamProcessing(String threadId);
 
-}
\ No newline at end of file
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
index b79035a1f..96a5898af 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
@@ -23,7 +23,6 @@
 import com.alibaba.cloud.ai.dataagent.enums.TextType;
 import com.alibaba.cloud.ai.dataagent.interceptor.ToolsInterceptor;
 import com.alibaba.cloud.ai.dataagent.interceptor.ToolsInterceptor.ToolCallCallback;
-import com.alibaba.cloud.ai.dataagent.service.aimodelconfig.AiModelRegistry;
 import com.alibaba.cloud.ai.dataagent.service.aimodelconfig.ReactAgentRegistry;
 import com.alibaba.cloud.ai.dataagent.service.graph.Context.MultiTurnContextManager;
 import com.alibaba.cloud.ai.dataagent.service.graph.Context.StreamContext;
@@ -35,7 +34,6 @@
 import com.alibaba.cloud.ai.graph.exception.GraphRunnerException;
 import com.alibaba.cloud.ai.graph.exception.GraphStateException;
 import com.alibaba.cloud.ai.graph.streaming.StreamingOutput;
-import com.fasterxml.jackson.core.JsonProcessingException;
 import java.util.Date;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
@@ -44,7 +42,6 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.codec.ServerSentEvent;
 import org.springframework.stereotype.Service;
-import org.springframework.util.StringUtils;
 import reactor.core.Disposable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Sinks;
@@ -53,261 +50,257 @@
 @Service
 public class ReactAgentServiceImpl implements ReactAgentService {
 
-  private final ReactAgentRegistry reactAgentRegistry;
-  private final Map<String, StreamContext> streamContextMap = new ConcurrentHashMap<>();
+	private final ReactAgentRegistry reactAgentRegistry;
 
-  private final ExecutorService executor;
+	private final Map<String, StreamContext> streamContextMap = new ConcurrentHashMap<>();
 
-  private final MultiTurnContextManager multiTurnContextManager;
+	private final ExecutorService executor;
 
-  private final ToolsInterceptor toolsInterceptor;
+	private final MultiTurnContextManager multiTurnContextManager;
 
-  public ReactAgentServiceImpl(ExecutorService executor,
-      ReactAgentRegistry reactAgentRegistry,
-      MultiTurnContextManager multiTurnContextManager,
-      ToolsInterceptor toolsInterceptor) throws GraphStateException {
-    this.executor = executor;
-    this.reactAgentRegistry = reactAgentRegistry;
-    this.multiTurnContextManager = multiTurnContextManager;
-    this.toolsInterceptor = toolsInterceptor;
+	private final ToolsInterceptor toolsInterceptor;
 
-    // 添加工具调用回调
-    this.toolsInterceptor.addToolCallCallback(new ToolCallCallback() {
-      @Override
-      public void onToolCall(String threadId, String toolName, String input, String output) {
-        ReactAgentServiceImpl.this.handleToolCall(threadId, toolName, input, output);
-      }
-    });
-  }
+	public ReactAgentServiceImpl(ExecutorService executor, ReactAgentRegistry reactAgentRegistry,
+			MultiTurnContextManager multiTurnContextManager, ToolsInterceptor toolsInterceptor)
+			throws GraphStateException {
+		this.executor = executor;
+		this.reactAgentRegistry = reactAgentRegistry;
+		this.multiTurnContextManager = multiTurnContextManager;
+		this.toolsInterceptor = toolsInterceptor;
 
-  @Override
-  public void reactStreamProcess(Sinks.Many<ServerSentEvent<GraphNodeResponse>> sink,
-      GraphRequest request){
-    String threadId = request.getThreadId();
-    String agentId = request.getAgentId();
-    String query = request.getQuery();
+		// 添加工具调用回调
+		this.toolsInterceptor.addToolCallCallback(new ToolCallCallback() {
+			@Override
+			public void onToolCall(String threadId, String toolName, String input, String output) {
+				ReactAgentServiceImpl.this.handleToolCall(threadId, toolName, input, output);
+			}
 
-    ReactAgent reactAgent = reactAgentRegistry.getReactAgent();
-    RunnableConfig config = RunnableConfig.builder().threadId(threadId)
-        .addMetadata("thread_id", threadId)
-        .addMetadata("agent_id", agentId)
-        .addMetadata("current_time", new Date().toString())
-        .build();
-    // 创建并存储 StreamContext
-    StreamContext context = streamContextMap.computeIfAbsent(threadId, k -> new StreamContext());
-    context.setSink(sink);
-    // 过滤掉开始和结束事件
-    Flux<?> nodeOutputFlux = null;
-    try {
-      nodeOutputFlux = reactAgent.stream(query, config)
-          .filter(nodeOutput -> !nodeOutput.isSTART() && !nodeOutput.isEND());
-    } catch (GraphRunnerException e) {
-      log.error("Error streaming node outputs for threadId: {}", threadId, e);
-      throw new RuntimeException(e);
-    }
-    subscribeToFlux(context, nodeOutputFlux, agentId, threadId);
-  }
+		});
+	}
 
-  @Override
-  public void stopStreamProcessing(String threadId) {
-    log.info("Stopping stream processing for threadId: {}", threadId);
-    StreamContext context = streamContextMap.remove(threadId);
-    if (context != null) {
-      context.cleanup();
-    }
-  }
+	@Override
+	public void reactStreamProcess(Sinks.Many<ServerSentEvent<GraphNodeResponse>> sink, GraphRequest request) {
+		String threadId = request.getThreadId();
+		String agentId = request.getAgentId();
+		String query = request.getQuery();
 
-  /**
-   * 订阅 Flux 并原子性地设置 Disposable 线程安全：使用 synchronized 确保 Disposable 设置的原子性
-   *
-   * @param context        流式处理上下文
-   * @param nodeOutputFlux 节点输出流
-   * @param agentId        代理ID
-   * @param threadId       线程ID
-   */
-  private void subscribeToFlux(StreamContext context, Flux<?> nodeOutputFlux, String agentId,
-      String threadId) {
-    CompletableFuture.runAsync(() -> {
-      // 在订阅之前检查上下文是否仍然有效
-      if (context.isCleaned()) {
-        log.debug("StreamContext cleaned before subscription for threadId: {}", threadId);
-        return;
-      }
-      Disposable disposable = nodeOutputFlux.subscribe(
-          output -> handleNodeOutput(output, agentId, threadId),
-          error -> handleStreamError(agentId, threadId, error),
-          () -> handleStreamComplete(agentId, threadId));
-      // 原子性地设置 Disposable，如果已经清理则立即释放
-      synchronized (context) {
-        if (context.isCleaned()) {
-          // 如果已经清理，立即释放刚创建的 Disposable
-          if (disposable != null && !disposable.isDisposed()) {
-            disposable.dispose();
-          }
-        } else {
-          // 只有在未清理的情况下才设置 Disposable
-          context.setDisposable(disposable);
-        }
-      }
-    }, executor);
-  }
+		ReactAgent reactAgent = reactAgentRegistry.getReactAgent();
+		RunnableConfig config = RunnableConfig.builder()
+			.threadId(threadId)
+			.addMetadata("thread_id", threadId)
+			.addMetadata("agent_id", agentId)
+			.addMetadata("current_time", new Date().toString())
+			.build();
+		// 创建并存储 StreamContext
+		StreamContext context = streamContextMap.computeIfAbsent(threadId, k -> new StreamContext());
+		context.setSink(sink);
+		// 过滤掉开始和结束事件
+		Flux<?> nodeOutputFlux = null;
+		try {
+			nodeOutputFlux = reactAgent.stream(query, config)
+				.filter(nodeOutput -> !nodeOutput.isSTART() && !nodeOutput.isEND());
+		}
+		catch (GraphRunnerException e) {
+			log.error("Error streaming node outputs for threadId: {}", threadId, e);
+			throw new RuntimeException(e);
+		}
+		subscribeToFlux(context, nodeOutputFlux, agentId, threadId);
+	}
 
-  /**
-   * 处理节点输出
-   */
-  private void handleNodeOutput(Object nodeOutput, String agentId, String threadId) {
-    StreamContext context = streamContextMap.get(threadId);
-    // 检查是否已经停止处理
-    if (context == null || context.getSink() == null) {
-      log.debug("Stream processing already stopped for threadId: {}, skipping output", threadId);
-      return;
-    }
-    if (nodeOutput instanceof StreamingOutput streamingOutput) {
-      handleStreamNodeOutput(threadId, agentId, streamingOutput);
-    }
-  }
+	@Override
+	public void stopStreamProcessing(String threadId) {
+		log.info("Stopping stream processing for threadId: {}", threadId);
+		StreamContext context = streamContextMap.remove(threadId);
+		if (context != null) {
+			context.cleanup();
+		}
+	}
 
-  /**
-   * 处理流式错误 线程安全：使用 remove 操作确保只有一个线程能获取到 context
-   */
-  private void handleStreamError(String agentId, String threadId, Throwable error) {
-    log.error("Error in stream processing for threadId: {}: ", threadId, error);
-    StreamContext context = streamContextMap.remove(threadId);
-    if (context != null && !context.isCleaned() && context.getSink() != null) {
-      // 检查 sink 是否还有订阅者
-      if (context.getSink().currentSubscriberCount() > 0) {
-        context.getSink()
-            .tryEmitNext(ServerSentEvent
-                .builder(GraphNodeResponse.error(agentId, threadId,
-                    "Error in stream processing: " + error.getMessage()))
-                .event(STREAM_EVENT_ERROR)
-                .build());
-        context.getSink().tryEmitComplete();
-      }
-      // 清理资源（cleanup 内部已经保证只执行一次）
-      context.cleanup();
-    }
-  }
+	/**
+	 * 订阅 Flux 并原子性地设置 Disposable 线程安全：使用 synchronized 确保 Disposable 设置的原子性
+	 * @param context 流式处理上下文
+	 * @param nodeOutputFlux 节点输出流
+	 * @param agentId 代理ID
+	 * @param threadId 线程ID
+	 */
+	private void subscribeToFlux(StreamContext context, Flux<?> nodeOutputFlux, String agentId, String threadId) {
+		CompletableFuture.runAsync(() -> {
+			// 在订阅之前检查上下文是否仍然有效
+			if (context.isCleaned()) {
+				log.debug("StreamContext cleaned before subscription for threadId: {}", threadId);
+				return;
+			}
+			Disposable disposable = nodeOutputFlux.subscribe(output -> handleNodeOutput(output, agentId, threadId),
+					error -> handleStreamError(agentId, threadId, error),
+					() -> handleStreamComplete(agentId, threadId));
+			// 原子性地设置 Disposable，如果已经清理则立即释放
+			synchronized (context) {
+				if (context.isCleaned()) {
+					// 如果已经清理，立即释放刚创建的 Disposable
+					if (disposable != null && !disposable.isDisposed()) {
+						disposable.dispose();
+					}
+				}
+				else {
+					// 只有在未清理的情况下才设置 Disposable
+					context.setDisposable(disposable);
+				}
+			}
+		}, executor);
+	}
 
-  /**
-   * 处理流式完成 线程安全：使用 remove 操作确保只有一个线程能获取到 context
-   */
-  private void handleStreamComplete(String agentId, String threadId) {
-    log.info("Stream processing completed successfully for threadId: {}", threadId);
-    StreamContext context = streamContextMap.remove(threadId);
-    if (context != null && !context.isCleaned() && context.getSink() != null) {
-      if (context.getSink().currentSubscriberCount() > 0) {
-        context.getSink()
-            .tryEmitNext(ServerSentEvent.builder(GraphNodeResponse.complete(agentId, threadId))
-                .event(STREAM_EVENT_COMPLETE)
-                .build());
-        context.getSink().tryEmitComplete();
-      }
-      context.cleanup();
-    }
-  }
+	/**
+	 * 处理节点输出
+	 */
+	private void handleNodeOutput(Object nodeOutput, String agentId, String threadId) {
+		StreamContext context = streamContextMap.get(threadId);
+		// 检查是否已经停止处理
+		if (context == null || context.getSink() == null) {
+			log.debug("Stream processing already stopped for threadId: {}, skipping output", threadId);
+			return;
+		}
+		if (nodeOutput instanceof StreamingOutput streamingOutput) {
+			handleStreamNodeOutput(threadId, agentId, streamingOutput);
+		}
+	}
 
+	/**
+	 * 处理流式错误 线程安全：使用 remove 操作确保只有一个线程能获取到 context
+	 */
+	private void handleStreamError(String agentId, String threadId, Throwable error) {
+		log.error("Error in stream processing for threadId: {}: ", threadId, error);
+		StreamContext context = streamContextMap.remove(threadId);
+		if (context != null && !context.isCleaned() && context.getSink() != null) {
+			// 检查 sink 是否还有订阅者
+			if (context.getSink().currentSubscriberCount() > 0) {
+				context.getSink()
+					.tryEmitNext(ServerSentEvent
+						.builder(GraphNodeResponse.error(agentId, threadId,
+								"Error in stream processing: " + error.getMessage()))
+						.event(STREAM_EVENT_ERROR)
+						.build());
+				context.getSink().tryEmitComplete();
+			}
+			// 清理资源（cleanup 内部已经保证只执行一次）
+			context.cleanup();
+		}
+	}
 
-  private void handleStreamNodeOutput(String threadId, String agentId, StreamingOutput output) {
-    StreamContext context = streamContextMap.get(threadId);
-    // 检查是否已经停止处理
-    if (context == null || context.getSink() == null) {
-      log.debug("Stream processing already stopped for threadId: {}, skipping output", threadId);
-      return;
-    }
-    String node = output.node();
-    String chunk = output.chunk();
+	/**
+	 * 处理流式完成 线程安全：使用 remove 操作确保只有一个线程能获取到 context
+	 */
+	private void handleStreamComplete(String agentId, String threadId) {
+		log.info("Stream processing completed successfully for threadId: {}", threadId);
+		StreamContext context = streamContextMap.remove(threadId);
+		if (context != null && !context.isCleaned() && context.getSink() != null) {
+			if (context.getSink().currentSubscriberCount() > 0) {
+				context.getSink()
+					.tryEmitNext(ServerSentEvent.builder(GraphNodeResponse.complete(agentId, threadId))
+						.event(STREAM_EVENT_COMPLETE)
+						.build());
+				context.getSink().tryEmitComplete();
+			}
+			context.cleanup();
+		}
+	}
 
-    if(RunnableConfig.AGENT_MODEL_NAME.equals(node)) {
-      log.debug("handleToolCall: threadId={}, toolName={}, input={}", threadId, node, chunk);
-      log.info("------- {}", output.message().getText());
-    }
-    log.debug("Received Stream output: node={}, chunk={}", node, chunk);
+	private void handleStreamNodeOutput(String threadId, String agentId, StreamingOutput output) {
+		StreamContext context = streamContextMap.get(threadId);
+		// 检查是否已经停止处理
+		if (context == null || context.getSink() == null) {
+			log.debug("Stream processing already stopped for threadId: {}, skipping output", threadId);
+			return;
+		}
+		String node = output.node();
+		String chunk = output.chunk();
 
-    if (chunk == null || chunk.isEmpty()) {
-      return;
-    }
+		if (RunnableConfig.AGENT_MODEL_NAME.equals(node)) {
+			// 最终的结果使用reportnode进行展示即可
+			node = "ReportGeneratorNode";
+		}
+		log.debug("Received Stream output: node={}, chunk={}", node, chunk);
 
-    // 如果是文本标记符号，则更新文本类型
-    TextType originType = context.getTextType();
-    TextType textType;
-    boolean isTypeSign = false;
-    if (originType == null) {
-      textType = TextType.getTypeByStratSign(chunk);
-      if (textType != TextType.TEXT) {
-        isTypeSign = true;
-      }
-      context.setTextType(textType);
-    } else {
-      textType = TextType.getType(originType, chunk);
-      if (textType != originType) {
-        isTypeSign = true;
-      }
-      context.setTextType(textType);
-    }
-    // 文本标记符号不返回给前端
-    if (!isTypeSign) {
-      if (PlannerNode.class.getSimpleName().equals(node)) {
-        multiTurnContextManager.appendPlannerChunk(threadId, chunk);
-      }
-      GraphNodeResponse response = GraphNodeResponse.builder()
-          .agentId(agentId)
-          .threadId(threadId)
-          .nodeName(node)
-          .text(chunk)
-          .textType(textType)
-          .build();
-      // 检查发送是否成功，如果失败说明客户端已断开
-      Sinks.EmitResult result = context.getSink()
-          .tryEmitNext(ServerSentEvent.builder(response).build());
-      if (result.isFailure()) {
-        log.warn(
-            "Failed to emit data to sink for threadId: {}, result: {}. Stopping stream processing.",
-            threadId, result);
-        // 如果发送失败，停止处理
-        stopStreamProcessing(threadId);
-      }
-    }
-  }
+		if (chunk == null || chunk.isEmpty()) {
+			return;
+		}
 
-  /**
-   * 处理工具调用，将工具调用的输入和输出写出到流中
-   */
-  private void handleToolCall(String threadId, String toolName, String input, String output) {
-    log.debug("handleToolCall: threadId={}, toolName={}, input={}, output={}", threadId, toolName, input, output);
-    StreamContext context = streamContextMap.get(threadId);
-    // 检查是否已经停止处理
-    if (context == null || context.getSink() == null) {
-      log.debug("Stream processing already stopped for threadId: {}, skipping tool call output", threadId);
-      return;
-    }
+		// 如果是文本标记符号，则更新文本类型
+		TextType originType = context.getTextType();
+		TextType textType;
+		boolean isTypeSign = false;
+		if (originType == null) {
+			textType = TextType.getTypeByStratSign(chunk);
+			if (textType != TextType.TEXT) {
+				isTypeSign = true;
+			}
+			context.setTextType(textType);
+		}
+		else {
+			textType = TextType.getType(originType, chunk);
+			if (textType != originType) {
+				isTypeSign = true;
+			}
+			context.setTextType(textType);
+		}
+		// 文本标记符号不返回给前端
+		if (!isTypeSign) {
+			if (PlannerNode.class.getSimpleName().equals(node)) {
+				multiTurnContextManager.appendPlannerChunk(threadId, chunk);
+			}
+			GraphNodeResponse response = GraphNodeResponse.builder()
+				.agentId(agentId)
+				.threadId(threadId)
+				.nodeName(node)
+				.text(chunk)
+				.textType(TextType.MARK_DOWN)
+				.build();
+			// 检查发送是否成功，如果失败说明客户端已断开
+			Sinks.EmitResult result = context.getSink().tryEmitNext(ServerSentEvent.builder(response).build());
+			if (result.isFailure()) {
+				log.warn("Failed to emit data to sink for threadId: {}, result: {}. Stopping stream processing.",
+						threadId, result);
+				// 如果发送失败，停止处理
+				stopStreamProcessing(threadId);
+			}
+		}
+	}
 
-    try {
-      ToolCallDTO toolCallDTO = new ToolCallDTO(toolName, input, output);
-      // 创建 GraphNodeResponse
-      GraphNodeResponse response = GraphNodeResponse.builder()
-          .agentId(context.getAgentId())
-          .threadId(threadId)
-          .nodeName("ToolCallNode")
-          .text(JsonUtil.getObjectMapper().writeValueAsString(toolCallDTO))
-          .textType(TextType.JSON)
-          .build();
+	/**
+	 * 处理工具调用，将工具调用的输入和输出写出到流中
+	 */
+	private void handleToolCall(String threadId, String toolName, String input, String output) {
+		log.debug("handleToolCall: threadId={}, toolName={}, input={}, output={}", threadId, toolName, input, output);
+		StreamContext context = streamContextMap.get(threadId);
+		// 检查是否已经停止处理
+		if (context == null || context.getSink() == null) {
+			log.debug("Stream processing already stopped for threadId: {}, skipping tool call output", threadId);
+			return;
+		}
 
-      // 写出到流中
-      Sinks.EmitResult result = context.getSink()
-          .tryEmitNext(ServerSentEvent.builder(response).build());
+		try {
+			ToolCallDTO toolCallDTO = new ToolCallDTO(toolName, input, output);
+			// 创建 GraphNodeResponse
+			GraphNodeResponse response = GraphNodeResponse.builder()
+				.agentId(context.getAgentId())
+				.threadId(threadId)
+				.nodeName("ToolCallNode")
+				.text(JsonUtil.getObjectMapper().writeValueAsString(toolCallDTO))
+				.textType(TextType.JSON)
+				.build();
 
-      if (result.isFailure()) {
-        log.warn(
-            "Failed to emit tool call data to sink for threadId: {}, result: {}. Stopping stream processing.",
-            threadId, result);
-        // 如果发送失败，停止处理
-        stopStreamProcessing(threadId);
-      }
-    } catch (Exception e) {
-      log.error("Error processing tool call: {}", e.getMessage(), e);
-    }
-  }
+			// 写出到流中
+			Sinks.EmitResult result = context.getSink().tryEmitNext(ServerSentEvent.builder(response).build());
 
-
-}
\ No newline at end of file
+			if (result.isFailure()) {
+				log.warn(
+						"Failed to emit tool call data to sink for threadId: {}, result: {}. Stopping stream processing.",
+						threadId, result);
+				// 如果发送失败，停止处理
+				stopStreamProcessing(threadId);
+			}
+		}
+		catch (Exception e) {
+			log.error("Error processing tool call: {}", e.getMessage(), e);
+		}
+	}
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
index f150406f0..4454fff19 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
@@ -38,142 +38,141 @@
 @Component
 public class ListTableSchemaTool implements BiFunction<ListTableSchemaTool.Request, ToolContext, String> {
 
-  private final SchemaService schemaService;
+	private final SchemaService schemaService;
 
-  private final AgentDatasourceMapper agentDatasourceMapper;
+	private final AgentDatasourceMapper agentDatasourceMapper;
 
-  @Override
-  public String apply(Request request, ToolContext toolContext) {
-    log.info("========== List Table shema Tool Start ==========");
+	@Override
+	public String apply(Request request, ToolContext toolContext) {
+		log.info("========== List Table schema Tool Start ==========");
 
-    Long agentId = null;
-    if (toolContext.getContext().get("agent_id") != null) {
-      agentId = Long.parseLong((String) toolContext.getContext().get("agent_id"));
-    }
-    if (agentId == null) {
-      log.error("agent_id is null, please check the context");
-      return "Error listing table schemas: agent_id is null, please check the context.";
-    }
-    try {
-      // 查询 Agent 的激活数据源
-      Integer datasourceId = agentDatasourceMapper.selectActiveDatasourceIdByAgentId(agentId);
+		Long agentId = null;
+		if (toolContext.getContext().get("agent_id") != null) {
+			agentId = Long.parseLong((String) toolContext.getContext().get("agent_id"));
+		}
 
-      List<Document> tableDocuments = new ArrayList<>(
-          schemaService.getTableDocumentsByDatasource(datasourceId, request.query()));
-      // extract table names
-      List<String> recalledTableNames = extractTableName(tableDocuments);
-      List<Document> columnDocuments = schemaService.getColumnDocumentsByTableName(datasourceId,
-          recalledTableNames);
-      if (recalledTableNames.isEmpty()) {
-        log.info("No tables found in the database");
-        return "No tables found in the database.";
-      }
-      StringBuilder sb = new StringBuilder();
-      int index = 1;
-      for (String tableName : recalledTableNames) {
-        sb.append("## result").append(index).append(": \n");
-        sb.append(tableName).append("\n");
-        List<Document> columns = columnDocuments.stream()
-            .filter(p -> p.getMetadata().get(DocumentMetadataConstant.TABLE_NAME) != null
-                && p.getMetadata().get(DocumentMetadataConstant.TABLE_NAME).equals(tableName))
-            .toList();
-        if (!columns.isEmpty()) {
-          sb.append("  ---- Columns ----\n");
-        }
-        for (Document column : columns) {
-          String columnName = (String) column.getMetadata().get("name");
-          String columnComment = (String) column.getMetadata().get("description");
-          sb.append("      ").append(columnName);
-          if (StringUtils.hasText(columnComment)) {
-            sb.append("  comment: ").append(columnComment);
-          }
-          sb.append("\n");
-        }
-        index++;
-      }
-      log.info("Found {} tables: {}", recalledTableNames.size(), sb);
-      log.info("========== List Table schema Tool End ==========");
-      return sb.toString();
-    } catch (Exception e) {
-      log.error("Error listing tables", e);
-      return "Error listing tables: " + e.getMessage();
-    }
-  }
+		if (agentId == null) {
+			log.error("agent_id is null, please check the context");
+			return "Error listing table schemas: agent_id is null, please check the context.";
+		}
+		try {
+			// 查询 Agent 的激活数据源
+			Integer datasourceId = agentDatasourceMapper.selectActiveDatasourceIdByAgentId(agentId);
 
-  public ToolCallback toolCallback() {
-    return FunctionToolCallback.builder("list_table_schema", this)
-        .description(
-            """
-                # Semantic/vector search tool for retrieving relevant database table Schema from knowledge base based on business intent
-                This tool uses embeddings to understand the user's business-related query and find semantically relevant database table structure information, including table details and column specifications, to provide a foundation for subsequent SQL statement generation.
-                ## Purpose
-                Designed for retrieving database table Schema information aligned with user business needs, specifically to:
-                - Obtain table names and their Chinese names associated with the target business scenario
-                - Retrieve detailed column information including column names, data types, and Chinese names
-                - Provide accurate structural references to guide correct SQL statement drafting
-                - Identify all relevant tables and columns required to fulfill the user's data retrieval or analysis needs via SQL
-                The tool searches by business intent and data relevance rather than exact keyword matching, ensuring it captures all tables/columns related to the user's data request context.
-                ## What the Tool Does NOT Do
-                - Does NOT perform literal keyword-only matching without considering business contextual relevance
-                - Does NOT return actual business data records (only table and column structure metadata)
-                - Should NOT be used for conceptual explanations unrelated to database Schema
-                - Should NOT process queries that do not involve data retrieval or SQL generation requirements
-                - Does NOT generate SQL statements directly (only provides Schema information to support subsequent SQL creation)
-                ## Required Input Behavior
-                "query" must contain **well-formed semantic questions or intent statements** that clearly express the business data need and corresponding Schema retrieval requirement.
-                Each query should represent a **business data scenario, data analysis requirement, or specific data element need** that points to the database table structure needed, such as:
-                - Business process-related data scenarios (e.g., order creation, user payment)
-                - Specific data element tracking needs (e.g., user membership points, product inventory levels)
-                - Data analysis scope requirements (e.g., tables for monthly sales performance analysis)
-                - Contextual data association needs (e.g., tables linked to user delivery information)
-                Avoid:
-                - Isolated keyword lists without business context
-                - Raw unprocessed user messages that don't clarify Schema retrieval intent
-                - Full paragraphs of business logic description without explicit Schema focus
-                - Queries centered on business logic explanations rather than table structure needs
-                ## Examples of valid query shapes (not content):
-                - "Which tables store user order related data and their column structures?"
-                - "Retrieve Schema information of tables associated with user payment records"
-                - "What tables contain user delivery address fields, including column details?"
-                - "Get table structures for product inventory management scenarios"
-                - "Which tables are needed to analyze sales performance, along with their column specs?"
-                ## Parameters
-                - query (required): questions or intent statements.
-                  These should reflect the business data context and the specific Schema information you aim to retrieve.
-                ## Output
-                Returns chunks ranked by semantic relevance to the business intent, reranked when applicable.
-                Results contain structured database Schema information including:
-                - Table name
-                - Table Chinese name
-                - Column name
-                - Column data type
-                - Column Chinese name
-                The results are intended to provide clear, context-aligned structural references for subsequent SQL statement generation.
-                """)
-        .inputType(Request.class)
-        .build();
-  }
+			List<Document> tableDocuments = new ArrayList<>(
+					schemaService.getTableDocumentsByDatasource(datasourceId, request.query()));
+			// extract table names
+			List<String> recalledTableNames = extractTableName(tableDocuments);
+			List<Document> columnDocuments = schemaService.getColumnDocumentsByTableName(datasourceId,
+					recalledTableNames);
+			if (recalledTableNames.isEmpty()) {
+				log.info("No tables found in the database");
+				return "No tables found in the database.";
+			}
+			StringBuilder sb = new StringBuilder();
+			int index = 1;
+			for (String tableName : recalledTableNames) {
+				sb.append("## result").append(index).append(": \n");
+				sb.append(tableName).append("\n");
+				List<Document> columns = columnDocuments.stream()
+					.filter(p -> p.getMetadata().get(DocumentMetadataConstant.TABLE_NAME) != null
+							&& p.getMetadata().get(DocumentMetadataConstant.TABLE_NAME).equals(tableName))
+					.toList();
+				if (!columns.isEmpty()) {
+					sb.append("  ---- Columns ----\n");
+				}
+				for (Document column : columns) {
+					String columnName = (String) column.getMetadata().get("name");
+					String columnComment = (String) column.getMetadata().get("description");
+					sb.append("      ").append(columnName);
+					if (StringUtils.hasText(columnComment)) {
+						sb.append("  comment: ").append(columnComment);
+					}
+					sb.append("\n");
+				}
+				index++;
+			}
+			log.info("Found {} tables: {}", recalledTableNames.size(), sb);
+			log.info("========== List Table schema Tool End ==========");
+			return sb.toString();
+		}
+		catch (Exception e) {
+			log.error("Error listing tables", e);
+			return "Error listing tables: " + e.getMessage();
+		}
+	}
 
-  @JsonClassDescription("Request to list matched database tables and schema")
-  public record Request(
-      @JsonProperty(value = "query", required = true)
-      @JsonPropertyDescription("The search query to find relevant documentation. "
-          + "Be specific and include key terms related to your question.") String query) {
+	public ToolCallback toolCallback() {
+		return FunctionToolCallback.builder("list_table_schema", this)
+			.description(
+					"""
+							# Semantic/vector search tool for retrieving relevant database table Schema from knowledge base based on business intent
+							This tool uses embeddings to understand the user's business-related query and find semantically relevant database table structure information, including table details and column specifications, to provide a foundation for subsequent SQL statement generation.
+							## Purpose
+							Designed for retrieving database table Schema information aligned with user business needs, specifically to:
+							- Obtain table names and their Chinese names associated with the target business scenario
+							- Retrieve detailed column information including column names, data types, and Chinese names
+							- Provide accurate structural references to guide correct SQL statement drafting
+							- Identify all relevant tables and columns required to fulfill the user's data retrieval or analysis needs via SQL
+							The tool searches by business intent and data relevance rather than exact keyword matching, ensuring it captures all tables/columns related to the user's data request context.
+							## What the Tool Does NOT Do
+							- Does NOT perform literal keyword-only matching without considering business contextual relevance
+							- Does NOT return actual business data records (only table and column structure metadata)
+							- Should NOT be used for conceptual explanations unrelated to database Schema
+							- Should NOT process queries that do not involve data retrieval or SQL generation requirements
+							- Does NOT generate SQL statements directly (only provides Schema information to support subsequent SQL creation)
+							## Required Input Behavior
+							"query" must contain **well-formed semantic questions or intent statements** that clearly express the business data need and corresponding Schema retrieval requirement.
+							Each query should represent a **business data scenario, data analysis requirement, or specific data element need** that points to the database table structure needed, such as:
+							- Business process-related data scenarios (e.g., order creation, user payment)
+							- Specific data element tracking needs (e.g., user membership points, product inventory levels)
+							- Data analysis scope requirements (e.g., tables for monthly sales performance analysis)
+							- Contextual data association needs (e.g., tables linked to user delivery information)
+							Avoid:
+							- Isolated keyword lists without business context
+							- Raw unprocessed user messages that don't clarify Schema retrieval intent
+							- Full paragraphs of business logic description without explicit Schema focus
+							- Queries centered on business logic explanations rather than table structure needs
+							## Examples of valid query shapes (not content):
+							- "Which tables store user order related data and their column structures?"
+							- "Retrieve Schema information of tables associated with user payment records"
+							- "What tables contain user delivery address fields, including column details?"
+							- "Get table structures for product inventory management scenarios"
+							- "Which tables are needed to analyze sales performance, along with their column specs?"
+							## Parameters
+							- query (required): questions or intent statements.
+							  These should reflect the business data context and the specific Schema information you aim to retrieve.
+							## Output
+							Returns chunks ranked by semantic relevance to the business intent, reranked when applicable.
+							Results contain structured database Schema information including:
+							- Table name
+							- Table Chinese name
+							- Column name
+							- Column data type
+							- Column Chinese name
+							The results are intended to provide clear, context-aligned structural references for subsequent SQL statement generation.
+							""")
+			.inputType(Request.class)
+			.build();
+	}
 
-  }
+	@JsonClassDescription("Request to list matched database tables and schema")
+	public record Request(@JsonProperty(value = "query",
+			required = true) @JsonPropertyDescription("The search query to find relevant documentation. "
+					+ "Be specific and include key terms related to your question.") String query) {
 
-  private static List<String> extractTableName(List<Document> tableDocuments) {
-    List<String> tableNames = new ArrayList<>();
-    // metadata中的name字段
-    for (Document document : tableDocuments) {
-      String name = (String) document.getMetadata().get("name");
-      if (name != null && !name.isEmpty()) {
-        tableNames.add(name);
-      }
-    }
-    log.info("At this SchemaRecallNode, Recall tables are: {}", tableNames);
-    return tableNames;
+	}
 
-  }
-
-}
\ No newline at end of file
+	private static List<String> extractTableName(List<Document> tableDocuments) {
+		List<String> tableNames = new ArrayList<>();
+		// metadata中的name字段
+		for (Document document : tableDocuments) {
+			String name = (String) document.getMetadata().get("name");
+			if (name != null && !name.isEmpty()) {
+				tableNames.add(name);
+			}
+		}
+		log.info("At this SchemaRecallNode, Recall tables are: {}", tableNames);
+		return tableNames;
+	}
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
index 56f133133..2ab9e496a 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
@@ -33,208 +33,185 @@
 @Slf4j
 @AllArgsConstructor
 @Component
-public class SequentialThinkingTool implements
-    BiFunction<SequentialThinkingTool.Request, ToolContext, String> {
-
-  private final List<Request> thoughtHistory = new ArrayList<>();
-  private final Map<String, List<Request>> branches = new HashMap<>();
-
-  @Override
-  public String apply(Request request, ToolContext toolContext) {
-    log.info("========== Sequential Thinking Tool Start ==========");
-
-    try {
-      // Validate input
-      if (!validate(request)) {
-        return "Validation failed: Invalid input parameters";
-      }
-
-      // Adjust totalThoughts if thoughtNumber exceeds it
-      if (request.thoughtNumber() > request.totalThoughts()) {
-        request = new Request(
-            request.thought(),
-            request.nextThoughtNeeded(),
-            request.thoughtNumber(),
-            request.thoughtNumber(), // Update totalThoughts
-            request.isRevision(),
-            request.revisesThought(),
-            request.branchFromThought(),
-            request.branchId(),
-            request.needsMoreThoughts()
-        );
-      }
-
-      // Add to thought history
-      thoughtHistory.add(request);
-
-      // Handle branching
-      if (request.branchFromThought() != null && request.branchId() != null && !request.branchId()
-          .isEmpty()) {
-        branches.computeIfAbsent(request.branchId(), k -> new ArrayList<>()).add(request);
-      }
-
-      log.info("[Tool][SequentialThinking] Thought: {}", request.thought());
-
-      // Prepare response data
-      List<String> branchKeys = new ArrayList<>(branches.keySet());
-      boolean incomplete = request.nextThoughtNeeded() || (request.needsMoreThoughts()!=null && request.needsMoreThoughts()) ||
-          request.thoughtNumber() < request.totalThoughts();
-
-      Map<String, Object> responseData = new HashMap<>();
-      responseData.put("thought_number", request.thoughtNumber());
-      responseData.put("total_thoughts", request.totalThoughts());
-      responseData.put("next_thought_needed", request.nextThoughtNeeded());
-      responseData.put("branches", branchKeys);
-      responseData.put("thought_history_length", thoughtHistory.size());
-      responseData.put("display_type", "thinking");
-      responseData.put("thought", request.thought());
-      responseData.put("incomplete_steps", incomplete);
-
-      log.info(
-          "[Tool][SequentialThinking] Execute completed - Thought {}/{}",
-          request.thoughtNumber(),
-          request.totalThoughts()
-      );
-
-      String outputMsg = "Thought process recorded";
-      if (incomplete) {
-        outputMsg = "Thought process recorded - unfinished steps remain, continue exploring and calling tools";
-      }
-
-      log.info("========== Sequential Thinking Tool End ==========");
-      return outputMsg;
-    } catch (Exception e) {
-      log.error("Error in sequential thinking tool", e);
-      return "Error in sequential thinking tool: " + e.getMessage();
-    }
-  }
-
-  public ToolCallback toolCallback() {
-    return FunctionToolCallback.builder("sequential_thinking", this)
-        .description(
-            """
-                A detailed tool for dynamic and reflective problem-solving through thoughts.
-                This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
-                Each thought can build on, question, or revise previous insights as understanding deepens.
-                ## When to Use This Tool
-                - Breaking down complex problems into steps
-                - Planning and design with room for revision
-                - Analysis that might need course correction
-                - Problems where the full scope might not be clear initially
-                - Problems that require a multi-step solution
-                - Tasks that need to maintain context over multiple steps
-                - Situations where irrelevant information needs to be filtered out
-                ## Typical Application Scenarios
-                This tool is particularly useful for data analysis workflows involving:
-                - Understanding user business intent from natural language queries
-                - Identifying relevant database tables and columns for the business scenario
-                - Planning SQL query structure based on data requirements
-                - Analyzing query results and extracting meaningful insights
-                - Iterating on SQL statements when results don't meet expectations
-                - Combining multiple data sources to answer complex questions
-                - Validating data quality and completeness before drawing conclusions
-                - Explaining analytical findings in business-friendly language
-                ## Key Features
-                - You can adjust total_thoughts up or down as you progress
-                - You can question or revise previous thoughts
-                - You can add more thoughts even after reaching what seemed like the end
-                - You can express uncertainty and explore alternative approaches
-                - Not every thought needs to build linearly - you can branch or backtrack
-                - Generates a solution hypothesis
-                - Verifies the hypothesis based on the Chain of Thought steps
-                - Repeats the process until satisfied
-                - Provides a correct answer
-                ## Parameters Explained
-                - **thought**: Your current thinking step, which can include:
-                  * Regular analytical steps
-                  * Revisions of previous thoughts
-                  * Questions about previous decisions
-                  * Realizations about needing more analysis
-                  * Changes in approach
-                  * Hypothesis generation
-                  * Hypothesis verification
-                  
-                  **CRITICAL - User-Friendly Thinking**: Write your thoughts in natural, user-friendly language. NEVER mention tool names (like "grep_chunks", "knowledge_search", "web_search", etc.) in your thinking process. Instead, describe your actions in plain language:
-                  - ❌ BAD: "I'll use list_table_schema to search for keywords, then sql_execute for semantic understanding"
-                  - ✅ GOOD: "I'll start by searching for key terms in the knowledge, then explore related concepts"
-                  - ❌ BAD: "After list_table_schema returns results, I'll use sql_execute"
-                  - ✅ GOOD: "After finding relevant documents, I'll search for semantically related content"
-                  
-                  Write thinking as if explaining your reasoning to a user, not documenting technical steps. Focus on WHAT you're trying to find and WHY, not HOW (which tools you'll use).
-                - **next_thought_needed**: True if you need more thinking, even if at what seemed like the end
-                - **thought_number**: Current number in sequence (can go beyond initial total if needed)
-                - **total_thoughts**: Current estimate of thoughts needed (can be adjusted up/down)
-                - **is_revision**: A boolean indicating if this thought revises previous thinking
-                - **revises_thought**: If is_revision is true, which thought number is being reconsidered
-                - **branch_from_thought**: If branching, which thought number is the branching point
-                - **branch_id**: Identifier for the current branch (if any)
-                - **needs_more_thoughts**: If reaching end but realizing more thoughts needed
-                """)
-        .inputType(Request.class)
-        .build();
-  }
-
-  @JsonClassDescription("Request for sequential thinking tool")
-  public record Request(
-      @JsonProperty(value = "thought", required = true)
-      @JsonPropertyDescription("Your current thinking step. Write in natural, user-friendly language. NEVER mention tool names (like \"list_table_schema\", \"sql_execute\", \"web_search\", etc.). Instead, describe actions in plain language (e.g., \"I'll search for key terms\" instead of \"I'll use list_table_schema\"). Focus on WHAT you're trying to find and WHY, not HOW (which tools you'll use).")
-      String thought,
-
-      @JsonProperty(value = "next_thought_needed", required = true)
-      @JsonPropertyDescription("Whether another thought step is needed")
-      boolean nextThoughtNeeded,
-
-      @JsonProperty(value = "thought_number", required = true)
-      @JsonPropertyDescription("Current thought number (numeric value, e.g., 1, 2, 3)")
-      int thoughtNumber,
-
-      @JsonProperty(value = "total_thoughts", required = true)
-      @JsonPropertyDescription("Estimated total thoughts needed (numeric value, e.g., 5, 10)")
-      int totalThoughts,
-
-      @JsonProperty(value = "is_revision")
-      @JsonPropertyDescription("Whether this revises previous thinking")
-      Boolean isRevision,
-
-      @JsonProperty(value = "revises_thought")
-      @JsonPropertyDescription("Which thought is being reconsidered")
-      Integer revisesThought,
-
-      @JsonProperty(value = "branch_from_thought")
-      @JsonPropertyDescription("Branching point thought number")
-      Integer branchFromThought,
-
-      @JsonProperty(value = "branch_id")
-      @JsonPropertyDescription("Branch identifier")
-      String branchId,
-
-      @JsonProperty(value = "needs_more_thoughts")
-      @JsonPropertyDescription("If more thoughts are needed")
-      Boolean needsMoreThoughts
-  ) {
-
-  }
-
-  private boolean validate(Request request) {
-    // Validate thought (required)
-    if (request.thought() == null || request.thought().isEmpty()) {
-      log.error("Invalid thought: must be a non-empty string");
-      return false;
-    }
-
-    // Validate thoughtNumber (required)
-    if (request.thoughtNumber() < 1) {
-      log.error("Invalid thoughtNumber: must be >= 1");
-      return false;
-    }
-
-    // Validate totalThoughts (required)
-    if (request.totalThoughts() < 1) {
-      log.error("Invalid totalThoughts: must be >= 1");
-      return false;
-    }
-
-    return true;
-  }
-
-}
\ No newline at end of file
+public class SequentialThinkingTool implements BiFunction<SequentialThinkingTool.Request, ToolContext, String> {
+
+	private final List<Request> thoughtHistory = new ArrayList<>();
+
+	private final Map<String, List<Request>> branches = new HashMap<>();
+
+	@Override
+	public String apply(Request request, ToolContext toolContext) {
+		log.info("========== Sequential Thinking Tool Start ==========");
+
+		try {
+			// Validate input
+			if (!validate(request)) {
+				return "Validation failed: Invalid input parameters";
+			}
+
+
+			// Adjust totalThoughts if thoughtNumber exceeds it
+			if (request.thoughtNumber() > request.totalThoughts()) {
+				request = new Request(request.thought(), request.nextThoughtNeeded(), request.thoughtNumber(),
+						request.thoughtNumber(), // Update totalThoughts
+						request.isRevision(), request.revisesThought(), request.branchFromThought(), request.branchId(),
+						request.needsMoreThoughts());
+			}
+
+			// Add to thought history
+			thoughtHistory.add(request);
+
+			// Handle branching
+			if (request.branchFromThought() != null && request.branchId() != null && !request.branchId().isEmpty()) {
+				branches.computeIfAbsent(request.branchId(), k -> new ArrayList<>()).add(request);
+			}
+
+			log.info("thinking Thought: {}", request.thought());
+
+			// Prepare response data
+			List<String> branchKeys = new ArrayList<>(branches.keySet());
+			boolean incomplete = request.nextThoughtNeeded()
+					|| (request.needsMoreThoughts() != null && request.needsMoreThoughts())
+					|| request.thoughtNumber() < request.totalThoughts();
+
+			Map<String, Object> responseData = new HashMap<>();
+			responseData.put("thought_number", request.thoughtNumber());
+			responseData.put("total_thoughts", request.totalThoughts());
+			responseData.put("next_thought_needed", request.nextThoughtNeeded());
+			responseData.put("branches", branchKeys);
+			responseData.put("thought_history_length", thoughtHistory.size());
+			responseData.put("display_type", "thinking");
+			responseData.put("thought", request.thought());
+			responseData.put("incomplete_steps", incomplete);
+
+			log.info("thinking Execute completed - Thought {}/{}", request.thoughtNumber(),
+					request.totalThoughts());
+
+			String outputMsg = "Thought process recorded";
+			if (incomplete) {
+				outputMsg = "Thought process recorded - unfinished steps remain, continue exploring and calling tools";
+			}
+
+			log.info("========== Sequential Thinking Tool End ==========");
+			return outputMsg;
+		}
+		catch (Exception e) {
+			log.error("Error in sequential thinking tool", e);
+			return "Error in sequential thinking tool: " + e.getMessage();
+		}
+	}
+
+	public ToolCallback toolCallback() {
+		return FunctionToolCallback.builder("sequential_thinking", this)
+			.description(
+					"""
+							A detailed tool for dynamic and reflective problem-solving through thoughts.
+							This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
+							Each thought can build on, question, or revise previous insights as understanding deepens.
+							## When to Use This Tool
+							- Breaking down complex problems into steps
+							- Planning and design with room for revision
+							- Analysis that might need course correction
+							- Problems where the full scope might not be clear initially
+							- Problems that require a multi-step solution
+							- Tasks that need to maintain context over multiple steps
+							- Situations where irrelevant information needs to be filtered out
+							## Typical Application Scenarios
+							This tool is particularly useful for data analysis workflows involving:
+							- Understanding user business intent from natural language queries
+							- Identifying relevant database tables and columns for the business scenario
+							- Planning SQL query structure based on data requirements
+							- Analyzing query results and extracting meaningful insights
+							- Iterating on SQL statements when results don't meet expectations
+							- Combining multiple data sources to answer complex questions
+							- Validating data quality and completeness before drawing conclusions
+							- Explaining analytical findings in business-friendly language
+							## Key Features
+							- You can adjust total_thoughts up or down as you progress
+							- You can question or revise previous thoughts
+							- You can add more thoughts even after reaching what seemed like the end
+							- You can express uncertainty and explore alternative approaches
+							- Not every thought needs to build linearly - you can branch or backtrack
+							- Generates a solution hypothesis
+							- Verifies the hypothesis based on the Chain of Thought steps
+							- Repeats the process until satisfied
+							- Provides a correct answer
+							## Parameters Explained
+							- **thought**: Your current thinking step, which can include:
+							  * Regular analytical steps
+							  * Revisions of previous thoughts
+							  * Questions about previous decisions
+							  * Realizations about needing more analysis
+							  * Changes in approach
+							  * Hypothesis generation
+							  * Hypothesis verification
+
+							  **CRITICAL - User-Friendly Thinking**: Write your thoughts in natural, user-friendly language. NEVER mention tool names (like "grep_chunks", "knowledge_search", "web_search", etc.) in your thinking process. Instead, describe your actions in plain language:
+							  - ❌ BAD: "I'll use list_table_schema to search for keywords, then sql_execute for semantic understanding"
+							  - ✅ GOOD: "I'll start by searching for key terms in the knowledge, then explore related concepts"
+							  - ❌ BAD: "After list_table_schema returns results, I'll use sql_execute"
+							  - ✅ GOOD: "After finding relevant documents, I'll search for semantically related content"
+
+							  Write thinking as if explaining your reasoning to a user, not documenting technical steps. Focus on WHAT you're trying to find and WHY, not HOW (which tools you'll use).
+							- **next_thought_needed**: True if you need more thinking, even if at what seemed like the end
+							- **thought_number**: Current number in sequence (can go beyond initial total if needed)
+							- **total_thoughts**: Current estimate of thoughts needed (can be adjusted up/down)
+							- **is_revision**: A boolean indicating if this thought revises previous thinking
+							- **revises_thought**: If is_revision is true, which thought number is being reconsidered
+							- **branch_from_thought**: If branching, which thought number is the branching point
+							- **branch_id**: Identifier for the current branch (if any)
+							- **needs_more_thoughts**: If reaching end but realizing more thoughts needed
+							""")
+			.inputType(Request.class)
+			.build();
+	}
+
+	@JsonClassDescription("Request for sequential thinking tool")
+	public record Request(@JsonProperty(value = "thought",
+			required = true) @JsonPropertyDescription("Your current thinking step. Write in natural, user-friendly language. NEVER mention tool names (like \"list_table_schema\", \"sql_execute\", \"web_search\", etc.). Instead, describe actions in plain language (e.g., \"I'll search for key terms\" instead of \"I'll use list_table_schema\"). Focus on WHAT you're trying to find and WHY, not HOW (which tools you'll use).") String thought,
+
+			@JsonProperty(value = "next_thought_needed",
+					required = true) @JsonPropertyDescription("Whether another thought step is needed") boolean nextThoughtNeeded,
+
+			@JsonProperty(value = "thought_number",
+					required = true) @JsonPropertyDescription("Current thought number (numeric value, e.g., 1, 2, 3)") int thoughtNumber,
+
+			@JsonProperty(value = "total_thoughts",
+					required = true) @JsonPropertyDescription("Estimated total thoughts needed (numeric value, e.g., 5, 10)") int totalThoughts,
+
+			@JsonProperty(
+					value = "is_revision") @JsonPropertyDescription("Whether this revises previous thinking") Boolean isRevision,
+
+			@JsonProperty(
+					value = "revises_thought") @JsonPropertyDescription("Which thought is being reconsidered") Integer revisesThought,
+
+			@JsonProperty(
+					value = "branch_from_thought") @JsonPropertyDescription("Branching point thought number") Integer branchFromThought,
+
+			@JsonProperty(value = "branch_id") @JsonPropertyDescription("Branch identifier") String branchId,
+
+			@JsonProperty(
+					value = "needs_more_thoughts") @JsonPropertyDescription("If more thoughts are needed") Boolean needsMoreThoughts) {
+
+	}
+
+	private boolean validate(Request request) {
+		// Validate thought (required)
+		if (request.thought() == null || request.thought().isEmpty()) {
+			log.error("Invalid thought: must be a non-empty string");
+			return false;
+		}
+
+		// Validate thoughtNumber (required)
+		if (request.thoughtNumber() < 1) {
+			log.error("Invalid thoughtNumber: must be >= 1");
+			return false;
+		}
+		// Validate totalThoughts (required)
+		if (request.totalThoughts() < 1) {
+			log.error("Invalid totalThoughts: must be >= 1");
+			return false;
+		}
+		return true;
+	}
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
index 34be14039..0095e45ed 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
@@ -42,124 +42,120 @@
 @Component
 public class SqlExecuteTool implements BiFunction<SqlExecuteTool.Request, ToolContext, String> {
 
-  private final DatabaseUtil databaseUtil;
-
-  @Override
-  public String apply(Request request, ToolContext toolContext) {
-    log.info("========== SQL Execute Tool Start ==========");
-
-    try {
-      // 验证输入
-      Long agentId = null;
-      if(toolContext.getContext().get("agent_id")!=null) {
-        agentId = Long.parseLong((String) toolContext.getContext().get("agent_id"));
-      }
-      if(agentId ==null) {
-        log.error("agent_id is null, please check the context");
-        return "Error listing tables: agent_id is null, please check the context.";
-      }
-
-      if (request.sql() == null || request.sql().isEmpty()) {
-        return "SQL statement is required";
-      }
-
-      // 获取数据库配置
-      DbConfigBO dbConfig = databaseUtil.getAgentDbConfig(agentId);
-      if (dbConfig == null) {
-        return "Database configuration not found for agent ID: " + agentId;
-      }
-
-      // 创建查询参数
-      DbQueryParameter dbQueryParameter = new DbQueryParameter();
-      dbQueryParameter.setSql(request.sql());
-      dbQueryParameter.setSchema(dbConfig.getSchema());
-
-      // 获取数据库访问器
-      Accessor dbAccessor = databaseUtil.getAgentAccessor(agentId);
-      if (dbAccessor == null) {
-        return "Database accessor not found for agent ID: " + agentId;
-      }
-
-      // 执行SQL查询
-      ResultSetBO resultSetBO = dbAccessor.executeSqlAndReturnObject(dbConfig, dbQueryParameter);
-
-      // 生成执行结果
-      String result = generateExecutionResult(request.sql(), resultSetBO);
-
-      log.info("========== SQL Execute Tool End ==========");
-      return result;
-    } catch (Exception e) {
-      log.error("Error executing SQL: {}", e.getMessage(), e);
-      return "Error executing SQL: " + e.getMessage();
-    }
-  }
-
-  /**
-   * 生成SQL执行结果
-   */
-  private String generateExecutionResult(String sql, ResultSetBO resultSetBO) throws Exception {
-    StringBuilder result = new StringBuilder();
-
-    result.append("# SQL执行结果\n\n");
-    result.append("## 执行的SQL\n");
-    result.append("```sql\n").append(sql).append("\n```\n\n");
-
-    if (resultSetBO != null) {
-      result.append("## 执行结果\n");
-      result.append("- 行数: ")
-          .append(resultSetBO.getData() != null ? resultSetBO.getData().size() : 0).append("\n\n");
-
-      if (resultSetBO.getData() != null && !resultSetBO.getData().isEmpty()) {
-        result.append("## 数据预览\n");
-        String resultJson = JsonUtil.getObjectMapper().writeValueAsString(resultSetBO.getData());
-        result.append("```json\n").append(resultJson).append("\n```\n");
-      }
-    } else {
-      result.append("## 执行结果\n");
-      result.append("- 无数据返回\n");
-    }
-
-    return result.toString();
-  }
-
-  /**
-   * SQL执行工具请求参数
-   */
-  public record Request(
-      @JsonProperty(value = "sql", required = true)
-      @JsonPropertyDescription("SQL statement to execute")
-      String sql
-  ) {
-
-  }
-
-  /**
-   * 获取工具回调
-   */
-  public ToolCallback toolCallback() {
-    return FunctionToolCallback.builder("execute_sql", this)
-        .description(
-            """
-                # SQL执行工具
-                用于执行SQL查询并返回结果。
-                ## 何时使用
-                - 当需要执行SQL查询以获取数据时
-                - 当需要验证SQL语句的正确性时
-                - 当需要获取数据库中的数据进行分析时
-                ## 输入参数
-                - `sql`: 要执行的SQL语句（必填）
-                - `agentId`: 代理ID，用于获取数据库配置（必填）
-                - `schema`: 数据库schema（可选）
-                ## 输出
-                - SQL执行结果，包括执行的SQL语句、列数、行数和数据预览
-                - 如果执行失败，返回错误信息
-                ## 注意事项
-                - 请确保SQL语句是有效的，否则会返回错误信息
-                - 请确保agentId是有效的，否则会返回错误信息
-                - 执行结果中的数据预览可能会被截断，仅用于参考
-                """)
-        .inputType(Request.class)
-        .build();
-  }
-
-}
\ No newline at end of file
+	private final DatabaseUtil databaseUtil;
+
+	@Override
+	public String apply(Request request, ToolContext toolContext) {
+		log.info("========== SQL Execute Tool Start ==========");
+
+		try {
+			// 验证输入
+			Long agentId = null;
+			if (toolContext.getContext().get("agent_id") != null) {
+				agentId = Long.parseLong((String) toolContext.getContext().get("agent_id"));
+			}
+
+			if (agentId == null) {
+				log.error("agent_id is null, please check the context");
+				return "Error listing tables: agent_id is null, please check the context.";
+			}
+
+			if (request.sql() == null || request.sql().isEmpty()) {
+				return "SQL statement is required";
+			}
+
+			// 获取数据库配置
+			DbConfigBO dbConfig = databaseUtil.getAgentDbConfig(agentId);
+			if (dbConfig == null) {
+				return "Database configuration not found for agent ID: " + agentId;
+			}
+
+			// 创建查询参数
+			DbQueryParameter dbQueryParameter = new DbQueryParameter();
+			dbQueryParameter.setSql(request.sql());
+			dbQueryParameter.setSchema(dbConfig.getSchema());
+
+			// 获取数据库访问器
+			Accessor dbAccessor = databaseUtil.getAgentAccessor(agentId);
+			if (dbAccessor == null) {
+				return "Database accessor not found for agent ID: " + agentId;
+			}
+
+			// 执行SQL查询
+			ResultSetBO resultSetBO = dbAccessor.executeSqlAndReturnObject(dbConfig, dbQueryParameter);
+
+			// 生成执行结果
+			String result = generateExecutionResult(request.sql(), resultSetBO);
+
+			log.info("========== SQL Execute Tool End ==========");
+			return result;
+		}
+		catch (Exception e) {
+			log.error("Error executing SQL: {}", e.getMessage(), e);
+			return "Error executing SQL: " + e.getMessage();
+		}
+	}
+
+	/**
+	 * 生成SQL执行结果
+	 */
+	private String generateExecutionResult(String sql, ResultSetBO resultSetBO) throws Exception {
+		StringBuilder result = new StringBuilder();
+
+		result.append("# SQL执行结果\n\n");
+		result.append("## 执行的SQL\n");
+		result.append("```sql\n").append(sql).append("\n```\n\n");
+
+		if (resultSetBO != null) {
+			result.append("## 执行结果\n");
+			result.append("- 行数: ")
+				.append(resultSetBO.getData() != null ? resultSetBO.getData().size() : 0)
+				.append("\n\n");
+
+			if (resultSetBO.getData() != null && !resultSetBO.getData().isEmpty()) {
+				result.append("## 数据预览\n");
+				String resultJson = JsonUtil.getObjectMapper().writeValueAsString(resultSetBO.getData());
+				result.append("```json\n").append(resultJson).append("\n```\n");
+			}
+		}
+		else {
+			result.append("## 执行结果\n");
+			result.append("- 无数据返回\n");
+		}
+
+		return result.toString();
+	}
+
+	/**
+	 * SQL执行工具请求参数
+	 */
+	public record Request(@JsonProperty(value = "sql",
+			required = true) @JsonPropertyDescription("SQL statement to execute") String sql) {
+
+	}
+
+	/**
+	 * 获取工具回调
+	 */
+	public ToolCallback toolCallback() {
+		return FunctionToolCallback.builder("execute_sql", this).description("""
+				# SQL执行工具
+				用于执行SQL查询并返回结果。
+				## 何时使用
+				- 当需要执行SQL查询以获取数据时
+				- 当需要验证SQL语句的正确性时
+				- 当需要获取数据库中的数据进行分析时
+				## 输入参数
+				- `sql`: 要执行的SQL语句（必填）
+				- `agentId`: 代理ID，用于获取数据库配置（必填）
+				- `schema`: 数据库schema（可选）
+				## 输出
+				- SQL执行结果，包括执行的SQL语句、列数、行数和数据预览
+				- 如果执行失败，返回错误信息
+				## 注意事项
+				- 请确保SQL语句是有效的，否则会返回错误信息
+				- 请确保agentId是有效的，否则会返回错误信息
+				- 执行结果中的数据预览可能会被截断，仅用于参考
+				""").inputType(Request.class).build();
+	}
+}
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
index 53bbdb9ce..922d5cf88 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
@@ -32,213 +32,204 @@
 @Component
 public class TodoWriteTool implements BiFunction<TodoWriteTool.Request, ToolContext, String> {
 
-  @Override
-  public String apply(Request request, ToolContext toolContext) {
-    log.info("========== Todo Write Tool Start ==========");
-
-    try {
-      // Validate input
-      if (request.task() == null || request.task().isEmpty()) {
-        return "Task description is required";
-      }
-
-      if (request.steps() == null || request.steps().isEmpty()) {
-        return generateEmptyPlanOutput(request.task());
-      }
-
-      // Generate formatted output
-      String output = generatePlanOutput(request.task(), request.steps());
-
-      log.info("========== Todo Write Tool End ==========");
-      return output;
-    } catch (Exception e) {
-      log.error("Error in todo write tool", e);
-      return "Error in todo write tool: " + e.getMessage();
-    }
-  }
-
-  public ToolCallback toolCallback() {
-    return FunctionToolCallback.builder("todo_write", this)
-        .description(
-            """
-                Use this tool to create and manage a structured task list for retrieval and research tasks. This helps you track progress, organize complex retrieval operations, and demonstrate thoroughness to user.
-                **CRITICAL - Focus on Retrieval Tasks Only**:
-                - This tool is for tracking RETRIEVAL and RESEARCH tasks (e.g., searching knowledge bases, retrieving documents, gathering information)
-                - DO NOT include summary or synthesis tasks in todo_write - those are handled by thinking tool
-                - Examples of appropriate tasks: "Search for X in knowledge base", "Retrieve information about Y", "Compare A and B"
-                - Examples of tasks to EXCLUDE: "Summarize findings", "Generate final answer", "Synthesize results" - these are for thinking tool
-                ## When to Use This Tool
-                Use this tool proactively in these scenarios:
-                1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-                2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-                3. User explicitly requests todo list - When user directly asks you to use todo list
-                4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-                5. After receiving new instructions - Immediately capture user requirements as todos
-                6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
-                7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
-                ## When NOT to Use This Tool
-                Skip using this tool when:
-                1. There is only a single, straightforward task
-                2. The task is trivial and tracking it provides no organizational benefit
-                3. The task is purely conversational or informational
-                NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing task directly.
-                ## Task States and Management
-                1. **Task States**: Use these states to track progress:
-                  - pending: Task not yet started
-                  - in_progress: Currently working on (limit to ONE task at a time)
-                  - completed: Task finished successfully
-                2. **Task Management**:
-                  - Update task status in real-time as you work
-                  - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
-                  - Only have ONE task in_progress at any time
-                  - Complete current tasks before starting new ones
-                  - Remove tasks that are no longer relevant from list entirely
-                3. **Task Completion Requirements**:
-                  - ONLY mark a task as completed when you have FULLY accomplished it
-                  - If you encounter errors, blockers, or cannot finish, keep task as in_progress
-                  - When blocked, create a new task describing what needs to be resolved
-                  - Never mark a task as completed if:
-                    - Tests are failing
-                    - Implementation is partial
-                    - You encountered unresolved errors
-                    - You couldn't find necessary files or dependencies
-                4. **Task Breakdown**:
-                  - Create specific, actionable RETRIEVAL tasks
-                  - Break complex retrieval needs into smaller, manageable steps
-                  - Use clear, descriptive task names focused on what to retrieve or research
-                  - **DO NOT include summary/synthesis tasks** - those are handled separately by thinking tool
-                **Important**: After completing all retrieval tasks in todo_write, use thinking tool to synthesize findings and generate final answer. The todo_write tool tracks WHAT to retrieve, while thinking tool handles HOW to synthesize and present information.
-                When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all retrieval requirements successfully.
-                """)
-        .inputType(Request.class)
-        .build();
-  }
-
-  @JsonClassDescription("Request for todo write tool")
-  public record Request(
-      @JsonProperty(value = "task", required = true)
-      @JsonPropertyDescription("The complex task or question you need to create a plan for")
-      String task,
-
-      @JsonProperty(value = "steps", required = true)
-      @JsonPropertyDescription("Array of research plan steps with status tracking")
-      List<PlanStep> steps
-  ) {
-
-  }
-
-  @JsonClassDescription("Plan step for todo write tool")
-  public record PlanStep(
-      @JsonProperty(value = "id", required = true)
-      @JsonPropertyDescription("Unique identifier for this step (e.g., 'step1', 'step2')")
-      String id,
-
-      @JsonProperty(value = "description", required = true)
-      @JsonPropertyDescription("Clear description of what to investigate or accomplish in this step")
-      String description,
-
-      @JsonProperty(value = "status", required = true)
-      @JsonPropertyDescription("Current status: pending (not started), in_progress (executing), completed (finished)")
-      String status
-  ) {
-
-  }
-
-  private String generateEmptyPlanOutput(String task) {
-    StringBuilder output = new StringBuilder();
-    output.append("计划已创建\n\n");
-    output.append("**任务**: ").append(task).append("\n\n");
-    output.append("注意：未提供具体步骤。建议创建3-7个检索任务以系统化研究。\n\n");
-    output.append("建议的检索流程（专注于检索任务，不包含总结）：\n");
-    output.append("1. 使用 grep_chunks 搜索关键词定位相关文档\n");
-    output.append("2. 使用 knowledge_search 进行语义搜索获取相关内容\n");
-    output.append("3. 使用 list_knowledge_chunks 获取关键文档的完整内容\n");
-    output.append("4. 使用 web_search 获取补充信息（如需要）\n");
-    output.append("\n注意：总结和综合由 thinking 工具处理，不要在此处添加总结任务。\n");
-    return output.toString();
-  }
-
-  private String generatePlanOutput(String task, List<PlanStep> steps) {
-    StringBuilder output = new StringBuilder();
-    output.append("计划已创建\n\n");
-    output.append("**任务**: ").append(task).append("\n\n");
-    output.append("**计划步骤**:\n\n");
-
-    // Count task statuses
-    int pendingCount = 0;
-    int inProgressCount = 0;
-    int completedCount = 0;
-    for (PlanStep step : steps) {
-      switch (step.status()) {
-        case "pending":
-          pendingCount++;
-          break;
-        case "in_progress":
-          inProgressCount++;
-          break;
-        case "completed":
-          completedCount++;
-          break;
-      }
-    }
-    int totalCount = steps.size();
-    int remainingCount = pendingCount + inProgressCount;
-
-    // Display all steps in order
-    for (int i = 0; i < steps.size(); i++) {
-      output.append(formatPlanStep(i + 1, steps.get(i)));
-    }
-
-    // Add summary and emphasis on remaining tasks
-    output.append("\n=== 任务进度 ===\n");
-    output.append("总计: ").append(totalCount).append(" 个任务\n");
-    output.append("✅ 已完成: ").append(completedCount).append(" 个\n");
-    output.append("🔄 进行中: ").append(inProgressCount).append(" 个\n");
-    output.append("⏳ 待处理: ").append(pendingCount).append(" 个\n");
-
-    output.append("\n=== ⚠️ 重要提醒 ===\n");
-    if (remainingCount > 0) {
-      output.append("**还有 ").append(remainingCount).append(" 个任务未完成！**\n\n");
-      output.append("**必须完成所有任务后才能总结或得出结论。**\n\n");
-      output.append("下一步操作：\n");
-      if (inProgressCount > 0) {
-        output.append("- 继续完成当前进行中的任务\n");
-      }
-      if (pendingCount > 0) {
-        output.append("- 开始处理 ").append(pendingCount).append(" 个待处理任务\n");
-        output.append("- 按顺序完成每个任务，不要跳过\n");
-      }
-      output.append("- 完成每个任务后，更新 todo_write 标记为 completed\n");
-      output.append("- 只有在所有任务完成后，才能生成最终总结\n");
-    } else {
-      output.append("✅ **所有任务已完成！**\n\n");
-      output.append("现在可以：\n");
-      output.append("- 综合所有任务的发现\n");
-      output.append("- 生成完整的最终答案或报告\n");
-      output.append("- 确保所有方面都已充分研究\n");
-    }
-
-    return output.toString();
-  }
-
-  private String formatPlanStep(int index, PlanStep step) {
-    String statusEmoji;
-    switch (step.status()) {
-      case "pending":
-        statusEmoji = "⏳";
-        break;
-      case "in_progress":
-        statusEmoji = "🔄";
-        break;
-      case "completed":
-        statusEmoji = "✅";
-        break;
-      default:
-        statusEmoji = "⏳";
-    }
-
-    return String.format("  %d. %s [%s] %s\n", index, statusEmoji, step.status(),
-        step.description());
-  }
-
-}
\ No newline at end of file
+	@Override
+	public String apply(Request request, ToolContext toolContext) {
+		log.info("========== Todo Write Tool Start ==========");
+
+		try {
+			// Validate input
+			if (request.task() == null || request.task().isEmpty()) {
+				return "Task description is required";
+			}
+
+
+			if (request.steps() == null || request.steps().isEmpty()) {
+				return generateEmptyPlanOutput(request.task());
+			}
+
+			// Generate formatted output
+			String output = generatePlanOutput(request.task(), request.steps());
+
+			log.info("========== Todo Write Tool End ==========");
+			return output;
+		}
+		catch (Exception e) {
+			log.error("Error in todo write tool", e);
+			return "Error in todo write tool: " + e.getMessage();
+		}
+	}
+
+	public ToolCallback toolCallback() {
+		return FunctionToolCallback.builder("todo_write", this)
+			.description(
+					"""
+							Use this tool to create and manage a structured task list for retrieval and research tasks. This helps you track progress, organize complex retrieval operations, and demonstrate thoroughness to user.
+							**CRITICAL - Focus on Retrieval Tasks Only**:
+							- This tool is for tracking RETRIEVAL and RESEARCH tasks (e.g., searching knowledge bases, retrieving documents, gathering information)
+							- DO NOT include summary or synthesis tasks in todo_write - those are handled by thinking tool
+							- Examples of appropriate tasks: "Search for X in knowledge base", "Retrieve information about Y", "Compare A and B"
+							- Examples of tasks to EXCLUDE: "Summarize findings", "Generate final answer", "Synthesize results" - these are for thinking tool
+							## When to Use This Tool
+							Use this tool proactively in these scenarios:
+							1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
+							2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
+							3. User explicitly requests todo list - When user directly asks you to use todo list
+							4. User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
+							5. After receiving new instructions - Immediately capture user requirements as todos
+							6. When you start working on a task - Mark it as in_progress BEFORE beginning work. Ideally you should only have one todo as in_progress at a time
+							7. After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+							## When NOT to Use This Tool
+							Skip using this tool when:
+							1. There is only a single, straightforward task
+							2. The task is trivial and tracking it provides no organizational benefit
+							3. The task is purely conversational or informational
+							NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing task directly.
+							## Task States and Management
+							1. **Task States**: Use these states to track progress:
+							  - pending: Task not yet started
+							  - in_progress: Currently working on (limit to ONE task at a time)
+							  - completed: Task finished successfully
+							2. **Task Management**:
+							  - Update task status in real-time as you work
+							  - Mark tasks complete IMMEDIATELY after finishing (don't batch completions)
+							  - Only have ONE task in_progress at any time
+							  - Complete current tasks before starting new ones
+							  - Remove tasks that are no longer relevant from list entirely
+							3. **Task Completion Requirements**:
+							  - ONLY mark a task as completed when you have FULLY accomplished it
+							  - If you encounter errors, blockers, or cannot finish, keep task as in_progress
+							  - When blocked, create a new task describing what needs to be resolved
+							  - Never mark a task as completed if:
+							    - Tests are failing
+							    - Implementation is partial
+							    - You encountered unresolved errors
+							    - You couldn't find necessary files or dependencies
+							4. **Task Breakdown**:
+							  - Create specific, actionable RETRIEVAL tasks
+							  - Break complex retrieval needs into smaller, manageable steps
+							  - Use clear, descriptive task names focused on what to retrieve or research
+							  - **DO NOT include summary/synthesis tasks** - those are handled separately by thinking tool
+							**Important**: After completing all retrieval tasks in todo_write, use thinking tool to synthesize findings and generate final answer. The todo_write tool tracks WHAT to retrieve, while thinking tool handles HOW to synthesize and present information.
+							When in doubt, use this tool. Being proactive with task management demonstrates attentiveness and ensures you complete all retrieval requirements successfully.
+							""")
+			.inputType(Request.class)
+			.build();
+	}
+
+	@JsonClassDescription("Request for todo write tool")
+	public record Request(@JsonProperty(value = "task",
+			required = true) @JsonPropertyDescription("The complex task or question you need to create a plan for") String task,
+
+			@JsonProperty(value = "steps",
+					required = true) @JsonPropertyDescription("Array of research plan steps with status tracking") List<PlanStep> steps) {
+
+	}
+
+	@JsonClassDescription("Plan step for todo write tool")
+	public record PlanStep(@JsonProperty(value = "id",
+			required = true) @JsonPropertyDescription("Unique identifier for this step (e.g., 'step1', 'step2')") String id,
+
+			@JsonProperty(value = "description",
+					required = true) @JsonPropertyDescription("Clear description of what to investigate or accomplish in this step") String description,
+
+			@JsonProperty(value = "status",
+					required = true) @JsonPropertyDescription("Current status: pending (not started), in_progress (executing), completed (finished)") String status) {
+
+	}
+
+	private String generateEmptyPlanOutput(String task) {
+		StringBuilder output = new StringBuilder();
+		output.append("计划已创建\n\n");
+		output.append("**任务**: ").append(task).append("\n\n");
+		output.append("注意：未提供具体步骤。建议创建3-7个检索任务以系统化研究。\n\n");
+		output.append("建议的检索流程（专注于检索任务，不包含总结）：\n");
+		output.append("1. 使用 grep_chunks 搜索关键词定位相关文档\n");
+		output.append("2. 使用 knowledge_search 进行语义搜索获取相关内容\n");
+		output.append("3. 使用 list_knowledge_chunks 获取关键文档的完整内容\n");
+		output.append("4. 使用 web_search 获取补充信息（如需要）\n");
+		output.append("\n注意：总结和综合由 thinking 工具处理，不要在此处添加总结任务。\n");
+		return output.toString();
+	}
+
+	private String generatePlanOutput(String task, List<PlanStep> steps) {
+		StringBuilder output = new StringBuilder();
+		output.append("计划已创建\n\n");
+		output.append("**任务**: ").append(task).append("\n\n");
+		output.append("**计划步骤**:\n\n");
+
+		// Count task statuses
+		int pendingCount = 0;
+		int inProgressCount = 0;
+		int completedCount = 0;
+		for (PlanStep step : steps) {
+			switch (step.status()) {
+				case "pending":
+					pendingCount++;
+					break;
+				case "in_progress":
+					inProgressCount++;
+					break;
+				case "completed":
+					completedCount++;
+					break;
+			}
+		}
+		int totalCount = steps.size();
+		int remainingCount = pendingCount + inProgressCount;
+
+		// Display all steps in order
+		for (int i = 0; i < steps.size(); i++) {
+			output.append(formatPlanStep(i + 1, steps.get(i)));
+		}
+
+		// Add summary and emphasis on remaining tasks
+		output.append("\n=== 任务进度 ===\n");
+		output.append("总计: ").append(totalCount).append(" 个任务\n");
+		output.append("✅ 已完成: ").append(completedCount).append(" 个\n");
+		output.append("🔄 进行中: ").append(inProgressCount).append(" 个\n");
+		output.append("⏳ 待处理: ").append(pendingCount).append(" 个\n");
+
+		output.append("\n=== ⚠️ 重要提醒 ===\n");
+		if (remainingCount > 0) {
+			output.append("**还有 ").append(remainingCount).append(" 个任务未完成！**\n\n");
+			output.append("**必须完成所有任务后才能总结或得出结论。**\n\n");
+			output.append("下一步操作：\n");
+			if (inProgressCount > 0) {
+				output.append("- 继续完成当前进行中的任务\n");
+			}
+			if (pendingCount > 0) {
+				output.append("- 开始处理 ").append(pendingCount).append(" 个待处理任务\n");
+				output.append("- 按顺序完成每个任务，不要跳过\n");
+			}
+			output.append("- 完成每个任务后，更新 todo_write 标记为 completed\n");
+			output.append("- 只有在所有任务完成后，才能生成最终总结\n");
+		}
+		else {
+			output.append("✅ **所有任务已完成！**\n\n");
+			output.append("现在可以：\n");
+			output.append("- 综合所有任务的发现\n");
+			output.append("- 生成完整的最终答案或报告\n");
+			output.append("- 确保所有方面都已充分研究\n");
+		}
+
+		return output.toString();
+	}
+
+	private String formatPlanStep(int index, PlanStep step) {
+		String statusEmoji;
+		switch (step.status()) {
+			case "pending":
+				statusEmoji = "⏳";
+				break;
+			case "in_progress":
+				statusEmoji = "🔄";
+				break;
+			case "completed":
+				statusEmoji = "✅";
+				break;
+			default:
+				statusEmoji = "⏳";
+		}
+		return String.format("  %d. %s [%s] %s\n", index, statusEmoji, step.status(), step.description());
+	}
+}

From be48177c39c87fddec7f0d8745bb6f21889908df Mon Sep 17 00:00:00 2001
From: fudawei <fudawei@yunlizhihui.com>
Date: Sun, 8 Feb 2026 15:31:32 +0800
Subject: [PATCH 3/3] =?UTF-8?q?fix:=20=E4=BF=AE=E5=A4=8D=E6=A0=B7=E5=BC=8F?=
 =?UTF-8?q?=E6=A3=80=E6=9F=A5=E9=97=AE=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../cloud/ai/dataagent/interceptor/ToolsInterceptor.java     | 1 -
 .../ai/dataagent/service/react/ReactAgentServiceImpl.java    | 1 +
 .../cloud/ai/dataagent/tools/ListTableSchemaTool.java        | 1 +
 .../cloud/ai/dataagent/tools/SequentialThinkingTool.java     | 5 ++---
 .../com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java | 1 +
 .../com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java  | 2 +-
 6 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
index 1dcbee102..0afbf0eb2 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/interceptor/ToolsInterceptor.java
@@ -34,7 +34,6 @@ public interface ToolCallCallback {
 
 	}
 
-
 	private final List<ToolCallCallback> callbacks = new ArrayList<>();
 
 	@Override
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
index 96a5898af..702e91105 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/service/react/ReactAgentServiceImpl.java
@@ -303,4 +303,5 @@ private void handleToolCall(String threadId, String toolName, String input, Stri
 			log.error("Error processing tool call: {}", e.getMessage(), e);
 		}
 	}
+
 }
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
index 4454fff19..ba9368cea 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/ListTableSchemaTool.java
@@ -175,4 +175,5 @@ private static List<String> extractTableName(List<Document> tableDocuments) {
 		log.info("At this SchemaRecallNode, Recall tables are: {}", tableNames);
 		return tableNames;
 	}
+
 }
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
index 2ab9e496a..f44ebe0ed 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SequentialThinkingTool.java
@@ -49,7 +49,6 @@ public String apply(Request request, ToolContext toolContext) {
 				return "Validation failed: Invalid input parameters";
 			}
 
-
 			// Adjust totalThoughts if thoughtNumber exceeds it
 			if (request.thoughtNumber() > request.totalThoughts()) {
 				request = new Request(request.thought(), request.nextThoughtNeeded(), request.thoughtNumber(),
@@ -84,8 +83,7 @@ public String apply(Request request, ToolContext toolContext) {
 			responseData.put("thought", request.thought());
 			responseData.put("incomplete_steps", incomplete);
 
-			log.info("thinking Execute completed - Thought {}/{}", request.thoughtNumber(),
-					request.totalThoughts());
+			log.info("thinking Execute completed - Thought {}/{}", request.thoughtNumber(), request.totalThoughts());
 
 			String outputMsg = "Thought process recorded";
 			if (incomplete) {
@@ -214,4 +212,5 @@ private boolean validate(Request request) {
 		}
 		return true;
 	}
+
 }
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
index 0095e45ed..2dfe8740d 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/SqlExecuteTool.java
@@ -158,4 +158,5 @@ public ToolCallback toolCallback() {
 				- 执行结果中的数据预览可能会被截断，仅用于参考
 				""").inputType(Request.class).build();
 	}
+
 }
diff --git a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
index 922d5cf88..a375c0925 100644
--- a/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
+++ b/data-agent-management/src/main/java/com/alibaba/cloud/ai/dataagent/tools/TodoWriteTool.java
@@ -42,7 +42,6 @@ public String apply(Request request, ToolContext toolContext) {
 				return "Task description is required";
 			}
 
-
 			if (request.steps() == null || request.steps().isEmpty()) {
 				return generateEmptyPlanOutput(request.task());
 			}
@@ -232,4 +231,5 @@ private String formatPlanStep(int index, PlanStep step) {
 		}
 		return String.format("  %d. %s [%s] %s\n", index, statusEmoji, step.status(), step.description());
 	}
+
 }