myagent-ai 1.15.83 → 1.15.85

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

@@ -231,7 +231,15 @@ class MemoryManager:
         params.append(timestamp())
 
         where = " AND ".join(conditions) if conditions else "1=1"
-        sql = f"SELECT * FROM memories WHERE {where} ORDER BY {order_by} LIMIT ?"
+        # 安全白名单：仅允许预定义的排序字段
+        _allowed_orders = {
+            "created_at ASC", "created_at DESC",
+            "importance ASC", "importance DESC",
+            "access_count ASC", "access_count DESC",
+            "updated_at ASC", "updated_at DESC",
+        }
+        _safe_order = order_by if order_by in _allowed_orders else "created_at ASC"
+        sql = f"SELECT * FROM memories WHERE {where} ORDER BY {_safe_order} LIMIT ?"
         params.append(limit)
 
         rows = conn.execute(sql, params).fetchall()
@@ -280,7 +288,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 +498,7 @@ class MemoryManager:
         session_id: str = "",
         key: str = "",
         similarity_threshold: float = 0.85,
+        category: str = "global",
     ) -> Optional[MemoryEntry]:
         """
         查找与给定内容高度相似的已有记忆（查重）。
@@ -501,6 +511,7 @@ class MemoryManager:
             session_id: 会话 ID（为空则跨会话查重）
             key: 记忆分类键（为空则不限制分类）
             similarity_threshold: 相似度阈值，超过此值视为重复（默认 0.85）
+            category: 记忆类别（默认 "global"，可设为 "session" 用于会话记忆查重）
 
         Returns:
             匹配的旧 MemoryEntry，或 None（无重复）
@@ -509,8 +520,8 @@ class MemoryManager:
             return None  # 空内容不查重
 
         conn = self._get_conn()
-        conditions = ["category = 'global'"]
-        params: list = []
+        conditions = ["category = ?"]
+        params: list = [category]
 
         if session_id:
             conditions.append("session_id = ?")
@@ -865,10 +876,13 @@ class MemoryManager:
                                          time_decay=time_decay, half_life_days=half_life_days)
         else:
             # 混合模式：取两种搜索结果的加权和 + 时间衰减
+            # 注意：传入 update_access=False 避免子搜索重复更新 access_count
             keyword_results = self._search_keyword(conn, query, where, params, limit * 2,
-                                                   time_decay=False, half_life_days=half_life_days)
+                                                   time_decay=False, half_life_days=half_life_days,
+                                                   update_access=False)
             semantic_results = self._search_semantic(conn, query, where, params, limit * 2,
-                                                     time_decay=False, half_life_days=half_life_days)
+                                                     time_decay=False, half_life_days=half_life_days,
+                                                     update_access=False)
 
             # 合并评分（相关性 + 时间衰减）
             combined: Dict[str, Tuple[MemoryEntry, float]] = {}
@@ -917,6 +931,7 @@ class MemoryManager:
         limit: int,
         time_decay: bool = False,
         half_life_days: float = 30.0,
+        update_access: bool = True,
     ) -> List[MemoryEntry]:
         """关键词 LIKE 搜索（支持时间衰减重排序）"""
         like_pattern = f"%{query}%"
@@ -946,12 +961,13 @@ class MemoryManager:
             entries = [e for e, _ in scored[:limit]]
 
         # 更新访问计数
-        for entry in entries:
-            conn.execute(
-                "UPDATE memories SET access_count = access_count + 1 WHERE id = ?",
-                (entry.id,),
-            )
-        conn.commit()
+        if update_access:
+            for entry in entries:
+                conn.execute(
+                    "UPDATE memories SET access_count = access_count + 1 WHERE id = ?",
+                    (entry.id,),
+                )
+            conn.commit()
 
         return entries
 
@@ -964,6 +980,7 @@ class MemoryManager:
         limit: int,
         time_decay: bool = False,
         half_life_days: float = 30.0,
+        update_access: bool = True,
     ) -> List[MemoryEntry]:
         """TF-IDF 语义搜索（支持时间衰减重排序）"""
         # 先取一批候选文档
@@ -998,12 +1015,13 @@ class MemoryManager:
         result = [MemoryEntry.from_row(row_map[doc_id]) for doc_id in top_ids if doc_id in row_map]
 
         # 更新访问计数
-        for entry in result:
-            conn.execute(
-                "UPDATE memories SET access_count = access_count + 1 WHERE id = ?",
-                (entry.id,),
-            )
-        conn.commit()
+        if update_access:
+            for entry in result:
+                conn.execute(
+                    "UPDATE memories SET access_count = access_count + 1 WHERE id = ?",
+                    (entry.id,),
+                )
+            conn.commit()
 
         return result
 

package/package.json

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

package/skills/search_skill.py

@@ -127,10 +127,21 @@ class WebSearchSkill(Skill):
                     r.raise_for_status()
                 except requests.exceptions.SSLError:
                     logger.warning("DuckDuckGo SSL 验证失败，跳过证书验证重试")
-                    r = requests.get("https://html.duckduckgo.com/html/", params={"q": query}, headers=_HEADERS, timeout=15, verify=False)
-                    r.raise_for_status()
+                    try:
+                        r = requests.get("https://html.duckduckgo.com/html/", params={"q": query}, headers=_HEADERS, timeout=15, verify=False)
+                        r.raise_for_status()
+                    except Exception as ssl_retry_err:
+                        logger.error(f"DuckDuckGo SSL 重试也失败: {ssl_retry_err}")
+                        return ""
+                except Exception as req_err:
+                    logger.error(f"DuckDuckGo 请求失败: {req_err}")
+                    return ""
                 if r is not None:
-                    return r.text or ""
+                    try:
+                        return r.text or ""
+                    except Exception as read_err:
+                        logger.error(f"DuckDuckGo 读取响应失败: {read_err}")
+                        return ""
                 return ""
 
             html = await asyncio.wait_for(loop.run_in_executor(None, _fetch), timeout=30)
@@ -181,10 +192,21 @@ class WebSearchSkill(Skill):
                     r.raise_for_status()
                 except requests.exceptions.SSLError:
                     logger.warning("Bing SSL 验证失败，跳过证书验证重试")
-                    r = requests.get("https://www.bing.com/search", params={"q": query, "count": num}, headers=_HEADERS, timeout=15, verify=False)
-                    r.raise_for_status()
+                    try:
+                        r = requests.get("https://www.bing.com/search", params={"q": query, "count": num}, headers=_HEADERS, timeout=15, verify=False)
+                        r.raise_for_status()
+                    except Exception as ssl_retry_err:
+                        logger.error(f"Bing SSL 重试也失败: {ssl_retry_err}")
+                        return ""
+                except Exception as req_err:
+                    logger.error(f"Bing 请求失败: {req_err}")
+                    return ""
                 if r is not None:
-                    return r.text or ""
+                    try:
+                        return r.text or ""
+                    except Exception as read_err:
+                        logger.error(f"Bing 读取响应失败: {read_err}")
+                        return ""
                 return ""
 
             html = await asyncio.wait_for(loop.run_in_executor(None, _fetch), timeout=30)
@@ -266,12 +288,23 @@ class WebReadSkill(Skill):
                     r.raise_for_status()
                 except requests.exceptions.SSLError:
                     logger.warning(f"web_read SSL 验证失败 ({url})，跳过证书验证重试")
-                    r = requests.get(url, headers=_HEADERS, timeout=30, verify=False)
-                    r.raise_for_status()
+                    try:
+                        r = requests.get(url, headers=_HEADERS, timeout=30, verify=False)
+                        r.raise_for_status()
+                    except Exception as ssl_retry_err:
+                        logger.error(f"web_read SSL 重试也失败 ({url}): {ssl_retry_err}")
+                        return None
+                except Exception as req_err:
+                    logger.error(f"web_read 请求失败 ({url}): {req_err}")
+                    return None
                 if r is not None:
-                    r.encoding = r.apparent_encoding
-                    return r.text or ""
-                return ""
+                    try:
+                        r.encoding = r.apparent_encoding
+                        return r.text or ""
+                    except Exception as read_err:
+                        logger.error(f"web_read 读取响应内容失败 ({url}): {read_err}")
+                        return None
+                return None
 
             html = await asyncio.wait_for(
                 loop.run_in_executor(None, _fetch), timeout=60
@@ -323,6 +356,7 @@ class WebReadSkill(Skill):
         except asyncio.TimeoutError:
             return SkillResult(success=False, error=f"网页读取超时 (60s): {url}")
         except Exception as e:
+            logger.error(f"web_read 异常 ({url}): {e}", exc_info=True)
             return SkillResult(success=False, error=f"网页读取失败: {e}")
 
 
@@ -369,23 +403,33 @@ class URLReadSkill(Skill):
                     )
                 except requests.exceptions.SSLError:
                     logger.warning(f"url_read SSL 验证失败 ({url})，跳过证书验证重试")
-                    r = requests.request(
-                        method=method,
-                        url=url,
-                        headers=headers,
-                        data=body,
-                        timeout=30,
-                        verify=False,
-                    )
+                    try:
+                        r = requests.request(
+                            method=method,
+                            url=url,
+                            headers=headers,
+                            data=body,
+                            timeout=30,
+                            verify=False,
+                        )
+                    except Exception as ssl_retry_err:
+                        logger.error(f"url_read SSL 重试也失败 ({url}): {ssl_retry_err}")
+                        return None
+                except Exception as req_err:
+                    logger.error(f"url_read 请求失败 ({url}): {req_err}")
+                    return None
                 if r is not None:
                     return r
-                raise requests.exceptions.ConnectionError(f"请求失败: {url}")
+                return None
 
             response = await asyncio.wait_for(loop.run_in_executor(None, _request), timeout=60)
 
+            if response is None:
+                return SkillResult(success=False, error=f"请求失败: 无法连接到 {url}")
+
             try:
                 content = response.json()
-            except ValueError:
+            except (ValueError, AttributeError):
                 content = response.text[:20000]
 
             return SkillResult(
@@ -398,4 +442,5 @@ class URLReadSkill(Skill):
                 message=f"HTTP {response.status_code}",
             )
         except Exception as e:
+            logger.error(f"url_read 异常 ({url}): {e}", exc_info=True)
             return SkillResult(success=False, error=f"请求失败: {e}")