refactor(memory): 移除废弃的记忆系统备份文件，优化消息管理器架构

移除了deprecated_backup目录下的所有废弃记忆系统文件，包括增强记忆适配器、钩子、集成层、重排序器、元数据索引、多阶段检索和向量存储等模块。同时优化了消息管理器，集成了批量数据库写入器、流缓存管理器和自适应流管理器，提升了系统性能和可维护性。

src/chat/message_receive/chat_stream.py

@@ -464,7 +464,7 @@ class ChatManager:
     async def get_or_create_stream(
         self, platform: str, user_info: UserInfo, group_info: GroupInfo | None = None
     ) -> ChatStream:
-        """获取或创建聊天流
+        """获取或创建聊天流 - 优化版本使用缓存管理器
 
         Args:
             platform: 平台标识
@@ -478,6 +478,31 @@ class ChatManager:
         try:
             stream_id = self._generate_stream_id(platform, user_info, group_info)
 
+            # 优先使用缓存管理器（优化版本）
+            try:
+                from src.chat.message_manager.stream_cache_manager import get_stream_cache_manager
+                cache_manager = get_stream_cache_manager()
+
+                if cache_manager.is_running:
+                    optimized_stream = await cache_manager.get_or_create_stream(
+                        stream_id=stream_id,
+                        platform=platform,
+                        user_info=user_info,
+                        group_info=group_info
+                    )
+
+                    # 设置消息上下文
+                    from .message import MessageRecv
+                    if stream_id in self.last_messages and isinstance(self.last_messages[stream_id], MessageRecv):
+                        optimized_stream.set_context(self.last_messages[stream_id])
+
+                    # 转换为原始ChatStream以保持兼容性
+                    return self._convert_to_original_stream(optimized_stream)
+
+            except Exception as e:
+                logger.debug(f"缓存管理器获取流失败，使用原始方法: {e}")
+
+            # 回退到原始方法
             # 检查内存中是否存在
             if stream_id in self.streams:
                 stream = self.streams[stream_id]
@@ -634,12 +659,35 @@ class ChatManager:
 
     @staticmethod
     async def _save_stream(stream: ChatStream):
-        """保存聊天流到数据库"""
+        """保存聊天流到数据库 - 优化版本使用异步批量写入"""
         if stream.saved:
             return
         stream_data_dict = stream.to_dict()
 
-        # 尝试使用数据库批量调度器
+        # 优先使用新的批量写入器
+        try:
+            from src.chat.message_manager.batch_database_writer import get_batch_writer
+
+            batch_writer = get_batch_writer()
+            if batch_writer.is_running:
+                success = await batch_writer.schedule_stream_update(
+                    stream_id=stream_data_dict["stream_id"],
+                    update_data=ChatManager._prepare_stream_data(stream_data_dict),
+                    priority=1  # 流更新的优先级
+                )
+                if success:
+                    stream.saved = True
+                    logger.debug(f"聊天流 {stream.stream_id} 通过批量写入器调度成功")
+                    return
+                else:
+                    logger.warning(f"批量写入器队列已满，使用原始方法: {stream.stream_id}")
+            else:
+                logger.debug(f"批量写入器未运行，使用原始方法: {stream.stream_id}")
+
+        except Exception as e:
+            logger.debug(f"批量写入器保存聊天流失败，使用原始方法: {e}")
+
+        # 尝试使用数据库批量调度器（回退方案1）
         try:
             from src.common.database.db_batch_scheduler import batch_update, get_batch_session
 
@@ -657,7 +705,7 @@ class ChatManager:
         except (ImportError, Exception) as e:
             logger.debug(f"批量调度器保存聊天流失败，使用原始方法: {e}")
 
-        # 回退到原始方法
+        # 回退到原始方法（最终方案）
         async def _db_save_stream_async(s_data_dict: dict):
             async with get_db_session() as session:
                 user_info_d = s_data_dict.get("user_info")
@@ -782,6 +830,46 @@ class ChatManager:
 chat_manager = None
 
 
+def _convert_to_original_stream(self, optimized_stream) -> "ChatStream":
+        """将OptimizedChatStream转换为原始ChatStream以保持兼容性"""
+        try:
+            # 创建原始ChatStream实例
+            original_stream = ChatStream(
+                stream_id=optimized_stream.stream_id,
+                platform=optimized_stream.platform,
+                user_info=optimized_stream._get_effective_user_info(),
+                group_info=optimized_stream._get_effective_group_info()
+            )
+
+            # 复制状态
+            original_stream.create_time = optimized_stream.create_time
+            original_stream.last_active_time = optimized_stream.last_active_time
+            original_stream.sleep_pressure = optimized_stream.sleep_pressure
+            original_stream.base_interest_energy = optimized_stream.base_interest_energy
+            original_stream._focus_energy = optimized_stream._focus_energy
+            original_stream.no_reply_consecutive = optimized_stream.no_reply_consecutive
+            original_stream.saved = optimized_stream.saved
+
+            # 复制上下文信息（如果存在）
+            if hasattr(optimized_stream, '_stream_context') and optimized_stream._stream_context:
+                original_stream.stream_context = optimized_stream._stream_context
+
+            if hasattr(optimized_stream, '_context_manager') and optimized_stream._context_manager:
+                original_stream.context_manager = optimized_stream._context_manager
+
+            return original_stream
+
+        except Exception as e:
+            logger.error(f"转换OptimizedChatStream失败: {e}")
+            # 如果转换失败，创建一个新的原始流
+            return ChatStream(
+                stream_id=optimized_stream.stream_id,
+                platform=optimized_stream.platform,
+                user_info=optimized_stream._get_effective_user_info(),
+                group_info=optimized_stream._get_effective_group_info()
+            )
+
+
 def get_chat_manager():
     global chat_manager
     if chat_manager is None:

src/chat/message_receive/optimized_chat_stream.py

@@ -0,0 +1,494 @@
+"""
+优化版聊天流 - 实现写时复制机制
+避免不必要的深拷贝开销，提升多流并发性能
+"""
+
+import asyncio
+import copy
+import hashlib
+import time
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+from maim_message import GroupInfo, UserInfo
+from rich.traceback import install
+
+from src.common.database.sqlalchemy_database_api import get_db_session
+from src.common.database.sqlalchemy_models import ChatStreams
+from src.common.logger import get_logger
+from src.config.config import global_config
+
+if TYPE_CHECKING:
+    from .message import MessageRecv
+
+install(extra_lines=3)
+
+logger = get_logger("optimized_chat_stream")
+
+
+class SharedContext:
+    """共享上下文数据 - 只读数据结构"""
+
+    def __init__(self, stream_id: str, platform: str, user_info: UserInfo, group_info: Optional[GroupInfo] = None):
+        self.stream_id = stream_id
+        self.platform = platform
+        self.user_info = user_info
+        self.group_info = group_info
+        self.create_time = time.time()
+        self._frozen = True
+
+    def __setattr__(self, name, value):
+        if hasattr(self, '_frozen') and self._frozen and name not in ['_frozen']:
+            raise AttributeError(f"SharedContext is frozen, cannot modify {name}")
+        super().__setattr__(name, value)
+
+
+class LocalChanges:
+    """本地修改跟踪器"""
+
+    def __init__(self):
+        self._changes: Dict[str, Any] = {}
+        self._dirty = False
+
+    def set_change(self, key: str, value: Any):
+        """设置修改项"""
+        self._changes[key] = value
+        self._dirty = True
+
+    def get_change(self, key: str, default: Any = None) -> Any:
+        """获取修改项"""
+        return self._changes.get(key, default)
+
+    def has_changes(self) -> bool:
+        """是否有修改"""
+        return self._dirty
+
+    def get_changes(self) -> Dict[str, Any]:
+        """获取所有修改"""
+        return self._changes.copy()
+
+    def clear_changes(self):
+        """清除修改记录"""
+        self._changes.clear()
+        self._dirty = False
+
+
+class OptimizedChatStream:
+    """优化版聊天流 - 使用写时复制机制"""
+
+    def __init__(
+        self,
+        stream_id: str,
+        platform: str,
+        user_info: UserInfo,
+        group_info: Optional[GroupInfo] = None,
+        data: Optional[Dict] = None,
+    ):
+        # 共享的只读数据
+        self._shared_context = SharedContext(
+            stream_id=stream_id,
+            platform=platform,
+            user_info=user_info,
+            group_info=group_info
+        )
+
+        # 本地修改数据
+        self._local_changes = LocalChanges()
+
+        # 写时复制标志
+        self._copy_on_write = False
+
+        # 基础参数
+        self.base_interest_energy = data.get("base_interest_energy", 0.5) if data else 0.5
+        self._focus_energy = data.get("focus_energy", 0.5) if data else 0.5
+        self.no_reply_consecutive = 0
+
+        # 创建StreamContext（延迟创建）
+        self._stream_context = None
+        self._context_manager = None
+
+        # 更新活跃时间
+        self.update_active_time()
+
+        # 保存标志
+        self.saved = False
+
+    @property
+    def stream_id(self) -> str:
+        return self._shared_context.stream_id
+
+    @property
+    def platform(self) -> str:
+        return self._shared_context.platform
+
+    @property
+    def user_info(self) -> UserInfo:
+        return self._shared_context.user_info
+
+    @user_info.setter
+    def user_info(self, value: UserInfo):
+        """修改用户信息时触发写时复制"""
+        self._ensure_copy_on_write()
+        # 由于SharedContext是frozen的，我们需要在本地修改中记录
+        self._local_changes.set_change('user_info', value)
+
+    @property
+    def group_info(self) -> Optional[GroupInfo]:
+        if self._local_changes.has_changes() and 'group_info' in self._local_changes._changes:
+            return self._local_changes.get_change('group_info')
+        return self._shared_context.group_info
+
+    @group_info.setter
+    def group_info(self, value: Optional[GroupInfo]):
+        """修改群组信息时触发写时复制"""
+        self._ensure_copy_on_write()
+        self._local_changes.set_change('group_info', value)
+
+    @property
+    def create_time(self) -> float:
+        if self._local_changes.has_changes() and 'create_time' in self._local_changes._changes:
+            return self._local_changes.get_change('create_time')
+        return self._shared_context.create_time
+
+    @property
+    def last_active_time(self) -> float:
+        return self._local_changes.get_change('last_active_time', self.create_time)
+
+    @last_active_time.setter
+    def last_active_time(self, value: float):
+        self._local_changes.set_change('last_active_time', value)
+        self.saved = False
+
+    @property
+    def sleep_pressure(self) -> float:
+        return self._local_changes.get_change('sleep_pressure', 0.0)
+
+    @sleep_pressure.setter
+    def sleep_pressure(self, value: float):
+        self._local_changes.set_change('sleep_pressure', value)
+        self.saved = False
+
+    def _ensure_copy_on_write(self):
+        """确保写时复制机制生效"""
+        if not self._copy_on_write:
+            self._copy_on_write = True
+            # 深拷贝共享上下文到本地
+            logger.debug(f"触发写时复制: {self.stream_id}")
+
+    def _get_effective_user_info(self) -> UserInfo:
+        """获取有效的用户信息"""
+        if self._local_changes.has_changes() and 'user_info' in self._local_changes._changes:
+            return self._local_changes.get_change('user_info')
+        return self._shared_context.user_info
+
+    def _get_effective_group_info(self) -> Optional[GroupInfo]:
+        """获取有效的群组信息"""
+        if self._local_changes.has_changes() and 'group_info' in self._local_changes._changes:
+            return self._local_changes.get_change('group_info')
+        return self._shared_context.group_info
+
+    def update_active_time(self):
+        """更新最后活跃时间"""
+        self.last_active_time = time.time()
+
+    def set_context(self, message: "MessageRecv"):
+        """设置聊天消息上下文"""
+        # 确保stream_context存在
+        if self._stream_context is None:
+            self._ensure_copy_on_write()
+            self._create_stream_context()
+
+        # 将MessageRecv转换为DatabaseMessages并设置到stream_context
+        import json
+        from src.common.data_models.database_data_model import DatabaseMessages
+
+        message_info = getattr(message, "message_info", {})
+        user_info = getattr(message_info, "user_info", {})
+        group_info = getattr(message_info, "group_info", {})
+
+        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", ""),
+            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"interest_value: {db_message.interest_value}"
+        )
+
+    def _create_stream_context(self):
+        """创建StreamContext"""
+        from src.common.data_models.message_manager_data_model import StreamContext
+        from src.plugin_system.base.component_types import ChatMode, ChatType
+
+        self._stream_context = StreamContext(
+            stream_id=self.stream_id,
+            chat_type=ChatType.GROUP if self.group_info else ChatType.PRIVATE,
+            chat_mode=ChatMode.NORMAL
+        )
+
+        # 创建单流上下文管理器
+        from src.chat.message_manager.context_manager import SingleStreamContextManager
+        self._context_manager = SingleStreamContextManager(
+            stream_id=self.stream_id, context=self._stream_context
+        )
+
+    @property
+    def stream_context(self):
+        """获取StreamContext"""
+        if self._stream_context is None:
+            self._ensure_copy_on_write()
+            self._create_stream_context()
+        return self._stream_context
+
+    @property
+    def context_manager(self):
+        """获取ContextManager"""
+        if self._context_manager is None:
+            self._ensure_copy_on_write()
+            self._create_stream_context()
+        return self._context_manager
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典格式 - 考虑本地修改"""
+        user_info = self._get_effective_user_info()
+        group_info = self._get_effective_group_info()
+
+        return {
+            "stream_id": self.stream_id,
+            "platform": self.platform,
+            "user_info": user_info.to_dict() if user_info else None,
+            "group_info": group_info.to_dict() if group_info else None,
+            "create_time": self.create_time,
+            "last_active_time": self.last_active_time,
+            "sleep_pressure": self.sleep_pressure,
+            "focus_energy": self.focus_energy,
+            "base_interest_energy": self.base_interest_energy,
+            "stream_context_chat_type": self.stream_context.chat_type.value,
+            "stream_context_chat_mode": self.stream_context.chat_mode.value,
+            "interruption_count": self.stream_context.interruption_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "OptimizedChatStream":
+        """从字典创建实例"""
+        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
+
+        instance = cls(
+            stream_id=data["stream_id"],
+            platform=data["platform"],
+            user_info=user_info,  # type: ignore
+            group_info=group_info,
+            data=data,
+        )
+
+        # 恢复stream_context信息
+        if "stream_context_chat_type" in data:
+            from src.plugin_system.base.component_types import ChatMode, ChatType
+            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 ChatMode, ChatType
+            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 _safe_get_actions(self, message: "MessageRecv") -> list | None:
+        """安全获取消息的actions字段"""
+        try:
+            actions = getattr(message, "actions", None)
+            if actions is None:
+                return None
+
+            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) -> str | None:
+        """从消息段中提取reply_to信息"""
+        try:
+            if hasattr(segment, "type") and segment.type == "seglist":
+                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":
+                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:
+                return f"{self.platform}_{group_info.group_id}"
+            elif user_info and hasattr(user_info, "user_id") and user_info.user_id:
+                return f"{self.platform}_{user_info.user_id}_private"
+            else:
+                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值"""
+        return self._focus_energy
+
+    async def calculate_focus_energy(self) -> float:
+        """异步计算focus_energy"""
+        try:
+            all_messages = self.context_manager.get_messages(limit=global_config.chat.max_context_size)
+
+            user_id = None
+            effective_user_info = self._get_effective_user_info()
+            if effective_user_info and hasattr(effective_user_info, "user_id"):
+                user_id = str(effective_user_info.user_id)
+
+            from src.chat.energy_system import energy_manager
+
+            energy = await 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)
+            return self._focus_energy
+
+    @focus_energy.setter
+    def focus_energy(self, value: float):
+        """设置focus_energy值"""
+        self._focus_energy = max(0.0, min(1.0, value))
+
+    async def _get_user_relationship_score(self) -> float:
+        """获取用户关系分"""
+        try:
+            from src.plugins.built_in.affinity_flow_chatter.interest_scoring import chatter_interest_scoring_system
+
+            effective_user_info = self._get_effective_user_info()
+            if effective_user_info and hasattr(effective_user_info, "user_id"):
+                user_id = str(effective_user_info.user_id)
+                relationship_score = await chatter_interest_scoring_system._calculate_relationship_score(user_id)
+                logger.debug(f"OptimizedChatStream {self.stream_id}: 用户关系分 = {relationship_score:.3f}")
+                return max(0.0, min(1.0, relationship_score))
+
+        except Exception as e:
+            logger.warning(f"OptimizedChatStream {self.stream_id}: 插件内部关系分计算失败: {e}")
+
+        return 0.3
+
+    def create_snapshot(self) -> "OptimizedChatStream":
+        """创建当前状态的快照（用于缓存）"""
+        # 创建一个新的实例，共享相同的上下文
+        snapshot = OptimizedChatStream(
+            stream_id=self.stream_id,
+            platform=self.platform,
+            user_info=self._get_effective_user_info(),
+            group_info=self._get_effective_group_info()
+        )
+
+        # 复制本地修改（但不触发写时复制）
+        snapshot._local_changes._changes = self._local_changes.get_changes()
+        snapshot._local_changes._dirty = self._local_changes._dirty
+        snapshot._focus_energy = self._focus_energy
+        snapshot.base_interest_energy = self.base_interest_energy
+        snapshot.no_reply_consecutive = self.no_reply_consecutive
+        snapshot.saved = self.saved
+
+        return snapshot
+
+
+# 为了向后兼容，创建一个工厂函数
+def create_optimized_chat_stream(
+    stream_id: str,
+    platform: str,
+    user_info: UserInfo,
+    group_info: Optional[GroupInfo] = None,
+    data: Optional[Dict] = None,
+) -> OptimizedChatStream:
+    """创建优化版聊天流实例"""
+    return OptimizedChatStream(
+        stream_id=stream_id,
+        platform=platform,
+        user_info=user_info,
+        group_info=group_info,
+        data=data
+    )