myagent-ai 1.23.37 → 1.23.39

package/agents/base.py

@@ -371,6 +371,9 @@ class BaseAgent(ABC):
                 model=request_kwargs.get("model", self.llm.model),
                 reasoning=full_reasoning,
             )
+        except asyncio.CancelledError:
+            # [v1.23.38] 传播取消信号，不吞掉
+            raise
         except Exception as e:
             logger.error(f"LLM 流式调用失败: {e}")
             return LLMResponse(success=False, error=str(e))

package/agents/main_agent.py

@@ -215,6 +215,8 @@ class MainAgent(BaseAgent):
         self._exec_event_counter: int = 0
         # 活跃会话上下文追踪（用于消息注入）
         self.active_contexts: Dict[str, AgentContext] = {}
+        # [v1.23.37] 会话取消标志（由 api_server.handle_chat_stop 设置）
+        self._cancelled_sessions: set = set()
 
     def init_context_builder(self, memory_manager=None, skill_registry=None, knowledge_base_dir=None, context_window=None):
         """初始化 Context Builder（在系统启动后调用，注入依赖）"""
@@ -737,6 +739,14 @@ class MainAgent(BaseAgent):
             logger.info(f"[{task_id}] V2 迭代 {self._iteration_count}/{max_iter}")
             _emitted_reasoning_this_iter = False  # [v1.15.8] 本轮是否已发送过 v2_reasoning 事件（防 TTS 重复）
 
+            # [v1.23.37] 检查是否收到停止信号
+            if context.session_id in self._cancelled_sessions:
+                logger.info(f"[{task_id}] 收到停止信号，终止执行循环")
+                context.working_memory["final_response"] = "⏹️ 任务已被用户停止"
+                await self._emit_v2_event("v2_stopped", {"reason": "用户手动停止"}, stream_callback)
+                self._cancelled_sessions.discard(context.session_id)
+                break
+
             # ── 检查配置热加载广播 ──
             if self.config_broadcaster:
                 reloaded, reload_type = await self.config_broadcaster.check_and_wait(task_id)
@@ -1559,6 +1569,14 @@ class MainAgent(BaseAgent):
 
             all_tool_outputs = "\n".join(tool_outputs_parts)
 
+            # [v1.23.38] 工具执行完毕后检查取消信号
+            if context.session_id in self._cancelled_sessions:
+                logger.info(f"[{task_id}] 收到停止信号，跳过 LLM 回调")
+                context.working_memory["final_response"] = "⏹️ 任务已被用户停止"
+                await self._emit_v2_event("v2_stopped", {"reason": "用户手动停止"}, stream_callback)
+                self._cancelled_sessions.discard(context.session_id)
+                break
+
             # Step 12: 有工具执行完毕 → 统一回调 LLM（不再根据 finish 标签判断）
             # 所有工具结果已收集到 all_tool_outputs（或任一超时提前收集），直接喂回 LLM 继续执行
             _timeout_info = "（有工具超时，已停止剩余工具）" if _has_timeout else f"（{len(tool_outputs_parts)} 个工具结果已收集）"
@@ -1652,8 +1670,12 @@ class MainAgent(BaseAgent):
         """[v1.22.0] V2 工具执行 — 统一分发到 ToolDispatcher"""
         try:
             import json as _json
+            import html as _html
             try:
-                params = _json.loads(parms_str) if parms_str else {}
+                # [v1.23.38] 防御性修复: 解码 HTML 实体 (& → & 等)
+                # LLM 可能在 XML 输出中使用 & 代替 &，导致 bash 命令失败
+                _clean_parms = _html.unescape(parms_str) if parms_str else ""
+                params = _json.loads(_clean_parms) if _clean_parms else {}
             except (_json.JSONDecodeError, TypeError):
                 params = {"raw_input": parms_str}
 

package/core/output_parser.py

@@ -48,6 +48,7 @@ Fault-tolerance features:
 
 from __future__ import annotations
 
+import html
 import re
 from dataclasses import dataclass, field
 from typing import Any, Dict, List
@@ -227,7 +228,7 @@ def _extract_tag_content(text: str, tag_name: str, stop_tags: List[str] | None =
         re.DOTALL | re.IGNORECASE,
     )
     if m:
-        return m.group(1)
+        return html.unescape(m.group(1))
 
     # Conservative mode: only extract properly closed tags, skip all fallbacks
     if conservative:
@@ -251,7 +252,7 @@ def _extract_tag_content(text: str, tag_name: str, stop_tags: List[str] | None =
         re.DOTALL | re.IGNORECASE,
     )
     if m:
-        return m.group(1)
+        return html.unescape(m.group(1))
 
     # Strategy 3: Self-closing <tag/> or <tag />
     m = re.search(rf"<{tag_esc}[^>]*/\s*>", text, re.IGNORECASE)
@@ -268,7 +269,7 @@ def _extract_tag_content(text: str, tag_name: str, stop_tags: List[str] | None =
         content = m.group(1).strip()
         # Only return if there's actual content (not just whitespace)
         if content:
-            return content
+            return html.unescape(content)
 
     return ""
 
@@ -300,7 +301,7 @@ def _extract_all_tag_blocks(
         re.DOTALL | re.IGNORECASE,
     )
     if properly_closed:
-        return properly_closed
+        return [html.unescape(b) for b in properly_closed]
 
     # Conservative mode: only extract properly closed blocks
     if conservative:
@@ -326,7 +327,7 @@ def _extract_all_tag_blocks(
         else:
             content_end = len(text)
 
-        blocks.append(text[content_start:content_end])
+        blocks.append(html.unescape(text[content_start:content_end]))
 
     return blocks
 

package/executor/engine.py

@@ -221,6 +221,10 @@ class ExecutionEngine:
         self.work_dir = work_dir or os.getcwd()
         self._permission_checker = permission_checker  # callable(perm_name) -> bool
         self._agent_name = agent_name
+        # [v1.23.37] 当前正在运行的子进程引用，用于 cancel_current() 终止
+        self._current_process: Optional[asyncio.subprocess.Process] = None
+        # [v1.23.38] 取消标志，用于在长等待中响应停止请求
+        self._cancelled = False
 
         # 安全: 合并正则模式 + 字符串黑名单
         self._blocked = set(self.DANGEROUS_COMMANDS)
@@ -506,6 +510,9 @@ class ExecutionEngine:
         work_dir = work_dir or self.work_dir
         metadata = metadata or {}
 
+        # [v1.23.38] 每次执行前重置取消标志
+        self._cancelled = False
+
         # 权限检查: execution 权限
         if not self._check_permission("execution"):
             return ExecResult(
@@ -606,6 +613,7 @@ class ExecutionEngine:
                 cwd=work_dir,
                 env=self._get_env(env),
             )
+            self._current_process = process  # [v1.23.37] 保存引用
 
             try:
                 # 使用流式读取代替 communicate()，确保超时后能保留已产生的输出
@@ -620,7 +628,10 @@ class ExecutionEngine:
                             if not chunk:
                                 break
                             chunks.append(chunk)
-                    except (asyncio.CancelledError, Exception):
+                    except asyncio.CancelledError:
+                        # [v1.23.38] 传播取消信号，不再吞掉
+                        raise
+                    except Exception:
                         pass
 
                 # 同时启动 stdout 和 stderr 的读取任务
@@ -633,28 +644,63 @@ class ExecutionEngine:
 
                 timed_out = False
                 try:
-                    # 等待进程结束，同时流式收集输出
-                    done, pending = await asyncio.wait(
-                        [
-                            asyncio.ensure_future(process.wait()),
-                            stdout_task,
-                            stderr_task,
-                        ],
-                        timeout=timeout,
-                    )
-                    if pending:
-                        # 超时发生
-                        timed_out = True
-                        for t in pending:
-                            t.cancel()
-                        try:
-                            process.kill()
-                        except ProcessLookupError:
-                            pass
-                        # 等待取消完成，获取已缓冲的数据
-                        await asyncio.gather(*pending, return_exceptions=True)
-
-                except Exception:
+                    # [v1.23.38] 使用短间隔轮询，确保取消信号能及时响应
+                    wait_timeout = min(timeout, 3.0)  # 每3秒检查一次取消标志
+                    remaining = timeout
+                    while True:
+                        if self._cancelled:
+                            # 收到停止信号，终止进程
+                            try:
+                                process.kill()
+                            except ProcessLookupError:
+                                pass
+                            for t in [stdout_task, stderr_task]:
+                                if not t.done():
+                                    t.cancel()
+                            await asyncio.gather(
+                                stdout_task, stderr_task,
+                                return_exceptions=True,
+                            )
+                            elapsed = asyncio.get_event_loop().time() - start_time
+                            stdout_str = b"".join(stdout_chunks).decode("utf-8", errors="replace")
+                            stderr_str = b"".join(stderr_chunks).decode("utf-8", errors="replace")
+                            logger.info(f"[executor] 执行被用户停止 (elapsed={elapsed:.1f}s)")
+                            return ExecResult(
+                                success=False,
+                                output=stdout_str,
+                                error="执行被用户停止",
+                                execution_time=elapsed,
+                                metadata={"cancelled": True},
+                            )
+                        done, pending = await asyncio.wait(
+                            [
+                                asyncio.ensure_future(process.wait()),
+                                stdout_task,
+                                stderr_task,
+                            ],
+                            timeout=wait_timeout,
+                        )
+                        if process.returncode is not None:
+                            # 进程已结束
+                            if pending:
+                                for t in pending:
+                                    t.cancel()
+                                await asyncio.gather(*pending, return_exceptions=True)
+                            break
+                        remaining -= wait_timeout
+                        if remaining <= 0:
+                            # 超时
+                            timed_out = True
+                            for t in pending:
+                                t.cancel()
+                            try:
+                                process.kill()
+                            except ProcessLookupError:
+                                pass
+                            await asyncio.gather(*pending, return_exceptions=True)
+                            break
+                except asyncio.CancelledError:
+                    # [v1.23.38] asyncio.Task 被取消时传播
                     timed_out = True
                     try:
                         process.kill()
@@ -667,6 +713,7 @@ class ExecutionEngine:
                         stdout_task, stderr_task,
                         return_exceptions=True,
                     )
+                    raise
 
                 elapsed = asyncio.get_event_loop().time() - start_time
                 stdout_str = b"".join(stdout_chunks).decode("utf-8", errors="replace")
@@ -747,6 +794,7 @@ class ExecutionEngine:
                 cwd=work_dir,
                 env=self._get_env(env),
             )
+            self._current_process = process  # [v1.23.37] 保存引用
 
             # 使用流式读取代替 communicate()，确保超时后能保留已产生的输出
             stdout_chunks = []
@@ -948,6 +996,7 @@ class ExecutionEngine:
                 cwd=work_dir,
                 env=self._get_env(env),
             )
+            self._current_process = process  # [v1.23.37] 保存引用
             try:
                 stdout, stderr = await asyncio.wait_for(
                     process.communicate(), timeout=timeout
@@ -989,6 +1038,27 @@ class ExecutionEngine:
                 metadata={"mode": "sandbox"},
             )
 
+    # [v1.23.37] ── 取消当前执行 ──
+
+    def cancel_current(self):
+        """终止当前正在运行的子进程（由 /api/chat/stop 调用）"""
+        self._cancelled = True  # [v1.23.38] 设置取消标志
+        proc = self._current_process
+        if proc is None:
+            return False
+        try:
+            if proc.returncode is None:  # 进程仍在运行
+                proc.kill()
+                logger.info(f"[executor] 已终止子进程 PID={proc.pid}")
+                self._current_process = None
+                return True
+        except ProcessLookupError:
+            pass  # 进程已结束
+        except Exception as e:
+            logger.debug(f"[executor] 终止子进程失败: {e}")
+        self._current_process = None
+        return False
+
     def set_execution_mode(self, mode: str) -> bool:
         """切换执行模式。返回是否切换成功。"""
         if mode not in ("local", "sandbox"):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.23.37",
+  "version": "1.23.39",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {
@@ -43,4 +43,4 @@
     "python": ">=3.10",
     "node": ">=18"
   }
-}
+}

package/web/api_server.py

@@ -406,6 +406,8 @@ class ApiServer:
         r.add_post("/api/chat", self.handle_chat)
         r.add_post("/api/chat/stream", self.handle_chat_stream)
         r.add_post("/api/chat/inject", self.handle_chat_inject)
+        # [v1.23.37] 停止执行
+        r.add_post("/api/chat/stop", self.handle_chat_stop)
         r.add_post("/api/voice-optimize", self.handle_voice_optimize)
         r.add_post("/api/voice-stt", self.handle_voice_stt)
         r.add_get("/chat", self.handle_chat_page)
@@ -1911,6 +1913,10 @@ window.addEventListener('beforeunload', function() {{
     # {session_id: {running: bool, started_at: float, result: str, done: bool, error: str}}
     _running_sessions: Dict[str, Dict] = {}
     _running_sessions_ttl = 300  # 过期时间（秒），用于自动清理已完成会话
+    # [v1.23.37] 存储后台 asyncio.Task 引用，用于取消执行
+    _running_tasks: Dict[str, asyncio.Task] = {}
+    # [v1.23.37] 会话取消标志，供 agent 执行循环检查
+    _session_cancelled: Dict[str, bool] = {}
 
     async def _get_session_lock(self, session_id: str) -> asyncio.Lock:
         """获取或创建会话级锁（每个 session_id 一个锁，防并发覆盖 MainAgent 共享状态）"""
@@ -2169,6 +2175,15 @@ window.addEventListener('beforeunload', function() {{
                     result_store["done"] = True
                     await safe_write({"type": "done", "exec_events": exec_events_q, "session_id": session_id})
 
+            except asyncio.CancelledError:
+                # [v1.23.38] 任务被取消（用户点击停止），清理资源
+                logger.info(f"[{session_id}] 后台流式任务被取消")
+                result_store["done"] = True
+                result_store["cancelled"] = True
+                try:
+                    await safe_write({"type": "stopped", "session_id": session_id})
+                except Exception:
+                    pass
             except Exception as e:
                 logger.error(f"[{session_id}] 后台流式任务异常: {e}", exc_info=True)
                 result_store["error"] = str(e)
@@ -2210,10 +2225,15 @@ window.addEventListener('beforeunload', function() {{
                     session_lock.release()
                 except RuntimeError:
                     pass
+                # [v1.23.37] 清理任务引用和取消标志
+                self._running_tasks.pop(session_id, None)
+                self._session_cancelled.pop(session_id, None)
 
         # ── 启动后台任务（不等它完成，前端断开也不影响） ──
         logger.info(f"[{session_id}] 准备创建后台任务")
         bg_task = asyncio.create_task(_run_stream_task())
+        self._running_tasks[session_id] = bg_task  # [v1.23.37] 保存引用用于取消
+        self._session_cancelled[session_id] = False  # [v1.23.37] 初始化取消标志
         logger.info(f"[{session_id}] 后台任务已创建: {bg_task}")
 
         # ── SSE 事件循环：实时转发后台任务的事件到客户端 ──
@@ -2240,6 +2260,56 @@ window.addEventListener('beforeunload', function() {{
 
         return response
 
+    # [v1.23.37] ── 停止执行 ──
+
+    async def handle_chat_stop(self, request):
+        """POST /api/chat/stop - 停止正在执行的任务
+
+        停止链：前端 abort → 调用此 API → 设置取消标志 + cancel task
+        → agent 循环检测到取消标志 → 退出循环 → 任务结束
+        """
+        try:
+            data = await request.json()
+        except Exception:
+            return web.json_response({"error": "invalid JSON"}, status=400)
+
+        session_id = data.get("session_id", "")
+        if not session_id:
+            return web.json_response({"ok": False, "error": "missing session_id"})
+
+        logger.info(f"[{session_id}] 收到停止执行请求")
+
+        # 1. 设置取消标志（agent 循环会检查）
+        self._session_cancelled[session_id] = True
+
+        # 1.5 设置 MainAgent 上的取消标志（agent 循环会检查 _cancelled_sessions）
+        if self.core.main_agent:
+            self.core.main_agent._cancelled_sessions.add(session_id)
+
+        # 2. 尝试取消 asyncio.Task
+        task = self._running_tasks.get(session_id)
+        cancelled = False
+        if task and not task.done():
+            task.cancel()
+            cancelled = True
+            logger.info(f"[{session_id}] 已发送 task.cancel()")
+
+        # 3. 更新会话状态
+        sess = self._running_sessions.get(session_id)
+        if sess and sess.get("running"):
+            sess["running"] = False
+            sess["done"] = True
+            sess["cancelled"] = True
+
+        # 4. 尝试终止正在运行的子进程（如果 executor 正在执行命令）
+        try:
+            if hasattr(self.core, 'executor') and self.core.executor:
+                self.core.executor.cancel_current()
+        except Exception as e:
+            logger.debug(f"[{session_id}] executor 取消失败: {e}")
+
+        return web.json_response({"ok": True, "cancelled": cancelled})
+
     async def handle_chat_inject(self, request):
         """POST /api/chat/inject - 注入消息到正在执行的任务，或进入排队序列"""
         try:

package/web/ui/chat/flow_engine.js

@@ -2392,6 +2392,16 @@ async function sendMessage(opts) {
 
 // ── Stop Generation ──
 function stopGenerating() {
+  // [v1.23.37] 告知后端停止执行（kill subprocess + 设置取消标志）
+  var sid = state.activeSessionId || '';
+  if (sid) {
+    fetch('/api/chat/stop', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ session_id: sid }),
+    }).catch(function() {});
+  }
+  // 中断前端 SSE 连接
   if (state.abortController) {
     state.abortController.abort();
   }