refactor(chat): 异步化聊天系统并重构兴趣值计算机制

将同步调用改为异步调用以提升性能，重构兴趣值计算流程以支持更灵活的组件化架构。主要改进包括：

- 异步化ChatManager相关方法，避免阻塞主线程
- 重构兴趣值计算系统，从插件内部计算改为通过兴趣管理器统一处理
- 新增should_act字段支持更细粒度的动作决策
- 优化初始化逻辑，避免构造函数中的异步操作
- 扩展插件系统支持兴趣计算器组件注册
- 更新数据库模型以支持新的兴趣值相关字段

这些改进提升了系统的响应性能和可扩展性，同时保持了API的向后兼容性。

src/mais4u/mai_think.py

@@ -38,13 +38,11 @@ def init_prompt():
 class MaiThinking:
     def __init__(self, chat_id):
         self.chat_id = chat_id
-        self.chat_stream = get_chat_manager().get_stream(chat_id)
-        self.platform = self.chat_stream.platform
-
-        if self.chat_stream.group_info:
-            self.is_group = True
-        else:
-            self.is_group = False
+        # 这些将在异步初始化中设置
+        self.chat_stream = None  # type: ignore
+        self.platform = None
+        self.is_group = False
+        self._initialized = False
 
         self.s4u_message_processor = S4UMessageProcessor()
 
@@ -63,6 +61,15 @@ class MaiThinking:
 
         self.thinking_model = LLMRequest(model_set=model_config.model_task_config.replyer, request_type="thinking")
 
+    async def _initialize(self):
+        """异步初始化方法"""
+        if not self._initialized:
+            self.chat_stream = await get_chat_manager().get_stream(self.chat_id)
+            if self.chat_stream:
+                self.platform = self.chat_stream.platform
+                self.is_group = bool(self.chat_stream.group_info)
+            self._initialized = True
+
     async def do_think_before_response(self):
         pass
 
@@ -98,6 +105,9 @@ class MaiThinking:
         pass
 
     async def build_internal_message_recv(self, message_text: str):
+        # 初始化
+        await self._initialize()
+
         msg_id = f"internal_{time.time()}"
 
         message_dict = {

src/mais4u/mais4u_chat/s4u_chat.py

@@ -162,9 +162,9 @@ class S4UChatManager:
     def __init__(self):
         self.s4u_chats: dict[str, "S4UChat"] = {}
 
-    def get_or_create_chat(self, chat_stream: ChatStream) -> "S4UChat":
+    async def get_or_create_chat(self, chat_stream: ChatStream) -> "S4UChat":
         if chat_stream.stream_id not in self.s4u_chats:
-            stream_name = get_chat_manager().get_stream_name(chat_stream.stream_id) or chat_stream.stream_id
+            stream_name = await get_chat_manager().get_stream_name(chat_stream.stream_id) or chat_stream.stream_id
             logger.info(f"Creating new S4UChat for stream: {stream_name}")
             self.s4u_chats[chat_stream.stream_id] = S4UChat(chat_stream)
         return self.s4u_chats[chat_stream.stream_id]
@@ -187,7 +187,7 @@ class S4UChat:
         self.last_msg_id = self.msg_id
         self.chat_stream = chat_stream
         self.stream_id = chat_stream.stream_id
-        self.stream_name = get_chat_manager().get_stream_name(self.stream_id) or self.stream_id
+        self.stream_name = self.stream_id  # 初始化时使用stream_id，稍后异步更新
         self.relationship_builder = relationship_builder_manager.get_or_create_builder(self.stream_id)
 
         # 两个消息队列
@@ -213,6 +213,13 @@ class S4UChat:
         self.voice_done = ""
 
         logger.info(f"[{self.stream_name}] S4UChat with two-queue system initialized.")
+        self._stream_name_initialized = False
+
+    async def _initialize_stream_name(self):
+        """异步初始化stream_name"""
+        if not self._stream_name_initialized:
+            self.stream_name = await get_chat_manager().get_stream_name(self.stream_id) or self.stream_id
+            self._stream_name_initialized = True
 
     @staticmethod
     def _get_priority_info(message: MessageRecv) -> dict:
@@ -263,6 +270,9 @@ class S4UChat:
                 self.interest_dict[person_id] = 0
 
     async def add_message(self, message: MessageRecvS4U | MessageRecv) -> None:
+        # 初始化stream_name
+        await self._initialize_stream_name()
+
         self.decay_interest_score()
 
         """根据VIP状态和中断逻辑将消息放入相应队列。"""

src/mais4u/mais4u_chat/s4u_msg_processor.py

@@ -157,7 +157,7 @@ class S4UMessageProcessor:
 
         await self.storage.store_message(message, chat)
 
-        s4u_chat = get_s4u_chat_manager().get_or_create_chat(chat)
+        s4u_chat = await get_s4u_chat_manager().get_or_create_chat(chat)
 
         await s4u_chat.add_message(message)
 
@@ -191,7 +191,7 @@ class S4UMessageProcessor:
             chat = await get_chat_manager().get_or_create_stream(
                 platform="amaidesu_default", user_info=message.message_info.user_info, group_info=group_info
             )
-            s4u_chat = get_s4u_chat_manager().get_or_create_chat(chat)
+            s4u_chat = await get_s4u_chat_manager().get_or_create_chat(chat)
             message.message_info.group_info = s4u_chat.chat_stream.group_info
             message.message_info.platform = s4u_chat.chat_stream.platform
 
@@ -215,7 +215,7 @@ class S4UMessageProcessor:
     @staticmethod
     async def hadle_if_voice_done(message: MessageRecvS4U):
         if message.voice_done:
-            s4u_chat = get_s4u_chat_manager().get_or_create_chat(message.chat_stream)
+            s4u_chat = await get_s4u_chat_manager().get_or_create_chat(message.chat_stream)
             s4u_chat.voice_done = message.voice_done
             return True
         return False