myagent-ai 1.10.0 → 1.10.1

package/agents/main_agent.py

@@ -323,12 +323,29 @@ class MainAgent(BaseAgent):
 
         conversation_history = list(context.conversation_history or [])
 
+        # 从 DB 加载历史对话（如果 conversation_history 为空且 memory 可用）
+        if self.memory and not conversation_history:
+            try:
+                db_history = self.memory.get_conversation(
+                    session_id=context.session_id,
+                    limit=100,
+                )
+                if db_history:
+                    conversation_history = [
+                        Message(role=entry.role, content=entry.content)
+                        for entry in db_history
+                    ]
+                    logger.info(f"[{task_id}] 从 DB 加载了 {len(conversation_history)} 条历史对话")
+            except Exception as e:
+                logger.warning(f"[{task_id}] 加载历史对话失败: {e}")
+
         # 保存用户消息到短期记忆
         if self.memory:
             self.memory.add_short_term(
                 session_id=context.session_id,
                 role="user",
                 content=context.user_message,
+                key="user_input",
             )
 
         # 加载相关记忆 (recall from previous round or initial load)
@@ -391,7 +408,6 @@ class MainAgent(BaseAgent):
                 + self.SYSTEM_PROMPT.split("\n", 1)[1]
             )
             system_content = _prompt_with_placeholder.replace(_CONTEXT_PLACEHOLDER, context_xml)
-            print(system_content)
             # Step 3: 调用 LLM
             messages = [Message(role="system", content=system_content)]
 
@@ -420,6 +436,16 @@ class MainAgent(BaseAgent):
             llm_raw = response.content
             logger.debug(f"[{task_id}] LLM 输出 (前500字): {llm_raw[:500]}")
 
+            # 保存 LLM 原始输出到短期记忆（用于回溯和审计）
+            if self.memory:
+                self.memory.add_short_term(
+                    session_id=context.session_id,
+                    role="assistant",
+                    content=llm_raw,
+                    key="llm_output",
+                    importance=0.3,
+                )
+
             # Step 4: 解析结构化输出
             parsed = parse_output(llm_raw)
 
@@ -667,11 +693,30 @@ class MainAgent(BaseAgent):
                 )
 
                 # 发送工具结果事件
+                # 提取实际输出：SkillResult 有 output/message/data，ExecResult 有 stdout/stderr
+                def _extract_tool_output(tr):
+                    """从工具结果中提取实际输出文本"""
+                    out = tr.get("output", "")
+                    if out:
+                        return out
+                    out = tr.get("message", "")
+                    if out:
+                        return out
+                    out = tr.get("stdout", "")
+                    if out:
+                        return out
+                    data = tr.get("data")
+                    if data is not None:
+                        return str(data) if not isinstance(data, str) else data
+                    return tr.get("error", "")
+
+                tool_output_text = _extract_tool_output(tool_result)
+
                 await self._emit_v2_event(
                     "v2_tool_result",
                     {"tool": {"toolname": tool_name}, "result": {
                         "success": tool_result.get("success", False),
-                        "output": truncate_str(tool_result.get("output", ""), 3000),
+                        "output": truncate_str(tool_output_text, 3000),
                         "error": truncate_str(tool_result.get("error", ""), 1000),
                         "timed_out": tool_result.get("timed_out", False),
                     }},
@@ -682,7 +727,7 @@ class MainAgent(BaseAgent):
                     "title": f"工具结果: {tool_name}",
                     "tool_name": tool_name,
                     "success": tool_result.get("success", False),
-                    "summary": truncate_str(str(tool_result.get("output", tool_result.get("error", ""))), 500),
+                    "summary": truncate_str(tool_output_text, 500),
                     "result": tool_result,
                 })
 
@@ -693,7 +738,7 @@ class MainAgent(BaseAgent):
                 elif should_callback:
                     need_callback = True
 
-                output_str = tool_result.get("output", "") or tool_result.get("error", "")
+                output_str = tool_output_text
                 tool_outputs_parts.append(
                     f"### {before_call}\n"
                     f"**工具**: {tool_name}\n"
@@ -710,6 +755,23 @@ class MainAgent(BaseAgent):
                     content=f"[工具 {tool_name} 执行完成] {'成功' if tool_result.get('success') else '失败'}",
                 ))
 
+                # 保存工具调用到短期记忆
+                if self.memory:
+                    self.memory.add_short_term(
+                        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(
+                        session_id=context.session_id,
+                        role="tool",
+                        content=f"[{tool_name}] {'成功' if tool_result.get('success') else '失败'}\n{truncate_str(output_str, 5000)}",
+                        key="tool_result",
+                        importance=0.4,
+                    )
+
             all_tool_outputs = "\n".join(tool_outputs_parts)
 
             # Step 12: 工具执行完毕后，根据 finish 标志决定是否回调 LLM

package/core/context_builder.py

@@ -118,10 +118,11 @@ class ContextBuilder:
         kb_query = get_knowledge.strip() if get_knowledge else query
 
         sections: List[str] = [
+            self._build_datetime(),
             self._build_whomi(agent_name, agent_description, agent_override_prompt),
             self._build_memory(query, session_id),
             self._build_knowledge(kb_query),
-            self._build_recent_dialog(conversation_history, self.max_dialog_chars),
+            self._build_recent_dialog(conversation_history, self.max_dialog_chars, session_id),
             self._build_user_input(user_typed_text, user_voice_text),
             self._build_task_plan(task_plan),
             self._build_tools(self.skill_registry),
@@ -140,6 +141,24 @@ class ContextBuilder:
     # 各段落构建方法
     # =========================================================================
 
+    def _build_datetime(self) -> str:
+        """
+        构建 <datetime> 段落 —— 当前日期时间（精确到秒）。
+        让 LLM 知道当前时间，以便给出与时间相关的回答。
+        """
+        from datetime import datetime
+        now = datetime.now()
+        weekdays = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
+        date_str = now.strftime("%Y年%m月%d日")
+        time_str = now.strftime("%H:%M:%S")
+        weekday = weekdays[now.weekday()]
+        return (
+            f"<datetime>\n"
+            f"当前时间: {date_str} {weekday} {time_str}\n"
+            f"时间戳: {now.timestamp()}\n"
+            f"</datetime>"
+        )
+
     def _build_whomi(
         self,
         agent_name: str,
@@ -275,16 +294,18 @@ class ContextBuilder:
         self,
         conversation_history: List["Message"],
         max_chars: int,
+        session_id: str = "",
     ) -> str:
         """
         构建 <resentdialog> 段落 —— 近期对话历史。
 
-        将对话格式化为带角色标签的文本，并截断到指定最大字符数。
-        保留 agent (assistant) 和 user 的消息，使用中文标签。
+        将对话格式化为带角色标签的文本。当历史过长时，将较早的消息
+        压缩为摘要，保留近期消息完整呈现，总字符数不超过 max_chars。
 
         Args:
             conversation_history: 对话历史消息列表
             max_chars: 最大字符数限制
+            session_id: 会话 ID（用于 MemoryManager 摘要）
 
         Returns:
             <resentdialog> XML 段落字符串
@@ -300,32 +321,126 @@ class ContextBuilder:
             "tool": "工具",
         }
 
-        # 格式化每条消息
-        formatted_lines: List[str] = []
+        # 过滤空消息并格式化
+        filtered_msgs: List[tuple] = []
         for msg in conversation_history:
             role = getattr(msg, "role", "user")
             content = getattr(msg, "content", "")
             if not content.strip():
                 continue
-
             label = role_labels.get(role, role)
-            formatted_lines.append(f"[{label}] {_xml_escape(content.strip())}")
+            filtered_msgs.append((label, content.strip()))
+
+        if not filtered_msgs:
+            return "<resentdialog>\n(无对话历史)\n</resentdialog>"
+
+        # 当消息超过阈值时，将旧消息压缩为摘要
+        SUMMARY_THRESHOLD = 30  # 超过30条时启用摘要
+        RECENT_KEEP = 15        # 保留最近15条完整消息
+        SUMMARY_BUDGET = 3000   # 摘要最大字符数
+
+        prefix_text = ""
+        recent_msgs = filtered_msgs
+
+        if len(filtered_msgs) > SUMMARY_THRESHOLD:
+            old_msgs = filtered_msgs[:-RECENT_KEEP]
+            recent_msgs = filtered_msgs[-RECENT_KEEP:]
+            prefix_text = self._build_dialog_summary(old_msgs, SUMMARY_BUDGET)
+
+        # 格式化近期消息
+        formatted_lines: List[str] = []
+        if prefix_text:
+            formatted_lines.append(prefix_text)
+            formatted_lines.append("")  # 空行分隔
+
+        for label, content in recent_msgs:
+            formatted_lines.append(f"[{label}] {_xml_escape(content)}")
 
         dialog_text = "\n".join(formatted_lines)
 
-        # 截断到最大字符数
+        # Token 预算裁剪：超预算时从最早的消息开始移除
         if len(dialog_text) > max_chars:
-            # 从尾部截断，避免丢失最新的对话
-            dialog_text = dialog_text[-max_chars:]
-            # 从截断点找到最近的换行符以保持完整性
-            newline_pos = dialog_text.find("\n")
-            if newline_pos > 0 and newline_pos < 500:
-                dialog_text = dialog_text[newline_pos + 1:]
-            # 添加截断标记
-            dialog_text = "(... 前面的对话已被截断 ...)\n" + dialog_text
+            # 保留摘要前缀，裁剪近期消息部分
+            if prefix_text:
+                # 先尝试只裁剪近期消息
+                recent_budget = max_chars - len(prefix_text) - 100
+                if recent_budget < 500:
+                    # 摘要本身太长，整体裁剪
+                    dialog_text = dialog_text[-max_chars:]
+                else:
+                    recent_part = "\n".join(formatted_lines[len(formatted_lines) - len(recent_msgs):])
+                    if len(recent_part) > recent_budget:
+                        recent_part = self._trim_messages_from_start(recent_part, recent_budget)
+                    dialog_text = prefix_text + "\n\n" + recent_part
+            else:
+                dialog_text = self._trim_messages_from_start(dialog_text, max_chars)
+            dialog_text = "(... 前面的对话已被裁剪 ...)\n" + dialog_text
 
         return f"<resentdialog>\n{dialog_text}\n</resentdialog>"
 
+    def _build_dialog_summary(self, old_msgs: List[tuple], max_chars: int) -> str:
+        """
+        将旧消息列表压缩为摘要文本。
+
+        策略: 提取每条消息的第一行作为要点，保留关键信息的同时大幅压缩篇幅。
+        如果有 MemoryManager，也可以调用 LLM 生成摘要（未来扩展）。
+
+        Args:
+            old_msgs: (label, content) 元组列表
+            max_chars: 摘要最大字符数
+
+        Returns:
+            摘要文本字符串
+        """
+        if not old_msgs:
+            return ""
+
+        summary_parts: List[str] = ["[历史对话摘要]"]
+        for label, content in old_msgs:
+            # 提取第一行或前100字符作为要点
+            first_line = content.split("\n")[0].strip()
+            if len(first_line) > 100:
+                first_line = first_line[:100] + "..."
+            summary_parts.append(f"- [{label}] {first_line}")
+
+        summary_text = "\n".join(summary_parts)
+
+        # 摘要本身也要限制长度
+        if len(summary_text) > max_chars:
+            summary_text = summary_text[:max_chars] + "\n... (更多历史已省略)"
+
+        return summary_text
+
+    def _trim_messages_from_start(self, text: str, max_chars: int) -> str:
+        """
+        从文本开头裁剪消息，保留尾部（最新消息优先）。
+
+        按行（即按消息）为单位裁剪，避免在消息中间截断。
+
+        Args:
+            text: 格式化后的对话文本
+            max_chars: 最大保留字符数
+
+        Returns:
+            裁剪后的文本
+        """
+        if len(text) <= max_chars:
+            return text
+
+        lines = text.split("\n")
+        result_lines: List[str] = []
+        total = 0
+
+        # 从后往前添加行，保留最新的消息
+        for line in reversed(lines):
+            if total + len(line) + 1 > max_chars:
+                break
+            result_lines.append(line)
+            total += len(line) + 1
+
+        result_lines.reverse()
+        return "\n".join(result_lines)
+
     def _build_user_input(
         self,
         user_typed_text: str,

package/departments/manager.py

@@ -203,16 +203,22 @@ class DepartmentManager:
         if not name:
             return {"ok": False, "message": "部门名称不能为空"}
 
+        # 清理部门名称：移除空格和特殊字符，保留中英文、数字、下划线、连字符
+        import re
+        clean_name = re.sub(r'[^\w\u4e00-\u9fff-]', '', name)
+        if not clean_name:
+            return {"ok": False, "message": "部门名称包含无效字符"}
+
         # 安全校验
         if not self._validate_path(parent):
             return {"ok": False, "message": "非法的父部门路径"}
-        if not self._validate_path(name):
+        if not self._validate_path(clean_name):
             return {"ok": False, "message": "非法的部门名称"}
-        if "/" in name or "\\" in name:
+        if "/" in clean_name or "\\" in clean_name:
             return {"ok": False, "message": "部门名称不能包含 / 或 \\"}
 
-        # 构建完整路径
-        dept_path = f"{parent}/{name}" if parent else name
+        # 构建完整路径（使用清理后的名称作为目录名）
+        dept_path = f"{parent}/{clean_name}" if parent else clean_name
 
         # 检查是否已存在
         dept_dir = self._dept_dir(dept_path)
@@ -243,13 +249,14 @@ class DepartmentManager:
                 encoding="utf-8",
             )
 
-            # 自动创建群聊
+            # 自动创建群聊（部门群不带默认 owner，成员由 assign_agent 添加）
             chat_group_id = ""
             if self._group_manager:
                 try:
                     group_name = f"部门: {name}"
                     group = self._group_manager.create_group(
                         name=group_name,
+                        owner="",  # 部门群无默认 owner
                         description=description or f"{name} 部门群聊",
                         avatar_emoji=emoji or "🏢",
                     )
@@ -559,6 +566,20 @@ class DepartmentManager:
                             logger.warning(
                                 f"添加 {agent} 到群聊失败 ({chat_group_id}): {e}"
                             )
+                        # 如果部门群没有 owner，将第一个 agent 设为 owner
+                        if not meta.get("head") and self._group_manager:
+                            try:
+                                group = self._group_manager.get_group(chat_group_id)
+                                if group and not group.owner:
+                                    group.owner = agent
+                                    self._group_manager.add_member(
+                                        chat_group_id, agent, role="owner"
+                                    )
+                                    meta["head"] = agent
+                            except Exception as e:
+                                logger.warning(
+                                    f"设置部门群 owner 失败 ({chat_group_id}): {e}"
+                                )
             msg = f"已添加 {len(agents)} 个成员"
         elif action == "remove":
             removed = [a for a in agents if a in current_agents]
@@ -638,6 +659,40 @@ class DepartmentManager:
         logger.info(f"部门 {path} 负责人已{action}: {head or '无'}")
         return {"ok": True, "meta": meta, "message": f"已{action}负责人"}
 
+    def update_dept_meta(
+        self,
+        path: str,
+        description: str = None,
+        head: str = None,
+    ) -> Dict[str, Any]:
+        """
+        更新部门元数据（描述、负责人等），不修改 dept.md。
+
+        Args:
+            path: 部门路径
+            description: 新描述（None=不修改）
+            head: 负责人 Agent 路径（None=不修改）
+
+        Returns:
+            {ok, meta, message}
+        """
+        if not self._validate_path(path):
+            return {"ok": False, "message": "非法路径"}
+
+        meta = self._load_meta(path)
+        if not meta:
+            return {"ok": False, "message": f"部门不存在: {path}"}
+
+        if description is not None:
+            meta["description"] = description
+        if head is not None:
+            meta["head"] = head
+        meta["updated_at"] = timestamp()
+        self._save_meta(path, meta)
+
+        logger.info(f"部门 {path} 元数据已更新")
+        return {"ok": True, "meta": meta, "message": "已更新"}
+
     # ==========================================================================
     # 部门介绍（dept.md）
     # ==========================================================================

package/groups/manager.py

@@ -323,14 +323,15 @@ class GroupManager:
             owner=owner,
         )
 
-        # 添加创建者为群主
-        owner_member = GroupMember(agent_path=owner, role="owner")
-        group.add_member(owner_member)
+        # 添加创建者为群主（仅当 owner 非空时）
+        if owner:
+            owner_member = GroupMember(agent_path=owner, role="owner")
+            group.add_member(owner_member)
 
         # 添加额外成员
         if member_paths:
             for mp in member_paths:
-                if mp != owner:
+                if mp and mp != owner:
                     group.add_member(GroupMember(agent_path=mp, role="member"))
 
         self._groups[group.id] = group

package/package.json

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