Merge afc branch into dev, prioritizing afc changes and migrating database async modifications from dev

src/chat/message_receive/bot.py

@@ -11,11 +11,12 @@ from src.mood.mood_manager import mood_manager  # 导入情绪管理器
 from src.chat.message_receive.chat_stream import get_chat_manager, ChatStream
 from src.chat.message_receive.message import MessageRecv, MessageRecvS4U
 from src.chat.message_receive.storage import MessageStorage
-from src.chat.heart_flow.heartflow_message_processor import HeartFCMessageReceiver
+from src.chat.message_manager import message_manager
 from src.chat.utils.prompt import Prompt, global_prompt_manager
 from src.plugin_system.core import component_registry, event_manager, global_announcement_manager
 from src.plugin_system.base import BaseCommand, EventType
 from src.mais4u.mais4u_chat.s4u_msg_processor import S4UMessageProcessor
+from src.chat.utils.utils import is_mentioned_bot_in_message
 
 # 导入反注入系统
 from src.chat.antipromptinjector import initialize_anti_injector
@@ -73,15 +74,17 @@ class ChatBot:
         self.bot = None  # bot 实例引用
         self._started = False
         self.mood_manager = mood_manager  # 获取情绪管理器单例
-        self.heartflow_message_receiver = HeartFCMessageReceiver()  # 新增
+        # 亲和力流消息处理器 - 直接使用全局afc_manager
 
         self.s4u_message_processor = S4UMessageProcessor()
 
         # 初始化反注入系统
         self._initialize_anti_injector()
 
-    @staticmethod
-    def _initialize_anti_injector():
+        # 启动消息管理器
+        self._message_manager_started = False
+
+    def _initialize_anti_injector(self):
         """初始化反注入系统"""
         try:
             initialize_anti_injector()
@@ -99,10 +102,15 @@ class ChatBot:
         if not self._started:
             logger.debug("确保ChatBot所有任务已启动")
 
+            # 启动消息管理器
+            if not self._message_manager_started:
+                await message_manager.start()
+                self._message_manager_started = True
+                logger.info("消息管理器已启动")
+
             self._started = True
 
-    @staticmethod
-    async def _process_plus_commands(message: MessageRecv):
+    async def _process_plus_commands(self, message: MessageRecv):
         """独立处理PlusCommand系统"""
         try:
             text = message.processed_plain_text
@@ -182,7 +190,7 @@ class ChatBot:
             try:
                 # 检查聊天类型限制
                 if not plus_command_instance.is_chat_type_allowed():
-                    is_group = hasattr(message, "is_group_message") and message.is_group_message
+                    is_group = message.message_info.group_info                    
                     logger.info(
                         f"PlusCommand {plus_command_class.__name__} 不支持当前聊天类型: {'群聊' if is_group else '私聊'}"
                     )
@@ -222,8 +230,7 @@ class ChatBot:
             logger.error(f"处理PlusCommand时出错: {e}")
             return False, None, True  # 出错时继续处理消息
 
-    @staticmethod
-    async def _process_commands_with_new_system(message: MessageRecv):
+    async def _process_commands_with_new_system(self, message: MessageRecv):
         # sourcery skip: use-named-expression
         """使用新插件系统处理命令"""
         try:
@@ -256,7 +263,7 @@ class ChatBot:
                 try:
                     # 检查聊天类型限制
                     if not command_instance.is_chat_type_allowed():
-                        is_group = hasattr(message, "is_group_message") and message.is_group_message
+                        is_group = message.message_info.group_info
                         logger.info(
                             f"命令 {command_class.__name__} 不支持当前聊天类型: {'群聊' if is_group else '私聊'}"
                         )
@@ -313,8 +320,7 @@ class ChatBot:
 
         return False
 
-    @staticmethod
-    async def handle_adapter_response(message: MessageRecv):
+    async def handle_adapter_response(self, message: MessageRecv):
         """处理适配器命令响应"""
         try:
             from src.plugin_system.apis.send_api import put_adapter_response
@@ -354,19 +360,7 @@ class ChatBot:
         return
 
     async def message_process(self, message_data: Dict[str, Any]) -> None:
-        """处理转化后的统一格式消息
-        这个函数本质是预处理一些数据，根据配置信息和消息内容，预处理消息，并分发到合适的消息处理器中
-        heart_flow模式：使用思维流系统进行回复
-        - 包含思维流状态管理
-        - 在回复前进行观察和状态更新
-        - 回复后更新思维流状态
-        - 消息过滤
-        - 记忆激活
-        - 意愿计算
-        - 消息生成和发送
-        - 表情包处理
-        - 性能计时
-        """
+        """处理转化后的统一格式消息"""
         try:
             # 首先处理可能的切片消息重组
             from src.utils.message_chunker import reassembler
@@ -403,9 +397,7 @@ class ChatBot:
             # logger.debug(str(message_data))
             message = MessageRecv(message_data)
 
-            if await self.handle_notice_message(message):
-                ...
-
+            message.is_mentioned, _ = is_mentioned_bot_in_message(message)
             group_info = message.message_info.group_info
             user_info = message.message_info.user_info
             if message.message_info.additional_config:
@@ -415,6 +407,7 @@ class ChatBot:
                     return
 
             get_chat_manager().register_message(message)
+
             chat = await get_chat_manager().get_or_create_stream(
                 platform=message.message_info.platform,  # type: ignore
                 user_info=user_info,  # type: ignore
@@ -426,11 +419,14 @@ class ChatBot:
             # 处理消息内容，生成纯文本
             await message.process()
 
-            # 过滤检查 (在消息处理之后进行)
-            if _check_ban_words(
-                message.processed_plain_text, chat, user_info  # type: ignore
-            ) or _check_ban_regex(
-                message.processed_plain_text, chat, user_info  # type: ignore
+            # 在这里打印[所见]日志，确保在所有处理和过滤之前记录
+            logger.info(f"\u001b[38;5;118m{message.message_info.user_info.user_nickname}:{message.processed_plain_text}\u001b[0m")
+
+            # 过滤检查
+            if _check_ban_words(message.processed_plain_text, chat, user_info) or _check_ban_regex(  # type: ignore
+                message.raw_message,  # type: ignore
+                chat,
+                user_info,  # type: ignore
             ):
                 return
 
@@ -456,7 +452,8 @@ class ChatBot:
             result = await event_manager.trigger_event(EventType.ON_MESSAGE, permission_group="SYSTEM", message=message)
             if not result.all_continue_process():
                 raise UserWarning(f"插件{result.get_summary().get('stopped_handlers', '')}于消息到达时取消了消息处理")
-
+            
+            # TODO:暂不可用
             # 确认从接口发来的message是否有自定义的prompt模板信息
             if message.message_info.template_info and not message.message_info.template_info.template_default:
                 template_group_name: Optional[str] = message.message_info.template_info.template_name  # type: ignore
@@ -470,7 +467,55 @@ class ChatBot:
                 template_group_name = None
 
             async def preprocess():
-                await self.heartflow_message_receiver.process_message(message)
+                # 存储消息到数据库
+                from .storage import MessageStorage
+
+                try:
+                    await MessageStorage.store_message(message, message.chat_stream)
+                    logger.debug(f"消息已存储到数据库: {message.message_info.message_id}")
+                except Exception as e:
+                    logger.error(f"存储消息到数据库失败: {e}")
+                    traceback.print_exc()
+
+                # 使用消息管理器处理消息（保持原有功能）
+                from src.common.data_models.database_data_model import DatabaseMessages
+
+                # 创建数据库消息对象
+                db_message = DatabaseMessages(
+                    message_id=message.message_info.message_id,
+                    time=message.message_info.time,
+                    chat_id=message.chat_stream.stream_id,
+                    processed_plain_text=message.processed_plain_text,
+                    display_message=message.processed_plain_text,
+                    is_mentioned=message.is_mentioned,
+                    is_at=message.is_at,
+                    is_emoji=message.is_emoji,
+                    is_picid=message.is_picid,
+                    is_command=message.is_command,
+                    is_notify=message.is_notify,
+                    user_id=message.message_info.user_info.user_id,
+                    user_nickname=message.message_info.user_info.user_nickname,
+                    user_cardname=message.message_info.user_info.user_cardname,
+                    user_platform=message.message_info.user_info.platform,
+                    chat_info_stream_id=message.chat_stream.stream_id,
+                    chat_info_platform=message.chat_stream.platform,
+                    chat_info_create_time=message.chat_stream.create_time,
+                    chat_info_last_active_time=message.chat_stream.last_active_time,
+                    chat_info_user_id=message.chat_stream.user_info.user_id,
+                    chat_info_user_nickname=message.chat_stream.user_info.user_nickname,
+                    chat_info_user_cardname=message.chat_stream.user_info.user_cardname,
+                    chat_info_user_platform=message.chat_stream.user_info.platform,
+                )
+
+                # 如果是群聊，添加群组信息
+                if message.chat_stream.group_info:
+                    db_message.chat_info_group_id = message.chat_stream.group_info.group_id
+                    db_message.chat_info_group_name = message.chat_stream.group_info.group_name
+                    db_message.chat_info_group_platform = message.chat_stream.group_info.platform
+
+                # 添加消息到消息管理器
+                message_manager.add_message(message.chat_stream.stream_id, db_message)
+                logger.debug(f"消息已添加到消息管理器: {message.chat_stream.stream_id}")
 
             if template_group_name:
                 async with global_prompt_manager.async_message_scope(template_group_name):

src/chat/message_receive/chat_stream.py

@@ -25,43 +25,6 @@ install(extra_lines=3)
 logger = get_logger("chat_stream")
 
 
-class ChatMessageContext:
-    """聊天消息上下文，存储消息的上下文信息"""
-
-    def __init__(self, message: "MessageRecv"):
-        self.message = message
-
-    def get_template_name(self) -> Optional[str]:
-        """获取模板名称"""
-        if self.message.message_info.template_info and not self.message.message_info.template_info.template_default:
-            return self.message.message_info.template_info.template_name  # type: ignore
-        return None
-
-    def get_last_message(self) -> "MessageRecv":
-        """获取最后一条消息"""
-        return self.message
-
-    def check_types(self, types: list) -> bool:
-        # sourcery skip: invert-any-all, use-any, use-next
-        """检查消息类型"""
-        if not self.message.message_info.format_info.accept_format:  # type: ignore
-            return False
-        for t in types:
-            if t not in self.message.message_info.format_info.accept_format:  # type: ignore
-                return False
-        return True
-
-    def get_priority_mode(self) -> str:
-        """获取优先级模式"""
-        return self.message.priority_mode
-
-    def get_priority_info(self) -> Optional[dict]:
-        """获取优先级信息"""
-        if hasattr(self.message, "priority_info") and self.message.priority_info:
-            return self.message.priority_info
-        return None
-
-
 class ChatStream:
     """聊天流对象，存储一个完整的聊天上下文"""
 
@@ -79,14 +42,24 @@ class ChatStream:
         self.group_info = group_info
         self.create_time = data.get("create_time", time.time()) if data else time.time()
         self.last_active_time = data.get("last_active_time", self.create_time) if data else self.create_time
-        self.energy_value = data.get("energy_value", 5.0) if data else 5.0
         self.sleep_pressure = data.get("sleep_pressure", 0.0) if data else 0.0
         self.saved = False
-        self.context: ChatMessageContext = None  # type: ignore # 用于存储该聊天的上下文信息
-        # 从配置文件中读取focus_value，如果没有则使用默认值1.0
-        self.focus_energy = data.get("focus_energy", global_config.chat.focus_value) if data else global_config.chat.focus_value
+
+        # 使用StreamContext替代ChatMessageContext
+        from src.common.data_models.message_manager_data_model import StreamContext
+        from src.plugin_system.base.component_types import ChatType, ChatMode
+
+        self.stream_context: StreamContext = StreamContext(
+            stream_id=stream_id, chat_type=ChatType.GROUP if group_info else ChatType.PRIVATE, chat_mode=ChatMode.NORMAL
+        )
+
+        # 基础参数
+        self.base_interest_energy = 0.5  # 默认基础兴趣度
+        self._focus_energy = 0.5  # 内部存储的focus_energy值
         self.no_reply_consecutive = 0
-        self.breaking_accumulated_interest = 0.0
+
+        # 自动加载历史消息
+        self._load_history_messages()
 
     def to_dict(self) -> dict:
         """转换为字典格式"""
@@ -97,10 +70,15 @@ class ChatStream:
             "group_info": self.group_info.to_dict() if self.group_info else None,
             "create_time": self.create_time,
             "last_active_time": self.last_active_time,
-            "energy_value": self.energy_value,
             "sleep_pressure": self.sleep_pressure,
             "focus_energy": self.focus_energy,
-            "breaking_accumulated_interest": self.breaking_accumulated_interest,
+            # 基础兴趣度
+            "base_interest_energy": self.base_interest_energy,
+            # 新增stream_context信息
+            "stream_context_chat_type": self.stream_context.chat_type.value,
+            "stream_context_chat_mode": self.stream_context.chat_mode.value,
+            # 新增interruption_count信息
+            "interruption_count": self.stream_context.interruption_count,
         }
 
     @classmethod
@@ -109,7 +87,7 @@ class ChatStream:
         user_info = UserInfo.from_dict(data.get("user_info", {})) if data.get("user_info") else None
         group_info = GroupInfo.from_dict(data.get("group_info", {})) if data.get("group_info") else None
 
-        return cls(
+        instance = cls(
             stream_id=data["stream_id"],
             platform=data["platform"],
             user_info=user_info,  # type: ignore
@@ -117,6 +95,22 @@ class ChatStream:
             data=data,
         )
 
+        # 恢复stream_context信息
+        if "stream_context_chat_type" in data:
+            from src.plugin_system.base.component_types import ChatType, ChatMode
+
+            instance.stream_context.chat_type = ChatType(data["stream_context_chat_type"])
+        if "stream_context_chat_mode" in data:
+            from src.plugin_system.base.component_types import ChatType, ChatMode
+
+            instance.stream_context.chat_mode = ChatMode(data["stream_context_chat_mode"])
+
+        # 恢复interruption_count信息
+        if "interruption_count" in data:
+            instance.stream_context.interruption_count = data["interruption_count"]
+
+        return instance
+
     def update_active_time(self):
         """更新最后活跃时间"""
         self.last_active_time = time.time()
@@ -124,7 +118,312 @@ class ChatStream:
 
     def set_context(self, message: "MessageRecv"):
         """设置聊天消息上下文"""
-        self.context = ChatMessageContext(message)
+        # 将MessageRecv转换为DatabaseMessages并设置到stream_context
+        from src.common.data_models.database_data_model import DatabaseMessages
+        import json
+
+        # 安全获取message_info中的数据
+        message_info = getattr(message, "message_info", {})
+        user_info = getattr(message_info, "user_info", {})
+        group_info = getattr(message_info, "group_info", {})
+
+        # 提取reply_to信息（从message_segment中查找reply类型的段）
+        reply_to = None
+        if hasattr(message, "message_segment") and message.message_segment:
+            reply_to = self._extract_reply_from_segment(message.message_segment)
+
+        # 完整的数据转移逻辑
+        db_message = DatabaseMessages(
+            # 基础消息信息
+            message_id=getattr(message, "message_id", ""),
+            time=getattr(message, "time", time.time()),
+            chat_id=self._generate_chat_id(message_info),
+            reply_to=reply_to,
+            # 兴趣度相关
+            interest_value=getattr(message, "interest_value", 0.0),
+            # 关键词
+            key_words=json.dumps(getattr(message, "key_words", []), ensure_ascii=False)
+            if getattr(message, "key_words", None)
+            else None,
+            key_words_lite=json.dumps(getattr(message, "key_words_lite", []), ensure_ascii=False)
+            if getattr(message, "key_words_lite", None)
+            else None,
+            # 消息状态标记
+            is_mentioned=getattr(message, "is_mentioned", None),
+            is_at=getattr(message, "is_at", False),
+            is_emoji=getattr(message, "is_emoji", False),
+            is_picid=getattr(message, "is_picid", False),
+            is_voice=getattr(message, "is_voice", False),
+            is_video=getattr(message, "is_video", False),
+            is_command=getattr(message, "is_command", False),
+            is_notify=getattr(message, "is_notify", False),
+            # 消息内容
+            processed_plain_text=getattr(message, "processed_plain_text", ""),
+            display_message=getattr(message, "processed_plain_text", ""),  # 默认使用processed_plain_text
+            # 优先级信息
+            priority_mode=getattr(message, "priority_mode", None),
+            priority_info=json.dumps(getattr(message, "priority_info", None))
+            if getattr(message, "priority_info", None)
+            else None,
+            # 额外配置
+            additional_config=getattr(message_info, "additional_config", None),
+            # 用户信息
+            user_id=str(getattr(user_info, "user_id", "")),
+            user_nickname=getattr(user_info, "user_nickname", ""),
+            user_cardname=getattr(user_info, "user_cardname", None),
+            user_platform=getattr(user_info, "platform", ""),
+            # 群组信息
+            chat_info_group_id=getattr(group_info, "group_id", None),
+            chat_info_group_name=getattr(group_info, "group_name", None),
+            chat_info_group_platform=getattr(group_info, "platform", None),
+            # 聊天流信息
+            chat_info_user_id=str(getattr(user_info, "user_id", "")),
+            chat_info_user_nickname=getattr(user_info, "user_nickname", ""),
+            chat_info_user_cardname=getattr(user_info, "user_cardname", None),
+            chat_info_user_platform=getattr(user_info, "platform", ""),
+            chat_info_stream_id=self.stream_id,
+            chat_info_platform=self.platform,
+            chat_info_create_time=self.create_time,
+            chat_info_last_active_time=self.last_active_time,
+            # 新增兴趣度系统字段 - 添加安全处理
+            actions=self._safe_get_actions(message),
+            should_reply=getattr(message, "should_reply", False),
+        )
+
+        self.stream_context.set_current_message(db_message)
+        self.stream_context.priority_mode = getattr(message, "priority_mode", None)
+        self.stream_context.priority_info = getattr(message, "priority_info", None)
+
+        # 调试日志：记录数据转移情况
+        logger.debug(f"消息数据转移完成 - message_id: {db_message.message_id}, "
+                    f"chat_id: {db_message.chat_id}, "
+                    f"is_mentioned: {db_message.is_mentioned}, "
+                    f"is_emoji: {db_message.is_emoji}, "
+                    f"is_picid: {db_message.is_picid}, "
+                    f"interest_value: {db_message.interest_value}")
+
+    def _safe_get_actions(self, message: "MessageRecv") -> Optional[list]:
+        """安全获取消息的actions字段"""
+        try:
+            actions = getattr(message, "actions", None)
+            if actions is None:
+                return None
+
+            # 如果是字符串，尝试解析为JSON
+            if isinstance(actions, str):
+                try:
+                    import json
+                    actions = json.loads(actions)
+                except json.JSONDecodeError:
+                    logger.warning(f"无法解析actions JSON字符串: {actions}")
+                    return None
+
+            # 确保返回列表类型
+            if isinstance(actions, list):
+                # 过滤掉空值和非字符串元素
+                filtered_actions = [action for action in actions if action is not None and isinstance(action, str)]
+                return filtered_actions if filtered_actions else None
+            else:
+                logger.warning(f"actions字段类型不支持: {type(actions)}")
+                return None
+
+        except Exception as e:
+            logger.warning(f"获取actions字段失败: {e}")
+            return None
+
+    def _extract_reply_from_segment(self, segment) -> Optional[str]:
+        """从消息段中提取reply_to信息"""
+        try:
+            if hasattr(segment, "type") and segment.type == "seglist":
+                # 递归搜索seglist中的reply段
+                if hasattr(segment, "data") and segment.data:
+                    for seg in segment.data:
+                        reply_id = self._extract_reply_from_segment(seg)
+                        if reply_id:
+                            return reply_id
+            elif hasattr(segment, "type") and segment.type == "reply":
+                # 找到reply段，返回message_id
+                return str(segment.data) if segment.data else None
+        except Exception as e:
+            logger.warning(f"提取reply_to信息失败: {e}")
+        return None
+
+    def _generate_chat_id(self, message_info) -> str:
+        """生成chat_id，基于群组或用户信息"""
+        try:
+            group_info = getattr(message_info, "group_info", None)
+            user_info = getattr(message_info, "user_info", None)
+
+            if group_info and hasattr(group_info, "group_id") and group_info.group_id:
+                # 群聊：使用群组ID
+                return f"{self.platform}_{group_info.group_id}"
+            elif user_info and hasattr(user_info, "user_id") and user_info.user_id:
+                # 私聊：使用用户ID
+                return f"{self.platform}_{user_info.user_id}_private"
+            else:
+                # 默认：使用stream_id
+                return self.stream_id
+        except Exception as e:
+            logger.warning(f"生成chat_id失败: {e}")
+            return self.stream_id
+
+    @property
+    def focus_energy(self) -> float:
+        """使用重构后的能量管理器计算focus_energy"""
+        try:
+            from src.chat.energy_system import energy_manager
+
+            # 获取所有消息
+            history_messages = self.stream_context.get_history_messages(limit=global_config.chat.max_context_size)
+            unread_messages = self.stream_context.get_unread_messages()
+            all_messages = history_messages + unread_messages
+
+            # 获取用户ID
+            user_id = None
+            if self.user_info and hasattr(self.user_info, "user_id"):
+                user_id = str(self.user_info.user_id)
+
+            # 使用能量管理器计算
+            energy = energy_manager.calculate_focus_energy(
+                stream_id=self.stream_id,
+                messages=all_messages,
+                user_id=user_id
+            )
+
+            # 更新内部存储
+            self._focus_energy = energy
+
+            logger.debug(f"聊天流 {self.stream_id} 能量: {energy:.3f}")
+            return energy
+
+        except Exception as e:
+            logger.error(f"获取focus_energy失败: {e}", exc_info=True)
+            # 返回缓存的值或默认值
+            if hasattr(self, '_focus_energy'):
+                return self._focus_energy
+            else:
+                return 0.5
+
+    @focus_energy.setter
+    def focus_energy(self, value: float):
+        """设置focus_energy值（主要用于初始化或特殊场景）"""
+        self._focus_energy = max(0.0, min(1.0, value))
+
+    def _get_user_relationship_score(self) -> float:
+        """获取用户关系分"""
+        # 使用插件内部的兴趣度评分系统
+        try:
+            from src.plugins.built_in.affinity_flow_chatter.interest_scoring import chatter_interest_scoring_system
+
+            if self.user_info and hasattr(self.user_info, "user_id"):
+                user_id = str(self.user_info.user_id)
+                relationship_score = chatter_interest_scoring_system._calculate_relationship_score(user_id)
+                logger.debug(f"ChatStream {self.stream_id}: 用户关系分 = {relationship_score:.3f}")
+                return max(0.0, min(1.0, relationship_score))
+
+        except Exception as e:
+            logger.warning(f"ChatStream {self.stream_id}: 插件内部关系分计算失败: {e}")
+
+        # 默认基础分
+        return 0.3
+
+    def _load_history_messages(self):
+        """从数据库加载历史消息到StreamContext"""
+        try:
+            from src.common.database.sqlalchemy_models import Messages
+            from src.common.database.sqlalchemy_database_api import get_db_session
+            from src.common.data_models.database_data_model import DatabaseMessages
+            from sqlalchemy import select, desc
+            import asyncio
+
+            async def _load_messages():
+                def _db_query():
+                    with get_db_session() as session:
+                        # 查询该stream_id的最近20条消息
+                        stmt = (
+                            select(Messages)
+                            .where(Messages.chat_info_stream_id == self.stream_id)
+                            .order_by(desc(Messages.time))
+                            .limit(global_config.chat.max_context_size)
+                        )
+                        results = session.execute(stmt).scalars().all()
+                        return results
+
+                # 在线程中执行数据库查询
+                db_messages = await asyncio.to_thread(_db_query)
+
+                # 转换为DatabaseMessages对象并添加到StreamContext
+                for db_msg in db_messages:
+                    try:
+                        # 从SQLAlchemy模型转换为DatabaseMessages数据模型
+                        import orjson
+
+                        # 解析actions字段（JSON格式）
+                        actions = None
+                        if db_msg.actions:
+                            try:
+                                actions = orjson.loads(db_msg.actions)
+                            except (orjson.JSONDecodeError, TypeError):
+                                actions = None
+
+                        db_message = DatabaseMessages(
+                            message_id=db_msg.message_id,
+                            time=db_msg.time,
+                            chat_id=db_msg.chat_id,
+                            reply_to=db_msg.reply_to,
+                            interest_value=db_msg.interest_value,
+                            key_words=db_msg.key_words,
+                            key_words_lite=db_msg.key_words_lite,
+                            is_mentioned=db_msg.is_mentioned,
+                            processed_plain_text=db_msg.processed_plain_text,
+                            display_message=db_msg.display_message,
+                            priority_mode=db_msg.priority_mode,
+                            priority_info=db_msg.priority_info,
+                            additional_config=db_msg.additional_config,
+                            is_emoji=db_msg.is_emoji,
+                            is_picid=db_msg.is_picid,
+                            is_command=db_msg.is_command,
+                            is_notify=db_msg.is_notify,
+                            user_id=db_msg.user_id,
+                            user_nickname=db_msg.user_nickname,
+                            user_cardname=db_msg.user_cardname,
+                            user_platform=db_msg.user_platform,
+                            chat_info_group_id=db_msg.chat_info_group_id,
+                            chat_info_group_name=db_msg.chat_info_group_name,
+                            chat_info_group_platform=db_msg.chat_info_group_platform,
+                            chat_info_user_id=db_msg.chat_info_user_id,
+                            chat_info_user_nickname=db_msg.chat_info_user_nickname,
+                            chat_info_user_cardname=db_msg.chat_info_user_cardname,
+                            chat_info_user_platform=db_msg.chat_info_user_platform,
+                            chat_info_stream_id=db_msg.chat_info_stream_id,
+                            chat_info_platform=db_msg.chat_info_platform,
+                            chat_info_create_time=db_msg.chat_info_create_time,
+                            chat_info_last_active_time=db_msg.chat_info_last_active_time,
+                            actions=actions,
+                            should_reply=getattr(db_msg, "should_reply", False) or False,
+                        )
+
+                        # 添加调试日志：检查从数据库加载的interest_value
+                        logger.debug(f"加载历史消息 {db_message.message_id} - interest_value: {db_message.interest_value}")
+
+                        # 标记为已读并添加到历史消息
+                        db_message.is_read = True
+                        self.stream_context.history_messages.append(db_message)
+
+                    except Exception as e:
+                        logger.warning(f"转换消息 {db_msg.message_id} 失败: {e}")
+                        continue
+
+                if self.stream_context.history_messages:
+                    logger.info(
+                        f"已从数据库加载 {len(self.stream_context.history_messages)} 条历史消息到聊天流 {self.stream_id}"
+                    )
+
+            # 创建任务来加载历史消息
+            asyncio.create_task(_load_messages())
+
+        except Exception as e:
+            logger.error(f"加载历史消息失败: {e}")
 
 
 class ChatManager:
@@ -362,7 +661,16 @@ class ChatManager:
                     "group_name": group_info_d["group_name"] if group_info_d else "",
                     "energy_value": s_data_dict.get("energy_value", 5.0),
                     "sleep_pressure": s_data_dict.get("sleep_pressure", 0.0),
-                    "focus_energy": s_data_dict.get("focus_energy", global_config.chat.focus_value),
+                    "focus_energy": s_data_dict.get("focus_energy", 0.5),
+                    # 新增动态兴趣度系统字段
+                    "base_interest_energy": s_data_dict.get("base_interest_energy", 0.5),
+                    "message_interest_total": s_data_dict.get("message_interest_total", 0.0),
+                    "message_count": s_data_dict.get("message_count", 0),
+                    "action_count": s_data_dict.get("action_count", 0),
+                    "reply_count": s_data_dict.get("reply_count", 0),
+                    "last_interaction_time": s_data_dict.get("last_interaction_time", time.time()),
+                    "consecutive_no_reply": s_data_dict.get("consecutive_no_reply", 0),
+                    "interruption_count": s_data_dict.get("interruption_count", 0),
                 }
                 if global_config.database.database_type == "sqlite":
                     stmt = sqlite_insert(ChatStreams).values(stream_id=s_data_dict["stream_id"], **fields_to_save)
@@ -419,7 +727,17 @@ class ChatManager:
                         "last_active_time": model_instance.last_active_time,
                         "energy_value": model_instance.energy_value,
                         "sleep_pressure": model_instance.sleep_pressure,
-                        "focus_energy": getattr(model_instance, "focus_energy", global_config.chat.focus_value),
+                        "focus_energy": getattr(model_instance, "focus_energy", 0.5),
+                        # 新增动态兴趣度系统字段 - 使用getattr提供默认值
+                        "base_interest_energy": getattr(model_instance, "base_interest_energy", 0.5),
+                        "message_interest_total": getattr(model_instance, "message_interest_total", 0.0),
+                        "message_count": getattr(model_instance, "message_count", 0),
+                        "action_count": getattr(model_instance, "action_count", 0),
+                        "reply_count": getattr(model_instance, "reply_count", 0),
+                        "last_interaction_time": getattr(model_instance, "last_interaction_time", time.time()),
+                        "relationship_score": getattr(model_instance, "relationship_score", 0.3),
+                        "consecutive_no_reply": getattr(model_instance, "consecutive_no_reply", 0),
+                        "interruption_count": getattr(model_instance, "interruption_count", 0),
                     }
                     loaded_streams_data.append(data_for_from_dict)
                 await session.commit()

src/chat/message_receive/message.py

@@ -123,7 +123,7 @@ class MessageRecv(Message):
         self.is_video = False
         self.is_mentioned = None
         self.is_notify = False
-
+        self.is_at = False
         self.is_command = False
 
         self.priority_mode = "interest"

src/chat/message_receive/storage.py

@@ -1,14 +1,14 @@
 import re
 import traceback
+import orjson
 from typing import Union
 
-import orjson
-from sqlalchemy import select, desc, update
-
-from src.common.database.sqlalchemy_models import Messages, Images, get_db_session
+from src.common.database.sqlalchemy_models import Messages, Images
 from src.common.logger import get_logger
 from .chat_stream import ChatStream
 from .message import MessageSending, MessageRecv
+from src.common.database.sqlalchemy_database_api import get_db_session
+from sqlalchemy import select, update, desc
 
 logger = get_logger("message_storage")
 
@@ -41,7 +41,7 @@ class MessageStorage:
             processed_plain_text = message.processed_plain_text
 
             if processed_plain_text:
-                processed_plain_text = await MessageStorage.replace_image_descriptions(processed_plain_text)
+                processed_plain_text = MessageStorage.replace_image_descriptions(processed_plain_text)
                 filtered_processed_plain_text = re.sub(pattern, "", processed_plain_text, flags=re.DOTALL)
             else:
                 filtered_processed_plain_text = ""
@@ -51,7 +51,8 @@ class MessageStorage:
                 if display_message:
                     filtered_display_message = re.sub(pattern, "", display_message, flags=re.DOTALL)
                 else:
-                    filtered_display_message = ""
+                    # 如果没有设置display_message，使用processed_plain_text作为显示消息
+                    filtered_display_message = re.sub(pattern, "", message.processed_plain_text, flags=re.DOTALL) if message.processed_plain_text else ""
                 interest_value = 0
                 is_mentioned = False
                 reply_to = message.reply_to
@@ -116,14 +117,21 @@ class MessageStorage:
                 user_nickname=user_info_dict.get("user_nickname"),
                 user_cardname=user_info_dict.get("user_cardname"),
                 processed_plain_text=filtered_processed_plain_text,
+                display_message=filtered_display_message,
+                memorized_times=message.memorized_times,
+                interest_value=interest_value,
                 priority_mode=priority_mode,
                 priority_info=priority_info_json,
                 is_emoji=is_emoji,
                 is_picid=is_picid,
+                is_notify=is_notify,
+                is_command=is_command,
+                key_words=key_words,
+                key_words_lite=key_words_lite,
             )
-            async with get_db_session() as session:
+            with get_db_session() as session:
                 session.add(new_message)
-                await session.commit()
+                session.commit()
 
         except Exception:
             logger.exception("存储消息失败")
@@ -146,7 +154,8 @@ class MessageStorage:
                 qq_message_id = message.message_segment.data.get("id")
             elif message.message_segment.type == "reply":
                 qq_message_id = message.message_segment.data.get("id")
-                logger.debug(f"从reply消息段获取到消息ID: {qq_message_id}")
+                if qq_message_id:
+                    logger.debug(f"从reply消息段获取到消息ID: {qq_message_id}")
             elif message.message_segment.type == "adapter_response":
                 logger.debug("适配器响应消息，不需要更新ID")
                 return
@@ -162,19 +171,18 @@ class MessageStorage:
                 logger.debug(f"消息段数据: {message.message_segment.data}")
                 return
 
-            async with get_db_session() as session:
-                matched_message = (
-                    await session.execute(
-                        select(Messages).where(Messages.message_id == mmc_message_id).order_by(desc(Messages.time))
-                    )
+            # 使用上下文管理器确保session正确管理
+            from src.common.database.sqlalchemy_models import get_db_session
+
+            with get_db_session() as session:
+                matched_message = session.execute(
+                    select(Messages).where(Messages.message_id == mmc_message_id).order_by(desc(Messages.time))
                 ).scalar()
 
                 if matched_message:
-                    await session.execute(
+                    session.execute(
                         update(Messages).where(Messages.id == matched_message.id).values(message_id=qq_message_id)
                     )
-                    await session.commit()
-                    #  会在上下文管理器中自动调用
                     logger.debug(f"更新消息ID成功: {matched_message.message_id} -> {qq_message_id}")
                 else:
                     logger.warning(f"未找到匹配的消息记录: {mmc_message_id}")
@@ -186,36 +194,117 @@ class MessageStorage:
                 f"segment_type={getattr(message.message_segment, 'type', 'N/A')}"
             )
 
-    async def replace_image_descriptions(text: str) -> str:
+    @staticmethod
+    def replace_image_descriptions(text: str) -> str:
         """将[图片：描述]替换为[picid:image_id]"""
         # 先检查文本中是否有图片标记
         pattern = r"\[图片：([^\]]+)\]"
-        matches = list(re.finditer(pattern, text))
+        matches = re.findall(pattern, text)
 
         if not matches:
             logger.debug("文本中没有图片标记，直接返回原文本")
             return text
 
-        new_text = ""
-        last_end = 0
-        for match in matches:
-            new_text += text[last_end : match.start()]
+        def replace_match(match):
             description = match.group(1).strip()
             try:
                 from src.common.database.sqlalchemy_models import get_db_session
 
-                async with get_db_session() as session:
-                    image_record = (
-                        await session.execute(
-                            select(Images).where(Images.description == description).order_by(desc(Images.timestamp))
-                        )
+                with get_db_session() as session:
+                    image_record = session.execute(
+                        select(Images).where(Images.description == description).order_by(desc(Images.timestamp))
                     ).scalar()
-                    if image_record:
-                        new_text += f"[picid:{image_record.image_id}]"
-                    else:
-                        new_text += match.group(0)
+                    return f"[picid:{image_record.image_id}]" if image_record else match.group(0)
             except Exception:
-                new_text += match.group(0)
-            last_end = match.end()
-        new_text += text[last_end:]
-        return new_text
+                return match.group(0)
+
+    @staticmethod
+    def update_message_interest_value(message_id: str, interest_value: float) -> None:
+        """
+        更新数据库中消息的interest_value字段
+
+        Args:
+            message_id: 消息ID
+            interest_value: 兴趣度值
+        """
+        try:
+            with get_db_session() as session:
+                # 更新消息的interest_value字段
+                stmt = update(Messages).where(Messages.message_id == message_id).values(interest_value=interest_value)
+                result = session.execute(stmt)
+                session.commit()
+
+                if result.rowcount > 0:
+                    logger.debug(f"成功更新消息 {message_id} 的interest_value为 {interest_value}")
+                else:
+                    logger.warning(f"未找到消息 {message_id}，无法更新interest_value")
+
+        except Exception as e:
+            logger.error(f"更新消息 {message_id} 的interest_value失败: {e}")
+            raise
+
+    @staticmethod
+    def fix_zero_interest_values(chat_id: str, since_time: float) -> int:
+        """
+        修复指定聊天中interest_value为0或null的历史消息记录
+
+        Args:
+            chat_id: 聊天ID
+            since_time: 从指定时间开始修复（时间戳）
+
+        Returns:
+            修复的记录数量
+        """
+        try:
+            with get_db_session() as session:
+                from sqlalchemy import select, update
+                from src.common.database.sqlalchemy_models import Messages
+
+                # 查找需要修复的记录：interest_value为0、null或很小的值
+                query = select(Messages).where(
+                    (Messages.chat_id == chat_id) &
+                    (Messages.time >= since_time) &
+                    (
+                        (Messages.interest_value == 0) |
+                        (Messages.interest_value.is_(None)) |
+                        (Messages.interest_value < 0.1)
+                    )
+                ).limit(50)  # 限制每次修复的数量，避免性能问题
+
+                messages_to_fix = session.execute(query).scalars().all()
+                fixed_count = 0
+
+                for msg in messages_to_fix:
+                    # 为这些消息设置一个合理的默认兴趣度
+                    # 可以基于消息长度、内容或其他因素计算
+                    default_interest = 0.3  # 默认中等兴趣度
+
+                    # 如果消息内容较长，可能是重要消息，兴趣度稍高
+                    if hasattr(msg, 'processed_plain_text') and msg.processed_plain_text:
+                        text_length = len(msg.processed_plain_text)
+                        if text_length > 50:  # 长消息
+                            default_interest = 0.4
+                        elif text_length > 20:  # 中等长度消息
+                            default_interest = 0.35
+
+                    # 如果是被@的消息，兴趣度更高
+                    if getattr(msg, 'is_mentioned', False):
+                        default_interest = min(default_interest + 0.2, 0.8)
+
+                    # 执行更新
+                    update_stmt = update(Messages).where(
+                        Messages.message_id == msg.message_id
+                    ).values(interest_value=default_interest)
+
+                    result = session.execute(update_stmt)
+                    if result.rowcount > 0:
+                        fixed_count += 1
+                        logger.debug(f"修复消息 {msg.message_id} 的interest_value为 {default_interest}")
+
+                session.commit()
+                logger.info(f"共修复了 {fixed_count} 条历史消息的interest_value值")
+                return fixed_count
+
+        except Exception as e:
+            logger.error(f"修复历史消息interest_value失败: {e}")
+            return 0