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

jarvis/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI Assistant"""
 
-__version__ = "0.3.30"
+__version__ = "0.7.0"

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
@@ -24,16 +25,18 @@ from jarvis.jarvis_agent.tool_executor import execute_tool_call
 from jarvis.jarvis_agent.memory_manager import MemoryManager
 from jarvis.jarvis_memory_organizer.memory_organizer import MemoryOrganizer
 from jarvis.jarvis_agent.task_analyzer import TaskAnalyzer
+from jarvis.jarvis_agent.task_planner import TaskPlanner
 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 as TASK_ANALYSIS_PROMPT,
 )
 from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
+from jarvis.jarvis_agent.rewrite_file_handler import RewriteFileHandler
 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 +57,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 +68,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,6 +76,9 @@ from jarvis.jarvis_utils.config import (
     is_use_methodology,
     get_tool_filter_threshold,
     get_after_tool_call_cb_dirs,
+    get_plan_max_depth,
+    is_plan_enabled,
+    get_addon_prompt_threshold,
 )
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.globals import (
@@ -243,8 +251,25 @@ class Agent:
     def clear_history(self):
         """
         Clears the current conversation history by delegating to the session manager.
+        Emits BEFORE_HISTORY_CLEAR/AFTER_HISTORY_CLEAR and reapplies system prompt to preserve constraints.
         """
+        # 广播清理历史前事件（不影响主流程）
+        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
+
+        # 重置后重新设置系统提示词，确保系统约束仍然生效
+        try:
+            self._setup_system_prompt()
+        except Exception:
+            pass
+
         # 广播清理历史后的事件
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
@@ -264,6 +289,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,15 +314,23 @@ 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,
+        auto_summary_rounds: Optional[int] = None,
         multiline_inputer: Optional[Callable[[str], str]] = None,
         use_methodology: Optional[bool] = None,
         use_analysis: Optional[bool] = None,
         force_save_memory: Optional[bool] = None,
+        disable_file_edit: bool = False,
         files: Optional[List[str]] = None,
         confirm_callback: Optional[Callable[[str, bool], bool]] = None,
+        non_interactive: Optional[bool] = None,
+        in_multi_agent: Optional[bool] = None,
+        plan: Optional[bool] = None,
+        plan_max_depth: Optional[int] = None,
+        plan_depth: int = 0,
+        agent_type: str = "normal",
+        **kwargs,
     ):
         """初始化Jarvis Agent实例
 
@@ -293,8 +341,6 @@ class Agent:
 
             summary_prompt: 任务总结提示模板
             auto_complete: 是否自动完成任务
-            output_handler: 输出处理器列表
-            input_handler: 输入处理器列表
             execute_tool_confirm: 执行工具前是否需要确认
             need_summary: 是否需要生成总结
             multiline_inputer: 多行输入处理器
@@ -302,21 +348,57 @@ class Agent:
             use_analysis: 是否使用任务分析
             force_save_memory: 是否强制保存记忆
             confirm_callback: 用户确认回调函数，签名为 (tip: str, default: bool) -> bool；默认使用CLI的user_confirm
+            non_interactive: 是否以非交互模式运行（优先级最高，覆盖环境变量与配置）
+            plan: 是否启用任务规划与子任务拆分（默认从配置加载；启用后在进入主循环前评估是否需要将任务拆分为 <SUB_TASK> 列表，逐一由子Agent执行并汇总结果）
+            plan_max_depth: 任务规划的最大层数（默认3，可通过配置 JARVIS_PLAN_MAX_DEPTH 或入参覆盖）
+            plan_depth: 当前规划层数（内部用于递归控制，子Agent会在父基础上+1）
         """
-        # 基础属性初始化
-        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)
+        # 自动摘要轮次：None 表示使用配置文件中的默认值，由 AgentRunLoop 决定最终取值
+        self.auto_summary_rounds = auto_summary_rounds
+        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.disable_file_edit = bool(disable_file_edit)
+        # 资源与环境
+        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.plan = bool(plan) if plan is not None else is_plan_enabled()
+        # 规划深度与上限
+        try:
+            self.plan_max_depth = (
+                int(plan_max_depth) if plan_max_depth is not None else int(get_plan_max_depth())
+            )
+        except Exception:
+            self.plan_max_depth = 2
+        try:
+            self.plan_depth = int(plan_depth)
+        except Exception:
+            self.plan_depth = 0
+        # 运行时状态
         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
 
 
         # 用户确认回调：默认使用 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 +408,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()
@@ -353,6 +472,8 @@ class Agent:
         self.task_analyzer = TaskAnalyzer(self)
         self.file_methodology_manager = FileMethodologyManager(self)
         self.prompt_manager = PromptManager(self)
+        # 任务规划器：封装规划与子任务调度逻辑
+        self.task_planner = TaskPlanner(self, plan_depth=self.plan_depth, plan_max_depth=self.plan_max_depth)
 
         # 设置系统提示词
         self._setup_system_prompt()
@@ -394,55 +515,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()]
+        if not getattr(self, "disable_file_edit", False):
+            default_handlers.extend([EditFileHandler(), RewriteFileHandler()])
+        handlers = output_handler or default_handlers
+        if getattr(self, "disable_file_edit", False):
+            handlers = [h for h in handlers if not isinstance(h, (EditFileHandler, RewriteFileHandler))]
+        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:
@@ -666,7 +758,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 +778,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 +819,9 @@ class Agent:
         return message
 
     def _manage_conversation_length(self, message: str) -> str:
-        """管理对话长度，必要时进行摘要"""
+        """管理对话长度计数；摘要触发由轮次在 AgentRunLoop 中统一处理。"""
         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 +841,14 @@ class Agent:
             pass
 
         response = self.model.chat_until_success(message)  # type: ignore
-
+        # 防御: 模型可能返回空响应(None或空字符串)，统一为空字符串并告警
+        if not response:
+            try:
+                PrettyOutput.print("模型返回空响应，已使用空字符串回退。", OutputType.WARNING)
+            except Exception:
+                pass
+            response = ""
+        
         # 事件：模型调用后
         try:
             self.event_bus.emit(
@@ -758,10 +877,21 @@ 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
+            # 优先使用外部传入的 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 = self.session.prompt + "\n" + SUMMARY_REQUEST_PROMPT
 
+            summary = self.model.chat_until_success(prompt_to_use)  # type: ignore
+            # 防御: 可能返回空响应(None或空字符串)，统一为空字符串并告警
+            if not summary:
+                try:
+                    PrettyOutput.print("总结模型返回空响应，已使用空字符串回退。", OutputType.WARNING)
+                except Exception:
+                    pass
+                summary = ""
             return summary
         except Exception:
             PrettyOutput.print("总结对话历史失败", OutputType.ERROR)
@@ -820,6 +950,8 @@ class Agent:
             self._setup_system_prompt()
         # 重置会话
         self.session.clear_history()
+        # 重置 addon_prompt 跳过轮数计数器
+        self._addon_prompt_skip_rounds = 0
         # 广播清理历史后的事件
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
@@ -836,6 +968,8 @@ class Agent:
         except Exception:
             pass
         result = self.file_methodology_manager.handle_history_with_file_upload()
+        # 重置 addon_prompt 跳过轮数计数器
+        self._addon_prompt_skip_rounds = 0
         # 广播清理历史后的事件
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
@@ -882,13 +1016,17 @@ class Agent:
 
         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，避免 BEFORE_SUMMARY 事件回调修改/清空后导致使用空prompt
             # 广播将要生成总结事件
             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,7 +1035,15 @@ 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:
+                    PrettyOutput.print("总结阶段模型返回空响应，已使用空字符串回退。", OutputType.WARNING)
+                except Exception:
+                    pass
+                ret = ""
             result = ret
 
             # 广播完成总结事件
@@ -957,7 +1103,6 @@ class Agent:
     {complete_prompt}
     如果没有完成，请进行下一步操作：
     - 仅包含一个操作
-    - 不要询问用户是否继续，直接继续执行直至完成
     - 如果信息不明确，请请求用户补充
     - 如果执行过程中连续失败5次，请使用ask_user询问用户操作
     - 操作列表：{action_handlers}{memory_prompts}
@@ -997,6 +1142,13 @@ class Agent:
                 )
             except Exception:
                 pass
+            # 如启用规划模式，先判断是否需要拆分并调度子任务
+            if self.plan:
+                try:
+                    self._maybe_plan_and_dispatch(self.session.prompt)
+                except Exception:
+                    # 防御式处理，规划失败不影响主流程
+                    pass
             return self._main_loop()
         except Exception as e:
             PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
@@ -1041,7 +1193,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,6 +1256,56 @@ 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,
+            "auto_summary_rounds": self.auto_summary_rounds,
+            "multiline_inputer": self.multiline_inputer,
+            "use_methodology": self.use_methodology,
+            "use_analysis": self.use_analysis,
+            "force_save_memory": self.force_save_memory,
+            "disable_file_edit": self.disable_file_edit,
+            "files": self.files,
+            "confirm_callback": self.confirm_callback,
+            "non_interactive": True,
+            "in_multi_agent": True,
+            "plan": self.plan,  # 继承父Agent的规划开关
+            "plan_depth": self.plan_depth + 1,  # 子Agent层数+1
+            "plan_max_depth": self.plan_max_depth,  # 继承上限
+        }
+
+    def _maybe_plan_and_dispatch(self, task_text: str) -> None:
+        """委托给 TaskPlanner 执行任务规划与子任务调度，保持向后兼容。"""
+        try:
+            if hasattr(self, "task_planner") and self.task_planner:
+                # 优先使用初始化时注入的规划器
+                self.task_planner.maybe_plan_and_dispatch(task_text)  # type: ignore[attr-defined]
+            else:
+                # 防御式回退：临时创建规划器以避免因未初始化导致的崩溃
+                from jarvis.jarvis_agent.task_planner import TaskPlanner
+                TaskPlanner(self, plan_depth=self.plan_depth, plan_max_depth=self.plan_max_depth).maybe_plan_and_dispatch(task_text)
+        except Exception:
+            # 规划失败不影响主流程
+            pass
+
     def _filter_tools_if_needed(self, task: str):
         """如果工具数量超过阈值，使用大模型筛选相关工具"""
         tool_registry = self.get_tool_registry()
@@ -1268,7 +1470,7 @@ class Agent:
             f"并且存在3个以上标签重叠的记忆。\n"
             f"是否立即整理记忆库以优化性能和相关性？"
         )
-        if self.user_confirm(prompt, True):
+        if self.confirm_callback(prompt, True):
             PrettyOutput.print(
                 f"正在开始整理 '{scope_name}' ({memory_type}) 记忆库...",
                 OutputType.INFO,

jarvis/jarvis_agent/agent_manager.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """Agent管理器模块，负责Agent的初始化和任务执行"""
-from typing import Optional
+from typing import Optional, Callable
 
 import typer
 
@@ -11,10 +11,8 @@ from jarvis.jarvis_agent import (
     get_multiline_input,
     origin_agent_system_prompt,
 )
-from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
-from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
 from jarvis.jarvis_agent.task_manager import TaskManager
-from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.jarvis_utils.config import is_non_interactive, is_skip_predefined_tasks
 
 
 class AgentManager:
@@ -27,6 +25,10 @@ class AgentManager:
         restore_session: bool = False,
         use_methodology: Optional[bool] = None,
         use_analysis: Optional[bool] = None,
+        multiline_inputer: Optional[Callable[[str], str]] = None,
+        confirm_callback: Optional[Callable[[str, bool], bool]] = None,
+        non_interactive: Optional[bool] = None,
+        plan: Optional[bool] = None,
     ):
         self.model_group = model_group
         self.tool_group = tool_group
@@ -34,6 +36,11 @@ class AgentManager:
         self.use_methodology = use_methodology
         self.use_analysis = use_analysis
         self.agent: Optional[Agent] = None
+        # 可选：注入输入与确认回调，用于Web模式等前端替代交互
+        self.multiline_inputer = multiline_inputer
+        self.confirm_callback = confirm_callback
+        self.non_interactive = non_interactive
+        self.plan = plan
 
     def initialize(self) -> Agent:
         """初始化Agent"""
@@ -46,11 +53,13 @@ class AgentManager:
         self.agent = Agent(
             system_prompt=origin_agent_system_prompt,
             model_group=self.model_group,
-            input_handler=[shell_input_handler, builtin_input_handler],
-            output_handler=[ToolRegistry()],  # type: ignore
             need_summary=False,
             use_methodology=self.use_methodology,
             use_analysis=self.use_analysis,
+            multiline_inputer=self.multiline_inputer,
+            confirm_callback=self.confirm_callback,
+            non_interactive=self.non_interactive,
+            plan=self.plan,
         )
 
         # 尝试恢复会话
@@ -72,8 +81,8 @@ class AgentManager:
             self.agent.run(task_content)
             raise typer.Exit(code=0)
 
-        # 处理预定义任务
-        if self.agent.first:
+        # 处理预定义任务（非交互模式下跳过；支持配置跳过加载）
+        if not is_non_interactive() and not is_skip_predefined_tasks() and self.agent.first:
             task_manager = TaskManager()
             tasks = task_manager.load_tasks()
             if tasks and (selected_task := task_manager.select_task(tasks)):