jarvis-ai-assistant 0.3.34__py3-none-any.whl → 0.4.1__py3-none-any.whl

jarvis/jarvis_code_agent/code_agent.py

@@ -56,9 +56,11 @@ class CodeAgent:
         need_summary: bool = True,
         append_tools: Optional[str] = None,
         tool_group: Optional[str] = None,
+        non_interactive: Optional[bool] = None,
     ):
         self.root_dir = os.getcwd()
         self.tool_group = tool_group
+        self.non_interactive = non_interactive
 
         # 检测 git username 和 email 是否已设置
         self._check_git_config()
@@ -68,7 +70,6 @@ class CodeAgent:
             "search_web",
             "ask_user",
             "read_code",
-            "rewrite_file",
             "save_memory",
             "retrieve_memory",
             "clear_memory",
@@ -89,16 +90,11 @@ class CodeAgent:
             system_prompt=code_system_prompt,
             name="CodeAgent",
             auto_complete=False,
-            output_handler=[tool_registry, EditFileHandler()],  # type: ignore
             model_group=model_group,
-            input_handler=[
-                shell_input_handler,
-                file_context_handler,
-                builtin_input_handler,
-            ],
             need_summary=need_summary,
             use_methodology=False,  # 禁用方法论
             use_analysis=False,  # 禁用分析
+            non_interactive=self.non_interactive,
         )
 
         self.agent.event_bus.subscribe(AFTER_TOOL_CALL, self._on_after_tool_call)
@@ -142,7 +138,7 @@ class CodeAgent:
 
 ## 文件编辑工具使用规范
 - 对于部分文件内容修改，使用edit_file工具
-- 对于需要重写整个文件内容，使用rewrite_file工具
+- 对于需要重写整个文件内容，使用 REWRITE 操作
 - 对于简单的修改，可以使用execute_script工具执行shell命令完成
 
 ## 子任务与子CodeAgent
@@ -572,8 +568,8 @@ class CodeAgent:
             1. 每次响应仅执行一步操作，先分析再修改，避免一步多改。
             2. 充分利用工具理解用户需求和现有代码，禁止凭空假设。
             3. 如果不清楚要修改的文件，必须先分析并找出需要修改的文件，明确目标后再进行编辑。
-            4. 代码编辑任务优先使用 edit_file 工具，确保搜索文本在目标文件中有且仅有一次精确匹配，保证修改的准确性和安全性。
-            5. 如需大范围重写，才可使用 rewrite_file 工具。
+            4. 代码编辑任务优先使用 PATCH 操作，确保搜索文本在目标文件中有且仅有一次精确匹配，保证修改的准确性和安全性。
+            5. 如需大范围重写，才可使用 REWRITE 操作。
             6. 如遇信息不明，优先调用工具补充分析，不要主观臆断。
             """
 
@@ -856,9 +852,10 @@ def cli(
         PrettyOutput.print(
             f"警告：当前目录 '{curr_dir_path}' 不是一个git仓库。", OutputType.WARNING
         )
-        if user_confirm(
+        init_git = True if non_interactive else user_confirm(
             f"是否要在 '{curr_dir_path}' 中初始化一个新的git仓库？", default=True
-        ):
+        )
+        if init_git:
             try:
                 subprocess.run(
                     ["git", "init"],
@@ -886,6 +883,7 @@ def cli(
             need_summary=False,
             append_tools=append_tools,
             tool_group=tool_group,
+            non_interactive=non_interactive,
         )
 
         # 尝试恢复会话

jarvis/jarvis_code_analysis/code_review.py

@@ -689,7 +689,6 @@ class CodeReviewTool:
 {ot("REPORT")}
 [在此处插入完整MARKDOWN格式的审查报告]
 {ct("REPORT")}""",
-                    output_handler=[tool_registry],  # type: ignore
                     auto_complete=False,
                 )
 

jarvis/jarvis_data/config_schema.json

@@ -322,6 +322,11 @@
       "description": "是否保存会话记录",
       "default": false
     },
+    "JARVIS_SKIP_PREDEFINED_TASKS": {
+      "type": "boolean",
+      "description": "是否跳过预定义任务加载（不读取 pre-command 列表）",
+      "default": false
+    },
     "JARVIS_GIT_CHECK_MODE": {
       "type": "string",
       "enum": ["strict", "warn"],

jarvis/jarvis_multi_agent/__init__.py

@@ -7,17 +7,20 @@ import yaml
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_agent.output_handler import OutputHandler
 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_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 
 
 class MultiAgent(OutputHandler):
-    def __init__(self, agents_config: List[Dict], main_agent_name: str):
+    def __init__(self, agents_config: List[Dict], main_agent_name: str, common_system_prompt: str = ""):
         self.agents_config = agents_config
         self.agents_config_map = {c["name"]: c for c in agents_config}
         self.agents: Dict[str, Agent] = {}
         self.main_agent_name = main_agent_name
         self.original_question: Optional[str] = None
+        self.common_system_prompt: str = common_system_prompt
 
     def prompt(self) -> str:
         return f"""
@@ -66,18 +69,168 @@ content: |2
 """
 
     def can_handle(self, response: str) -> bool:
-        return len(self._extract_send_msg(response)) > 0
+        # 只要检测到 SEND_MESSAGE 起始标签即认为可处理，
+        # 即便内容有误也由 handle 返回明确错误与修复指导
+        return ot("SEND_MESSAGE") in response
 
     def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
-        send_messages = self._extract_send_msg(response)
-        if len(send_messages) > 1:
+        """
+        处理 SEND_MESSAGE。若存在格式/解析/字段/目标等问题，返回明确错误原因与修复指导。
+        """
+        # 优先使用解析器获取“正确路径”结果
+        parsed = self._extract_send_msg(response)
+        if len(parsed) == 1:
+            msg = parsed[0]
+            # 字段校验
+            to_val = msg.get("to")
+            content_val = msg.get("content")
+            missing = []
+            if not to_val:
+                missing.append("to")
+            if content_val is None or (isinstance(content_val, str) and content_val.strip() == ""):
+                # 允许空格/空行被视为缺失
+                missing.append("content")
+            if missing:
+                guidance = (
+                    "SEND_MESSAGE 字段缺失或为空："
+                    + ", ".join(missing)
+                    + "\n修复建议：\n"
+                    "- 必须包含 to 和 content 字段\n"
+                    "- to: 目标智能体名称（字符串）\n"
+                    "- content: 发送内容，建议使用多行块 |2 保持格式\n"
+                    "示例：\n"
+                    f"{ot('SEND_MESSAGE')}\n"
+                    "to: 目标Agent名称\n"
+                    "content: |2\n"
+                    "  这里填写要发送的消息内容\n"
+                    f"{ct('SEND_MESSAGE')}"
+                )
+                return False, guidance
+            # 类型校验
+            if not isinstance(to_val, str):
+                return False, "SEND_MESSAGE 字段类型错误：to 必须为字符串。修复建议：将 to 改为字符串，如 to: ChapterPolisher"
+            if not isinstance(content_val, str):
+                return False, "SEND_MESSAGE 字段类型错误：content 必须为字符串。修复建议：将 content 改为字符串或使用多行块 content: |2"
+            # 目标校验
+            if to_val not in self.agents_config_map:
+                available = ", ".join(self.agents_config_map.keys())
+                return (
+                    False,
+                    f"目标智能体不存在：'{to_val}' 不在可用列表中。\n"
+                    f"可用智能体：[{available}]\n"
+                    "修复建议：\n"
+                    "- 将 to 修改为上述可用智能体之一\n"
+                    "- 或检查配置中是否遗漏了该智能体的定义"
+                )
+            # 通过校验，交给上层发送
+            return True, {"to": to_val, "content": content_val}
+        elif len(parsed) > 1:
+            return (
+                False,
+                "检测到多个 SEND_MESSAGE 块。一次只能发送一个消息。\n修复建议：合并消息或分多轮发送，每轮仅保留一个 SEND_MESSAGE 块。"
+            )
+        # 未成功解析，进行诊断并返回可操作指导
+        try:
+            normalized = response.replace("\r\n", "\n").replace("\r", "\n")
+        except Exception:
+            normalized = response
+        ot_tag = ot("SEND_MESSAGE")
+        ct_tag = ct("SEND_MESSAGE")
+        has_open = ot_tag in normalized
+        has_close = ct_tag in normalized
+        if has_open and not has_close:
             return (
                 False,
-                "Send multiple messages, please only send one message at a time.",
+                f"检测到 {ot_tag} 但缺少结束标签 {ct_tag}。\n"
+                "修复建议：在消息末尾补充结束标签，并确认标签各自独占一行。\n"
+                "示例：\n"
+                f"{ot_tag}\n"
+                "to: 目标Agent名称\n"
+                "content: |2\n"
+                "  这里填写要发送的消息内容\n"
+                f"{ct_tag}"
+            )
+        # 尝试提取原始块并指出 YAML 问题
+        import re as _re
+        pattern = _re.compile(
+            rf"{_re.escape(ot_tag)}[ \t]*\n(.*?)(?:\n)?[ \t]*{_re.escape(ct_tag)}",
+            _re.DOTALL,
+        )
+        blocks = pattern.findall(normalized)
+        if not blocks:
+            alt_pattern = _re.compile(
+                rf"{_re.escape(ot_tag)}[ \t]*(.*?)[ \t]*{_re.escape(ct_tag)}",
+                _re.DOTALL,
+            )
+            blocks = alt_pattern.findall(normalized)
+        if not blocks:
+            return (
+                False,
+                "SEND_MESSAGE 格式错误：未能识别完整的消息块。\n"
+                "修复建议：确保起止标签在单独行上，且中间内容为合法的 YAML，包含 to 与 content 字段。"
+            )
+        raw = blocks[0]
+        try:
+            msg_obj = yaml.safe_load(raw)
+            if not isinstance(msg_obj, dict):
+                return (
+                    False,
+                    "SEND_MESSAGE 内容必须为 YAML 对象（键值对）。\n"
+                    "修复建议：使用 to 与 content 字段构成的对象。\n"
+                    "示例：\n"
+                    f"{ot('SEND_MESSAGE')}\n"
+                    "to: 目标Agent名称\n"
+                    "content: |2\n"
+                    "  这里填写要发送的消息内容\n"
+                    f"{ct('SEND_MESSAGE')}"
+                )
+            missing_keys = [k for k in ("to", "content") if k not in msg_obj]
+            if missing_keys:
+                return (
+                    False,
+                    "SEND_MESSAGE 缺少必要字段：" + ", ".join(missing_keys) + "\n"
+                    "修复建议：补充缺失字段。\n"
+                    "示例：\n"
+                    f"{ot('SEND_MESSAGE')}\n"
+                    "to: 目标Agent名称\n"
+                    "content: |2\n"
+                    "  这里填写要发送的消息内容\n"
+                    f"{ct('SEND_MESSAGE')}"
+                )
+            # 针对值类型的提示（更细）
+            if not isinstance(msg_obj.get("to"), str):
+                return False, "SEND_MESSAGE 字段类型错误：to 必须为字符串。"
+            if not isinstance(msg_obj.get("content"), str):
+                return False, "SEND_MESSAGE 字段类型错误：content 必须为字符串，建议使用多行块 |2。"
+            # 若到此仍未返回，说明结构基本正确，但 _extract_send_msg 未命中，给出泛化建议
+            return (
+                False,
+                "SEND_MESSAGE 格式可能存在缩进或空白字符问题，导致未被系统识别。\n"
+                "修复建议：\n"
+                "- 确保起止标签各占一行\n"
+                "- 标签与内容之间保留换行\n"
+                "- 使用 content: |2 并保证 YAML 缩进一致\n"
+                "示例：\n"
+                f"{ot('SEND_MESSAGE')}\n"
+                "to: 目标Agent名称\n"
+                "content: |2\n"
+                "  这里填写要发送的消息内容\n"
+                f"{ct('SEND_MESSAGE')}"
+            )
+        except Exception as e:
+            return (
+                False,
+                f"SEND_MESSAGE YAML 解析失败：{str(e)}\n"
+                "修复建议：\n"
+                "- 检查冒号、缩进与引号是否正确\n"
+                "- 使用 content: |2 多行块以避免缩进歧义\n"
+                "示例：\n"
+                f"{ot('SEND_MESSAGE')}\n"
+                "to: 目标Agent名称\n"
+                "content: |2\n"
+                "  这里填写要发送的消息内容\n"
+                f"{ct('SEND_MESSAGE')}"
             )
-        if len(send_messages) == 0:
-            return False, ""
-        return True, send_messages[0]
 
     def name(self) -> str:
         return "SEND_MESSAGE"
@@ -89,16 +242,38 @@ content: |2
         Args:
             content: The content containing send message
         """
-        if ot("SEND_MESSAGE") in content and ct("SEND_MESSAGE") not in content:
-            content += "\n" + ct("SEND_MESSAGE")
-        data = re.findall(
-            ot("SEND_MESSAGE") + r"\n(.*?)\n" + ct("SEND_MESSAGE"), content, re.DOTALL
+        # Normalize line endings to handle CRLF/CR cases to ensure robust matching
+        try:
+            normalized = content.replace("\r\n", "\n").replace("\r", "\n")
+        except Exception:
+            normalized = content
+
+        ot_tag = ot("SEND_MESSAGE")
+        ct_tag = ct("SEND_MESSAGE")
+
+        # Auto-append closing tag if missing
+        if ot_tag in normalized and ct_tag not in normalized:
+            normalized += "\n" + ct_tag
+
+        # Use robust regex with DOTALL; escape tags to avoid regex meta issues
+        pattern = re.compile(
+            rf"{re.escape(ot_tag)}[ \t]*\n(.*?)(?:\n)?[ \t]*{re.escape(ct_tag)}",
+            re.DOTALL,
         )
+        data = pattern.findall(normalized)
+        # Fallback: handle cases without explicit newlines around closing tag
+        if not data:
+            alt_pattern = re.compile(
+                rf"{re.escape(ot_tag)}[ \t]*(.*?)[ \t]*{re.escape(ct_tag)}",
+                re.DOTALL,
+            )
+            data = alt_pattern.findall(normalized)
+
         ret = []
         for item in data:
             try:
                 msg = yaml.safe_load(item)
-                if "to" in msg and "content" in msg:
+                if isinstance(msg, dict) and "to" in msg and "content" in msg:
                     ret.append(msg)
             except Exception:
                 continue
@@ -113,24 +288,22 @@ content: |2
 
         config = self.agents_config_map[name].copy()
 
+        # Prepend common system prompt if configured
+        common_sp = getattr(self, "common_system_prompt", "")
+        if common_sp:
+            existing_sp = config.get("system_prompt", "")
+            if existing_sp:
+                config["system_prompt"] = f"{common_sp}\n\n{existing_sp}"
+            else:
+                config["system_prompt"] = common_sp
+
         if name != self.main_agent_name and self.original_question:
             system_prompt = config.get("system_prompt", "")
             config["system_prompt"] = (
                 f"{system_prompt}\n\n# 原始问题\n{self.original_question}"
             )
 
-        output_handler = config.get("output_handler", [])
-        if len(output_handler) == 0:
-            output_handler = [
-                ToolRegistry(),
-                self,
-            ]
-        else:
-            if not any(isinstance(h, MultiAgent) for h in output_handler):
-                output_handler.append(self)
-        config["output_handler"] = output_handler
-
-        agent = Agent(**config)
+        agent = Agent(output_handler=[ToolRegistry(),  EditFileHandler(), RewriteFileHandler(), self],**config)
         self.agents[name] = agent
         return agent
 
@@ -204,6 +377,13 @@ content: {msg['content']}
             if not agent:
                 return f"智能体 {to_agent_name} 未找到"
 
+            # Check if the sending agent should be cleared
+            sender_config = self.agents_config_map.get(last_agent_name, {})
+            if sender_config.get("clear_after_send_message"):
+                if agent:
+                    PrettyOutput.print(f"清除智能体 {last_agent_name} 在发送消息后的历史记录...", OutputType.INFO)
+                    agent.clear_history()
+
             last_agent_name = agent.name
             msg = agent.run(prompt)
         return ""

jarvis/jarvis_multi_agent/main.py

@@ -20,10 +20,12 @@ def cli(
     user_input: Optional[str] = typer.Option(
         None, "--input", "-i", help="用户输入（可选）"
     ),
+    model_group: Optional[str] = typer.Option(
+        None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
+    ),
     non_interactive: bool = typer.Option(
         False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
     ),
-    ),
 ):
     """从YAML配置文件初始化并运行多智能体系统"""
     # CLI 标志：非交互模式（不依赖配置文件）
@@ -46,6 +48,8 @@ def cli(
     try:
         if non_interactive:
             set_config("JARVIS_NON_INTERACTIVE", True)
+        if model_group:
+            set_config("JARVIS_LLM_GROUP", str(model_group))
     except Exception:
         # 静默忽略同步异常，不影响主流程
         pass
@@ -62,7 +66,11 @@ def cli(
             raise ValueError("必须指定main_agent作为主智能体")
 
         # 创建并运行多智能体系统
-        multi_agent = MultiAgent(agents_config, main_agent_name)
+        multi_agent = MultiAgent(
+            agents_config,
+            main_agent_name,
+            common_system_prompt=str(config_data.get("common_system_prompt", "") or "")
+        )
         final_input = (
             user_input
             if user_input is not None

jarvis/jarvis_platform/base.py

@@ -24,6 +24,7 @@ from jarvis.jarvis_utils.config import (
 )
 from jarvis.jarvis_utils.embedding import split_text_into_chunks
 from jarvis.jarvis_utils.globals import set_in_chat, get_interrupt, console
+import jarvis.jarvis_utils.globals as G
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 from jarvis.jarvis_utils.utils import get_context_token_count, while_success, while_true
@@ -83,6 +84,11 @@ class BasePlatform(ABC):
 
         start_time = time.time()
 
+        # 当输入为空白字符串时，打印警告并直接返回空字符串
+        if message.strip() == "":
+            PrettyOutput.print("输入为空白字符串，已忽略本次请求", OutputType.WARNING)
+            return ""
+
         input_token_count = get_context_token_count(message)
 
         if input_token_count > get_max_input_token_count(self.model_group):
@@ -133,7 +139,9 @@ class BasePlatform(ABC):
                     first_chunk = None
 
                     with Status(
-                        f"🤔 {self.name()} 正在思考中...", spinner="dots", console=console
+                        f"🤔 {(G.current_agent_name + ' · ') if G.current_agent_name else ''}{self.name()} 正在思考中...",
+                        spinner="dots",
+                        console=console,
                     ):
                         try:
                             while True:
@@ -147,7 +155,7 @@ class BasePlatform(ABC):
                     text_content = Text(overflow="fold")
                     panel = Panel(
                         text_content,
-                        title=f"[bold cyan]{self.name()}[/bold cyan]",
+                        title=f"[bold cyan]{(G.current_agent_name + ' · ') if G.current_agent_name else ''}{self.name()}[/bold cyan]",
                         subtitle="[yellow]正在回答... (按 Ctrl+C 中断)[/yellow]",
                         border_style="bright_blue",
                         box=box.ROUNDED,
@@ -223,10 +231,11 @@ class BasePlatform(ABC):
                         duration = end_time - start_time
                         panel.subtitle = f"[bold green]✓ 对话完成耗时: {duration:.2f}秒[/bold green]"
                         live.update(panel)
+                    console.print()
                 else:
                     # Print a clear prefix line before streaming model output (non-pretty mode)
                     console.print(
-                        f"🤖 模型输出 - {self.name()}  (按 Ctrl+C 中断)",
+                        f"🤖 模型输出 - {(G.current_agent_name + ' · ') if G.current_agent_name else ''}{self.name()}  (按 Ctrl+C 中断)",
                         soft_wrap=False,
                     )
                     for s in self.chat(message):
@@ -368,9 +377,10 @@ class BasePlatform(ABC):
                 return
 
             if self._session_history_file is None:
-                # Ensure data directory exists
+                # Ensure session history directory exists under data directory
                 data_dir = get_data_dir()
-                os.makedirs(data_dir, exist_ok=True)
+                session_dir = os.path.join(data_dir, "session_history")
+                os.makedirs(session_dir, exist_ok=True)
 
                 # Build a safe filename including platform, model and timestamp
                 try:
@@ -388,7 +398,7 @@ class BasePlatform(ABC):
                 ts = datetime.now().strftime("%Y%m%d_%H%M%S")
 
                 self._session_history_file = os.path.join(
-                    data_dir, f"session_history_{safe_platform}_{safe_model}_{ts}.log"
+                    session_dir, f"session_history_{safe_platform}_{safe_model}_{ts}.log"
                 )
 
             # Append record

jarvis/jarvis_tools/sub_agent.py

@@ -5,7 +5,7 @@ sub_agent 工具
 
 约定：
 - 必填参数：task, name, background, system_prompt, summary_prompt, use_tools
-- 继承父 Agent 的部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer；其他参数需显式提供
+- 继承父 Agent 的部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer、non_interactive、use_methodology、use_analysis；其他参数需显式提供
 - 子Agent必须自动完成(auto_complete=True)且需要summary(need_summary=True)
 """
 from typing import Any, Dict, List
@@ -27,7 +27,7 @@ class SubAgentTool:
 
     # 必须与文件名一致，供 ToolRegistry 自动注册
     name = "sub_agent"
-    description = "将子任务交给通用 Agent 执行，并返回执行结果（继承父Agent部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer；其他参数需显式提供，自动完成并生成总结）。"
+    description = "将子任务交给通用 Agent 执行，并返回执行结果（继承父Agent部分配置：model_group、input_handler、execute_tool_confirm、multiline_inputer、non_interactive、use_methodology、use_analysis；其他参数需显式提供，自动完成并生成总结）。"
     parameters = {
         "type": "object",
         "properties": {
@@ -51,17 +51,6 @@ class SubAgentTool:
                 "type": "string",
                 "description": "覆盖子Agent的总结提示词（必填）",
             },
-            "use_tools": {
-                "type": "array",
-                "items": {"type": "string"},
-                "description": "限制子Agent可用的工具名称列表（必填）。兼容以逗号分隔的字符串输入。可用的工具列表："
-                + "\n".join(
-                    [
-                        t["name"] + ": " + t["description"]
-                        for t in ToolRegistry().get_all_tools()
-                    ]
-                ),
-            },
         },
         "required": [
             "task",
@@ -69,7 +58,6 @@ class SubAgentTool:
             "background",
             "system_prompt",
             "summary_prompt",
-            "use_tools",
         ],
     }
 
@@ -105,16 +93,6 @@ class SubAgentTool:
             summary_prompt = str(args.get("summary_prompt", "")).strip()
             agent_name = str(args.get("name", "")).strip()
 
-            # 解析可用工具列表（支持数组或以逗号分隔的字符串）
-            _use_tools = args.get("use_tools", None)
-            use_tools: List[str] = []
-            if isinstance(_use_tools, list):
-                use_tools = [str(x).strip() for x in _use_tools if str(x).strip()]
-            elif isinstance(_use_tools, str):
-                use_tools = [s.strip() for s in _use_tools.split(",") if s.strip()]
-            else:
-                use_tools = []
-
             errors = []
             if not system_prompt:
                 errors.append("system_prompt 不能为空")
@@ -122,8 +100,6 @@ class SubAgentTool:
                 errors.append("summary_prompt 不能为空")
             if not agent_name:
                 errors.append("name 不能为空")
-            if not use_tools:
-                errors.append("use_tools 不能为空")
             if not background:
                 errors.append("background 不能为空")
 
@@ -137,16 +113,20 @@ class SubAgentTool:
             # 基于父Agent（如有）继承部分配置后创建子Agent
             parent_agent = args.get("agent", None)
             parent_model_group = None
-            parent_input_handler = None
             parent_execute_tool_confirm = None
             parent_multiline_inputer = None
+            parent_non_interactive = None
+            parent_use_methodology = None
+            parent_use_analysis = None
             try:
                 if parent_agent is not None:
                     if getattr(parent_agent, "model", None):
                         parent_model_group = getattr(parent_agent.model, "model_group", None)
-                    parent_input_handler = getattr(parent_agent, "input_handler", None)
                     parent_execute_tool_confirm = getattr(parent_agent, "execute_tool_confirm", None)
                     parent_multiline_inputer = getattr(parent_agent, "multiline_inputer", None)
+                    parent_non_interactive = getattr(parent_agent, "non_interactive", None)
+                    parent_use_methodology = getattr(parent_agent, "use_methodology", None)
+                    parent_use_analysis = getattr(parent_agent, "use_analysis", None)
             except Exception:
                 # 安全兜底：无法从父Agent获取配置则保持为None，使用系统默认
                 pass
@@ -158,24 +138,17 @@ class SubAgentTool:
                 model_group=parent_model_group,
                 summary_prompt=summary_prompt,
                 auto_complete=auto_complete,
-                output_handler=None,
                 use_tools=None,
-                input_handler=parent_input_handler,
                 execute_tool_confirm=parent_execute_tool_confirm,
                 need_summary=need_summary,
                 multiline_inputer=parent_multiline_inputer,
-                use_methodology=None,
-                use_analysis=None,
+                use_methodology=parent_use_methodology,
+                use_analysis=parent_use_analysis,
                 force_save_memory=None,
                 files=None,
+                non_interactive=parent_non_interactive,
             )
 
-            # 设置可用工具列表
-            try:
-                agent.set_use_tools(use_tools)
-            except Exception:
-                pass
-
             # 校验子Agent所用模型是否有效，必要时回退到平台可用模型
             try:
                 platform = getattr(agent, "model", None)

jarvis/jarvis_tools/sub_code_agent.py

@@ -84,6 +84,7 @@ class SubCodeAgentTool:
                             parent_agent = None
                 except Exception:
                     parent_agent = None
+            parent_non_interactive = getattr(parent_agent, "non_interactive", None) if parent_agent is not None else None
             model_group = None
             use_tools: List[str] = []
             try:
@@ -115,7 +116,7 @@ class SubCodeAgentTool:
                     "search_web",
                     "ask_user",
                     "read_code",
-                    "rewrite_file",
+
                     "save_memory",
                     "retrieve_memory",
                     "clear_memory",
@@ -138,6 +139,7 @@ class SubCodeAgentTool:
                     need_summary=True,
                     append_tools=append_tools,
                     tool_group=tool_group,
+                    non_interactive=parent_non_interactive,
                 )
             except SystemExit as se:
                 # 将底层 sys.exit 转换为工具错误，避免终止进程

jarvis/jarvis_utils/config.py

@@ -81,10 +81,10 @@ def get_max_token_count(model_group_override: Optional[str] = None) -> int:
     获取模型允许的最大token数量。
 
     返回:
-        int: 模型能处理的最大token数量，为最大输入token数量的100倍。
+        int: 模型能处理的最大token数量，为最大输入token数量的30倍。
     """
     max_input_tokens = get_max_input_token_count(model_group_override)
-    return max_input_tokens * 100
+    return max_input_tokens * 30
 
 
 def get_max_input_token_count(model_group_override: Optional[str] = None) -> int:
@@ -779,3 +779,13 @@ def is_non_interactive() -> bool:
         # 忽略环境变量解析异常，回退到配置
         pass
     return GLOBAL_CONFIG_DATA.get("JARVIS_NON_INTERACTIVE", False) is True
+
+
+def is_skip_predefined_tasks() -> bool:
+    """
+    是否跳过预定义任务加载。
+    
+    返回：
+        bool: 如果跳过预定义任务加载则返回True，默认为False
+    """
+    return GLOBAL_CONFIG_DATA.get("JARVIS_SKIP_PREDEFINED_TASKS", False) is True