myagent-ai 1.9.7 → 1.9.9

package/agents/main_agent.py

@@ -551,20 +551,20 @@ class MainAgent(BaseAgent):
                 )
 
             # Step 9: 处理 askuser（askuser 非空时，finish 必为 true）
-            if parsed.askuser:
-                logger.info(f"[{task_id}] 需要询问用户: {parsed.askuser[:100]}")
-                context.working_memory["final_response"] = parsed.askuser
-                context.working_memory["ask_user"] = parsed.askuser
+            if parsed.ask_user:
+                logger.info(f"[{task_id}] 需要询问用户: {parsed.ask_user[:100]}")
+                context.working_memory["final_response"] = parsed.ask_user
+                context.working_memory["ask_user"] = parsed.ask_user
                 await self._emit_v2_event(
                     "v2_ask_user",
-                    {"question": parsed.askuser},
+                    {"question": parsed.ask_user},
                     stream_callback,
                 )
                 if self.memory:
                     self.memory.add_short_term(
                         session_id=context.session_id,
                         role="assistant",
-                        content=parsed.askuser,
+                        content=parsed.ask_user,
                     )
                 break
 

package/main.py

@@ -1460,6 +1460,8 @@ def main():
     parser.add_argument("--tray", action="store_true", help="以系统托盘模式运行")
     parser.add_argument("--web", type=int, nargs="?", const=8767, default=None,
                         help="启动管理后台 Web UI (可选端口，默认8767)")
+    parser.add_argument("--server", action="store_true", help="API 服务模式 (等同于 --web，绑定 0.0.0.0)")
+    parser.add_argument("--host", type=str, default=None, help="Web UI 绑定地址 (默认 127.0.0.1，容器部署用 0.0.0.0)")
     parser.add_argument("--port", type=int, default=8767, help="Web UI 端口")
     parser.add_argument("--autostart", action="store_true", help="设置开机自启")
     parser.add_argument("--no-autostart", action="store_true", help="取消开机自启")
@@ -1492,7 +1494,13 @@ def main():
     # ══════════════════════════════════════════════════════════
     # 首次运行: 引导配置 LLM API Key
     # ══════════════════════════════════════════════════════════
+    # --server 等同于 --web，但默认绑定 0.0.0.0（用于容器/Docker 部署）
+    if args.server and not args.web:
+        args.web = args.port
+    if args.server and not args.host:
+        args.host = "0.0.0.0"
     web_port = args.web if args.web else args.port if args.tray else None
+    web_host = args.host or "127.0.0.1"
     if not web_port:
         # 仅 CLI 模式才用命令行配置向导
         # Web 模式下由 chat.html 的 Web 向导处理 (检测 /api/setup/status)
@@ -1525,7 +1533,7 @@ def main():
         if web_port:
             from web.api_server import ApiServer
             api_server = ApiServer(app)
-            await api_server.start(port=web_port)
+            await api_server.start(port=web_port, host=web_host)
             app.logger.info(f"管理后台: http://127.0.0.1:{web_port}/ui/")
 
             # 非 tray 模式（纯 web 模式）自动打开浏览器
@@ -1582,7 +1590,7 @@ def main():
                             if web_port:
                                 from web.api_server import ApiServer
                                 api_server = ApiServer(app)
-                                await api_server.start(port=web_port)
+                                await api_server.start(port=web_port, host=web_host)
                             if app.chat_manager:
                                 asyncio.create_task(app.chat_manager.start_all())
                             app._running_service = True
@@ -1614,7 +1622,7 @@ def main():
                         if web_port:
                             from web.api_server import ApiServer
                             api_server = ApiServer(app)
-                            await api_server.start(port=web_port)
+                            await api_server.start(port=web_port, host=web_host)
                             app.logger.info(f"Web 服务已重启: http://127.0.0.1:{web_port}/ui/")
 
                         # 4. 启动聊天平台

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "myagent-ai",
-  "version": "1.9.7",
-  "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
+  "version": "1.9.9",
+  "description": "\u672c\u5730\u684c\u9762\u7aef\u6267\u884c\u578bAI\u52a9\u624b - Open Interpreter \u98ce\u683c | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {
     "myagent-ai": "start.js"
@@ -65,4 +65,4 @@
     "departments/",
     "web/"
   ]
-}
+}

package/web/api_server.py

@@ -1070,6 +1070,75 @@ class ApiServer:
             tasks.append({"text": text, "status": status})
         return tasks if tasks else None
 
+    def _parse_v2_task_plan(self, plan_text: str) -> list | None:
+        """将 V2 结构化输出的 Markdown 任务计划解析为 [{text, status}] 格式。
+
+        V2 的 task_plan 使用 Markdown 列表格式：
+          - [ ] 未完成任务        → pending
+          - [x] 已完成任务        → done
+          - [ ] 正在进行的任务     → running (如果含特定关键词)
+          - [ ] 受阻的任务         → blocked (如果含特定关键词)
+
+        同时支持有序列表（1. 2. 3.）和无序列表（- *），
+        以及混合格式如 [pending] [running] [done] 标签。
+
+        Returns:
+            list | None: 成功返回任务列表，失败返回 None
+        """
+        import re
+        if not plan_text or not plan_text.strip():
+            return None
+
+        tasks = []
+        lines = plan_text.strip().split('\n')
+
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+
+            text = ""
+            status = "pending"
+
+            # 格式1: - [x] 或 - [ ] (Markdown checkbox)
+            m = re.match(r'^[\-\*\d\.]+\s*\[([xX\s])\]\s*(.+)$', line)
+            if m:
+                checkbox = m.group(1).strip()
+                text = m.group(2).strip()
+                status = "done" if checkbox.lower() == 'x' else "pending"
+            else:
+                # 格式2: - [pending] / [running] / [done] / [blocked] 文本
+                m = re.match(r'^[\-\*\d\.]+\s*\[(pending|running|done|blocked)\]\s*(.+)$', line, re.IGNORECASE)
+                if m:
+                    status = m.group(1).lower()
+                    text = m.group(2).strip()
+                else:
+                    # 格式3: - 纯文本 或 数字. 纯文本（作为 pending）
+                    m = re.match(r'^[\-\*\d\.\)]+\s+(.+)$', line)
+                    if m:
+                        text = m.group(1).strip()
+                        # 跳过标题行（如 "## 任务计划"）
+                        if text.startswith('#'):
+                            continue
+                    else:
+                        # 跳过非列表行
+                        continue
+
+            if not text:
+                continue
+
+            # 智能检测状态关键词（即使没有 checkbox/标签）
+            if status == "pending":
+                lower_text = text.lower()
+                if any(kw in lower_text for kw in ['正在', '进行中', '执行中', '处理中']):
+                    status = "running"
+                elif any(kw in lower_text for kw in ['受阻', '阻塞', '等待', '暂停']):
+                    status = "blocked"
+
+            tasks.append({"text": text, "status": status})
+
+        return tasks if tasks else None
+
     def _merge_task_list(self, session_id: str, llm_task_list: list) -> list:
         """
         合并 LLM 输出的 tasklist 与服务端存储的现有任务状态。
@@ -1142,40 +1211,60 @@ class ApiServer:
         return merged
 
     async def handle_get_task_plan(self, request):
-        """GET /api/task-plan?agent=default - Get task list from memory."""
+        """GET /api/task-plan?agent=default&session=xxx - Get task list from memory.
+
+        优先使用 session_id 查找（与聊天流存储键一致），
+        回退到 agent_path 查找（手动创建的任务）。
+        """
         agent_path = request.query.get("agent", "default")
+        session_id = request.query.get("session", "")
+        # 优先按 session_id 查找（聊天流生成的任务列表存储在此键下）
+        if session_id:
+            tasks = self._task_list_store.get(session_id, [])
+            if tasks:
+                return web.json_response({"agent": agent_path, "session": session_id, "tasks": tasks})
+        # 回退按 agent_path 查找（手动添加的任务）
         tasks = self._task_list_store.get(agent_path, [])
-        return web.json_response({"agent": agent_path, "tasks": tasks})
+        return web.json_response({"agent": agent_path, "session": session_id, "tasks": tasks})
 
     async def handle_update_task_plan(self, request):
         """PUT /api/task-plan - Overwrite entire task list."""
         data = await request.json()
         agent_path = data.get("agent", "default")
+        session_id = data.get("session", "")
         tasks = data.get("tasks", [])
-        self._task_list_store[agent_path] = tasks
-        return web.json_response({"ok": True, "agent": agent_path, "tasks": tasks})
+        # 优先按 session_id 存储（与聊天流一致），回退到 agent_path
+        store_key = session_id or agent_path
+        self._task_list_store[store_key] = tasks
+        return web.json_response({"ok": True, "agent": agent_path, "session": session_id, "tasks": tasks})
 
     async def handle_add_task_item(self, request):
         """POST /api/task-plan - Add a new task item."""
         data = await request.json()
         agent_path = data.get("agent", "default")
+        session_id = data.get("session", "")
         text = data.get("text", "").strip()
         if not text:
             return web.json_response({"error": "text is required"}, status=400)
-        tasks = list(self._task_list_store.get(agent_path, []))
+        # 优先按 session_id 查找，回退到 agent_path
+        store_key = session_id or agent_path
+        tasks = list(self._task_list_store.get(store_key, []))
         tasks.append({"text": text, "status": "pending"})
-        self._task_list_store[agent_path] = tasks
-        return web.json_response({"ok": True, "tasks": tasks, "added": len(tasks) - 1})
+        self._task_list_store[store_key] = tasks
+        return web.json_response({"ok": True, "tasks": tasks, "added": len(tasks) - 1, "session": session_id})
 
     async def handle_delete_task_item(self, request):
         """DELETE /api/task-plan/{idx} - Delete task by index."""
         idx = int(request.match_info["idx"])
         agent_path = request.query.get("agent", "default")
-        tasks = list(self._task_list_store.get(agent_path, []))
+        session_id = request.query.get("session", "")
+        # 优先按 session_id 查找，回退到 agent_path
+        store_key = session_id or agent_path
+        tasks = list(self._task_list_store.get(store_key, []))
         if 0 <= idx < len(tasks):
             tasks.pop(idx)
-        self._task_list_store[agent_path] = tasks
-        return web.json_response({"ok": True, "tasks": tasks})
+        self._task_list_store[store_key] = tasks
+        return web.json_response({"ok": True, "tasks": tasks, "session": session_id})
 
     async def handle_shutdown(self, request):
         self.core._running = False
@@ -3042,9 +3131,30 @@ class ApiServer:
 
             # 收集 V2 输出中的 reasoning 文本作为最终响应
             _v2_reasoning_parts = []
+            # V2 模式下追踪最新 task_plan（Markdown 格式）
+            _v2_latest_task_plan = ""
 
             async def _v2_collecting_callback(event: dict):
-                """收集 reasoning 内容，同时转发所有事件"""
+                """收集 reasoning 内容 + 同步 task_plan 到 _task_list_store，同时转发所有事件"""
+                # ── 拦截 v2_task_plan 事件：解析 Markdown 并同步到 _task_list_store ──
+                if event.get("type") == "v2_task_plan":
+                    nonlocal _v2_latest_task_plan
+                    plan_text = event.get("plan", "")
+                    if plan_text:
+                        _v2_latest_task_plan = plan_text
+                        # 解析 Markdown 任务列表为 [{text, status}] 格式
+                        parsed_tasks = self._parse_v2_task_plan(plan_text)
+                        if parsed_tasks:
+                            # 合并与存储
+                            merged = self._merge_task_list(session_id, parsed_tasks)
+                            self._task_list_store[session_id] = merged
+                            # 额外发送 task_list_update 事件（前端侧边栏 task panel 依赖此事件）
+                            try:
+                                await _write_sse({"type": "task_list_update", "tasks": merged})
+                            except Exception:
+                                pass
+
+                # 转发所有事件到前端
                 await _write_sse(event)
                 if event.get("type") == "v2_reasoning":
                     content = event.get("content", "")
@@ -3061,6 +3171,15 @@ class ApiServer:
                 stream_response=stream_response,
             )
 
+            # V2 结束后：如果 task_list_store 中有任务，确保最终推送一次
+            if chat_mode == "exec" and session_id in self._task_list_store:
+                final_tasks = self._task_list_store[session_id]
+                if final_tasks:
+                    try:
+                        await _write_sse({"type": "task_list_update", "tasks": final_tasks})
+                    except Exception:
+                        pass
+
             # 返回最终响应
             final_response = v2_context.working_memory.get("final_response", "")
             # 优先使用 v2_reasoning 流式推送的文本（用户实际看到的内容），
@@ -4724,7 +4843,7 @@ class ApiServer:
         ok = mgr.clear_messages(gid)
         return web.json_response({"ok": ok})
 
-    async def start(self, port: int = 8767):
+    async def start(self, port: int = 8767, host: str = "127.0.0.1"):
         # 加载禁用技能列表
         self._load_disabled_skills()
 
@@ -4744,9 +4863,9 @@ class ApiServer:
 
         self._runner = web.AppRunner(self.app)
         await self._runner.setup()
-        site = web.TCPSite(self._runner, "127.0.0.1", port)
+        site = web.TCPSite(self._runner, host, port)
         await site.start()
-        logger.info(f"管理后台: http://127.0.0.1:{port}/ui/")
+        logger.info(f"管理后台: http://{host}:{port}/ui/")
 
     async def stop(self):
         if self._runner: await self._runner.cleanup()

package/web/ui/chat/chat_main.js

@@ -582,7 +582,10 @@ function hasTaskListChanged() {
 async function loadTaskPlan() {
   try {
     var agent = state.activeAgent || 'default';
-    var data = await api('/api/task-plan?agent=' + encodeURIComponent(agent));
+    var session = state.activeSessionId || '';
+    var url = '/api/task-plan?agent=' + encodeURIComponent(agent);
+    if (session) url += '&session=' + encodeURIComponent(session);
+    var data = await api(url);
     state.taskItems = data.tasks || [];
     renderTaskList();
     // Auto-show and expand task panel if tasks exist
@@ -653,9 +656,10 @@ async function toggleTaskDone(idx) {
   }
   try {
     var agent = state.activeAgent || 'default';
+    var session = state.activeSessionId || '';
     await api('/api/task-plan', {
       method: 'PUT',
-      body: JSON.stringify({agent: agent, tasks: state.taskItems})
+      body: JSON.stringify({agent: agent, session: session, tasks: state.taskItems})
     });
     renderTaskList();
   } catch (e) {
@@ -677,9 +681,10 @@ async function addTaskItem() {
   input.value = '';
   try {
     var agent = state.activeAgent || 'default';
+    var session = state.activeSessionId || '';
     var data = await api('/api/task-plan', {
       method: 'POST',
-      body: JSON.stringify({agent: agent, text: text})
+      body: JSON.stringify({agent: agent, session: session, text: text})
     });
     state.taskItems = data.tasks || [];
     renderTaskList();
@@ -693,7 +698,10 @@ async function deleteTaskItem(idx) {
  if (idx < 0 || idx >= state.taskItems.length) return;
   try {
     var agent = state.activeAgent || 'default';
-    var data = await api('/api/task-plan/' + idx + '?agent=' + encodeURIComponent(agent), {
+    var session = state.activeSessionId || '';
+    var url = '/api/task-plan/' + idx + '?agent=' + encodeURIComponent(agent);
+    if (session) url += '&session=' + encodeURIComponent(session);
+    var data = await api(url, {
       method: 'DELETE'
     });
     state.taskItems = data.tasks || [];