fix：实例化 normal_chat，支持不同子聊天拥有不同参数，修复各种问题

src/plugins/heartFC_chat/heartFC_chat.py

@@ -17,8 +17,8 @@ from src.plugins.utils.timer_calculater import Timer  # <--- Import Timer
 # --- Import necessary dependencies directly ---
 from .heartFC_generator import ResponseGenerator  # Assuming this is the type for gpt
 from src.do_tool.tool_use import ToolUser
-from src.plugins.chat.emoji_manager import EmojiManager  # Assuming this is the type
 from ..chat.message_sender import message_manager  # <-- Import the global manager
+from src.plugins.chat.emoji_manager import emoji_manager
 # --- End import ---
 
 
@@ -78,10 +78,8 @@ class HeartFChatting:
     def __init__(
         self,
         chat_id: str,
-        # 显式依赖注入
         gpt_instance: ResponseGenerator,  # 文本回复生成器
         tool_user_instance: ToolUser,  # 工具使用实例
-        emoji_manager_instance: EmojiManager,  # 表情管理实例
     ):
         """
         HeartFChatting 初始化函数
@@ -106,7 +104,6 @@ class HeartFChatting:
         # 依赖注入存储
         self.gpt_instance = gpt_instance  # 文本回复生成器
         self.tool_user = tool_user_instance  # 工具使用实例
-        self.emoji_manager = emoji_manager_instance  # 表情管理实例
 
         # LLM规划器配置
         self.planner_llm = LLMRequest(
@@ -659,26 +656,6 @@ class HeartFChatting:
             logger.error(traceback.format_exc())
             return None
 
-    # def _cleanup_thinking_message(self, thinking_id: str):
-    #     """Safely removes the thinking message."""
-    #     log_prefix = self._get_log_prefix()
-    #     try:
-    #         # Access MessageManager directly
-    #         container = await message_manager.get_container(self.stream_id)
-    #         # container.remove_message(thinking_id, msg_type=MessageThinking) # Need to find the message object first
-    #         found_msg = None
-    #         for msg in container.get_all_messages():
-    #             if isinstance(msg, MessageThinking) and msg.message_info.message_id == thinking_id:
-    #                 found_msg = msg
-    #                 break
-    #         if found_msg:
-    #             container.remove_message(found_msg)
-    #             logger.debug(f"{log_prefix} Cleaned up thinking message {thinking_id}.")
-    #         else:
-    #              logger.warning(f"{log_prefix} Could not find thinking message {thinking_id} to cleanup.")
-    #     except Exception as e:
-    #         logger.error(f"{log_prefix} Error cleaning up thinking message {thinking_id}: {e}")
-
     # --- 发送器 (Sender) --- #
     async def _sender(
         self,
@@ -783,12 +760,6 @@ class HeartFChatting:
         log_prefix = self._get_log_prefix()
         response_set: Optional[List[str]] = None
         try:
-            # --- Generate Response with LLM --- #
-            # Access gpt instance directly
-            # logger.debug(f"{log_prefix}[Replier-{thinking_id}] Calling LLM to generate response...")
-
-            # Ensure generate_response has access to current_mind if it's crucial context
-            # Access gpt_instance directly
             response_set = await self.gpt_instance.generate_response(
                 current_mind_info=self.sub_hf.current_mind,
                 reason=reason,
@@ -902,15 +873,12 @@ class HeartFChatting:
             return
 
         chat = anchor_message.chat_stream
-        # Access emoji_manager directly
-        # emoji_manager_instance = self.heartfc_controller.emoji_manager # Removed
+
         if send_emoji:
-            # Use self.emoji_manager directly
-            emoji_raw = await self.emoji_manager.get_emoji_for_text(send_emoji)
+            emoji_raw = await emoji_manager.get_emoji_for_text(send_emoji)
         else:
             emoji_text_source = "".join(response_set) if response_set else ""
-            # Use self.emoji_manager directly
-            emoji_raw = await self.emoji_manager.get_emoji_for_text(emoji_text_source)
+            emoji_raw = await emoji_manager.get_emoji_for_text(emoji_text_source)
 
         if emoji_raw:
             emoji_path, _description = emoji_raw

src/plugins/heartFC_chat/heartflow_processor.py

@@ -12,7 +12,6 @@ from ..chat.chat_stream import chat_manager
 from ..chat.message_buffer import message_buffer
 from ..utils.timer_calculater import Timer
 from src.plugins.person_info.relationship_manager import relationship_manager
-from .normal_chat import NormalChat
 
 # 定义日志配置
 processor_config = LogConfig(
@@ -25,7 +24,6 @@ logger = get_module_logger("heartflow_processor", config=processor_config)
 class HeartFCProcessor:
     def __init__(self):
         self.storage = MessageStorage()
-        self.normal_chat = NormalChat.get_instance()
 
     async def process_message(self, message_data: str) -> None:
         """处理接收到的原始消息数据，完成消息解析、缓冲、过滤、存储、兴趣度计算与更新等核心流程。
@@ -75,11 +73,6 @@ class HeartFCProcessor:
                 logger.error(f"无法为 stream_id {chat.stream_id} 创建或获取 SubHeartflow，中止处理")
                 return
 
-            # --- 添加兴趣追踪启动 (现在移动到这里，确保 subheartflow 存在后启动) ---
-            # 在获取到 chat 对象和确认 subheartflow 后，启动对该聊天流的兴趣监控
-            await self.normal_chat.start_monitoring_interest(chat)  # start_monitoring_interest 内部需要修改以适应
-            # --- 结束添加 ---
-
             message.update_chat_stream(chat)
 
             await heartflow.create_subheartflow(chat.stream_id)

src/plugins/heartFC_chat/heartflow_prompt_builder.py

@@ -226,11 +226,6 @@ class PromptBuilder:
                 "memory_prompt", related_memory_info=related_memory_info
             )
 
-        # print(f"相关记忆：{related_memory_info}")
-
-        # 日程构建
-        # schedule_prompt = f"""你现在正在做的事情是：{bot_schedule.get_current_num_task(num=1, time_info=False)}"""
-
         # 获取聊天上下文
         if chat_stream.group_info:
             chat_in_group = True
@@ -292,9 +287,12 @@ class PromptBuilder:
 
         logger.debug("开始构建prompt")
 
-        schedule_prompt = await global_prompt_manager.format_prompt(
-            "schedule_prompt", schedule_info=bot_schedule.get_current_num_task(num=1, time_info=False)
-        )
+        if global_config.ENABLE_SCHEDULE_GEN:
+            schedule_prompt = await global_prompt_manager.format_prompt(
+                "schedule_prompt", schedule_info=bot_schedule.get_current_num_task(num=1, time_info=False)
+            )
+        else:
+            schedule_prompt = ""
 
         prompt = await global_prompt_manager.format_prompt(
             "reasoning_prompt_main",

src/plugins/heartFC_chat/normal_chat.py

@@ -1,17 +1,15 @@
 import time
-import threading  # 导入 threading
-from random import random
-import traceback
 import asyncio
-from typing import List, Dict
+import traceback
+from random import random
+from typing import List, Optional  # 导入 Optional
+
 from ..moods.moods import MoodManager
 from ...config.config import global_config
 from ..chat.emoji_manager import emoji_manager
 from .normal_chat_generator import ResponseGenerator
 from ..chat.message import MessageSending, MessageRecv, MessageThinking, MessageSet
 from ..chat.message_sender import message_manager
-from ..storage.storage import MessageStorage
-from ..chat.utils import is_mentioned_bot_in_message
 from ..chat.utils_image import image_path_to_base64
 from ..willing.willing_manager import willing_manager
 from ..message import UserInfo, Seg
@@ -20,8 +18,6 @@ from src.plugins.chat.chat_stream import ChatStream, chat_manager
 from src.plugins.person_info.relationship_manager import relationship_manager
 from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
 from src.plugins.utils.timer_calculater import Timer
-from src.heart_flow.heartflow import heartflow
-from src.heart_flow.sub_heartflow import ChatState
 
 # 定义日志配置
 chat_config = LogConfig(
@@ -33,46 +29,34 @@ logger = get_module_logger("normal_chat", config=chat_config)
 
 
 class NormalChat:
-    _instance = None
-    _lock = threading.Lock()
-    _initialized = False
+    def __init__(self, chat_stream: ChatStream, interest_dict: dict):
+        """
+        初始化 NormalChat 实例，针对特定的 ChatStream。
 
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            with cls._lock:
-                # Double-check locking
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-        return cls._instance
+        Args:
+            chat_stream (ChatStream): 此 NormalChat 实例关联的聊天流对象。
+        """
 
-    def __init__(self):
-        # 防止重复初始化
-        if self._initialized:
-            return
-        with self.__class__._lock:  # 使用类锁确保线程安全
-            if self._initialized:
-                return
-            logger.info("正在初始化 NormalChat 单例...")  # 添加日志
-            self.storage = MessageStorage()
-            self.gpt = ResponseGenerator()
-            self.mood_manager = MoodManager.get_instance()
-            # 用于存储每个 chat stream 的兴趣监控任务
-            self._interest_monitoring_tasks: Dict[str, asyncio.Task] = {}
-            self._initialized = True
-            logger.info("NormalChat 单例初始化完成。")  # 添加日志
+        self.chat_stream = chat_stream
+        self.stream_id = chat_stream.stream_id
+        self.stream_name = chat_manager.get_stream_name(self.stream_id) or self.stream_id
 
-    @classmethod
-    def get_instance(cls):
-        """获取 NormalChat 的单例实例。"""
-        if cls._instance is None:
-            # 如果实例还未创建（理论上应该在 main 中初始化，但作为备用）
-            logger.warning("NormalChat 实例在首次 get_instance 时创建。")
-            cls()  # 调用构造函数来创建实例
-        return cls._instance
+        self.interest_dict = interest_dict
 
-    @staticmethod
-    async def _create_thinking_message(message, chat, userinfo, messageinfo):
+        logger.info(f"[{self.stream_name}] 正在初始化 NormalChat 实例...")
+
+        self.gpt = ResponseGenerator()
+        self.mood_manager = MoodManager.get_instance()  # MoodManager 保持单例
+        # 存储此实例的兴趣监控任务
+        self._interest_monitoring_task: Optional[asyncio.Task] = None
+        logger.info(f"[{self.stream_name}] NormalChat 实例初始化完成。")
+
+    # 改为实例方法
+    async def _create_thinking_message(self, message: MessageRecv) -> str:
         """创建思考消息"""
+        userinfo = message.message_info.user_info
+        messageinfo = message.message_info
+
         bot_user_info = UserInfo(
             user_id=global_config.BOT_QQ,
             user_nickname=global_config.BOT_NICKNAME,
@@ -83,7 +67,7 @@ class NormalChat:
         thinking_id = "mt" + str(thinking_time_point)
         thinking_message = MessageThinking(
             message_id=thinking_id,
-            chat_stream=chat,
+            chat_stream=self.chat_stream,  # 使用 self.chat_stream
             bot_user_info=bot_user_info,
             reply=message,
             thinking_start_time=thinking_time_point,
@@ -93,10 +77,12 @@ class NormalChat:
 
         return thinking_id
 
-    @staticmethod
-    async def _send_response_messages(message, chat, response_set: List[str], thinking_id) -> MessageSending:
+    # 改为实例方法
+    async def _add_messages_to_manager(
+        self, message: MessageRecv, response_set: List[str], thinking_id
+    ) -> Optional[MessageSending]:
         """发送回复消息"""
-        container = await message_manager.get_container(chat.stream_id)
+        container = await message_manager.get_container(self.stream_id)  # 使用 self.stream_id
         thinking_message = None
 
         for msg in container.messages[:]:
@@ -106,11 +92,11 @@ class NormalChat:
                 break
 
         if not thinking_message:
-            logger.warning(f"[{chat.stream_id}] 未找到对应的思考消息 {thinking_id}，可能已超时被移除")
+            logger.warning(f"[{self.stream_name}] 未找到对应的思考消息 {thinking_id}，可能已超时被移除")
             return None
 
         thinking_start_time = thinking_message.thinking_start_time
-        message_set = MessageSet(chat, thinking_id)
+        message_set = MessageSet(self.chat_stream, thinking_id)  # 使用 self.chat_stream
 
         mark_head = False
         first_bot_msg = None
@@ -118,7 +104,7 @@ class NormalChat:
             message_segment = Seg(type="text", data=msg)
             bot_message = MessageSending(
                 message_id=thinking_id,
-                chat_stream=chat,
+                chat_stream=self.chat_stream,  # 使用 self.chat_stream
                 bot_user_info=UserInfo(
                     user_id=global_config.BOT_QQ,
                     user_nickname=global_config.BOT_NICKNAME,
@@ -141,8 +127,8 @@ class NormalChat:
 
         return first_bot_msg
 
-    @staticmethod
-    async def _handle_emoji(message, chat, response):
+    # 改为实例方法
+    async def _handle_emoji(self, message: MessageRecv, response: str):
         """处理表情包"""
         if random() < global_config.emoji_chance:
             emoji_raw = await emoji_manager.get_emoji_for_text(response)
@@ -155,7 +141,7 @@ class NormalChat:
                 message_segment = Seg(type="emoji", data=emoji_cq)
                 bot_message = MessageSending(
                     message_id="mt" + str(thinking_time_point),
-                    chat_stream=chat,
+                    chat_stream=self.chat_stream,  # 使用 self.chat_stream
                     bot_user_info=UserInfo(
                         user_id=global_config.BOT_QQ,
                         user_nickname=global_config.BOT_NICKNAME,
@@ -170,193 +156,151 @@ class NormalChat:
                 )
                 await message_manager.add_message(bot_message)
 
+    # 改为实例方法 (虽然它只用 message.chat_stream, 但逻辑上属于实例)
     async def _update_relationship(self, message: MessageRecv, response_set):
         """更新关系情绪"""
         ori_response = ",".join(response_set)
         stance, emotion = await self.gpt._get_emotion_tags(ori_response, message.processed_plain_text)
         await relationship_manager.calculate_update_relationship_value(
-            chat_stream=message.chat_stream, label=emotion, stance=stance
+            chat_stream=self.chat_stream,
+            label=emotion,
+            stance=stance,  # 使用 self.chat_stream
         )
         self.mood_manager.update_mood_from_emotion(emotion, global_config.mood_intensity_factor)
 
-    async def _find_interested_message(self, chat: ChatStream) -> None:
-        # 此函数设计为后台任务，轮询指定 chat 的兴趣消息。
-        # 它通常由外部代码在 chat 流活跃时启动。
-        stream_id = chat.stream_id  # 获取 stream_id
-
-        # logger.info(f"[{stream_id}] 兴趣消息监控任务启动。") # 减少日志
+    async def _find_interested_message(self) -> None:
+        """
+        后台任务方法，轮询当前实例关联chat的兴趣消息
+        通常由start_monitoring_interest()启动
+        """
         while True:
             await asyncio.sleep(1)  # 每秒检查一次
 
-            subheartflow = heartflow.get_subheartflow(stream_id)
-
-            if not subheartflow or subheartflow.should_stop:
-                # logger.info(f"[{stream_id}] SubHeartflow 不存在或已停止，兴趣消息监控任务退出。") # 减少日志
+            # 检查任务是否已被取消
+            if self._interest_monitoring_task is None or self._interest_monitoring_task.cancelled():
+                logger.info(f"[{self.stream_name}] 兴趣监控任务被取消或置空，退出")
                 break
 
-            interest_dict = subheartflow.get_interest_dict()
-            items_to_process = list(interest_dict.items())
-
+            # 获取待处理消息列表
+            items_to_process = list(self.interest_dict.items())
             if not items_to_process:
                 continue
 
+            # 处理每条兴趣消息
             for msg_id, (message, interest_value, is_mentioned) in items_to_process:
-                # --- 在处理前检查 SubHeartflow 的状态 --- #
-                current_chat_state = subheartflow.chat_state.chat_status
-                stream_name = chat_manager.get_stream_name(stream_id) or stream_id
-
-                if current_chat_state != ChatState.CHAT:
-                    # 如果不是闲聊状态 (可能是 ABSENT 或 FOCUSED)，则跳过推理聊天
-                    # logger.debug(f"[{stream_name}] 跳过处理兴趣消息 {msg_id}，因为当前状态为 {current_chat_state.value}")
-                    # 移除消息并继续下一个
-                    removed_item = interest_dict.pop(msg_id, None)
-                    if removed_item:
-                        # logger.debug(f"[{stream_name}] 已从兴趣字典中移除消息 {msg_id} (因状态跳过)") # 减少日志
-                        pass
-                    continue  # 处理下一条消息
-                # --- 结束状态检查 --- #
-
-                # --- 检查 HeartFChatting 是否活跃 (改为检查 SubHeartflow 状态) --- #
-                is_focused = subheartflow.chat_state.chat_status == ChatState.FOCUSED
-
-                if is_focused:  # New check: If the subflow is focused, NormalChat shouldn't process
-                    removed_item = interest_dict.pop(msg_id, None)
-                    if removed_item:
-                        # logger.debug(f"[{stream_name}] SubHeartflow 处于 FOCUSED 状态，已跳过并移除 NormalChat 兴趣消息 {msg_id}") # Reduce noise
-                        pass
-                    continue
-                # --- 结束检查 --- #
-
-                # 只有当状态为 CHAT 且 HeartFChatting 不活跃 (即 Subflow 不是 FOCUSED) 时才执行以下处理逻辑
                 try:
-                    await self.normal_normal_chat(
-                        message=message,
-                        chat=chat,
-                        is_mentioned=is_mentioned,
-                        interested_rate=interest_value,
+                    # 处理消息
+                    await self.normal_response(
+                        message=message, is_mentioned=is_mentioned, interested_rate=interest_value
                     )
                 except Exception as e:
-                    logger.error(f"[{stream_name}] 处理兴趣消息 {msg_id} 时出错: {e}\n{traceback.format_exc()}")
+                    logger.error(f"[{self.stream_name}] 处理兴趣消息{msg_id}时出错: {e}\n{traceback.format_exc()}")
                 finally:
-                    removed_item = interest_dict.pop(msg_id, None)
-                    if removed_item:
-                        # logger.debug(f"[{stream_name}] 已从兴趣字典中移除消息 {msg_id}") # 减少日志
-                        pass
+                    self.interest_dict.pop(msg_id, None)
+
+    # 改为实例方法, 移除 chat 参数
+    async def normal_response(self, message: MessageRecv, is_mentioned: bool, interested_rate: float) -> None:
+        # 检查收到的消息是否属于当前实例处理的 chat stream
+        if message.chat_stream.stream_id != self.stream_id:
+            logger.error(
+                f"[{self.stream_name}] normal_response 收到不匹配的消息 (来自 {message.chat_stream.stream_id})，预期 {self.stream_id}。已忽略。"
+            )
+            return
 
-    async def normal_normal_chat(
-        self, message: MessageRecv, chat: ChatStream, is_mentioned: bool, interested_rate: float
-    ) -> None:
         timing_results = {}
         userinfo = message.message_info.user_info
         messageinfo = message.message_info
-        stream_id = chat.stream_id
-        stream_name = chat_manager.get_stream_name(stream_id) or stream_id
 
-        # --- 在开始时检查 SubHeartflow 状态 --- #
-        sub_hf = heartflow.get_subheartflow(stream_id)
-        if not sub_hf:
-            logger.warning(f"[{stream_name}] 无法获取 SubHeartflow，无法执行 normal_normal_chat。")
-            return
+        reply_probability = 1.0 if is_mentioned else 0.0  # 如果被提及，基础概率为1，否则需要意愿判断
 
-        current_chat_state = sub_hf.chat_state.chat_status
-        if current_chat_state != ChatState.CHAT:
-            logger.debug(
-                f"[{stream_name}] 跳过 normal_normal_chat，因为 SubHeartflow 状态为 {current_chat_state.value} (需要 CHAT)。"
-            )
-            # 可以在这里添加 not_reply_handle 逻辑吗？ 如果不回复，也需要清理意愿。
-            # 注意：willing_manager.setup 尚未调用
-            willing_manager.setup(message, chat, is_mentioned, interested_rate)  # 先 setup
-            await willing_manager.not_reply_handle(message.message_info.message_id)
-            willing_manager.delete(message.message_info.message_id)
-            return
-        # --- 结束状态检查 --- #
-
-        # --- 接下来的逻辑只在 ChatState.CHAT 状态下执行 --- #
-
-        is_mentioned, reply_probability = is_mentioned_bot_in_message(message)
         # 意愿管理器：设置当前message信息
-        willing_manager.setup(message, chat, is_mentioned, interested_rate)
+
+        willing_manager.setup(message, self.chat_stream, is_mentioned, interested_rate)
 
         # 获取回复概率
         is_willing = False
-        if reply_probability != 1:
+        # 仅在未被提及或基础概率不为1时查询意愿概率
+        if reply_probability < 1:  # 简化逻辑，如果未提及 (reply_probability 为 0)，则获取意愿概率
             is_willing = True
             reply_probability = await willing_manager.get_reply_probability(message.message_info.message_id)
 
             if message.message_info.additional_config:
                 if "maimcore_reply_probability_gain" in message.message_info.additional_config.keys():
                     reply_probability += message.message_info.additional_config["maimcore_reply_probability_gain"]
+                    reply_probability = min(max(reply_probability, 0), 1)  # 确保概率在 0-1 之间
 
         # 打印消息信息
-        mes_name = chat.group_info.group_name if chat.group_info else "私聊"
+        mes_name = self.chat_stream.group_info.group_name if self.chat_stream.group_info else "私聊"
         current_time = time.strftime("%H:%M:%S", time.localtime(message.message_info.time))
-        willing_log = f"[回复意愿:{await willing_manager.get_willing(chat.stream_id):.2f}]" if is_willing else ""
+        # 使用 self.stream_id
+        willing_log = f"[回复意愿:{await willing_manager.get_willing(self.stream_id):.2f}]" if is_willing else ""
         logger.info(
             f"[{current_time}][{mes_name}]"
-            f"{chat.user_info.user_nickname}:"
+            f"{self.chat_stream.user_info.user_nickname}:"  # 使用 self.chat_stream
             f"{message.processed_plain_text}{willing_log}[概率:{reply_probability * 100:.1f}%]"
         )
         do_reply = False
+        response_set = None  # 初始化 response_set
         if random() < reply_probability:
             do_reply = True
 
             # 回复前处理
             await willing_manager.before_generate_reply_handle(message.message_info.message_id)
 
-            # 创建思考消息
             with Timer("创建思考消息", timing_results):
-                thinking_id = await self._create_thinking_message(message, chat, userinfo, messageinfo)
+                thinking_id = await self._create_thinking_message(message)
 
-            logger.debug(f"创建捕捉器，thinking_id:{thinking_id}")
+            logger.debug(f"[{self.stream_name}] 创建捕捉器，thinking_id:{thinking_id}")
 
             info_catcher = info_catcher_manager.get_info_catcher(thinking_id)
             info_catcher.catch_decide_to_response(message)
 
-            # 生成回复
-            sub_hf = heartflow.get_subheartflow(stream_id)
-
             try:
                 with Timer("生成回复", timing_results):
                     response_set = await self.gpt.generate_response(
-                        sub_hf=sub_hf,
                         message=message,
                         thinking_id=thinking_id,
                     )
 
                 info_catcher.catch_after_generate_response(timing_results["生成回复"])
             except Exception as e:
-                logger.error(f"回复生成出现错误：{str(e)} {traceback.format_exc()}")
-                response_set = None
+                logger.error(f"[{self.stream_name}] 回复生成出现错误：{str(e)} {traceback.format_exc()}")
+                response_set = None  # 确保出错时 response_set 为 None
 
             if not response_set:
-                logger.info(f"[{chat.stream_id}] 模型未生成回复内容")
+                logger.info(f"[{self.stream_name}] 模型未生成回复内容")
                 # 如果模型未生成回复，移除思考消息
-                container = await message_manager.get_container(chat.stream_id)
-                # thinking_message = None
-                for msg in container.messages[:]:  # Iterate over a copy
+                container = await message_manager.get_container(self.stream_id)  # 使用 self.stream_id
+                for msg in container.messages[:]:
                     if isinstance(msg, MessageThinking) and msg.message_info.message_id == thinking_id:
-                        # thinking_message = msg
                         container.messages.remove(msg)
-                        # container.remove_message(msg) # 直接移除
-                        logger.debug(f"[{chat.stream_id}] 已移除未产生回复的思考消息 {thinking_id}")
+                        logger.debug(f"[{self.stream_name}] 已移除未产生回复的思考消息 {thinking_id}")
                         break
-                return  # 不发送回复
+                # 需要在此处也调用 not_reply_handle 和 delete 吗？
+                # 如果是因为模型没回复，也算是一种 "未回复"
+                await willing_manager.not_reply_handle(message.message_info.message_id)
+                willing_manager.delete(message.message_info.message_id)
+                return  # 不执行后续步骤
 
-            logger.info(f"[{chat.stream_id}] 回复内容: {response_set}")
+            logger.info(f"[{self.stream_name}] 回复内容: {response_set}")
 
-            # 发送回复
+            # 发送回复 (不再需要传入 chat)
             with Timer("消息发送", timing_results):
-                first_bot_msg = await self._send_response_messages(message, chat, response_set, thinking_id)
+                first_bot_msg = await self._add_messages_to_manager(message, response_set, thinking_id)
 
-            info_catcher.catch_after_response(timing_results["消息发送"], response_set, first_bot_msg)
+            # 检查 first_bot_msg 是否为 None (例如思考消息已被移除的情况)
+            if first_bot_msg:
+                info_catcher.catch_after_response(timing_results["消息发送"], response_set, first_bot_msg)
+            else:
+                logger.warning(f"[{self.stream_name}] 思考消息 {thinking_id} 在发送前丢失，无法记录 info_catcher")
 
             info_catcher.done_catch()
 
-            # 处理表情包
+            # 处理表情包 (不再需要传入 chat)
             with Timer("处理表情包", timing_results):
-                await self._handle_emoji(message, chat, response_set[0])
+                await self._handle_emoji(message, response_set[0])
 
-            # 更新关系情绪
+            # 更新关系情绪 (不再需要传入 chat)
             with Timer("关系更新", timing_results):
                 await self._update_relationship(message, response_set)
 
@@ -364,88 +308,104 @@ class NormalChat:
             await willing_manager.after_generate_reply_handle(message.message_info.message_id)
 
         # 输出性能计时结果
-        if do_reply:
+        if do_reply and response_set:  # 确保 response_set 不是 None
             timing_str = " | ".join([f"{step}: {duration:.2f}秒" for step, duration in timing_results.items()])
             trigger_msg = message.processed_plain_text
-            response_msg = " ".join(response_set) if response_set else "无回复"
-            logger.info(f"触发消息: {trigger_msg[:20]}... | 推理消息: {response_msg[:20]}... | 性能计时: {timing_str}")
-        else:
+            response_msg = " ".join(response_set)
+            logger.info(
+                f"[{self.stream_name}] 触发消息: {trigger_msg[:20]}... | 推理消息: {response_msg[:20]}... | 性能计时: {timing_str}"
+            )
+        elif not do_reply:
             # 不回复处理
             await willing_manager.not_reply_handle(message.message_info.message_id)
+        # else: # do_reply is True but response_set is None (handled above)
+        # logger.info(f"[{self.stream_name}] 决定回复但模型未生成内容。触发: {message.processed_plain_text[:20]}...")
 
-        # 意愿管理器：注销当前message信息
+        # 意愿管理器：注销当前message信息 (无论是否回复，只要处理过就删除)
         willing_manager.delete(message.message_info.message_id)
 
+    # 保持 staticmethod, 因为不依赖实例状态, 但需要 chat 对象来获取日志上下文
     @staticmethod
-    def _check_ban_words(text: str, chat, userinfo) -> bool:
+    def _check_ban_words(text: str, chat: ChatStream, userinfo: UserInfo) -> bool:
         """检查消息中是否包含过滤词"""
+        stream_name = chat_manager.get_stream_name(chat.stream_id) or chat.stream_id
         for word in global_config.ban_words:
             if word in text:
                 logger.info(
-                    f"[{chat.group_info.group_name if chat.group_info else '私聊'}]{userinfo.user_nickname}:{text}"
+                    f"[{stream_name}][{chat.group_info.group_name if chat.group_info else '私聊'}]"
+                    f"{userinfo.user_nickname}:{text}"
                 )
-                logger.info(f"[过滤词识别]消息中含有{word}，filtered")
+                logger.info(f"[{stream_name}][过滤词识别] 消息中含有 '{word}'，filtered")
                 return True
         return False
 
+    # 保持 staticmethod, 因为不依赖实例状态, 但需要 chat 对象来获取日志上下文
     @staticmethod
-    def _check_ban_regex(text: str, chat, userinfo) -> bool:
+    def _check_ban_regex(text: str, chat: ChatStream, userinfo: UserInfo) -> bool:
         """检查消息是否匹配过滤正则表达式"""
+        stream_name = chat_manager.get_stream_name(chat.stream_id) or chat.stream_id
         for pattern in global_config.ban_msgs_regex:
             if pattern.search(text):
                 logger.info(
-                    f"[{chat.group_info.group_name if chat.group_info else '私聊'}]{userinfo.user_nickname}:{text}"
+                    f"[{stream_name}][{chat.group_info.group_name if chat.group_info else '私聊'}]"
+                    f"{userinfo.user_nickname}:{text}"
                 )
-                logger.info(f"[正则表达式过滤]消息匹配到{pattern}，filtered")
+                logger.info(f"[{stream_name}][正则表达式过滤] 消息匹配到 '{pattern.pattern}'，filtered")
                 return True
         return False
 
-    async def start_monitoring_interest(self, chat: ChatStream):
-        """为指定的 ChatStream 启动兴趣消息监控任务（如果尚未运行）。"""
-        stream_id = chat.stream_id
-        if stream_id not in self._interest_monitoring_tasks or self._interest_monitoring_tasks[stream_id].done():
-            logger.info(f"为聊天流 {stream_id} 启动兴趣消息监控任务...")
-            # 创建新任务
-            task = asyncio.create_task(self._find_interested_message(chat))
-            # 添加完成回调
-            task.add_done_callback(lambda t: self._handle_task_completion(stream_id, t))
-            self._interest_monitoring_tasks[stream_id] = task
-        # else:
-        # logger.debug(f"聊天流 {stream_id} 的兴趣消息监控任务已在运行。")
+    # 改为实例方法, 移除 chat 参数
+    async def start_monitoring_interest(self):
+        """为此 NormalChat 实例关联的 ChatStream 启动兴趣消息监控任务（如果尚未运行）。"""
+        if self._interest_monitoring_task is None or self._interest_monitoring_task.done():
+            logger.info(f"[{self.stream_name}] 启动兴趣消息监控任务...")
+            task = asyncio.create_task(self._find_interested_message())
+            task.add_done_callback(lambda t: self._handle_task_completion(t))  # 回调现在是实例方法
+            self._interest_monitoring_task = task
 
-    def _handle_task_completion(self, stream_id: str, task: asyncio.Task):
+    # 改为实例方法, 移除 stream_id 参数
+    def _handle_task_completion(self, task: asyncio.Task):
         """兴趣监控任务完成时的回调函数。"""
+        # 检查完成的任务是否是当前实例的任务
+        if task is not self._interest_monitoring_task:
+            logger.warning(f"[{self.stream_name}] 收到一个未知或过时任务的完成回调。")
+            return
+
         try:
             # 检查任务是否因异常而结束
             exception = task.exception()
             if exception:
-                logger.error(f"聊天流 {stream_id} 的兴趣监控任务因异常结束: {exception}")
+                logger.error(f"[{self.stream_name}] 兴趣监控任务因异常结束: {exception}")
                 logger.error(traceback.format_exc())  # 记录完整的 traceback
-            else:
-                logger.info(f"聊天流 {stream_id} 的兴趣监控任务正常结束。")
+            # else: # 减少日志
+            # logger.info(f"[{self.stream_name}] 兴趣监控任务正常结束。")
         except asyncio.CancelledError:
-            logger.info(f"聊天流 {stream_id} 的兴趣监控任务被取消。")
+            logger.info(f"[{self.stream_name}] 兴趣监控任务被取消。")
         except Exception as e:
-            logger.error(f"处理聊天流 {stream_id} 任务完成回调时出错: {e}")
+            logger.error(f"[{self.stream_name}] 处理任务完成回调时出错: {e}")
         finally:
-            # 从字典中移除已完成或取消的任务
-            if stream_id in self._interest_monitoring_tasks:
-                del self._interest_monitoring_tasks[stream_id]
-                logger.debug(f"已从监控任务字典中移除 {stream_id}")
+            # 标记任务已完成/移除
+            if self._interest_monitoring_task is task:  # 再次确认是当前任务
+                self._interest_monitoring_task = None
+                logger.debug(f"[{self.stream_name}] 兴趣监控任务已被标记为完成/移除。")
 
-    async def stop_monitoring_interest(self, stream_id: str):
-        """停止指定聊天流的兴趣监控任务。"""
-        if stream_id in self._interest_monitoring_tasks:
-            task = self._interest_monitoring_tasks[stream_id]
-            if task and not task.done():
-                task.cancel()  # 尝试取消任务
-                logger.info(f"尝试取消聊天流 {stream_id} 的兴趣监控任务。")
-                try:
-                    await task  # 等待任务响应取消
-                except asyncio.CancelledError:
-                    logger.info(f"聊天流 {stream_id} 的兴趣监控任务已成功取消。")
-                except Exception as e:
-                    logger.error(f"等待聊天流 {stream_id} 监控任务取消时出现异常: {e}")
-            # 在回调函数 _handle_task_completion 中移除任务
+    # 改为实例方法, 移除 stream_id 参数
+    async def stop_monitoring_interest(self):
+        """停止当前实例的兴趣监控任务。"""
+        if self._interest_monitoring_task and not self._interest_monitoring_task.done():
+            task = self._interest_monitoring_task
+            logger.info(f"[{self.stream_name}] 尝试取消兴趣监控任务。")
+            task.cancel()
+            try:
+                await task  # 等待任务响应取消
+            except asyncio.CancelledError:
+                logger.info(f"[{self.stream_name}] 兴趣监控任务已成功取消。")
+            except Exception as e:
+                # 回调函数 _handle_task_completion 会处理异常日志
+                logger.warning(f"[{self.stream_name}] 等待监控任务取消时捕获到异常 (可能已在回调中记录): {e}")
+            finally:
+                # 确保任务状态更新，即使等待出错 (回调函数也会尝试更新)
+                if self._interest_monitoring_task is task:
+                    self._interest_monitoring_task = None
         # else:
-        # logger.debug(f"聊天流 {stream_id} 没有正在运行的兴趣监控任务可停止。")
+        # logger.debug(f"[{self.stream_name}] 没有正在运行的兴趣监控任务可停止。")

src/plugins/heartFC_chat/normal_chat_generator.py

@@ -8,7 +8,6 @@ from ..chat.utils import process_llm_response
 from ..utils.timer_calculater import Timer
 from src.common.logger import get_module_logger, LogConfig, LLM_STYLE_CONFIG
 from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
-from src.heart_flow.sub_heartflow import SubHeartflow
 
 # 定义日志配置
 llm_config = LogConfig(
@@ -41,9 +40,7 @@ class ResponseGenerator:
         self.current_model_type = "r1"  # 默认使用 R1
         self.current_model_name = "unknown model"
 
-    async def generate_response(
-        self, sub_hf: SubHeartflow, message: MessageThinking, thinking_id: str
-    ) -> Optional[Union[str, List[str]]]:
+    async def generate_response(self, message: MessageThinking, thinking_id: str) -> Optional[Union[str, List[str]]]:
         """根据当前模型类型选择对应的生成函数"""
         # 从global_config中获取模型概率值并选择模型
         if random.random() < global_config.model_reasoning_probability:
@@ -57,9 +54,7 @@ class ResponseGenerator:
             f"{self.current_model_type}思考:{message.processed_plain_text[:30] + '...' if len(message.processed_plain_text) > 30 else message.processed_plain_text}"
         )  # noqa: E501
 
-        model_response = await self._generate_response_with_model(sub_hf, message, current_model, thinking_id)
-
-        # print(f"raw_content: {model_response}")
+        model_response = await self._generate_response_with_model(message, current_model, thinking_id)
 
         if model_response:
             logger.info(f"{global_config.BOT_NICKNAME}的回复是：{model_response}")
@@ -70,9 +65,7 @@ class ResponseGenerator:
             logger.info(f"{self.current_model_type}思考，失败")
             return None
 
-    async def _generate_response_with_model(
-        self, sub_hf: SubHeartflow, message: MessageThinking, model: LLMRequest, thinking_id: str
-    ):
+    async def _generate_response_with_model(self, message: MessageThinking, model: LLMRequest, thinking_id: str):
         info_catcher = info_catcher_manager.get_info_catcher(thinking_id)
 
         if message.chat_stream.user_info.user_cardname and message.chat_stream.user_info.user_nickname:

src/plugins/schedule/schedule_generator.py

@@ -73,29 +73,32 @@ class ScheduleGenerator:
     async def mai_schedule_start(self):
         """启动日程系统，每5分钟执行一次move_doing，并在日期变化时重新检查日程"""
         try:
-            logger.info(f"日程系统启动/刷新时间: {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}")
-            # 初始化日程
-            await self.check_and_create_today_schedule()
-            # self.print_schedule()
+            if global_config.ENABLE_SCHEDULE_GEN:
+                logger.info(f"日程系统启动/刷新时间: {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+                # 初始化日程
+                await self.check_and_create_today_schedule()
+                # self.print_schedule()
 
-            while True:
-                # print(self.get_current_num_task(1, True))
+                while True:
+                    # print(self.get_current_num_task(1, True))
 
-                current_time = datetime.datetime.now(TIME_ZONE)
+                    current_time = datetime.datetime.now(TIME_ZONE)
 
-                # 检查是否需要重新生成日程（日期变化）
-                if current_time.date() != self.start_time.date():
-                    logger.info("检测到日期变化，重新生成日程")
-                    self.start_time = current_time
-                    await self.check_and_create_today_schedule()
-                    # self.print_schedule()
+                    # 检查是否需要重新生成日程（日期变化）
+                    if current_time.date() != self.start_time.date():
+                        logger.info("检测到日期变化，重新生成日程")
+                        self.start_time = current_time
+                        await self.check_and_create_today_schedule()
+                        # self.print_schedule()
 
-                # 执行当前活动
-                # mind_thinking = heartflow.current_state.current_mind
+                    # 执行当前活动
+                    # mind_thinking = heartflow.current_state.current_mind
 
-                await self.move_doing()
+                    await self.move_doing()
 
-                await asyncio.sleep(self.schedule_doing_update_interval)
+                    await asyncio.sleep(self.schedule_doing_update_interval)
+            else:
+                logger.info("日程系统未启用")
 
         except Exception as e:
             logger.error(f"日程系统运行时出错: {str(e)}")