myagent-ai 1.7.0 → 1.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {
@@ -65,4 +65,4 @@
     "departments/",
     "web/"
   ]
-}
+}

package/web/api_server.py

@@ -2611,10 +2611,29 @@ class ApiServer:
         max_iter = agent.config.agent.max_iterations if agent.config else 30
         final_response = ""
         iteration = 0
+        # 追踪连续无 action 迭代次数，防止无限重新提示
+        _consecutive_no_action = 0
+        _MAX_NO_ACTION_RETRIES = 3
 
         while iteration < max_iter:
             iteration += 1
 
+            # ── 执行模式：每轮迭代前刷新任务进度上下文 ──
+            # 这样 LLM 在每次调用时都能看到最新的任务列表状态
+            if chat_mode == "exec":
+                fresh_task_context = self._build_task_plan_context(agent_path, chat_mode, user_message)
+                if fresh_task_context:
+                    # 替换掉之前的任务规划上下文（保留非任务规划部分）
+                    base_prompt = context.metadata.get("agent_override_prompt", "")
+                    task_section_marker = "\n\n## 任务规划\n"
+                    idx = base_prompt.find(task_section_marker)
+                    if idx >= 0:
+                        # 替换旧的任务规划上下文
+                        context.metadata["agent_override_prompt"] = base_prompt[:idx] + task_section_marker + fresh_task_context
+                    else:
+                        # 没有旧的任务规划上下文，追加
+                        context.metadata["agent_override_prompt"] = base_prompt + task_section_marker + fresh_task_context
+
             # Build messages
             messages = agent._build_messages(context)
             tools = agent._get_tools()
@@ -2634,7 +2653,9 @@ class ApiServer:
             }
 
             # 需要回退(hold back)的最大字符数，用于检测 ```action 或 ```tasklist 标记
-            _MAX_HOLD = 22  # ```tasklist\n 最长 14 字符，留余量
+            # 注意: 12 足够覆盖 ```tasklist\n (12字符) + 余量
+            # 过大的值会导致短文本被 hold 住，流结束后一次性输出（看起来像非流式）
+            _MAX_HOLD = 12
 
             async def _text_delta_callback(full_text_so_far: str, delta_text: str):
                 """智能流式过滤器：文本正常推送，JSON action 块拦截"""
@@ -2661,7 +2682,8 @@ class ApiServer:
                             text_before = remaining[:marker_pos]
                             if text_before.strip():
                                 await _write_sse({"type": "text_delta", "content": text_before})
-                            st["processed_pos"] += marker_pos
+                            # 跳过整个开始标记（```action 或 ```tasklist），不要只跳到 ```
+                            st["processed_pos"] += marker_pos + len(f"```{block_type}")
                             if block_type == "tasklist":
                                 st["mode"] = "tasklist_block"
                             else:
@@ -2706,10 +2728,14 @@ class ApiServer:
 
                     elif st["mode"] == "action_block":
                         # ── Action 代码块模式：寻找结束标记 ``` ──
-                        end_marker = remaining.find("```")
+                        # 结束标记是独立的 ``` 行（前面有换行），不要匹配块开始标记内的 ```
+                        end_marker = remaining.find("\n```")
+                        if end_marker < 0 and remaining.startswith("```"):
+                            end_marker = 0
                         if end_marker >= 0:
                             # 找到结束标记，跳过整个 action 块（不推送）
-                            st["processed_pos"] += end_marker + 3  # 跳过 ```
+                            skip_len = (end_marker + 1 + 3) if end_marker > 0 else 3
+                            st["processed_pos"] += skip_len
                             st["mode"] = "text"
                             remaining = full_text_so_far[st["processed_pos"]:]
                             continue
@@ -2719,10 +2745,13 @@ class ApiServer:
 
                     elif st["mode"] == "tasklist_block":
                         # ── Tasklist 代码块模式：寻找结束标记 ``` ──
-                        end_marker = remaining.find("```")
+                        end_marker = remaining.find("\n```")
+                        if end_marker < 0 and remaining.startswith("```"):
+                            end_marker = 0
                         if end_marker >= 0:
                             # 找到结束标记，跳过整个 tasklist 块（不推送）
-                            st["processed_pos"] += end_marker + 3  # 跳过 ```
+                            skip_len = (end_marker + 1 + 3) if end_marker > 0 else 3
+                            st["processed_pos"] += skip_len
                             st["mode"] = "text"
                             remaining = full_text_so_far[st["processed_pos"]:]
                             continue
@@ -2756,7 +2785,11 @@ class ApiServer:
                 st = _stream_state
                 remaining = full_text[st["processed_pos"]:]
                 if remaining.strip() and st["mode"] == "text":
-                    await _write_sse({"type": "text_delta", "content": remaining})
+                    # 如果剩余文本较长，逐 token 推送以保持流式体验
+                    if len(remaining) > 20:
+                        await _stream_text_chunked(remaining, _write_sse, chunk_size=3, delay=0.01)
+                    else:
+                        await _write_sse({"type": "text_delta", "content": remaining})
                     st["processed_pos"] = len(full_text)
 
             # Call LLM with streaming — tokens are filtered through _text_delta_callback
@@ -2825,6 +2858,8 @@ class ApiServer:
                     )
                 continue  # Next iteration — let LLM process tool results
 
+            # 注意：成功处理 tool_calls 或 actions 后，_consecutive_no_action 会被重置
+
             # ── 从混合内容中提取 JSON action 指令 ──
             # 支持格式：
             #   1. 纯 JSON（向后兼容）
@@ -2945,6 +2980,7 @@ class ApiServer:
 
                     # Continue the loop — let LLM decide next step based on execution results
                     # tasklist 已在循环顶部 LLM 调用后提取并推送，此处无需重复
+                    _consecutive_no_action = 0  # 成功执行 action，重置无 action 计数
 
                     continue
 
@@ -2956,10 +2992,66 @@ class ApiServer:
                         await _stream_text_chunked(final_response, _write_sse)
                     break
 
-            # ── Pure text response (no actions/tool calls) — this is the final answer ──
+            # ── Pure text response (no actions/tool calls) ──
             # Content was already streamed token-by-token via _text_delta_callback
-            final_response = content
-            break
+
+            # ── 执行模式多轮续命机制 ──
+            # 问题：LLM 有时只输出文字总结而不输出 ```action``` 块，
+            # 导致循环在此处 break，任务未完成就停止。
+            # 修复：检查任务列表中是否还有未完成步骤，如果有则重新提示 LLM 继续。
+            if chat_mode == "exec":
+                current_tasks = self._task_list_store.get(agent_path, [])
+                pending_count = sum(
+                    1 for t in current_tasks
+                    if t.get("status") in ("pending", "running", "blocked")
+                )
+                if pending_count > 0 and _consecutive_no_action < _MAX_NO_ACTION_RETRIES and iteration < max_iter - 1:
+                    # 还有未完成任务，LLM 忘记了输出 action 块，重新提示
+                    _consecutive_no_action += 1
+                    logger.info(
+                        f"[{session_id}] Exec 模式: LLM 未输出 action，"
+                        f"重新提示继续执行 ({_consecutive_no_action}/{_MAX_NO_ACTION_RETRIES})"
+                    )
+                    context.conversation_history.append(
+                        Message(role="assistant", content=content)
+                    )
+                    context.conversation_history.append(
+                        Message(
+                            role="user",
+                            content=(
+                                f"[系统提示] 任务尚未完成，仍有 {pending_count} 个未执行步骤。"
+                                "你必须继续执行操作：用 ```action``` 代码块输出操作指令。"
+                                "不要只输出文字总结或反馈，必须输出具体的操作命令。"
+                            ),
+                        )
+                    )
+                    await _write_sse({
+                        "type": "thought",
+                        "content": (
+                            f"\n\n⏳ 检测到 {pending_count} 个未完成任务，"
+                            f"继续执行下一步操作..."
+                        ),
+                    })
+                    # 清除上一轮的流式输出，为下一轮腾出空间
+                    await _write_sse({"type": "clear_text"})
+                    continue
+                else:
+                    # 所有任务完成，或已达到重试上限
+                    if pending_count > 0 and _consecutive_no_action >= _MAX_NO_ACTION_RETRIES:
+                        logger.warning(
+                            f"[{session_id}] Exec 模式: 连续 {_MAX_NO_ACTION_RETRIES} 次"
+                            f"无 action 输出，强制结束循环"
+                        )
+                        # 在回复末尾追加提示
+                        final_response = content + (
+                            f"\n\n⚠️ 注意：仍有 {pending_count} 个任务未完成，"
+                            "但 Agent 已达到最大重试次数。你可以要求我继续完成这些任务。"
+                        )
+                    break
+            else:
+                # 非 exec 模式或无待办任务，正常结束
+                final_response = content
+                break
 
         # Save assistant response to memory
         if agent.memory and final_response:

package/web/ui/chat/chat_main.js

@@ -2582,6 +2582,7 @@ function insertQuick(text) {
 // ══════════════════════════════════════════════════════
 // ── TTS (Text-to-Speech) Manager ──
 // ══════════════════════════════════════════════════════
+// 支持分段流式播放：文本边生成边朗读，遇到句子边界立即合成播放
 
 // Simple hash function for text caching
 function simpleHash(str) {
@@ -2603,6 +2604,13 @@ const ttsManager = {
   cache: new Map(), // textHash -> blobUrl
   voice: 'zh-CN-XiaoxiaoNeural',
   speed: '+0%',
+  // ── 分段流式状态 ──
+  _streamActive: false,     // 是否正在流式模式
+  _streamBuffer: '',        // 当前缓冲区（积累到句子边界前）
+  _audioQueue: [],          // 待播放的音频 blobUrl 队列
+  _audioPlaying: false,     // 队列是否正在播放
+  _stopRequested: false,    // 是否已请求停止
+  _streamMsgIndex: -1,      // 流式模式对应的消息索引
 
   init() {
     // Load TTS enabled state from localStorage
@@ -2613,15 +2621,25 @@ const ttsManager = {
     this.updateButtonUI();
     // Audio event handlers
     this.audio.addEventListener('ended', () => {
-      this.isPlaying = false;
-      this.currentMsgIndex = -1;
-      this.updatePlayingIndicator();
+      if (this._streamActive) {
+        // 流式模式：播放队列下一段
+        this._playNextInQueue();
+      } else {
+        this.isPlaying = false;
+        this.currentMsgIndex = -1;
+        this.updatePlayingIndicator();
+      }
     });
     this.audio.addEventListener('error', (e) => {
       console.error('TTS audio error:', e);
-      this.isPlaying = false;
-      this.currentMsgIndex = -1;
-      this.updatePlayingIndicator();
+      if (this._streamActive) {
+        // 流式模式：跳过错误段，播放下一段
+        this._playNextInQueue();
+      } else {
+        this.isPlaying = false;
+        this.currentMsgIndex = -1;
+        this.updatePlayingIndicator();
+      }
     });
   },
 
@@ -2652,10 +2670,16 @@ const ttsManager = {
   },
 
   stop() {
+    this._stopRequested = true;
     this.audio.pause();
     this.audio.currentTime = 0;
     this.isPlaying = false;
     this.currentMsgIndex = -1;
+    this._streamActive = false;
+    this._streamBuffer = '';
+    this._audioQueue = [];
+    this._audioPlaying = false;
+    this._streamMsgIndex = -1;
     this.updatePlayingIndicator();
   },
 
@@ -2666,10 +2690,216 @@ const ttsManager = {
     }
   },
 
+  // ════════════════════════════════════════════
+  // ── 分段流式 TTS：text_delta 回调 ──
+  // ════════════════════════════════════════════
+
+  /**
+   * 开始流式 TTS 会话
+   * @param {number} msgIndex - 消息索引
+   */
+  _startStream(msgIndex) {
+    this._stopRequested = false;
+    this._streamActive = true;
+    this._streamBuffer = '';
+    this._audioQueue = [];
+    this._audioPlaying = false;
+    this._streamMsgIndex = msgIndex;
+    this.currentMsgIndex = msgIndex;
+    this.isPlaying = true;
+  },
+
+  /**
+   * 流式推送文本增量
+   * 在 flow_engine.js 的 text_delta 处理中调用
+   * 积累到句子边界时自动触发 TTS 合成
+   * @param {string} delta - 新增文本片段
+   */
+  streamDelta(delta) {
+    if (!this.enabled || !this._streamActive || this._stopRequested) return;
+    if (!delta || !delta.trim()) return;
+
+    this._streamBuffer += delta;
+
+    // 检测句子边界：中文句号/感叹号/问号，英文句号+空格，或换行
+    var boundaryPattern = /[。！？]|\.(?:\s|$)|\n/;
+    var boundaryIdx = -1;
+    for (var i = 0; i < this._streamBuffer.length; i++) {
+      if (boundaryPattern.test(this._streamBuffer[i])) {
+        boundaryIdx = i;
+        break;
+      }
+    }
+
+    // 还没到句子边界，但如果缓冲区已经很长（>200字），强制切分
+    if (boundaryIdx === -1 && this._streamBuffer.length > 200) {
+      // 在最后一个逗号或空格处切分
+      var lastComma = -1;
+      for (var j = 0; j < this._streamBuffer.length; j++) {
+        var ch = this._streamBuffer[j];
+        if (ch === '，' || ch === ',' || ch === '；' || ch === ';' || ch === ' ' || ch === ':') {
+          lastComma = j;
+        }
+      }
+      if (lastComma > 0) {
+        boundaryIdx = lastComma;
+      } else {
+        boundaryIdx = this._streamBuffer.length;
+      }
+    }
+
+    if (boundaryIdx !== -1) {
+      // 提取到边界的文本
+      var sentence = this._streamBuffer.substring(0, boundaryIdx + 1).trim();
+      this._streamBuffer = this._streamBuffer.substring(boundaryIdx + 1);
+
+      if (sentence) {
+        var cleanSentence = this._cleanForStreamTTS(sentence);
+        if (cleanSentence) {
+          this._enqueueTTS(cleanSentence);
+        }
+      }
+    }
+  },
+
+  /**
+   * 刷新剩余缓冲区（流结束时调用）
+   * 将 buffer 中剩余的文本立即合成
+   */
+  streamFlush() {
+    if (!this.enabled || !this._streamActive || this._stopRequested) return;
+    var remaining = this._streamBuffer.trim();
+    this._streamBuffer = '';
+    if (remaining) {
+      var cleanText = this._cleanForStreamTTS(remaining);
+      if (cleanText) {
+        this._enqueueTTS(cleanText);
+      }
+    }
+    // 标记流式阶段结束（队列播完后自动清理状态）
+    this._streamActive = false;
+  },
+
+  /**
+   * 清理文本用于流式 TTS（去 HTML/代码块/执行结果等）
+   */
+  _cleanForStreamTTS(text) {
+    // 去除代码块
+    text = text.replace(/```[\s\S]*?```/g, '');
+    // 去除执行结果标记
+    text = text.replace(/^\s*[✅❌⏰]\s*\[执行结果\].*/gm, '');
+    // 去除 HTML 标签
+    text = text.replace(/<svg[^>]*>[\s\S]*?<\/svg>/gi, '');
+    text = text.replace(/<img[^>]*>/gi, '');
+    text = text.replace(/<br\s*\/?>/gi, '\n');
+    text = text.replace(/<[^>]+>/g, '');
+    // 去除 emoji
+    text = text.replace(/[\u{1F300}-\u{1FAFF}]/gu, '');
+    text = text.replace(/[\u{2600}-\u{27BF}]/gu, '');
+    text = text.replace(/[\u{FE00}-\u{FE0F}]/gu, '');
+    text = text.replace(/[\u{200D}]/gu, '');
+    text = text.replace(/[\u{20E3}]/gu, '');
+    text = text.replace(/[\u{2300}-\u{23FF}]/gu, '');
+    text = text.replace(/[\u{2B50}-\u{2B55}]/gu, '');
+    text = text.replace(/[\u{203C}-\u{3299}]/gu, '');
+    text = text.replace(/[\u{E0020}-\u{E007F}]/gu, '');
+    text = text.replace(/[✅❌⚠️🔄⏰🔒💻🔍📁🧠🌐🛠👋🤖🎯💡🚀👍🎯📊📝🔊🔍💬📌✨✓✗→←↓↑⏹⬇⬆↩]/g, '');
+    // 去除多余换行
+    text = text.replace(/\n{2,}/g, '\n');
+    text = text.trim();
+    return text || null;
+  },
+
+  /**
+   * 将文本加入 TTS 合成队列（异步，不阻塞）
+   */
+  _enqueueTTS(text) {
+    if (this._stopRequested) return;
+    var self = this;
+
+    (async function() {
+      try {
+        var hash = simpleHash(text);
+        var blobUrl = self.cache.get(hash);
+
+        if (!blobUrl) {
+          var resp = await fetch('/api/tts', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              text: text,
+              voice: self.voice,
+              speed: self.speed,
+            }),
+          });
+
+          if (!resp.ok) {
+            var errData = await resp.json().catch(function() { return {}; });
+            throw new Error(errData.error || 'TTS 请求失败');
+          }
+
+          var blob = await resp.blob();
+          blobUrl = URL.createObjectURL(blob);
+          self.cache.set(hash, blobUrl);
+        }
+
+        if (!self._stopRequested) {
+          self._audioQueue.push(blobUrl);
+          // 如果还没开始播放队列，立即开始
+          if (!self._audioPlaying) {
+            self._playNextInQueue();
+          }
+        }
+      } catch (e) {
+        console.error('TTS stream chunk error:', e);
+      }
+    })();
+  },
+
+  /**
+   * 播放队列中的下一段音频
+   */
+  _playNextInQueue() {
+    if (this._stopRequested) {
+      this.isPlaying = false;
+      this._audioPlaying = false;
+      this.currentMsgIndex = -1;
+      this.updatePlayingIndicator();
+      return;
+    }
+
+    if (this._audioQueue.length === 0) {
+      // 队列空了，检查流式是否已结束
+      if (!this._streamActive) {
+        // 流结束且队列为空 → 播放完成
+        this.isPlaying = false;
+        this._audioPlaying = false;
+        this.currentMsgIndex = -1;
+        this.updatePlayingIndicator();
+      }
+      // 如果流还在继续，等待新的音频入队
+      return;
+    }
+
+    var blobUrl = this._audioQueue.shift();
+    this.audio.src = blobUrl;
+    this._audioPlaying = true;
+
+    var self = this;
+    this.audio.play().catch(function(e) {
+      console.error('TTS play queue error:', e);
+      self._playNextInQueue();
+    });
+  },
+
+  // ════════════════════════════════════════════
+  // ── 完整消息 TTS（非流式，兼容手动点击） ──
+  // ════════════════════════════════════════════
+
   async speak(msgIndex) {
     if (msgIndex < 0 || msgIndex >= state.messages.length) return;
     const msg = state.messages[msgIndex];
-    if (!msg || msg.role !== 'user' && !msg.content) return;
+    if (!msg || msg.role !== 'assistant' && !msg.content) return;
 
     // 跳过命令执行结果（以 [执行结果] 开头的消息）
     var rawText = msg.content.replace(/<[^>]+>/g, '');
@@ -2677,24 +2907,23 @@ const ttsManager = {
 
     // 去除 HTML 标签（msg.content 是 HTML 格式，SVG 图标等会被朗读）
     let text = msg.content
-      .replace(/<svg[^>]*>[\s\S]*?<\/svg>/gi, '')      // 移除 SVG 图标
-      .replace(/<img[^>]*>/gi, '[图片]')                   // 图片替换为文字
-      .replace(/<br\s*\/?>/gi, '\n')                       // <br> 转换为换行
-      .replace(/<[^>]+>/g, '')                              // 移除所有 HTML 标签
-      // emoji 和特殊符号过滤
-      .replace(/[\u{1F300}-\u{1FAFF}]/gu, '')            // 全部 Emoji 范围
-      .replace(/[\u{2600}-\u{27BF}]/gu, '')              // 杂项/装饰符号
-      .replace(/[\u{FE00}-\u{FE0F}]/gu, '')              // 变体选择符
-      .replace(/[\u{200D}]/gu, '')                          // ZWJ 零宽连接符
-      .replace(/[\u{20E3}]/gu, '')                          // 组合符号
-      .replace(/[\u{2300}-\u{23FF}]/gu, '')              // 技术符号
-      .replace(/[\u{2B50}-\u{2B55}]/gu, '')              // 星星等
-      .replace(/[\u{203C}-\u{3299}]/gu, '')              // CJK 符号
-      .replace(/[\u{E0020}-\u{E007F}]/gu, '')            // 标签
-      .replace(/[✅❌⚠️🔄⏰🔒💻🔍📁🧠🌐🛠️👋🤖🎯💡🚀👍🎯📊📝🔊🔍💬📌✨✓✗→←↓↑⏹⬇⬆↩]/g, '') // 常用图标
-      .replace(/```[\s\S]*?```/g, '代码块')               // 代码块替换为文字
-      .replace(/`[^`]+`/g, function(m) { return m.slice(1,-1); }) // 保留内联代码文字但去引号
-      .replace(/\n{2,}/g, '\n')                            // 多余换行
+      .replace(/<svg[^>]*>[\s\S]*?<\/svg>/gi, '')
+      .replace(/<img[^>]*>/gi, '[图片]')
+      .replace(/<br\s*\/?>/gi, '\n')
+      .replace(/<[^>]+>/g, '')
+      .replace(/[\u{1F300}-\u{1FAFF}]/gu, '')
+      .replace(/[\u{2600}-\u{27BF}]/gu, '')
+      .replace(/[\u{FE00}-\u{FE0F}]/gu, '')
+      .replace(/[\u{200D}]/gu, '')
+      .replace(/[\u{20E3}]/gu, '')
+      .replace(/[\u{2300}-\u{23FF}]/gu, '')
+      .replace(/[\u{2B50}-\u{2B55}]/gu, '')
+      .replace(/[\u{203C}-\u{3299}]/gu, '')
+      .replace(/[\u{E0020}-\u{E007F}]/gu, '')
+      .replace(/[✅❌⚠️🔄⏰🔒💻🔍📁🧠🌐🛠👋🤖🎯💡🚀👍🎯📊📝🔊🔍💬📌✨✓✗→←↓↑⏹⬇⬆↩]/g, '')
+      .replace(/```[\s\S]*?```/g, '代码块')
+      .replace(/`[^`]+`/g, function(m) { return m.slice(1,-1); })
+      .replace(/\n{2,}/g, '\n')
       .trim();
 
     if (!text) return;

package/web/ui/chat/flow_engine.js

@@ -1,3 +1,4 @@
+<string>:27: SyntaxWarning: invalid escape sequence '\s'
 // ══════════════════════════════════════════════════════
 // ── Flow Engine: 文本处理流引擎 ──
 // ── 负责消息发送、SSE 流式处理、大文本检测与分段、
@@ -738,6 +739,11 @@ async function sendMessage() {
             fullResponse += evt.content;
             state.messages[msgIdx].content = fullResponse;
             throttledStreamUpdate(msgIdx);
+            // ── 分段流式 TTS：推送增量文本 ──
+            if (ttsManager.enabled && !ttsManager._streamActive) {
+              ttsManager._startStream(msgIdx);
+            }
+            ttsManager.streamDelta(evt.content);
           } else if (evt.type === 'thought_delta') {
             // Agent 思考过程增量文本（流式推送，单独显示）
             fullThought += evt.content;
@@ -843,10 +849,9 @@ async function sendMessage() {
     state.agentSessions[state.activeAgent] = [...state.sessions];
     renderSessions();
 
-    // Auto-play TTS if enabled (skip command execution results)
-    if (ttsManager.enabled && fullResponse && !fullResponse.match(/^\s*[✅❌⏰]\s*\[执行结果\]/m)) {
-      const idx = state.messages.length - 1;
-      ttsManager.speak(idx);
+    // ── 分段流式 TTS：刷新剩余缓冲区 ──
+    if (ttsManager.enabled && ttsManager._streamActive) {
+      ttsManager.streamFlush();
     }
   } catch (e) {
     if (e.name === 'AbortError') {