myagent-ai 1.23.37 → 1.23.38

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)

package/executor/engine.py

@@ -221,6 +221,8 @@ 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
 
         # 安全: 合并正则模式 + 字符串黑名单
         self._blocked = set(self.DANGEROUS_COMMANDS)
@@ -606,6 +608,7 @@ class ExecutionEngine:
                 cwd=work_dir,
                 env=self._get_env(env),
             )
+            self._current_process = process  # [v1.23.37] 保存引用
 
             try:
                 # 使用流式读取代替 communicate()，确保超时后能保留已产生的输出
@@ -747,6 +750,7 @@ class ExecutionEngine:
                 cwd=work_dir,
                 env=self._get_env(env),
             )
+            self._current_process = process  # [v1.23.37] 保存引用
 
             # 使用流式读取代替 communicate()，确保超时后能保留已产生的输出
             stdout_chunks = []
@@ -948,6 +952,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 +994,26 @@ class ExecutionEngine:
                 metadata={"mode": "sandbox"},
             )
 
+    # [v1.23.37] ── 取消当前执行 ──
+
+    def cancel_current(self):
+        """终止当前正在运行的子进程（由 /api/chat/stop 调用）"""
+        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.38",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

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 共享状态）"""
@@ -2210,10 +2216,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 +2251,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();
   }