myagent-ai 1.0.0

package/agents/memory_agent.py

@@ -0,0 +1,313 @@
+"""
+agents/memory_agent.py - 记忆 Agent
+=====================================
+负责读写记忆、总结经验、检索历史知识。
+主 Agent 通过 MemoryAgent 间接操作记忆系统。
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional
+
+from core.logger import get_logger
+from core.llm import Message
+from agents.base import BaseAgent, AgentContext
+from core.utils import timestamp
+
+logger = get_logger("myagent.agent.memory")
+
+
+class MemoryAgent(BaseAgent):
+    """
+    记忆管理 Agent。
+
+    职责:
+      - 对话上下文管理(短期记忆)
+      - 任务进度跟踪(工作记忆)
+      - 知识/经验存储(长期记忆)
+      - 记忆检索与总结
+      - 错误模式记录(避免重复犯错)
+    """
+
+    name = "memory_agent"
+    description = "负责记忆管理和知识检索的专业Agent"
+
+    # 记忆总结系统提示词
+    SUMMARY_PROMPT = """你是一个记忆总结专家。请将以下对话历史总结为简洁的知识要点。
+
+要求:
+1. 提取关键信息: 任务目标、执行步骤、结果、教训
+2. 标记重要偏好和约束
+3. 记录有用的代码片段和命令
+4. 识别错误和修复方法
+5. 输出 JSON 格式:
+{
+  "summary": "一句话总结",
+  "key_points": ["要点1", "要点2"],
+  "preferences": {"偏好领域": "偏好值"},
+  "errors_learned": [{"error": "错误描述", "fix": "修复方法"}],
+  "useful_commands": ["命令1", "命令2"],
+  "importance": 0.8
+}"""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._auto_summarize = True
+
+    async def process(self, context: AgentContext) -> AgentContext:
+        """
+        处理记忆相关请求。
+
+        通过 context.metadata["memory_action"] 指定操作:
+          - save_conversation: 保存对话到短期记忆
+          - get_context: 获取当前对话上下文
+          - save_progress: 保存工作进度
+          - get_progress: 获取工作进度
+          - search: 搜索记忆
+          - summarize: 总结当前对话
+          - record_error: 记录错误模式
+          - save_preference: 保存用户偏好
+          - get_relevant: 获取与当前任务相关的历史记忆
+        """
+        action = context.metadata.get("memory_action", "")
+        session_id = context.session_id
+
+        try:
+            if action == "save_conversation":
+                await self._save_conversation(context, session_id)
+            elif action == "get_context":
+                await self._get_context(context, session_id)
+            elif action == "save_progress":
+                await self._save_progress(context, session_id)
+            elif action == "get_progress":
+                await self._get_progress(context, session_id)
+            elif action == "search":
+                await self._search(context, session_id)
+            elif action == "summarize":
+                await self._summarize(context, session_id)
+            elif action == "record_error":
+                await self._record_error(context, session_id)
+            elif action == "save_preference":
+                await self._save_preference(context, session_id)
+            elif action == "get_relevant":
+                await self._get_relevant(context, session_id)
+            else:
+                logger.warning(f"未知的记忆操作: {action}")
+
+        except Exception as e:
+            logger.error(f"记忆 Agent 处理失败: {e}")
+            context.working_memory["memory_error"] = str(e)
+
+        return context
+
+    async def _save_conversation(self, context: AgentContext, session_id: str):
+        """保存对话消息到短期记忆"""
+        if not self.memory:
+            return
+
+        for msg in context.conversation_history:
+            if msg.role in ("user", "assistant", "system", "tool"):
+                # 避免重复保存
+                self.memory.add_short_term(
+                    session_id=session_id,
+                    role=msg.role,
+                    content=msg.content,
+                    key=f"conv_{msg.role}",
+                )
+
+        # 修剪旧消息
+        max_msgs = self.config.memory.max_short_term
+        self.memory.prune_conversation(session_id, max_msgs)
+
+        logger.debug(f"对话已保存到短期记忆 (session={session_id})")
+
+    async def _get_context(self, context: AgentContext, session_id: str):
+        """获取对话上下文"""
+        if not self.memory:
+            return
+
+        entries = self.memory.get_conversation(session_id, limit=50)
+        context.working_memory["conversation_context"] = [
+            {"role": e.role, "content": e.content} for e in entries
+        ]
+        logger.debug(f"已加载对话上下文: {len(entries)} 条")
+
+    async def _save_progress(self, context: AgentContext, session_id: str):
+        """保存任务进度到工作记忆"""
+        if not self.memory:
+            return
+
+        progress = context.metadata.get("progress_data", {})
+        for key, value in progress.items() if isinstance(progress, dict) else []:
+            self.memory.add_working(
+                session_id=session_id,
+                key=key,
+                content=str(value) if not isinstance(value, str) else value,
+            )
+
+        # 也保存整体状态
+        task_status = context.working_memory.get("task_status", "进行中")
+        self.memory.add_working(
+            session_id=session_id,
+            key="task_status",
+            content=task_status,
+            metadata=context.working_memory,
+        )
+        logger.debug(f"工作进度已保存 (session={session_id})")
+
+    async def _get_progress(self, context: AgentContext, session_id: str):
+        """获取工作进度"""
+        if not self.memory:
+            return
+
+        entries = self.memory.get_working(session_id)
+        context.working_memory["task_progress"] = [
+            {"key": e.key, "content": e.content, "metadata": e.metadata}
+            for e in entries
+        ]
+        logger.debug(f"已加载工作进度: {len(entries)} 条")
+
+    async def _search(self, context: AgentContext, session_id: str):
+        """搜索记忆"""
+        if not self.memory:
+            return
+
+        query = context.metadata.get("search_query", context.user_message)
+        category = context.metadata.get("search_category", "")
+        limit = context.metadata.get("search_limit", 10)
+
+        results = self.memory.search(query, session_id=session_id,
+                                     category=category, limit=limit)
+        context.working_memory["search_results"] = [
+            {
+                "id": e.id,
+                "category": e.category,
+                "key": e.key,
+                "content": e.content[:2000],
+                "summary": e.summary,
+                "importance": e.importance,
+                "created_at": e.created_at,
+            }
+            for e in results
+        ]
+
+    async def _summarize(self, context: AgentContext, session_id: str):
+        """总结当前对话"""
+        if not self.memory or not self.llm:
+            return
+
+        entries = self.memory.get_recent_for_summary(session_id)
+        if len(entries) < 5:
+            logger.debug("对话太短，不需要总结")
+            return
+
+        # 构建对话文本
+        conv_text = "\n".join(
+            f"[{e.role}] {e.content}" for e in entries
+        )
+
+        messages = [
+            Message(role="system", content=self.SUMMARY_PROMPT),
+            Message(role="user", content=f"请总结以下对话:\n\n{conv_text}"),
+        ]
+
+        result = await self._call_llm_json(messages)
+        if "error" not in result:
+            self.memory.save_summary(
+                session_id=session_id,
+                summary=result.get("summary", ""),
+            )
+
+            # 保存偏好
+            preferences = result.get("preferences", {})
+            for key, value in preferences.items():
+                self.memory.add_long_term(
+                    session_id="global",
+                    key="user_pref",
+                    content=f"{key}: {value}",
+                    importance=0.7,
+                )
+
+            # 保存错误经验
+            for err_item in result.get("errors_learned", []):
+                self.memory.record_error_pattern(
+                    error=err_item.get("error", ""),
+                    fix=err_item.get("fix", ""),
+                )
+
+            logger.info(f"对话已总结并保存到长期记忆 (session={session_id})")
+            # 清理已总结的旧对话
+            self.memory.clear_conversation(session_id)
+
+    async def _record_error(self, context: AgentContext, session_id: str):
+        """记录错误模式"""
+        if not self.memory:
+            return
+
+        error = context.metadata.get("error", "")
+        fix = context.metadata.get("fix", "")
+        if error:
+            self.memory.record_error_pattern(error=error, fix=fix,
+                                              session_id=session_id)
+
+    async def _save_preference(self, context: AgentContext, session_id: str):
+        """保存用户偏好"""
+        if not self.memory:
+            return
+
+        pref_key = context.metadata.get("pref_key", "")
+        pref_value = context.metadata.get("pref_value", "")
+        if pref_key and pref_value:
+            self.memory.add_long_term(
+                session_id="global",
+                key="user_pref",
+                content=f"{pref_key}: {pref_value}",
+                summary=f"{pref_key}={pref_value}",
+                importance=0.7,
+            )
+
+    async def _get_relevant(self, context: AgentContext, session_id: str):
+        """获取与当前任务相关的历史记忆"""
+        if not self.memory:
+            return
+
+        query = context.user_message
+
+        # 搜索长期记忆
+        long_term = self.memory.search(
+            query, session_id="", category="long_term", limit=5
+        )
+        # 搜索错误模式
+        errors = self.memory.get_error_patterns(session_id="global", limit=3)
+        # 搜索偏好
+        prefs = self.memory.get_preferences(session_id="global")
+
+        context.working_memory["relevant_memories"] = {
+            "long_term": [
+                {"content": e.content[:500], "key": e.key, "summary": e.summary}
+                for e in long_term
+            ],
+            "error_patterns": [
+                {"content": e.content[:300]} for e in errors
+            ],
+            "preferences": [
+                {"content": e.content[:200]} for e in prefs[-5:]
+            ],
+        }
+
+        # 构建上下文提示
+        context_parts = []
+        if prefs:
+            context_parts.append("## 用户偏好")
+            context_parts.extend(f"- {e.content}" for e in prefs[-5:])
+
+        if errors:
+            context_parts.append("\n## 历史错误(避免重复)")
+            context_parts.extend(f"- {e.content[:200]}" for e in errors)
+
+        if long_term:
+            context_parts.append("\n## 相关经验")
+            context_parts.extend(f"- {e.summary or e.content[:200]}" for e in long_term)
+
+        if context_parts:
+            context.working_memory["memory_context_prompt"] = "\n".join(context_parts)

package/agents/tool_agent.py

@@ -0,0 +1,248 @@
+"""
+agents/tool_agent.py - 工具 Agent
+===================================
+负责系统执行、文件操作、技能调用。
+主 Agent 通过 ToolAgent 间接调用执行引擎和技能系统。
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional
+
+from core.logger import get_logger
+from core.llm import Message
+from agents.base import BaseAgent, AgentContext
+from core.utils import timestamp, safe_json_parse, truncate_str
+
+logger = get_logger("myagent.agent.tool")
+
+
+class ToolAgent(BaseAgent):
+    """
+    工具执行 Agent。
+
+    职责:
+      - 执行代码(Python/Shell/PowerShell)
+      - 调用技能系统
+      - 文件操作
+      - 系统命令
+      - 结果格式化和错误恢复
+    """
+
+    name = "tool_agent"
+    description = "负责代码执行和工具调用的专业Agent"
+
+    # 系统提示词
+    SYSTEM_PROMPT = """你是一个精准的代码执行助手。你的任务是根据指令执行代码或调用工具，并返回结构化结果。
+
+重要规则:
+1. 严格按要求执行，不要过度发挥
+2. 代码必须安全、可靠
+3. 如果执行失败，分析错误并尝试修复
+4. 结果必须结构化返回(JSON格式)
+5. 对于危险操作，先确认再执行
+
+输出格式(JSON):
+{
+  "action": "execute_code | call_skill | analyze_result",
+  "language": "python | shell | powershell",
+  "code": "要执行的代码",
+  "skill_name": "技能名称",
+  "skill_params": {},
+  "analysis": "结果分析",
+  "suggestion": "下一步建议"
+}"""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._execution_log: List[Dict] = []
+
+    async def process(self, context: AgentContext) -> AgentContext:
+        """
+        处理工具执行请求。
+
+        通过 context.metadata["tool_action"] 指定操作:
+          - execute: 执行代码
+          - call_skill: 调用技能
+          - auto: 由LLM自动决定(默认)
+        """
+        action = context.metadata.get("tool_action", "auto")
+
+        try:
+            if action == "execute":
+                result = await self._execute_direct(context)
+            elif action == "call_skill":
+                result = await self._call_skill_direct(context)
+            elif action == "auto":
+                result = await self._auto_execute(context)
+            else:
+                result = {"error": f"未知工具操作: {action}"}
+
+            context.working_memory["tool_result"] = result
+
+            # 记录执行日志
+            self._execution_log.append({
+                "timestamp": timestamp(),
+                "action": action,
+                "success": result.get("success", False),
+                "task_id": context.task_id,
+            })
+
+        except Exception as e:
+            logger.error(f"工具 Agent 执行失败: {e}")
+            context.working_memory["tool_result"] = {
+                "success": False,
+                "error": f"工具执行异常: {str(e)}",
+            }
+
+        return context
+
+    async def _execute_direct(self, context: AgentContext) -> Dict:
+        """直接执行代码"""
+        language = context.metadata.get("language", "python")
+        code = context.metadata.get("code", "")
+
+        if not code:
+            return {"success": False, "error": "未提供代码"}
+
+        return await self._run_code(language, code)
+
+    async def _call_skill_direct(self, context: AgentContext) -> Dict:
+        """直接调用技能"""
+        skill_name = context.metadata.get("skill_name", "")
+        skill_params = context.metadata.get("skill_params", {})
+
+        if not skill_name:
+            return {"success": False, "error": "未指定技能名称"}
+
+        return await self._invoke_skill(skill_name, skill_params)
+
+    async def _auto_execute(self, context: AgentContext) -> Dict:
+        """由 LLM 自动决定执行方式"""
+        user_msg = context.user_message
+
+        # 如果上下文已有工具调用结果，进行分析
+        if "tool_result" in context.working_memory:
+            return await self._analyze_result(context)
+
+        # 检查是否是技能调用请求
+        if self.skills and user_msg.startswith("!"):
+            parts = user_msg[1:].split(maxsplit=1)
+            skill_name = parts[0]
+            param_str = parts[1] if len(parts) > 1 else "{}"
+            try:
+                params = json.loads(param_str) if param_str.startswith("{") else {"query": param_str}
+            except json.JSONDecodeError:
+                params = {"query": param_str}
+            return await self._invoke_skill(skill_name, params)
+
+        # 让 LLM 决定如何执行
+        messages = [
+            Message(role="system", content=self.SYSTEM_PROMPT),
+        ]
+
+        # 添加对话历史
+        for msg in context.conversation_history[-10:]:
+            messages.append(msg)
+
+        messages.append(Message(role="user", content=user_msg))
+
+        # 获取可用技能列表
+        if self.skills:
+            available_skills = self.skills.list_skills_info()
+            skills_desc = "\n".join(
+                f"- {s['name']}: {s['description']}" for s in available_skills
+            )
+            messages.append(Message(
+                role="system",
+                content=f"可用技能列表:\n{skills_desc}\n\n"
+                        f"你也可以直接执行 Python/Shell/PowerShell 代码。",
+            ))
+
+        # 使用 JSON 模式
+        result = await self._call_llm_json(
+            messages, required_fields=["action"]
+        )
+
+        if "error" in result:
+            return {"success": False, "error": result["error"]}
+
+        action = result.get("action", "")
+
+        if action == "execute_code":
+            language = result.get("language", "python")
+            code = result.get("code", "")
+            return await self._run_code(language, code)
+
+        elif action == "call_skill":
+            skill_name = result.get("skill_name", "")
+            skill_params = result.get("skill_params", {})
+            return await self._invoke_skill(skill_name, skill_params)
+
+        elif action == "analyze_result":
+            # 如果LLM只是分析，返回分析结果
+            return {
+                "success": True,
+                "data": result,
+                "message": result.get("analysis", result.get("suggestion", "")),
+            }
+
+        else:
+            return {"success": False, "error": f"未知 action: {action}"}
+
+    async def _run_code(self, language: str, code: str) -> Dict:
+        """执行代码"""
+        if not self.executor:
+            return {"success": False, "error": "执行引擎未初始化"}
+
+        exec_result = await self.executor.execute(
+            language=language,
+            code=code,
+        )
+
+        return {
+            "success": exec_result.success,
+            "stdout": exec_result.stdout,
+            "stderr": exec_result.stderr,
+            "error": exec_result.error,
+            "exit_code": exec_result.exit_code,
+            "execution_time": exec_result.execution_time,
+            "language": language,
+            "llm_message": exec_result.to_llm_message(),
+        }
+
+    async def _invoke_skill(self, skill_name: str, params: Dict) -> Dict:
+        """调用技能"""
+        if not self.skills:
+            return {"success": False, "error": "技能系统未初始化"}
+
+        skill_result = await self.skills.execute(skill_name, **params)
+        return skill_result.to_dict()
+
+    async def _analyze_result(self, context: AgentContext) -> Dict:
+        """分析执行结果"""
+        prev_result = context.working_memory.get("tool_result", {})
+        user_msg = context.user_message
+
+        messages = [
+            Message(
+                role="system",
+                content="你是一个执行结果分析专家。请分析以下执行结果，给出下一步建议。"
+                        "输出 JSON 格式:\n"
+                        '{"analysis": "分析结论", "success": true/false, '
+                        '"suggestion": "下一步建议", "fixed_code": "修复后的代码(如需)"}'
+            ),
+            Message(role="user", content=f"执行结果:\n{json.dumps(prev_result, ensure_ascii=False, indent=2)}\n\n"
+                                         f"用户请求: {user_msg}"),
+        ]
+
+        result = await self._call_llm_json(messages)
+        return result
+
+    def get_execution_log(self, limit: int = 50) -> List[Dict]:
+        """获取执行日志"""
+        return self._execution_log[-limit:]
+
+    def clear_execution_log(self):
+        """清空执行日志"""
+        self._execution_log.clear()

package/chatbot/__init__.py

@@ -0,0 +1,5 @@
+"""
+chatbot/__init__.py - 聊天机器人模块入口
+"""
+from chatbot.manager import ChatBotManager
+from chatbot.base import BaseChatBot, ChatMessage

package/chatbot/base.py

@@ -0,0 +1,124 @@
+"""
+chatbot/base.py - 聊天平台基类
+================================
+定义所有聊天平台的统一接口。
+每个平台必须继承此类并实现 send/receive 方法。
+"""
+from __future__ import annotations
+
+import asyncio
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Callable, Dict, List, Optional
+
+from core.logger import get_logger
+from core.utils import generate_id, timestamp
+
+
+@dataclass
+class ChatMessage:
+    """统一聊天消息格式"""
+    id: str = field(default_factory=lambda: generate_id("msg"))
+    platform: str = ""               # 来源平台: telegram/discord/feishu/qq/wechat
+    chat_id: str = ""                # 聊天/群组 ID
+    user_id: str = ""                # 用户 ID
+    username: str = ""               # 用户名/昵称
+    text: str = ""                   # 消息文本
+    is_group: bool = False           # 是否群聊
+    reply_to: str = ""               # 回复的消息 ID
+    raw_data: Dict[str, Any] = field(default_factory=dict)  # 原始平台数据
+    timestamp: str = field(default_factory=timestamp)
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "platform": self.platform,
+            "chat_id": self.chat_id,
+            "user_id": self.user_id,
+            "username": self.username,
+            "text": self.text,
+            "is_group": self.is_group,
+            "timestamp": self.timestamp,
+        }
+
+
+@dataclass
+class ChatResponse:
+    """聊天回复"""
+    chat_id: str = ""
+    user_id: str = ""
+    text: str = ""
+    parse_mode: str = ""             # markdown | html | ""
+    reply_to: str = ""               # 回复的消息 ID
+    files: List[str] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+class BaseChatBot(ABC):
+    """
+    聊天平台基类。
+
+    所有聊天平台适配器必须继承此类。
+    """
+
+    platform_name: str = "base"
+    enabled: bool = False
+
+    def __init__(
+        self,
+        token: str = "",
+        allowed_users: Optional[List[str]] = None,
+        message_handler: Optional[Callable] = None,
+        **config,
+    ):
+        self.token = token
+        self.allowed_users = set(allowed_users or [])
+        self.message_handler = message_handler
+        self.config = config
+        self._running = False
+        self.logger = get_logger(f"myagent.chatbot.{self.platform_name}")
+
+    @abstractmethod
+    async def start(self):
+        """启动聊天机器人"""
+        pass
+
+    @abstractmethod
+    async def stop(self):
+        """停止聊天机器人"""
+        pass
+
+    @abstractmethod
+    async def send_message(self, response: ChatResponse) -> bool:
+        """发送消息"""
+        pass
+
+    def is_user_allowed(self, user_id: str) -> bool:
+        """检查用户是否在白名单中"""
+        if not self.allowed_users:
+            return True  # 空白名单 = 允许所有
+        return user_id in self.allowed_users
+
+    def _generate_session_id(self, message: ChatMessage) -> str:
+        """为消息生成会话 ID(支持多用户/多会话隔离)"""
+        if message.is_group:
+            return f"{self.platform_name}_group_{message.chat_id}"
+        return f"{self.platform_name}_dm_{message.user_id}"
+
+    async def _handle_message(self, message: ChatMessage):
+        """处理收到的消息(统一入口)"""
+        if not self.is_user_allowed(message.user_id):
+            self.logger.warning(f"用户被拒绝: {message.username} ({message.user_id})")
+            return
+
+        self.logger.info(
+            f"[{self.platform_name}] 收到消息: "
+            f"{message.username}: {message.text[:100]}"
+        )
+
+        if self.message_handler:
+            try:
+                await self.message_handler(message, self)
+            except Exception as e:
+                self.logger.error(f"消息处理失败: {e}")