feat：麦麦会产生thinking，并发送内容到直播流

src/mais4u/mais4u_chat/s4u_chat.py

@@ -2,7 +2,7 @@ import asyncio
 import traceback
 import time
 import random
-from typing import Optional, Dict, Tuple  # 导入类型提示
+from typing import Optional, Dict, Tuple, List  # 导入类型提示
 from maim_message import UserInfo, Seg
 from src.common.logger import get_logger
 from src.chat.message_receive.chat_stream import ChatStream, get_chat_manager
@@ -42,6 +42,8 @@ class MessageSenderContainer:
         self.voice_done = ""
         
 
+        
+
     async def add_message(self, chunk: str):
         """向队列中添加一个消息块。"""
         await self.queue.put(chunk)
@@ -195,6 +197,7 @@ class S4UChat:
         self.gpt = S4UStreamGenerator()
         self.interest_dict: Dict[str, float] = {}  # 用户兴趣分
         
+        self.internal_message :List[MessageRecvS4U] = []
         
         self.msg_id = ""
         self.voice_done = ""
@@ -240,7 +243,7 @@ class S4UChat:
         score += self._get_interest_score(message.message_info.user_info.user_id)
         return score
     
-    def decay_interest_score(self,message: MessageRecvS4U|MessageRecv):
+    def decay_interest_score(self):
         for person_id, score in self.interest_dict.items():
             if score > 0:
                 self.interest_dict[person_id] = score * 0.95
@@ -249,7 +252,7 @@ class S4UChat:
 
     async def add_message(self, message: MessageRecvS4U|MessageRecv) -> None:
         
-        self.decay_interest_score(message)
+        self.decay_interest_score()
         
         """根据VIP状态和中断逻辑将消息放入相应队列。"""
         user_id = message.message_info.user_info.user_id
@@ -259,8 +262,8 @@ class S4UChat:
         try:
             is_gift = message.is_gift
             is_superchat = message.is_superchat
-            print(is_gift)
-            print(is_superchat)
+            # print(is_gift)
+            # print(is_superchat)
             if is_gift:
                 await self.relationship_builder.build_relation(immediate_build=person_id)
                 # 安全地增加兴趣分，如果person_id不存在则先初始化为1.0
@@ -388,18 +391,49 @@ class S4UChat:
                     queue_name = "vip"
                 # 其次处理普通队列
                 elif not self._normal_queue.empty():
-                    neg_priority, entry_count, timestamp, message = self._normal_queue.get_nowait()
-                    priority = -neg_priority
-                    # 检查普通消息是否超时
-                    if time.time() - timestamp > s4u_config.message_timeout_seconds:
-                        logger.info(
-                            f"[{self.stream_name}] Discarding stale normal message: {message.processed_plain_text[:20]}..."
-                        )
-                        self._normal_queue.task_done()
-                        continue  # 处理下一条
-                    queue_name = "normal"
+                    # 判断 normal 队列是否只有一条消息，且 internal_message 有内容
+                    if self._normal_queue.qsize() == 1 and self.internal_message:
+                        if random.random() < 0.5:
+                            # 50% 概率用 internal_message 最新一条
+                            message = self.internal_message[-1]
+                            priority = 0  # internal_message 没有优先级，设为 0
+                            queue_name = "internal"
+                            neg_priority = 0
+                            entry_count = 0
+                            logger.info(f"[{self.stream_name}] 触发 internal_message 生成回复: {getattr(message, 'processed_plain_text', str(message))[:20]}...")
+                            # 不要从 normal 队列取出消息，保留在队列中
+                        else:
+                            neg_priority, entry_count, timestamp, message = self._normal_queue.get_nowait()
+                            priority = -neg_priority
+                            # 检查普通消息是否超时
+                            if time.time() - timestamp > s4u_config.message_timeout_seconds:
+                                logger.info(
+                                    f"[{self.stream_name}] Discarding stale normal message: {message.processed_plain_text[:20]}..."
+                                )
+                                self._normal_queue.task_done()
+                                continue  # 处理下一条
+                            queue_name = "normal"
+                    else:
+                        neg_priority, entry_count, timestamp, message = self._normal_queue.get_nowait()
+                        priority = -neg_priority
+                        # 检查普通消息是否超时
+                        if time.time() - timestamp > s4u_config.message_timeout_seconds:
+                            logger.info(
+                                f"[{self.stream_name}] Discarding stale normal message: {message.processed_plain_text[:20]}..."
+                            )
+                            self._normal_queue.task_done()
+                            continue  # 处理下一条
+                        queue_name = "normal"
                 else:
-                    continue  # 没有消息了，回去等事件
+                    if self.internal_message:
+                        message = self.internal_message[-1]
+                        priority = 0
+                        neg_priority = 0
+                        entry_count = 0
+                        queue_name = "internal"
+                        logger.info(f"[{self.stream_name}] normal/vip 队列都空，触发 internal_message 回复: {getattr(message, 'processed_plain_text', str(message))[:20]}...")
+                    else:
+                        continue  # 没有消息了，回去等事件
 
                 self._current_message_being_replied = (queue_name, priority, entry_count, message)
                 self._current_generation_task = asyncio.create_task(self._generate_and_send(message))
@@ -421,6 +455,9 @@ class S4UChat:
                     # 标记任务完成
                     if queue_name == "vip":
                         self._vip_queue.task_done()
+                    elif queue_name == "internal":
+                        # 如果使用 internal_message 生成回复，则不从 normal 队列中移除
+                        pass
                     else:
                         self._normal_queue.task_done()
 

src/mais4u/mais4u_chat/s4u_msg_processor.py

@@ -4,6 +4,7 @@ from typing import Tuple
 
 from src.chat.memory_system.Hippocampus import hippocampus_manager
 from src.chat.message_receive.message import MessageRecv, MessageRecvS4U
+from maim_message.message_base import GroupInfo,UserInfo
 from src.chat.message_receive.storage import MessageStorage
 from src.chat.message_receive.chat_stream import get_chat_manager
 from src.chat.utils.timer_calculator import Timer
@@ -93,6 +94,9 @@ class S4UMessageProcessor:
             group_info=groupinfo,
         )
         
+        if await self.handle_internal_message(message):
+            return
+        
         if await self.hadle_if_voice_done(message):
             return
         
@@ -137,6 +141,32 @@ class S4UMessageProcessor:
         else:
             logger.info(f"[S4U]{userinfo.user_nickname}:{message.processed_plain_text}")
     
+    async def handle_internal_message(self, message: MessageRecvS4U):
+        if message.is_internal:
+            
+            group_info = GroupInfo(platform = "amaidesu_default",group_id = 114514,group_name = "内心")
+            
+            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)
+            message.message_info.group_info = s4u_chat.chat_stream.group_info
+            message.message_info.platform = s4u_chat.chat_stream.platform
+            
+            
+            s4u_chat.internal_message.append(message)
+            s4u_chat._new_message_event.set()
+            
+            
+            logger.info(f"[{s4u_chat.stream_name}] 添加内部消息-------------------------------------------------------: {message.processed_plain_text}")
+            
+            
+            return True
+        return False
+    
+    
     async def handle_screen_message(self, message: MessageRecvS4U):
         if message.is_screen:
             screen_manager.set_screen(message.screen_info)

src/mais4u/mais4u_chat/s4u_prompt.py

@@ -16,6 +16,7 @@ from src.mais4u.mais4u_chat.super_chat_manager import get_super_chat_manager
 from src.mais4u.mais4u_chat.screen_manager import screen_manager
 from src.chat.express.expression_selector import expression_selector
 from .s4u_mood_manager import mood_manager
+from src.person_info.person_info import PersonInfoManager, get_person_info_manager
 
 logger = get_logger("prompt")
 
@@ -58,6 +59,37 @@ def init_prompt():
 """,
         "s4u_prompt",  # New template for private CHAT chat
     )
+    
+    Prompt(
+        """
+你的名字是麦麦, 是千石可乐开发的程序，可以在QQ，微信等平台发言，你现在正在哔哩哔哩作为虚拟主播进行直播
+虽然是个AI，但你在努力扮演真人, 人设的配色是橙色和紫色和绿色
+你有一头法式橙色卷发，你很可爱，穿戴英式侦探风格学院风裙子和帽子，你正在一个教室场景里进行虚拟线上直播。不过不要刻意提及这些内容，自然回复
+你可以看见用户发送的弹幕，礼物和superchat
+你可以看见面前的屏幕，目前屏幕的内容是:
+{screen_info}
+
+{memory_block}
+{expression_habits_block}
+
+{sc_info}
+
+{time_block}
+{chat_info_danmu}
+--------------------------------
+以上是你和弹幕的对话，与此同时，你在与QQ群友聊天，聊天记录如下：
+{chat_info_qq}
+--------------------------------
+你刚刚回复了QQ群，你内心的想法是：{mind}
+请根据你内心的想法，组织一条回复，在直播间进行发言，可以点名吐槽对象，让观众知道你在说谁
+{gift_info}
+回复简短一些，平淡一些，可以参考贴吧，知乎和微博的回复风格。不要浮夸，有逻辑和条理。
+表现的有个性，不要随意服从他人要求，积极互动。你现在的心情是：{mood_state}
+不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。
+你的发言：
+""",
+        "s4u_prompt_internal",  # New template for private CHAT chat
+    )
 
 
 class PromptBuilder:
@@ -147,6 +179,7 @@ class PromptBuilder:
             timestamp=time.time(),
             limit=300,
         )
+        
 
         talk_type = message.message_info.platform + ":" + str(message.chat_stream.user_info.user_id)
 
@@ -218,8 +251,21 @@ class PromptBuilder:
             all_msg_seg_list.append(msg_seg_str)
             for msg in all_msg_seg_list:
                 core_msg_str += msg
+                
+                
+        all_dialogue_prompt = get_raw_msg_before_timestamp_with_chat(
+            chat_id=chat_stream.stream_id,
+            timestamp=time.time(),
+            limit=20,
+        )        
+        all_dialogue_prompt_str = build_readable_messages(
+            all_dialogue_prompt,
+            timestamp_mode="normal_no_YMD",
+            show_pic=False,
+        )
+        
 
-        return core_msg_str, background_dialogue_prompt
+        return core_msg_str, background_dialogue_prompt,all_dialogue_prompt_str
 
     def build_gift_info(self, message: MessageRecvS4U):
         if message.is_gift:
@@ -234,18 +280,34 @@ class PromptBuilder:
         super_chat_manager = get_super_chat_manager()
         return super_chat_manager.build_superchat_summary_string(message.chat_stream.stream_id)
 
+
     async def build_prompt_normal(
         self,
         message: MessageRecvS4U,
         chat_stream: ChatStream,
         message_txt: str,
-        sender_name: str = "某人",
     ) -> str:
+        
+        person_id = PersonInfoManager.get_person_id(
+            message.chat_stream.user_info.platform, message.chat_stream.user_info.user_id
+        )
+        person_info_manager = get_person_info_manager()
+        person_name = await person_info_manager.get_value(person_id, "person_name")
+
+        if message.chat_stream.user_info.user_nickname:
+            if person_name:
+                sender_name = f"[{message.chat_stream.user_info.user_nickname}]（你叫ta{person_name}）"
+            else:
+                sender_name = f"[{message.chat_stream.user_info.user_nickname}]"
+        else:
+            sender_name = f"用户({message.chat_stream.user_info.user_id})"
+        
+        
         relation_info_block, memory_block, expression_habits_block = await asyncio.gather(
             self.build_relation_info(chat_stream), self.build_memory_block(message_txt), self.build_expression_habits(chat_stream, message_txt, sender_name)
         )
 
-        core_dialogue_prompt, background_dialogue_prompt = self.build_chat_history_prompts(chat_stream, message)
+        core_dialogue_prompt, background_dialogue_prompt,all_dialogue_prompt = self.build_chat_history_prompts(chat_stream, message)
         
         gift_info = self.build_gift_info(message)
         
@@ -258,23 +320,41 @@ class PromptBuilder:
         mood = mood_manager.get_mood_by_chat_id(chat_stream.stream_id)
 
         template_name = "s4u_prompt"
-
-        prompt = await global_prompt_manager.format_prompt(
-            template_name,
-            time_block=time_block,
-            expression_habits_block=expression_habits_block,
-            relation_info_block=relation_info_block,
-            memory_block=memory_block,
-            screen_info=screen_info,
-            gift_info=gift_info,
-            sc_info=sc_info,
-            sender_name=sender_name,
-            core_dialogue_prompt=core_dialogue_prompt,
-            background_dialogue_prompt=background_dialogue_prompt,
-            message_txt=message_txt,
-            mood_state=mood.mood_state,
-        )
         
+        if not message.is_internal:
+            prompt = await global_prompt_manager.format_prompt(
+                template_name,
+                time_block=time_block,
+                expression_habits_block=expression_habits_block,
+                relation_info_block=relation_info_block,
+                memory_block=memory_block,
+                screen_info=screen_info,
+                gift_info=gift_info,
+                sc_info=sc_info,
+                sender_name=sender_name,
+                core_dialogue_prompt=core_dialogue_prompt,
+                background_dialogue_prompt=background_dialogue_prompt,
+                message_txt=message_txt,
+                mood_state=mood.mood_state,
+            )
+        else:
+            
+            
+            prompt = await global_prompt_manager.format_prompt(
+                "s4u_prompt_internal",
+                time_block=time_block,
+                expression_habits_block=expression_habits_block,
+                relation_info_block=relation_info_block,
+                memory_block=memory_block,
+                screen_info=screen_info,
+                gift_info=gift_info,
+                sc_info=sc_info,
+                chat_info_danmu=all_dialogue_prompt,
+                chat_info_qq=message.chat_info,
+                mind=message.processed_plain_text,
+                mood_state=mood.mood_state,
+            )
+            
         print(prompt)
 
         return prompt

src/mais4u/mais4u_chat/s4u_stream_generator.py

@@ -2,7 +2,7 @@ import os
 from typing import AsyncGenerator
 from src.mais4u.openai_client import AsyncOpenAIClient
 from src.config.config import global_config
-from src.chat.message_receive.message import MessageRecv
+from src.chat.message_receive.message import MessageRecvS4U
 from src.mais4u.mais4u_chat.s4u_prompt import prompt_builder
 from src.common.logger import get_logger
 from src.person_info.person_info import PersonInfoManager, get_person_info_manager
@@ -45,16 +45,8 @@ class S4UStreamGenerator:
             r'[^.。!?？！\n\r]+(?:[.。!?？！\n\r](?![\'"])|$))',  # 匹配直到句子结束符
             re.UNICODE | re.DOTALL,
         )
-
-    async def generate_response(
-        self, message: MessageRecv, previous_reply_context: str = ""
-    ) -> AsyncGenerator[str, None]:
-        """根据当前模型类型选择对应的生成函数"""
-        # 从global_config中获取模型概率值并选择模型
-        self.partial_response = ""
-        current_client = self.client_1
-        self.current_model_name = self.model_1_name
-
+        
+    async def build_last_internal_message(self,message:MessageRecvS4U,previous_reply_context:str = ""):
         person_id = PersonInfoManager.get_person_id(
             message.chat_stream.user_info.platform, message.chat_stream.user_info.user_id
         )
@@ -78,13 +70,30 @@ class S4UStreamGenerator:
             [这是用户发来的新消息, 你需要结合上下文，对此进行回复]:
             {message.processed_plain_text}
             """
+            return True,message_txt
         else:
             message_txt = message.processed_plain_text
+            return False,message_txt
+        
+
+            
+    
+
+    async def generate_response(
+        self, message: MessageRecvS4U, previous_reply_context: str = ""
+    ) -> AsyncGenerator[str, None]:
+        """根据当前模型类型选择对应的生成函数"""
+        # 从global_config中获取模型概率值并选择模型
+        self.partial_response = ""
+        message_txt = message.processed_plain_text
+        if not message.is_internal:
+            interupted,message_txt_added = await self.build_last_internal_message(message,previous_reply_context)
+            if interupted:
+                message_txt = message_txt_added
 
         prompt = await prompt_builder.build_prompt_normal(
             message=message,
             message_txt=message_txt,
-            sender_name=sender_name,
             chat_stream=message.chat_stream,
         )
 
@@ -92,6 +101,10 @@ class S4UStreamGenerator:
             f"{self.current_model_name}思考:{message_txt[:30] + '...' if len(message_txt) > 30 else message_txt}"
         )  # noqa: E501
 
+        current_client = self.client_1
+        self.current_model_name = self.model_1_name
+
+
         extra_kwargs = {}
         if self.replyer_1_config.get("enable_thinking") is not None:
             extra_kwargs["enable_thinking"] = self.replyer_1_config.get("enable_thinking")