myagent-ai 1.23.38 → 1.23.40

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

@@ -1569,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)} 个工具结果已收集）"
@@ -1606,9 +1614,9 @@ class MainAgent(BaseAgent):
                 _tp.initialize()
                 _tp.save_task(
                     task_id=task_id,
-                    description=context.user_input or "未完成任务",
+                    description=context.user_message or "未完成任务",
                     session_id=context.session_id or "",
-                    agent_path=context.agent_path or "",
+                    agent_path=context.metadata.get("agent_path", "") or "",
                     status="pending",
                     metadata={"iterations": self._iteration_count, "reason": "达到最大迭代次数"},
                     last_message=f"达到最大迭代次数 {max_iter}，共执行 {self._iteration_count} 次",
@@ -1662,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

@@ -223,6 +223,8 @@ class ExecutionEngine:
         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)
@@ -508,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(
@@ -623,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 的读取任务
@@ -636,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()
@@ -670,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")
@@ -998,6 +1042,7 @@ class ExecutionEngine:
 
     def cancel_current(self):
         """终止当前正在运行的子进程（由 /api/chat/stop 调用）"""
+        self._cancelled = True  # [v1.23.38] 设置取消标志
         proc = self._current_process
         if proc is None:
             return False

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.23.38",
+  "version": "1.23.40",
   "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

@@ -2175,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)