myagent-ai 1.10.7 → 1.10.9

package/agents/main_agent.py

@@ -453,9 +453,9 @@ class MainAgent(BaseAgent):
             except Exception as e:
                 logger.warning(f"[{task_id}] 加载历史对话失败: {e}")
 
-        # 保存用户消息到短期记忆
+        # 保存用户消息到会话记忆
         if self.memory:
-            self.memory.add_short_term(
+            self.memory.add_session(
                 session_id=context.session_id,
                 role="user",
                 content=context.user_message,
@@ -551,9 +551,9 @@ class MainAgent(BaseAgent):
             llm_raw = response.content
             logger.debug(f"[{task_id}] LLM 输出 (前500字): {llm_raw[:500]}")
 
-            # 保存 LLM 原始输出到短期记忆（用于回溯和审计）
+            # 保存 LLM 原始输出到会话记忆（用于回溯和审计）
             if self.memory:
-                self.memory.add_short_term(
+                self.memory.add_session(
                     session_id=context.session_id,
                     role="assistant",
                     content=llm_raw,
@@ -588,7 +588,7 @@ class MainAgent(BaseAgent):
                     context.working_memory["final_response"] = final_text
                     await self._emit_v2_event("v2_reasoning", {"content": final_text}, stream_callback)
                     if self.memory:
-                        self.memory.add_short_term(
+                        self.memory.add_session(
                             session_id=context.session_id,
                             role="assistant",
                             content=final_text,
@@ -601,7 +601,7 @@ class MainAgent(BaseAgent):
                     context.working_memory["final_response"] = final_text
                     await self._emit_v2_event("v2_reasoning", {"content": final_text}, stream_callback)
                     if self.memory:
-                        self.memory.add_short_term(
+                        self.memory.add_session(
                             session_id=context.session_id,
                             role="assistant",
                             content=final_text,
@@ -741,7 +741,7 @@ class MainAgent(BaseAgent):
                     stream_callback,
                 )
                 if self.memory:
-                    self.memory.add_short_term(
+                    self.memory.add_session(
                         session_id=context.session_id,
                         role="assistant",
                         content=parsed.ask_user,
@@ -758,7 +758,7 @@ class MainAgent(BaseAgent):
                     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:
-                        self.memory.add_short_term(
+                        self.memory.add_session(
                             session_id=context.session_id,
                             role="assistant",
                             content=final_text,
@@ -770,7 +770,7 @@ class MainAgent(BaseAgent):
                     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:
-                        self.memory.add_short_term(
+                        self.memory.add_session(
                             session_id=context.session_id,
                             role="assistant",
                             content=final_text,
@@ -1006,16 +1006,16 @@ class MainAgent(BaseAgent):
                     content=f"[工具 {tool_name} 执行完成] {'成功' if tool_result.get('success') else '失败'}",
                 ))
 
-                # 保存工具调用到短期记忆
+                # 保存工具调用到会话记忆
                 if self.memory:
-                    self.memory.add_short_term(
+                    self.memory.add_session(
                         session_id=context.session_id,
                         role="assistant",
                         content=f"调用工具: {tool_name}\n参数: {truncate_str(parms, 1000)}",
                         key="tool_call",
                         importance=0.4,
                     )
-                    self.memory.add_short_term(
+                    self.memory.add_session(
                         session_id=context.session_id,
                         role="tool",
                         content=f"[{tool_name}] {'成功' if tool_result.get('success') else '失败'}\n{truncate_str(output_str, 5000)}",
@@ -1048,7 +1048,7 @@ class MainAgent(BaseAgent):
                 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:
-                    self.memory.add_short_term(
+                    self.memory.add_session(
                         session_id=context.session_id,
                         role="assistant",
                         content=final_text,
@@ -1075,7 +1075,7 @@ class MainAgent(BaseAgent):
                 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:
-                    self.memory.add_short_term(
+                    self.memory.add_session(
                         session_id=context.session_id,
                         role="assistant",
                         content=final_text,
@@ -1084,14 +1084,14 @@ class MainAgent(BaseAgent):
 
             logger.info(f"[{task_id}] finish=false 且 need_callback=true，回调 LLM...")
 
-            # 回调前，保存当前轮次的 LLM 输出到短期记忆
+            # 回调前，保存当前轮次的 LLM 输出到会话记忆
             # 这样每轮工具调用都有对应的 assistant 消息记录
             if self.memory:
                 _round_items = _v2_reasoning_collected[_reasoning_len_before_round:]
                 if _round_items:
                     _round_output = "\n".join(_round_items)
                     if _round_output.strip():
-                        self.memory.add_short_term(
+                        self.memory.add_session(
                             session_id=context.session_id,
                             role="assistant",
                             content=_round_output,
@@ -1102,7 +1102,7 @@ class MainAgent(BaseAgent):
             if self.memory and _v2_reasoning_collected:
                 _fallback_text = "\n".join(_v2_reasoning_collected)
                 if _fallback_text.strip():
-                    self.memory.add_short_term(
+                    self.memory.add_session(
                         session_id=context.session_id,
                         role="assistant",
                         content=_fallback_text,
@@ -1137,6 +1137,10 @@ class MainAgent(BaseAgent):
                 code_lang = params.get("language", "python")
                 code_text = params.get("code", parms_str)
                 if self.executor:
+                    # 注入权限检查器（V1 路径在 api_server 中设置，V2 路径需要在此设置）
+                    self.executor.set_permission_checker(
+                        self.check_permission, self.name
+                    )
                     exec_result = await self.executor.execute(
                         language=code_lang,
                         code=code_text,
@@ -1149,6 +1153,10 @@ class MainAgent(BaseAgent):
             elif tool_name == "command" or tool_name == "command_run":
                 code_text = params.get("command", parms_str)
                 if self.executor:
+                    # 注入权限检查器（V1 路径在 api_server 中设置，V2 路径需要在此设置）
+                    self.executor.set_permission_checker(
+                        self.check_permission, self.name
+                    )
                     exec_result = await self.executor.execute(
                         language="shell",
                         code=code_text,

package/agents/memory_agent.py

@@ -116,7 +116,7 @@ class MemoryAgent(BaseAgent):
                 )
 
         # 修剪旧消息
-        max_msgs = self.config.memory.max_short_term
+        max_msgs = self.config.memory.max_session
         self.memory.prune_conversation(session_id, max_msgs)
 
         logger.debug(f"对话已保存到会话记忆 (session={session_id})")
@@ -162,7 +162,7 @@ class MemoryAgent(BaseAgent):
         if not self.memory:
             return
 
-        entries = self.memory.get_working(session_id)
+        entries = self.memory._query(session_id=session_id, category="session", limit=100)
         context.working_memory["task_progress"] = [
             {"key": e.key, "content": e.content, "metadata": e.metadata}
             for e in entries

package/config.py

@@ -50,11 +50,6 @@ class MemoryConfig:
     auto_summarize: bool = True        # 自动总结开关
     summarize_threshold: int = 20      # 触发总结的对话轮数
 
-    # 兼容旧配置名
-    @property
-    def max_short_term(self) -> int:
-        return self.max_session
-
 
 @dataclass
 class ExecutorConfig:

package/main.py

@@ -218,6 +218,10 @@ class MyAgentApp:
             max_retries=exe_cfg.max_retries,
             auto_fix=exe_cfg.auto_fix,
             max_output_length=exe_cfg.max_output_length,
+            execution_mode=exe_cfg.execution_mode,
+            sandbox_image=exe_cfg.sandbox_image,
+            sandbox_network=exe_cfg.sandbox_network,
+            sandbox_memory=exe_cfg.sandbox_memory,
         )
         self.logger.info(f"执行引擎: timeout={exe_cfg.timeout}s, auto_fix={exe_cfg.auto_fix}")
 

package/memory/manager.py

@@ -6,10 +6,6 @@ memory/manager.py - 记忆管理器
   - 会话记忆 (session): 当前会话的对话上下文和任务进度，仅本 session 可检索
 
 所有记忆通过 session_id 隔离，全局记忆可跨会话检索。
-
-向后兼容:
-  旧 API (add_short_term, add_working, add_long_term) 仍然可用，
-  内部自动映射到新的 session / global 分类。
 """
 from __future__ import annotations
 
@@ -95,23 +91,13 @@ class MemoryManager:
       - session (会话记忆): 对话上下文 + 任务进度，按 session_id 隔离
       - global  (全局记忆): 跨会话持久知识，所有 session 可检索
 
-    向后兼容:
-      旧方法 add_short_term / add_working / add_long_term 仍可正常使用，
-      内部自动映射到 session / global 分类。
-      旧分类值 short_term、working、long_term 在查询时自动包含。
-
     使用示例:
         mm = MemoryManager(db_path="~/.myagent/data/memory.db")
         mm.initialize()
 
-        # 新 API
         mm.add_session("s1", role="user", content="帮我创建一个Python项目")
         mm.add_global(content="偏好使用Python, TypeScript")
 
-        # 旧 API (仍然可用)
-        mm.add_short_term("s1", "user", "帮我创建一个Python项目")
-        mm.add_long_term("user_prefs", "coding_style", "偏好使用Python, TypeScript")
-
         # 查询对话历史
         history = mm.get_conversation("s1")
 
@@ -183,29 +169,6 @@ class MemoryManager:
             self._local.conn.close()
             self._local.conn = None
 
-    # ==========================================================================
-    # 分类映射 (向后兼容)
-    # ==========================================================================
-
-    def _normalize_category(self, category: str) -> str:
-        """Map old category values to new ones:
-        short_term, working → session
-        long_term → global
-        """
-        _MAP = {"short_term": "session", "working": "session", "long_term": "global"}
-        return _MAP.get(category, category)
-
-    def _expand_category(self, category: str) -> list:
-        """Expand category for SQL IN clause (backward compat):
-        "session" → ["session", "short_term", "working"]
-        "global" → ["global", "long_term"]
-        """
-        if category == "session":
-            return ["session", "short_term", "working"]
-        elif category == "global":
-            return ["global", "long_term"]
-        return [category]
-
     # ==========================================================================
     # 基础 CRUD
     # ==========================================================================
@@ -252,10 +215,8 @@ class MemoryManager:
             conditions.append("session_id = ?")
             params.append(session_id)
         if category:
-            expanded = self._expand_category(category)
-            placeholders = ",".join("?" for _ in expanded)
-            conditions.append(f"category IN ({placeholders})")
-            params.extend(expanded)
+            conditions.append("category = ?")
+            params.append(category)
         if key:
             conditions.append("key = ?")
             params.append(key)
@@ -323,58 +284,13 @@ class MemoryManager:
         )
         return self._insert(entry)
 
-    # --- 兼容别名 ---
-    def add_short_term(self, session_id, role, content, key="", importance=0.5) -> str:
-        """[兼容] → add_session()"""
-        return self.add_session(session_id=session_id, role=role, content=content, key=key, importance=importance)
-
-    def add_working(self, session_id, key, content, metadata=None) -> str:
-        """[兼容] → add_session()"""
-        return self.add_session(session_id=session_id, key=key, content=content, importance=0.7, metadata=metadata or {})
-
-    def get_working(self, session_id, key="") -> List[MemoryEntry]:
-        """[兼容] 获取会话记忆中 key 非空的条目"""
-        conn = self._get_conn()
-        cats = self._expand_category("session")
-        placeholders = ",".join("?" for _ in cats)
-        conditions = [f"session_id = ?", f"category IN ({placeholders})", "key != ''"]
-        params = [session_id] + cats
-        if key:
-            conditions.append("key = ?")
-            params.append(key)
-        where = " AND ".join(conditions)
-        sql = f"SELECT * FROM memories WHERE {where} ORDER BY created_at DESC LIMIT 100"
-        rows = conn.execute(sql, params).fetchall()
-        return [MemoryEntry.from_row(row) for row in rows]
-
-    def update_working(self, memory_id, content, **updates):
-        """[兼容] → _update_content()"""
-        self._update_content(memory_id, content, **updates)
-
-    def clear_working(self, session_id) -> int:
-        """[兼容] 清空会话记忆中 key 非空的条目"""
-        conn = self._get_conn()
-        cats = self._expand_category("session")
-        placeholders = ",".join("?" for _ in cats)
-        params = [session_id] + cats
-        cursor = conn.execute(
-            f"DELETE FROM memories WHERE session_id = ? AND category IN ({placeholders}) AND key != ''",
-            params,
-        )
-        conn.commit()
-        return cursor.rowcount
-
     def get_conversation(self, session_id, limit=500, include_roles=None) -> List[MemoryEntry]:
-        """获取对话历史（搜索 session 分类中 role 非空的条目，兼容旧 short_term 数据）"""
+        """获取对话历史（session 分类中 role 非空的条目）"""
         conn = self._get_conn()
-        cats = self._expand_category("session")
-        placeholders = ",".join("?" for _ in cats)
-        conditions = ["session_id = ?", f"category IN ({placeholders})", "role != ''"]
-        params = [session_id] + cats
-        where = " AND ".join(conditions)
-        sql = f"SELECT * FROM memories WHERE {where} ORDER BY created_at ASC LIMIT ?"
-        params.append(limit)
-        rows = conn.execute(sql, params).fetchall()
+        sql = """SELECT * FROM memories 
+                 WHERE session_id = ? AND category = 'session' AND role != ''
+                 ORDER BY created_at ASC LIMIT ?"""
+        rows = conn.execute(sql, (session_id, limit)).fetchall()
         entries = [MemoryEntry.from_row(row) for row in rows]
         if include_roles:
             entries = [e for e in entries if e.role in include_roles]
@@ -403,14 +319,7 @@ class MemoryManager:
 
     def clear_conversation(self, session_id) -> int:
         """清空会话对话历史"""
-        count = self._delete(session_id, category="session")
-        # 兼容旧数据
-        for old_cat in ("short_term", "working"):
-            try:
-                count += self._delete(session_id, category=old_cat)
-            except Exception:
-                pass
-        return count
+        return self._delete(session_id, category="session")
 
     def delete_session(self, session_id: str) -> int:
         """删除会话的所有记忆（对话、工作记忆、长期记忆等），彻底删除该会话"""
@@ -504,11 +413,6 @@ class MemoryManager:
         )
         return self._insert(entry)
 
-    # --- 兼容别名 ---
-    def add_long_term(self, session_id="global", key="", content="", summary="", importance=0.7, metadata=None) -> str:
-        """[兼容] → add_global()"""
-        return self.add_global(session_id=session_id, key=key, content=content, summary=summary, importance=importance, metadata=metadata)
-
     def find_duplicate_memory(
         self,
         content: str,
@@ -535,10 +439,8 @@ class MemoryManager:
             return None  # 空内容不查重
 
         conn = self._get_conn()
-        cats = self._expand_category("global")
-        placeholders = ",".join("?" for _ in cats)
-        conditions = [f"category IN ({placeholders})"]
-        params: list = list(cats)
+        conditions = ["category = 'global'"]
+        params: list = []
 
         if session_id:
             conditions.append("session_id = ?")
@@ -633,13 +535,11 @@ class MemoryManager:
             return True
         return False
 
-    def get_long_term(self, session_id="global", key="", limit=50) -> List[MemoryEntry]:
+    def get_global_memories(self, session_id="global", key="", limit=50) -> List[MemoryEntry]:
         """获取全局记忆"""
         conn = self._get_conn()
-        cats = self._expand_category("global")
-        placeholders = ",".join("?" for _ in cats)
-        conditions = ["category IN (%s)" % placeholders]
-        params = list(cats)
+        conditions = ["category = 'global'"]
+        params: list = []
         if session_id:
             conditions.insert(0, "session_id = ?")
             params.insert(0, session_id)
@@ -654,15 +554,15 @@ class MemoryManager:
 
     def get_preferences(self, session_id: str = "global") -> List[MemoryEntry]:
         """获取用户偏好"""
-        return self.get_long_term(session_id, key="user_pref")
+        return self.get_global_memories(session_id, key="user_pref")
 
     def get_experience(self, session_id: str = "global") -> List[MemoryEntry]:
         """获取技能经验"""
-        return self.get_long_term(session_id, key="skill_experience")
+        return self.get_global_memories(session_id, key="skill_experience")
 
     def get_task_summaries(self, session_id: str = "global") -> List[MemoryEntry]:
         """获取历史任务总结"""
-        return self.get_long_term(session_id, key="task_summary")
+        return self.get_global_memories(session_id, key="task_summary")
 
     # ==========================================================================
     # 记忆搜索
@@ -812,10 +712,8 @@ class MemoryManager:
             conditions.append("session_id = ?")
             params.append(session_id)
         if category:
-            expanded = self._expand_category(category)
-            placeholders = ",".join("?" for _ in expanded)
-            conditions.append(f"category IN ({placeholders})")
-            params.extend(expanded)
+            conditions.append("category = ?")
+            params.append(category)
 
         # 过滤过期
         conditions.append("(expires_at = '' OR expires_at > ?)")
@@ -959,7 +857,7 @@ class MemoryManager:
         original_count: int = 0,
     ) -> str:
         """保存对话总结为全局记忆"""
-        return self.add_long_term(
+        return self.add_global(
             session_id=session_id,
             key="conversation_summary",
             content=summary,
@@ -985,7 +883,7 @@ class MemoryManager:
         session_id: str = "global",
     ):
         """记录错误模式及修复方案"""
-        self.add_long_term(
+        self.add_global(
             session_id=session_id,
             key="error_pattern",
             content=f"错误: {error}\n修复: {fix}",
@@ -1002,22 +900,17 @@ class MemoryManager:
         conn = self._get_conn()
         stats = {}
         for cat in ("session", "global"):
-            cats = self._expand_category(cat)
-            placeholders = ",".join("?" for _ in cats)
             row = conn.execute(
-                f"SELECT COUNT(*) as cnt FROM memories WHERE category IN ({placeholders})",
-                cats,
+                "SELECT COUNT(*) as cnt FROM memories WHERE category = ?",
+                (cat,),
             ).fetchone()
             stats[f"{cat}_count"] = row["cnt"]
-
         total = conn.execute("SELECT COUNT(*) as cnt FROM memories").fetchone()
         stats["total_count"] = total["cnt"]
-
         sessions = conn.execute(
             "SELECT COUNT(DISTINCT session_id) as cnt FROM memories"
         ).fetchone()
         stats["distinct_sessions"] = sessions["cnt"]
-
         return stats
 
     def cleanup_expired(self) -> int:

package/package.json

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