myagent-ai 1.13.4 → 1.13.6

package/agents/main_agent.py

@@ -43,7 +43,7 @@ class MainAgent(BaseAgent):
 <output>
 <response>直接回复用户的内容。这是一段友好、自然的话语，用于向用户说明你正在做什么，或者回应用户的问题/问候。要求简洁、有礼貌、符合对话场景。如果用户只是问候，简单回应即可；如果用户有具体任务，要说明你的计划。</response>
 <usersays_correct>根据用户输入的"usersays"内容，结合上下文优化为新的用户输入，如果"usersays"为空，这里输出为空。</usersays_correct>
-<task_plan>如"context"包含非空"task_plan",则更新它，变为当前输出。否则，根据"context", 以MD 的格式，制定新任务列表。</task_plan>
+<task_plan>任务计划（仅复杂任务使用）：如"context"包含非空"task_plan"，则更新它。否则，先评估任务复杂度——如果预计操作步骤不超过5步（如：单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务），则<task_plan>输出为空，不要创建任务列表；只有当任务较复杂（预计超过5步操作，如：多文件修改、需要调研+实现+测试、涉及多个模块联动等），才以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
 
 <toolstocal>
 <tool><beforecalltext>连接词，介绍调用什么工具，达到什么目的。</beforecalltext><toolname>工具名</toolname><parms>JSON格式的参数对象，例如: {"query": "搜索关键词", "num": 5}</parms><timeout>预估超时时限(秒)</timeout><callback>true/false,要求解析器在该工具执行完后是否要回调llm大模型，将所有工具输出结果+新构造的"context"输入给llm</callback></tool>
@@ -63,7 +63,7 @@ class MainAgent(BaseAgent):
 1. 你必须且只能输出 <output> XML 结构，不要输出任何其他文本
 2. <response>: 必须输出一段直接回复用户的话语（这是用户实际看到的回复），要求简洁友好、自然流畅。不要只输出任务计划而不说话！
 3. <usersays_correct>: 如果 context 中 usersays 非空，则根据对话语境优化为更准确的用户意图表达
-4. <task_plan>: 使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
+4. <task_plan>: 仅用于复杂任务（预计超过5步操作）。简单任务（≤5步）输出为空。复杂任务使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
 5. <toolstocal>: 列出所有需要执行的工具调用，每个工具包含完整的参数说明
 6. <parms>: **必须使用严格合法的JSON格式**，例如 {"query": "关键词", "num": 10}，不要使用其他格式
 7. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）

package/package.json

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

package/web/api_server.py

@@ -3336,8 +3336,9 @@ class ApiServer:
                         _v2_latest_task_plan = plan_text
                         # 解析 Markdown 任务列表为 [{text, status}] 格式
                         parsed_tasks = self._parse_v2_task_plan(plan_text)
-                        if parsed_tasks:
-                            # 合并与存储
+                        if parsed_tasks and len(parsed_tasks) >= 3:
+                            # 仅当任务项 >= 3 时才同步到 store 并推送前端
+                            # （小任务 <3 项视为简单任务，不创建任务列表）
                             merged = self._merge_task_list(session_id, parsed_tasks)
                             self._task_list_store[session_id] = merged
                             # 额外发送 task_list_update 事件（前端侧边栏 task panel 依赖此事件）
@@ -3345,6 +3346,14 @@ class ApiServer:
                                 await _write_sse({"type": "task_list_update", "tasks": merged})
                             except Exception:
                                 pass
+                        elif not parsed_tasks or len(parsed_tasks) == 0:
+                            # LLM 输出了空的 task_plan，清空任务列表
+                            if session_id in self._task_list_store:
+                                self._task_list_store[session_id] = []
+                                try:
+                                    await _write_sse({"type": "task_list_update", "tasks": []})
+                                except Exception:
+                                    pass
 
                 # 转发所有事件到前端
                 await _write_sse(event)

package/web/ui/chat/chat_main.js

@@ -2419,14 +2419,14 @@ function _renderMessagesInner() {
         partsInner += '<div class="timeline-segment">' + renderMarkdown(msg._streamingText) + _cursor + '</div>';
       }
       if (partsInner) {
-        // All parts (text segments + tool calls) wrapped in ONE message-bubble
-        timelineHtml = '<div class="message-bubble"><div class="msg-timeline">' + partsInner + '</div></div>';
+        // All parts (text segments + tool calls) wrapped in ONE message-bubble (full width during streaming)
+        timelineHtml = '<div class="message-bubble msg-bubble-wrapper"><div class="msg-timeline">' + partsInner + '</div></div>';
       }
     }
 
-    // Backward compat: single bubble for messages without parts
+    // Backward compat: single bubble for messages without parts (full width)
     const singleBubbleHtml = (!hasParts && !hasStreamingText)
-      ? (content ? `<div class="message-bubble">${content}${ttsIndicator}</div>` : '')
+      ? (content ? `<div class="message-bubble msg-bubble-wrapper">${content}${ttsIndicator}</div>` : '')
       : '';
 
     // Exec events panel: only for backward compat (messages without parts loaded from DB)
@@ -3459,6 +3459,9 @@ const ttsManager = {
   _audioPlaying: false,     // 队列是否正在播放
   _stopRequested: false,    // 是否已请求停止
   _streamMsgIndex: -1,      // 流式模式对应的消息索引
+  _pendingFetches: 0,       // 正在进行的 TTS 请求计数（防竞态）
+  _flushed: false,          // streamFlush 已调用（防竞态停止）
+  _firstChunkSent: false,   // 是否已发送第一个音频块（降低首句延迟）
 
   init() {
     // Load TTS enabled state from localStorage
@@ -3545,6 +3548,9 @@ const ttsManager = {
     this._audioQueue = [];
     this._audioPlaying = false;
     this._stopRequested = false;
+    this._pendingFetches = 0;
+    this._flushed = false;
+    this._firstChunkSent = false;
     // 保持 _streamActive = true 和 isPlaying = true
     // 这样后续的 text_delta 会继续往新的缓冲区添加文本
     // 新的句子会被合成并入队播放
@@ -3574,6 +3580,9 @@ const ttsManager = {
     this._streamMsgIndex = msgIndex;
     this.currentMsgIndex = msgIndex;
     this.isPlaying = true;
+    this._pendingFetches = 0;
+    this._flushed = false;
+    this._firstChunkSent = false;
   },
 
   /**
@@ -3588,6 +3597,27 @@ const ttsManager = {
 
     this._streamBuffer += delta;
 
+    // 首句快速通道：第一个音频块降低延迟，缓冲区达到 25 字即触发
+    if (!this._firstChunkSent && this._streamBuffer.length >= 25) {
+      var lastSep = -1;
+      for (var k = 0; k < this._streamBuffer.length; k++) {
+        var c = this._streamBuffer[k];
+        if (c === '，' || c === ',' || c === '。' || c === '！' || c === '？' || c === '；' || c === ' ' || c === '\n') {
+          lastSep = k;
+        }
+      }
+      if (lastSep > 0) {
+        var firstChunk = this._streamBuffer.substring(0, lastSep + 1).trim();
+        this._streamBuffer = this._streamBuffer.substring(lastSep + 1);
+        var cleanFirst = this._cleanForStreamTTS(firstChunk);
+        if (cleanFirst) {
+          this._firstChunkSent = true;
+          this._enqueueTTS(cleanFirst);
+        }
+      }
+      return;
+    }
+
     // 检测句子边界：中文句号/感叹号/问号，英文句号+空格，或换行
     var boundaryPattern = /[。！？]|\.(?:\s|$)|\n/;
     var boundaryIdx = -1;
@@ -3643,8 +3673,15 @@ const ttsManager = {
         this._enqueueTTS(cleanText);
       }
     }
-    // 标记流式阶段结束（队列播完后自动清理状态）
-    this._streamActive = false;
+    // 标记已刷新，但不立即停止 —— 等队列和 pending fetch 全部完成后再停止
+    this._flushed = true;
+    // 如果没有 pending fetch 且队列为空，立即停止
+    if (this._pendingFetches === 0 && this._audioQueue.length === 0 && !this._audioPlaying) {
+      this.isPlaying = false;
+      this._streamActive = false;
+      this.currentMsgIndex = -1;
+      this.updatePlayingIndicator();
+    }
   },
 
   /**
@@ -3683,6 +3720,7 @@ const ttsManager = {
   _enqueueTTS(text) {
     if (this._stopRequested) return;
     var self = this;
+    self._pendingFetches++;
 
     (async function() {
       try {
@@ -3719,6 +3757,15 @@ const ttsManager = {
         }
       } catch (e) {
         console.error('TTS stream chunk error:', e);
+      } finally {
+        self._pendingFetches--;
+        // 如果已 flush 且没有更多 pending，检查是否该停止
+        if (self._flushed && self._pendingFetches === 0 && self._audioQueue.length === 0 && !self._audioPlaying) {
+          self.isPlaying = false;
+          self._streamActive = false;
+          self.currentMsgIndex = -1;
+          self.updatePlayingIndicator();
+        }
       }
     })();
   },
@@ -3736,15 +3783,16 @@ const ttsManager = {
     }
 
     if (this._audioQueue.length === 0) {
-      // 队列空了，检查流式是否已结束
-      if (!this._streamActive) {
-        // 流结束且队列为空 → 播放完成
+      // 队列空了，检查流式是否已结束 AND 没有 pending fetches
+      if (this._flushed && this._pendingFetches === 0) {
+        // 流已结束、无 pending 请求、队列空 → 播放完成
         this.isPlaying = false;
+        this._streamActive = false;
         this._audioPlaying = false;
         this.currentMsgIndex = -1;
         this.updatePlayingIndicator();
       }
-      // 如果流还在继续，等待新的音频入队
+      // 如果流还在继续或还有 pending fetches，等待新的音频入队
       return;
     }
 

package/web/ui/chat/flow_engine.js

@@ -472,59 +472,7 @@ function updateStreamingMessage(msgIdx) {
     }
   }
 
-  // V2 Reasoning block (from v2_reasoning events)
-  if (msg._v2Reasoning) {
-    let v2ReasoningBlock = null;
-    const allThoughts2 = contentArea.querySelectorAll('.thought-block');
-    for (const tb of allThoughts2) {
-      const label = tb.querySelector('.thought-label');
-      if (label && label.textContent.includes('V2 推理')) {
-        v2ReasoningBlock = tb;
-        break;
-      }
-    }
-    if (!v2ReasoningBlock && msg.thought) {
-      // Skip if V1 thought already exists - don't duplicate
-    } else {
-      const v2Len = msg._v2Reasoning.length;
-      const v2WordCount = msg.streaming
-        ? '<span class="thought-word-count">' + v2Len + ' 字</span>'
-        : '';
-      if (v2ReasoningBlock) {
-        // Incremental update for V2 reasoning block
-        const label = v2ReasoningBlock.querySelector('.thought-label');
-        if (label) label.innerHTML = 'V2 推理过程' + v2WordCount;
-        const badge = v2ReasoningBlock.querySelector('.thought-badge');
-        if (badge) badge.textContent = msg.streaming ? '推理中...' : '已完成';
-        const thoughtContent = v2ReasoningBlock.querySelector('.thought-content');
-        if (thoughtContent && msg.streaming) {
-          const prevLen = v2ReasoningBlock._lastV2Len || 0;
-          if (msg._v2Reasoning.length > prevLen) {
-            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);
-          v2ReasoningBlock._lastV2Len = msg._v2Reasoning.length;
-        }
-      } else if (!msg.thought) {
-        const v2Html = `<details class="thought-block ${msg.streaming ? 'streaming' : ''}" ${msg.streaming ? 'open' : ''}>
-          <summary>
-            <span class="thought-icon">🧠</span>
-            <span class="thought-label">V2 推理过程${v2WordCount}</span>
-            ${msg.streaming ? '<span class="thought-badge">推理中...</span>' : '<span class="thought-badge">已完成</span>'}
-          </summary>
-          <div class="thought-content">${renderMarkdown(msg._v2Reasoning)}</div>
-        </details>`;
-        contentArea.insertAdjacentHTML('afterbegin', v2Html);
-        const newBlock = contentArea.querySelector(':scope > .thought-block');
-        if (newBlock) newBlock._lastV2Len = msg._v2Reasoning.length;
-      }
-    }
-  }
+  // V2 Reasoning: content is already rendered in msg.parts timeline, skip separate block to avoid duplication
 
   // Update content - timeline (interleaved text + exec events) or single bubble (backward compat)
   const hasParts = Array.isArray(msg.parts);
@@ -1430,15 +1378,20 @@ async function sendMessage() {
             if (evt.tasks && Array.isArray(evt.tasks) && !_finishReceived) {
               state.taskItems = evt.tasks;
               renderTaskList();
-              // 显示任务面板头部（不自动展开内容区）
               var panel = document.getElementById('taskPanel');
-              if (panel && state.taskItems.length > 0) {
-                panel.classList.remove('hidden');
-                // Use change detection + auto-fade (but don't force expand)
-                if (typeof hasTaskListChanged === 'function' && typeof triggerTaskAutoFade === 'function') {
-                  if (hasTaskListChanged()) {
-                    triggerTaskAutoFade();
+              if (panel) {
+                if (state.taskItems.length > 0) {
+                  // 有任务时才显示面板
+                  panel.classList.remove('hidden');
+                  // Use change detection + auto-fade (but don't force expand)
+                  if (typeof hasTaskListChanged === 'function' && typeof triggerTaskAutoFade === 'function') {
+                    if (hasTaskListChanged()) {
+                      triggerTaskAutoFade();
+                    }
                   }
+                } else {
+                  // 空任务列表时隐藏面板
+                  panel.classList.add('hidden');
                 }
               }
             }
@@ -1457,11 +1410,14 @@ async function sendMessage() {
             if (evt.data && evt.data.task_plan) {
               state.messages[msgIdx]._v2TaskPlan = evt.data.task_plan;
             }
-            // ── finish 标签：任务完成后清空任务面板 ──
+            // ── finish 标签：任务完成后清空任务面板并隐藏 ──
             if (evt.data && evt.data.finish) {
               _finishReceived = true;
               state.taskItems = [];
               if (typeof renderTaskList === 'function') renderTaskList();
+              // 隐藏任务面板
+              var finishPanel = document.getElementById('taskPanel');
+              if (finishPanel) finishPanel.classList.add('hidden');
             }
             throttledStreamUpdate(msgIdx);
           } else if (evt.type === 'v2_tool_start') {