myagent-ai 1.8.9 → 1.9.1

package/agents/main_agent.py

@@ -7,13 +7,15 @@ from __future__ import annotations
 
 import json
 import asyncio
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, 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
 from core.context_manager import ContextManager, ContextConfig, estimate_tokens
+from core.context_builder import ContextBuilder
+from core.output_parser import ParsedOutput, parse_output, validate_output, extract_surrounding_text
 
 logger = get_logger("myagent.agent.main")
 
@@ -171,6 +173,45 @@ status 取值：
 - 绝对不要在回复开头进行自我介绍
 - 不要重复问候"""
 
+    # =========================================================================
+    # V2 系统提示词 — 结构化输出格式
+    # =========================================================================
+    SYSTEM_PROMPT_V2 = """你是一个强内容分析格式转化引擎，要深入分析以下上下文内容：
+
+严格格式化输出以下内容:
+<output>
+<usersays_correct>根据用户输入的"usersays"内容，结合上下文优化为新的用户输入，如果"usersays"为空，这里输出为空。</usersays_correct>
+<task_plan>如"context"包含非空"task_plan",则更新它，变为当前输出。否则，根据"context", 以MD 的格式，制定新任务列表。</task_plan>
+
+<toolstocal>
+<tool><beforecalltext>连接词，介绍调用什么工具，达到什么目的。示例:首先，要调用网页查询工具，找到网页内容。</beforecalltext><toolname>工具名</toolname><parms>参数</parms><timeout>预估超时时限</timeout><callback>true/false,要求解析器在该工具执行完后是否要回调llm大模型，将所有工具输出结果+新构造的"context"输入给llm</callback></tool>
+
+<tool><beforecalltext>连接词，介绍调用什么工具，达到什么目的。示例:接下来，要调用命令行工具，获得ip地址。</beforecalltext><toolname>工具名</toolname><parms>参数</parms><timeout>预估超时时限</timeout><callback>true/false</callback></tool>
+</toolstocal>
+<remember>根据"context,提取需要存入记忆库的内容，这里要搜简上记忆库</remember>
+<recall>下一轮执行需要调取的记忆，这里要设计接上记忆库</recall>
+<get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的<knowledge>内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>
+<askuser>需要询问用户的内容，如无，则为空</askuser>
+<finish>true/false，是否结束循环调用llm。如"askuser"为非空，则"finish"输出true。否则，根据"context"判断任务是否已完成，是否结束llm回调</finish>
+
+</output>
+
+## 核心规则
+1. 你必须且只能输出 <output> XML 结构，不要输出任何其他文本
+2. <usersays_correct>: 如果 context 中 usersays 非空，则根据对话语境优化为更准确的用户意图表达
+3. <task_plan>: 使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
+4. <toolstocal>: 列出所有需要执行的工具调用，每个工具包含完整的参数说明
+5. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
+6. <callback>: 如果该工具的执行结果对后续决策有影响，设为 true；否则设为 false
+7. <remember>: 提取本轮对话中值得长期记忆的关键信息（用户偏好、重要结论、错误经验等）
+8. <recall>: 描述下一轮执行时需要从记忆库中检索的内容关键词
+9. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
+10. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
+11. <finish>: 当任务已完成或需要等待用户回应时为 true；否则为 false 继续执行
+12. 使用中文输出所有内容
+13. 优先使用技能系统（skill）而非直接写代码执行
+"""
+
     def __init__(self, tool_agent=None, memory_agent=None, **kwargs):
         super().__init__(**kwargs)
         self.tool_agent = tool_agent
@@ -183,12 +224,23 @@ status 取值：
         self._org_context_mtime: float = 0  # 文件修改时间，用于检测变更
         # Token 上下文管理器 (滚动摘要 + 预算控制)
         self.context_manager = ContextManager(ContextConfig())
+        # V2 Context Builder (结构化上下文构建)
+        self.context_builder: Optional[ContextBuilder] = None
         # 执行事件追踪（用于前端展示命令执行过程）
         self._execution_events: List[Dict] = []
         self._exec_event_counter: int = 0
         # 活跃会话上下文追踪（用于消息注入）
         self.active_contexts: Dict[str, AgentContext] = {}
 
+    def init_context_builder(self, memory_manager=None, skill_registry=None, knowledge_base_dir=None):
+        """初始化 V2 Context Builder（在系统启动后调用，注入依赖）"""
+        self.context_builder = ContextBuilder(
+            memory_manager=memory_manager,
+            skill_registry=skill_registry,
+            knowledge_base_dir=knowledge_base_dir,
+        )
+        logger.info("V2 Context Builder 已初始化" + (f" (知识库: {knowledge_base_dir})" if knowledge_base_dir else ""))
+
     def _add_exec_event(self, event_type: str, data: Dict):
         """记录一个执行事件（供前端展示）"""
         import time as _time
@@ -241,6 +293,10 @@ status 取值：
         logger.info(f"[{task_id}] 开始处理用户请求: {context.user_message[:100]}")
 
         try:
+            # V2 路由: 如果 context_builder 已初始化，使用 V2 结构化输出循环
+            if self.context_builder is not None:
+                logger.info(f"[{task_id}] 检测到 V2 Context Builder，使用 V2 执行循环")
+                return await self.process_v2(context)
             return await self._process_inner(context, task_id)
         finally:
             # 移除活跃上下文
@@ -479,6 +535,44 @@ status 取值：
                 content=final_response,
             )
 
+        # ── 保存工具调用过程到短期记忆（供历史记录查看）──
+        if self.memory and self._execution_events:
+            try:
+                tool_summary_parts = []
+                for evt in self._execution_events:
+                    etype = evt.get("type", "")
+                    if etype in ("tool_call", "skill_call"):
+                        tool_name = evt.get("tool_name") or evt.get("skill_name", "")
+                        args = evt.get("arguments") or evt.get("params", {})
+                        tool_summary_parts.append(f"🔧 调用工具: {tool_name}({json.dumps(args, ensure_ascii=False)[:200]})")
+                    elif etype in ("tool_result", "skill_result"):
+                        tool_name = evt.get("tool_name") or evt.get("skill_name", "")
+                        success = evt.get("success", False)
+                        summary = evt.get("summary", "")
+                        status = "✅" if success else "❌"
+                        tool_summary_parts.append(f"  {status} 结果: {summary[:300]}")
+                    elif etype == "code_exec":
+                        lang = evt.get("language", "")
+                        code_preview = evt.get("code_preview", "")
+                        stdout = evt.get("stdout", "")
+                        success = evt.get("success", False)
+                        status = "✅" if success else "❌"
+                        tool_summary_parts.append(f"💻 执行 {lang}: {code_preview[:150]}")
+                        if stdout:
+                            tool_summary_parts.append(f"  {status} 输出: {stdout[:300]}")
+                    elif etype == "code_result":
+                        pass  # code_result is duplicate of code_exec with final status
+                if tool_summary_parts:
+                    exec_log = "\n".join(tool_summary_parts)
+                    self.memory.add_short_term(
+                        session_id=context.session_id,
+                        role="tool",
+                        content=exec_log,
+                        importance=0.3,
+                    )
+            except Exception as e:
+                logger.warning(f"保存工具调用过程失败: {e}")
+
         # 清理工作记忆
         context.working_memory["final_response"] = final_response
         context.working_memory["iterations"] = self._iteration_count
@@ -1026,3 +1120,523 @@ status 取值：
         except Exception as e:
             logger.debug(f"构建组织上下文失败: {e}")
             return ""
+
+    # =========================================================================
+    # V2 执行循环 — 结构化输出 + Context Builder + Output Parser
+    # =========================================================================
+
+    async def _emit_v2_event(self, event_type: str, data: Dict, stream_callback: Optional[Callable] = None):
+        """发送 V2 SSE 事件。如果 stream_callback 不存在则仅记录日志。"""
+        event = {"type": event_type, **data}
+        if stream_callback is not None:
+            try:
+                if asyncio.iscoroutinefunction(stream_callback):
+                    await stream_callback(event)
+                else:
+                    stream_callback(event)
+            except Exception as e:
+                logger.debug(f"V2 SSE 事件发送失败 ({event_type}): {e}")
+        else:
+            logger.debug(f"[v2-event] {event_type}: {data}")
+
+    async def process_v2(
+        self,
+        context: AgentContext,
+        agent_name: str = "助手",
+        agent_description: str = "通用AI助手",
+        agent_override_prompt: Optional[str] = None,
+        stream_callback: Optional[Callable] = None,
+        stream_response=None,
+        text_delta_callback=None,
+    ) -> AgentContext:
+        """
+        V2 主处理循环 — 使用结构化输出格式。
+
+        核心流程:
+          1. 使用 ContextBuilder 构建 <context> XML
+          2. 将 context 注入 SYSTEM_PROMPT_V2，调用 LLM
+          3. 使用 OutputParser 解析 <output> XML
+          4. 根据 parsed.tools_to_call 依次执行工具
+          5. 任一工具超时 → 强制回调 LLM
+          6. 根据 callback 标志决定是否回调 LLM
+          7. 处理 remember/recall/askuser/finish
+
+        Args:
+            context: Agent 上下文
+            agent_name: Agent 名称（用于 ContextBuilder）
+            agent_description: Agent 描述
+            agent_override_prompt: 可选的 Agent 身份覆盖提示词
+            stream_callback: 可选的 SSE 事件回调 (callable 或 async callable)
+            stream_response: 可选的流式响应对象（用于 LLM 流式输出）
+            text_delta_callback: 可选的文本增量回调
+        """
+        task_id = context.task_id or generate_id("task")
+        context.task_id = task_id
+        self._iteration_count = 0
+        self._current_task_id = task_id
+        self.clear_execution_events()
+
+        if not self.context_builder:
+            logger.warning("Context Builder 未初始化，回退到 V1 执行循环")
+            return await self._process_inner(context, task_id)
+
+        logger.info(f"[{task_id}] V2 执行循环启动: {context.user_message[:100]}")
+
+        try:
+            return await self._process_v2_inner(
+                context, task_id, agent_name, agent_description,
+                agent_override_prompt, stream_callback, stream_response, text_delta_callback
+            )
+        except Exception as e:
+            logger.error(f"[{task_id}] V2 执行循环异常: {e}", exc_info=True)
+            context.working_memory["final_response"] = f"执行异常: {str(e)}"
+            await self._emit_v2_event("v2_reasoning", {"content": f"执行异常: {str(e)}"}, stream_callback)
+            return context
+
+    async def _process_v2_inner(
+        self,
+        context: AgentContext,
+        task_id: str,
+        agent_name: str,
+        agent_description: str,
+        agent_override_prompt: Optional[str],
+        stream_callback: Optional[Callable] = None,
+        stream_response=None,
+        text_delta_callback=None,
+    ) -> AgentContext:
+        """V2 内部循环逻辑 — 结构化输出 + 工具调度 + SSE 事件推送"""
+        max_iter = self.config.agent.max_iterations
+        current_task_plan = ""
+        all_tool_outputs = ""
+        recall_content = ""
+        get_knowledge_content = ""
+
+        conversation_history = list(context.conversation_history or [])
+
+        # 保存用户消息到短期记忆
+        if self.memory:
+            self.memory.add_short_term(
+                session_id=context.session_id,
+                role="user",
+                content=context.user_message,
+            )
+
+        # 加载相关记忆 (recall from previous round or initial load)
+        if self.memory_agent and context.user_message:
+            mem_ctx = 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_ctx)
+            if "memory_context_prompt" in mem_ctx.working_memory:
+                context.working_memory["memory_context_prompt"] = \
+                    mem_ctx.working_memory["memory_context_prompt"]
+
+        while self._iteration_count < max_iter:
+            self._iteration_count += 1
+            logger.info(f"[{task_id}] V2 迭代 {self._iteration_count}/{max_iter}")
+
+            # ── 检查配置热加载广播 ──
+            if self.config_broadcaster:
+                reloaded, reload_type = await self.config_broadcaster.check_and_wait(task_id)
+                if reloaded:
+                    logger.info(f"[{task_id}] V2 迭代 {self._iteration_count}: {reload_type}已热更新")
+
+            # ── 检查并处理注入的消息 ──
+            if context.pending_injected_messages:
+                injected = context.pending_injected_messages.copy()
+                context.pending_injected_messages.clear()
+                for msg_text in injected:
+                    logger.info(f"[{task_id}] 注入消息到对话历史: {msg_text[:50]}...")
+                    conversation_history.append(
+                        Message(role="user", content=f"[用户中断/补充]: {msg_text}")
+                    )
+
+            # Step 1: 构建 Context XML
+            context_xml = self.context_builder.build_context(
+                agent_name=agent_name,
+                agent_description=agent_description,
+                session_id=context.session_id,
+                conversation_history=conversation_history,
+                user_typed_text=context.user_message,
+                user_voice_text="",
+                task_plan=current_task_plan,
+                agent_override_prompt=agent_override_prompt,
+                get_knowledge=get_knowledge_content,
+            )
+
+            await self._emit_v2_event(
+                "v2_context",
+                {"context": truncate_str(context_xml, 8000)},
+                stream_callback,
+            )
+
+            # Step 2: 构建系统消息 (SYSTEM_PROMPT_V2 + context XML)
+            system_content = self.SYSTEM_PROMPT_V2 + "\n\n" + context_xml
+
+            # Step 3: 调用 LLM
+            messages = [Message(role="system", content=system_content)]
+
+            if all_tool_outputs:
+                messages.append(Message(
+                    role="user",
+                    content=f"[上一轮工具执行结果汇总]\n{truncate_str(all_tool_outputs, 15000)}"
+                ))
+                all_tool_outputs = ""
+
+            if stream_response and self.llm:
+                response = await self._call_llm_stream(
+                    messages, text_delta_callback=text_delta_callback,
+                    stream_response=stream_response,
+                )
+            else:
+                response = await self._call_llm(messages)
+
+            if not response.success:
+                logger.error(f"[{task_id}] LLM 调用失败: {response.error}")
+                error_msg = f"LLM 调用失败: {response.error}"
+                context.working_memory["final_response"] = error_msg
+                await self._emit_v2_event("v2_reasoning", {"content": error_msg}, stream_callback)
+                break
+
+            llm_raw = response.content
+            logger.debug(f"[{task_id}] LLM 输出 (前500字): {llm_raw[:500]}")
+
+            # Step 4: 解析结构化输出
+            parsed = parse_output(llm_raw)
+
+            await self._emit_v2_event(
+                "v2_output_parsed",
+                {"data": {
+                    "usersays_correct": parsed.usersays_correct,
+                    "task_plan": truncate_str(parsed.task_plan, 500),
+                    "tools_count": len(parsed.tools_to_call),
+                    "remember": truncate_str(parsed.remember, 200),
+                    "ask_user": truncate_str(parsed.ask_user, 200),
+                    "finish": parsed.finish,
+                    "parse_success": parsed.parse_success,
+                }},
+                stream_callback,
+            )
+
+            if not parsed.parse_success:
+                logger.warning(f"[{task_id}] XML 解析失败，尝试提取周边文本")
+                before, after = extract_surrounding_text(llm_raw)
+                if before.strip() or after.strip():
+                    final_text = (before + "\n" + after).strip()
+                    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(
+                            session_id=context.session_id,
+                            role="assistant",
+                            content=final_text,
+                        )
+                    break
+                else:
+                    context.working_memory["final_response"] = llm_raw
+                    break
+
+            warnings = validate_output(parsed)
+            for w in warnings:
+                logger.debug(f"[{task_id}] 验证警告: {w}")
+
+            # Step 5: 处理 usersays_correct — 存入上下文供后续使用
+            if parsed.usersays_correct:
+                context.working_memory["usersays_correct"] = parsed.usersays_correct
+
+            # Step 6: 处理 remember — 存入长期记忆
+            if parsed.remember and self.memory_agent:
+                try:
+                    mem_ctx = AgentContext(
+                        task_id=task_id,
+                        session_id=context.session_id,
+                        metadata={
+                            "memory_action": "save",
+                            "content": parsed.remember,
+                        },
+                    )
+                    await self.memory_agent.process(mem_ctx)
+                    await self._emit_v2_event(
+                        "v2_memory_saved",
+                        {"content": truncate_str(parsed.remember, 200)},
+                        stream_callback,
+                    )
+                except Exception as e:
+                    logger.warning(f"[{task_id}] 存入记忆失败: {e}")
+            elif parsed.remember and self.memory:
+                try:
+                    self.memory.add_long_term(
+                        session_id=context.session_id,
+                        key="conversation_insight",
+                        content=parsed.remember,
+                        summary=truncate_str(parsed.remember, 200),
+                        importance=0.7,
+                    )
+                    await self._emit_v2_event(
+                        "v2_memory_saved",
+                        {"content": truncate_str(parsed.remember, 200)},
+                        stream_callback,
+                    )
+                except Exception as e:
+                    logger.warning(f"[{task_id}] 存入记忆失败: {e}")
+
+            # Step 7: 处理 recall — 记录下一轮需要检索的记忆内容
+            if parsed.recall:
+                recall_content = parsed.recall
+
+            # Step 7.5: 处理 get_knowledge — 记录下一轮需要 RAG 搜索的知识关键词
+            if parsed.get_knowledge:
+                get_knowledge_content = parsed.get_knowledge
+                await self._emit_v2_event(
+                    "v2_knowledge_request",
+                    {"query": truncate_str(parsed.get_knowledge, 200)},
+                    stream_callback,
+                )
+
+            # Step 8: 更新任务计划
+            if parsed.task_plan:
+                current_task_plan = parsed.task_plan
+                await self._emit_v2_event(
+                    "v2_task_plan",
+                    {"plan": truncate_str(current_task_plan, 2000)},
+                    stream_callback,
+                )
+
+            # Step 9: 处理 askuser（askuser 非空时，finish 必为 true）
+            if parsed.askuser:
+                logger.info(f"[{task_id}] 需要询问用户: {parsed.askuser[:100]}")
+                context.working_memory["final_response"] = parsed.askuser
+                context.working_memory["ask_user"] = parsed.askuser
+                await self._emit_v2_event(
+                    "v2_ask_user",
+                    {"question": parsed.askuser},
+                    stream_callback,
+                )
+                if self.memory:
+                    self.memory.add_short_term(
+                        session_id=context.session_id,
+                        role="assistant",
+                        content=parsed.askuser,
+                    )
+                break
+
+            # Step 10: 执行工具调用（无论 finish 值如何，先执行工具）
+            if not parsed.tools_to_call:
+                # 无工具调用: 直接根据 finish 判断是否结束
+                if parsed.finish:
+                    logger.info(f"[{task_id}] finish=true 且无工具调用，结束循环")
+                    before, after = extract_surrounding_text(llm_raw)
+                    final_text = (before + "\n" + after).strip() if (before.strip() or after.strip()) else "任务已完成。"
+                    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(
+                            session_id=context.session_id,
+                            role="assistant",
+                            content=final_text,
+                        )
+                else:
+                    logger.info(f"[{task_id}] 无工具调用且 finish=false，结束")
+                    before, after = extract_surrounding_text(llm_raw)
+                    final_text = (before + "\n" + after).strip() if (before.strip() or after.strip()) else "处理完毕。"
+                    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(
+                            session_id=context.session_id,
+                            role="assistant",
+                            content=final_text,
+                        )
+                break
+
+            # Step 11: 有工具调用 — 先执行所有工具，再根据 finish 决定回调
+            need_callback = False
+            tool_outputs_parts = []
+
+            for tool_info in parsed.tools_to_call:
+                tool_name = tool_info.get("toolname", "").strip()
+                before_call = tool_info.get("beforecalltext", "")
+                parms = tool_info.get("parms", "")
+                timeout = tool_info.get("timeout", 120)
+                should_callback = tool_info.get("callback", True)
+
+                if not tool_name:
+                    continue
+
+                logger.info(f"[{task_id}] 执行工具: {tool_name} (timeout={timeout}s, callback={should_callback})")
+
+                # 发送 beforecalltext 作为显示文本
+                if before_call:
+                    await self._emit_v2_event(
+                        "v2_reasoning",
+                        {"content": before_call},
+                        stream_callback,
+                    )
+
+                # 发送工具开始事件
+                await self._emit_v2_event(
+                    "v2_tool_start",
+                    {"tool": {
+                        "toolname": tool_name,
+                        "parms": truncate_str(parms, 500),
+                        "timeout": timeout,
+                        "callback": should_callback,
+                    }},
+                    stream_callback,
+                )
+
+                self._add_exec_event("tool_call", {
+                    "title": f"调用工具: {tool_name}",
+                    "tool_name": tool_name,
+                    "arguments": parms,
+                })
+
+                tool_result = await self._execute_v2_tool(
+                    tool_name, parms, timeout, context, task_id
+                )
+
+                # 发送工具结果事件
+                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),
+                        "error": truncate_str(tool_result.get("error", ""), 1000),
+                        "timed_out": tool_result.get("timed_out", False),
+                    }},
+                    stream_callback,
+                )
+
+                self._add_exec_event("tool_result", {
+                    "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),
+                    "result": tool_result,
+                })
+
+                is_timeout = tool_result.get("timed_out", False)
+                if is_timeout:
+                    need_callback = True
+                    logger.warning(f"[{task_id}] 工具 {tool_name} 超时 ({timeout}s)")
+                elif should_callback:
+                    need_callback = True
+
+                output_str = tool_result.get("output", "") or tool_result.get("error", "")
+                tool_outputs_parts.append(
+                    f"### {before_call}\n"
+                    f"**工具**: {tool_name}\n"
+                    f"**结果**: {'成功' if tool_result.get('success') else '失败'}\n"
+                    f"{truncate_str(output_str, 2000)}\n"
+                )
+
+                conversation_history.append(Message(
+                    role="assistant",
+                    content=f"执行工具 {tool_name}:\n{truncate_str(output_str, 3000)}",
+                ))
+                conversation_history.append(Message(
+                    role="user",
+                    content=f"[工具 {tool_name} 执行完成] {'成功' if tool_result.get('success') else '失败'}",
+                ))
+
+            all_tool_outputs = "\n".join(tool_outputs_parts)
+
+            # Step 12: 工具执行完毕后，根据 finish 标志决定是否回调 LLM
+            # 核心逻辑: finish=true 表示任务已完成/不需要再调用LLM，即使工具设置了callback=true
+            if parsed.finish:
+                logger.info(f"[{task_id}] finish=true，任务已完成，不回调 LLM")
+                final_text = "已完成所有操作。"
+                if current_task_plan:
+                    final_text += f"\n\n任务计划:\n{current_task_plan}"
+                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(
+                        session_id=context.session_id,
+                        role="assistant",
+                        content=final_text,
+                    )
+                break
+
+            # finish=false: 根据工具的 callback 标志决定是否回调
+            if not need_callback:
+                logger.info(f"[{task_id}] 所有工具无需回调且 finish=false，结束循环")
+                final_text = "已完成所有操作。"
+                if current_task_plan:
+                    final_text += f"\n\n任务计划:\n{current_task_plan}"
+                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(
+                        session_id=context.session_id,
+                        role="assistant",
+                        content=final_text,
+                    )
+                break
+
+            logger.info(f"[{task_id}] finish=false 且 need_callback=true，回调 LLM...")
+
+        context.working_memory["iterations"] = self._iteration_count
+        if current_task_plan:
+            context.working_memory["task_plan"] = current_task_plan
+
+        logger.info(f"[{task_id}] V2 循环完成 (共 {self._iteration_count} 次迭代)")
+        return context
+
+    async def _execute_v2_tool(
+        self,
+        tool_name: str,
+        parms_str: str,
+        timeout: int,
+        context: AgentContext,
+        task_id: str,
+    ) -> Dict[str, Any]:
+        """V2 工具执行"""
+        result = {"success": False, "output": "", "error": ""}
+
+        try:
+            import json as _json
+            try:
+                params = _json.loads(parms_str) if parms_str else {}
+            except (_json.JSONDecodeError, TypeError):
+                params = {"raw_input": parms_str}
+
+            if tool_name == "code" or tool_name.startswith("code_"):
+                code_lang = params.get("language", "python")
+                code_text = params.get("code", parms_str)
+                if self.executor:
+                    exec_result = await self.executor.execute(
+                        language=code_lang,
+                        code=code_text,
+                        timeout=timeout,
+                    )
+                    result = exec_result.to_dict()
+                else:
+                    result["error"] = "执行引擎未初始化"
+
+            elif tool_name == "command" or tool_name == "command_run":
+                code_text = params.get("command", parms_str)
+                if self.executor:
+                    exec_result = await self.executor.execute(
+                        language="shell",
+                        code=code_text,
+                        timeout=timeout,
+                    )
+                    result = exec_result.to_dict()
+                else:
+                    result["error"] = "执行引擎未初始化"
+
+            elif self.skills:
+                exec_result = await self.skills.execute(tool_name, **params)
+                result = exec_result.to_dict()
+            else:
+                result["error"] = f"未知工具: {tool_name}"
+
+        except Exception as e:
+            result["error"] = str(e)
+            logger.error(f"[{task_id}] 工具 {tool_name} 异常: {e}")
+
+        return result