jarvis-ai-assistant 0.2.8__py3-none-any.whl → 0.3.1__py3-none-any.whl

jarvis/jarvis_agent/__init__.py

@@ -13,6 +13,9 @@ 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.memory_manager import MemoryManager
+from jarvis.jarvis_agent.task_analyzer import TaskAnalyzer
+from jarvis.jarvis_agent.file_methodology_manager import FileMethodologyManager
 from jarvis.jarvis_agent.prompts import (
     DEFAULT_SUMMARY_PROMPT,
     SUMMARY_REQUEST_PROMPT,
@@ -31,6 +34,7 @@ from jarvis.jarvis_utils.config import (
     get_thinking_model_name,
     get_thinking_platform_name,
     is_execute_tool_confirm,
+    is_force_save_memory,
     is_use_analysis,
     is_use_methodology,
 )
@@ -43,7 +47,6 @@ from jarvis.jarvis_utils.globals import (
     set_interrupt,
 )
 from jarvis.jarvis_utils.input import get_multiline_input, user_confirm
-from jarvis.jarvis_utils.methodology import load_methodology, upload_methodology
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ct, ot
 
@@ -113,9 +116,9 @@ class Agent:
         multiline_inputer: Optional[Callable[[str], str]] = None,
         use_methodology: Optional[bool] = None,
         use_analysis: Optional[bool] = None,
+        force_save_memory: Optional[bool] = None,
         files: List[str] = [],
     ):
-        self.files = files
         """初始化Jarvis Agent实例
 
         参数:
@@ -133,10 +136,51 @@ class Agent:
             multiline_inputer: 多行输入处理器
             use_methodology: 是否使用方法论
             use_analysis: 是否使用任务分析
+            force_save_memory: 是否强制保存记忆
         """
+        # 基础属性初始化
+        self.files = files
         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.first = True
+        self.run_input_handlers_next_turn = False
+        self.user_data: Dict[str, Any] = {}
+        self.after_tool_call_cb: Optional[Callable[[Agent], None]] = None
+
+        # 初始化模型和会话
+        self._init_model(llm_type, model_group)
+        self._init_session()
+
+        # 初始化处理器
+        self._init_handlers(output_handler, input_handler, multiline_inputer, use_tools)
+
+        # 初始化配置
+        self._init_config(
+            use_methodology,
+            use_analysis,
+            execute_tool_confirm,
+            summary_prompt,
+            model_group,
+            force_save_memory,
+        )
+
+        # 初始化管理器
+        self.memory_manager = MemoryManager(self)
+        self.task_analyzer = TaskAnalyzer(self)
+        self.file_methodology_manager = FileMethodologyManager(self)
+
+        # 设置系统提示词
+        self._setup_system_prompt()
+
+        # 打印欢迎信息
+        welcome_message = f"{name} 初始化完成 - 使用 {self.model.name()} 模型"  # type: ignore
+        PrettyOutput.print(welcome_message, OutputType.SYSTEM)
+
+    def _init_model(self, llm_type: str, model_group: Optional[str]):
+        """初始化模型平台"""
         if llm_type == "thinking":
             platform_name = get_thinking_platform_name(model_group)
             model_name = get_thinking_model_name(model_group)
@@ -146,49 +190,60 @@ class Agent:
 
         self.model = PlatformRegistry().create_platform(platform_name)
         if self.model is None:
-            PrettyOutput.print(
-                f"平台 {platform_name} 不存在，将使用普通模型", OutputType.WARNING
-            )
+            PrettyOutput.print(f"平台 {platform_name} 不存在，将使用普通模型", OutputType.WARNING)
             self.model = PlatformRegistry().get_normal_platform()
 
         if model_name:
             self.model.set_model_name(model_name)
 
         self.model.set_model_group(model_group)
-
-        self.user_data: Dict[str, Any] = {}
-
         self.model.set_suppress_output(False)
 
-        # Initialize the session manager
-        self.session = SessionManager(model=self.model, agent_name=self.name)
+    def _init_session(self):
+        """初始化会话管理器"""
+        self.session = SessionManager(model=self.model, agent_name=self.name)  # type: ignore
 
+    def _init_handlers(
+        self,
+        output_handler: List[OutputHandlerProtocol],
+        input_handler: Optional[List[Callable[[str, Any], Tuple[str, bool]]]],
+        multiline_inputer: Optional[Callable[[str], str]],
+        use_tools: List[str],
+    ):
+        """初始化各种处理器"""
         from jarvis.jarvis_tools.registry import ToolRegistry
 
         self.output_handler = output_handler if output_handler else [ToolRegistry()]
         self.set_use_tools(use_tools)
 
+        self.input_handler = input_handler if input_handler is not None else []
+
         self.multiline_inputer = (
             multiline_inputer if multiline_inputer else 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],
+    ):
+        """初始化配置选项"""
         # 如果有上传文件，自动禁用方法论
         self.use_methodology = (
             False
-            if files
+            if self.files
             else (
                 use_methodology if use_methodology is not None else is_use_methodology()
             )
         )
+
         self.use_analysis = (
             use_analysis if use_analysis is not None else is_use_analysis()
         )
-        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.after_tool_call_cb: Optional[Callable[[Agent], None]] = None
 
         self.execute_tool_confirm = (
             execute_tool_confirm
@@ -201,22 +256,23 @@ class Agent:
         )
 
         self.max_token_count = get_max_token_count(model_group)
-        self.auto_complete = auto_complete
-        welcome_message = f"{name} 初始化完成 - 使用 {self.model.name()} 模型"
 
-        PrettyOutput.print(welcome_message, OutputType.SYSTEM)
+        self.force_save_memory = (
+            force_save_memory
+            if force_save_memory is not None
+            else is_force_save_memory()
+        )
 
+    def _setup_system_prompt(self):
+        """设置系统提示词"""
         action_prompt = self.get_tool_usage_prompt()
-
-        self.model.set_system_prompt(
+        self.model.set_system_prompt(  # type: ignore
             f"""
 {self.system_prompt}
 
 {action_prompt}
 """
         )
-        self.first = True
-        self.run_input_handlers_next_turn = False
 
     def set_user_data(self, key: str, value: Any):
         """Sets user data in the session."""
@@ -280,6 +336,7 @@ class Agent:
         参数:
             message: 输入给模型的消息
             need_complete: 是否需要完成任务标记
+            run_input_handlers: 是否运行输入处理器
 
         返回:
             str: 模型的响应
@@ -290,27 +347,63 @@ class Agent:
             3. 会自动添加附加提示
             4. 会检查并处理上下文长度限制
         """
+        # 处理输入
+        message = self._process_input(message, run_input_handlers)
+        if run_input_handlers and self._should_return_early(message):
+            return message
+
+        # 添加附加提示
+        message = self._add_addon_prompt(message, need_complete)
+
+        # 管理对话长度
+        message = self._manage_conversation_length(message)
+
+        # 调用模型
+        response = self._invoke_model(message)
+
+        return response
+
+    def _process_input(self, message: str, run_input_handlers: bool) -> str:
+        """处理输入消息"""
         if run_input_handlers:
             for handler in self.input_handler:
                 message, need_return = handler(message, self)
                 if need_return:
+                    self._last_handler_returned = True
                     return message
+        self._last_handler_returned = False
+        return message
+
+    def _should_return_early(self, message: str) -> bool:
+        """检查是否需要提前返回"""
+        return hasattr(self, "_last_handler_returned") and self._last_handler_returned
 
+    def _add_addon_prompt(self, message: str, need_complete: bool) -> str:
+        """添加附加提示到消息"""
         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)}"
+        return message
 
-        # 累加对话长度
+    def _manage_conversation_length(self, message: str) -> str:
+        """管理对话长度，必要时进行摘要"""
         self.session.conversation_length += get_context_token_count(message)
 
         if self.session.conversation_length > self.max_token_count:
-            message = self._summarize_and_clear_history() + "\n\n" + message
-            self.session.conversation_length += get_context_token_count(message)
+            summary = self._summarize_and_clear_history()
+            if summary:
+                message = summary + "\n\n" + message
+            self.session.conversation_length = get_context_token_count(message)
 
+        return message
+
+    def _invoke_model(self, message: str) -> str:
+        """实际调用模型获取响应"""
         if not self.model:
             raise RuntimeError("Model not initialized")
+
         response = self.model.chat_until_success(message)  # type: ignore
         self.session.conversation_length += get_context_token_count(response)
 
@@ -342,11 +435,12 @@ class Agent:
         """总结当前对话并清理历史记录
 
         该方法将:
-        1. 调用_generate_summary生成摘要
-        2. 清除对话历史
-        3. 保留系统消息
-        4. 添加摘要作为新上下文
-        5. 重置对话长度计数器
+        1. 提示用户保存重要记忆
+        2. 调用_generate_summary生成摘要
+        3. 清除对话历史
+        4. 保留系统消息
+        5. 添加摘要作为新上下文
+        6. 重置对话长度计数器
 
         返回:
             str: 包含对话摘要的字符串
@@ -354,25 +448,37 @@ class Agent:
         注意:
             当上下文长度超过最大值时使用
         """
-        need_summary = True
-        tmp_file_name = ""
-        try:
-            if self.model and self.model.support_upload_files():
-                need_summary = False
-            if need_summary:
-                summary = self.generate_summary()
-            else:
-                import tempfile
+        # 在清理历史之前，提示用户保存重要记忆
+        if self.force_save_memory:
+            print("📌 对话历史即将被总结和清理，请先保存重要信息...")
+            self.memory_manager.prompt_memory_save()
+
+        if self._should_use_file_upload():
+            return self._handle_history_with_file_upload()
+        else:
+            return self._handle_history_with_summary()
 
-                tmp_file = tempfile.NamedTemporaryFile(delete=False)
-                tmp_file_name = tmp_file.name
-            self.clear_history()  # type: ignore
+    def _should_use_file_upload(self) -> bool:
+        """判断是否应该使用文件上传方式处理历史"""
+        return bool(self.model and self.model.support_upload_files())
+
+    def _handle_history_with_summary(self) -> str:
+        """使用摘要方式处理历史"""
+        summary = self.generate_summary()
+        self.clear_history()
+
+        if not summary:
+            return ""
 
-            if need_summary:
-                if not summary:
-                    return ""
+        return self._format_summary_message(summary)
 
-                return f"""
+    def _handle_history_with_file_upload(self) -> str:
+        """使用文件上传方式处理历史"""
+        return self.file_methodology_manager.handle_history_with_file_upload()
+
+    def _format_summary_message(self, summary: str) -> str:
+        """格式化摘要消息"""
+        return f"""
 以下是之前对话的关键信息总结：
 
 <content>
@@ -381,14 +487,6 @@ class Agent:
 
 请基于以上信息继续完成任务。请注意，这是之前对话的摘要，上下文长度已超过限制而被重置。请直接继续任务，无需重复已完成的步骤。如有需要，可以询问用户以获取更多信息。
         """
-            else:
-                if self.model and self.model.upload_files([tmp_file_name]):
-                    return "上传的文件是历史对话信息，请基于历史对话信息继续完成任务。"
-                else:
-                    return ""
-        finally:
-            if tmp_file_name:
-                os.remove(tmp_file_name)
 
     def _call_tools(self, response: str) -> Tuple[bool, Any]:
         """
@@ -407,26 +505,18 @@ class Agent:
             2. 对于子Agent: 可能会生成总结(如果启用)
             3. 使用spinner显示生成状态
         """
-        satisfaction_feedback = ""
-
-        if not auto_completed and self.use_analysis:
-            if user_confirm("您对本次任务的完成是否满意？", True):
-                satisfaction_feedback = "\n\n用户对本次任务的完成表示满意。"
-            else:
-                feedback = self.multiline_inputer(
-                    "请提供您的反馈意见（可留空直接回车）:"
-                )
-                if feedback:
-                    satisfaction_feedback = (
-                        f"\n\n用户对本次任务的完成不满意，反馈意见如下：\n{feedback}"
-                    )
-                else:
-                    satisfaction_feedback = (
-                        "\n\n用户对本次任务的完成不满意，未提供具体反馈意见。"
-                    )
+        # 收集满意度反馈
+        satisfaction_feedback = self.task_analyzer.collect_satisfaction_feedback(
+            auto_completed
+        )
 
         if self.use_analysis:
-            self._analysis_task(satisfaction_feedback)
+            self.task_analyzer.analysis_task(satisfaction_feedback)
+        else:
+            # 如果没有开启分析，也提示用户是否有值得记忆的信息
+            if self.force_save_memory:
+                self.memory_manager.prompt_memory_save()
+
         if self.need_summary:
             print("📄 正在生成总结...")
             self.session.prompt = self.summary_prompt
@@ -438,23 +528,6 @@ class Agent:
 
         return "任务完成"
 
-    def _analysis_task(self, satisfaction_feedback: str = ""):
-        print("🔍 正在分析任务...")
-        try:
-            # 让模型判断是否需要生成方法论
-            analysis_prompt = TASK_ANALYSIS_PROMPT
-            if satisfaction_feedback:
-                analysis_prompt += satisfaction_feedback
-
-            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:
-            print("❌ 分析失败")
-
     def make_default_addon_prompt(self, need_complete: bool) -> str:
         """生成附加提示。
 
@@ -473,21 +546,10 @@ class Agent:
         )
 
         # 检查工具列表并添加记忆工具相关提示
-        memory_prompts = ""
         tool_registry = self.get_tool_registry()
-        if tool_registry:
-            tool_names = [tool.name for tool in tool_registry.tools.values()]
-            
-            # 如果有save_memory工具，添加相关提示
-            if "save_memory" in tool_names:
-                memory_prompts += "\n    - 如果有关键信息需要记忆，请调用save_memory工具进行记忆："
-                memory_prompts += "\n      * project_long_term: 保存与当前项目相关的长期信息"
-                memory_prompts += "\n      * global_long_term: 保存通用的信息、用户喜好、知识、方法等"
-                memory_prompts += "\n      * short_term: 保存当前任务相关的临时信息"
-            
-            # 如果有retrieve_memory工具，添加相关提示
-            if "retrieve_memory" in tool_names:
-                memory_prompts += "\n    - 如果需要检索相关记忆信息，请调用retrieve_memory工具"
+        memory_prompts = self.memory_manager.add_memory_prompts_to_addon(
+            "", tool_registry
+        )
 
         addon_prompt = f"""
 <system_prompt>
@@ -521,155 +583,128 @@ class Agent:
             3. 包含错误处理和恢复逻辑
             4. 自动加载相关方法论(如果是首次运行)
         """
-
         self.session.prompt = f"{user_input}"
         try:
             set_agent(self.name, self)
+            return self._main_loop()
+        except Exception as e:
+            PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
+            return f"Task failed: {str(e)}"
+
+    def _main_loop(self) -> Any:
+        """主运行循环"""
+        run_input_handlers = True
 
-            run_input_handlers = True
-            while True:
+        while True:
+            try:
+                # 更新输入处理器标志
                 if self.run_input_handlers_next_turn:
                     run_input_handlers = True
                     self.run_input_handlers_next_turn = False
 
+                # 首次运行初始化
                 if self.first:
                     self._first_run()
-                try:
-                    current_response = self._call_model(
-                        self.session.prompt, True, run_input_handlers
-                    )
-                    self.session.prompt = ""
-                    run_input_handlers = False
-
-                    if get_interrupt():
-                        set_interrupt(False)
-                        user_input = self.multiline_inputer(
-                            f"模型交互期间被中断，请输入用户干预信息："
-                        )
-                        if user_input:
-                            run_input_handlers = True
-                            # 如果有工具调用且用户确认继续，则继续执行工具调用
-                            if any(
-                                handler.can_handle(current_response)
-                                for handler in self.output_handler
-                            ):
-                                if user_confirm(
-                                    "检测到有工具调用，是否继续处理工具调用？", True
-                                ):
-                                    # 先添加用户干预信息到session
-                                    self.session.prompt = f"被用户中断，用户补充信息为：{user_input}\n\n用户同意继续工具调用。"
-                                    # 继续执行下面的工具调用逻辑，不要continue跳过
-                                else:
-                                    # 用户选择不继续处理工具调用
-                                    self.session.prompt = f"被用户中断，用户补充信息为：{user_input}\n\n检测到有工具调用，但被用户拒绝执行。请根据用户的补充信息重新考虑下一步操作。"
-                                    continue
-                            else:
-                                # 没有检测到工具调用
-                                self.session.prompt = (
-                                    f"被用户中断，用户补充信息为：{user_input}"
-                                )
-                                continue
-
-                    need_return, self.session.prompt = self._call_tools(
-                        current_response
-                    )
-
-                    if need_return:
-                        return self.session.prompt
-
-                    if self.after_tool_call_cb:
-                        self.after_tool_call_cb(self)
-
-                    if self.session.prompt or self.session.addon_prompt:
-                        continue
-
-                    if self.auto_complete and ot("!!!COMPLETE!!!") in current_response:
-                        return self._complete_task(auto_completed=True)
-
-                    # 获取用户输入
-                    user_input = self.multiline_inputer(
-                        f"{self.name}: 请输入，或输入空行来结束当前任务："
-                    )
-
-                    if user_input:
-                        self.session.prompt = user_input
-                        run_input_handlers = True
-                        continue
-
-                    if not user_input:
-                        return self._complete_task(auto_completed=False)
-
-                except Exception as e:
-                    PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
-                    return f"Task failed: {str(e)}"
 
-        except Exception as e:
-            PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
-            return f"Task failed: {str(e)}"
-
-    def _first_run(self):
-        # 获取所有记忆标签并添加到提示中
-        from jarvis.jarvis_utils.globals import get_all_memory_tags
-        
-        memory_tags = get_all_memory_tags()
-        memory_tags_prompt = ""
-        
-        # 检查是否有save_memory工具
-        tool_registry = self.get_tool_registry()
-        has_save_memory = False
-        if tool_registry:
-            tool_names = [tool.name for tool in tool_registry.tools.values()]
-            has_save_memory = "save_memory" in tool_names
-        
-        # 如果有save_memory工具，添加记录关键信息的提示
-        if has_save_memory:
-            memory_tags_prompt = "\n\n💡 提示：在分析任务之前，建议使用 save_memory 工具将关键信息记录下来，便于后续检索和复用。"
-        
-        if any(tags for tags in memory_tags.values()):
-            memory_tags_prompt += "\n\n系统中存在以下记忆标签，你可以使用 retrieve_memory 工具检索相关记忆："
-            for memory_type, tags in memory_tags.items():
-                if tags:
-                    type_name = {
-                        "short_term": "短期记忆",
-                        "project_long_term": "项目长期记忆", 
-                        "global_long_term": "全局长期记忆"
-                    }.get(memory_type, memory_type)
-                    memory_tags_prompt += f"\n- {type_name}: {', '.join(tags)}"
-        
-        # 如果有上传文件，先上传文件
-        if self.model and self.model.support_upload_files():
-            if self.use_methodology:
-                if not upload_methodology(self.model, other_files=self.files):
-                    if self.files:
-                        PrettyOutput.print(
-                            "文件上传失败，将忽略文件列表", OutputType.WARNING
-                        )
-                        # 上传失败则回退到本地加载
-                    msg = self.session.prompt
-                    for handler in self.input_handler:
-                        msg, _ = handler(msg, self)
-                    self.session.prompt = f"{self.session.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}{memory_tags_prompt}"
-                else:
-                    if self.files:
-                        self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息和方法论文件，可以从中获取一些经验信息。{memory_tags_prompt}"
+                # 调用模型获取响应
+                current_response = self._call_model(
+                    self.session.prompt, True, run_input_handlers
+                )
+                self.session.prompt = ""
+                run_input_handlers = False
+
+                # 处理中断
+                interrupt_result = self._handle_run_interrupt(current_response)
+                if interrupt_result:
+                    if isinstance(interrupt_result, tuple):
+                        run_input_handlers, should_continue = interrupt_result
+                        if should_continue:
+                            continue
                     else:
-                        self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。{memory_tags_prompt}"
-            elif self.files:
-                if not self.model.upload_files(self.files):
-                    PrettyOutput.print(
-                        "文件上传失败，将忽略文件列表", OutputType.WARNING
-                    )
-                else:
-                    self.session.prompt = f"{self.session.prompt}\n\n上传的文件包含历史对话信息，可以从中获取一些经验信息。"
+                        return interrupt_result
+
+                # 处理工具调用
+                need_return, self.session.prompt = self._call_tools(current_response)
+                if need_return:
+                    return self.session.prompt
+
+                # 执行回调
+                if self.after_tool_call_cb:
+                    self.after_tool_call_cb(self)
+
+                # 检查是否需要继续
+                if self.session.prompt or self.session.addon_prompt:
+                    continue
+
+                # 检查自动完成
+                if self.auto_complete and ot("!!!COMPLETE!!!") in current_response:
+                    return self._complete_task(auto_completed=True)
+
+                # 获取下一步用户输入
+                next_action = self._get_next_user_action()
+                if next_action == "continue":
+                    run_input_handlers = True
+                    continue
+                elif next_action == "complete":
+                    return self._complete_task(auto_completed=False)
+
+            except Exception as e:
+                PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
+                return f"Task failed: {str(e)}"
+
+    def _handle_run_interrupt(
+        self, current_response: str
+    ) -> Optional[Union[Any, Tuple[bool, bool]]]:
+        """处理运行中的中断
+
+        返回:
+            None: 无中断，继续执行
+            Any: 需要返回的结果
+            Tuple[bool, bool]: (run_input_handlers, should_continue)
+        """
+        if not get_interrupt():
+            return None
+
+        set_interrupt(False)
+        user_input = self.multiline_inputer(f"模型交互期间被中断，请输入用户干预信息：")
+
+        if not user_input:
+            # 用户输入为空，完成任务
+            return self._complete_task(auto_completed=False)
+
+        if any(handler.can_handle(current_response) for handler in self.output_handler):
+            if user_confirm("检测到有工具调用，是否继续处理工具调用？", True):
+                self.session.prompt = f"被用户中断，用户补充信息为：{user_input}\n\n用户同意继续工具调用。"
+                return None  # 继续执行工具调用
+            else:
+                self.session.prompt = f"被用户中断，用户补充信息为：{user_input}\n\n检测到有工具调用，但被用户拒绝执行。请根据用户的补充信息重新考虑下一步操作。"
+                return (True, True)  # run_input_handlers=True, should_continue=True
         else:
-            if self.files:
-                PrettyOutput.print("不支持上传文件，将忽略文件列表", OutputType.WARNING)
-            if self.use_methodology:
-                msg = self.session.prompt
-                for handler in self.input_handler:
-                    msg, _ = handler(msg, self)
-                self.session.prompt = f"{self.session.prompt}\n\n以下是历史类似问题的执行经验，可参考：\n{load_methodology(msg, self.get_tool_registry())}"
-        
+            self.session.prompt = f"被用户中断，用户补充信息为：{user_input}"
+            return (True, True)  # run_input_handlers=True, should_continue=True
+
+    def _get_next_user_action(self) -> str:
+        """获取用户下一步操作
+
+        返回:
+            str: "continue" 或 "complete"
+        """
+        user_input = self.multiline_inputer(f"{self.name}: 请输入，或输入空行来结束当前任务：")
+
+        if user_input:
+            self.session.prompt = user_input
+            return "continue"
+        else:
+            return "complete"
+
+    def _first_run(self):
+        """首次运行初始化"""
+        # 准备记忆标签提示
+        memory_tags_prompt = self.memory_manager.prepare_memory_tags_prompt()
+
+        # 处理文件上传和方法论加载
+        self.file_methodology_manager.handle_files_and_methodology()
+
         # 添加记忆标签提示
         if memory_tags_prompt:
             self.session.prompt = f"{self.session.prompt}{memory_tags_prompt}"