myagent-ai 1.9.5 → 1.9.6

package/agents/main_agent.py

@@ -1139,6 +1139,81 @@ status 取值：
         else:
             logger.debug(f"[v2-event] {event_type}: {data}")
 
+    async def _merge_duplicate_memory(
+        self,
+        old_memory,
+        new_content: str,
+        context: AgentContext,
+        task_id: str,
+    ) -> Optional[str]:
+        """
+        当发现新旧记忆高度相似时，调用 LLM API 让其判断最终记忆内容。
+
+        将旧记忆、新记忆、当前上下文发送给 LLM，由 LLM 决定:
+          - 合并为一条更完整的记忆
+          - 保留新记忆（旧记忆已过时）
+          - 保留旧记忆（新记忆无新增信息）
+
+        Returns:
+            合并后的记忆内容，或 None（合并失败）
+        """
+        if not self.llm:
+            logger.warning(f"[{task_id}] 记忆合并: 无 LLM 客户端，跳过合并")
+            return None
+
+        from datetime import datetime
+        old_time = old_memory.created_at or "未知时间"
+        new_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        user_msg = context.user_message or ""
+
+        merge_prompt = f"""你是一个记忆管理系统。现在系统检测到两条高度相似的记忆，请你判断如何合并它们。
+
+## 旧记忆（创建于 {old_time}）
+{old_memory.content}
+
+## 新记忆（创建于 {new_time}）
+{new_content}
+
+## 当前用户输入
+{user_msg}
+
+## 任务
+请分析新旧记忆，输出一条最终的合并记忆。规则：
+1. 如果新记忆包含了旧记忆的信息并有更新，则合并为更完整的表述
+2. 如果新记忆只是旧记忆的重复或信息量更少，保留旧记忆中更完整的信息
+3. 如果新记忆提供了全新的信息，以新记忆为主，补充旧记忆中的有效部分
+4. 合并后的记忆应当简洁、准确、包含时间上下文
+5. 直接输出合并后的记忆内容，不要输出任何解释或标记
+
+请输出合并后的记忆："""
+
+        try:
+            messages = [
+                Message(role="system", content="你是一个记忆管理系统，负责合并重复或相似的记忆条目。只输出合并后的记忆内容，不要输出任何额外说明。"),
+                Message(role="user", content=merge_prompt),
+            ]
+
+            response = await self._call_llm(messages)
+
+            if response.success and response.content:
+                merged = response.content.strip()
+                # 清理可能的引号包裹
+                if merged.startswith('"') and merged.endswith('"'):
+                    merged = merged[1:-1]
+                if merged.startswith("'") and merged.endswith("'"):
+                    merged = merged[1:-1]
+                logger.info(
+                    f"[{task_id}] 记忆合并成功: 旧({len(old_memory.content)}字) + "
+                    f"新({len(new_content)}字) → 合并({len(merged)}字)"
+                )
+                return merged
+            else:
+                logger.warning(f"[{task_id}] 记忆合并 LLM 调用失败: {response.error}")
+                return None
+        except Exception as e:
+            logger.warning(f"[{task_id}] 记忆合并异常: {e}")
+            return None
+
     async def process_v2(
         self,
         context: AgentContext,
@@ -1210,6 +1285,8 @@ status 取值：
         all_tool_outputs = ""
         recall_content = ""
         get_knowledge_content = ""
+        # 追踪流式推送的 reasoning 文本（用于构建有意义的最终回复）
+        _v2_reasoning_collected: List[str] = []
 
         conversation_history = list(context.conversation_history or [])
 
@@ -1347,38 +1424,63 @@ status 取值：
             if parsed.usersays_correct:
                 context.working_memory["usersays_correct"] = parsed.usersays_correct
 
-            # Step 6: 处理 remember — 查重后存入长期记忆
+            # Step 6: 处理 remember — 查重+LLM合并后存入长期记忆
             if parsed.remember:
                 try:
-                    # 查重：跳过与已有记忆高度重复的内容
-                    is_dup = False
                     if self.memory:
-                        is_dup = self.memory.is_duplicate_memory(
+                        # 查找是否有相似记忆
+                        dup_memory = self.memory.find_duplicate_memory(
                             content=parsed.remember,
                             session_id=context.session_id,
                             key="conversation_insight",
                         )
-                    if is_dup:
-                        logger.debug(f"[{task_id}] 记忆查重: 跳过重复内容")
-                    else:
-                        if self.memory_agent:
-                            mem_ctx = AgentContext(
-                                task_id=task_id,
-                                session_id=context.session_id,
-                                metadata={
-                                    "memory_action": "save",
-                                    "content": parsed.remember,
-                                },
+                        if dup_memory:
+                            # 发现相似记忆 → 调用 LLM API 合并新旧记忆
+                            logger.info(
+                                f"[{task_id}] 记忆查重: 发现相似内容，调用LLM合并 "
+                                f"(旧记忆ID={dup_memory.id}, 创建于={dup_memory.created_at})"
                             )
-                            await self.memory_agent.process(mem_ctx)
-                        elif self.memory:
-                            self.memory.add_long_term(
-                                session_id=context.session_id,
-                                key="conversation_insight",
-                                content=parsed.remember,
-                                summary=truncate_str(parsed.remember, 200),
-                                importance=0.7,
+                            merged_content = await self._merge_duplicate_memory(
+                                old_memory=dup_memory,
+                                new_content=parsed.remember,
+                                context=context,
+                                task_id=task_id,
                             )
+                            if merged_content:
+                                # 用 LLM 合并后的内容替换旧记忆
+                                self.memory.update_memory(
+                                    memory_id=dup_memory.id,
+                                    content=merged_content,
+                                    summary=truncate_str(merged_content, 200),
+                                )
+                                logger.info(f"[{task_id}] 记忆已合并更新: {dup_memory.id}")
+                            else:
+                                # LLM 合并失败，直接更新为新内容
+                                self.memory.update_memory(
+                                    memory_id=dup_memory.id,
+                                    content=parsed.remember,
+                                )
+                                logger.info(f"[{task_id}] 记忆直接更新为新内容: {dup_memory.id}")
+                        else:
+                            # 无重复，直接存储新记忆
+                            if self.memory_agent:
+                                mem_ctx = AgentContext(
+                                    task_id=task_id,
+                                    session_id=context.session_id,
+                                    metadata={
+                                        "memory_action": "save",
+                                        "content": parsed.remember,
+                                    },
+                                )
+                                await self.memory_agent.process(mem_ctx)
+                            else:
+                                self.memory.add_long_term(
+                                    session_id=context.session_id,
+                                    key="conversation_insight",
+                                    content=parsed.remember,
+                                    summary=truncate_str(parsed.remember, 200),
+                                    importance=0.7,
+                                )
                         await self._emit_v2_event(
                             "v2_memory_saved",
                             {"content": truncate_str(parsed.remember, 200)},
@@ -1474,6 +1576,7 @@ status 取值：
 
                 # 发送 beforecalltext 作为显示文本
                 if before_call:
+                    _v2_reasoning_collected.append(before_call)
                     await self._emit_v2_event(
                         "v2_reasoning",
                         {"content": before_call},
@@ -1552,9 +1655,15 @@ status 取值：
             # 核心逻辑: finish=true 表示任务已完成/不需要再调用LLM，即使工具设置了callback=true
             if parsed.finish:
                 logger.info(f"[{task_id}] finish=true，任务已完成，不回调 LLM")
-                final_text = "已完成所有操作。"
-                if current_task_plan:
-                    final_text += f"\n\n任务计划:\n{current_task_plan}"
+                # 构建有意义的最终回复：使用收集到的 reasoning text + 任务计划摘要
+                if _v2_reasoning_collected:
+                    final_text = "\n".join(_v2_reasoning_collected)
+                    if current_task_plan:
+                        final_text += f"\n\n{current_task_plan}"
+                else:
+                    final_text = "已完成所有操作。"
+                    if current_task_plan:
+                        final_text += f"\n\n任务计划:\n{current_task_plan}"
                 context.working_memory["final_response"] = final_text
                 await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
                 if self.memory:
@@ -1568,9 +1677,14 @@ status 取值：
             # finish=false: 根据工具的 callback 标志决定是否回调
             if not need_callback:
                 logger.info(f"[{task_id}] 所有工具无需回调且 finish=false，结束循环")
-                final_text = "已完成所有操作。"
-                if current_task_plan:
-                    final_text += f"\n\n任务计划:\n{current_task_plan}"
+                if _v2_reasoning_collected:
+                    final_text = "\n".join(_v2_reasoning_collected)
+                    if current_task_plan:
+                        final_text += f"\n\n{current_task_plan}"
+                else:
+                    final_text = "已完成所有操作。"
+                    if current_task_plan:
+                        final_text += f"\n\n任务计划:\n{current_task_plan}"
                 context.working_memory["final_response"] = final_text
                 await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
                 if self.memory:

package/main.py

@@ -319,6 +319,11 @@ class MyAgentApp:
             memory_agent=self.memory_agent,
             config_broadcaster=self.config_broadcaster,
         )
+        self.main_agent.init_context_builder(
+            memory_manager=self.memory,
+            skill_registry=self.skill_registry,
+            knowledge_base_dir=str(self.config_mgr.data_dir / "organization" / "knowledge")
+        )
         self.logger.info("Agent 集群已初始化 (主/工具/记忆)")
 
         # 10. 自动更新管理器

package/memory/manager.py

@@ -479,18 +479,18 @@ class MemoryManager:
     # 长期记忆 (持久知识)
     # ==========================================================================
 
-    def is_duplicate_memory(
+    def find_duplicate_memory(
         self,
         content: str,
         session_id: str = "",
         key: str = "",
         similarity_threshold: float = 0.85,
-    ) -> bool:
+    ) -> Optional[MemoryEntry]:
         """
-        检查是否已存在高度相似的记忆（查重）。
+        查找与给定内容高度相似的已有记忆（查重）。
 
         使用 TF-IDF 余弦相似度判断新内容是否与已有记忆高度重复。
-        相似度超过阈值则视为重复。
+        相似度超过阈值则返回匹配的旧记忆，否则返回 None。
 
         Args:
             content: 待检查的新记忆内容
@@ -499,10 +499,10 @@ class MemoryManager:
             similarity_threshold: 相似度阈值，超过此值视为重复（默认 0.85）
 
         Returns:
-            True 表示存在重复记忆，False 表示可以存储
+            匹配的旧 MemoryEntry，或 None（无重复）
         """
         if not content or not content.strip():
-            return True  # 空内容视为重复
+            return None  # 空内容不查重
 
         conn = self._get_conn()
         conditions = ["category = 'long_term'"]
@@ -521,27 +521,84 @@ class MemoryManager:
 
         where = " AND ".join(conditions)
         # 取最近的记忆候选进行比对
-        sql = f"SELECT id, content, summary FROM memories WHERE {where} ORDER BY created_at DESC LIMIT 50"
+        sql = f"SELECT id, content, summary, created_at FROM memories WHERE {where} ORDER BY created_at DESC LIMIT 50"
         rows = conn.execute(sql, params).fetchall()
 
         if not rows:
-            return False
+            return None
 
         # 使用 TF-IDF 计算新内容与每条已有记忆的相似度
         documents = [(row["id"], row["content"]) for row in rows]
         scores = self._compute_tfidf(content, documents)
 
         if not scores:
-            return False
+            return None
 
-        max_score = max(scores.values())
+        max_id = max(scores, key=scores.get)
+        max_score = scores[max_id]
         if max_score >= similarity_threshold:
             logger.debug(
-                f"记忆查重: 发现重复内容 (相似度={max_score:.2f}, "
-                f"阈值={similarity_threshold}, 匹配ID={max(scores, key=scores.get)})"
+                f"记忆查重: 发现相似内容 (相似度={max_score:.2f}, "
+                f"阈值={similarity_threshold}, 匹配ID={max_id})"
             )
-            return True
+            # 返回匹配的旧记忆
+            for row in rows:
+                if row["id"] == max_id:
+                    return MemoryEntry.from_row(row)
+
+        return None
+
+    def is_duplicate_memory(
+        self,
+        content: str,
+        session_id: str = "",
+        key: str = "",
+        similarity_threshold: float = 0.85,
+    ) -> bool:
+        """
+        检查是否已存在高度相似的记忆（查重）。
+
+        Returns:
+            True 表示存在重复记忆，False 表示可以存储
+        """
+        return self.find_duplicate_memory(
+            content, session_id, key, similarity_threshold
+        ) is not None
 
+    def update_memory(self, memory_id: str, content: str, summary: str = "", **updates) -> bool:
+        """
+        更新记忆内容（保留原 ID 和创建时间）。
+
+        Args:
+            memory_id: 记忆 ID
+            content: 新内容
+            summary: 新摘要（为空则自动截取）
+
+        Returns:
+            True 更新成功
+        """
+        if not summary:
+            summary = truncate_str(content, 200)
+        self._update_content(memory_id, content, summary=summary, **updates)
+        logger.info(f"记忆已更新: {memory_id}")
+        return True
+
+    def delete_memory(self, memory_id: str) -> bool:
+        """
+        删除单条记忆。
+
+        Args:
+            memory_id: 记忆 ID
+
+        Returns:
+            True 删除成功
+        """
+        conn = self._get_conn()
+        cursor = conn.execute("DELETE FROM memories WHERE id = ?", (memory_id,))
+        conn.commit()
+        if cursor.rowcount > 0:
+            logger.info(f"记忆已删除: {memory_id}")
+            return True
         return False
 
     def add_long_term(
@@ -563,14 +620,23 @@ class MemoryManager:
             summary: 简要摘要
             importance: 重要性(越高越不容易被淘汰)
         """
+        from datetime import datetime
+        now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        # 在 content 开头自动附加时间戳
+        timestamped_content = f"[{now_str}] {truncate_str(content, 50000)}"
+        ts_summary = summary or truncate_str(content, 200)
+
         entry = MemoryEntry(
             session_id=session_id,
             category="long_term",
             key=key,
-            content=truncate_str(content, 50000),
-            summary=summary,
+            content=timestamped_content,
+            summary=f"[{now_str}] {ts_summary}",
             importance=importance,
-            metadata=metadata or {},
+            metadata={
+                "timestamp": now_str,
+                **(metadata or {}),
+            },
         )
         return self._insert(entry)
 

package/package.json

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

package/web/api_server.py

@@ -3063,14 +3063,19 @@ class ApiServer:
 
             # 返回最终响应
             final_response = v2_context.working_memory.get("final_response", "")
-            if not final_response and _v2_reasoning_parts:
+            # 优先使用 v2_reasoning 流式推送的文本（用户实际看到的内容），
+            # 而不是后端设定的通用占位符如"已完成所有操作。"
+            if _v2_reasoning_parts:
                 # Smart join: only add separator when parts don't already end with newline
                 joined_parts = []
                 for i, part in enumerate(_v2_reasoning_parts):
                     if i > 0 and joined_parts and not joined_parts[-1].endswith('\n') and not part.startswith('\n'):
                         joined_parts.append('\n')
                     joined_parts.append(part)
-                final_response = ''.join(joined_parts)
+                reasoning_text = ''.join(joined_parts)
+                # 如果 final_response 是通用占位符或为空，使用 reasoning text
+                if not final_response or final_response.startswith("已完成所有操作") or final_response.startswith("处理完毕"):
+                    final_response = reasoning_text
             return final_response
 
         # ── V1 路由: 标准 JSON action 格式 ──

package/web/ui/chat/flow_engine.js

@@ -851,9 +851,12 @@ function _assembleV2Content(msg, msgParts) {
     return msg._askUser.trim();
   }
   // Priority 3: V1 text parts (backward compat — non-V2 mode)
-  var textParts = msgParts.filter(function(p) { return p.type === 'text'; });
-  if (textParts.length > 0) {
-    return textParts.map(function(p) { return p.content; }).join('\n\n');
+  // Guard: msgParts may be undefined after page refresh (only role/content/time persisted)
+  if (msgParts && Array.isArray(msgParts) && msgParts.length > 0) {
+    var textParts = msgParts.filter(function(p) { return p.type === 'text'; });
+    if (textParts.length > 0) {
+      return textParts.map(function(p) { return p.content; }).join('\n\n');
+    }
   }
   // Priority 4: raw content from message (server-stored response)
   if (msg.content && msg.content.trim() && msg.content !== '(无回复)') {
@@ -1107,6 +1110,8 @@ async function sendMessage() {
             _isV2Mode = true;
           } else if (evt.type === 'v2_output_parsed') {
             // LLM output was parsed into structured format
+            // IMPORTANT: Also mark V2 mode here — some server configs may skip v2_context
+            _isV2Mode = true;
             // evt.data contains: {usersays_correct, task_plan, tools_to_call, remember, recall, ask_user, finish}
             // Store for rendering
             state.messages[msgIdx]._v2Parsed = evt.data;