myagent-ai 1.0.0

package/agents/main_agent.py

@@ -0,0 +1,695 @@
+"""
+agents/main_agent.py - 主 Agent
+=================================
+总指挥 Agent，负责任务规划、Agent 调度、结果汇总。
+"""
+from __future__ import annotations
+
+import json
+import asyncio
+from typing import Any, Dict, List, Optional
+
+from core.logger import get_logger
+from core.llm import LLMClient, LLMResponse, Message
+from agents.base import BaseAgent, AgentContext
+from core.utils import generate_id, timestamp, safe_json_parse, truncate_str
+
+logger = get_logger("myagent.agent.main")
+
+
+class MainAgent(BaseAgent):
+    """
+    主 Agent - 总指挥。
+
+    职责:
+      - 接收用户消息
+      - 任务分析与规划
+      - 调度子 Agent (ToolAgent / MemoryAgent)
+      - 整合结果并回复
+      - 多轮迭代(计划-执行-反思循环)
+      - 确保不进入死循环
+    """
+
+    name = "main_agent"
+    description = "AI助手主控Agent，负责理解用户意图、规划任务、调度执行"
+
+    SYSTEM_PROMPT = """你是 MyAgent - 一个强大的本地桌面AI助手。你拥有以下能力:
+
+## 核心能力
+1. **代码执行**: 可以运行 Python、Shell/Bash、PowerShell 代码
+2. **文件操作**: 读取、写入、搜索、管理文件
+3. **网络搜索**: 搜索互联网、读取网页
+4. **系统操作**: 查询系统信息、管理进程
+5. **浏览器操作**: 自动化浏览器(如已安装 Playwright)
+6. **记忆系统**: 记住用户偏好、历史任务、避免重复犯错
+
+## 工作方式
+- 仔细分析用户需求，拆解为可执行的步骤
+- 使用可用工具完成任务
+- 每一步执行后检查结果，遇到错误自动修复
+- 完成后总结成果
+
+## 重要规则
+- 优先使用技能系统完成操作，而不是直接写代码
+- 执行危险操作前先警告用户
+- 保持回复简洁明了
+- 如果需要多步操作，先规划再执行
+- 用中文回复
+
+## ⏰ 超时控制规则（强制要求）
+对于每个需要执行的命令(action type="code")，你**必须**在 action 中包含 "timeout_seconds" 字段，
+指定该命令的预估最大执行超时时间（秒）。这是一项强制要求，不能省略。
+
+超时时间设定指南:
+- 简单打印/计算: 10-30秒
+- 文件读写/搜索: 30-60秒
+- 网络请求/API调用: 60-120秒
+- 数据处理/批量操作: 120-300秒
+- 大规模编译/安装: 300-600秒
+- 如果不确定，默认设为 120秒
+
+**如果命令执行超时**: 系统会自动将超时信息反馈给你，包含命令已产生的部分输出。
+你需要分析超时原因并给出改进方案（如优化算法、添加超时参数、分批处理等）。
+
+## 格式要求
+当你需要执行操作时，输出 JSON 格式:
+```json
+{
+  "thought": "你的思考过程",
+  "plan": ["步骤1", "步骤2"],
+  "actions": [
+    {"type": "skill", "name": "技能名", "params": {}},
+    {"type": "code", "language": "python", "code": "代码", "timeout_seconds": 60},
+    {"type": "memory", "action": "记忆操作", "data": {}}
+  ]
+}
+```
+
+**注意**: action type="code" 必须包含 "timeout_seconds" 字段。action type="skill" 或 "memory" 不需要此字段。
+
+你可以用 markdown 格式回复普通对话。
+
+## 任务规划模式
+当用户消息中包含"当前任务计划"上下文时，你处于**任务规划模式**。请:
+1. 分析用户需求，评估现有任务的完成状态
+2. 根据需要添加新任务、标记已完成任务
+3. 在回复末尾用以下格式输出更新后的任务计划:
+
+## 任务计划
+- [ ] 任务描述1
+- [x] 已完成的任务
+- [ ] 待执行的任务描述2
+
+保持任务简洁明确，每个任务一行。"""
+
+    def __init__(self, tool_agent=None, memory_agent=None, **kwargs):
+        super().__init__(**kwargs)
+        self.tool_agent = tool_agent
+        self.memory_agent = memory_agent
+        self._iteration_count = 0
+        self._current_task_id: str = ""
+        self._registered_task: bool = False
+        # 组织上下文缓存（避免重复加载）
+        self._org_context_cache: str = ""
+        self._org_context_loaded: bool = False
+
+    async def process(self, context: AgentContext) -> AgentContext:
+        """
+        主处理循环。
+
+        流程:
+          1. 加载相关记忆
+          2. 构建消息(系统提示 + 记忆上下文 + 对话历史 + 用户消息)
+          3. 调用 LLM
+          4. 解析响应(纯文本回复 / 工具调用)
+          5. 如需执行工具，调度 ToolAgent
+          6. 如需记忆操作，调度 MemoryAgent
+          7. 循环直到任务完成或达到最大迭代次数
+        """
+        task_id = context.task_id or generate_id("task")
+        context.task_id = task_id
+        self._iteration_count = 0
+        self._current_task_id = task_id
+
+        # 注册到配置广播器（用于热重载通知）
+        if self.config_broadcaster:
+            self.config_broadcaster.register(task_id, agent_name=self.name)
+            self._registered_task = True
+
+        logger.info(f"[{task_id}] 开始处理用户请求: {context.user_message[:100]}")
+
+        try:
+            return await self._process_inner(context, task_id)
+        finally:
+            # 注销广播器
+            if self.config_broadcaster and self._registered_task:
+                self.config_broadcaster.unregister(task_id)
+                self._registered_task = False
+
+    async def _process_inner(self, context: AgentContext, task_id: str) -> AgentContext:
+        """内部处理逻辑（被 process 包裹，用于确保注册/注销广播器）"""
+
+        # Step 1: 加载相关记忆
+        if self.memory_agent:
+            mem_context = AgentContext(
+                task_id=task_id,
+                session_id=context.session_id,
+                user_message=context.user_message,
+                metadata={"memory_action": "get_relevant"},
+            )
+            await self.memory_agent.process(mem_context)
+            if "memory_context_prompt" in mem_context.working_memory:
+                context.working_memory["memory_context_prompt"] = \
+                    mem_context.working_memory["memory_context_prompt"]
+
+        # Step 2: 保存用户消息到短期记忆
+        if self.memory:
+            self.memory.add_short_term(
+                session_id=context.session_id,
+                role="user",
+                content=context.user_message,
+            )
+
+        # Step 3: 主循环(计划-执行-反思)
+        final_response = ""
+        max_iter = self.config.agent.max_iterations
+
+        while self._iteration_count < max_iter:
+            self._iteration_count += 1
+            logger.debug(f"[{task_id}] 迭代 {self._iteration_count}/{max_iter}")
+
+            # 检查配置热加载广播（每次迭代前检查）
+            if self.config_broadcaster:
+                reloaded = await self.config_broadcaster.check_and_wait(task_id)
+                if reloaded:
+                    logger.info(f"[{task_id}] 🔄 配置已热更新，继续执行 (iteration={self._iteration_count})")
+                    # 更新迭代检查点
+                    if self.config_broadcaster._active_tasks.get(task_id):
+                        self.config_broadcaster._active_tasks[task_id].iteration = self._iteration_count
+
+            # 构建消息列表
+            messages = self._build_messages(context)
+
+            # 添加可用工具
+            tools = self._get_tools()
+
+            # 调用 LLM
+            response = await self._call_llm(messages, tools=tools)
+
+            if not response.success:
+                final_response = f"⚠️ LLM 调用失败: {response.error}"
+                break
+
+            # 解析响应
+            content = response.content
+
+            # 检查是否有工具调用 (OpenAI function calling)
+            if response.tool_calls:
+                tool_results = await self._handle_tool_calls(
+                    response.tool_calls, context, task_id
+                )
+                # 将工具结果加入消息历史
+                for tc, result in tool_results:
+                    context.conversation_history.append(
+                        Message(role="tool", content=json.dumps(result, ensure_ascii=False),
+                               tool_call_id=tc["id"], name=tc["name"])
+                    )
+                    context.conversation_history.append(
+                        Message(role="assistant",
+                               content=f"[已调用工具 {tc['name']}，结果: "
+                                       f"{'成功' if result.get('success') else '失败'}]",
+                               tool_calls=[tc])
+                    )
+                # 继续循环，让 LLM 处理工具结果
+                continue
+
+            # 尝试解析 JSON 操作指令
+            action_data = safe_json_parse(content)
+
+            if action_data and isinstance(action_data, dict):
+                # 有结构化的操作指令
+                if "actions" in action_data:
+                    # 执行操作列表
+                    results = await self._execute_actions(
+                        action_data, context, task_id
+                    )
+                    # 将结果反馈给 LLM
+                    context.conversation_history.append(
+                        Message(role="assistant", content=content)
+                    )
+                    result_summary = self._summarize_action_results(results)
+
+                    # 如果有超时诊断，追加详细信息供 LLM 分析
+                    has_timeout = any(r.get("timed_out") for r in results)
+                    timeout_detail = ""
+                    if has_timeout:
+                        timeout_details = []
+                        for i, r in enumerate(results, 1):
+                            if r.get("timed_out"):
+                                diag = r.get("timeout_diagnosis", {})
+                                timeout_details.append(
+                                    f"### 命令 {i} 超时诊断\n"
+                                    f"- 原因: {diag.get('diagnosis', '未知')}\n"
+                                    f"- 进展: {diag.get('progress', '未知')}\n"
+                                    f"- 是否建议重试: {'是' if diag.get('should_retry') else '否'}\n"
+                                    f"- 重试策略: {diag.get('retry_strategy', '无')}\n"
+                                    f"- 改进建议:\n"
+                                )
+                                for s in diag.get("suggestions", []):
+                                    timeout_details.append(f"  - {s}")
+                        timeout_detail = "\n\n## ⏰ 超时诊断详情\n" + "\n".join(timeout_details)
+
+                    feedback_msg = f"[执行结果]\n{result_summary}\n\n请基于以上结果继续。"
+                    if timeout_detail:
+                        feedback_msg += timeout_detail + "\n\n请根据以上诊断信息决定下一步操作。"
+
+                    context.conversation_history.append(
+                        Message(role="user", content=feedback_msg)
+                    )
+
+                    # 如果任务已完成(所有操作成功)，退出循环
+                    all_success = all(r.get("success", False) for r in results)
+                    if all_success and results:
+                        final_response = action_data.get("thought", "")
+                        if "plan" in action_data and action_data["plan"]:
+                            final_response += "\n\n已完成: " + " → ".join(action_data["plan"])
+                        break
+
+                    continue
+
+                # 单个 action
+                if action_data.get("type") == "final_answer":
+                    final_response = action_data.get("content", content)
+                    break
+
+            # 纯文本回复(没有工具调用)
+            final_response = content
+            break
+
+        # 保存助手回复到短期记忆
+        if self.memory and final_response:
+            self.memory.add_short_term(
+                session_id=context.session_id,
+                role="assistant",
+                content=final_response,
+            )
+
+        # 清理工作记忆
+        context.working_memory["final_response"] = final_response
+        context.working_memory["iterations"] = self._iteration_count
+
+        logger.info(f"[{task_id}] 处理完成 (迭代 {self._iteration_count} 次)")
+
+        # 检查是否需要总结对话
+        if self.memory_agent and self._iteration_count > 5:
+            try:
+                await self.memory_agent.process(AgentContext(
+                    session_id=context.session_id,
+                    metadata={"memory_action": "summarize"},
+                ))
+            except Exception as e:
+                logger.warning(f"对话总结失败: {e}")
+
+        return context
+
+    def _build_messages(self, context: AgentContext) -> List[Message]:
+        """构建完整的消息列表"""
+        messages = [Message(role="system", content=self.SYSTEM_PROMPT)]
+
+        # 添加组织上下文（如果已启用）
+        org_context = self._build_org_context(context)
+        if org_context:
+            messages.append(Message(
+                role="system",
+                content=org_context,
+            ))
+
+        # 添加记忆上下文
+        memory_ctx = context.working_memory.get("memory_context_prompt", "")
+        if memory_ctx:
+            messages.append(Message(
+                role="system",
+                content=f"[记忆上下文]\n{memory_ctx}",
+            ))
+
+        # 添加对话历史
+        for msg in context.conversation_history[-20:]:
+            messages.append(msg)
+
+        # 添加当前用户消息
+        messages.append(Message(role="user", content=context.user_message))
+
+        return messages
+
+    def _get_tools(self) -> Optional[List[Dict]]:
+        """获取可用工具列表(OpenAI function calling 格式)"""
+        if not self.skills:
+            return None
+        try:
+            return self.skills.get_all_schemas()
+        except Exception as e:
+            logger.warning(f"获取工具列表失败: {e}")
+            return None
+
+    async def _handle_tool_calls(
+        self,
+        tool_calls: List[Dict],
+        context: AgentContext,
+        task_id: str,
+    ) -> List[tuple]:
+        """处理 OpenAI function calling 工具调用"""
+        results = []
+        for tc in tool_calls:
+            name = tc["name"]
+            args = tc.get("arguments", {})
+            logger.info(f"[{task_id}] 调用工具: {name}({args})")
+
+            try:
+                if self.skills:
+                    result = await self.skills.execute(name, **args)
+                    result_dict = result.to_dict()
+                else:
+                    result_dict = {"success": False, "error": "技能系统未初始化"}
+            except Exception as e:
+                result_dict = {"success": False, "error": str(e)}
+
+            results.append((tc, result_dict))
+
+            # 记录错误模式
+            if not result_dict.get("success") and self.memory:
+                self.memory.record_error_pattern(
+                    error=f"工具 {name} 失败: {result_dict.get('error', '')}",
+                )
+
+        return results
+
+    async def _execute_actions(
+        self,
+        action_data: Dict,
+        context: AgentContext,
+        task_id: str,
+    ) -> List[Dict]:
+        """执行操作列表"""
+        results = []
+        actions = action_data.get("actions", [])
+
+        for action in actions:
+            action_type = action.get("type", "")
+
+            if action_type == "skill" and self.skills:
+                result = await self.skills.execute(
+                    action.get("name", ""),
+                    **action.get("params", {}),
+                )
+                results.append(result.to_dict())
+
+            elif action_type == "code" and self.executor:
+                # 提取 LLM 预估的超时时间
+                timeout_seconds = action.get("timeout_seconds")
+                if timeout_seconds is None:
+                    # 如果 LLM 未提供 timeout_seconds，使用默认值并记录警告
+                    timeout_seconds = self.config.executor.timeout if hasattr(self.config, 'executor') else 120
+                    logger.warning(
+                        f"[{task_id}] LLM 未指定 timeout_seconds，使用默认值 {timeout_seconds}s"
+                    )
+                else:
+                    try:
+                        timeout_seconds = int(timeout_seconds)
+                        # 限制超时范围: 最小 5s，最大 3600s
+                        timeout_seconds = max(5, min(timeout_seconds, 3600))
+                    except (ValueError, TypeError):
+                        timeout_seconds = 120
+                        logger.warning(
+                            f"[{task_id}] timeout_seconds 值无效，使用默认值 120s"
+                        )
+
+                exec_result = await self.executor.execute(
+                    language=action.get("language", "python"),
+                    code=action.get("code", ""),
+                    timeout=timeout_seconds,
+                )
+
+                # 设置超时追踪字段（executor 已直接设置 timed_out，这里确保 timeout_limit）
+                if not exec_result.timeout_limit:
+                    exec_result.timeout_limit = timeout_seconds
+
+                result_dict = exec_result.to_dict()
+
+                # 超时后自动触发 LLM 诊断分析
+                if exec_result.timed_out:
+                    logger.info(
+                        f"[{task_id}] ⏰ 命令执行超时 ({timeout_seconds}s)，"
+                        f"自动触发 LLM 诊断分析..."
+                    )
+                    diagnosis = await self._diagnose_timeout(
+                        action, exec_result, context, task_id
+                    )
+                    result_dict["timeout_diagnosis"] = diagnosis
+
+                results.append(result_dict)
+
+            elif action_type == "memory" and self.memory_agent:
+                mem_ctx = AgentContext(
+                    task_id=task_id,
+                    session_id=context.session_id,
+                    metadata={
+                        "memory_action": action.get("action", ""),
+                        **action.get("data", {}),
+                    },
+                )
+                await self.memory_agent.process(mem_ctx)
+                results.append({"success": True, "action": "memory"})
+
+            elif action_type == "final":
+                break
+
+            else:
+                results.append({
+                    "success": False,
+                    "error": f"未知操作类型: {action_type}",
+                })
+
+        return results
+
+    @staticmethod
+    def _build_timeout_diagnosis_message(action: Dict, exec_result: 'ExecResult') -> str:
+        """构建超时诊断的用户消息（避免 f-string 内换行问题）"""
+        parts = []
+        parts.append("## 超时命令信息")
+        parts.append(f"- 语言: {action.get('language', 'unknown')}")
+        parts.append(f"- 超时上限: {exec_result.timeout_limit}s")
+        parts.append(f"- 实际执行时间: {exec_result.execution_time:.1f}s")
+        parts.append(f"- 代码:")
+        parts.append(f"```{action.get('language', '')}")
+        parts.append(f"{action.get('code', '')}")
+        parts.append("```")
+        parts.append("")
+        parts.append("## 执行输出（超时前）")
+
+        if exec_result.stdout and exec_result.stdout.strip():
+            parts.append("### 标准输出")
+            parts.append("```")
+            parts.append(exec_result.stdout[:5000])
+            parts.append("```")
+            parts.append("")
+        else:
+            parts.append("(无输出)")
+            parts.append("")
+
+        if exec_result.stderr and exec_result.stderr.strip():
+            parts.append("### 标准错误")
+            parts.append("```")
+            parts.append(exec_result.stderr[:3000])
+            parts.append("```")
+        else:
+            parts.append("(无错误输出)")
+
+        return "\n".join(parts)
+
+    async def _diagnose_timeout(
+        self,
+        action: Dict,
+        exec_result: 'ExecResult',
+        context: AgentContext,
+        task_id: str,
+    ) -> Dict[str, Any]:
+        """
+        超时后自动调用 LLM 诊断分析执行问题。
+
+        分析维度:
+          1. 超时原因诊断（死循环/网络阻塞/数据量过大/缺少输入等）
+          2. 基于已有输出的进展评估
+          3. 具体改进建议（优化代码/拆分任务/添加超时参数等）
+          4. 是否值得重试
+
+        Returns:
+            诊断结果字典
+        """
+        diagnosis_messages = [
+            Message(
+                role="system",
+                content=(
+                    "你是一个执行超时诊断专家。一个命令刚刚因超时被强制终止，"
+                    "请仔细分析以下信息，给出诊断结论和改进建议。\n\n"
+                    "请用 JSON 格式回复:\n"
+                    "{\n"
+                    '  "diagnosis": "超时原因诊断（简明扼要）",\n'
+                    '  "progress": "已完成的进度评估",\n'
+                    '  "suggestions": ["改进建议1", "改进建议2", ...],\n'
+                    '  "should_retry": true/false,\n'
+                    '  "retry_strategy": "如果建议重试，说明重试策略",\n'
+                    '  "estimated_fix_time": "预计修复后需要的时间(秒)"\n'
+                    "}"
+                ),
+            ),
+            Message(
+                role="user",
+                content=self._build_timeout_diagnosis_message(action, exec_result),
+            ),
+        ]
+
+        try:
+            diagnosis = await self._call_llm_json(diagnosis_messages)
+            if "error" in diagnosis:
+                logger.warning(f"[{task_id}] 超时诊断 LLM 调用失败: {diagnosis['error']}")
+                return {
+                    "diagnosis": "LLM 诊断调用失败",
+                    "suggestions": ["检查命令是否有死循环", "尝试减少处理数据量"],
+                    "should_retry": False,
+                }
+
+            # 记录诊断结果
+            logger.info(
+                f"[{task_id}] ⏰ 超时诊断完成: {diagnosis.get('diagnosis', 'N/A')}"
+            )
+
+            # 如果诊断建议重试且提供了重试策略，记录到记忆中
+            if diagnosis.get("should_retry") and self.memory:
+                self.memory.record_error_pattern(
+                    error=(
+                        f"命令超时 ({exec_result.timeout_limit}s): "
+                        f"{action.get('code', '')[:200]}\n"
+                        f"诊断: {diagnosis.get('diagnosis', '')}\n"
+                        f"建议: {'; '.join(diagnosis.get('suggestions', []))}"
+                    )
+                )
+
+            return diagnosis
+
+        except Exception as e:
+            logger.error(f"[{task_id}] 超时诊断异常: {e}")
+            return {
+                "diagnosis": f"诊断过程异常: {str(e)}",
+                "suggestions": ["检查命令逻辑", "手动测试命令"],
+                "should_retry": False,
+            }
+
+    def _summarize_action_results(self, results: List[Dict]) -> str:
+        """汇总操作结果"""
+        if not results:
+            return "无操作结果"
+
+        parts = []
+        for i, r in enumerate(results, 1):
+            status = "✅" if r.get("success") else "❌"
+            msg = r.get("message", r.get("error", ""))[:200]
+
+            # 超时特殊标记
+            if r.get("timed_out"):
+                status = "⏰"
+                limit = r.get("timeout_limit", "?")
+                actual = r.get("execution_time", "?")
+                msg = f"执行超时 (上限{limit}s, 实际{actual}s)"
+
+                # 追加诊断结果
+                diagnosis = r.get("timeout_diagnosis")
+                if diagnosis:
+                    diag_text = diagnosis.get("diagnosis", "")
+                    suggestions = diagnosis.get("suggestions", [])
+                    msg += f"\n  诊断: {diag_text}"
+                    if suggestions:
+                        msg += f"\n  建议: {'; '.join(suggestions[:3])}"
+
+            parts.append(f"{i}. {status} {msg}")
+
+        return "\n".join(parts)
+
+    def _build_org_context(self, context: AgentContext) -> str:
+        """
+        构建组织上下文信息。
+
+        如果组织功能已启用:
+        1. 读取 organization.md 内容
+        2. 对用户查询进行 RAG 搜索，获取相关知识片段
+        3. 返回格式化的上下文字符串
+
+        Returns:
+            格式化的组织上下文，未启用时返回空字符串
+        """
+        try:
+            # 检查配置中是否启用了组织功能
+            org_enabled = False
+            if hasattr(self.config, 'organization'):
+                org_enabled = self.config.organization.enabled
+            if not org_enabled:
+                return ""
+
+            parts = []
+
+            # 1. 读取 organization.md（使用缓存避免重复读取）
+            if not self._org_context_loaded:
+                try:
+                    from config import get_config
+                    config_mgr = get_config()
+                    org_dir = config_mgr.data_dir / "organization"
+                    org_info_path = org_dir / "organization.md"
+                    if org_info_path.exists():
+                        content = org_info_path.read_text(encoding="utf-8")
+                        # 检查是否仍是模板（包含占位注释）
+                        is_template = "<!-- 在此填写" in content
+                        if not is_template:
+                            self._org_context_cache = content
+                except Exception as e:
+                    logger.debug(f"读取组织信息失败: {e}")
+                self._org_context_loaded = True
+
+            if self._org_context_cache:
+                parts.append("## 组织信息\n")
+                # 截取合理的长度，避免占用过多 token
+                org_text = self._org_context_cache[:3000]
+                parts.append(org_text)
+                parts.append("")
+
+            # 2. RAG 搜索组织知识库
+            try:
+                from config import get_config
+                from knowledge.rag import KnowledgeRAG
+
+                config_mgr = get_config()
+                kb_dir = config_mgr.data_dir / "organization" / "knowledge"
+                if kb_dir.exists() and any(kb_dir.iterdir()):
+                    rag = KnowledgeRAG(kb_dir=kb_dir)
+                    rag.build_index()
+
+                    if rag.total_chunks > 0:
+                        # 使用用户消息作为查询
+                        query = context.user_message
+                        results = rag.search(query, top_k=3)
+                        if results:
+                            parts.append("## 相关知识库内容\n")
+                            for r in results:
+                                parts.append(
+                                    f"### 📄 {r.file_name} (片段 {r.chunk_index + 1})\n"
+                                    f"{r.content[:1000]}\n"
+                                )
+            except Exception as e:
+                logger.debug(f"组织知识库搜索失败: {e}")
+
+            if not parts:
+                return ""
+
+            return "[组织上下文]\n请参考以下组织信息回答用户问题。如果组织信息与用户问题无关，可以忽略。\n\n" + "\n".join(parts)
+
+        except Exception as e:
+            logger.debug(f"构建组织上下文失败: {e}")
+            return ""