myagent-ai 1.15.82 → 1.15.84

package/agents/main_agent.py

@@ -50,7 +50,7 @@ class MainAgent(BaseAgent):
 </toolstocal>
 </response>
 <task_plan>仅复杂任务使用任务计划，如"context"包含非空"task_plan"，则更新它。否则，先评估任务复杂度，针对单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务，若预计操作步骤不超过3步，则此处输出为空，不要创建任务列表；针对多文件修改、需要调研+实现+测试、涉及多个模块联动等复杂任务，如预计超过3步操作，则以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
-<remember><type>填global或session，其中"global"为跨会话全局记忆，"session"为仅当前会话。</type><content>仅从最新用户输入，包括"userprint"或"usersays_correct"或工具调用结果，中提炼值得记忆的信息（如用户偏好、重要结论、错误经验等）。如本轮无新信息要记忆，则为空，type也为空。</content></remember>
+<remember><type>填global或session，其中"global"为跨会话全局记忆，"session"为仅当前会话。</type><content>仅从最新用户输入，包括"userprint"或"usersays_correct"或工具调用结果，中提炼值得记忆的信息（如用户偏好、重要结论、错误经验、用户个人信息、对话要点、用户诉求、ai回复等）。因为对话默认不自动保存聊天记录，而是从记忆库搜索最相关的最新内容到"automemory"供决策，所以此次必须有所记忆，才能为后续多轮对话提供持续记忆基础。</content></remember>
 <recall>下一轮需要主动召回的记忆描述。填写需要从记忆库中检索的关键字或描述。如果不填写则为空。如果需要更多记忆支持当前任务，填写相关关键词（可包含时间参考，如"2025年1月的项目"），系统将在下一轮搜索top5相关记忆并通过"recall_memory"注入上下文。也可直接调用"recall_memory"工具即时搜索。</recall>
 <knowledge>从本轮对话或工具执行结果中提炼值得长期保存到知识库的专业知识、事实、经验法则、技术要点等，将被持久化存储，未来可通过 "get_knowledge"检索复用。如果本轮无需保存的知识，则为空。格式要求：简洁明确，每条知识一行，用换行分隔。</knowledge>
 <get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的knowledge内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>
@@ -593,6 +593,8 @@ class MainAgent(BaseAgent):
                     )
 
             # Step 1: 构建 Context XML
+            # 获取 MemoryAgent 预加载的用户偏好/错误模式（如果有）
+            _memory_ctx_prompt = context.working_memory.get("memory_context_prompt", "")
             context_xml = self.context_builder.build_context(
                 agent_name=agent_name,
                 agent_description=agent_description,
@@ -604,6 +606,7 @@ class MainAgent(BaseAgent):
                 agent_override_prompt=agent_override_prompt,
                 get_knowledge=get_knowledge_content,
                 recall=recall_content,
+                memory_context_prompt=_memory_ctx_prompt,
             )
 
             await self._emit_v2_event(
@@ -951,13 +954,26 @@ class MainAgent(BaseAgent):
                                     importance=0.7,
                                 )
                         else:
-                            # === 会话记忆：直接存储 → add_session ===
-                            self.memory.add_session(
+                            # === 会话记忆：查重后存储（避免 "必须记忆" 导致大量重复） ===
+                            _session_dup = self.memory.find_duplicate_memory(
+                                content=parsed.remember,
                                 session_id=context.session_id,
                                 key="conversation_insight",
-                                content=parsed.remember,
-                                importance=0.6,
+                                similarity_threshold=0.80,
+                                category="session",
                             )
+                            if _session_dup:
+                                logger.debug(
+                                    f"[{task_id}] 会话记忆查重: 跳过相似内容 "
+                                    f"(相似度>=0.80, 旧记忆ID={_session_dup.id})"
+                                )
+                            else:
+                                self.memory.add_session(
+                                    session_id=context.session_id,
+                                    key="conversation_insight",
+                                    content=parsed.remember,
+                                    importance=0.6,
+                                )
 
                         await self._emit_v2_event(
                             "v2_memory_saved",

package/core/context_builder.py

@@ -124,6 +124,7 @@ class ContextBuilder:
         agent_override_prompt: Optional[str] = None,
         get_knowledge: str = "",
         recall: str = "",
+        memory_context_prompt: str = "",
     ) -> str:
         """
         构建完整的 <context> XML 字符串。
@@ -161,11 +162,10 @@ class ContextBuilder:
         sections: List[str] = [
             self._build_datetime(),
             self._build_whomi(agent_name, agent_description, agent_override_prompt),
-            self._build_memory(query, session_id, recall),
+            self._build_memory(query, session_id, recall, memory_context_prompt),
             self._build_knowledge(kb_query),
-            # [v1.15.6] 注释掉聊天历史注入 — 仅保留用户最新消息 + 工具回调，
-            # 其他上下文由系统记忆（automemory/recall_memory）自行处理
-            # self._build_recent_dialog(conversation_history, self.max_dialog_chars, session_id),
+            # 轻量近期对话兜底：最近 3 轮对话摘要，补充 automemory 搜索的盲区
+            self._build_recent_summary(session_id),
             self._build_user_input(user_typed_text, user_voice_text),
             self._build_task_plan(task_plan),
             self._build_tools(self.skill_registry),
@@ -242,7 +242,7 @@ class ContextBuilder:
         parts.append("</whomi>")
         return "\n".join(parts)
 
-    def _build_memory(self, query: str, session_id: str, recall: str = "") -> str:
+    def _build_memory(self, query: str, session_id: str, recall: str = "", memory_context_prompt: str = "") -> str:
         """
         构建 <automemory> 和 <recall_memory> 段落 —— 双层记忆检索结果。
 
@@ -258,6 +258,7 @@ class ContextBuilder:
             query: 搜索查询文本（通常为最新用户消息）
             session_id: 会话 ID
             recall: LLM 上一轮输出的 <recall> 内容（关键字+时间描述）
+            memory_context_prompt: MemoryAgent 预加载的用户偏好/错误模式（直接注入）
 
         Returns:
             <automemory> + <recall_memory> XML 段落字符串
@@ -299,6 +300,9 @@ class ContextBuilder:
 
                 if combined:
                     auto_lines.append("<automemory>")
+                    # 注入 MemoryAgent 预加载的用户偏好/错误模式
+                    if memory_context_prompt and memory_context_prompt.strip():
+                        auto_lines.append(_xml_escape(memory_context_prompt.strip()))
                     for i, entry in enumerate(combined[:10], 1):
                         content = entry.content.strip()
                         if content:
@@ -438,6 +442,51 @@ class ContextBuilder:
             logger.warning(f"知识库 RAG 检索失败 ({kb_dir}): {e}")
             return ""
 
+    def _build_recent_summary(self, session_id: str) -> str:
+        """
+        构建 <recent_summary> 段落 —— 最近几轮对话的轻量摘要。
+
+        作为 automemory 搜索的兜底机制，确保 LLM 至少能看到最近几轮
+        对话的基本脉络。只取最近 6 条（约 3 轮 user+assistant），
+        每条截断到 200 字，总字符控制在 1500 以内。
+        """
+        if not self.memory_manager or not session_id:
+            return ""
+
+        try:
+            from core.utils import truncate_str
+            # 只取 user 和 assistant 角色，排除内部审计条目
+            entries = self.memory_manager.get_conversation(
+                session_id=session_id,
+                limit=6,
+                include_roles=["user", "assistant"],
+            )
+            if not entries:
+                return ""
+
+            role_labels = {"user": "用户", "assistant": "助手"}
+            lines = []
+            total_chars = 0
+            for entry in reversed(entries):  # 最新的在前
+                content = (entry.content or "").strip()
+                if not content:
+                    continue
+                label = role_labels.get(entry.role, entry.role)
+                # 截断过长内容
+                truncated = truncate_str(content, 200)
+                lines.append(f"{label}: {_xml_escape(truncated)}")
+                total_chars += len(truncated) + 10
+                if total_chars > 1500:
+                    break
+
+            if not lines:
+                return ""
+
+            return "<recent_summary>\n" + "\n".join(lines) + "\n</recent_summary>"
+        except Exception as e:
+            logger.debug(f"recent_summary 构建失败: {e}")
+            return ""
+
     def _build_recent_dialog(
         self,
         conversation_history: List["Message"],
@@ -768,8 +817,9 @@ class ContextBuilder:
             replacement = f'<{tag}>\n(因 token 预算不足已裁剪)\n</{tag}>'
             return re.sub(pattern, replacement, xml, count=1, flags=re.DOTALL)
 
-        # 按优先级从低到高裁剪
-        for tag in ['knowledge', 'recall_memory', 'automemory']:
+        # 按优先级从低到高裁剪（记忆最优先保留，知识库和任务计划优先裁剪）
+        # recent_summary 是兜底机制，最先裁剪
+        for tag in ['recent_summary', 'knowledge', 'task_plan', 'recall_memory', 'automemory']:
             if estimated <= budget:
                 break
             if f'<{tag}>' in context_xml:

package/memory/manager.py

@@ -280,7 +280,8 @@ class MemoryManager:
     def add_session(self, session_id, role="", content="", key="", importance=0.5, metadata=None) -> str:
         """添加会话记忆。内容不包含时间前缀，时间仅存于 created_at 和 metadata。"""
         from datetime import datetime as _dt
-        _now_str = _dt.now().strftime("%Y-%m-%d %H:%M:%S")
+        from core.utils import get_config_tz
+        _now_str = _dt.now(get_config_tz()).strftime("%Y-%m-%d %H:%M:%S")
         # 直接存储原始内容，不再注入时间前缀
         entry = MemoryEntry(
             session_id=session_id, category="session", role=role,
@@ -489,6 +490,7 @@ class MemoryManager:
         session_id: str = "",
         key: str = "",
         similarity_threshold: float = 0.85,
+        category: str = "global",
     ) -> Optional[MemoryEntry]:
         """
         查找与给定内容高度相似的已有记忆（查重）。
@@ -501,6 +503,7 @@ class MemoryManager:
             session_id: 会话 ID（为空则跨会话查重）
             key: 记忆分类键（为空则不限制分类）
             similarity_threshold: 相似度阈值，超过此值视为重复（默认 0.85）
+            category: 记忆类别（默认 "global"，可设为 "session" 用于会话记忆查重）
 
         Returns:
             匹配的旧 MemoryEntry，或 None（无重复）
@@ -509,7 +512,7 @@ class MemoryManager:
             return None  # 空内容不查重
 
         conn = self._get_conn()
-        conditions = ["category = 'global'"]
+        conditions = [f"category = '{category}'"]
         params: list = []
 
         if session_id:

package/package.json

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

package/web/api_server.py

@@ -884,7 +884,11 @@ class ApiServer:
 
         agent_path = data.get("agent_path", "default")
         raw_session_id = data.get("session_id", "web_default")
-        session_id = f"{agent_path}_{raw_session_id}"
+        # Avoid double-prefixing: if the session_id already starts with agent_path_, use it directly
+        if raw_session_id.startswith(f"{agent_path}_"):
+            session_id = raw_session_id
+        else:
+            session_id = f"{agent_path}_{raw_session_id}"
         choice = data.get("choice", "queue")  # "continue" (插入后继续) 或 "queue" (排队)
 
         # 检查会话是否正在运行

package/web/ui/chat/chat_main.js

@@ -311,6 +311,11 @@ const StatePersistence = {
     if (savedRpSections) { Object.assign(rpSections, savedRpSections); }
     const savedNodes = StatePersistence.load('expandedNodes', ['default']);
     state.expandedNodes = new Set(savedNodes);
+    // 恢复上次活跃的会话 ID，供 loadSessions() 使用
+    var savedSessionId = StatePersistence.load('activeSessionId', null);
+    if (savedSessionId) {
+      state._pendingSessionRestore = savedSessionId;
+    }
   },
   /** 标记 setup 已完成（避免每次刷新弹出向导） */
   markSetupDone() { StatePersistence.save('setupDone', true); },
@@ -318,7 +323,7 @@ const StatePersistence = {
 };
 
 // ── Init ──
-function initChat() {
+async function initChat() {
   // Initialize theme
   initTheme();
   // Restore persisted UI state
@@ -333,8 +338,6 @@ function initChat() {
   if (urlMode === 'chat' || urlMode === 'exec') {
     state.chatMode = urlMode;
   }
-  // agent 参数先暂存，等 loadAgents() 完成后校验是否存在
-  state._pendingUrlAgent = urlAgent;
 
   // Popout mode: hide sidebar, collapse agent panel, update title
   if (isPopout) {
@@ -347,9 +350,7 @@ function initChat() {
     if (agentPanel) agentPanel.classList.add('collapsed');
     const agentToggle = document.getElementById('agentToggle');
     if (agentToggle) agentToggle.style.display = 'none';
-    // Update page title with agent name
-    const agentObj = findAgentByPath(urlAgent);
-    document.title = (agentObj ? agentObj.name : urlAgent || 'MyAgent') + ' - MyAgent';
+    // Update page title with agent name (after agents load)
   }
 
   // Apply restored state to DOM
@@ -357,7 +358,6 @@ function initChat() {
   if (panel) panel.classList.toggle('collapsed', !state.agentPanelOpen);
   if (state.chatMode === 'exec') setMode('exec');
   loadModels();
-  loadAgents();
   loadStatus();
   loadChatVersion();
   fetchGroups();
@@ -380,49 +380,53 @@ function initChat() {
     loadTaskPlan();
   }
 
-  // 如果 URL 指定了 agent 或 session，等 agent 列表加载后自动选中
-  // 注意：loadSessions() 内部会检查 URL session 参数并自动恢复
+  // 页面卸载前保存 UI 状态（包括活跃 session）
+  window.addEventListener('beforeunload', function() {
+    StatePersistence.saveUIState();
+  });
+
+  // ── 核心：先等待 loadAgents 完成（内含 loadSessions），再做 agent/session 选择 ──
+  // 这样避免了 setTimeout 竞态条件导致 sendMessage 和 selectAgent 互相干扰
+  await loadAgents();
+
+  // loadAgents 完成后，agent 列表和 sessions 已加载完毕
+  // 现在可以安全地做 agent/session 选择（不会再和 sendMessage 竞态）
+  if (isPopout) {
+    const agentObj = findAgentByPath(urlAgent);
+    document.title = (agentObj ? agentObj.name : urlAgent || 'MyAgent') + ' - MyAgent';
+  }
+
   if (urlAgent) {
-    setTimeout(function() {
-      // 校验 agent 是否真实存在，不存在则回退 default
-      var resolved = urlAgent;
-      if (!findAgentByPath(resolved)) {
-        console.warn('URL agent not found, fallback to default:', resolved);
-        resolved = 'default';
-      }
+    // URL 指定了 agent，校验后切换
+    var resolved = urlAgent;
+    if (!findAgentByPath(resolved)) {
+      console.warn('URL agent not found, fallback to default:', resolved);
+      resolved = 'default';
+    }
+    if (resolved !== state.activeAgent) {
       selectAgent(resolved);
-    }, 500);
+    }
   } else if (urlSession) {
     // 只有 session 没有 agent，尝试从 session ID 推断 agent
     const targetAgent = urlSession.split('_web_')[0] || 'default';
-    setTimeout(function() {
-      if (!findAgentByPath(targetAgent)) {
-        console.warn('Session-inferred agent not found, fallback to default:', targetAgent);
-        selectAgent('default');
-      } else {
-        selectAgent(targetAgent);
-      }
-    }, 500);
+    var target = targetAgent;
+    if (!findAgentByPath(target)) {
+      console.warn('Session-inferred agent not found, fallback to default:', target);
+      target = 'default';
+    }
+    if (target !== state.activeAgent) {
+      selectAgent(target);
+    }
+    // 如果 agent 已一致，loadSessions 内部已通过 URL session 参数自动恢复了
   } else {
-    // URL 中没有 session 参数，尝试从 localStorage 恢复上次的会话
-    var savedSessionId = StatePersistence.load('activeSessionId', null);
+    // URL 中没有 agent/session 参数，尝试从 localStorage 恢复上次的会话
     var savedSessionAgent = StatePersistence.load('activeSessionAgent', null);
-    if (savedSessionId && savedSessionAgent) {
-      // 确保 agent 一致，然后延迟等待 loadSessions() 完成后恢复
-      state._pendingSessionRestore = savedSessionId;
-      if (savedSessionAgent !== state.activeAgent) {
-        setTimeout(function() {
-          selectAgent(savedSessionAgent);
-        }, 500);
-      }
-      // 如果 agent 已经一致，loadSessions() 内部会自动处理
+    if (savedSessionAgent && savedSessionAgent !== state.activeAgent) {
+      // agent 不一致，需要切换（loadSessions 内部已通过 _pendingSessionRestore 处理 session 恢复）
+      selectAgent(savedSessionAgent);
     }
+    // 如果 agent 一致，loadSessions() 内部已通过 _pendingSessionRestore 自动处理了
   }
-
-  // 页面卸载前保存 UI 状态（包括活跃 session）
-  window.addEventListener('beforeunload', function() {
-    StatePersistence.saveUIState();
-  });
 }
 
 // Run init: if DOMContentLoaded already fired (dynamic script load), run immediately

package/web/ui/chat/flow_engine.js

@@ -1382,6 +1382,7 @@ async function sendMessage(opts) {
     let allExecEvents = [];  // All exec events (for summary panel at bottom)
     let msgIdx = state.messages.length;
     let sessionIdReceived = sessionId;
+    let sessionIdOriginal = sessionId;  // 保存前端原始 ID，用于后端返回不同 ID 时的回退查找
     let fullThought = '';
     let _isV2Mode = false;   // Track whether V2 structured output events are received
     let _v2RawXml = '';      // In V2 mode, accumulate raw XML from text_delta separately
@@ -1857,8 +1858,11 @@ async function sendMessage(opts) {
       state.sessions.unshift(existing);
     } else {
       // 防御：后端返回的 sessionIdReceived 和前端的不一致时，
-      // 找到当前 activeSessionId 的条目，更新其 ID 而非创建新条目
-      var localIdx = state.sessions.findIndex(s => s.id === state.activeSessionId);
+      // 优先用前端原始 ID 查找，再用 activeSessionId 查找
+      var localIdx = state.sessions.findIndex(s => s.id === sessionIdOriginal);
+      if (localIdx < 0) {
+        localIdx = state.sessions.findIndex(s => s.id === state.activeSessionId);
+      }
       if (localIdx >= 0) {
         var localEntry = state.sessions[localIdx];
         localEntry.id = sessionIdReceived;
@@ -1869,6 +1873,7 @@ async function sendMessage(opts) {
         state.sessions.unshift(localEntry);
         console.warn('[sendMessage] Session ID mismatch, updated local entry:', sessionIdReceived);
       } else {
+        // 真正的新会话（本地列表中不存在）
         state.sessions.unshift({ id: sessionIdReceived, name: formatSessionName(sessionIdReceived), messages: 2, last: new Date().toISOString() });
       }
     }