Merge branch 'main-fix' of https://github.com/SengokuCola/MaiMBot into prompt-update

# Conflicts:
#	src/plugins/chat/prompt_builder.py

src/plugins/chat/__init__.py

@@ -15,7 +15,7 @@ from .bot import chat_bot
 from .config import global_config
 from .emoji_manager import emoji_manager
 from .relationship_manager import relationship_manager
-from .willing_manager import willing_manager
+from ..willing.willing_manager import willing_manager
 from .chat_stream import chat_manager
 from ..memory_system.memory import hippocampus, memory_graph
 from .bot import ChatBot

src/plugins/chat/bot.py

@@ -29,7 +29,7 @@ from .storage import MessageStorage
 from .utils import calculate_typing_time, is_mentioned_bot_in_message
 from .utils_image import image_path_to_base64
 from .utils_user import get_user_nickname, get_user_cardname, get_groupname
-from .willing_manager import willing_manager  # 导入意愿管理器
+from ..willing.willing_manager import willing_manager  # 导入意愿管理器
 from .message_base import UserInfo, GroupInfo, Seg
 from ..utils.logger_config import LogClassification, LogModule
 
@@ -55,112 +55,18 @@ class ChatBot:
         if not self._started:
             self._started = True
 
-    async def handle_notice(self, event: NoticeEvent, bot: Bot) -> None:
-        """处理收到的通知"""
-        # 戳一戳通知
-        if isinstance(event, PokeNotifyEvent):
-            # 不处理其他人的戳戳
-            if not event.is_tome():
-                return
-
-            # 用户屏蔽,不区分私聊/群聊
-            if event.user_id in global_config.ban_user_id:
-                return
-
-            reply_poke_probability = 1.0  # 回复戳一戳的概率，如果要改可以在这里改，暂不提取到配置文件
-
-            if random() < reply_poke_probability:
-                raw_message = "[戳了戳]你"  # 默认类型
-                if info := event.raw_info:
-                    poke_type = info[2].get("txt", "戳了戳")  # 戳戳类型，例如“拍一拍”、“揉一揉”、“捏一捏”
-                    custom_poke_message = info[4].get("txt", "")  # 自定义戳戳消息，若不存在会为空字符串
-                    raw_message = f"[{poke_type}]你{custom_poke_message}"
-
-                raw_message += "（这是一个类似摸摸头的友善行为，而不是恶意行为，请不要作出攻击发言）"
-                await self.directly_reply(raw_message, event.user_id, event.group_id)
-
-        if isinstance(event, GroupRecallNoticeEvent) or isinstance(event, FriendRecallNoticeEvent):
-            user_info = UserInfo(
-                user_id=event.user_id,
-                user_nickname=get_user_nickname(event.user_id) or None,
-                user_cardname=get_user_cardname(event.user_id) or None,
-                platform="qq",
-            )
-
-            group_info = GroupInfo(group_id=event.group_id, group_name=None, platform="qq")
-
-            chat = await chat_manager.get_or_create_stream(
-                platform=user_info.platform, user_info=user_info, group_info=group_info
-            )
-
-            await self.storage.store_recalled_message(event.message_id, time.time(), chat)
-
-    async def handle_message(self, event: MessageEvent, bot: Bot) -> None:
-        """处理收到的消息"""
-
-        self.bot = bot  # 更新 bot 实例
-
-        # 用户屏蔽,不区分私聊/群聊
-        if event.user_id in global_config.ban_user_id:
-            return
-
-        if (
-            event.reply
-            and hasattr(event.reply, "sender")
-            and hasattr(event.reply.sender, "user_id")
-            and event.reply.sender.user_id in global_config.ban_user_id
-        ):
-            logger.debug(f"跳过处理回复来自被ban用户 {event.reply.sender.user_id} 的消息")
-            return
-        # 处理私聊消息
-        if isinstance(event, PrivateMessageEvent):
-            if not global_config.enable_friend_chat:  # 私聊过滤
-                return
-            else:
-                try:
-                    user_info = UserInfo(
-                        user_id=event.user_id,
-                        user_nickname=(await bot.get_stranger_info(user_id=event.user_id, no_cache=True))["nickname"],
-                        user_cardname=None,
-                        platform="qq",
-                    )
-                except Exception as e:
-                    logger.error(f"获取陌生人信息失败: {e}")
-                    return
-                logger.debug(user_info)
-
-                # group_info = GroupInfo(group_id=0, group_name="私聊", platform="qq")
-                group_info = None
-
-        # 处理群聊消息
-        else:
-            # 白名单设定由nontbot侧完成
-            if event.group_id:
-                if event.group_id not in global_config.talk_allowed_groups:
-                    return
-
-            user_info = UserInfo(
-                user_id=event.user_id,
-                user_nickname=event.sender.nickname,
-                user_cardname=event.sender.card or None,
-                platform="qq",
-            )
-
-            group_info = GroupInfo(group_id=event.group_id, group_name=None, platform="qq")
-
-        # group_info = await bot.get_group_info(group_id=event.group_id)
-        # sender_info = await bot.get_group_member_info(group_id=event.group_id, user_id=event.user_id, no_cache=True)
-
-        message_cq = MessageRecvCQ(
-            message_id=event.message_id,
-            user_info=user_info,
-            raw_message=str(event.original_message),
-            group_info=group_info,
-            reply_message=event.reply,
-            platform="qq",
-        )
+    async def message_process(self, message_cq: MessageRecvCQ) -> None:
+        """处理转化后的统一格式消息
+        1. 过滤消息
+        2. 记忆激活
+        3. 意愿激活
+        4. 生成回复并发送
+        5. 更新关系
+        6. 更新情绪
+        """
         await message_cq.initialize()
         message_json = message_cq.to_dict()
+        # 哦我嘞个json
 
         # 进入maimbot
         message = MessageRecv(message_json)
@@ -170,16 +76,20 @@ class ChatBot:
 
         # 消息过滤，涉及到config有待更新
 
+        # 创建聊天流
         chat = await chat_manager.get_or_create_stream(
-            platform=messageinfo.platform, user_info=userinfo, group_info=groupinfo
+            platform=messageinfo.platform, user_info=userinfo, group_info=groupinfo #我嘞个gourp_info
         )
         message.update_chat_stream(chat)
         await relationship_manager.update_relationship(
             chat_stream=chat,
         )
-        await relationship_manager.update_relationship_value(chat_stream=chat, relationship_value=0.5)
+        await relationship_manager.update_relationship_value(
+            chat_stream=chat, relationship_value=0.5
+        )
 
         await message.process()
+        
         # 过滤词
         for word in global_config.ban_words:
             if word in message.processed_plain_text:
@@ -198,12 +108,15 @@ class ChatBot:
                 logger.info(f"[正则表达式过滤]消息匹配到{pattern}，filtered")
                 return
 
-        current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(messageinfo.time))
-
-        # topic=await topic_identifier.identify_topic_llm(message.processed_plain_text)
+        current_time = time.strftime(
+            "%Y-%m-%d %H:%M:%S", time.localtime(messageinfo.time)
+        )
 
+        #根据话题计算激活度
         topic = ""
-        interested_rate = await hippocampus.memory_activate_value(message.processed_plain_text) / 100
+        interested_rate = (
+            await hippocampus.memory_activate_value(message.processed_plain_text) / 100
+        )
         logger.debug(f"对{message.processed_plain_text}的激活度:{interested_rate}")
         # logger.info(f"\033[1;32m[主题识别]\033[0m 使用{global_config.topic_extract}主题: {topic}")
 
@@ -212,7 +125,6 @@ class ChatBot:
         is_mentioned = is_mentioned_bot_in_message(message)
         reply_probability = await willing_manager.change_reply_willing_received(
             chat_stream=chat,
-            topic=topic[0] if topic else None,
             is_mentioned_bot=is_mentioned,
             config=global_config,
             is_emoji=message.is_emoji,
@@ -260,7 +172,10 @@ class ChatBot:
             # 找到message,删除
             # print(f"开始找思考消息")
             for msg in container.messages:
-                if isinstance(msg, MessageThinking) and msg.message_info.message_id == think_id:
+                if (
+                    isinstance(msg, MessageThinking)
+                    and msg.message_info.message_id == think_id
+                ):
                     # print(f"找到思考消息: {msg}")
                     thinking_message = msg
                     container.messages.remove(msg)
@@ -354,79 +269,168 @@ class ChatBot:
                 chat_stream=chat, relationship_value=valuedict[emotion[0]]
             )
             # 使用情绪管理器更新情绪
-            self.mood_manager.update_mood_from_emotion(emotion[0], global_config.mood_intensity_factor)
+            self.mood_manager.update_mood_from_emotion(
+                emotion[0], global_config.mood_intensity_factor
+            )
 
             # willing_manager.change_reply_willing_after_sent(
             #     chat_stream=chat
             # )
 
-    async def directly_reply(self, raw_message: str, user_id: int, group_id: int):
-        """
-        直接回复发来的消息，不经过意愿管理器
-        """
+    async def handle_notice(self, event: NoticeEvent, bot: Bot) -> None:
+        """处理收到的通知"""
+        if isinstance(event, PokeNotifyEvent):
+            # 戳一戳 通知
+            # 不处理其他人的戳戳
+            if not event.is_tome():
+                return
 
-        # 构造用户信息和群组信息
-        user_info = UserInfo(
-            user_id=user_id,
-            user_nickname=get_user_nickname(user_id) or None,
-            user_cardname=get_user_cardname(user_id) or None,
-            platform="qq",
-        )
-        group_info = GroupInfo(group_id=group_id, group_name=None, platform="qq")
+            # 用户屏蔽,不区分私聊/群聊
+            if event.user_id in global_config.ban_user_id:
+                return
+
+            # 白名单模式
+            if event.group_id:
+                if event.group_id not in global_config.talk_allowed_groups:
+                    return
+
+            raw_message = f"[戳了戳]{global_config.BOT_NICKNAME}"  # 默认类型
+            if info := event.raw_info:
+                poke_type = info[2].get(
+                    "txt", "戳了戳"
+                )  # 戳戳类型，例如“拍一拍”、“揉一揉”、“捏一捏”
+                custom_poke_message = info[4].get(
+                    "txt", ""
+                )  # 自定义戳戳消息，若不存在会为空字符串
+                raw_message = (
+                    f"[{poke_type}]{global_config.BOT_NICKNAME}{custom_poke_message}"
+                )
+
+                raw_message += "（这是一个类似摸摸头的友善行为，而不是恶意行为，请不要作出攻击发言）"
+
+            user_info = UserInfo(
+                user_id=event.user_id,
+                user_nickname=(
+                    await bot.get_stranger_info(user_id=event.user_id, no_cache=True)
+                )["nickname"],
+                user_cardname=None,
+                platform="qq",
+            )
+
+            if event.group_id:
+                group_info = GroupInfo(
+                    group_id=event.group_id, group_name=None, platform="qq"
+                )
+            else:
+                group_info = None
+
+            message_cq = MessageRecvCQ(
+                message_id=0,
+                user_info=user_info,
+                raw_message=str(raw_message),
+                group_info=group_info,
+                reply_message=None,
+                platform="qq",
+            )
+
+            await self.message_process(message_cq)
+            
+        elif isinstance(event, GroupRecallNoticeEvent) or isinstance(
+            event, FriendRecallNoticeEvent
+        ):
+            user_info = UserInfo(
+                user_id=event.user_id,
+                user_nickname=get_user_nickname(event.user_id) or None,
+                user_cardname=get_user_cardname(event.user_id) or None,
+                platform="qq",
+            )
+
+            group_info = GroupInfo(
+                group_id=event.group_id, group_name=None, platform="qq"
+            )
+
+            chat = await chat_manager.get_or_create_stream(
+                platform=user_info.platform, user_info=user_info, group_info=group_info
+            )
+
+            await self.storage.store_recalled_message(
+                event.message_id, time.time(), chat
+            )
+
+    async def handle_message(self, event: MessageEvent, bot: Bot) -> None:
+        """处理收到的消息"""
+
+        self.bot = bot  # 更新 bot 实例
+
+        # 用户屏蔽,不区分私聊/群聊
+        if event.user_id in global_config.ban_user_id:
+            return
+
+        if (
+            event.reply
+            and hasattr(event.reply, "sender")
+            and hasattr(event.reply.sender, "user_id")
+            and event.reply.sender.user_id in global_config.ban_user_id
+        ):
+            logger.debug(
+                f"跳过处理回复来自被ban用户 {event.reply.sender.user_id} 的消息"
+            )
+            return
+        # 处理私聊消息
+        if isinstance(event, PrivateMessageEvent):
+            if not global_config.enable_friend_chat:  # 私聊过滤
+                return
+            else:
+                try:
+                    user_info = UserInfo(
+                        user_id=event.user_id,
+                        user_nickname=(
+                            await bot.get_stranger_info(
+                                user_id=event.user_id, no_cache=True
+                            )
+                        )["nickname"],
+                        user_cardname=None,
+                        platform="qq",
+                    )
+                except Exception as e:
+                    logger.error(f"获取陌生人信息失败: {e}")
+                    return
+                logger.debug(user_info)
+
+                # group_info = GroupInfo(group_id=0, group_name="私聊", platform="qq")
+                group_info = None
+
+        # 处理群聊消息
+        else:
+            # 白名单设定由nontbot侧完成
+            if event.group_id:
+                if event.group_id not in global_config.talk_allowed_groups:
+                    return
+
+            user_info = UserInfo(
+                user_id=event.user_id,
+                user_nickname=event.sender.nickname,
+                user_cardname=event.sender.card or None,
+                platform="qq",
+            )
+
+            group_info = GroupInfo(
+                group_id=event.group_id, group_name=None, platform="qq"
+            )
+
+        # group_info = await bot.get_group_info(group_id=event.group_id)
+        # sender_info = await bot.get_group_member_info(group_id=event.group_id, user_id=event.user_id, no_cache=True)
 
         message_cq = MessageRecvCQ(
-            message_id=None,
+            message_id=event.message_id,
             user_info=user_info,
-            raw_message=raw_message,
+            raw_message=str(event.original_message),
             group_info=group_info,
-            reply_message=None,
+            reply_message=event.reply,
             platform="qq",
         )
-        await message_cq.initialize()
-        message_json = message_cq.to_dict()
-
-        message = MessageRecv(message_json)
-        groupinfo = message.message_info.group_info
-        userinfo = message.message_info.user_info
-        messageinfo = message.message_info
-
-        chat = await chat_manager.get_or_create_stream(
-            platform=messageinfo.platform, user_info=userinfo, group_info=groupinfo
-        )
-        message.update_chat_stream(chat)
-        await message.process()
-
-        bot_user_info = UserInfo(
-            user_id=global_config.BOT_QQ,
-            user_nickname=global_config.BOT_NICKNAME,
-            platform=messageinfo.platform,
-        )
-
-        current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(messageinfo.time))
-        logger.info(
-            f"[{current_time}][{chat.group_info.group_name if chat.group_info else '私聊'}]{chat.user_info.user_nickname}:"
-            f"{message.processed_plain_text}"
-        )
-
-        # 使用大模型生成回复
-        response, raw_content = await self.gpt.generate_response(message)
-
-        if response:
-            for msg in response:
-                message_segment = Seg(type="text", data=msg)
-
-                bot_message = MessageSending(
-                    message_id=None,
-                    chat_stream=chat,
-                    bot_user_info=bot_user_info,
-                    sender_info=userinfo,
-                    message_segment=message_segment,
-                    reply=None,
-                    is_head=False,
-                    is_emoji=False,
-                )
-                message_manager.add_message(bot_message)
 
+        await self.message_process(message_cq)
 
 # 创建全局ChatBot实例
 chat_bot = ChatBot()

src/plugins/chat/config.py

@@ -73,6 +73,8 @@ class BotConfig:
     mood_update_interval: float = 1.0  # 情绪更新间隔 单位秒
     mood_decay_rate: float = 0.95  # 情绪衰减率
     mood_intensity_factor: float = 0.7  # 情绪强度因子
+    
+    willing_mode: str = "classical"  # 意愿模式
 
     keywords_reaction_rules = []  # 关键词回复规则
 
@@ -212,6 +214,10 @@ class BotConfig:
                 "model_r1_distill_probability", config.MODEL_R1_DISTILL_PROBABILITY
             )
             config.max_response_length = response_config.get("max_response_length", config.max_response_length)
+            
+        def willing(parent: dict):
+            willing_config = parent["willing"]
+            config.willing_mode = willing_config.get("willing_mode", config.willing_mode)
 
         def model(parent: dict):
             # 加载模型配置
@@ -353,6 +359,7 @@ class BotConfig:
             "cq_code": {"func": cq_code, "support": ">=0.0.0"},
             "bot": {"func": bot, "support": ">=0.0.0"},
             "response": {"func": response, "support": ">=0.0.0"},
+            "willing": {"func": willing, "support": ">=0.0.9", "necessary": False},
             "model": {"func": model, "support": ">=0.0.0"},
             "message": {"func": message, "support": ">=0.0.0"},
             "memory": {"func": memory, "support": ">=0.0.0", "necessary": False},

src/plugins/chat/message.py

@@ -160,7 +160,7 @@ class MessageRecv(Message):
         user_info = self.message_info.user_info
         name = (
             f"{user_info.user_nickname}(ta的昵称:{user_info.user_cardname},ta的id:{user_info.user_id})"
-            if user_info.user_cardname != ""
+            if user_info.user_cardname != None
             else f"{user_info.user_nickname}(ta的id:{user_info.user_id})"
         )
         return f"[{time_str}] {name}: {self.processed_plain_text}\n"
@@ -256,7 +256,7 @@ class MessageProcessBase(Message):
         user_info = self.message_info.user_info
         name = (
             f"{user_info.user_nickname}(ta的昵称:{user_info.user_cardname},ta的id:{user_info.user_id})"
-            if user_info.user_cardname != ""
+            if user_info.user_cardname != None
             else f"{user_info.user_nickname}(ta的id:{user_info.user_id})"
         )
         return f"[{time_str}] {name}: {self.processed_plain_text}\n"

src/plugins/chat/prompt_builder.py

@@ -1,7 +1,6 @@
 import random
 import time
 from typing import Optional
-from loguru import logger
 
 from ...common.database import db
 from ..memory_system.memory import hippocampus, memory_graph
@@ -11,6 +10,13 @@ from .config import global_config
 from .utils import get_embedding, get_recent_group_detailed_plain_text
 from .chat_stream import chat_manager
 
+from ..utils.logger_config import LogClassification, LogModule
+
+log_module = LogModule()
+logger = log_module.setup_logger(LogClassification.PBUILDER)
+
+logger.info("初始化Prompt系统")
+
 
 class PromptBuilder:
     def __init__(self):
@@ -185,18 +191,17 @@ class PromptBuilder:
 `</MainRule>`"""
 
         """读空气prompt处理"""
-        # activate_prompt_check = f"以上是群里正在进行的聊天，昵称为 '{sender_name}' 的用户说的:{message_txt}。引起了你的注意,你和他{relation_prompt}，你想要{relation_prompt_2}，但是这不一定是合适的时机，请你决定是否要回应这条消息。"
-        # prompt_personality_check = ""
-        # extra_check_info = f"请注意把握群里的聊天内容的基础上，综合群内的氛围，例如，和{global_config.BOT_NICKNAME}相关的话题要积极回复,如果是at自己的消息一定要回复，如果自己正在和别人聊天一定要回复，其他话题如果合适搭话也可以回复，如果认为应该回复请输出yes，否则输出no，请注意是决定是否需要回复，而不是编写回复内容，除了yes和no不要输出任何回复内容。"
-        # if personality_choice < probability_1:  # 第一种人格
-        #     prompt_personality_check = f"""你的网名叫{global_config.BOT_NICKNAME}，{personality[0]}, 你正在浏览qq群，{promt_info_prompt} {activate_prompt_check} {extra_check_info}"""
-        # elif personality_choice < probability_1 + probability_2:  # 第二种人格
-        #     prompt_personality_check = f"""你的网名叫{global_config.BOT_NICKNAME}，{personality[1]}, 你正在浏览qq群，{promt_info_prompt} {activate_prompt_check} {extra_check_info}"""
-        # else:  # 第三种人格
-        #     prompt_personality_check = f"""你的网名叫{global_config.BOT_NICKNAME}，{personality[2]}, 你正在浏览qq群，{promt_info_prompt} {activate_prompt_check} {extra_check_info}"""
-        #
-        # prompt_check_if_response = f"{prompt_info}\n{prompt_date}\n{chat_talking_prompt}\n{prompt_personality_check}"
-        prompt_check_if_response = ""
+        activate_prompt_check = f"以上是群里正在进行的聊天，昵称为 '{sender_name}' 的用户说的:{message_txt}。引起了你的注意,你和他{relation_prompt}，你想要{relation_prompt_2}，但是这不一定是合适的时机，请你决定是否要回应这条消息。"
+        prompt_personality_check = ""
+        extra_check_info = f"请注意把握群里的聊天内容的基础上，综合群内的氛围，例如，和{global_config.BOT_NICKNAME}相关的话题要积极回复,如果是at自己的消息一定要回复，如果自己正在和别人聊天一定要回复，其他话题如果合适搭话也可以回复，如果认为应该回复请输出yes，否则输出no，请注意是决定是否需要回复，而不是编写回复内容，除了yes和no不要输出任何回复内容。"
+        if personality_choice < probability_1:  # 第一种人格
+            prompt_personality_check = f"""你的网名叫{global_config.BOT_NICKNAME}，{personality[0]}, 你正在浏览qq群，{promt_info_prompt} {activate_prompt_check} {extra_check_info}"""
+        elif personality_choice < probability_1 + probability_2:  # 第二种人格
+            prompt_personality_check = f"""你的网名叫{global_config.BOT_NICKNAME}，{personality[1]}, 你正在浏览qq群，{promt_info_prompt} {activate_prompt_check} {extra_check_info}"""
+        else:  # 第三种人格
+            prompt_personality_check = f"""你的网名叫{global_config.BOT_NICKNAME}，{personality[2]}, 你正在浏览qq群，{promt_info_prompt} {activate_prompt_check} {extra_check_info}"""
+
+        prompt_check_if_response = f"{prompt_info}\n{prompt_date}\n{chat_talking_prompt}\n{prompt_personality_check}"
 
         return prompt, prompt_check_if_response
 
@@ -250,7 +255,7 @@ class PromptBuilder:
         return prompt_for_check, memory
 
     def _build_initiative_prompt(self, selected_node, prompt_regular, memory):
-        prompt_for_initiative = f"{prompt_regular}你现在想在群里发言，回忆了一下，想到一个话题,是{selected_node['concept']}，关于这个话题的记忆有\n{memory}\n，请在把握群里的聊天内容的基础上，综合群内的氛围，以日常且口语化的口吻，简短且随意一点进行发言，不要说的太有条理，可以有个性。记住不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)"
+        prompt_for_initiative = f"{prompt_regular}你现在想在群里发言，回忆了一下，想到一个话题,是{selected_node['concept']}，关于这个话题的记忆有\n{memory}\n，请在把握群里的聊天内容的基础上，综合群内的氛围，以日常且口语化的口吻，简短且随意一点进行发言，不要说的太有条理，可以有个性。记住不要输出多余内容(包括前后缀，冒号和引号，括号，表情,@等)"
         return prompt_for_initiative
 
     async def get_prompt_info(self, message: str, threshold: float):

src/plugins/chat/thinking_idea.py

@@ -1,14 +0,0 @@
-#Broca's Area
-# 功能：语言产生、语法处理和言语运动控制。
-# 损伤后果：布洛卡失语症（表达困难，但理解保留）。
-
-import time
-
-
-class Thinking_Idea:
-    def __init__(self, message_id: str):
-        self.messages = []  # 消息列表集合
-        self.current_thoughts = []  # 当前思考内容列表
-        self.time = time.time()  # 创建时间
-        self.id = str(int(time.time() * 1000))  # 使用时间戳生成唯一标识ID
-        

src/plugins/chat/willing_manager.py

@@ -1,259 +0,0 @@
-import asyncio
-import random
-import time
-from typing import Dict
-from loguru import logger
-
-
-from .config import global_config
-from .chat_stream import ChatStream
-
-
-class WillingManager:
-    def __init__(self):
-        self.chat_reply_willing: Dict[str, float] = {}  # 存储每个聊天流的回复意愿
-        self.chat_high_willing_mode: Dict[str, bool] = {}  # 存储每个聊天流是否处于高回复意愿期
-        self.chat_msg_count: Dict[str, int] = {}  # 存储每个聊天流接收到的消息数量
-        self.chat_last_mode_change: Dict[str, float] = {}  # 存储每个聊天流上次模式切换的时间
-        self.chat_high_willing_duration: Dict[str, int] = {}  # 高意愿期持续时间(秒)
-        self.chat_low_willing_duration: Dict[str, int] = {}  # 低意愿期持续时间(秒)
-        self.chat_last_reply_time: Dict[str, float] = {}  # 存储每个聊天流上次回复的时间
-        self.chat_last_sender_id: Dict[str, str] = {}  # 存储每个聊天流上次回复的用户ID
-        self.chat_conversation_context: Dict[str, bool] = {}  # 标记是否处于对话上下文中
-        self._decay_task = None
-        self._mode_switch_task = None
-        self._started = False
-        
-    async def _decay_reply_willing(self):
-        """定期衰减回复意愿"""
-        while True:
-            await asyncio.sleep(5)
-            for chat_id in self.chat_reply_willing:
-                is_high_mode = self.chat_high_willing_mode.get(chat_id, False)
-                if is_high_mode:
-                    # 高回复意愿期内轻微衰减
-                    self.chat_reply_willing[chat_id] = max(0.5, self.chat_reply_willing[chat_id] * 0.95)
-                else:
-                    # 低回复意愿期内正常衰减
-                    self.chat_reply_willing[chat_id] = max(0, self.chat_reply_willing[chat_id] * 0.8)
-                
-    async def _mode_switch_check(self):
-        """定期检查是否需要切换回复意愿模式"""
-        while True:
-            current_time = time.time()
-            await asyncio.sleep(10)  # 每10秒检查一次
-            
-            for chat_id in self.chat_high_willing_mode:
-                last_change_time = self.chat_last_mode_change.get(chat_id, 0)
-                is_high_mode = self.chat_high_willing_mode.get(chat_id, False)
-                
-                # 获取当前模式的持续时间
-                duration = 0
-                if is_high_mode:
-                    duration = self.chat_high_willing_duration.get(chat_id, 180)  # 默认3分钟
-                else:
-                    duration = self.chat_low_willing_duration.get(chat_id, random.randint(300, 1200))  # 默认5-20分钟
-                
-                # 检查是否需要切换模式
-                if current_time - last_change_time > duration:
-                    self._switch_willing_mode(chat_id)
-                elif not is_high_mode and random.random() < 0.1:
-                    # 低回复意愿期有10%概率随机切换到高回复期
-                    self._switch_willing_mode(chat_id)
-                
-                # 检查对话上下文状态是否需要重置
-                last_reply_time = self.chat_last_reply_time.get(chat_id, 0)
-                if current_time - last_reply_time > 300:  # 5分钟无交互，重置对话上下文
-                    self.chat_conversation_context[chat_id] = False
-    
-    def _switch_willing_mode(self, chat_id: str):
-        """切换聊天流的回复意愿模式"""
-        is_high_mode = self.chat_high_willing_mode.get(chat_id, False)
-        
-        if is_high_mode:
-            # 从高回复期切换到低回复期
-            self.chat_high_willing_mode[chat_id] = False
-            self.chat_reply_willing[chat_id] = 0.1  # 设置为最低回复意愿
-            self.chat_low_willing_duration[chat_id] = random.randint(600, 1200)  # 10-20分钟
-            logger.debug(f"聊天流 {chat_id} 切换到低回复意愿期，持续 {self.chat_low_willing_duration[chat_id]} 秒")
-        else:
-            # 从低回复期切换到高回复期
-            self.chat_high_willing_mode[chat_id] = True
-            self.chat_reply_willing[chat_id] = 1.0  # 设置为较高回复意愿
-            self.chat_high_willing_duration[chat_id] = random.randint(180, 240)  # 3-4分钟
-            logger.debug(f"聊天流 {chat_id} 切换到高回复意愿期，持续 {self.chat_high_willing_duration[chat_id]} 秒")
-        
-        self.chat_last_mode_change[chat_id] = time.time()
-        self.chat_msg_count[chat_id] = 0  # 重置消息计数
-                
-    def get_willing(self, chat_stream: ChatStream) -> float:
-        """获取指定聊天流的回复意愿"""
-        stream = chat_stream
-        if stream:
-            return self.chat_reply_willing.get(stream.stream_id, 0)
-        return 0
-    
-    def set_willing(self, chat_id: str, willing: float):
-        """设置指定聊天流的回复意愿"""
-        self.chat_reply_willing[chat_id] = willing
-        
-    def _ensure_chat_initialized(self, chat_id: str):
-        """确保聊天流的所有数据已初始化"""
-        if chat_id not in self.chat_reply_willing:
-            self.chat_reply_willing[chat_id] = 0.1
-        
-        if chat_id not in self.chat_high_willing_mode:
-            self.chat_high_willing_mode[chat_id] = False
-            self.chat_last_mode_change[chat_id] = time.time()
-            self.chat_low_willing_duration[chat_id] = random.randint(300, 1200)  # 5-20分钟
-        
-        if chat_id not in self.chat_msg_count:
-            self.chat_msg_count[chat_id] = 0
-            
-        if chat_id not in self.chat_conversation_context:
-            self.chat_conversation_context[chat_id] = False
-        
-    async def change_reply_willing_received(self, 
-                                          chat_stream: ChatStream,
-                                          topic: str = None,
-                                          is_mentioned_bot: bool = False,
-                                          config = None,
-                                          is_emoji: bool = False,
-                                          interested_rate: float = 0,
-                                          sender_id: str = None) -> float:
-        """改变指定聊天流的回复意愿并返回回复概率"""
-        # 获取或创建聊天流
-        stream = chat_stream
-        chat_id = stream.stream_id
-        current_time = time.time()
-        
-        self._ensure_chat_initialized(chat_id)
-        
-        # 增加消息计数
-        self.chat_msg_count[chat_id] = self.chat_msg_count.get(chat_id, 0) + 1
-        
-        current_willing = self.chat_reply_willing.get(chat_id, 0)
-        is_high_mode = self.chat_high_willing_mode.get(chat_id, False)
-        msg_count = self.chat_msg_count.get(chat_id, 0)
-        in_conversation_context = self.chat_conversation_context.get(chat_id, False)
-        
-        # 检查是否是对话上下文中的追问
-        last_reply_time = self.chat_last_reply_time.get(chat_id, 0)
-        last_sender = self.chat_last_sender_id.get(chat_id, "")
-        is_follow_up_question = False
-        
-        # 如果是同一个人在短时间内（2分钟内）发送消息，且消息数量较少（<=5条），视为追问
-        if sender_id and sender_id == last_sender and current_time - last_reply_time < 120 and msg_count <= 5:
-            is_follow_up_question = True
-            in_conversation_context = True
-            self.chat_conversation_context[chat_id] = True
-            logger.debug(f"检测到追问 (同一用户), 提高回复意愿")
-            current_willing += 0.3
-        
-        # 特殊情况处理
-        if is_mentioned_bot:
-            current_willing += 0.5
-            in_conversation_context = True
-            self.chat_conversation_context[chat_id] = True
-            logger.debug(f"被提及, 当前意愿: {current_willing}")
-        
-        if is_emoji:
-            current_willing *= 0.1
-            logger.debug(f"表情包, 当前意愿: {current_willing}")
-        
-        # 根据话题兴趣度适当调整
-        if interested_rate > 0.5:
-            current_willing += (interested_rate - 0.5) * 0.5
-            
-        # 根据当前模式计算回复概率
-        base_probability = 0.0
-        
-        if in_conversation_context:
-            # 在对话上下文中，降低基础回复概率
-            base_probability = 0.5 if is_high_mode else 0.25
-            logger.debug(f"处于对话上下文中，基础回复概率: {base_probability}")
-        elif is_high_mode:
-            # 高回复周期：4-8句话有50%的概率会回复一次
-            base_probability = 0.50 if 4 <= msg_count <= 8 else 0.2
-        else:
-            # 低回复周期：需要最少15句才有30%的概率会回一句
-            base_probability = 0.30 if msg_count >= 15 else 0.03 * min(msg_count, 10)
-            
-        # 考虑回复意愿的影响
-        reply_probability = base_probability * current_willing
-        
-        # 检查群组权限（如果是群聊）
-        if chat_stream.group_info and config:               
-            if chat_stream.group_info.group_id in config.talk_frequency_down_groups:
-                reply_probability = reply_probability / global_config.down_frequency_rate
-
-        # 限制最大回复概率
-        reply_probability = min(reply_probability, 0.75)  # 设置最大回复概率为75%
-        if reply_probability < 0:
-            reply_probability = 0
-        
-        # 记录当前发送者ID以便后续追踪
-        if sender_id:
-            self.chat_last_sender_id[chat_id] = sender_id
-            
-        self.chat_reply_willing[chat_id] = min(current_willing, 3.0)
-        return reply_probability
-    
-    def change_reply_willing_sent(self, chat_stream: ChatStream):
-        """开始思考后降低聊天流的回复意愿"""
-        stream = chat_stream
-        if stream:
-            chat_id = stream.stream_id
-            self._ensure_chat_initialized(chat_id)
-            is_high_mode = self.chat_high_willing_mode.get(chat_id, False)
-            current_willing = self.chat_reply_willing.get(chat_id, 0)
-            
-            # 回复后减少回复意愿
-            self.chat_reply_willing[chat_id] = max(0, current_willing - 0.3)
-            
-            # 标记为对话上下文中
-            self.chat_conversation_context[chat_id] = True
-            
-            # 记录最后回复时间
-            self.chat_last_reply_time[chat_id] = time.time()
-            
-            # 重置消息计数
-            self.chat_msg_count[chat_id] = 0
-        
-    def change_reply_willing_not_sent(self, chat_stream: ChatStream):
-        """决定不回复后提高聊天流的回复意愿"""
-        stream = chat_stream
-        if stream:
-            chat_id = stream.stream_id
-            self._ensure_chat_initialized(chat_id)
-            is_high_mode = self.chat_high_willing_mode.get(chat_id, False)
-            current_willing = self.chat_reply_willing.get(chat_id, 0)
-            in_conversation_context = self.chat_conversation_context.get(chat_id, False)
-            
-            # 根据当前模式调整不回复后的意愿增加
-            if is_high_mode:
-                willing_increase = 0.1
-            elif in_conversation_context:
-                # 在对话上下文中但决定不回复，小幅增加回复意愿
-                willing_increase = 0.15
-            else:
-                willing_increase = random.uniform(0.05, 0.1)
-                
-            self.chat_reply_willing[chat_id] = min(2.0, current_willing + willing_increase)
-        
-    def change_reply_willing_after_sent(self, chat_stream: ChatStream):
-        """发送消息后提高聊天流的回复意愿"""
-        # 由于已经在sent中处理，这个方法保留但不再需要额外调整
-        pass
-        
-    async def ensure_started(self):
-        """确保所有任务已启动"""
-        if not self._started:
-            if self._decay_task is None:
-                self._decay_task = asyncio.create_task(self._decay_reply_willing())
-            if self._mode_switch_task is None:
-                self._mode_switch_task = asyncio.create_task(self._mode_switch_check())
-            self._started = True
-
-# 创建全局实例
-willing_manager = WillingManager()