fix：调整目录结构，优化hfc prompt，移除日程，移除动态和llm判断willing模式，

src/chat/normal_chat/normal_chat.py

@@ -0,0 +1,525 @@
+import asyncio
+import statistics  # 导入 statistics 模块
+import time
+import traceback
+from random import random
+from typing import List, Optional  # 导入 Optional
+
+from maim_message import UserInfo, Seg
+
+from src.common.logger_manager import get_logger
+from src.heart_flow.utils_chat import get_chat_type_and_target_info
+from src.manager.mood_manager import mood_manager
+from src.chat.message_receive.chat_stream import ChatStream, chat_manager
+from src.chat.person_info.relationship_manager import relationship_manager
+from src.chat.utils.info_catcher import info_catcher_manager
+from src.chat.utils.timer_calculator import Timer
+from .normal_chat_generator import NormalChatGenerator
+from ..message_receive.message import MessageSending, MessageRecv, MessageThinking, MessageSet
+from src.chat.message_receive.message_sender import message_manager
+from src.chat.utils.utils_image import image_path_to_base64
+from src.chat.emoji_system.emoji_manager import emoji_manager
+from src.chat.normal_chat.willing.willing_manager import willing_manager
+from src.config.config import global_config
+
+logger = get_logger("chat")
+
+
+class NormalChat:
+    def __init__(self, chat_stream: ChatStream, interest_dict: dict = None):
+        """初始化 NormalChat 实例。只进行同步操作。"""
+
+        # Basic info from chat_stream (sync)
+        self.chat_stream = chat_stream
+        self.stream_id = chat_stream.stream_id
+        # Get initial stream name, might be updated in initialize
+        self.stream_name = chat_manager.get_stream_name(self.stream_id) or self.stream_id
+
+        # Interest dict
+        self.interest_dict = interest_dict
+
+        # --- Initialize attributes (defaults) ---
+        self.is_group_chat: bool = False
+        self.chat_target_info: Optional[dict] = None
+        # --- End Initialization ---
+
+        # Other sync initializations
+        self.gpt = NormalChatGenerator()
+        self.mood_manager = mood_manager
+        self.start_time = time.time()
+        self.last_speak_time = 0
+        self._chat_task: Optional[asyncio.Task] = None
+        self._initialized = False  # Track initialization status
+
+        # logger.info(f"[{self.stream_name}] NormalChat 实例 __init__ 完成 (同步部分)。")
+        # Avoid logging here as stream_name might not be final
+
+    async def initialize(self):
+        """异步初始化，获取聊天类型和目标信息。"""
+        if self._initialized:
+            return
+
+        # --- Use utility function to determine chat type and fetch info ---
+        self.is_group_chat, self.chat_target_info = await get_chat_type_and_target_info(self.stream_id)
+        # Update stream_name again after potential async call in util func
+        self.stream_name = chat_manager.get_stream_name(self.stream_id) or self.stream_id
+        # --- End using utility function ---
+        self._initialized = True
+        logger.info(f"[{self.stream_name}] NormalChat 实例 initialize 完成 (异步部分)。")
+
+    # 改为实例方法
+    async def _create_thinking_message(self, message: MessageRecv, timestamp: Optional[float] = None) -> str:
+        """创建思考消息"""
+        messageinfo = message.message_info
+
+        bot_user_info = UserInfo(
+            user_id=global_config.BOT_QQ,
+            user_nickname=global_config.BOT_NICKNAME,
+            platform=messageinfo.platform,
+        )
+
+        thinking_time_point = round(time.time(), 2)
+        thinking_id = "mt" + str(thinking_time_point)
+        thinking_message = MessageThinking(
+            message_id=thinking_id,
+            chat_stream=self.chat_stream,
+            bot_user_info=bot_user_info,
+            reply=message,
+            thinking_start_time=thinking_time_point,
+            timestamp=timestamp if timestamp is not None else None,
+        )
+
+        await message_manager.add_message(thinking_message)
+        return thinking_id
+
+    # 改为实例方法
+    async def _add_messages_to_manager(
+        self, message: MessageRecv, response_set: List[str], thinking_id
+    ) -> Optional[MessageSending]:
+        """发送回复消息"""
+        container = await message_manager.get_container(self.stream_id)  # 使用 self.stream_id
+        thinking_message = None
+
+        for msg in container.messages[:]:
+            if isinstance(msg, MessageThinking) and msg.message_info.message_id == thinking_id:
+                thinking_message = msg
+                container.messages.remove(msg)
+                break
+
+        if not thinking_message:
+            logger.warning(f"[{self.stream_name}] 未找到对应的思考消息 {thinking_id}，可能已超时被移除")
+            return None
+
+        thinking_start_time = thinking_message.thinking_start_time
+        message_set = MessageSet(self.chat_stream, thinking_id)  # 使用 self.chat_stream
+
+        mark_head = False
+        first_bot_msg = None
+        for msg in response_set:
+            message_segment = Seg(type="text", data=msg)
+            bot_message = MessageSending(
+                message_id=thinking_id,
+                chat_stream=self.chat_stream,  # 使用 self.chat_stream
+                bot_user_info=UserInfo(
+                    user_id=global_config.BOT_QQ,
+                    user_nickname=global_config.BOT_NICKNAME,
+                    platform=message.message_info.platform,
+                ),
+                sender_info=message.message_info.user_info,
+                message_segment=message_segment,
+                reply=message,
+                is_head=not mark_head,
+                is_emoji=False,
+                thinking_start_time=thinking_start_time,
+                apply_set_reply_logic=True,
+            )
+            if not mark_head:
+                mark_head = True
+                first_bot_msg = bot_message
+            message_set.add_message(bot_message)
+
+        await message_manager.add_message(message_set)
+
+        self.last_speak_time = time.time()
+
+        return first_bot_msg
+
+    # 改为实例方法
+    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)
+            if emoji_raw:
+                emoji_path, description = emoji_raw
+                emoji_cq = image_path_to_base64(emoji_path)
+
+                thinking_time_point = round(message.message_info.time, 2)
+
+                message_segment = Seg(type="emoji", data=emoji_cq)
+                bot_message = MessageSending(
+                    message_id="mt" + str(thinking_time_point),
+                    chat_stream=self.chat_stream,  # 使用 self.chat_stream
+                    bot_user_info=UserInfo(
+                        user_id=global_config.BOT_QQ,
+                        user_nickname=global_config.BOT_NICKNAME,
+                        platform=message.message_info.platform,
+                    ),
+                    sender_info=message.message_info.user_info,
+                    message_segment=message_segment,
+                    reply=message,
+                    is_head=False,
+                    is_emoji=True,
+                    apply_set_reply_logic=True,
+                )
+                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)
+        user_info = message.message_info.user_info
+        platform = user_info.platform
+        await relationship_manager.calculate_update_relationship_value(
+            user_info,
+            platform,
+            label=emotion,
+            stance=stance,  # 使用 self.chat_stream
+        )
+        self.mood_manager.update_mood_from_emotion(emotion, global_config.mood_intensity_factor)
+
+    async def _reply_interested_message(self) -> None:
+        """
+        后台任务方法，轮询当前实例关联chat的兴趣消息
+        通常由start_monitoring_interest()启动
+        """
+        while True:
+            await asyncio.sleep(0.5)  # 每秒检查一次
+            # 检查任务是否已被取消
+            if self._chat_task is None or self._chat_task.cancelled():
+                logger.info(f"[{self.stream_name}] 兴趣监控任务被取消或置空，退出")
+                break
+
+            # 获取待处理消息列表
+            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:
+                try:
+                    # 处理消息
+                    await self.normal_response(
+                        message=message,
+                        is_mentioned=is_mentioned,
+                        interested_rate=interest_value,
+                        rewind_response=False,
+                    )
+                except Exception as e:
+                    logger.error(f"[{self.stream_name}] 处理兴趣消息{msg_id}时出错: {e}\n{traceback.format_exc()}")
+                finally:
+                    self.interest_dict.pop(msg_id, None)
+
+    # 改为实例方法, 移除 chat 参数
+    async def normal_response(
+        self, message: MessageRecv, is_mentioned: bool, interested_rate: float, rewind_response: bool = False
+    ) -> 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
+
+        timing_results = {}
+
+        reply_probability = 1.0 if is_mentioned else 0.0  # 如果被提及，基础概率为1，否则需要意愿判断
+
+        # 意愿管理器：设置当前message信息
+
+        willing_manager.setup(message, self.chat_stream, is_mentioned, interested_rate)
+
+        # 获取回复概率
+        is_willing = False
+        # 仅在未被提及或基础概率不为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 = 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))
+        # 使用 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"{message.message_info.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):
+                if rewind_response:
+                    thinking_id = await self._create_thinking_message(message, message.message_info.time)
+                else:
+                    thinking_id = await self._create_thinking_message(message)
+
+            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)
+
+            try:
+                with Timer("生成回复", timing_results):
+                    response_set = await self.gpt.generate_response(
+                        message=message,
+                        thinking_id=thinking_id,
+                    )
+
+                info_catcher.catch_after_generate_response(timing_results["生成回复"])
+            except Exception as e:
+                logger.error(f"[{self.stream_name}] 回复生成出现错误：{str(e)} {traceback.format_exc()}")
+                response_set = None  # 确保出错时 response_set 为 None
+
+            if not response_set:
+                logger.info(f"[{self.stream_name}] 模型未生成回复内容")
+                # 如果模型未生成回复，移除思考消息
+                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:
+                        container.messages.remove(msg)
+                        logger.debug(f"[{self.stream_name}] 已移除未产生回复的思考消息 {thinking_id}")
+                        break
+                # 需要在此处也调用 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"[{self.stream_name}] 回复内容: {response_set}")
+
+            # 发送回复 (不再需要传入 chat)
+            with Timer("消息发送", timing_results):
+                first_bot_msg = await self._add_messages_to_manager(message, response_set, thinking_id)
+
+            # 检查 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, response_set[0])
+
+            # 更新关系情绪 (不再需要传入 chat)
+            with Timer("关系更新", timing_results):
+                await self._update_relationship(message, response_set)
+
+            # 回复后处理
+            await willing_manager.after_generate_reply_handle(message.message_info.message_id)
+
+        # 输出性能计时结果
+        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)
+            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信息 (无论是否回复，只要处理过就删除)
+        willing_manager.delete(message.message_info.message_id)
+
+    # --- 新增：处理初始高兴趣消息的私有方法 ---
+    async def _process_initial_interest_messages(self):
+        """处理启动时存在于 interest_dict 中的高兴趣消息。"""
+        if not self.interest_dict:
+            return  # 如果 interest_dict 为 None 或空，直接返回
+
+        items_to_process = list(self.interest_dict.items())
+        if not items_to_process:
+            return  # 没有初始消息，直接返回
+
+        logger.info(f"[{self.stream_name}] 发现 {len(items_to_process)} 条初始兴趣消息，开始处理高兴趣部分...")
+        interest_values = [item[1][1] for item in items_to_process]  # 提取兴趣值列表
+
+        messages_to_reply = []  # 需要立即回复的消息
+
+        if len(interest_values) == 1:
+            # 如果只有一个消息，直接处理
+            messages_to_reply.append(items_to_process[0])
+            logger.info(f"[{self.stream_name}] 只有一条初始消息，直接处理。")
+        elif len(interest_values) > 1:
+            # 计算均值和标准差
+            try:
+                mean_interest = statistics.mean(interest_values)
+                stdev_interest = statistics.stdev(interest_values)
+                threshold = mean_interest + stdev_interest
+                logger.info(
+                    f"[{self.stream_name}] 初始兴趣值 均值: {mean_interest:.2f}, 标准差: {stdev_interest:.2f}, 阈值: {threshold:.2f}"
+                )
+
+                # 找出高于阈值的消息
+                for item in items_to_process:
+                    msg_id, (message, interest_value, is_mentioned) = item
+                    if interest_value > threshold:
+                        messages_to_reply.append(item)
+                logger.info(f"[{self.stream_name}] 找到 {len(messages_to_reply)} 条高于阈值的初始消息进行处理。")
+            except statistics.StatisticsError as e:
+                logger.error(f"[{self.stream_name}] 计算初始兴趣统计值时出错: {e}，跳过初始处理。")
+
+        # 处理需要回复的消息
+        processed_count = 0
+        # --- 修改：迭代前创建要处理的ID列表副本，防止迭代时修改 ---
+        messages_to_process_initially = list(messages_to_reply)  # 创建副本
+        # --- 新增：限制最多处理两条消息 ---
+        messages_to_process_initially = messages_to_process_initially[:2]
+        # --- 新增结束 ---
+        for item in messages_to_process_initially:  # 使用副本迭代
+            msg_id, (message, interest_value, is_mentioned) = item
+            # --- 修改：在处理前尝试 pop，防止竞争 ---
+            popped_item = self.interest_dict.pop(msg_id, None)
+            if popped_item is None:
+                logger.warning(f"[{self.stream_name}] 初始兴趣消息 {msg_id} 在处理前已被移除，跳过。")
+                continue  # 如果消息已被其他任务处理（pop），则跳过
+            # --- 修改结束 ---
+
+            try:
+                logger.info(f"[{self.stream_name}] 处理初始高兴趣消息 {msg_id} (兴趣值: {interest_value:.2f})")
+                await self.normal_response(
+                    message=message, is_mentioned=is_mentioned, interested_rate=interest_value, rewind_response=True
+                )
+                processed_count += 1
+            except Exception as e:
+                logger.error(f"[{self.stream_name}] 处理初始兴趣消息 {msg_id} 时出错: {e}\\n{traceback.format_exc()}")
+
+        # --- 新增：处理完后清空整个字典 ---
+        logger.info(
+            f"[{self.stream_name}] 处理了 {processed_count} 条初始高兴趣消息。现在清空所有剩余的初始兴趣消息..."
+        )
+        self.interest_dict.clear()
+        # --- 新增结束 ---
+
+        logger.info(
+            f"[{self.stream_name}] 初始高兴趣消息处理完毕，共处理 {processed_count} 条。剩余 {len(self.interest_dict)} 条待轮询。"
+        )
+
+    # --- 新增结束 ---
+
+    # 保持 staticmethod, 因为不依赖实例状态, 但需要 chat 对象来获取日志上下文
+    @staticmethod
+    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"[{stream_name}][{chat.group_info.group_name if chat.group_info else '私聊'}]"
+                    f"{userinfo.user_nickname}:{text}"
+                )
+                logger.info(f"[{stream_name}][过滤词识别] 消息中含有 '{word}'，filtered")
+                return True
+        return False
+
+    # 保持 staticmethod, 因为不依赖实例状态, 但需要 chat 对象来获取日志上下文
+    @staticmethod
+    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"[{stream_name}][{chat.group_info.group_name if chat.group_info else '私聊'}]"
+                    f"{userinfo.user_nickname}:{text}"
+                )
+                logger.info(f"[{stream_name}][正则表达式过滤] 消息匹配到 '{pattern.pattern}'，filtered")
+                return True
+        return False
+
+    # 改为实例方法, 移除 chat 参数
+
+    async def start_chat(self):
+        """先进行异步初始化，然后启动聊天任务。"""
+        if not self._initialized:
+            await self.initialize()  # Ensure initialized before starting tasks
+
+        if self._chat_task is None or self._chat_task.done():
+            logger.info(f"[{self.stream_name}] 开始后台处理初始兴趣消息和轮询任务...")
+            # Process initial messages first
+            await self._process_initial_interest_messages()
+            # Then start polling task
+            polling_task = asyncio.create_task(self._reply_interested_message())
+            polling_task.add_done_callback(lambda t: self._handle_task_completion(t))
+            self._chat_task = polling_task
+        else:
+            logger.info(f"[{self.stream_name}] 聊天轮询任务已在运行中。")
+
+    def _handle_task_completion(self, task: asyncio.Task):
+        """任务完成回调处理"""
+        if task is not self._chat_task:
+            logger.warning(f"[{self.stream_name}] 收到未知任务回调")
+            return
+        try:
+            if exc := task.exception():
+                logger.error(f"[{self.stream_name}] 任务异常: {exc}")
+                logger.error(traceback.format_exc())
+        except asyncio.CancelledError:
+            logger.debug(f"[{self.stream_name}] 任务已取消")
+        except Exception as e:
+            logger.error(f"[{self.stream_name}] 回调处理错误: {e}")
+        finally:
+            if self._chat_task is task:
+                self._chat_task = None
+                logger.debug(f"[{self.stream_name}] 任务清理完成")
+
+    # 改为实例方法, 移除 stream_id 参数
+    async def stop_chat(self):
+        """停止当前实例的兴趣监控任务。"""
+        if self._chat_task and not self._chat_task.done():
+            task = self._chat_task
+            logger.debug(f"[{self.stream_name}] 尝试取消normal聊天任务。")
+            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._chat_task is task:
+                    self._chat_task = None
+
+        # 清理所有未处理的思考消息
+        try:
+            container = await message_manager.get_container(self.stream_id)
+            if container:
+                # 查找并移除所有 MessageThinking 类型的消息
+                thinking_messages = [msg for msg in container.messages[:] if isinstance(msg, MessageThinking)]
+                if thinking_messages:
+                    for msg in thinking_messages:
+                        container.messages.remove(msg)
+                    logger.info(f"[{self.stream_name}] 清理了 {len(thinking_messages)} 条未处理的思考消息。")
+        except Exception as e:
+            logger.error(f"[{self.stream_name}] 清理思考消息时出错: {e}")
+            logger.error(traceback.format_exc())

src/chat/normal_chat/normal_chat_generator.py

@@ -0,0 +1,163 @@
+from typing import List, Optional, Tuple, Union
+import random
+from ..models.utils_model import LLMRequest
+from ...config.config import global_config
+from ..message_receive.message import MessageThinking
+from src.chat.focus_chat.heartflow_prompt_builder import prompt_builder
+from src.chat.utils.utils import process_llm_response
+from src.chat.utils.timer_calculator import Timer
+from src.common.logger_manager import get_logger
+from src.chat.utils.info_catcher import info_catcher_manager
+
+
+logger = get_logger("llm")
+
+
+class NormalChatGenerator:
+    def __init__(self):
+        self.model_reasoning = LLMRequest(
+            model=global_config.llm_reasoning,
+            temperature=0.7,
+            max_tokens=3000,
+            request_type="response_reasoning",
+        )
+        self.model_normal = LLMRequest(
+            model=global_config.llm_normal,
+            temperature=global_config.llm_normal["temp"],
+            max_tokens=256,
+            request_type="response_reasoning",
+        )
+
+        self.model_sum = LLMRequest(
+            model=global_config.llm_summary, temperature=0.7, max_tokens=3000, request_type="relation"
+        )
+        self.current_model_type = "r1"  # 默认使用 R1
+        self.current_model_name = "unknown model"
+
+    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:
+            self.current_model_type = "深深地"
+            current_model = self.model_reasoning
+        else:
+            self.current_model_type = "浅浅的"
+            current_model = self.model_normal
+
+        logger.info(
+            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(message, current_model, thinking_id)
+
+        if model_response:
+            logger.info(f"{global_config.BOT_NICKNAME}的回复是：{model_response}")
+            model_response = await self._process_response(model_response)
+
+            return model_response
+        else:
+            logger.info(f"{self.current_model_type}思考，失败")
+            return None
+
+    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:
+            sender_name = (
+                f"[({message.chat_stream.user_info.user_id}){message.chat_stream.user_info.user_nickname}]"
+                f"{message.chat_stream.user_info.user_cardname}"
+            )
+        elif message.chat_stream.user_info.user_nickname:
+            sender_name = f"({message.chat_stream.user_info.user_id}){message.chat_stream.user_info.user_nickname}"
+        else:
+            sender_name = f"用户({message.chat_stream.user_info.user_id})"
+        # 构建prompt
+        with Timer() as t_build_prompt:
+            prompt = await prompt_builder.build_prompt(
+                build_mode="normal",
+                reason="",
+                current_mind_info="",
+                structured_info="",
+                message_txt=message.processed_plain_text,
+                sender_name=sender_name,
+                chat_stream=message.chat_stream,
+            )
+        logger.debug(f"构建prompt时间: {t_build_prompt.human_readable}")
+
+        try:
+            content, reasoning_content, self.current_model_name = await model.generate_response(prompt)
+
+            logger.debug(f"prompt:{prompt}\n生成回复：{content}")
+
+            logger.info(f"对  {message.processed_plain_text}  的回复：{content}")
+
+            info_catcher.catch_after_llm_generated(
+                prompt=prompt, response=content, reasoning_content=reasoning_content, model_name=self.current_model_name
+            )
+
+        except Exception:
+            logger.exception("生成回复时出错")
+            return None
+
+        return content
+
+    async def _get_emotion_tags(self, content: str, processed_plain_text: str):
+        """提取情感标签，结合立场和情绪"""
+        try:
+            # 构建提示词，结合回复内容、被回复的内容以及立场分析
+            prompt = f"""
+            请严格根据以下对话内容，完成以下任务：
+            1. 判断回复者对被回复者观点的直接立场：
+            - "支持"：明确同意或强化被回复者观点
+            - "反对"：明确反驳或否定被回复者观点
+            - "中立"：不表达明确立场或无关回应
+            2. 从"开心,愤怒,悲伤,惊讶,平静,害羞,恐惧,厌恶,困惑"中选出最匹配的1个情感标签
+            3. 按照"立场-情绪"的格式直接输出结果，例如："反对-愤怒"
+            4. 考虑回复者的人格设定为{global_config.personality_core}
+
+            对话示例：
+            被回复：「A就是笨」
+            回复：「A明明很聪明」 → 反对-愤怒
+
+            当前对话：
+            被回复：「{processed_plain_text}」
+            回复：「{content}」
+
+            输出要求：
+            - 只需输出"立场-情绪"结果，不要解释
+            - 严格基于文字直接表达的对立关系判断
+            """
+
+            # 调用模型生成结果
+            result, _, _ = await self.model_sum.generate_response(prompt)
+            result = result.strip()
+
+            # 解析模型输出的结果
+            if "-" in result:
+                stance, emotion = result.split("-", 1)
+                valid_stances = ["支持", "反对", "中立"]
+                valid_emotions = ["开心", "愤怒", "悲伤", "惊讶", "害羞", "平静", "恐惧", "厌恶", "困惑"]
+                if stance in valid_stances and emotion in valid_emotions:
+                    return stance, emotion  # 返回有效的立场-情绪组合
+                else:
+                    logger.debug(f"无效立场-情感组合:{result}")
+                    return "中立", "平静"  # 默认返回中立-平静
+            else:
+                logger.debug(f"立场-情感格式错误:{result}")
+                return "中立", "平静"  # 格式错误时返回默认值
+
+        except Exception as e:
+            logger.debug(f"获取情感标签时出错: {e}")
+            return "中立", "平静"  # 出错时返回默认值
+
+    @staticmethod
+    async def _process_response(content: str) -> Tuple[List[str], List[str]]:
+        """处理响应内容，返回处理后的内容和情感标签"""
+        if not content:
+            return None, []
+
+        processed_response = process_llm_response(content)
+
+        # print(f"得到了处理后的llm返回{processed_response}")
+
+        return processed_response

src/chat/normal_chat/willing/mode_classical.py

@@ -0,0 +1,79 @@
+import asyncio
+from .willing_manager import BaseWillingManager
+
+
+class ClassicalWillingManager(BaseWillingManager):
+    def __init__(self):
+        super().__init__()
+        self._decay_task: asyncio.Task = None
+
+    async def _decay_reply_willing(self):
+        """定期衰减回复意愿"""
+        while True:
+            await asyncio.sleep(1)
+            for chat_id in self.chat_reply_willing:
+                self.chat_reply_willing[chat_id] = max(0, self.chat_reply_willing[chat_id] * 0.9)
+
+    async def async_task_starter(self):
+        if self._decay_task is None:
+            self._decay_task = asyncio.create_task(self._decay_reply_willing())
+
+    async def get_reply_probability(self, message_id):
+        willing_info = self.ongoing_messages[message_id]
+        chat_id = willing_info.chat_id
+        current_willing = self.chat_reply_willing.get(chat_id, 0)
+
+        interested_rate = willing_info.interested_rate * self.global_config.response_interested_rate_amplifier
+
+        if interested_rate > 0.4:
+            current_willing += interested_rate - 0.3
+
+        if willing_info.is_mentioned_bot and current_willing < 1.0:
+            current_willing += 1
+        elif willing_info.is_mentioned_bot:
+            current_willing += 0.05
+
+        is_emoji_not_reply = False
+        if willing_info.is_emoji:
+            if self.global_config.emoji_response_penalty != 0:
+                current_willing *= self.global_config.emoji_response_penalty
+            else:
+                is_emoji_not_reply = True
+
+        self.chat_reply_willing[chat_id] = min(current_willing, 3.0)
+
+        reply_probability = min(
+            max((current_willing - 0.5), 0.01) * self.global_config.response_willing_amplifier * 2, 1
+        )
+
+        # 检查群组权限（如果是群聊）
+        if (
+            willing_info.group_info
+            and willing_info.group_info.group_id in self.global_config.talk_frequency_down_groups
+        ):
+            reply_probability = reply_probability / self.global_config.down_frequency_rate
+
+        if is_emoji_not_reply:
+            reply_probability = 0
+
+        return reply_probability
+
+    async def before_generate_reply_handle(self, message_id):
+        chat_id = self.ongoing_messages[message_id].chat_id
+        current_willing = self.chat_reply_willing.get(chat_id, 0)
+        self.chat_reply_willing[chat_id] = max(0, current_willing - 1.8)
+
+    async def after_generate_reply_handle(self, message_id):
+        if message_id not in self.ongoing_messages:
+            return
+
+        chat_id = self.ongoing_messages[message_id].chat_id
+        current_willing = self.chat_reply_willing.get(chat_id, 0)
+        if current_willing < 1:
+            self.chat_reply_willing[chat_id] = min(1, current_willing + 0.4)
+
+    async def bombing_buffer_message_handle(self, message_id):
+        return await super().bombing_buffer_message_handle(message_id)
+
+    async def not_reply_handle(self, message_id):
+        return await super().not_reply_handle(message_id)

src/chat/normal_chat/willing/mode_custom.py

@@ -0,0 +1,24 @@
+from .willing_manager import BaseWillingManager
+
+
+class CustomWillingManager(BaseWillingManager):
+    async def async_task_starter(self) -> None:
+        pass
+
+    async def before_generate_reply_handle(self, message_id: str):
+        pass
+
+    async def after_generate_reply_handle(self, message_id: str):
+        pass
+
+    async def not_reply_handle(self, message_id: str):
+        pass
+
+    async def get_reply_probability(self, message_id: str):
+        pass
+
+    async def bombing_buffer_message_handle(self, message_id: str):
+        pass
+
+    def __init__(self):
+        super().__init__()

src/chat/normal_chat/willing/mode_mxp.py

@@ -0,0 +1,331 @@
+"""
+Mxp 模式：梦溪畔独家赞助
+此模式的一些参数不会在配置文件中显示，要修改请在可变参数下修改
+同时一些全局设置对此模式无效
+此模式的可变参数暂时比较草率，需要调参仙人的大手
+此模式的特点：
+1.每个聊天流的每个用户的意愿是独立的
+2.接入关系系统，关系会影响意愿值
+3.会根据群聊的热度来调整基础意愿值
+4.限制同时思考的消息数量，防止喷射
+5.拥有单聊增益，无论在群里还是私聊，只要bot一直和你聊，就会增加意愿值
+6.意愿分为衰减意愿+临时意愿
+7.疲劳机制
+
+如果你发现本模式出现了bug
+上上策是询问智慧的小草神（）
+上策是询问万能的千石可乐
+中策是发issue
+下下策是询问一个菜鸟（@梦溪畔）
+"""
+
+from .willing_manager import BaseWillingManager
+from typing import Dict
+import asyncio
+import time
+import math
+
+
+class MxpWillingManager(BaseWillingManager):
+    """Mxp意愿管理器"""
+
+    def __init__(self):
+        super().__init__()
+        self.chat_person_reply_willing: Dict[str, Dict[str, float]] = {}  # chat_id: {person_id: 意愿值}
+        self.chat_new_message_time: Dict[str, list[float]] = {}  # 聊天流ID: 消息时间
+        self.last_response_person: Dict[str, tuple[str, int]] = {}  # 上次回复的用户信息
+        self.temporary_willing: float = 0  # 临时意愿值
+        self.chat_bot_message_time: Dict[str, list[float]] = {}  # 聊天流ID: bot已回复消息时间
+        self.chat_fatigue_punishment_list: Dict[
+            str, list[tuple[float, float]]
+        ] = {}  # 聊天流疲劳惩罚列, 聊天流ID: 惩罚时间列(开始时间，持续时间)
+        self.chat_fatigue_willing_attenuation: Dict[str, float] = {}  # 聊天流疲劳意愿衰减值
+
+        # 可变参数
+        self.intention_decay_rate = 0.93  # 意愿衰减率
+
+        self.number_of_message_storage = 12  # 消息存储数量
+        self.expected_replies_per_min = 3  # 每分钟预期回复数
+        self.basic_maximum_willing = 0.5  # 基础最大意愿值
+
+        self.mention_willing_gain = 0.6  # 提及意愿增益
+        self.interest_willing_gain = 0.3  # 兴趣意愿增益
+        self.emoji_response_penalty = self.global_config.emoji_response_penalty  # 表情包回复惩罚
+        self.down_frequency_rate = self.global_config.down_frequency_rate  # 降低回复频率的群组惩罚系数
+        self.single_chat_gain = 0.12  # 单聊增益
+
+        self.fatigue_messages_triggered_num = self.expected_replies_per_min  # 疲劳消息触发数量(int)
+        self.fatigue_coefficient = 1.0  # 疲劳系数
+
+        self.is_debug = False  # 是否开启调试模式
+
+    async def async_task_starter(self) -> None:
+        """异步任务启动器"""
+        asyncio.create_task(self._return_to_basic_willing())
+        asyncio.create_task(self._chat_new_message_to_change_basic_willing())
+        asyncio.create_task(self._fatigue_attenuation())
+
+    async def before_generate_reply_handle(self, message_id: str):
+        """回复前处理"""
+        current_time = time.time()
+        async with self.lock:
+            w_info = self.ongoing_messages[message_id]
+            if w_info.chat_id not in self.chat_bot_message_time:
+                self.chat_bot_message_time[w_info.chat_id] = []
+            self.chat_bot_message_time[w_info.chat_id] = [
+                t for t in self.chat_bot_message_time[w_info.chat_id] if current_time - t < 60
+            ]
+            self.chat_bot_message_time[w_info.chat_id].append(current_time)
+            if len(self.chat_bot_message_time[w_info.chat_id]) == int(self.fatigue_messages_triggered_num):
+                time_interval = 60 - (current_time - self.chat_bot_message_time[w_info.chat_id].pop(0))
+                self.chat_fatigue_punishment_list[w_info.chat_id].append([current_time, time_interval * 2])
+
+    async def after_generate_reply_handle(self, message_id: str):
+        """回复后处理"""
+        async with self.lock:
+            w_info = self.ongoing_messages[message_id]
+            rel_value = await w_info.person_info_manager.get_value(w_info.person_id, "relationship_value")
+            rel_level = self._get_relationship_level_num(rel_value)
+            self.chat_person_reply_willing[w_info.chat_id][w_info.person_id] += rel_level * 0.05
+
+            now_chat_new_person = self.last_response_person.get(w_info.chat_id, [w_info.person_id, 0])
+            if now_chat_new_person[0] == w_info.person_id:
+                if now_chat_new_person[1] < 3:
+                    now_chat_new_person[1] += 1
+            else:
+                self.last_response_person[w_info.chat_id] = [w_info.person_id, 0]
+
+    async def not_reply_handle(self, message_id: str):
+        """不回复处理"""
+        async with self.lock:
+            w_info = self.ongoing_messages[message_id]
+            if w_info.is_mentioned_bot:
+                self.chat_person_reply_willing[w_info.chat_id][w_info.person_id] += self.mention_willing_gain / 2.5
+            if (
+                w_info.chat_id in self.last_response_person
+                and self.last_response_person[w_info.chat_id][0] == w_info.person_id
+                and self.last_response_person[w_info.chat_id][1]
+            ):
+                self.chat_person_reply_willing[w_info.chat_id][w_info.person_id] += self.single_chat_gain * (
+                    2 * self.last_response_person[w_info.chat_id][1] - 1
+                )
+            now_chat_new_person = self.last_response_person.get(w_info.chat_id, ["", 0])
+            if now_chat_new_person[0] != w_info.person_id:
+                self.last_response_person[w_info.chat_id] = [w_info.person_id, 0]
+
+    async def get_reply_probability(self, message_id: str):
+        """获取回复概率"""
+        async with self.lock:
+            w_info = self.ongoing_messages[message_id]
+            current_willing = self.chat_person_reply_willing[w_info.chat_id][w_info.person_id]
+            if self.is_debug:
+                self.logger.debug(f"基础意愿值：{current_willing}")
+
+            if w_info.is_mentioned_bot:
+                current_willing_ = self.mention_willing_gain / (int(current_willing) + 1)
+                current_willing += current_willing_
+                if self.is_debug:
+                    self.logger.debug(f"提及增益：{current_willing_}")
+
+            if w_info.interested_rate > 0:
+                current_willing += math.atan(w_info.interested_rate / 2) / math.pi * 2 * self.interest_willing_gain
+                if self.is_debug:
+                    self.logger.debug(
+                        f"兴趣增益：{math.atan(w_info.interested_rate / 2) / math.pi * 2 * self.interest_willing_gain}"
+                    )
+
+            self.chat_person_reply_willing[w_info.chat_id][w_info.person_id] = current_willing
+
+            rel_value = await w_info.person_info_manager.get_value(w_info.person_id, "relationship_value")
+            rel_level = self._get_relationship_level_num(rel_value)
+            current_willing += rel_level * 0.1
+            if self.is_debug and rel_level != 0:
+                self.logger.debug(f"关系增益：{rel_level * 0.1}")
+
+            if (
+                w_info.chat_id in self.last_response_person
+                and self.last_response_person[w_info.chat_id][0] == w_info.person_id
+                and self.last_response_person[w_info.chat_id][1]
+            ):
+                current_willing += self.single_chat_gain * (2 * self.last_response_person[w_info.chat_id][1] + 1)
+                if self.is_debug:
+                    self.logger.debug(
+                        f"单聊增益：{self.single_chat_gain * (2 * self.last_response_person[w_info.chat_id][1] + 1)}"
+                    )
+
+            current_willing += self.chat_fatigue_willing_attenuation.get(w_info.chat_id, 0)
+            if self.is_debug:
+                self.logger.debug(f"疲劳衰减：{self.chat_fatigue_willing_attenuation.get(w_info.chat_id, 0)}")
+
+            chat_ongoing_messages = [msg for msg in self.ongoing_messages.values() if msg.chat_id == w_info.chat_id]
+            chat_person_ogoing_messages = [msg for msg in chat_ongoing_messages if msg.person_id == w_info.person_id]
+            if len(chat_person_ogoing_messages) >= 2:
+                current_willing = 0
+                if self.is_debug:
+                    self.logger.debug("进行中消息惩罚：归0")
+            elif len(chat_ongoing_messages) == 2:
+                current_willing -= 0.5
+                if self.is_debug:
+                    self.logger.debug("进行中消息惩罚：-0.5")
+            elif len(chat_ongoing_messages) == 3:
+                current_willing -= 1.5
+                if self.is_debug:
+                    self.logger.debug("进行中消息惩罚：-1.5")
+            elif len(chat_ongoing_messages) >= 4:
+                current_willing = 0
+                if self.is_debug:
+                    self.logger.debug("进行中消息惩罚：归0")
+
+            probability = self._willing_to_probability(current_willing)
+
+            if w_info.is_emoji:
+                probability *= self.emoji_response_penalty
+
+            if w_info.group_info and w_info.group_info.group_id in self.global_config.talk_frequency_down_groups:
+                probability /= self.down_frequency_rate
+
+            self.temporary_willing = current_willing
+
+            return probability
+
+    async def bombing_buffer_message_handle(self, message_id: str):
+        """炸飞消息处理"""
+        async with self.lock:
+            w_info = self.ongoing_messages[message_id]
+            self.chat_person_reply_willing[w_info.chat_id][w_info.person_id] += 0.1
+
+    async def _return_to_basic_willing(self):
+        """使每个人的意愿恢复到chat基础意愿"""
+        while True:
+            await asyncio.sleep(3)
+            async with self.lock:
+                for chat_id, person_willing in self.chat_person_reply_willing.items():
+                    for person_id, willing in person_willing.items():
+                        if chat_id not in self.chat_reply_willing:
+                            self.logger.debug(f"聊天流{chat_id}不存在，错误")
+                            continue
+                        basic_willing = self.chat_reply_willing[chat_id]
+                        person_willing[person_id] = (
+                            basic_willing + (willing - basic_willing) * self.intention_decay_rate
+                        )
+
+    def setup(self, message, chat, is_mentioned_bot, interested_rate):
+        super().setup(message, chat, is_mentioned_bot, interested_rate)
+
+        self.chat_reply_willing[chat.stream_id] = self.chat_reply_willing.get(
+            chat.stream_id, self.basic_maximum_willing
+        )
+        self.chat_person_reply_willing[chat.stream_id] = self.chat_person_reply_willing.get(chat.stream_id, {})
+        self.chat_person_reply_willing[chat.stream_id][
+            self.ongoing_messages[message.message_info.message_id].person_id
+        ] = self.chat_person_reply_willing[chat.stream_id].get(
+            self.ongoing_messages[message.message_info.message_id].person_id, self.chat_reply_willing[chat.stream_id]
+        )
+
+        current_time = time.time()
+        if chat.stream_id not in self.chat_new_message_time:
+            self.chat_new_message_time[chat.stream_id] = []
+        self.chat_new_message_time[chat.stream_id].append(current_time)
+        if len(self.chat_new_message_time[chat.stream_id]) > self.number_of_message_storage:
+            self.chat_new_message_time[chat.stream_id].pop(0)
+
+        if chat.stream_id not in self.chat_fatigue_punishment_list:
+            self.chat_fatigue_punishment_list[chat.stream_id] = [
+                (
+                    current_time,
+                    self.number_of_message_storage * self.basic_maximum_willing / self.expected_replies_per_min * 60,
+                )
+            ]
+            self.chat_fatigue_willing_attenuation[chat.stream_id] = (
+                -2 * self.basic_maximum_willing * self.fatigue_coefficient
+            )
+
+    @staticmethod
+    def _willing_to_probability(willing: float) -> float:
+        """意愿值转化为概率"""
+        willing = max(0, willing)
+        if willing < 2:
+            probability = math.atan(willing * 2) / math.pi * 2
+        elif willing < 2.5:
+            probability = math.atan(willing * 4) / math.pi * 2
+        else:
+            probability = 1
+        return probability
+
+    async def _chat_new_message_to_change_basic_willing(self):
+        """聊天流新消息改变基础意愿"""
+        update_time = 20
+        while True:
+            await asyncio.sleep(update_time)
+            async with self.lock:
+                for chat_id, message_times in self.chat_new_message_time.items():
+                    # 清理过期消息
+                    current_time = time.time()
+                    message_times = [
+                        msg_time
+                        for msg_time in message_times
+                        if current_time - msg_time
+                        < self.number_of_message_storage
+                        * self.basic_maximum_willing
+                        / self.expected_replies_per_min
+                        * 60
+                    ]
+                    self.chat_new_message_time[chat_id] = message_times
+
+                    if len(message_times) < self.number_of_message_storage:
+                        self.chat_reply_willing[chat_id] = self.basic_maximum_willing
+                        update_time = 20
+                    elif len(message_times) == self.number_of_message_storage:
+                        time_interval = current_time - message_times[0]
+                        basic_willing = self._basic_willing_culculate(time_interval)
+                        self.chat_reply_willing[chat_id] = basic_willing
+                        update_time = 17 * basic_willing / self.basic_maximum_willing + 3
+                    else:
+                        self.logger.debug(f"聊天流{chat_id}消息时间数量异常，数量：{len(message_times)}")
+                        self.chat_reply_willing[chat_id] = 0
+                if self.is_debug:
+                    self.logger.debug(f"聊天流意愿值更新：{self.chat_reply_willing}")
+
+    @staticmethod
+    def _get_relationship_level_num(relationship_value) -> int:
+        """关系等级计算"""
+        if -1000 <= relationship_value < -227:
+            level_num = 0
+        elif -227 <= relationship_value < -73:
+            level_num = 1
+        elif -73 <= relationship_value < 227:
+            level_num = 2
+        elif 227 <= relationship_value < 587:
+            level_num = 3
+        elif 587 <= relationship_value < 900:
+            level_num = 4
+        elif 900 <= relationship_value <= 1000:
+            level_num = 5
+        else:
+            level_num = 5 if relationship_value > 1000 else 0
+        return level_num - 2
+
+    def _basic_willing_culculate(self, t: float) -> float:
+        """基础意愿值计算"""
+        return math.tan(t * self.expected_replies_per_min * math.pi / 120 / self.number_of_message_storage) / 2
+
+    async def _fatigue_attenuation(self):
+        """疲劳衰减"""
+        while True:
+            await asyncio.sleep(1)
+            current_time = time.time()
+            async with self.lock:
+                for chat_id, fatigue_list in self.chat_fatigue_punishment_list.items():
+                    fatigue_list = [z for z in fatigue_list if current_time - z[0] < z[1]]
+                    self.chat_fatigue_willing_attenuation[chat_id] = 0
+                    for start_time, duration in fatigue_list:
+                        self.chat_fatigue_willing_attenuation[chat_id] += (
+                            self.chat_reply_willing[chat_id]
+                            * 2
+                            / math.pi
+                            * math.asin(2 * (current_time - start_time) / duration - 1)
+                            - self.chat_reply_willing[chat_id]
+                        ) * self.fatigue_coefficient
+
+    async def get_willing(self, chat_id):
+        return self.temporary_willing

src/chat/normal_chat/willing/willing_manager.py

@@ -0,0 +1,181 @@
+from src.common.logger import LogConfig, WILLING_STYLE_CONFIG, LoguruLogger, get_module_logger
+from dataclasses import dataclass
+from src.config.config import global_config, BotConfig
+from src.chat.message_receive.chat_stream import ChatStream, GroupInfo
+from src.chat.message_receive.message import MessageRecv
+from src.chat.person_info.person_info import person_info_manager, PersonInfoManager
+from abc import ABC, abstractmethod
+import importlib
+from typing import Dict, Optional
+import asyncio
+from rich.traceback import install
+
+install(extra_lines=3)
+
+"""
+基类方法概览：
+以下8个方法是你必须在子类重写的（哪怕什么都不干）：
+async_task_starter 在程序启动时执行，在其中用asyncio.create_task启动你想要执行的异步任务
+before_generate_reply_handle 确定要回复后，在生成回复前的处理
+after_generate_reply_handle 确定要回复后，在生成回复后的处理
+not_reply_handle 确定不回复后的处理
+get_reply_probability 获取回复概率
+bombing_buffer_message_handle 缓冲器炸飞消息后的处理
+get_variable_parameters 暂不确定
+set_variable_parameters 暂不确定
+以下2个方法根据你的实现可以做调整：
+get_willing 获取某聊天流意愿
+set_willing 设置某聊天流意愿
+规范说明：
+模块文件命名: `mode_{manager_type}.py` 
+示例: 若 `manager_type="aggressive"`，则模块文件应为 `mode_aggressive.py`
+类命名: `{manager_type}WillingManager` (首字母大写)
+示例: 在 `mode_aggressive.py` 中，类名应为 `AggressiveWillingManager`
+"""
+
+willing_config = LogConfig(
+    # 使用消息发送专用样式
+    console_format=WILLING_STYLE_CONFIG["console_format"],
+    file_format=WILLING_STYLE_CONFIG["file_format"],
+)
+logger = get_module_logger("willing", config=willing_config)
+
+
+@dataclass
+class WillingInfo:
+    """此类保存意愿模块常用的参数
+
+    Attributes:
+        message (MessageRecv): 原始消息对象
+        chat (ChatStream): 聊天流对象
+        person_info_manager (PersonInfoManager): 用户信息管理对象
+        chat_id (str): 当前聊天流的标识符
+        person_id (str): 发送者的个人信息的标识符
+        group_id (str): 群组ID（如果是私聊则为空）
+        is_mentioned_bot (bool): 是否提及了bot
+        is_emoji (bool): 是否为表情包
+        interested_rate (float): 兴趣度
+    """
+
+    message: MessageRecv
+    chat: ChatStream
+    person_info_manager: PersonInfoManager
+    chat_id: str
+    person_id: str
+    group_info: Optional[GroupInfo]
+    is_mentioned_bot: bool
+    is_emoji: bool
+    interested_rate: float
+    # current_mood: float  当前心情？
+
+
+class BaseWillingManager(ABC):
+    """回复意愿管理基类"""
+
+    @classmethod
+    def create(cls, manager_type: str) -> "BaseWillingManager":
+        try:
+            module = importlib.import_module(f".mode_{manager_type}", __package__)
+            manager_class = getattr(module, f"{manager_type.capitalize()}WillingManager")
+            if not issubclass(manager_class, cls):
+                raise TypeError(f"Manager class {manager_class.__name__} is not a subclass of {cls.__name__}")
+            else:
+                logger.info(f"普通回复模式：{manager_type}")
+            return manager_class()
+        except (ImportError, AttributeError, TypeError) as e:
+            module = importlib.import_module(".mode_classical", __package__)
+            manager_class = module.ClassicalWillingManager
+            logger.info(f"载入当前意愿模式{manager_type}失败，使用经典配方~~~~")
+            logger.debug(f"加载willing模式{manager_type}失败，原因: {str(e)}。")
+            return manager_class()
+
+    def __init__(self):
+        self.chat_reply_willing: Dict[str, float] = {}  # 存储每个聊天流的回复意愿(chat_id)
+        self.ongoing_messages: Dict[str, WillingInfo] = {}  # 当前正在进行的消息(message_id)
+        self.lock = asyncio.Lock()
+        self.global_config: BotConfig = global_config
+        self.logger: LoguruLogger = logger
+
+    def setup(self, message: MessageRecv, chat: ChatStream, is_mentioned_bot: bool, interested_rate: float):
+        person_id = person_info_manager.get_person_id(chat.platform, chat.user_info.user_id)
+        self.ongoing_messages[message.message_info.message_id] = WillingInfo(
+            message=message,
+            chat=chat,
+            person_info_manager=person_info_manager,
+            chat_id=chat.stream_id,
+            person_id=person_id,
+            group_info=chat.group_info,
+            is_mentioned_bot=is_mentioned_bot,
+            is_emoji=message.is_emoji,
+            interested_rate=interested_rate,
+        )
+
+    def delete(self, message_id: str):
+        del_message = self.ongoing_messages.pop(message_id, None)
+        if not del_message:
+            logger.debug(f"尝试删除不存在的消息 ID: {message_id}，可能已被其他流程处理，喵~")
+
+    @abstractmethod
+    async def async_task_starter(self) -> None:
+        """抽象方法：异步任务启动器"""
+        pass
+
+    @abstractmethod
+    async def before_generate_reply_handle(self, message_id: str):
+        """抽象方法：回复前处理"""
+        pass
+
+    @abstractmethod
+    async def after_generate_reply_handle(self, message_id: str):
+        """抽象方法：回复后处理"""
+        pass
+
+    @abstractmethod
+    async def not_reply_handle(self, message_id: str):
+        """抽象方法：不回复处理"""
+        pass
+
+    @abstractmethod
+    async def get_reply_probability(self, message_id: str):
+        """抽象方法：获取回复概率"""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def bombing_buffer_message_handle(self, message_id: str):
+        """抽象方法：炸飞消息处理"""
+        pass
+
+    async def get_willing(self, chat_id: str):
+        """获取指定聊天流的回复意愿"""
+        async with self.lock:
+            return self.chat_reply_willing.get(chat_id, 0)
+
+    async def set_willing(self, chat_id: str, willing: float):
+        """设置指定聊天流的回复意愿"""
+        async with self.lock:
+            self.chat_reply_willing[chat_id] = willing
+
+    # @abstractmethod
+    # async def get_variable_parameters(self) -> Dict[str, str]:
+    #     """抽象方法：获取可变参数"""
+    #     pass
+
+    # @abstractmethod
+    # async def set_variable_parameters(self, parameters: Dict[str, any]):
+    #     """抽象方法：设置可变参数"""
+    #     pass
+
+
+def init_willing_manager() -> BaseWillingManager:
+    """
+    根据配置初始化并返回对应的WillingManager实例
+
+    Returns:
+        对应mode的WillingManager实例
+    """
+    mode = global_config.willing_mode.lower()
+    return BaseWillingManager.create(mode)
+
+
+# 全局willing_manager对象
+willing_manager = init_willing_manager()