jarvis-ai-assistant 0.1.219__py3-none-any.whl → 0.1.221__py3-none-any.whl

jarvis/jarvis_agent/__init__.py

@@ -9,6 +9,16 @@ from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, Union
 
 # 本地库导入
 # jarvis_agent 相关
+from jarvis.jarvis_agent.prompt_builder import build_action_prompt
+from jarvis.jarvis_agent.protocols import OutputHandlerProtocol
+from jarvis.jarvis_agent.session_manager import SessionManager
+from jarvis.jarvis_agent.tool_executor import execute_tool_call
+from jarvis.jarvis_agent.prompts import (
+    DEFAULT_SUMMARY_PROMPT,
+    SUMMARY_REQUEST_PROMPT,
+    TASK_ANALYSIS_PROMPT,
+)
+
 # jarvis_platform 相关
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -36,108 +46,43 @@ from jarvis.jarvis_utils.tag import ct, ot
 origin_agent_system_prompt = f"""
 <role>
 # 🤖 角色
-你是一个专业的任务执行助手，擅长根据用户需求生成详细的任务执行计划并执行。
+你是一个专业的任务执行助手，根据用户需求制定并执行详细的计划。
 </role>
 
-<requirements>
-# 🔥 绝对行动要求
-1. 每个响应必须包含且仅包含一个工具调用
-2. 唯一例外：任务结束
-3. 空响应会触发致命错误
-</requirements>
-
-<violations>
-# 🚫 违规示例
-- 没有工具调用的分析 → 永久挂起
-- 未选择的多选项 → 永久挂起
-- 请求用户确认 → 永久挂起
-</violations>
+<rules>
+# ❗ 核心规则
+1.  **单步操作**: 每个响应必须包含且仅包含一个工具调用。
+2.  **任务终结**: 当任务完成时，明确指出任务已完成。这是唯一可以不调用工具的例外。
+3.  **无响应错误**: 空响应或仅有分析无工具调用的响应是致命错误，会导致系统挂起。
+4.  **决策即工具**: 所有的决策和分析都必须通过工具调用来体现。
+5.  **等待结果**: 在继续下一步之前，必须等待当前工具的执行结果。
+6.  **持续推进**: 除非任务完成，否则必须生成可操作的下一步。
+7.  **记录沉淀**: 如果解决方案有普适价值，应记录为方法论。
+8.  **用户语言**: 始终使用用户的语言进行交流。
+</rules>
 
 <workflow>
-# 🔄 问题解决流程
-1. 问题分析
-   - 重述问题以确认理解
-   - 分析根本原因（针对问题分析任务）
-   - 定义清晰、可实现的目标
-   → 必须调用分析工具
-
-2. 解决方案设计
-   - 生成多个可执行的解决方案
-   - 评估并选择最优方案
-   - 使用PlantUML创建详细行动计划
-   → 必须调用设计工具
-
-3. 执行
-   - 一次执行一个步骤
-   - 每个步骤只使用一个工具
-   - 等待工具结果后再继续
-   - 监控结果并根据需要调整
-   → 必须调用执行工具
-
-4. 任务完成
-   - 验证目标完成情况
-   - 如有价值则记录方法论
+# 🔄 工作流程
+1.  **分析**: 理解和分析问题，定义清晰的目标。
+2.  **设计**: 设计解决方案并制定详细的行动计划。
+3.  **执行**: 按照计划，一次一个步骤地执行。
+4.  **完成**: 验证任务是否达成目标，并进行总结。
 </workflow>
 
-<principles>
-# ⚖️ 操作原则
-- 每个步骤一个操作
-- 下一步前必须等待结果
-- 除非任务完成否则必须生成可操作步骤
-- 根据反馈调整计划
-- 记录可复用的解决方案
-- 使用完成命令结束任务
-- 操作之间不能有中间思考状态
-- 所有决策必须表现为工具调用
-</principles>
-
-<rules>
-# ❗ 重要规则
-1. 每个步骤只能使用一个操作
-2. 必须等待操作执行结果
-3. 必须验证任务完成情况
-4. 必须生成可操作步骤
-5. 如果无需操作必须使用完成命令
-6. 永远不要使对话处于等待状态
-7. 始终使用用户语言交流
-8. 必须记录有价值的方法论
-9. 违反操作协议将导致系统崩溃
-10. 空响应会触发永久挂起
-</rules>
-
 <system_info>
-# 系统信息：
-{platform.platform()}
-{platform.version()}
-
-# 当前时间
-{datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+# 系统信息
+- OS: {platform.platform()} {platform.version()}
+- Time: {datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
 </system_info>
 """
 
 
-class OutputHandlerProtocol(Protocol):
-    def name(self) -> str: ...
-
-    def can_handle(self, response: str) -> bool: ...
-
-    def prompt(self) -> str: ...
-
-    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]: ...
-
-
 class Agent:
     def clear(self):
-        """清除当前对话历史，保留系统消息。
-
-        该方法将：
-        1. 调用模型的delete_chat方法清除对话历史
-        2. 重置对话长度计数器
-        3. 清空当前提示
         """
-        self.model.reset()  # type: ignore
-        self.conversation_length = 0
-        self.prompt = ""
+        Clears the current conversation history by delegating to the session manager.
+        """
+        self.session.clear()
 
     def __del__(self):
         # 只有在记录启动时才停止记录
@@ -207,6 +152,9 @@ class Agent:
 
         self.model.set_suppress_output(False)
 
+        # Initialize the session manager
+        self.session = SessionManager(model=self.model, agent_name=self.name)
+
         from jarvis.jarvis_tools.registry import ToolRegistry
 
         self.output_handler = output_handler if output_handler else [ToolRegistry()]
@@ -227,13 +175,10 @@ class Agent:
         self.use_analysis = (
             use_analysis if use_analysis is not None else is_use_analysis()
         )
-        self.prompt = ""
-        self.conversation_length = 0  # Use length counter instead
         self.system_prompt = system_prompt
         self.input_handler = input_handler if input_handler is not None else []
         self.need_summary = need_summary
         # Load configuration from environment variables
-        self.addon_prompt = ""
 
         self.after_tool_call_cb: Optional[Callable[[Agent], None]] = None
 
@@ -244,24 +189,7 @@ class Agent:
         )
 
         self.summary_prompt = (
-            summary_prompt
-            if summary_prompt
-            else f"""<report>
-请生成任务执行的简明总结报告，包括：
-
-<content>
-1. 任务目标：任务重述
-2. 执行结果：成功/失败
-3. 关键信息：执行过程中提取的重要信息
-4. 重要发现：任何值得注意的发现
-5. 后续建议：如果有的话
-</content>
-
-<format>
-请使用简洁的要点描述，突出重要信息。
-</format>
-</report>
-"""
+            summary_prompt if summary_prompt else DEFAULT_SUMMARY_PROMPT
         )
 
         self.max_token_count = get_max_token_count()
@@ -270,46 +198,7 @@ class Agent:
 
         PrettyOutput.print(welcome_message, OutputType.SYSTEM)
 
-        action_prompt = """
-<actions>
-# 🧰 可用操作
-以下是您可以使用的操作：
-"""
-
-        # 添加工具列表概览
-        action_prompt += "\n<overview>\n## Action List\n"
-        action_prompt += (
-            "[" + ", ".join([handler.name() for handler in self.output_handler]) + "]"
-        )
-        action_prompt += "\n</overview>"
-
-        # 添加每个工具的详细说明
-        action_prompt += "\n\n<details>\n# 📝 Action Details\n"
-        for handler in self.output_handler:
-            action_prompt += f"\n<tool>\n## {handler.name()}\n"
-            # 获取工具的提示词并确保格式正确
-            handler_prompt = handler.prompt().strip()
-            # 调整缩进以保持层级结构
-            handler_prompt = "\n".join(
-                "   " + line if line.strip() else line
-                for line in handler_prompt.split("\n")
-            )
-            action_prompt += handler_prompt + "\n</tool>\n"
-
-        # 添加工具使用总结
-        action_prompt += """
-</details>
-
-<rules>
-# ❗ 重要操作使用规则
-1. 一次对话只能使用一个操作，否则会出错
-2. 严格按照每个操作的格式执行
-3. 等待操作结果后再进行下一个操作
-4. 处理完结果后再调用新的操作
-5. 如果对操作使用不清楚，请请求帮助
-</rules>
-</actions>
-"""
+        action_prompt = build_action_prompt(self.output_handler) # type: ignore
 
         self.model.set_system_prompt(
             f"""
@@ -321,12 +210,12 @@ class Agent:
         self.first = True
 
     def set_user_data(self, key: str, value: Any):
-        """设置用户数据"""
-        self.user_data[key] = value
+        """Sets user data in the session."""
+        self.session.set_user_data(key, value)
 
     def get_user_data(self, key: str) -> Optional[Any]:
-        """获取用户数据"""
-        return self.user_data.get(key, None)
+        """Gets user data from the session."""
+        return self.session.get_user_data(key)
 
     def set_use_tools(self, use_tools):
         """设置要使用的工具列表"""
@@ -339,12 +228,8 @@ class Agent:
                 break
 
     def set_addon_prompt(self, addon_prompt: str):
-        """设置附加提示。
-
-        参数:
-            addon_prompt: 附加提示内容
-        """
-        self.addon_prompt = addon_prompt
+        """Sets the addon prompt in the session."""
+        self.session.set_addon_prompt(addon_prompt)
 
     def set_after_tool_call_cb(self, cb: Callable[[Any], None]):  # type: ignore
         """设置工具调用后回调函数。
@@ -355,41 +240,12 @@ class Agent:
         self.after_tool_call_cb = cb
 
     def save_session(self) -> bool:
-        """保存当前会话状态到文件"""
-        if not self.model:
-            PrettyOutput.print("没有可用的模型实例来保存会话。", OutputType.ERROR)
-            return False
-        session_dir = os.path.join(os.getcwd(), ".jarvis")
-        os.makedirs(session_dir, exist_ok=True)
-        platform_name = self.model.platform_name()
-        model_name = self.model.name().replace("/", "_").replace("\\", "_")
-        session_file = os.path.join(
-            session_dir, f"saved_session_{self.name}_{platform_name}_{model_name}.json"
-        )
-        return self.model.save(session_file)
+        """Saves the current session state by delegating to the session manager."""
+        return self.session.save_session()
 
     def restore_session(self) -> bool:
-        """从文件恢复会话状态"""
-        if not self.model:
-            return False  # No model, cannot restore
-        platform_name = self.model.platform_name()
-        model_name = self.model.name().replace("/", "_").replace("\\", "_")
-        session_file = os.path.join(
-            os.getcwd(),
-            ".jarvis",
-            f"saved_session_{self.name}_{platform_name}_{model_name}.json",
-        )
-        if not os.path.exists(session_file):
-            return False
-
-        if self.model.restore(session_file):
-            try:
-                os.remove(session_file)
-                PrettyOutput.print("会话已恢复，并已删除会话文件。", OutputType.SUCCESS)
-            except OSError as e:
-                PrettyOutput.print(f"删除会话文件失败: {e}", OutputType.ERROR)
-            return True
-        return False
+        """Restores the session state by delegating to the session manager."""
+        return self.session.restore_session()
 
     def get_tool_registry(self) -> Optional[Any]:
         """获取工具注册表实例"""
@@ -421,21 +277,23 @@ class Agent:
             if need_return:
                 return message
 
-        if self.addon_prompt:
-            message += f"\n\n{self.addon_prompt}"
-            self.addon_prompt = ""
+        if self.session.addon_prompt:
+            message += f"\n\n{self.session.addon_prompt}"
+            self.session.addon_prompt = ""
         else:
             message += f"\n\n{self.make_default_addon_prompt(need_complete)}"
 
         # 累加对话长度
-        self.conversation_length += get_context_token_count(message)
+        self.session.conversation_length += get_context_token_count(message)
 
-        if self.conversation_length > self.max_token_count:
+        if self.session.conversation_length > self.max_token_count:
             message = self._summarize_and_clear_history() + "\n\n" + message
-            self.conversation_length += get_context_token_count(message)
+            self.session.conversation_length += get_context_token_count(message)
 
+        if not self.model:
+            raise RuntimeError("Model not initialized")
         response = self.model.chat_until_success(message)  # type: ignore
-        self.conversation_length += get_context_token_count(response)
+        self.session.conversation_length += get_context_token_count(response)
 
         return response
 
@@ -449,31 +307,12 @@ class Agent:
             仅生成摘要，不修改对话状态
         """
         print("📄 正在总结对话历史...")
-        summary_prompt = """
-<summary_request>
-<objective>
-请对当前对话历史进行简明扼要的总结，提取关键信息和重要决策点。这个总结将作为上下文继续任务，因此需要保留对后续对话至关重要的内容。
-</objective>
-
-<guidelines>
-1. 提取关键信息：任务目标、已确定的事实、重要决策、达成的共识
-2. 保留技术细节：命令、代码片段、文件路径、配置设置等技术细节
-3. 记录任务进展：已完成的步骤、当前所处阶段、待解决的问题
-4. 包含用户偏好：用户表达的明确偏好、限制条件或特殊要求
-5. 省略冗余内容：问候语、重复信息、不相关的讨论
-</guidelines>
-
-<format>
-- 使用简洁、客观的语言
-- 按时间顺序或主题组织信息
-- 使用要点列表增强可读性
-- 总结应控制在500词以内
-</format>
-</summary_request>
-"""
-
         try:
-            summary = self.model.chat_until_success(self.prompt + "\n" + summary_prompt)  # type: ignore
+            if not self.model:
+                raise RuntimeError("Model not initialized")
+            summary = self.model.chat_until_success(
+                self.session.prompt + "\n" + SUMMARY_REQUEST_PROMPT
+            )  # type: ignore
             print("✅ 总结对话历史完成")
             return summary
         except Exception as e:
@@ -533,46 +372,10 @@ class Agent:
                 os.remove(tmp_file_name)
 
     def _call_tools(self, response: str) -> Tuple[bool, Any]:
-        """调用工具执行响应
-
-        参数:
-            response: 包含工具调用信息的响应字符串
-
-        返回:
-            Tuple[bool, Any]:
-                - 第一个元素表示是否需要返回结果
-                - 第二个元素是返回结果或错误信息
-
-        注意:
-            1. 一次只能执行一个工具
-            2. 如果配置了确认选项，会在执行前请求用户确认
-            3. 使用spinner显示执行状态
         """
-        tool_list = []
-        for handler in self.output_handler:
-            if handler.can_handle(response):
-                tool_list.append(handler)
-        if len(tool_list) > 1:
-            PrettyOutput.print(
-                f"操作失败：检测到多个操作。一次只能执行一个操作。尝试执行的操作：{', '.join([handler.name() for handler in tool_list])}",
-                OutputType.WARNING,
-            )
-            return (
-                False,
-                f"操作失败：检测到多个操作。一次只能执行一个操作。尝试执行的操作：{', '.join([handler.name() for handler in tool_list])}",
-            )
-        if len(tool_list) == 0:
-            return False, ""
-
-        if not self.execute_tool_confirm or user_confirm(
-            f"需要执行{tool_list[0].name()}确认执行？", True
-        ):
-            print(f"🔧 正在执行{tool_list[0].name()}...")
-            result = tool_list[0].handle(response, self)
-            print(f"✅ {tool_list[0].name()}执行完成")
-
-            return result
-        return False, ""
+        Delegates the tool execution to the external `execute_tool_call` function.
+        """
+        return execute_tool_call(response, self)
 
     def _complete_task(self) -> str:
         """完成任务并生成总结(如果需要)
@@ -589,8 +392,10 @@ class Agent:
             self._analysis_task()
         if self.need_summary:
             print("📄 正在生成总结...")
-            self.prompt = self.summary_prompt
-            ret = self.model.chat_until_success(self.prompt)  # type: ignore
+            self.session.prompt = self.summary_prompt
+            if not self.model:
+                raise RuntimeError("Model not initialized")
+            ret = self.model.chat_until_success(self.session.prompt)  # type: ignore
             print("✅ 总结生成完成")
             return ret
 
@@ -600,154 +405,12 @@ class Agent:
         print("🔍 正在分析任务...")
         try:
             # 让模型判断是否需要生成方法论
-            analysis_prompt = f"""<task_analysis>
-<request>
-当前任务已结束，请分析该任务的解决方案：
-1. 首先检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
-2. 如果现有工具/方法论不足，评估当前任务是否可以通过编写新工具来自动化解决
-3. 如果可以通过工具解决，请设计并提供工具代码
-4. 如果无法通过编写通用工具完成，评估当前的执行流程是否可以总结为通用方法论
-5. 如果以上都不可行，给出详细理由
-请根据分析结果采取相应行动：说明现有工具/方法论、创建新工具、生成新方法论或说明原因。
-</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)}}"
-       }}
-   ```
-</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 for text transformation"
-                Tool description
-        适用场景：1. 格式化文本; 2. 处理标题; 3. 标准化输出
-        \"\"\"
-        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>
-</task_analysis>"""
-
-            self.prompt = analysis_prompt
-            response = self.model.chat_until_success(self.prompt)  # type: ignore
+            analysis_prompt = TASK_ANALYSIS_PROMPT
+
+            self.session.prompt = analysis_prompt
+            if not self.model:
+                raise RuntimeError("Model not initialized")
+            response = self.model.chat_until_success(self.session.prompt)  # type: ignore
             self._call_tools(response)
             print("✅ 分析完成")
         except Exception as e:
@@ -803,7 +466,7 @@ arguments:
             4. 自动加载相关方法论(如果是首次运行)
         """
 
-        self.prompt = f"{user_input}"
+        self.session.prompt = f"{user_input}"
         try:
             set_agent(self.name, self)
 
@@ -811,8 +474,8 @@ arguments:
                 if self.first:
                     self._first_run()
                 try:
-                    current_response = self._call_model(self.prompt, True)
-                    self.prompt = ""
+                    current_response = self._call_model(self.session.prompt, True)
+                    self.session.prompt = ""
 
                     if get_interrupt():
                         set_interrupt(False)
@@ -828,20 +491,24 @@ arguments:
                                 if user_confirm(
                                     "检测到有工具调用，是否继续处理工具调用？", True
                                 ):
-                                    self.prompt = f"{user_input}\n\n{current_response}"
+                                    self.session.prompt = (
+                                        f"{user_input}\n\n{current_response}"
+                                    )
                                     continue
-                            self.prompt += f"{user_input}"
+                            self.session.prompt += f"{user_input}"
                             continue
 
-                    need_return, self.prompt = self._call_tools(current_response)
+                    need_return, self.session.prompt = self._call_tools(
+                        current_response
+                    )
 
                     if need_return:
-                        return self.prompt
+                        return self.session.prompt
 
                     if self.after_tool_call_cb:
                         self.after_tool_call_cb(self)
 
-                    if self.prompt or self.addon_prompt:
+                    if self.session.prompt or self.session.addon_prompt:
                         continue
 
                     if self.auto_complete and ot("!!!COMPLETE!!!") in current_response:
@@ -853,7 +520,7 @@ arguments:
                     )
 
                     if user_input:
-                        self.prompt = user_input
+                        self.session.prompt = user_input
                         continue
 
                     if not user_input:
@@ -877,44 +544,35 @@ arguments:
                             "文件上传失败，将忽略文件列表", OutputType.WARNING
                         )
                         # 上传失败则回退到本地加载
-                    msg = self.prompt
+                    msg = self.session.prompt
                     for handler in self.input_handler:
                         msg, _ = handler(msg, self)
-                    self.prompt = f"{self.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}"
+                    self.session.prompt = f"{self.session.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}"
                 else:
                     if self.files:
-                        self.prompt = f"{self.prompt}\n\n上传的文件包含历史对话信息和方法论文件，可以从中获取一些经验信息。"
+                        self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息和方法论文件，可以从中获取一些经验信息。"
                     else:
-                        self.prompt = f"{self.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。"
+                        self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。"
             elif self.files:
                 if not self.model.upload_files(self.files):
                     PrettyOutput.print(
                         "文件上传失败，将忽略文件列表", OutputType.WARNING
                     )
                 else:
-                    self.prompt = f"{self.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。"
+                    self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。"
         else:
             if self.files:
                 PrettyOutput.print("不支持上传文件，将忽略文件列表", OutputType.WARNING)
             if self.use_methodology:
-                msg = self.prompt
+                msg = self.session.prompt
                 for handler in self.input_handler:
                     msg, _ = handler(msg, self)
-                self.prompt = f"{self.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}"
+                self.session.prompt = f"{self.session.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}"
 
         self.first = False
 
     def clear_history(self):
-        """清空对话历史但保留系统提示
-
-        该方法将：
-        1. 清空当前提示
-        2. 重置模型状态
-        3. 重置对话长度计数器
-
-        注意:
-            用于重置Agent状态而不影响系统消息
         """
-        self.prompt = ""
-        self.model.reset()  # type: ignore
-        self.conversation_length = 0  # 重置对话长度
+        Clears conversation history by delegating to the session manager.
+        """
+        self.session.clear_history()