myagent-ai 1.8.0 → 1.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/web/api_server.py

@@ -153,7 +153,7 @@ class ApiServer:
         # 消息队列（用于存放待执行的消息，key: session_id）
         self._msg_queues: Dict[str, List[Dict]] = {}
         # 任务列表内存存储（exec 模式，替代 task.md）
-        self._task_list_store: dict[str, list] = {}  # agent_path -> [{text, status}]
+        self._task_list_store: dict[str, list] = {}  # session_id -> [{text, status}]  (per-session, not per-agent)
         self._setup_routes()
         self._runner: Optional[web.AppRunner] = None
 
@@ -264,9 +264,13 @@ class ApiServer:
         # ── 会话管理 ──
         r.add_get("/api/sessions", self.handle_list_sessions)
         r.add_get("/api/sessions/{sid}/messages", self.handle_get_messages)
+        r.add_get("/api/session/messages", self.handle_get_messages_query)  # query param version (supports / in sid)
         r.add_delete("/api/sessions/{sid}", self.handle_delete_session)
+        r.add_delete("/api/session", self.handle_delete_session_query)  # query param version
         r.add_delete("/api/sessions/{sid}/messages", self.handle_clear_session_messages)
+        r.add_delete("/api/session/messages", self.handle_clear_session_messages_query)  # query param version
         r.add_put("/api/sessions/{sid}/rename", self.handle_rename_session)
+        r.add_put("/api/session/rename", self.handle_rename_session_query)  # query param version
         r.add_get("/api/memory/stats", self.handle_memory_stats)
         r.add_get("/api/memory/search", self.handle_memory_search)
         r.add_get("/api/memory/long-term", self.handle_list_long_term)
@@ -491,7 +495,7 @@ class ApiServer:
             clean_message, agent_system_prompt = self._build_agent_chat_context(agent_path, agent_cfg, message)
 
             # ── 执行模式: 将任务规划上下文注入到 system_prompt（而非用户消息）──
-            task_plan_context = self._build_task_plan_context(agent_path, chat_mode, message)
+            task_plan_context = self._build_task_plan_context(agent_path, chat_mode, message, session_id=session_id)
             if task_plan_context:
                 agent_system_prompt += "\n\n## 任务规划\n" + task_plan_context
 
@@ -518,7 +522,7 @@ class ApiServer:
                 try:
                     tl = self._extract_task_list_json(response)
                     if tl is not None:
-                        self._task_list_store[agent_path] = tl
+                        self._task_list_store[session_id] = tl
                 except Exception as tp_err:
                     logger.warning(f"任务列表更新失败: {tp_err}")
 
@@ -589,7 +593,7 @@ class ApiServer:
             model_chain = self._build_model_chain(agent_cfg, agent_path)
 
             # Build context with task plan injection into system_prompt (NOT user message)
-            task_plan_context = self._build_task_plan_context(agent_path, chat_mode, message)
+            task_plan_context = self._build_task_plan_context(agent_path, chat_mode, message, session_id=session_id)
             clean_message, agent_system_prompt = self._build_agent_chat_context(agent_path, agent_cfg, message)
             if task_plan_context:
                 agent_system_prompt += "\n\n## 任务规划\n" + task_plan_context
@@ -627,7 +631,7 @@ class ApiServer:
                 try:
                     tl = self._extract_task_list_json(full_response)
                     if tl is not None:
-                        self._task_list_store[agent_path] = tl
+                        self._task_list_store[session_id] = tl
                         await response.write(("data: " + json.dumps({"type": "task_list_update", "tasks": tl}) + "\n\n").encode())
                 except Exception:
                     pass
@@ -678,7 +682,26 @@ class ApiServer:
 
         except Exception as e:
             logger.error(f"Stream chat error: {e}", exc_info=True)
-            await response.write(("data: " + json.dumps({"type": "error", "error": str(e)}) + "\n\n").encode())
+            # ── 兜底保存：流式输出被中断时，确保已推送的内容不丢失 ──
+            # 场景：用户在流式输出过程中刷新页面，SSE 连接断开，_stream_process_message
+            # 中的保存逻辑未执行，导致 user 消息在但 assistant 消息丢失
+            try:
+                if self.core.memory and session_id:
+                    # 检查最后一条消息是否为 user（说明 assistant 回复未保存）
+                    conv = self.core.memory.get_conversation(session_id, limit=5)
+                    if conv and conv[-1].role == "user":
+                        logger.info(f"[{session_id}] 流式中断兜底保存：补充一条中断提示")
+                        self.core.memory.add_short_term(
+                            session_id=session_id,
+                            role="assistant",
+                            content="⚠️ [连接中断] 上次回复因页面刷新被中断，部分内容可能丢失。请重新发送指令继续。",
+                        )
+            except Exception as save_err:
+                logger.warning(f"兜底保存失败: {save_err}")
+            try:
+                await response.write(("data: " + json.dumps({"type": "error", "error": str(e)}) + "\n\n").encode())
+            except Exception:
+                pass
         finally:
             # Release execution lock
             if needs_lock_check and self._execution_lock["locked_by"] == agent_path:
@@ -740,7 +763,7 @@ class ApiServer:
 
         return response
 
-    def _build_task_plan_context(self, agent_path: str, chat_mode: str, original_message: str) -> str:
+    def _build_task_plan_context(self, agent_path: str, chat_mode: str, original_message: str, session_id: str = "") -> str:
         """构建任务规划上下文（仅 exec 模式，注入到 system_prompt 中）"""
         if chat_mode != "exec":
             return ""
@@ -757,10 +780,12 @@ class ApiServer:
             "   - 执行完一个操作后停下来，等待结果反馈后再决定下一步\n"
             "   - 不要一次性执行多个操作\n"
             "3. **回复格式**：先写纯文本分析/总结 → 再写 ```tasklist``` 更新进度 → 最后写 ```action``` 执行操作（如有）\n"
+            "4. **任务完成**：当所有步骤都标记为 done 时，用 ```action``` 输出 {\"type\": \"final_answer\", \"content\": \"...\"} 结束任务。\n"
         )
 
-        # 从内存读取当前任务列表
-        tasks = self._task_list_store.get(agent_path, [])
+        # 从内存读取当前任务列表（按 session 隔离）
+        store_key = session_id or agent_path
+        tasks = self._task_list_store.get(store_key, [])
         if not tasks:
             return base_instruction + "\n## 当前状态\n暂无任务计划。请先分析用户需求，拆分为具体步骤，然后用 ```tasklist``` 输出计划。"
 
@@ -768,6 +793,10 @@ class ApiServer:
         done = [f"  - ✅ {t['text']}" for t in tasks if t.get("status") == "done"]
         running = [f"  - 🔄 {t['text']}" for t in tasks if t.get("status") == "running"]
 
+        # 如果所有任务都已完成，不再注入任务上下文，让 LLM 自然回复
+        if not pending and not running:
+            return ""
+
         context = base_instruction + "\n## 当前任务进度\n"
         if done:
             context += "已完成:\n" + "\n".join(done) + "\n"
@@ -780,6 +809,7 @@ class ApiServer:
             "1. 用纯文本简要分析当前进展\n"
             "2. 用 ```tasklist``` 更新任务进度（标记已完成的步骤为 done，标记当前步骤为 running）\n"
             "3. 用 ```action``` 执行下一个待执行步骤（每次只执行一个操作）\n"
+            "4. 如果所有步骤已完成，用 {\"type\": \"final_answer\", \"content\": \"总结\"} 结束\n"
         )
         return context
 
@@ -1823,6 +1853,15 @@ class ApiServer:
         entries = self.core.memory.get_conversation(sid, limit=100)
         return web.json_response([{"role": e.role, "content": e.content, "time": e.created_at} for e in entries])
 
+    async def handle_get_messages_query(self, request):
+        """GET /api/session/messages?sid=... - 通过 query 参数获取会话消息（支持 session_id 中包含 /）"""
+        sid = request.query.get("sid", "")
+        if not sid:
+            return web.json_response([])
+        if not self.core.memory: return web.json_response([])
+        entries = self.core.memory.get_conversation(sid, limit=100)
+        return web.json_response([{"role": e.role, "content": e.content, "time": e.created_at} for e in entries])
+
     async def handle_delete_session(self, request):
         """DELETE /api/sessions/{sid} - 彻底删除会话（所有记忆）"""
         sid = request.match_info["sid"]
@@ -1832,6 +1871,17 @@ class ApiServer:
             logger.info(f"会话 {sid} 已删除，共清除 {count} 条记忆")
         return web.json_response({"ok": True, "deleted": True})
 
+    async def handle_delete_session_query(self, request):
+        """DELETE /api/session?sid=... - 通过 query 参数删除会话（支持 session_id 中包含 /）"""
+        sid = request.query.get("sid", "")
+        if not sid:
+            return web.json_response({"ok": False, "error": "missing sid"}, status=400)
+        logger.info(f"删除会话: {sid}")
+        if self.core.memory:
+            count = self.core.memory.delete_session(sid)
+            logger.info(f"会话 {sid} 已删除，共清除 {count} 条记忆")
+        return web.json_response({"ok": True, "deleted": True})
+
     async def handle_clear_session_messages(self, request):
         """DELETE /api/sessions/{sid}/messages - 仅清空会话对话历史（保留会话本身）"""
         sid = request.match_info["sid"]
@@ -1841,6 +1891,17 @@ class ApiServer:
             logger.info(f"会话 {sid} 消息已清空，共清除 {count} 条消息")
         return web.json_response({"ok": True, "cleared": True})
 
+    async def handle_clear_session_messages_query(self, request):
+        """DELETE /api/session/messages?sid=... - 通过 query 参数清空会话消息"""
+        sid = request.query.get("sid", "")
+        if not sid:
+            return web.json_response({"ok": False, "error": "missing sid"}, status=400)
+        logger.info(f"清空会话消息: {sid}")
+        if self.core.memory:
+            count = self.core.memory.clear_conversation(sid)
+            logger.info(f"会话 {sid} 消息已清空，共清除 {count} 条消息")
+        return web.json_response({"ok": True, "cleared": True})
+
     async def handle_rename_session(self, request):
         """PUT /api/sessions/{sid}/rename - 重命名会话"""
         sid = request.match_info["sid"]
@@ -1857,6 +1918,24 @@ class ApiServer:
             self.core.memory.rename_session(sid, new_name)
         return web.json_response({"ok": True, "name": new_name})
 
+    async def handle_rename_session_query(self, request):
+        """PUT /api/session/rename?sid=... - 通过 query 参数重命名会话"""
+        sid = request.query.get("sid", "")
+        if not sid:
+            return web.json_response({"ok": False, "error": "missing sid"}, status=400)
+        try:
+            body = await request.json()
+        except Exception:
+            body = {}
+        new_name = (body.get("name") or "").strip()
+        if not new_name:
+            return web.json_response({"ok": False, "error": "名称不能为空"}, status=400)
+        if len(new_name) > 100:
+            return web.json_response({"ok": False, "error": "名称不能超过100个字符"}, status=400)
+        if self.core.memory:
+            self.core.memory.rename_session(sid, new_name)
+        return web.json_response({"ok": True, "name": new_name})
+
     # --- Memory ---
     async def handle_memory_stats(self, request):
         return web.json_response(self.core.memory.get_stats() if self.core.memory else {})
@@ -2625,7 +2704,7 @@ class ApiServer:
         iteration = 0
         # 追踪连续无 action 迭代次数，防止无限重新提示
         _consecutive_no_action = 0
-        _MAX_NO_ACTION_RETRIES = 5  # 提高重试次数，给 LLM 更多机会完成剩余任务
+        _MAX_NO_ACTION_RETRIES = 2  # 限制重试次数，避免重复循环规划
         # ── 追踪所有流式推送的纯文本（用于刷新后恢复） ──
         _all_streamed_text_parts = []  # 每轮迭代推送的纯文本片段
 
@@ -2635,7 +2714,7 @@ class ApiServer:
             # ── 执行模式：每轮迭代前刷新任务进度上下文 ──
             # 这样 LLM 在每次调用时都能看到最新的任务列表状态
             if chat_mode == "exec":
-                fresh_task_context = self._build_task_plan_context(agent_path, chat_mode, user_message)
+                fresh_task_context = self._build_task_plan_context(agent_path, chat_mode, user_message, session_id=session_id)
                 if fresh_task_context:
                     # 替换掉之前的任务规划上下文（保留非任务规划部分）
                     base_prompt = context.metadata.get("agent_override_prompt", "")
@@ -2828,8 +2907,8 @@ class ApiServer:
             if chat_mode == "exec":
                 task_list = self._extract_task_list_json(content)
                 if task_list is not None:
-                    # 保存到内存（替代 task.md）
-                    self._task_list_store[agent_path] = task_list
+                    # 保存到内存（按 session 隔离，避免跨会话任务泄漏）
+                    self._task_list_store[session_id] = task_list
                     await _write_sse({"type": "task_list_update", "tasks": task_list})
 
             # ── Check for tool calls (OpenAI function calling) ──
@@ -2938,6 +3017,29 @@ class ApiServer:
 
                     result_summary = agent._summarize_action_results(results)
 
+                    # ── 自动更新任务状态：将 running 任务标记为 done ──
+                    # 修复：执行成功后不依赖 LLM 下次输出才更新状态，避免重复执行同一任务
+                    if chat_mode == "exec":
+                        current_tasks = list(self._task_list_store.get(session_id, []))
+                        updated = False
+                        if results and results[0].get("success", False):
+                            # 找到第一个 running 的任务，标记为 done
+                            for t in current_tasks:
+                                if t.get("status") == "running":
+                                    t["status"] = "done"
+                                    updated = True
+                                    break
+                            # 如果没有 running 的，找第一个 pending 的标记为 done（兼容 LLM 未设置 running 的情况）
+                            if not updated:
+                                for t in current_tasks:
+                                    if t.get("status") == "pending":
+                                        t["status"] = "done"
+                                        updated = True
+                                        break
+                        if updated:
+                            self._task_list_store[session_id] = current_tasks
+                            await _write_sse({"type": "task_list_update", "tasks": current_tasks})
+
                     # Handle timeout diagnostics (same as _process_inner)
                     has_timeout = any(r.get("timed_out") for r in results)
                     timeout_detail = ""
@@ -3018,7 +3120,7 @@ class ApiServer:
             # 导致循环在此处 break，任务未完成就停止。
             # 修复：检查任务列表中是否还有未完成步骤，如果有则重新提示 LLM 继续。
             if chat_mode == "exec":
-                current_tasks = self._task_list_store.get(agent_path, [])
+                current_tasks = self._task_list_store.get(session_id, [])
                 pending_count = sum(
                     1 for t in current_tasks
                     if t.get("status") in ("pending", "running", "blocked")
@@ -3073,6 +3175,7 @@ class ApiServer:
 
         # Save assistant response to memory
         # ── 优先使用流式累积文本（包含所有迭代的纯文本），回退到 final_response ──
+        # 注意：即使客户端中途断开（刷新页面），也要保存已有内容
         saved_response = final_response
         if not saved_response and _all_streamed_text_parts:
             saved_response = "\n\n".join(p for p in _all_streamed_text_parts if p.strip())

package/web/ui/chat/chat.css

@@ -1712,13 +1712,23 @@ input,textarea,select{font:inherit}
   .agent-panel{
     position:fixed;
     right:0;top:0;
-    width:85vw;max-width:340px;
+    width:85vw!important;max-width:340px;min-width:260px!important;
     height:100vh;
     z-index:50;
     transform:translateX(100%);
     transition:transform .3s cubic-bezier(.4,0,.2,1);
     box-shadow:none;
   }
+  /* Override desktop collapsed state on mobile */
+  .agent-panel.collapsed{
+    width:85vw!important;min-width:260px!important;
+  }
+  .agent-panel.collapsed .agent-panel-header h3,
+  .agent-panel.collapsed .agent-list,
+  .agent-panel.collapsed .agent-create-btn,
+  .agent-panel.collapsed .agent-collapse-btn span,
+  .agent-panel.collapsed .agent-panel-footer{display:flex!important}
+  .agent-panel.collapsed .agent-collapse-btn span{display:inline!important}
   .agent-panel.mobile-open{
     transform:translateX(0);
     box-shadow:-4px 0 24px rgba(0,0,0,.15);
@@ -1753,8 +1763,15 @@ input,textarea,select{font:inherit}
   .messages-inner{
     max-width:100%;
   }
-  .message-bubble{
-    max-width:88%;
+  .message-row{gap:6px}
+  .message-avatar{
+    width:28px;height:28px;font-size:12px;
+  }
+  .message-row.assistant .message-bubble{
+    max-width:100%;
+  }
+  .message-row.user .message-bubble{
+    max-width:80%;
   }
   .message-bubble pre{
     font-size:12px;

package/web/ui/chat/chat_main.js

@@ -162,6 +162,7 @@ const state = {
   abortController: null,
   execTimerInterval: null,    // polling interval ID for execution progress
   systemStatus: null,
+  _sessionLoadSeq: 0,      // 防止 selectSession 并发竞态的序号
   // ── Execution mode escalation ──
   escalated: false,      // 当前会话是否临时提权到 local
   execLockInfo: null,     // 全局锁信息 {locked, locked_by, locked_at}
@@ -1103,6 +1104,8 @@ async function selectAgent(agentPath) {
   StatePersistence.save('activeAgent', agentPath);
   state.activeSessionId = null;
   state.messages = [];
+  // 递增序号，使任何进行中的 selectSession 请求失效
+  state._sessionLoadSeq++;
   var parts = agentPath.split('/');
   var cumPath = '';
   for (var i = 0; i < parts.length; i++) {
@@ -1528,7 +1531,7 @@ async function clearSessionFromMenu(id) {
   if (!id || id === '__new__') return;
   if (!confirm('确定清空此对话的消息？会话本身不会被删除。')) return;
   try {
-    const resp = await fetch(`/api/sessions/${encodeURIComponent(id)}/messages`, {
+    const resp = await fetch(`/api/session/messages?sid=${encodeURIComponent(id)}`, {
       method: 'DELETE',
       headers: { 'Content-Type': 'application/json' }
     });
@@ -1631,6 +1634,8 @@ async function selectSession(id) {
   document.getElementById('stopBtn').style.display = 'none';
 
   state.activeSessionId = id;
+  // 递增序号，用于检测并发竞态
+  const mySeq = ++state._sessionLoadSeq;
   const session = state.sessions.find(s => s.id === id);
   document.getElementById('headerTitle').textContent = session ? session.name : formatSessionName(id);
   document.getElementById('welcomeCard').style.display = 'none';
@@ -1638,13 +1643,16 @@ async function selectSession(id) {
 
   // Load messages
   try {
-    const data = await api(`/api/sessions/${encodeURIComponent(id)}/messages`);
+    const data = await api(`/api/session/messages?sid=${encodeURIComponent(id)}`);
+    // 竞态保护：如果在此请求期间又切换了其他会话，丢弃过期结果
+    if (mySeq !== state._sessionLoadSeq) return;
     state.messages = (data || []).map(m => ({
       role: m.role,
       content: m.content,
       time: m.time || '',
     }));
   } catch (e) {
+    if (mySeq !== state._sessionLoadSeq) return;
     state.messages = [];
     toast('加载消息失败', 'error');
   }
@@ -1656,7 +1664,7 @@ async function selectSession(id) {
 async function deleteSession(id) {
   if (!id || id === '__new__') return;
   try {
-    const resp = await fetch(`/api/sessions/${encodeURIComponent(id)}`, {
+    const resp = await fetch(`/api/session?sid=${encodeURIComponent(id)}`, {
       method: 'DELETE',
       headers: { 'Content-Type': 'application/json' }
     });
@@ -1721,7 +1729,7 @@ async function finishRenameSession(id, newName) {
     return;
   }
   try {
-    await api(`/api/sessions/${encodeURIComponent(id)}/rename`, {
+    await api(`/api/session/rename?sid=${encodeURIComponent(id)}`, {
       method: 'PUT',
       body: JSON.stringify({ name: newName }),
     });
@@ -1753,7 +1761,7 @@ async function clearCurrentChat() {
   }
   if (!confirm('确定清空当前对话消息？会话本身不会被删除。')) return;
   try {
-    const resp = await fetch(`/api/sessions/${encodeURIComponent(state.activeSessionId)}/messages`, {
+    const resp = await fetch(`/api/session/messages?sid=${encodeURIComponent(state.activeSessionId)}`, {
       method: 'DELETE',
       headers: { 'Content-Type': 'application/json' }
     });