fix：修复兴趣集未清空，模型失败导致planer失败，绘图插件配置文件问题

src/chat/focus_chat/heartFC_chat.py

@@ -54,7 +54,7 @@ CONSECUTIVE_NO_REPLY_THRESHOLD = 3  # 连续不回复的阈值
 logger = get_logger("hfc")  # Logger Name Changed
 
 # 设定处理器超时时间（秒）
-PROCESSOR_TIMEOUT = 40
+PROCESSOR_TIMEOUT = 30
 
 
 async def _handle_cycle_delay(action_taken_this_cycle: bool, cycle_start_time: float, log_prefix: str):
@@ -329,11 +329,20 @@ class HeartFChatting:
                     formatted_time = f"{elapsed * 1000:.2f}毫秒" if elapsed < 1 else f"{elapsed:.2f}秒"
                     timer_strings.append(f"{name}: {formatted_time}")
 
+                # 新增：输出每个处理器的耗时
+                processor_time_costs = self._current_cycle.loop_processor_info.get("processor_time_costs", {})
+                processor_time_strings = []
+                for pname, ptime in processor_time_costs.items():
+                    formatted_ptime = f"{ptime * 1000:.2f}毫秒" if ptime < 1 else f"{ptime:.2f}秒"
+                    processor_time_strings.append(f"{pname}: {formatted_ptime}")
+                processor_time_log = ("\n各处理器耗时: " + "; ".join(processor_time_strings)) if processor_time_strings else ""
+
                 logger.info(
                     f"{self.log_prefix} 第{self._current_cycle.cycle_id}次思考,"
                     f"耗时: {self._current_cycle.end_time - self._current_cycle.start_time:.1f}秒, "
                     f"动作: {self._current_cycle.loop_plan_info['action_result']['action_type']}"
                     + (f"\n详情: {'; '.join(timer_strings)}" if timer_strings else "")
+                    + processor_time_log
                 )
 
                 await asyncio.sleep(global_config.focus_chat.think_interval)
@@ -369,18 +378,18 @@ class HeartFChatting:
 
     async def _process_processors(
         self, observations: List[Observation], running_memorys: List[Dict[str, Any]], cycle_timers: dict
-    ) -> List[InfoBase]:
+    ) -> tuple[List[InfoBase], Dict[str, float]]:
         # 记录并行任务开始时间
         parallel_start_time = time.time()
         logger.debug(f"{self.log_prefix} 开始信息处理器并行任务")
 
         processor_tasks = []
         task_to_name_map = {}
+        processor_time_costs = {}  # 新增: 记录每个处理器耗时
 
         for processor in self.processors:
             processor_name = processor.__class__.log_prefix
 
-            # 用lambda包裹，便于传参
             async def run_with_timeout(proc=processor):
                 return await asyncio.wait_for(
                     proc.process_info(observations=observations, running_memorys=running_memorys),
@@ -404,22 +413,24 @@ class HeartFChatting:
                 duration_since_parallel_start = task_completed_time - parallel_start_time
 
                 try:
-                    # 使用 await task 来获取结果或触发异常
                     result_list = await task
                     logger.info(f"{self.log_prefix} 处理器 {processor_name} 已完成!")
                     if result_list is not None:
                         all_plan_info.extend(result_list)
                     else:
                         logger.warning(f"{self.log_prefix} 处理器 {processor_name} 返回了 None")
+                    # 记录耗时
+                    processor_time_costs[processor_name] = duration_since_parallel_start
                 except asyncio.TimeoutError:
                     logger.info(f"{self.log_prefix} 处理器 {processor_name} 超时（>{PROCESSOR_TIMEOUT}s），已跳过")
+                    processor_time_costs[processor_name] = PROCESSOR_TIMEOUT
                 except Exception as e:
                     logger.error(
                         f"{self.log_prefix} 处理器 {processor_name} 执行失败，耗时 (自并行开始): {duration_since_parallel_start:.2f}秒. 错误: {e}",
                         exc_info=True,
                     )
                     traceback.print_exc()
-                    # 即使出错，也认为该任务结束了，已从 pending_tasks 中移除
+                    processor_time_costs[processor_name] = duration_since_parallel_start
 
             if pending_tasks:
                 current_progress_time = time.time()
@@ -435,12 +446,11 @@ class HeartFChatting:
         logger.info(f"{self.log_prefix} 所有处理器任务全部完成，总耗时: {total_duration:.2f}秒")
         # logger.debug(f"{self.log_prefix} 所有信息处理器处理后的信息: {all_plan_info}")
 
-        return all_plan_info
+        return all_plan_info, processor_time_costs
 
     async def _observe_process_plan_action_loop(self, cycle_timers: dict, thinking_id: str) -> dict:
         try:
             with Timer("观察", cycle_timers):
-                # await self.observations[0].observe()
                 await self.chatting_observation.observe()
                 await self.working_observation.observe()
                 await self.hfcloop_observation.observe()
@@ -461,10 +471,11 @@ class HeartFChatting:
                 running_memorys = await self.memory_activator.activate_memory(observations)
 
             with Timer("执行 信息处理器", cycle_timers):
-                all_plan_info = await self._process_processors(observations, running_memorys, cycle_timers)
+                all_plan_info, processor_time_costs = await self._process_processors(observations, running_memorys, cycle_timers)
 
                 loop_processor_info = {
                     "all_plan_info": all_plan_info,
+                    "processor_time_costs": processor_time_costs,
                 }
 
             with Timer("规划器", cycle_timers):
@@ -483,7 +494,6 @@ class HeartFChatting:
                     plan_result.get("action_result", {}).get("reasoning", "未提供理由"),
                 )
 
-                # 在此处添加日志记录
                 if action_type == "reply":
                     action_str = "回复"
                 elif action_type == "no_reply":