jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_agent/__init__.py

@@ -7,7 +7,8 @@ import re
 import sys
 from pathlib import Path
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
 
 # 第三方库导入
 from rich.align import Align
@@ -28,12 +29,11 @@ from jarvis.jarvis_agent.file_methodology_manager import FileMethodologyManager
 from jarvis.jarvis_agent.prompts import (
     DEFAULT_SUMMARY_PROMPT,
     SUMMARY_REQUEST_PROMPT,
-    TASK_ANALYSIS_PROMPT,
+    TASK_ANALYSIS_PROMPT,  # noqa: F401
 )
 from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_agent.prompt_manager import PromptManager
 from jarvis.jarvis_agent.event_bus import EventBus
-from jarvis.jarvis_agent.config import AgentConfig
 from jarvis.jarvis_agent.run_loop import AgentRunLoop
 from jarvis.jarvis_agent.events import (
     BEFORE_SUMMARY,
@@ -54,6 +54,9 @@ from jarvis.jarvis_agent.events import (
 from jarvis.jarvis_agent.user_interaction import UserInteractionHandler
 from jarvis.jarvis_agent.utils import join_prompts
 from jarvis.jarvis_utils.methodology import _load_all_methodologies
+from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
+from jarvis.jarvis_agent.file_context_handler import file_context_handler
+from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
 
 # jarvis_platform 相关
 from jarvis.jarvis_platform.base import BasePlatform
@@ -62,7 +65,6 @@ from jarvis.jarvis_platform.registry import PlatformRegistry
 # jarvis_utils 相关
 from jarvis.jarvis_utils.config import (
     get_data_dir,
-    get_max_token_count,
     get_normal_model_name,
     get_normal_platform_name,
     is_execute_tool_confirm,
@@ -71,17 +73,19 @@ from jarvis.jarvis_utils.config import (
     is_use_methodology,
     get_tool_filter_threshold,
     get_after_tool_call_cb_dirs,
+    get_addon_prompt_threshold,
+    is_enable_memory_organizer,
 )
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.globals import (
     delete_agent,
     get_interrupt,
+    get_short_term_memories,
     make_agent_name,
     set_agent,
     set_interrupt,
 )
 from jarvis.jarvis_utils.input import get_multiline_input, user_confirm
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ot
 
 
@@ -130,6 +134,10 @@ def show_agent_startup_stats(
         if project_memory_dir.exists():
             project_memory_count = len(list(project_memory_dir.glob("*.json")))
 
+        # 检查短期记忆
+        short_term_memories = get_short_term_memories()
+        short_term_memory_count = len(short_term_memories) if short_term_memories else 0
+
         # 获取当前工作目录
         current_dir = os.getcwd()
 
@@ -149,6 +157,12 @@ def show_agent_startup_stats(
                 f"📝  项目记忆: [bold magenta]{project_memory_count}[/bold magenta]"
             )
 
+        # 如果有短期记忆，添加到统计信息中
+        if short_term_memory_count > 0:
+            stats_parts.append(
+                f"💭  短期记忆: [bold blue]{short_term_memory_count}[/bold blue]"
+            )
+
         stats_text = Text.from_markup(" | ".join(stats_parts), justify="center")
 
         # 创建包含欢迎信息和统计信息的面板内容
@@ -172,7 +186,7 @@ def show_agent_startup_stats(
         console.print(Align.center(panel))
 
     except Exception as e:
-        PrettyOutput.print(f"加载统计信息失败: {e}", OutputType.WARNING)
+        print(f"⚠️ 加载统计信息失败: {e}")
 
 
 origin_agent_system_prompt = f"""
@@ -243,9 +257,34 @@ class Agent:
     def clear_history(self):
         """
         Clears the current conversation history by delegating to the session manager.
+        直接调用关键流程函数，事件总线仅用于非关键流程（如日志、监控等）。
         """
+        # 关键流程：直接调用 memory_manager 确保记忆提示
+        try:
+            self.memory_manager._ensure_memory_prompt(agent=self)
+        except Exception:
+            pass
+        
+        # 非关键流程：广播清理历史前事件（用于日志、监控等）
+        try:
+            self.event_bus.emit(BEFORE_HISTORY_CLEAR, agent=self)
+        except Exception:
+            pass
+
+        # 清理会话历史并重置模型状态
         self.session.clear_history()
-        # 广播清理历史后的事件
+        # 重置 addon_prompt 跳过轮数计数器
+        self._addon_prompt_skip_rounds = 0
+        # 重置没有工具调用的计数器
+        self._no_tool_call_count = 0
+
+        # 重置后重新设置系统提示词，确保系统约束仍然生效
+        try:
+            self._setup_system_prompt()
+        except Exception:
+            pass
+
+        # 非关键流程：广播清理历史后的事件（用于日志、监控等）
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
         except Exception:
@@ -264,6 +303,21 @@ class Agent:
         """获取工具使用提示"""
         return build_action_prompt(self.output_handler)  # type: ignore
 
+    def __new__(cls, *args, **kwargs):
+        if kwargs.get("agent_type") == "code":
+            try:
+                from jarvis.jarvis_code_agent.code_agent import CodeAgent
+            except ImportError as e:
+                raise RuntimeError(
+                    "CodeAgent could not be imported. Please ensure jarvis_code_agent is installed correctly."
+                ) from e
+
+            # 移除 agent_type 避免无限循环，并传递所有其他参数
+            kwargs.pop("agent_type", None)
+            return CodeAgent(**kwargs)
+        else:
+            return super().__new__(cls)
+
     def __init__(
         self,
         system_prompt: str,
@@ -274,7 +328,6 @@ class Agent:
         auto_complete: bool = False,
         output_handler: Optional[List[OutputHandlerProtocol]] = None,
         use_tools: Optional[List[str]] = None,
-        input_handler: Optional[List[Callable[[str, Any], Tuple[str, bool]]]] = None,
         execute_tool_confirm: Optional[bool] = None,
         need_summary: bool = True,
         multiline_inputer: Optional[Callable[[str], str]] = None,
@@ -283,6 +336,10 @@ class Agent:
         force_save_memory: Optional[bool] = None,
         files: Optional[List[str]] = None,
         confirm_callback: Optional[Callable[[str, bool], bool]] = None,
+        non_interactive: Optional[bool] = None,
+        in_multi_agent: Optional[bool] = None,
+        agent_type: str = "normal",
+        **kwargs,
     ):
         """初始化Jarvis Agent实例
 
@@ -293,8 +350,6 @@ class Agent:
 
             summary_prompt: 任务总结提示模板
             auto_complete: 是否自动完成任务
-            output_handler: 输出处理器列表
-            input_handler: 输入处理器列表
             execute_tool_confirm: 执行工具前是否需要确认
             need_summary: 是否需要生成总结
             multiline_inputer: 多行输入处理器
@@ -302,21 +357,42 @@ class Agent:
             use_analysis: 是否使用任务分析
             force_save_memory: 是否强制保存记忆
             confirm_callback: 用户确认回调函数，签名为 (tip: str, default: bool) -> bool；默认使用CLI的user_confirm
+            non_interactive: 是否以非交互模式运行（优先级最高，覆盖环境变量与配置）
         """
-        # 基础属性初始化
-        self.files = files or []
+        # 基础属性初始化（仅根据入参设置原始值；实际生效的默认回退在 _init_config 中统一解析）
+        # 标识与描述
         self.name = make_agent_name(name)
         self.description = description
         self.system_prompt = system_prompt
-        self.need_summary = need_summary
-        self.auto_complete = auto_complete
+        # 行为控制开关（原始入参值）
+        self.auto_complete = bool(auto_complete)
+        self.need_summary = bool(need_summary)
+        self.use_methodology = use_methodology
+        self.use_analysis = use_analysis
+        self.execute_tool_confirm = execute_tool_confirm
+        self.summary_prompt = summary_prompt
+        self.force_save_memory = force_save_memory
+        # 资源与环境
+        self.model_group = model_group
+        self.files = files or []
+        self.use_tools = use_tools
+        self.non_interactive = non_interactive
+        # 多智能体运行标志：用于控制非交互模式下的自动完成行为
+        self.in_multi_agent = bool(in_multi_agent)
+        # 运行时状态
         self.first = True
         self.run_input_handlers_next_turn = False
         self.user_data: Dict[str, Any] = {}
+        # 记录连续未添加 addon_prompt 的轮数
+        self._addon_prompt_skip_rounds: int = 0
+        # 记录连续没有工具调用的次数（用于非交互模式下的工具使用提示）
+        self._no_tool_call_count: int = 0
+        
+        self._agent_type = "normal"
 
 
         # 用户确认回调：默认使用 CLI 的 user_confirm，可由外部注入以支持 TUI/GUI
-        self.user_confirm: Callable[[str, bool], bool] = (
+        self.confirm_callback: Callable[[str, bool], bool] = (
             confirm_callback or user_confirm  # type: ignore[assignment]
         )
 
@@ -326,25 +402,62 @@ class Agent:
 
         # 初始化处理器
         self._init_handlers(
-            output_handler or [],
-            input_handler,
             multiline_inputer,
+            output_handler,
             use_tools or [],
         )
         # 初始化用户交互封装，保持向后兼容
-        self.user_interaction = UserInteractionHandler(self.multiline_inputer, self.user_confirm)
+        self.user_interaction = UserInteractionHandler(self.multiline_inputer, self.confirm_callback)
         # 将确认函数指向封装后的 confirm，保持既有调用不变
-        self.user_confirm = self.user_interaction.confirm  # type: ignore[assignment]
-
-        # 初始化配置
-        self._init_config(
-            use_methodology,
-            use_analysis,
-            execute_tool_confirm,
-            summary_prompt,
-            model_group,
-            force_save_memory,
-        )
+        self.confirm_callback = self.user_interaction.confirm  # type: ignore[assignment]
+        # 非交互模式参数支持：允许通过构造参数显式控制，便于其他Agent调用时设置
+        try:
+            # 优先使用构造参数，其次回退到环境变量
+            self.non_interactive = (
+                bool(non_interactive)
+                if non_interactive is not None
+                else str(os.environ.get("JARVIS_NON_INTERACTIVE", "")).lower() in ("1", "true", "yes")
+            )
+            # 如果构造参数显式提供，则同步到环境变量与全局配置，供下游组件读取
+            if non_interactive is not None:
+                os.environ["JARVIS_NON_INTERACTIVE"] = "true" if self.non_interactive else "false"
+
+        except Exception:
+            # 防御式回退
+            self.non_interactive = False
+
+        # 初始化配置（直接解析，不再依赖 _init_config）
+        try:
+            resolved_use_methodology = bool(use_methodology if use_methodology is not None else is_use_methodology())
+        except Exception:
+            resolved_use_methodology = bool(use_methodology) if use_methodology is not None else True
+
+        try:
+            resolved_use_analysis = bool(use_analysis if use_analysis is not None else is_use_analysis())
+        except Exception:
+            resolved_use_analysis = bool(use_analysis) if use_analysis is not None else True
+
+        try:
+            resolved_execute_tool_confirm = bool(execute_tool_confirm if execute_tool_confirm is not None else is_execute_tool_confirm())
+        except Exception:
+            resolved_execute_tool_confirm = bool(execute_tool_confirm) if execute_tool_confirm is not None else False
+
+        try:
+            resolved_force_save_memory = bool(force_save_memory if force_save_memory is not None else is_force_save_memory())
+        except Exception:
+            resolved_force_save_memory = bool(force_save_memory) if force_save_memory is not None else False
+
+        self.use_methodology = resolved_use_methodology
+        self.use_analysis = resolved_use_analysis
+        self.execute_tool_confirm = resolved_execute_tool_confirm
+        self.summary_prompt = (summary_prompt or DEFAULT_SUMMARY_PROMPT)
+        self.force_save_memory = resolved_force_save_memory
+        # 多智能体模式下，默认不自动完成（即使是非交互），仅在明确传入 auto_complete=True 时开启
+        if self.in_multi_agent:
+            self.auto_complete = bool(self.auto_complete)
+        else:
+            # 非交互模式下默认自动完成；否则保持传入的 auto_complete 值
+            self.auto_complete = bool(self.auto_complete or (self.non_interactive or False))
 
         # 初始化事件总线需先于管理器，以便管理器在构造中安全订阅事件
         self.event_bus = EventBus()
@@ -354,6 +467,14 @@ class Agent:
         self.file_methodology_manager = FileMethodologyManager(self)
         self.prompt_manager = PromptManager(self)
 
+        # 如果配置了强制保存记忆，确保 save_memory 工具可用
+        if self.force_save_memory:
+            self._ensure_save_memory_tool()
+
+        # 如果启用了分析，确保 methodology 工具可用
+        if self.use_analysis:
+            self._ensure_methodology_tool()
+
         # 设置系统提示词
         self._setup_system_prompt()
 
@@ -364,6 +485,7 @@ class Agent:
             self.get_tool_registry(),  # type: ignore
             platform_name=self.model.platform_name(),  # type: ignore
         )
+        
         # 动态加载工具调用后回调
         self._load_after_tool_callbacks()
 
@@ -374,9 +496,7 @@ class Agent:
 
         maybe_model = PlatformRegistry().create_platform(platform_name)
         if maybe_model is None:
-            PrettyOutput.print(
-                f"平台 {platform_name} 不存在，将使用普通模型", OutputType.WARNING
-            )
+            print(f"⚠️ 平台 {platform_name} 不存在，将使用普通模型")
             maybe_model = PlatformRegistry().get_normal_platform()
 
         # 在此处收敛为非可选类型，确保后续赋值满足类型检查
@@ -394,67 +514,26 @@ class Agent:
 
     def _init_handlers(
         self,
-        output_handler: List[OutputHandlerProtocol],
-        input_handler: Optional[List[Callable[[str, Any], Tuple[str, bool]]]],
         multiline_inputer: Optional[Callable[[str], str]],
+        output_handler: Optional[List[OutputHandlerProtocol]],
         use_tools: List[str],
     ):
         """初始化各种处理器"""
-        self.output_handler = output_handler or [ToolRegistry()]
+        default_handlers: List[Any] = [ToolRegistry()]
+        handlers = output_handler or default_handlers
+        self.output_handler = handlers
         self.set_use_tools(use_tools)
-        self.input_handler = input_handler or []
+        self.input_handler = [
+            builtin_input_handler,
+            shell_input_handler,
+            file_context_handler,
+        ]
         self.multiline_inputer = multiline_inputer or get_multiline_input
 
-    def _init_config(
-        self,
-        use_methodology: Optional[bool],
-        use_analysis: Optional[bool],
-        execute_tool_confirm: Optional[bool],
-        summary_prompt: Optional[str],
-        model_group: Optional[str],
-        force_save_memory: Optional[bool],
-    ):
-        """初始化配置选项"""
-        # 使用集中配置解析，保持与原逻辑一致
-        cfg = AgentConfig(
-            system_prompt=self.system_prompt,
-            name=self.name,
-            description=self.description,
-            model_group=model_group,
-            auto_complete=self.auto_complete,
-            need_summary=self.need_summary,
-            summary_prompt=summary_prompt,
-            execute_tool_confirm=execute_tool_confirm,
-            use_methodology=use_methodology,
-            use_analysis=use_analysis,
-            force_save_memory=force_save_memory,
-            files=self.files,
-            max_token_count=None,
-        ).resolve_defaults()
-
-        # 将解析结果回填到 Agent 实例属性，保持向后兼容
-        self.use_methodology = bool(cfg.use_methodology)
-        self.use_analysis = bool(cfg.use_analysis)
-        self.execute_tool_confirm = bool(cfg.execute_tool_confirm)
-        self.summary_prompt = cfg.summary_prompt or DEFAULT_SUMMARY_PROMPT
-        self.max_token_count = int(cfg.max_token_count or get_max_token_count(model_group))
-        self.force_save_memory = bool(cfg.force_save_memory)
-
-        # 聚合配置到 AgentConfig，作为后续单一事实来源（保持兼容，不改变既有属性使用）
-        self.config = cfg
-
     def _setup_system_prompt(self):
         """设置系统提示词"""
         try:
-            if hasattr(self, "prompt_manager"):
-                prompt_text = self.prompt_manager.build_system_prompt()
-            else:
-                action_prompt = self.get_tool_usage_prompt()
-                prompt_text = f"""
-{self.system_prompt}
-
-{action_prompt}
-"""
+            prompt_text = self.prompt_manager.build_system_prompt()
             self.model.set_system_prompt(prompt_text)  # type: ignore
         except Exception:
             # 回退到原始行为，确保兼容性
@@ -475,6 +554,19 @@ class Agent:
         """Gets user data from the session."""
         return self.session.get_user_data(key)
 
+    def get_remaining_token_count(self) -> int:
+        """获取剩余可用的token数量
+        
+        返回:
+            int: 剩余可用的token数量，如果无法获取则返回0
+        """
+        if not self.model:
+            return 0
+        try:
+            return self.model.get_remaining_token_count()
+        except Exception:
+            return 0
+
     def set_use_tools(self, use_tools):
         """设置要使用的工具列表"""
         for handler in self.output_handler:
@@ -498,8 +590,10 @@ class Agent:
         otherwise, fall back to calling with a single argument for compatibility.
         """
         # 优先通过用户交互封装，便于未来替换 UI
-        if hasattr(self, "user_interaction"):
+        try:
             return self.user_interaction.multiline_input(tip, print_on_empty)
+        except Exception:
+            pass
         try:
             # Try to pass the keyword for enhanced input handler
             return self.multiline_inputer(tip, print_on_empty=print_on_empty)  # type: ignore
@@ -587,7 +681,7 @@ class Agent:
                                 pass
 
                     except Exception as e:
-                        PrettyOutput.print(f"从 {file_path} 加载回调失败: {e}", OutputType.WARNING)
+                        print(f"⚠️ 从 {file_path} 加载回调失败: {e}")
                     finally:
                         if added_path:
                             try:
@@ -595,7 +689,7 @@ class Agent:
                             except ValueError:
                                 pass
         except Exception as e:
-            PrettyOutput.print(f"加载回调目录时发生错误: {e}", OutputType.WARNING)
+            print(f"⚠️ 加载回调目录时发生错误: {e}")
 
     def save_session(self) -> bool:
         """Saves the current session state by delegating to the session manager."""
@@ -615,6 +709,58 @@ class Agent:
                 return handler
         return None
 
+    def _ensure_save_memory_tool(self) -> None:
+        """如果配置了强制保存记忆，确保 save_memory 工具在 use_tools 列表中"""
+        try:
+            tool_registry = self.get_tool_registry()
+            if not tool_registry:
+                return
+
+            # 检查 save_memory 工具是否已注册（工具默认都会注册）
+            if not tool_registry.get_tool("save_memory"):
+                # 如果工具本身不存在，则无法使用，直接返回
+                return
+
+            # 检查 save_memory 是否在 use_tools 列表中
+            # 如果 use_tools 为 None，表示使用所有工具，无需添加
+            if self.use_tools is None:
+                return
+
+            # 如果 save_memory 不在 use_tools 列表中，则添加
+            if "save_memory" not in self.use_tools:
+                self.use_tools.append("save_memory")
+                # 更新工具注册表的工具列表
+                self.set_use_tools(self.use_tools)
+        except Exception:
+            # 忽略所有错误，不影响主流程
+            pass
+
+    def _ensure_methodology_tool(self) -> None:
+        """如果启用了分析，确保 methodology 工具在 use_tools 列表中"""
+        try:
+            tool_registry = self.get_tool_registry()
+            if not tool_registry:
+                return
+
+            # 检查 methodology 工具是否已注册（工具默认都会注册）
+            if not tool_registry.get_tool("methodology"):
+                # 如果工具本身不存在，则无法使用，直接返回
+                return
+
+            # 检查 methodology 是否在 use_tools 列表中
+            # 如果 use_tools 为 None，表示使用所有工具，无需添加
+            if self.use_tools is None:
+                return
+
+            # 如果 methodology 不在 use_tools 列表中，则添加
+            if "methodology" not in self.use_tools:
+                self.use_tools.append("methodology")
+                # 更新工具注册表的工具列表
+                self.set_use_tools(self.use_tools)
+        except Exception:
+            # 忽略所有错误，不影响主流程
+            pass
+
     def get_event_bus(self) -> EventBus:
         """获取事件总线实例"""
         return self.event_bus
@@ -666,7 +812,13 @@ class Agent:
         return message
 
     def _add_addon_prompt(self, message: str, need_complete: bool) -> str:
-        """添加附加提示到消息"""
+        """添加附加提示到消息
+        
+        规则：
+        1. 如果 session.addon_prompt 存在，优先使用它
+        2. 如果消息长度超过阈值，添加默认 addon_prompt
+        3. 如果连续10轮都没有添加过 addon_prompt，强制添加一次
+        """
         # 广播添加附加提示前事件（不影响主流程）
         try:
             self.event_bus.emit(
@@ -680,13 +832,32 @@ class Agent:
             pass
 
         addon_text = ""
+        should_add = False
+        
         if self.session.addon_prompt:
+            # 优先使用 session 中设置的 addon_prompt
             addon_text = self.session.addon_prompt
             message = join_prompts([message, addon_text])
             self.session.addon_prompt = ""
+            should_add = True
         else:
-            addon_text = self.make_default_addon_prompt(need_complete)
-            message = join_prompts([message, addon_text])
+            threshold = get_addon_prompt_threshold()
+            # 条件1：消息长度超过阈值
+            if len(message) > threshold:
+                addon_text = self.make_default_addon_prompt(need_complete)
+                message = join_prompts([message, addon_text])
+                should_add = True
+            # 条件2：连续10轮都没有添加过 addon_prompt，强制添加一次
+            elif self._addon_prompt_skip_rounds >= 10:
+                addon_text = self.make_default_addon_prompt(need_complete)
+                message = join_prompts([message, addon_text])
+                should_add = True
+        
+        # 更新计数器：如果添加了 addon_prompt，重置计数器；否则递增
+        if should_add:
+            self._addon_prompt_skip_rounds = 0
+        else:
+            self._addon_prompt_skip_rounds += 1
 
         # 广播添加附加提示后事件（不影响主流程）
         try:
@@ -702,14 +873,9 @@ class Agent:
         return message
 
     def _manage_conversation_length(self, message: str) -> str:
-        """管理对话长度，必要时进行摘要"""
+        """管理对话长度计数；摘要触发由剩余token数量在 AgentRunLoop 中统一处理（剩余token低于20%时触发）。"""
         self.session.conversation_length += get_context_token_count(message)
 
-        if self.session.conversation_length > self.max_token_count:
-            summary = self._summarize_and_clear_history()
-            if summary:
-                message = join_prompts([summary, message])
-            self.session.conversation_length = get_context_token_count(message)
 
         return message
 
@@ -729,7 +895,14 @@ class Agent:
             pass
 
         response = self.model.chat_until_success(message)  # type: ignore
-
+        # 防御: 模型可能返回空响应(None或空字符串)，统一为空字符串并告警
+        if not response:
+            try:
+                print("⚠️ 模型返回空响应，已使用空字符串回退。")
+            except Exception:
+                pass
+            response = ""
+        
         # 事件：模型调用后
         try:
             self.event_bus.emit(
@@ -745,9 +918,13 @@ class Agent:
 
         return response
 
-    def generate_summary(self) -> str:
+    def generate_summary(self, for_token_limit: bool = False) -> str:
         """生成对话历史摘要
 
+        参数:
+            for_token_limit: 如果为True，表示由于token限制触发的summary，使用SUMMARY_REQUEST_PROMPT
+                            如果为False，表示任务完成时的summary，使用用户传入的summary_prompt
+
         返回:
             str: 包含对话摘要的字符串
 
@@ -758,13 +935,31 @@ class Agent:
         try:
             if not self.model:
                 raise RuntimeError("Model not initialized")
-            summary = self.model.chat_until_success(
-                self.session.prompt + "\n" + SUMMARY_REQUEST_PROMPT
-            )  # type: ignore
-
+            
+            print("🔍 开始生成对话历史摘要...")
+            
+            if for_token_limit:
+                # token限制触发的summary：使用SUMMARY_REQUEST_PROMPT进行上下文压缩
+                prompt_to_use = self.session.prompt + "\n" + SUMMARY_REQUEST_PROMPT
+            else:
+                # 任务完成时的summary：使用用户传入的summary_prompt或DEFAULT_SUMMARY_PROMPT
+                safe_summary_prompt = self.summary_prompt or ""
+                if isinstance(safe_summary_prompt, str) and safe_summary_prompt.strip() != "":
+                    prompt_to_use = safe_summary_prompt
+                else:
+                    prompt_to_use = DEFAULT_SUMMARY_PROMPT
+
+            summary = self.model.chat_until_success(prompt_to_use)  # type: ignore
+            # 防御: 可能返回空响应(None或空字符串)，统一为空字符串并告警
+            if not summary:
+                try:
+                    print("⚠️ 总结模型返回空响应，已使用空字符串回退。")
+                except Exception:
+                    pass
+                summary = ""
             return summary
         except Exception:
-            PrettyOutput.print("总结对话历史失败", OutputType.ERROR)
+            print("❌ 总结对话历史失败")
             return ""
 
     def _summarize_and_clear_history(self) -> str:
@@ -784,11 +979,6 @@ class Agent:
         注意:
             当上下文长度超过最大值时使用
         """
-        # 在清理历史之前，提示用户保存重要记忆（事件驱动触发实际保存）
-        if self.force_save_memory:
-            PrettyOutput.print(
-                "对话历史即将被总结和清理，请先保存重要信息...", OutputType.INFO
-            )
 
         if self._should_use_file_upload():
             return self._handle_history_with_file_upload()
@@ -801,26 +991,39 @@ class Agent:
 
     def _handle_history_with_summary(self) -> str:
         """使用摘要方式处理历史"""
-        summary = self.generate_summary()
+        # token限制触发的summary，使用SUMMARY_REQUEST_PROMPT
+        summary = self.generate_summary(for_token_limit=True)
 
         # 先获取格式化的摘要消息
         formatted_summary = ""
         if summary:
             formatted_summary = self._format_summary_message(summary)
 
-        # 清理历史（但不清理prompt，因为prompt会在builtin_input_handler中设置）
-        if self.model:
-            # 广播清理历史前事件
+        # 关键流程：直接调用 memory_manager 确保记忆提示
+        try:
+            self.memory_manager._ensure_memory_prompt(agent=self)
+        except Exception:
+            pass
+        
+        # 非关键流程：广播清理历史前事件（用于日志、监控等）
             try:
                 self.event_bus.emit(BEFORE_HISTORY_CLEAR, agent=self)
             except Exception:
                 pass
+
+        # 清理历史（但不清理prompt，因为prompt会在builtin_input_handler中设置）
+        if self.model:
             self.model.reset()
             # 重置后重新设置系统提示词，确保系统约束仍然生效
             self._setup_system_prompt()
         # 重置会话
         self.session.clear_history()
-        # 广播清理历史后的事件
+        # 重置 addon_prompt 跳过轮数计数器
+        self._addon_prompt_skip_rounds = 0
+        # 重置没有工具调用的计数器
+        self._no_tool_call_count = 0
+        
+        # 非关键流程：广播清理历史后的事件（用于日志、监控等）
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
         except Exception:
@@ -830,13 +1033,25 @@ class Agent:
 
     def _handle_history_with_file_upload(self) -> str:
         """使用文件上传方式处理历史"""
-        # 广播清理历史前事件
+        # 关键流程：直接调用 memory_manager 确保记忆提示
+        try:
+            self.memory_manager._ensure_memory_prompt(agent=self)
+        except Exception:
+            pass
+        
+        # 非关键流程：广播清理历史前事件（用于日志、监控等）
         try:
             self.event_bus.emit(BEFORE_HISTORY_CLEAR, agent=self)
         except Exception:
             pass
+        
         result = self.file_methodology_manager.handle_history_with_file_upload()
-        # 广播清理历史后的事件
+        # 重置 addon_prompt 跳过轮数计数器
+        self._addon_prompt_skip_rounds = 0
+        # 重置没有工具调用的计数器
+        self._no_tool_call_count = 0
+        
+        # 非关键流程：广播清理历史后的事件（用于日志、监控等）
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
         except Exception:
@@ -876,19 +1091,37 @@ class Agent:
         # - TaskAnalyzer 通过订阅 before_summary/task_completed 事件执行分析与满意度收集
         # - MemoryManager 通过订阅 before_history_clear/task_completed 事件执行记忆保存（受 force_save_memory 控制）
         # 为减少耦合，这里不再直接调用上述组件，保持行为由事件触发
-        self._check_and_organize_memory()
+        # 仅在启用自动记忆整理时检查并整理记忆
+        if is_enable_memory_organizer():
+            self._check_and_organize_memory()
 
         result = "任务完成"
 
         if self.need_summary:
 
-            self.session.prompt = self.summary_prompt
-            # 广播将要生成总结事件
+            # 确保总结提示词非空：若为None或仅空白，则回退到默认提示词
+            safe_summary_prompt = self.summary_prompt or ""
+            if isinstance(safe_summary_prompt, str) and safe_summary_prompt.strip() == "":
+                safe_summary_prompt = DEFAULT_SUMMARY_PROMPT
+            # 注意：不要写回 session.prompt，避免回调修改/清空后导致使用空prompt
+            
+            # 关键流程：直接调用 task_analyzer 执行任务分析
+            try:
+                self.task_analyzer._on_before_summary(
+                    agent=self,
+                    prompt=safe_summary_prompt,
+                    auto_completed=auto_completed,
+                    need_summary=self.need_summary,
+                )
+            except Exception:
+                pass
+            
+            # 非关键流程：广播将要生成总结事件（用于日志、监控等）
             try:
                 self.event_bus.emit(
                     BEFORE_SUMMARY,
                     agent=self,
-                    prompt=self.session.prompt,
+                    prompt=safe_summary_prompt,
                     auto_completed=auto_completed,
                     need_summary=self.need_summary,
                 )
@@ -897,10 +1130,18 @@ class Agent:
 
             if not self.model:
                 raise RuntimeError("Model not initialized")
-            ret = self.model.chat_until_success(self.session.prompt)  # type: ignore
+            # 直接使用本地变量，避免受事件回调影响
+            ret = self.model.chat_until_success(safe_summary_prompt)  # type: ignore
+            # 防御: 总结阶段模型可能返回空响应(None或空字符串)，统一为空字符串并告警
+            if not ret:
+                try:
+                    print("⚠️ 总结阶段模型返回空响应，已使用空字符串回退。")
+                except Exception:
+                    pass
+                ret = ""
             result = ret
 
-            # 广播完成总结事件
+            # 非关键流程：广播完成总结事件（用于日志、监控等）
             try:
                 self.event_bus.emit(
                     AFTER_SUMMARY,
@@ -910,7 +1151,26 @@ class Agent:
             except Exception:
                 pass
 
-        # 广播任务完成事件（不影响主流程）
+            # 关键流程：直接调用 task_analyzer 和 memory_manager
+        try:
+            self.task_analyzer._on_task_completed(
+                agent=self,
+                auto_completed=auto_completed,
+                need_summary=self.need_summary,
+            )
+        except Exception:
+            pass
+        
+        try:
+            self.memory_manager._ensure_memory_prompt(
+                agent=self,
+                auto_completed=auto_completed,
+                need_summary=self.need_summary,
+            )
+        except Exception:
+            pass
+        
+        # 非关键流程：广播任务完成事件（用于日志、监控等）
         try:
             self.event_bus.emit(
                 TASK_COMPLETED,
@@ -931,10 +1191,12 @@ class Agent:
 
         """
         # 优先使用 PromptManager 以保持逻辑集中
-        if hasattr(self, "prompt_manager"):
+        try:
             return self.prompt_manager.build_default_addon_prompt(need_complete)
+        except Exception:
+            pass
 
-        # 结构化系统指令
+        # 结构化系统指令（回退方案）
         action_handlers = ", ".join([handler.name() for handler in self.output_handler])
 
         # 任务完成提示
@@ -957,10 +1219,11 @@ class Agent:
     {complete_prompt}
     如果没有完成，请进行下一步操作：
     - 仅包含一个操作
-    - 不要询问用户是否继续，直接继续执行直至完成
     - 如果信息不明确，请请求用户补充
-    - 如果执行过程中连续失败5次，请使用ask_user询问用户操作
+    - 如果执行过程中连续失败5次，请请求用户操作
     - 操作列表：{action_handlers}{memory_prompts}
+    
+    注意：如果当前部分任务已完成，之前的上下文价值不大，可以输出<!!!SUMMARY!!!>标记来触发总结并清空历史，以便开始新的任务阶段。
 </system_prompt>
 
 请继续。
@@ -986,7 +1249,19 @@ class Agent:
         self.session.prompt = f"{user_input}"
         try:
             set_agent(self.name, self)
-            # 广播任务开始事件（不影响主流程）
+            
+            # 关键流程：直接调用 memory_manager 重置任务状态
+            try:
+                self.memory_manager._on_task_started(
+                    agent=self,
+                    name=self.name,
+                    description=self.description,
+                    user_input=self.session.prompt,
+                )
+            except Exception:
+                pass
+            
+            # 非关键流程：广播任务开始事件（用于日志、监控等）
             try:
                 self.event_bus.emit(
                     TASK_STARTED,
@@ -999,7 +1274,7 @@ class Agent:
                 pass
             return self._main_loop()
         except Exception as e:
-            PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 任务失败: {str(e)}")
             return f"Task failed: {str(e)}"
 
     def _main_loop(self) -> Any:
@@ -1041,7 +1316,7 @@ class Agent:
             return self._complete_task(auto_completed=False)
 
         if any(handler.can_handle(current_response) for handler in self.output_handler):
-            if self.user_confirm("检测到有工具调用，是否继续处理工具调用？", True):
+            if self.confirm_callback("检测到有工具调用，是否继续处理工具调用？", True):
                 self.session.prompt = join_prompts([
                     f"被用户中断，用户补充信息为：{user_input}",
                     "用户同意继续工具调用。"
@@ -1104,8 +1379,42 @@ class Agent:
         temp_model.set_system_prompt(system_prompt)
         return temp_model
 
+    def _build_child_agent_params(self, name: str, description: str) -> Dict[str, Any]:
+        """构建子Agent参数，尽量继承父Agent配置，并确保子Agent非交互自动完成。"""
+        use_tools_param: Optional[List[str]] = None
+        try:
+            tr = self.get_tool_registry()
+            if isinstance(tr, ToolRegistry):
+                selected_tools = tr.get_all_tools()
+                use_tools_param = [t["name"] for t in selected_tools]
+        except Exception:
+            use_tools_param = None
+
+        return {
+            "system_prompt": origin_agent_system_prompt,
+            "name": name,
+            "description": description,
+            "model_group": self.model_group,
+            "summary_prompt": self.summary_prompt,
+            "auto_complete": True,
+            "use_tools": use_tools_param,
+            "execute_tool_confirm": self.execute_tool_confirm,
+            "need_summary": self.need_summary,
+            "multiline_inputer": self.multiline_inputer,
+            "use_methodology": self.use_methodology,
+            "use_analysis": self.use_analysis,
+            "force_save_memory": self.force_save_memory,
+            "files": self.files,
+            "confirm_callback": self.confirm_callback,
+            "non_interactive": True,
+            "in_multi_agent": True,
+        }
+
     def _filter_tools_if_needed(self, task: str):
-        """如果工具数量超过阈值，使用大模型筛选相关工具"""
+        """如果工具数量超过阈值，使用大模型筛选相关工具
+        
+        注意：仅筛选用户自定义工具，内置工具不参与筛选（始终保留）
+        """
         tool_registry = self.get_tool_registry()
         if not isinstance(tool_registry, ToolRegistry):
             return
@@ -1115,10 +1424,16 @@ class Agent:
         if len(all_tools) <= threshold:
             return
 
-        # 为工具选择构建提示
+        # 获取用户自定义工具（非内置工具），仅对这些工具进行筛选
+        custom_tools = tool_registry.get_custom_tools()
+        if not custom_tools:
+            # 没有用户自定义工具，无需筛选
+            return
+
+        # 为工具选择构建提示（仅包含用户自定义工具）
         tools_prompt_part = ""
         tool_names = []
-        for i, tool in enumerate(all_tools, 1):
+        for i, tool in enumerate(custom_tools, 1):
             tool_names.append(tool["name"])
             tools_prompt_part += f"{i}. {tool['name']}: {tool['description']}\n"
 
@@ -1136,9 +1451,7 @@ class Agent:
 请根据用户任务，从列表中选择最相关的工具。
 请仅返回所选工具的编号，以逗号分隔。例如：1, 5, 12
 """
-        PrettyOutput.print(
-            f"工具数量超过{threshold}个，正在使用AI筛选相关工具...", OutputType.INFO
-        )
+        print(f"ℹ️ 工具数量超过{threshold}个，正在使用AI筛选相关工具...")
         # 广播工具筛选开始事件
         try:
             self.event_bus.emit(
@@ -1171,13 +1484,13 @@ class Agent:
             if selected_tool_names:
                 # 移除重复项
                 selected_tool_names = sorted(list(set(selected_tool_names)))
-                tool_registry.use_tools(selected_tool_names)
+                # 合并内置工具名称和筛选出的用户自定义工具名称
+                builtin_names = list(tool_registry._builtin_tool_names)
+                final_tool_names = sorted(list(set(builtin_names + selected_tool_names)))
+                tool_registry.use_tools(final_tool_names)
                 # 使用筛选后的工具列表重新设置系统提示
                 self._setup_system_prompt()
-                PrettyOutput.print(
-                    f"已筛选出 {len(selected_tool_names)} 个相关工具: {', '.join(selected_tool_names)}",
-                    OutputType.SUCCESS,
-                )
+                print(f"✅ 已筛选出 {len(selected_tool_names)} 个相关工具: {', '.join(selected_tool_names)}")
                 # 广播工具筛选事件
                 try:
                     self.event_bus.emit(
@@ -1191,9 +1504,7 @@ class Agent:
                 except Exception:
                     pass
             else:
-                PrettyOutput.print(
-                    "AI 未能筛选出任何相关工具，将使用所有工具。", OutputType.WARNING
-                )
+                print("⚠️ AI 未能筛选出任何相关工具，将使用所有工具。")
                 # 广播工具筛选事件（无筛选结果）
                 try:
                     self.event_bus.emit(
@@ -1208,9 +1519,7 @@ class Agent:
                     pass
 
         except Exception as e:
-            PrettyOutput.print(
-                f"工具筛选失败: {e}，将使用所有工具。", OutputType.ERROR
-            )
+            print(f"❌ 工具筛选失败: {e}，将使用所有工具。")
 
     def _check_and_organize_memory(self):
         """
@@ -1227,7 +1536,7 @@ class Agent:
                 "global",
             )
         except Exception as e:
-            PrettyOutput.print(f"检查记忆库时发生意外错误: {e}", OutputType.WARNING)
+            print(f"⚠️ 检查记忆库时发生意外错误: {e}")
 
     def _perform_memory_check(self, memory_type: str, base_path: Path, scope_name: str):
         """执行特定范围的记忆检查和整理"""
@@ -1268,11 +1577,8 @@ class Agent:
             f"并且存在3个以上标签重叠的记忆。\n"
             f"是否立即整理记忆库以优化性能和相关性？"
         )
-        if self.user_confirm(prompt, True):
-            PrettyOutput.print(
-                f"正在开始整理 '{scope_name}' ({memory_type}) 记忆库...",
-                OutputType.INFO,
-            )
+        if self.confirm_callback(prompt, False):
+            print(f"ℹ️ 正在开始整理 '{scope_name}' ({memory_type}) 记忆库...")
             organizer.organize_memories(memory_type, min_overlap=3)
         else:
-            PrettyOutput.print(f"已取消 '{scope_name}' 记忆库整理。", OutputType.INFO)
+            print(f"ℹ️ 已取消 '{scope_name}' 记忆库整理。")