Update heartFC_chat.py

src/chat/focus_chat/heartFC_chat.py

@@ -30,13 +30,14 @@ from src.config.config import global_config
 install(extra_lines=3)
 
 
-# 定义处理器映射
+# 定义处理器映射：键是处理器名称，值是 (处理器类, 可选的配置键名)
+# 如果配置键名为 None，则该处理器默认启用且不能通过 focus_chat_processor 配置禁用
 PROCESSOR_CLASSES = {
-    "ChattingInfoProcessor": ChattingInfoProcessor,
-    "MindProcessor": MindProcessor,
-    "ToolProcessor": ToolProcessor,
-    "WorkingMemoryProcessor": WorkingMemoryProcessor,
-    "SelfProcessor": SelfProcessor,
+    "ChattingInfoProcessor": (ChattingInfoProcessor, None),
+    "MindProcessor": (MindProcessor, None),
+    "ToolProcessor": (ToolProcessor, "tool_use_processor"),
+    "WorkingMemoryProcessor": (WorkingMemoryProcessor, "working_memory_processor"),
+    "SelfProcessor": (SelfProcessor, "self_identify_processor"),
 }
 
 
@@ -101,27 +102,19 @@ class HeartFChatting:
         )
 
         # 根据配置文件和默认规则确定启用的处理器
-        PROCESSOR_NAME_TO_CONFIG_KEY_MAP = {
-            "SelfProcessor": "self_identify_processor",
-            "ToolProcessor": "tool_use_processor",
-            "WorkingMemoryProcessor": "working_memory_processor",
-        }
         self.enabled_processor_names: List[str] = []
-        config_processor_settings = global_config.focus_chat_processor  # 获取处理器配置，若不存在则为空字典
+        config_processor_settings = global_config.focus_chat_processor
 
-        for proc_name in PROCESSOR_CLASSES.keys():
-            config_key = PROCESSOR_NAME_TO_CONFIG_KEY_MAP.get(proc_name)
-            if config_key:
-                # 此处理器可通过配置控制
-                # getattr(config_processor_settings, config_key, True)
-                # 如果config_processor_settings是字典，则用 config_processor_settings.get(config_key, True)
-                if getattr(config_processor_settings, config_key, True):  # 默认启用，如果配置中未指定
+        for proc_name, (proc_class, config_key) in PROCESSOR_CLASSES.items():
+            if config_key: # 此处理器可通过配置控制
+                if getattr(config_processor_settings, config_key, True):  # 默认启用 (如果配置中未指定该键)
                     self.enabled_processor_names.append(proc_name)
-            else:
-                # 此处理器不在配置映射中，默认启用
+            else: # 此处理器不在配置映射中 (config_key is None)，默认启用
                 self.enabled_processor_names.append(proc_name)
 
         logger.info(f"{self.log_prefix} 将启用的处理器: {self.enabled_processor_names}")
+        self.processors: List[BaseProcessor] = []
+        self._register_default_processors()
 
         self.expressor = DefaultExpressor(chat_id=self.stream_id)
         self.action_manager = ActionManager()
@@ -130,9 +123,7 @@ class HeartFChatting:
         self.hfcloop_observation.set_action_manager(self.action_manager)
 
         self.all_observations = observations
-        # --- 处理器列表 ---
-        self.processors: List[BaseProcessor] = []
-        self._register_default_processors()
+
 
         # 初始化状态控制
         self._initialized = False
@@ -186,19 +177,20 @@ class HeartFChatting:
         """根据 self.enabled_processor_names 注册信息处理器"""
         self.processors = []  # 清空已有的
 
-        # self.enabled_processor_names 由 __init__ 保证是一个列表
         for name in self.enabled_processor_names:  # 'name' is "ChattingInfoProcessor", etc.
-            processor_class = PROCESSOR_CLASSES.get(name)
-            if processor_class:
+            processor_info = PROCESSOR_CLASSES.get(name) # processor_info is (ProcessorClass, config_key)
+            if processor_info:
+                processor_actual_class = processor_info[0] # 获取实际的类定义
                 # 根据处理器类名判断是否需要 subheartflow_id
                 if name in ["MindProcessor", "ToolProcessor", "WorkingMemoryProcessor", "SelfProcessor"]:
-                    self.processors.append(processor_class(subheartflow_id=self.stream_id))
+                    self.processors.append(processor_actual_class(subheartflow_id=self.stream_id))
                 elif name == "ChattingInfoProcessor":
-                    self.processors.append(processor_class())
+                    self.processors.append(processor_actual_class())
                 else:
                     # 对于PROCESSOR_CLASSES中定义但此处未明确处理构造的处理器
+                    # (例如, 新增了一个处理器到PROCESSOR_CLASSES, 它不需要id, 也不叫ChattingInfoProcessor)
                     try:
-                        self.processors.append(processor_class())  # 尝试无参构造
+                        self.processors.append(processor_actual_class())  # 尝试无参构造
                         logger.debug(f"{self.log_prefix} 注册处理器 {name} (尝试无参构造).")
                     except TypeError:
                         logger.error(
@@ -206,7 +198,7 @@ class HeartFChatting:
                         )
             else:
                 # 这理论上不应该发生，因为 enabled_processor_names 是从 PROCESSOR_CLASSES 的键生成的
-                logger.warning(f"{self.log_prefix} 在 PROCESSOR_CLASSES 中未找到名为 '{name}' 的处理器，将跳过注册。")
+                logger.warning(f"{self.log_prefix} 在 PROCESSOR_CLASSES 中未找到名为 '{name}' 的处理器定义，将跳过注册。")
 
         if self.processors:
             logger.info(