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

jarvis/jarvis_agent/prompts.py

@@ -9,7 +9,11 @@ DEFAULT_SUMMARY_PROMPT = """<report>
 2. 执行结果：成功/失败
 3. 关键信息：执行过程中提取的重要信息
 4. 重要发现：任何值得注意的发现
-5. 后续建议：如果有的话
+5. 无效方案总结：如果当前是在修复问题，请总结尝试过但无效的方案，避免后续重复尝试
+   - 已尝试的方法及其失败原因
+   - 排除的错误假设
+   - 不可行的解决路径
+6. 后续建议：如果有的话
 </content>
 
 <format>
@@ -20,44 +24,198 @@ DEFAULT_SUMMARY_PROMPT = """<report>
 
 SUMMARY_REQUEST_PROMPT = """<summary_request>
 <objective>
-请对当前对话历史进行简明扼要的总结，提取关键信息和重要决策点。这个总结将作为上下文继续任务，因此需要保留对后续对话至关重要的内容。
+请对当前对话历史进行精准总结，核心目标是为后续对话提供“无关键信息缺失”的上下文支撑：既要提炼核心逻辑，又要完整保留影响后续决策/操作的关键细节，确保后续对话无需回溯原始历史即可顺畅推进。
 </objective>
 
 <guidelines>
-1. 提取关键信息：任务目标、已确定的事实、重要决策、达成的共识
-2. 保留技术细节：命令、代码片段、文件路径、配置设置等技术细节
-3. 记录任务进展：已完成的步骤、当前所处阶段、待解决的问题
-4. 包含用户偏好：用户表达的明确偏好、限制条件或特殊要求
-5. 省略冗余内容：问候语、重复信息、不相关的讨论
+#### 一、必保保留的关键信息（按优先级排序，不可遗漏）
+1. 核心目标与边界：用户最终要完成的任务（含量化指标，如“3天内实现接口”“QPS≥1000”）、明确排除的范围（如“暂不支持批量上传”）；
+2. 已确认的关键事实：技术栈（含版本，如“Python 3.9 + Django 4.2”）、环境配置（如“测试环境地址：http://test.example.com”）、数据/参数（如“数据库表名：user_info，分页大小：20条”）；
+3. 重要决策与共识：双方确认的方案（如“选用JWT做身份验证”）、否定的方案（如“排除Redis集群，用单机缓存”）、决策依据（如“因团队无K8s运维经验，选择Docker Compose”）；
+4. 技术细节（精准保留，不简化）：
+   - 可直接复用的内容：完整命令（如“pip install requests==2.31.0”）、代码片段（关键逻辑，用`代码块`标注）、文件路径（如“/data/logs/app.log”）、接口地址/参数（如“POST /api/login，必填字段：phone/code”）；
+   - 报错与调试信息：错误类型（如“IndexError”）、报错关键词（如“list index out of range”）、已尝试的有效/无效操作（如“修改索引为[-1]无效，更换httpx库报错消失”）；
+5. 任务进展与待办：
+   - 已完成步骤（如“已完成数据库表设计，已编写登录接口草稿”）；
+   - 待解决问题（明确优先级，如“高：跨域问题未处理；中：异常捕获逻辑待补充”）；
+   - 待确认/待补充信息（明确责任人与需求，如“用户需提供：测试数据库账号；助手需补充：接口文档示例”）；
+6. 用户偏好与约束：明确要求（如“代码需加注释”“输出JSON格式”）、限制条件（如“服务器内存4GB”“需兼容Windows 10”）、禁忌项（如“不可使用第三方ORM”）。
+
+#### 二、可省略的冗余内容（无需保留）
+- 寒暄与无关闲聊（如“您好”“谢谢”“今天天气不错”）；
+- 重复表述（用户多次强调的同一需求，仅保留1次核心表述）；
+- 临时试错/未落地的想法（如“我先试试这个思路”“可能用XX方案”，未确认的不保留）；
+- 与任务无关的细节（如“用户提及的其他项目经验”“无关的技术科普”）。
 </guidelines>
 
 <format>
-- 使用简洁、客观的语言
-- 按时间顺序或主题组织信息
-- 使用要点列表增强可读性
-- 总结应控制在500词以内
+1. 语言风格：简洁、客观、专业，使用编程领域规范表述（如“非阻塞IO”而非“不等待的输入输出”）；
+2. 结构组织：按“核心目标→已确认事实→决策与共识→技术细节→任务进展→待办事项→用户约束”的逻辑组织（替代“时间顺序”，更贴合后续对话需求）；
+3. 呈现形式：分点列出，关键技术内容用`代码块`/加粗标注，待办事项用“【优先级】+ 内容 + 责任人”明确（如“【高】补充跨域配置 - 助手”）；
+4. 长度限制：严格控制在500词以内，优先压缩冗余，不压缩必保信息（若必保信息较多，可适当放宽至600词）。
 </format>
 </summary_request>
 """
 
 
-TASK_ANALYSIS_PROMPT = f"""<task_analysis>
-<request>
-当前任务已结束，请按以下步骤分析该任务：
-
-第一步：记忆值得保存的信息
+def get_task_analysis_prompt(
+    has_save_memory: bool = False,
+    has_generate_new_tool: bool = False
+) -> str:
+    """根据配置返回任务分析提示词
+    
+    参数:
+        has_save_memory: 是否有 save_memory 工具（工具可用性）
+        has_generate_new_tool: 是否有 generate_new_tool 工具
+    """
+    # 第一步：记忆保存部分
+    if not has_save_memory:
+        # 如果没有 save_memory 工具，说明无法保存记忆
+        memory_step = """第一步：记忆值得保存的信息
+1. 识别任务中的关键信息和知识点
+2. 评估是否有值得保存的项目长期记忆或全局长期记忆
+3. 注意：当前环境不支持 save_memory 工具，无法保存记忆。请直接说明识别到的关键信息即可。"""
+    else:
+        # 有 save_memory 工具
+        memory_step = """第一步：记忆值得保存的信息
 1. 识别任务中的关键信息和知识点
 2. 评估是否有值得保存的项目长期记忆或全局长期记忆
-3. 使用 save_memory 工具保存有价值的信息：
+3. 如果有价值，使用 save_memory 工具保存有价值的信息：
    - project_long_term: 保存与当前项目相关的长期信息（如项目配置、架构决策、开发规范等）
-   - global_long_term: 保存通用的信息、用户偏好、知识或方法（如技术知识、最佳实践、用户习惯等）
-
-第二步：分析任务解决方案
+   - global_long_term: 保存通用的信息、用户偏好、知识或方法（如技术知识、最佳实践、用户习惯等）"""
+    
+    # 第二步：工具/方法论分析部分
+    if has_generate_new_tool:
+        solution_step = """第二步：分析任务解决方案
+1. 检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
+2. 如果现有工具/方法论不足，评估当前任务是否可以通过编写新工具来自动化解决
+3. 如果可以通过工具解决，请使用 generate_new_tool 工具创建新工具：
+   - 使用 generate_new_tool 工具，传入 tool_name 和 tool_code 参数
+   - tool_code 应包含完整的工具类定义，遵循工具代码要求
+4. 如果无法通过编写通用工具完成，评估当前的执行流程是否可以总结为通用方法论
+5. 如果以上都不可行，给出详细理由"""
+    else:
+        solution_step = """第二步：分析任务解决方案
 1. 检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
 2. 如果现有工具/方法论不足，评估当前任务是否可以通过编写新工具来自动化解决
-3. 如果可以通过工具解决，请设计并提供工具代码
+3. 如果可以通过工具解决，请设计并提供工具代码（注意：当前环境不支持 generate_new_tool 工具，需要手动创建工具文件）
 4. 如果无法通过编写通用工具完成，评估当前的执行流程是否可以总结为通用方法论
-5. 如果以上都不可行，给出详细理由
+5. 如果以上都不可行，给出详细理由"""
+    
+    # 输出要求部分
+    if has_generate_new_tool:
+        output_requirements = f"""<output_requirements>
+根据分析结果，输出以下三种情况之一：
+1. 如果现有工具/方法论可以解决，直接输出说明：
+已有工具/方法论可以解决该问题，无需创建新内容。
+可用的工具/方法论：[列出工具名称或方法论名称]
+使用方法：[简要说明如何使用]
+2. 工具创建（如果需要创建新工具）:
+{ot("TOOL_CALL")}
+{{
+  "want": "创建新工具来解决XXX问题",
+  "name": "generate_new_tool",
+  "arguments": {{
+    "tool_name": "工具名称",
+    "tool_code": `# -*- coding: utf-8 -*-
+from typing import Dict, Any
+
+class 工具名称:
+    name = "工具名称"
+    description = "Tool description"
+    parameters = {{
+        "type": "object",
+        "properties": {{
+            # 参数定义
+        }},
+        "required": []
+    }}
+    @staticmethod
+    def check() -> bool:
+        return True
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            # 使用print显示执行过程
+            print("ℹ️ 开始执行操作...")
+            # 实现逻辑
+            # ...
+            print("✅ 操作已完成")
+            return {{
+                "success": True,
+                "stdout": "结果输出",
+                "stderr": ""
+            }}
+        except Exception as e:
+            print(f"❌ 操作失败: {{str(e)}}")
+            return {{
+                "success": False,
+                "stdout": "",
+                "stderr": f"操作失败: {{str(e)}}"
+            }}`
+  }}
+}}
+{ct("TOOL_CALL")}
+
+注意：tool_code 参数推荐使用 ||| 或 ``` 分隔符包裹多行代码，直接换行无需转义，支持保留缩进。
+3. 方法论创建（如果需要创建新方法论）:
+{ot("TOOL_CALL")}
+{{
+  "want": "添加/更新xxxx的方法论",
+  "name": "methodology",
+  "arguments": {{
+    "operation": "add/update",
+    "problem_type": "方法论类型，不要过于细节，也不要过于泛化",
+    "content": |||
+方法论内容
+可以包含多行内容
+推荐使用 ||| 或 ``` 分隔符包裹多行字符串，直接换行无需转义，支持保留缩进
+包含"双引号"和'单引号'都无需转义
+    |||
+  }}
+}}
+{ct("TOOL_CALL")}
+
+注意：如果 content 参数包含多行内容，推荐使用 ||| 或 ``` 分隔符包裹，直接换行无需转义，支持保留缩进。
+如果以上三种情况都不适用，则直接输出原因分析，不要使用工具调用格式。
+</output_requirements>"""
+    else:
+        output_requirements = f"""<output_requirements>
+根据分析结果，输出以下三种情况之一：
+1. 如果现有工具/方法论可以解决，直接输出说明：
+已有工具/方法论可以解决该问题，无需创建新内容。
+可用的工具/方法论：[列出工具名称或方法论名称]
+使用方法：[简要说明如何使用]
+2. 工具创建（如果需要创建新工具）:
+注意：当前环境不支持 generate_new_tool 工具。如果需要创建新工具，请提供完整的工具代码和说明，用户需要手动创建工具文件。
+3. 方法论创建（如果需要创建新方法论）:
+{ot("TOOL_CALL")}
+{{
+  "want": "添加/更新xxxx的方法论",
+  "name": "methodology",
+  "arguments": {{
+    "operation": "add/update",
+    "problem_type": "方法论类型，不要过于细节，也不要过于泛化",
+    "content": |||
+方法论内容
+可以包含多行内容
+推荐使用 ||| 或 ``` 分隔符包裹多行字符串，直接换行无需转义，支持保留缩进
+包含"双引号"和'单引号'都无需转义
+    |||
+  }}
+}}
+{ct("TOOL_CALL")}
+
+注意：如果 content 参数包含多行内容，推荐使用 ||| 或 ``` 分隔符包裹，直接换行无需转义，支持保留缩进。
+如果以上三种情况都不适用，则直接输出原因分析，不要使用工具调用格式。
+</output_requirements>"""
+    
+    return f"""<task_analysis>
+<request>
+当前任务已结束，请按以下步骤分析该任务：
+
+{memory_step}
+
+{solution_step}
 
 请根据分析结果采取相应行动。
 
@@ -67,159 +225,23 @@ TASK_ANALYSIS_PROMPT = f"""<task_analysis>
 - 不要在一次响应中同时调用多个工具（如同时保存记忆和创建工具/方法论）
 </request>
 <evaluation_criteria>
-现有资源评估:
-1. 现有工具 - 检查系统中是否已有可以完成该任务的工具
-2. 现有方法论 - 检查是否已有适用于该任务的方法论
-3. 组合使用 - 评估现有工具和方法论组合使用是否可以解决问题
-工具评估标准:
-1. 通用性 - 该工具是否可以解决一类问题，而不仅仅是当前特定问题
-2. 自动化 - 该工具是否可以减少人工干预，提高效率
-3. 可靠性 - 该工具是否可以在不同场景下稳定工作
-4. 简单性 - 该工具是否易于使用，参数设计是否合理
-方法论评估标准:
-1. 方法论应聚焦于通用且可重复的解决方案流程
-2. 方法论应该具备足够的通用性，可应用于同类问题
-3. 特别注意用户在执行过程中提供的修正、反馈和改进建议
-4. 如果用户明确指出了某个解决步骤的优化方向，这应该被纳入方法论
-5. 方法论应面向未来复用，总结“下次遇到同类问题应该如何处理”的通用流程与检查清单，避免局限于本次执行细节
+现有资源评估: 检查现有工具/方法论/组合使用是否可解决问题
+工具评估: 通用性、自动化、可靠性、简单性
+方法论评估: 聚焦通用可重复流程，纳入用户反馈，面向未来复用
 </evaluation_criteria>
 <tool_requirements>
 工具代码要求:
-1. 工具类名应与工具名称保持一致
-2. 必须包含name、description、parameters属性
-3. 必须实现execute方法处理输入参数
-4. 可选实现check方法验证环境
-5. 工具描述应详细说明用途、适用场景和使用示例
-6. 参数定义应遵循JSON Schema格式
-7. 不要包含特定任务的细节，保持通用性
-工具设计关键点:
-1. **使用PrettyOutput打印执行过程**：强烈建议在工具中使用PrettyOutput显示执行过程，
-   这样用户可以了解工具在做什么，提升用户体验。示例：
-   ```python
-   from jarvis.jarvis_utils.output import PrettyOutput, OutputType
-   # 执行中打印信息
-   PrettyOutput.print("正在处理数据...", OutputType.INFO)
-   # 成功信息
-   PrettyOutput.print("操作成功完成", OutputType.SUCCESS)
-   # 警告信息
-   PrettyOutput.print("发现潜在问题", OutputType.WARNING)
-   # 错误信息
-   PrettyOutput.print("操作失败", OutputType.ERROR)
-   ```
-2. **结构化返回结果**：工具应该始终返回结构化的结果字典，包含以下字段：
-   - success: 布尔值，表示操作是否成功
-   - stdout: 字符串，包含工具的主要输出内容
-   - stderr: 字符串，包含错误信息（如果有）
-3. **异常处理**：工具应该妥善处理可能发生的异常，并在失败时清理已创建的资源
-   ```python
-   try:
-       # 执行逻辑
-       return {{
-           "success": True,
-           "stdout": "成功结果",
-           "stderr": ""
-       }}
-   except Exception as e:
-       PrettyOutput.print(f"操作失败: {{str(e)}}", OutputType.ERROR)
-       # 清理资源（如果有创建）
-       return {{
-           "success": False,
-           "stdout": "",
-           "stderr": f"操作失败: {{str(e)}}"
-       }}
-   ```
-4. **在工具中调用大模型**：如果工具需要调用大模型来完成子任务（例如，生成代码、分析文本等），为了避免干扰主对话流程，建议创建一个独立的大模型实例。
-   ```python
-    # 通过 agent 实例获取模型配置
-    agent = args.get("agent")
-    if not agent:
-        return {{"success": False, "stderr": "Agent not found."}}
-    
-    current_model = agent.model
-    platform_name = current_model.platform_name()
-    model_name = current_model.name()
-
-    # 创建独立的模型实例
-    from jarvis.jarvis_platform.registry import PlatformRegistry
-    llm = PlatformRegistry().create_platform(platform_name)
-    if not llm:
-        return {{"success": False, "stderr": f"Platform {{platform_name}} not found."}}
-    
-    llm.set_model_name(model_name)
-    llm.set_suppress_output(True) # 工具内的调用通常不需要流式输出
-
-    # 使用新实例调用大模型
-    PrettyOutput.print("正在执行子任务...", OutputType.INFO)
-    response = llm.chat_until_success("你的提示词")
-    PrettyOutput.print("子任务完成", OutputType.SUCCESS)
-   ```
+1. 工具类名与工具名称一致，包含name、description、parameters属性，实现execute方法
+2. 参数定义遵循JSON Schema，工具调用使用Jsonnet格式（支持 ||| 或 ``` 分隔符多行字符串、尾随逗号）
+3. 使用print显示执行过程，返回{{success, stdout, stderr}}结构化结果
+4. 妥善处理异常，失败时清理资源。如需调用大模型，创建独立实例避免干扰主流程
 </tool_requirements>
 <methodology_requirements>
-方法论格式要求:
-1. 问题重述: 简明扼要的问题归纳，不含特定细节
-2. 可复用解决流程: 面向“下次遇到同类问题”的步骤化方案（列出每步可用的工具），避免与本次特定上下文绑定
-3. 注意事项: 执行中可能遇到的常见问题和注意点，尤其是用户指出的问题
-4. 可选步骤: 对于有多种解决路径的问题，标注出可选步骤和适用场景
+方法论格式: 问题重述、可复用解决流程（步骤化+工具）、注意事项、可选步骤
 </methodology_requirements>
-<output_requirements>
-根据分析结果，输出以下三种情况之一：
-1. 如果现有工具/方法论可以解决，直接输出说明：
-已有工具/方法论可以解决该问题，无需创建新内容。
-可用的工具/方法论：[列出工具名称或方法论名称]
-使用方法：[简要说明如何使用]
-2. 工具创建（如果需要创建新工具）:
-{ot("TOOL_CALL")}
-want: 创建新工具来解决XXX问题
-name: generate_new_tool
-arguments:
-  tool_name: 工具名称
-  tool_code: |2
-    # -*- coding: utf-8 -*-
-    from typing import Dict, Any
-    from jarvis.jarvis_utils.output import PrettyOutput, OutputType
-    class 工具名称:
-        name = "工具名称"
-        description = "Tool description"
-        parameters = {{
-            "type": "object",
-            "properties": {{
-                # 参数定义
-            }},
-            "required": []
-        }}
-        @staticmethod
-        def check() -> bool:
-            return True
-        def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-            try:
-                # 使用PrettyOutput显示执行过程
-                PrettyOutput.print("开始执行操作...", OutputType.INFO)
-                # 实现逻辑
-                # ...
-        PrettyOutput.print("操作已完成", OutputType.SUCCESS)
-        return {{
-            "success": True,
-            "stdout": "结果输出",
-            "stderr": ""
-        }}
-    except Exception as e:
-        PrettyOutput.print(f"操作失败: {{str(e)}}", OutputType.ERROR)
-        return {{
-            "success": False,
-            "stdout": "",
-            "stderr": f"操作失败: {{str(e)}}"
-        }}
-{ct("TOOL_CALL")}
-3. 方法论创建（如果需要创建新方法论）:
-{ot("TOOL_CALL")}
-want: 添加/更新xxxx的方法论
-name: methodology
-arguments:
-  operation: add/update
-  problem_type: 方法论类型，不要过于细节，也不要过于泛化
-  content: |2
-    方法论内容
-{ct("TOOL_CALL")}
-如果以上三种情况都不适用，则直接输出原因分析，不要使用工具调用格式。
-</output_requirements>
+{output_requirements}
 </task_analysis>"""
+
+
+# 为了向后兼容，保留原来的常量（使用默认参数，假设有 save_memory 工具）
+TASK_ANALYSIS_PROMPT = get_task_analysis_prompt(has_save_memory=True)

jarvis/jarvis_agent/protocols.py

@@ -1,33 +1,29 @@
-# -*- coding: utf-8 -*-
 from typing import Any, Protocol, Tuple, runtime_checkable
 
 
 @runtime_checkable
 class OutputHandlerProtocol(Protocol):
     """
-    Defines the interface for an output handler, which is responsible for
-    processing the model's response, typically to execute a tool.
+    定义输出处理器的接口，该处理器负责处理模型的响应，通常用于执行工具。
     """
 
     def name(self) -> str:
-        """Returns the name of the handler."""
+        """返回处理器的名称。"""
         ...
 
     def can_handle(self, response: str) -> bool:
-        """Determines if this handler can process the given response."""
+        """判断此处理器能否处理给定的响应。"""
         ...
 
     def prompt(self) -> str:
-        """Returns the prompt snippet that describes the handler's functionality."""
+        """返回描述处理器功能的提示片段。"""
         ...
 
     def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
         """
-        Handles the response, executing the associated logic.
+        处理响应，执行相关逻辑。
 
-        Returns:
-            A tuple containing a boolean (whether to return) and the result.
+        返回：
+            一个元组，包含一个布尔值（是否返回）和结果。
         """
-        ...
-        
-__all__ = ["OutputHandlerProtocol"]
+        ...

jarvis/jarvis_agent/run_loop.py

@@ -11,10 +11,9 @@ import os
 from enum import Enum
 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
+from jarvis.jarvis_utils.config import get_max_input_token_count, get_conversation_turn_threshold
 
 if TYPE_CHECKING:
     # 仅用于类型标注，避免运行时循环依赖
@@ -26,12 +25,10 @@ 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()
-        )
+        # 基于剩余token数量的自动总结阈值：当剩余token低于输入窗口的20%时触发
+        max_input_tokens = get_max_input_token_count(self.agent.model_group)
+        self.summary_remaining_token_threshold = int(max_input_tokens * 0.2)
+        self.conversation_turn_threshold = get_conversation_turn_threshold()
 
     def run(self) -> Any:
         """主运行循环（委派到传入的 agent 实例的方法与属性）"""
@@ -44,15 +41,20 @@ 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:
+                # 基于剩余token数量或对话轮次的自动总结判断
+                remaining_tokens = self.agent.model.get_remaining_token_count()
+                should_summarize = (
+                    remaining_tokens <= self.summary_remaining_token_threshold or
+                    self.conversation_rounds > self.conversation_turn_threshold
+                )
+                if should_summarize:
                     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
 
@@ -75,6 +77,25 @@ class AgentRunLoop:
                 ag.session.prompt = ""
                 run_input_handlers = False
 
+                # 检查是否包含 <!!!SUMMARY!!!> 标记，触发总结并清空历史
+                if "<!!!SUMMARY!!!>" in current_response:
+                    print("ℹ️ 检测到 <!!!SUMMARY!!!> 标记，正在触发总结并清空历史...")
+                    # 移除标记，避免在后续处理中出现
+                    current_response = current_response.replace("<!!!SUMMARY!!!>", "").strip()
+                    # 触发总结并清空历史
+                    summary_text = ag._summarize_and_clear_history()
+                    if summary_text:
+                        # 将摘要作为下一轮的附加提示加入，从而维持上下文连续性
+                        ag.session.addon_prompt = join_prompts(
+                            [ag.session.addon_prompt, summary_text]
+                        )
+                    # 重置轮次计数（用于工具提醒）与对话长度计数器（用于摘要触发），开始新一轮周期
+                    self.conversation_rounds = 0
+                    ag.session.conversation_length = 0
+                    # 如果响应中还有其他内容，继续处理；否则继续下一轮
+                    if not current_response:
+                        continue
+
                 # 处理中断
                 interrupt_result = ag._handle_run_interrupt(current_response)
                 if (
@@ -88,7 +109,7 @@ class AgentRunLoop:
                     return interrupt_result
 
                 # 处理工具调用
-                # 广播工具调用前事件（不影响主流程）
+                # 非关键流程：广播工具调用前事件（用于日志、监控等）
                 try:
                     ag.event_bus.emit(
                         BEFORE_TOOL_CALL,
@@ -101,13 +122,32 @@ class AgentRunLoop:
 
                 # 如果工具要求立即返回结果（例如 SEND_MESSAGE 需要将字典返回给上层），直接返回该结果
                 if need_return:
+                    ag._no_tool_call_count = 0
                     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])
 
-                # 广播工具调用后的事件（不影响主流程）
+                # 关键流程：直接调用 after_tool_call 回调函数
+                try:
+                    # 获取所有订阅了 AFTER_TOOL_CALL 事件的回调
+                    listeners = ag.event_bus._listeners.get(AFTER_TOOL_CALL, [])
+                    for callback in listeners:
+                        try:
+                            callback(
+                                agent=ag,
+                                current_response=current_response,
+                                need_return=need_return,
+                                tool_prompt=tool_prompt,
+                            )
+                        except Exception:
+                            pass
+                except Exception:
+                    pass
+                
+                # 非关键流程：广播工具调用后的事件（用于日志、监控等）
                 try:
                     ag.event_bus.emit(
                         AFTER_TOOL_CALL,
@@ -121,10 +161,12 @@ class AgentRunLoop:
 
                 # 检查是否需要继续
                 if ag.session.prompt or ag.session.addon_prompt:
+                    ag._no_tool_call_count = 0
                     continue
 
                 # 检查自动完成
                 if ag.auto_complete and is_auto_complete(current_response):
+                    ag._no_tool_call_count = 0
                     # 先运行_complete_task，触发记忆整理/事件等副作用，再决定返回值
                     result = ag._complete_task(auto_completed=True)
                     # 若不需要summary，则将最后一条LLM输出作为返回值
@@ -132,6 +174,27 @@ class AgentRunLoop:
                         return current_response
                     return result
 
+                
+                # 检查是否有工具调用：如果tool_prompt不为空，说明有工具被调用
+                has_tool_call = bool(safe_tool_prompt and safe_tool_prompt.strip())
+                
+                # 在非交互模式下，跟踪连续没有工具调用的次数
+                if ag.non_interactive:
+                    if has_tool_call:
+                        # 有工具调用，重置计数器
+                        ag._no_tool_call_count = 0
+                    else:
+                        # 没有工具调用，增加计数器
+                        ag._no_tool_call_count += 1
+                        # 如果连续5次没有工具调用，添加工具使用提示
+                        if ag._no_tool_call_count >= 5:
+                            tool_usage_prompt = ag.get_tool_usage_prompt()
+                            ag.session.addon_prompt = join_prompts(
+                                [ag.session.addon_prompt, tool_usage_prompt]
+                            )
+                            # 重置计数器，避免重复添加
+                            ag._no_tool_call_count = 0
+
                 # 获取下一步用户输入
                 next_action = ag._get_next_user_action()
                 action = normalize_next_action(next_action)
@@ -142,5 +205,5 @@ class AgentRunLoop:
                     return ag._complete_task(auto_completed=False)
 
             except Exception as e:
-                PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
+                print(f"❌ 任务失败: {str(e)}")
                 return f"Task failed: {str(e)}"

jarvis/jarvis_agent/session_manager.py

@@ -2,7 +2,6 @@
 import os
 from typing import Any, Dict, Optional, TYPE_CHECKING
 
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 if TYPE_CHECKING:
     from jarvis.jarvis_platform.base import BasePlatform
@@ -61,9 +60,9 @@ class SessionManager:
         if self.model.restore(session_file):
             try:
                 os.remove(session_file)
-                PrettyOutput.print("会话已恢复，并已删除会话文件。", OutputType.SUCCESS)
+                print("✅ 会话已恢复，并已删除会话文件。")
             except OSError as e:
-                PrettyOutput.print(f"删除会话文件失败: {e}", OutputType.ERROR)
+                print(f"❌ 删除会话文件失败: {e}")
             return True
         return False