jarvis-ai-assistant 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

jarvis/__init__.py

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

jarvis/jarvis_agent/__init__.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from enum import Enum
 from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, Union
 
+
 # 第三方库导入
 from rich.align import Align
 from rich.console import Console
@@ -31,9 +32,10 @@ from jarvis.jarvis_agent.prompts import (
     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,
@@ -65,7 +67,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,
@@ -74,6 +75,8 @@ from jarvis.jarvis_utils.config import (
     is_use_methodology,
     get_tool_filter_threshold,
     get_after_tool_call_cb_dirs,
+
+
 )
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.globals import (
@@ -279,12 +282,16 @@ class Agent:
         use_tools: Optional[List[str]] = 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,
         files: Optional[List[str]] = None,
         confirm_callback: Optional[Callable[[str, bool], bool]] = None,
+        non_interactive: Optional[bool] = None,
+        in_multi_agent: Optional[bool] = None,
+        **kwargs,
     ):
         """初始化Jarvis Agent实例
 
@@ -295,7 +302,6 @@ class Agent:
 
             summary_prompt: 任务总结提示模板
             auto_complete: 是否自动完成任务
-            output_handler: 输出处理器列表
             execute_tool_confirm: 执行工具前是否需要确认
             need_summary: 是否需要生成总结
             multiline_inputer: 多行输入处理器
@@ -303,21 +309,38 @@ 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)
+        # 自动摘要轮次：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.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] = {}
 
 
         # 用户确认回调：默认使用 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]
         )
 
@@ -327,24 +350,62 @@ class Agent:
 
         # 初始化处理器
         self._init_handlers(
-            output_handler or [],
             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()
@@ -394,12 +455,12 @@ class Agent:
 
     def _init_handlers(
         self,
-        output_handler: List[OutputHandlerProtocol],
         multiline_inputer: Optional[Callable[[str], str]],
+        output_handler: Optional[List[OutputHandlerProtocol]],
         use_tools: List[str],
     ):
         """初始化各种处理器"""
-        self.output_handler = output_handler or [ToolRegistry()]
+        self.output_handler = output_handler or [ToolRegistry(),  EditFileHandler(), RewriteFileHandler()]
         self.set_use_tools(use_tools)
         self.input_handler = [
             builtin_input_handler,
@@ -408,46 +469,6 @@ class Agent:
         ]
         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)
-        # 非交互模式下自动完成标志需要同步到 Agent 实例，避免循环
-        self.auto_complete = bool(cfg.auto_complete)
-
-        # 聚合配置到 AgentConfig，作为后续单一事实来源（保持兼容，不改变既有属性使用）
-        self.config = cfg
-
     def _setup_system_prompt(self):
         """设置系统提示词"""
         try:
@@ -707,14 +728,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
 
@@ -900,13 +916,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,
                 )
@@ -915,7 +935,8 @@ 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:
@@ -1066,7 +1087,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}",
                     "用户同意继续工具调用。"
@@ -1293,7 +1314,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

@@ -16,7 +16,7 @@ from jarvis.jarvis_agent.file_context_handler import file_context_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
+from jarvis.jarvis_utils.config import is_non_interactive, is_skip_predefined_tasks
 
 
 class AgentManager:
@@ -31,6 +31,7 @@ class AgentManager:
         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,
     ):
         self.model_group = model_group
         self.tool_group = tool_group
@@ -41,6 +42,7 @@ class AgentManager:
         # 可选：注入输入与确认回调，用于Web模式等前端替代交互
         self.multiline_inputer = multiline_inputer
         self.confirm_callback = confirm_callback
+        self.non_interactive = non_interactive
 
     def initialize(self) -> Agent:
         """初始化Agent"""
@@ -53,12 +55,12 @@ class AgentManager:
         self.agent = Agent(
             system_prompt=origin_agent_system_prompt,
             model_group=self.model_group,
-            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,
         )
 
         # 尝试恢复会话
@@ -80,8 +82,8 @@ class AgentManager:
             self.agent.run(task_content)
             raise typer.Exit(code=0)
 
-        # 处理预定义任务（非交互模式下跳过）
-        if not is_non_interactive() and 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)):

jarvis/jarvis_agent/edit_file_handler.py

@@ -92,10 +92,10 @@ class EditFileHandler(OutputHandler):
         if not patches:
             return False, "未找到有效的文件编辑指令"
 
-        # 记录 edit_file 工具调用统计
+        # 记录 PATCH 操作调用统计
         from jarvis.jarvis_stats.stats import StatsManager
 
-        StatsManager.increment("edit_file", group="tool")
+        StatsManager.increment("patch", group="tool")
 
         results = []
 

jarvis/jarvis_agent/jarvis.py

@@ -595,7 +595,10 @@ def handle_builtin_config_selector(
 
                             elif sel["category"] == "multi_agent":
                                 # jarvis-multi-agent 需要 -c/--config，用户输入通过 -i/--input 传递
+                                # 同时传递 -g/--llm-group 以继承 jvs 的模型组选择
                                 args = [str(sel["cmd"]), "-c", str(sel["file"])]
+                                if model_group:
+                                    args += ["-g", str(model_group)]
                                 if task:
                                     args += ["-i", str(task)]
 
@@ -967,14 +970,14 @@ def run_cli(
             return
 
     # 在初始化环境前检测Git仓库，并可选择自动切换到代码开发模式（jca）
-    if not non_interactive and not web:
+    if not non_interactive:
         try_switch_to_jca_if_git_repo(
             model_group, tool_group, config_file, restore_session, task
         )
 
     # 在进入默认通用代理前，列出内置配置供选择（agent/multi_agent/roles）
     # 非交互模式下跳过内置角色/配置选择
-    if not non_interactive and not web:
+    if not non_interactive:
         handle_builtin_config_selector(model_group, tool_group, config_file, task)
 
     # 初始化环境
@@ -1005,13 +1008,9 @@ def run_cli(
         # 在 Web 模式下注入基于 WebSocket 的输入/确认回调
         extra_kwargs = {}
         if web:
-            try:
-                from jarvis.jarvis_agent.web_bridge import web_multiline_input, web_user_confirm
-                extra_kwargs["multiline_inputer"] = web_multiline_input
-                extra_kwargs["confirm_callback"] = web_user_confirm
-            except Exception as e:
-                PrettyOutput.print(f"Web 模式初始化失败（加载 Web 桥接模块）: {e}", OutputType.ERROR)
-                raise typer.Exit(code=1)
+            # 纯 xterm 交互模式：不注入 WebBridge 的输入/确认回调，避免阻塞等待浏览器响应
+            #（交互由 /terminal PTY 会话中的 jvs 进程处理）
+            pass
 
         agent_manager = AgentManager(
             model_group=model_group,
@@ -1019,6 +1018,7 @@ def run_cli(
             restore_session=restore_session,
             use_methodology=False if disable_methodology_analysis else None,
             use_analysis=False if disable_methodology_analysis else None,
+            non_interactive=non_interactive,
             **extra_kwargs,
         )
         agent = agent_manager.initialize()
@@ -1051,6 +1051,37 @@ def run_cli(
                     enable_web_stdin_redirect()
                 except Exception:
                     pass
+                # 记录用于交互式终端（PTY）重启的 jvs 启动命令（移除 web 相关参数）
+                try:
+                    import sys as _sys, os as _os, json as _json
+                    _argv = list(_sys.argv)
+                    # 去掉程序名（argv[0]），并过滤 --web 相关参数
+                    filtered = []
+                    i = 1
+                    while i < len(_argv):
+                        a = _argv[i]
+                        if a == "--web" or a.startswith("--web="):
+                            i += 1
+                            continue
+                        if a == "--web-host":
+                            i += 2
+                            continue
+                        if a.startswith("--web-host="):
+                            i += 1
+                            continue
+                        if a == "--web-port":
+                            i += 2
+                            continue
+                        if a.startswith("--web-port="):
+                            i += 1
+                            continue
+                        filtered.append(a)
+                        i += 1
+                    # 使用 jvs 命令作为可执行文件，保留其余业务参数
+                    cmd = ["jvs"] + filtered
+                    _os.environ["JARVIS_WEB_LAUNCH_JSON"] = _json.dumps(cmd, ensure_ascii=False)
+                except Exception:
+                    pass
                 PrettyOutput.print("以 Web 模式启动，请在浏览器中打开提供的地址进行交互。", OutputType.INFO)
                 # 启动 Web 服务（阻塞调用）
                 start_web_server(agent_manager, host=web_host, port=web_port)

jarvis/jarvis_agent/rewrite_file_handler.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+from typing import Any, Dict, List, Tuple
+
+from jarvis.jarvis_agent.output_handler import OutputHandler
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.tag import ct, ot
+
+
+class RewriteFileHandler(OutputHandler):
+    """
+    处理整文件重写指令的输出处理器。
+
+    指令格式：
+    <REWRITE file=文件路径>
+    新的文件完整内容
+    </REWRITE>
+
+    等价支持以下写法：
+    <REWRITE file=文件路径>
+    新的文件完整内容
+    </REWRITE>
+
+    说明：
+    - 该处理器用于完全重写文件内容，适用于新增文件或大范围改写
+    - 内部直接执行写入，提供失败回滚能力
+    - 支持同一响应中包含多个 REWRITE/REWRITE 块
+    """
+
+    def __init__(self) -> None:
+        # 允许 file 参数为单引号、双引号或无引号
+        self.rewrite_pattern_file = re.compile(
+            ot("REWRITE file=(?:'([^']+)'|\"([^\"]+)\"|([^>]+))")
+            + r"\s*"
+            + r"(.*?)"
+            + r"\s*"
+            + r"^"
+            + ct("REWRITE"),
+            re.DOTALL | re.MULTILINE,
+        )
+
+    def name(self) -> str:
+        """获取处理器名称，用于操作列表展示"""
+        return "REWRITE"
+
+    def prompt(self) -> str:
+        """返回用户提示，描述使用方法与格式"""
+        return f"""文件重写指令格式：
+{ot("REWRITE file=文件路径")}
+新的文件完整内容
+{ct("REWRITE")}
+
+注意：
+- {ot("REWRITE")}、{ct("REWRITE")} 必须出现在行首，否则不生效（会被忽略）
+- 整文件重写会完全替换文件内容，如需局部修改请使用 PATCH 操作
+- 该操作由处理器直接执行，具备失败回滚能力"""
+
+    def can_handle(self, response: str) -> bool:
+        """判断响应中是否包含 REWRITE/REWRITE 指令"""
+        return bool(self.rewrite_pattern_file.search(response))
+
+    def handle(self, response: str, agent: Any) -> Tuple[bool, str]:
+        """解析并执行整文件重写指令"""
+        rewrites = self._parse_rewrites(response)
+        if not rewrites:
+            return False, "未找到有效的文件重写指令"
+
+        # 记录 REWRITE 操作调用统计
+        try:
+            from jarvis.jarvis_stats.stats import StatsManager
+
+            StatsManager.increment("rewrite_file", group="tool")
+        except Exception:
+            # 统计失败不影响主流程
+            pass
+
+        results: List[str] = []
+        overall_success = True
+
+        for file_path, content in rewrites:
+            abs_path = os.path.abspath(file_path)
+            original_content = None
+            processed = False
+            try:
+                file_exists = os.path.exists(abs_path)
+                if file_exists:
+                    with open(abs_path, "r", encoding="utf-8") as rf:
+                        original_content = rf.read()
+                os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                with open(abs_path, "w", encoding="utf-8") as wf:
+                    wf.write(content)
+                processed = True
+                results.append(f"✅ 文件 {abs_path} 重写成功")
+                # 记录成功处理的文件（使用绝对路径）
+                if agent:
+                    files = agent.get_user_data("files")
+                    if files:
+                        if abs_path not in files:
+                            files.append(abs_path)
+                    else:
+                        files = [abs_path]
+                    agent.set_user_data("files", files)
+            except Exception as e:
+                overall_success = False
+                # 回滚已修改内容
+                try:
+                    if processed:
+                        if original_content is None:
+                            if os.path.exists(abs_path):
+                                os.remove(abs_path)
+                        else:
+                            with open(abs_path, "w", encoding="utf-8") as wf:
+                                wf.write(original_content)
+                except Exception:
+                    pass
+                PrettyOutput.print(f"文件重写失败: {str(e)}", OutputType.ERROR)
+                results.append(f"❌ 文件 {abs_path} 重写失败: {str(e)}")
+
+        summary = "\n".join(results)
+        # 按现有 EditFileHandler 约定，始终返回 (False, summary) 以继续主循环
+        return False, summary
+
+    def _parse_rewrites(self, response: str) -> List[Tuple[str, str]]:
+        """
+        解析响应中的 REWRITE/REWRITE 指令块。
+        返回列表 [(file_path, content), ...]，按在响应中的出现顺序排序
+        """
+        items: List[Tuple[str, str]] = []
+        matches: List[Tuple[int, Any]] = []
+        for m in self.rewrite_pattern_file.finditer(response):
+            matches.append((m.start(), m))
+
+        # 按出现顺序排序
+        matches.sort(key=lambda x: x[0])
+
+        for _, m in matches:
+            file_path = m.group(1) or m.group(2) or m.group(3) or ""
+            file_path = file_path.strip()
+            content = m.group(4)
+            if file_path:
+                items.append((file_path, content))
+        return items

jarvis/jarvis_agent/run_loop.py

@@ -14,6 +14,7 @@ from typing import Any, TYPE_CHECKING
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_agent.events import BEFORE_TOOL_CALL, AFTER_TOOL_CALL
 from jarvis.jarvis_agent.utils import join_prompts, is_auto_complete, normalize_next_action
+from jarvis.jarvis_utils.config import get_auto_summary_rounds
 
 if TYPE_CHECKING:
     # 仅用于类型标注，避免运行时循环依赖
@@ -25,6 +26,12 @@ class AgentRunLoop:
         self.agent = agent
         self.conversation_rounds = 0
         self.tool_reminder_rounds = int(os.environ.get("JARVIS_TOOL_REMINDER_ROUNDS", 20))
+        # 基于轮次的自动总结阈值：优先使用 Agent 入参，否则回落到全局配置（默认20轮）
+        self.auto_summary_rounds = (
+            self.agent.auto_summary_rounds
+            if getattr(self.agent, "auto_summary_rounds", None) is not None
+            else get_auto_summary_rounds()
+        )
 
     def run(self) -> Any:
         """主运行循环（委派到传入的 agent 实例的方法与属性）"""
@@ -37,6 +44,17 @@ class AgentRunLoop:
                     self.agent.session.addon_prompt = join_prompts(
                         [self.agent.session.addon_prompt, self.agent.get_tool_usage_prompt()]
                     )
+                # 基于轮次的自动总结判断：达到阈值后执行一次总结与历史清理
+                if self.conversation_rounds >= self.auto_summary_rounds:
+                    summary_text = self.agent._summarize_and_clear_history()
+                    if summary_text:
+                        # 将摘要作为下一轮的附加提示加入，从而维持上下文连续性
+                        self.agent.session.addon_prompt = join_prompts(
+                            [self.agent.session.addon_prompt, summary_text]
+                        )
+                    # 重置轮次计数与对话长度计数器，开始新一轮周期
+                    self.conversation_rounds = 0
+                    self.agent.session.conversation_length = 0
 
                 ag = self.agent
 
@@ -81,12 +99,13 @@ class AgentRunLoop:
                     pass
                 need_return, tool_prompt = ag._call_tools(current_response)
 
-                # 将上一个提示和工具提示安全地拼接起来
-                ag.session.prompt = join_prompts([ag.session.prompt, tool_prompt])
-
+                # 如果工具要求立即返回结果（例如 SEND_MESSAGE 需要将字典返回给上层），直接返回该结果
                 if need_return:
-                    return ag.session.prompt
+                    return tool_prompt
 
+                # 将上一个提示和工具提示安全地拼接起来（仅当工具结果为字符串时）
+                safe_tool_prompt = tool_prompt if isinstance(tool_prompt, str) else ""
+                ag.session.prompt = join_prompts([ag.session.prompt, safe_tool_prompt])
 
                 # 广播工具调用后的事件（不影响主流程）
                 try:

jarvis/jarvis_agent/utils.py

@@ -16,7 +16,11 @@ def join_prompts(parts: Iterable[str]) -> str:
     - 使用两个换行分隔
     - 不进行额外 strip，保持调用方原样语义
     """
-    non_empty: List[str] = [p for p in parts if p]
+    try:
+        non_empty: List[str] = [p for p in parts if isinstance(p, str) and p]
+    except Exception:
+        # 防御性处理：若 parts 不可迭代或出现异常，直接返回空字符串
+        return ""
     return "\n\n".join(non_empty)
 
 def is_auto_complete(response: str) -> bool: