myagent-ai 1.13.0 → 1.13.2

package/agents/main_agent.py

@@ -454,7 +454,11 @@ class MainAgent(BaseAgent):
                 )
                 if db_history:
                     conversation_history = [
-                        Message(role=entry.role, content=entry.content)
+                        Message(
+                            role=entry.role,
+                            content=entry.content,
+                            metadata={"time": (entry.created_at[:19] if entry.created_at else "")}
+                        )
                         for entry in db_history
                     ]
                     logger.info(f"[{task_id}] 从 DB 加载了 {len(conversation_history)} 条历史对话")

package/core/context_builder.py

@@ -42,6 +42,27 @@ if TYPE_CHECKING:
 logger = get_logger("myagent.context_builder")
 
 
+# ── 知识库 RAG 索引缓存（模块级，避免每次 LLM 调用重建） ──
+_rag_cache: dict = {}  # {abs_kb_dir: {"rag": KnowledgeRAG, "mtime": str}}
+
+
+def _compute_dir_mtime(dir_path: str) -> str:
+    """计算目录下所有支持文件的修改时间摘要（用于脏检测）"""
+    import os
+    _KB_EXTS = {".md", ".txt", ".json", ".csv", ".py", ".js", ".html"}
+    mtimes = []
+    try:
+        for f in sorted(os.listdir(dir_path)):
+            fp = os.path.join(dir_path, f)
+            if os.path.isfile(fp):
+                ext = os.path.splitext(f)[1].lower()
+                if ext in _KB_EXTS:
+                    mtimes.append(f"{f}:{os.path.getmtime(fp)}")
+    except OSError:
+        pass
+    return "|".join(sorted(mtimes))
+
+
 # 默认知识库目录名（相对于 data_dir）
 _DEFAULT_KB_RELATIVE_PATH = "knowledge"
 
@@ -143,6 +164,9 @@ class ContextBuilder:
         context_body = "\n".join(sections)
         context_xml = f"<context>\n{context_body}\n</context>"
 
+        # ── Token 预算检查与自动裁剪 ──
+        context_xml = self._enforce_token_budget(context_xml)
+
         logger.debug(
             f"上下文已构建 (session={session_id}, 对话条数={len(conversation_history)}, "
             f"context长度={len(context_xml)})"
@@ -336,7 +360,10 @@ class ContextBuilder:
         return "<knowledge>\n(未找到相关知识)\n</knowledge>"
 
     def _search_knowledge_dir(self, kb_dir: str, query: str, top_k: int = 5) -> str:
-        """在指定知识库目录中执行 RAG 搜索并格式化结果"""
+        """在指定知识库目录中执行 RAG 搜索并格式化结果
+
+        使用模块级缓存 + 文件修改时间脏检测，避免每次 LLM 调用都重建索引。
+        """
         import os as _os
 
         if not query.strip():
@@ -348,8 +375,30 @@ class ContextBuilder:
         try:
             from knowledge.rag import KnowledgeRAG
 
-            rag = KnowledgeRAG(kb_dir=kb_dir)
-            rag.build_index()
+            # ── 缓存键: 目录绝对路径 ──
+            abs_kb = _os.path.abspath(kb_dir)
+            cache = _rag_cache.get(abs_kb)
+            need_rebuild = True
+
+            if cache is not None:
+                # 脏检测: 比较上次记录的文件修改时间摘要
+                current_mtime = _compute_dir_mtime(abs_kb)
+                if current_mtime == cache["mtime"]:
+                    need_rebuild = False
+                else:
+                    logger.debug(f"知识库目录变更检测到 ({abs_kb})，重建索引")
+
+            if need_rebuild:
+                rag = KnowledgeRAG(kb_dir=kb_dir)
+                rag.build_index()
+                _rag_cache[abs_kb] = {
+                    "rag": rag,
+                    "mtime": _compute_dir_mtime(abs_kb),
+                }
+                rebuild_tag = "重新" if cache else ""
+                logger.debug(f"知识库索引已{rebuild_tag}构建: {rag.total_chunks} 块 ({abs_kb})")
+            else:
+                rag = cache["rag"]
 
             if rag.total_chunks == 0:
                 return ""
@@ -415,7 +464,12 @@ class ContextBuilder:
             if not content.strip():
                 continue
             label = role_labels.get(role, role)
-            filtered_msgs.append((label, content.strip()))
+            # 从 metadata 中提取时间（DB加载时已附带）
+            msg_time = ""
+            msg_meta = getattr(msg, "metadata", None)
+            if isinstance(msg_meta, dict):
+                msg_time = msg_meta.get("time", "")
+            filtered_msgs.append((label, content.strip(), msg_time))
 
         if not filtered_msgs:
             return "<resentdialog>\n(无对话历史)\n</resentdialog>"
@@ -439,8 +493,12 @@ class ContextBuilder:
             formatted_lines.append(prefix_text)
             formatted_lines.append("")  # 空行分隔
 
-        for label, content in recent_msgs:
-            formatted_lines.append(f"[{label}] {_xml_escape(content)}")
+        for label, content, msg_time in recent_msgs:
+            # 临时合并时间信息到内容中给 LLM 参考
+            if msg_time:
+                formatted_lines.append(f"[{label}] [{msg_time}] {_xml_escape(content)}")
+            else:
+                formatted_lines.append(f"[{label}] {_xml_escape(content)}")
 
         dialog_text = "\n".join(formatted_lines)
 
@@ -482,7 +540,9 @@ class ContextBuilder:
             return ""
 
         summary_parts: List[str] = ["[历史对话摘要]"]
-        for label, content in old_msgs:
+        for item in old_msgs:
+            label = item[0]
+            content = item[1]
             # 提取第一行或前100字符作为要点
             first_line = content.split("\n")[0].strip()
             if len(first_line) > 100:
@@ -637,6 +697,87 @@ class ContextBuilder:
         lines.append("</tools>")
         return "\n".join(lines)
 
+    # =========================================================================
+    # Token 预算管理
+    # =========================================================================
+
+    def _enforce_token_budget(self, context_xml: str, budget_ratio: float = 0.75) -> str:
+        """
+        Token 预算检查与自动裁剪。
+
+        估算 context_xml 的 token 数，如果超过 budget_ratio * context_window，
+        按优先级裁剪（先裁剪 <knowledge>、<recall_memory>、<automemory>，
+        再裁剪 <resentdialog> 历史部分）。
+
+        Args:
+            context_xml: 完整的 <context> XML 字符串
+            budget_ratio: 上下文窗口使用比例上限（默认 75%，为系统提示和输出预留空间）
+
+        Returns:
+            裁剪后的 context_xml
+        """
+        if not context_xml:
+            return context_xml
+
+        # 粗略估算 token: 中文约 1.3 token/字，英文约 0.35 token/字
+        def _est_tok(text: str) -> int:
+            if not text:
+                return 0
+            cn = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
+            other = len(text) - cn
+            return int(cn * 1.3 + other * 0.35)
+
+        # 默认 128K context window
+        window = 128000
+
+        budget = int(window * budget_ratio)
+        estimated = _est_tok(context_xml)
+
+        if estimated <= budget:
+            return context_xml
+
+        logger.warning(
+            f"上下文 token 估算 ({estimated}) 超出预算 ({budget} = {budget_ratio}*{window}), "
+            f"启动自动裁剪 (原始长度={len(context_xml)} 字符)"
+        )
+
+        import re
+
+        def _remove_section(xml: str, tag: str) -> str:
+            pattern = rf'<{tag}>[\s\S]*?</{tag}>'
+            replacement = f'<{tag}>\n(因 token 预算不足已裁剪)\n</{tag}>'
+            return re.sub(pattern, replacement, xml, count=1, flags=re.DOTALL)
+
+        # 按优先级从低到高裁剪
+        for tag in ['knowledge', 'recall_memory', 'automemory']:
+            if estimated <= budget:
+                break
+            if f'<{tag}>' in context_xml:
+                context_xml = _remove_section(context_xml, tag)
+                estimated = _est_tok(context_xml)
+                logger.debug(f"裁剪 <{tag}> 后 token 估算: {estimated}")
+
+        # 如果还超预算，截断 <resentdialog> 内容
+        if estimated > budget:
+            pattern = r'<resentdialog>\n([\s\S]*?)\n</resentdialog>'
+            match = re.search(pattern, context_xml)
+            if match:
+                dialog_text = match.group(1)
+                target_chars = int(budget / 1.3)
+                if len(dialog_text) > target_chars:
+                    truncated = dialog_text[-target_chars:]
+                    truncated = "(... 历史已因 token 预算不足裁剪 ...)\n" + truncated
+                    context_xml = (
+                        context_xml[:match.start(1)] + truncated + context_xml[match.end(1):]
+                    )
+                    estimated = _est_tok(context_xml)
+                    logger.debug(f"截断对话历史后 token 估算: {estimated}")
+
+        if estimated > budget:
+            logger.warning(f"上下文裁剪后仍超出预算 (token={estimated}/{budget})")
+
+        return context_xml
+
 
 # =============================================================================
 # 工具函数

package/memory/manager.py

@@ -278,17 +278,13 @@ class MemoryManager:
     # ==========================================================================
 
     def add_session(self, session_id, role="", content="", key="", importance=0.5, metadata=None) -> str:
-        """添加会话记忆。内容自动注入时间前缀，确保自包含时间信息。"""
+        """添加会话记忆。内容不包含时间前缀，时间仅存于 created_at 和 metadata。"""
         from datetime import datetime as _dt
         _now_str = _dt.now().strftime("%Y-%m-%d %H:%M:%S")
-        # 对话类记忆（user/assistant/system/tool）自动加时间前缀
-        if role and content and not content.startswith("["):
-            timestamped_content = f"[{_now_str}] {content}"
-        else:
-            timestamped_content = truncate_str(content, 50000)
+        # 直接存储原始内容，不再注入时间前缀
         entry = MemoryEntry(
             session_id=session_id, category="session", role=role,
-            content=timestamped_content, key=key,
+            content=truncate_str(content, 50000), key=key,
             importance=importance, metadata={"timestamp": _now_str, **(metadata or {})},
         )
         return self._insert(entry)
@@ -366,7 +362,7 @@ class MemoryManager:
         session_id: str,
         limit: int = 50,
     ) -> str:
-        """获取对话历史文本(供 LLM 使用)"""
+        """获取对话历史文本(供 LLM 使用)，临时合并时间信息"""
         entries = self.get_conversation(session_id, limit)
         lines = []
         for e in entries:
@@ -379,7 +375,12 @@ class MemoryManager:
                 label = "系统"
             elif e.role == "tool":
                 label = "工具"
-            lines.append(f"[{label}] {e.content}")
+            # 从 created_at 提取时间，临时合并到内容中给 LLM
+            time_str = e.created_at[:19] if e.created_at and len(e.created_at) >= 19 else ""
+            if time_str:
+                lines.append(f"[{label}] [{time_str}] {e.content}")
+            else:
+                lines.append(f"[{label}] {e.content}")
         return "\n".join(lines)
 
     def clear_conversation(self, session_id) -> int:
@@ -469,11 +470,10 @@ class MemoryManager:
         """添加全局记忆（跨会话可检索）"""
         from datetime import datetime
         now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        timestamped_content = f"[{now_str}] {truncate_str(content, 50000)}"
         ts_summary = summary or truncate_str(content, 200)
         entry = MemoryEntry(
             session_id=session_id, category="global", key=key,
-            content=timestamped_content, summary=f"[{now_str}] {ts_summary}",
+            content=truncate_str(content, 50000), summary=f"[{now_str}] {ts_summary}",
             importance=importance, metadata={"timestamp": now_str, **(metadata or {})},
         )
         return self._insert(entry)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.13.0",
+  "version": "1.13.2",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/web/api_server.py

@@ -155,6 +155,9 @@ class ApiServer:
         self._msg_queues: Dict[str, List[Dict]] = {}
         # 任务列表内存存储（exec 模式，替代 task.md）
         self._task_list_store: dict[str, list] = {}  # session_id -> [{text, status}]  (per-session, not per-agent)
+        # 模型链并发锁：防止并发请求互相覆盖 self.core.llm 配置
+        import asyncio
+        self._model_chain_lock = asyncio.Lock()
         self._setup_routes()
         self._runner: Optional[web.AppRunner] = None
 
@@ -3054,10 +3057,22 @@ class ApiServer:
     async def _try_model_chain(self, model_chain: list[dict], message: str, session_id: str,
                                  agent_path: str = None, agent_system_prompt: str = None,
                                  chat_mode: str = "") -> str:
-        """依次尝试模型链中的模型，直到成功或全部失败"""
+        """依次尝试模型链中的模型，直到成功或全部失败
+        
+        使用 asyncio.Lock 保护共享的 self.core.llm，防止并发请求互相干扰。
+        """
         if not model_chain:
             return await self.core.process_message(message, session_id)
 
+        async with self._model_chain_lock:
+            return await self._try_model_chain_inner(model_chain, message, session_id,
+                agent_path=agent_path, agent_system_prompt=agent_system_prompt,
+                chat_mode=chat_mode)
+
+    async def _try_model_chain_inner(self, model_chain: list[dict], message: str, session_id: str,
+                                      agent_path: str = None, agent_system_prompt: str = None,
+                                      chat_mode: str = "") -> str:
+        """_try_model_chain 的实际执行体（已在 _model_chain_lock 保护下）"""
         llm = self.core.llm
         last_error = ""
         used_model_name = ""
@@ -3152,12 +3167,26 @@ class ApiServer:
     async def _try_model_chain_stream(self, model_chain, message, session_id,
                                        agent_path=None, agent_system_prompt=None,
                                        chat_mode="", stream_response=None):
-        """流式版本的模型链调用，逐token输出到SSE"""
+        """流式版本的模型链调用，逐token输出到SSE
+        
+        使用 asyncio.Lock 保护共享的 self.core.llm，防止并发请求互相干扰。
+        """
         if not model_chain:
             result = await self.core.process_message(message, session_id)
             await stream_response.write(("data: " + json.dumps({"type": "text", "content": result}) + "\n\n").encode())
             return result
 
+        async with self._model_chain_lock:
+            return await self._try_model_chain_stream_inner(
+                model_chain, message, session_id,
+                agent_path=agent_path, agent_system_prompt=agent_system_prompt,
+                chat_mode=chat_mode, stream_response=stream_response,
+            )
+
+    async def _try_model_chain_stream_inner(self, model_chain, message, session_id,
+                                             agent_path=None, agent_system_prompt=None,
+                                             chat_mode="", stream_response=None):
+        """_try_model_chain_stream 的实际执行体（已在 _model_chain_lock 保护下）"""
         llm = self.core.llm
         full_text = ""
 

package/web/ui/chat/chat.css

@@ -455,7 +455,7 @@ input,textarea,select{font:inherit}
 
 /* ── Message Content Smooth Render ── */
 .message-content{
-  min-width:0;
+  flex:1;min-width:0;
 }
 .stream-text-node{
   display:inline;
@@ -2005,7 +2005,6 @@ body.popout-mode .main{margin-left:0 !important;border-left:none !important}
 body.popout-mode .agent-panel{display:none !important}
 body.popout-mode .main-header{padding-left:12px}
 body.popout-mode #popoutBtn{display:none !important}
-body.popout-mode #debugToggleBtn{display:none !important}
 
 /* ══════════════════════════════════════════════════════
    ── Mobile Responsive (≤768px) ──

package/web/ui/chat/chat_main.js

@@ -2547,32 +2547,27 @@ function formatTime(timeStr) {
   }
 }
 
+// ── User scroll lock: when user manually scrolls up, stop auto-scrolling ──
+var _userScrollLocked = false;
+
 function scrollToBottom(force) {
   const c = document.getElementById('messagesContainer');
   if (!c) return;
-  // During streaming: pin the active assistant message to the top of the chat window
-  // so the user can see the full response content below
-  const isStreaming = state.isGenerating;
-  if (isStreaming && !force) {
-    const activeRow = c.querySelector('.message-row.assistant.streaming, .message-row.assistant:last-of-type');
-    if (activeRow) {
-      requestAnimationFrame(() => {
-        const rowTop = activeRow.offsetTop;
-        // Scroll so the assistant row sits at the very top of the visible area
-        c.scrollTop = rowTop;
-        updateScrollToBottomBtn(c.scrollHeight - c.scrollTop - c.clientHeight);
-      });
-      return;
-    }
-  }
   requestAnimationFrame(() => {
-    // Smart scroll: only auto-scroll if user is near bottom (within 120px)
-    // or if force is true
     const distFromBottom = c.scrollHeight - c.scrollTop - c.clientHeight;
+    // If user has manually scrolled away, don't auto-scroll (unless forced)
+    if (!force && _userScrollLocked) {
+      updateScrollToBottomBtn(distFromBottom);
+      return;
+    }
+    // Smart scroll: only auto-scroll if near bottom (within 120px) or forced
     if (force || distFromBottom < 120) {
       c.scrollTop = c.scrollHeight;
+      _userScrollLocked = false;
+    } else {
+      // User is far from bottom — lock auto-scroll
+      _userScrollLocked = true;
     }
-    // Update scroll-to-bottom button visibility
     updateScrollToBottomBtn(distFromBottom);
   });
 }
@@ -2603,7 +2598,7 @@ function initScrollToBottomBtn() {
   btn.id = 'scrollToBottomBtn';
   btn.className = 'scroll-to-bottom-btn';
   btn.innerHTML = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 5v14M5 12l7 7 7-7"/></svg>';
-  btn.onclick = function() { scrollToBottom(true); };
+  btn.onclick = function() { _userScrollLocked = false; scrollToBottom(true); };
   // Insert into the main area (parent of messagesContainer)
   const mainArea = container.parentElement;
   if (mainArea) {
@@ -2611,9 +2606,14 @@ function initScrollToBottomBtn() {
     mainArea.appendChild(btn);
   }
 
-  // Listen for manual scroll to show/hide button
+  // Listen for manual scroll to show/hide button and detect user scroll-away
   container.addEventListener('scroll', function() {
-    updateScrollToBottomBtn();
+    const dist = container.scrollHeight - container.scrollTop - container.clientHeight;
+    // Lock auto-scroll when user scrolls more than 120px away from bottom
+    if (dist > 120) {
+      _userScrollLocked = true;
+    }
+    updateScrollToBottomBtn(dist);
   }, { passive: true });
 }
 

package/web/ui/chat/flow_engine.js

@@ -393,6 +393,8 @@ function updateStreamingMessage(msgIdx) {
           const newText = msg.reasoning.substring(prevLen);
           thoughtContent.insertAdjacentHTML('beforeend', renderMarkdown(newText));
           reasoningDetails._lastReasoningLen = msg.reasoning.length;
+          // 自动滚动推理框内部内容到底部（不滚动整个页面）
+          thoughtContent.scrollTop = thoughtContent.scrollHeight;
         }
       } else if (thoughtContent && !msg.streaming) {
         // Final render once streaming stops
@@ -443,6 +445,8 @@ function updateStreamingMessage(msgIdx) {
           const newText = msg.thought.substring(prevLen);
           thoughtContent.insertAdjacentHTML('beforeend', renderMarkdown(newText));
           thoughtBlock._lastThoughtLen = msg.thought.length;
+          // 自动滚动思考框内部内容到底部
+          thoughtContent.scrollTop = thoughtContent.scrollHeight;
         }
       } else if (thoughtContent && !msg.streaming) {
         thoughtContent.innerHTML = renderMarkdown(msg.thought);
@@ -499,6 +503,8 @@ function updateStreamingMessage(msgIdx) {
             const newText = msg._v2Reasoning.substring(prevLen);
             thoughtContent.insertAdjacentHTML('beforeend', renderMarkdown(newText));
             v2ReasoningBlock._lastV2Len = msg._v2Reasoning.length;
+            // 自动滚动 V2 推理框内部内容到底部
+            thoughtContent.scrollTop = thoughtContent.scrollHeight;
           }
         } else if (thoughtContent && !msg.streaming) {
           thoughtContent.innerHTML = renderMarkdown(msg._v2Reasoning);
@@ -855,6 +861,41 @@ function toggleExecEventsPanel(header) {
 // ── Inline Exec Event (Timeline Card) ──
 // ══════════════════════════════════════════════════════
 
+// Update an existing V2 tool card in the DOM (replace spinner with result icon)
+function _updateToolCardInDOM(msgIdx, partIdx) {
+  var container = document.getElementById('messagesInner');
+  if (!container) return;
+  // Find the target message row
+  var allRows = container.querySelectorAll('.message-row');
+  var targetRow = null;
+  var rowCount = 0;
+  for (var ri = 0; ri < allRows.length; ri++) {
+    if (rowCount === msgIdx) { targetRow = allRows[ri]; break; }
+    rowCount++;
+  }
+  if (!targetRow) return;
+  // Find the timeline inside the message
+  var timeline = targetRow.querySelector('.msg-timeline');
+  if (!timeline) return;
+  // Find all V2 tool event cards in the timeline
+  var toolCards = timeline.querySelectorAll('.v2-tool-event');
+  // partIdx is the index in msgParts — count only v2_tool parts to find the right card
+  var msg = state.messages[msgIdx];
+  if (!msg || !msg.parts) return;
+  var toolPartCount = 0;
+  var targetCard = null;
+  for (var ti = 0; ti < msg.parts.length && ti <= partIdx; ti++) {
+    if (msg.parts[ti].type === 'v2_tool') {
+      if (ti === partIdx) { targetCard = toolCards[toolPartCount]; break; }
+      toolPartCount++;
+    }
+  }
+  if (!targetCard) return;
+  // Re-render the card with updated data
+  var updatedHtml = renderInlineExecEvent(msg.parts[partIdx], msgIdx);
+  targetCard.outerHTML = updatedHtml;
+}
+
 function renderInlineExecEvent(data, msgIdx) {
   // V2 Tool Event handling (called with full part: {type:'v2_tool', data:{...}})
   if (data.type === 'v2_tool') {
@@ -1168,6 +1209,16 @@ async function sendMessage() {
     sessionId = `${state.activeAgent}_web_${ts}`;
     state.activeSessionId = sessionId;
     document.getElementById('headerTitle').textContent = formatSessionName(sessionId);
+    // ── 立即在左侧边栏添加新会话条目（不等后端返回） ──
+    state.sessions.unshift({
+      id: sessionId,
+      name: formatSessionName(sessionId),
+      messages: 0,
+      last: new Date().toISOString(),
+      preview: '',
+    });
+    state.agentSessions[state.activeAgent] = [...state.sessions];
+    renderSessions();
     // ── 更新 URL 参数，携带会话 ID（刷新页面可恢复） ──
     try {
       const url = new URL(window.location.href);
@@ -1349,6 +1400,7 @@ async function sendMessage() {
             fullThought = '';
             state.messages.push({ role: 'assistant', content: '', thought: '', parts: [], time: new Date().toISOString(), streaming: true });
             renderMessages();
+            _userScrollLocked = false;
             scrollToBottom(true); // Force scroll for new message
           } else if (evt.type === 'clear_text') {
             // Clear intermediate text from previous agent loop iterations
@@ -1437,36 +1489,66 @@ async function sendMessage() {
             state.messages[msgIdx].exec_events = [...allExecEvents];
             throttledStreamUpdate(msgIdx);
           } else if (evt.type === 'v2_tool_result') {
-            // Tool execution completed
-            // Stop the tool timer
-            if (evt.tool && evt.tool.toolname) {
-              // Find matching timer by checking all active timers
-              for (var tId in _toolTimers) {
-                stopToolTimer(tId);
-              }
-            }
-            // evt.tool contains: {beforecalltext, toolname, ...}
-            // evt.result contains: {success, output, error, ...}
+            // Tool execution completed — find and UPDATE the matching start card
             var _r = evt.result || {};
             var _t = evt.tool || {};
-            var resultEvent = {
-              type: 'v2_tool',
-              data: {
-                id: 'v2tool_' + Date.now() + '_' + allExecEvents.length,
-                type: 'tool_result',
-                title: (_t.toolname || '工具') + ' 执行完成',
-                tool_name: _t.toolname,
-                success: !!_r.success,
-                summary: (_r.output || _r.error || '').substring(0, 500),
-                result: _r,
-                callback: _t.callback
+            var _toolName = _t.toolname || '';
+            // Find the matching tool_start part in msgParts by tool_name
+            var _matchedIdx = -1;
+            for (var _pi = msgParts.length - 1; _pi >= 0; _pi--) {
+              if (msgParts[_pi].type === 'v2_tool' && msgParts[_pi].data.tool_name === _toolName && msgParts[_pi].data.status === 'running') {
+                _matchedIdx = _pi;
+                break;
               }
-            };
-            msgParts.push(resultEvent);
-            allExecEvents.push(resultEvent.data);
-            state.messages[msgIdx].parts = [...msgParts];
-            state.messages[msgIdx].exec_events = [...allExecEvents];
-            throttledStreamUpdate(msgIdx);
+            }
+            if (_matchedIdx >= 0) {
+              // Update the existing start card in-place
+              var _startData = msgParts[_matchedIdx].data;
+              // Stop timer using the start card's original ID
+              stopToolTimer(_startData.id);
+              // Update the part data to reflect completion
+              _startData.status = 'done';
+              _startData.type = 'tool_result';
+              _startData.success = !!_r.success;
+              _startData.summary = (_r.output || _r.error || '').substring(0, 500);
+              _startData.result = _r;
+              _startData.title = (_t.toolname || '工具') + ' 执行完成';
+              // Update in allExecEvents too
+              for (var _ei = allExecEvents.length - 1; _ei >= 0; _ei--) {
+                if (allExecEvents[_ei].id === _startData.id) {
+                  Object.assign(allExecEvents[_ei], _startData);
+                  break;
+                }
+              }
+              // Force re-render this specific card in the DOM
+              _updateToolCardInDOM(msgIdx, _matchedIdx);
+              state.messages[msgIdx].parts = [...msgParts];
+              state.messages[msgIdx].exec_events = [...allExecEvents];
+            } else {
+              // Fallback: no matching start found, push as new part
+              var _fallbackTimerIds = Object.keys(_toolTimers);
+              for (var _fi = 0; _fi < _fallbackTimerIds.length; _fi++) {
+                stopToolTimer(_fallbackTimerIds[_fi]);
+              }
+              var resultEvent = {
+                type: 'v2_tool',
+                data: {
+                  id: 'v2tool_' + Date.now() + '_' + allExecEvents.length,
+                  type: 'tool_result',
+                  title: (_t.toolname || '工具') + ' 执行完成',
+                  tool_name: _t.toolname,
+                  success: !!_r.success,
+                  summary: (_r.output || _r.error || '').substring(0, 500),
+                  result: _r,
+                  callback: _t.callback
+                }
+              };
+              msgParts.push(resultEvent);
+              allExecEvents.push(resultEvent.data);
+              state.messages[msgIdx].parts = [...msgParts];
+              state.messages[msgIdx].exec_events = [...allExecEvents];
+              throttledStreamUpdate(msgIdx);
+            }
           } else if (evt.type === 'v2_task_plan') {
             // Updated task plan from V2 output
             if (evt.plan) {