gardel/Mofox-Core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat:移除watching，增加回复生成缓冲，添加头部动作

Browse Source
This commit is contained in:
SengokuCola
2025-07-17 22:25:33 +08:00
parent 8768b5d31b
commit 9be97acb00
14 changed files with 497 additions and 512 deletions
Download Patch File Download Diff File Expand all files Collapse all files

134
src/mais4u/mais4u_chat/SUPERCHAT_MANAGER_README.md
View File

@@ -1,134 +0,0 @@
# SuperChat管理器使用说明
## 概述
SuperChat管理器是用于管理和跟踪超级弹幕消息的核心组件。它能够根据SuperChat的金额自动设置不同的存活时间，并提供多种格式的字符串构建功能。
## 主要功能
### 1. 自动记录SuperChat
当收到SuperChat消息时，管理器会自动记录以下信息：
- 用户ID和昵称
- 平台信息
- 聊天ID
- SuperChat金额和消息内容
- 时间戳和过期时间
- 群组名称（如果适用）
### 2. 基于金额的存活时间
SuperChat的存活时间根据金额阶梯设置：
| 金额范围 | 存活时间 |
|---------|---------|
| ≥500元 | 4小时 |
| 200-499元 | 2小时 |
| 100-199元 | 1小时 |
| 50-99元 | 30分钟 |
| 20-49元 | 15分钟 |
| 10-19元 | 10分钟 |
| <10元 | 5分钟 |
### 3. 自动清理
管理器每30秒自动检查并清理过期的SuperChat记录，保持内存使用的高效性。
## 使用方法
### 基本用法
```python
from src.mais4u.mais4u_chat.super_chat_manager import get_super_chat_manager
# 获取全局管理器实例
super_chat_manager = get_super_chat_manager()
# 添加SuperChat（通常在消息处理时自动调用）
await super_chat_manager.add_superchat(message)
# 获取指定聊天的SuperChat显示字符串
display_string = super_chat_manager.build_superchat_display_string(chat_id, max_count=10)
# 获取摘要信息
summary = super_chat_manager.build_superchat_summary_string(chat_id)
# 获取统计信息
stats = super_chat_manager.get_superchat_statistics(chat_id)
```
### 结合S4UChat使用
```python
from src.mais4u.mais4u_chat.s4u_chat import get_s4u_chat_manager
# 获取S4UChat实例
s4u_manager = get_s4u_chat_manager()
s4u_chat = s4u_manager.get_or_create_chat(chat_stream)
# 便捷方法获取SuperChat信息
display_string = s4u_chat.get_superchat_display_string(max_count=10)
summary = s4u_chat.get_superchat_summary_string()
stats = s4u_chat.get_superchat_statistics()
```
## API 参考
### SuperChatManager类
#### 主要方法
- `add_superchat(message: MessageRecvS4U)`: 添加SuperChat记录
- `get_superchats_by_chat(chat_id: str)`: 获取指定聊天的有效SuperChat列表
- `build_superchat_display_string(chat_id: str, max_count: int = 10)`: 构建显示字符串
- `build_superchat_summary_string(chat_id: str)`: 构建摘要字符串
- `get_superchat_statistics(chat_id: str)`: 获取统计信息
#### 输出格式示例
**显示字符串格式：**
```
📢 当前有效超级弹幕：
1. 【100元】用户名: 消息内容 (剩余25分30秒)
2. 【50元】用户名: 消息内容 (剩余10分15秒)
... 还有3条SuperChat
```
**摘要字符串格式：**
```
当前有5条超级弹幕，总金额350元，最高单笔100元
```
**统计信息格式：**
```python
{
"count": 5,
"total_amount": 350.0,
"average_amount": 70.0,
"highest_amount": 100.0,
"lowest_amount": 20.0
}
```
### S4UChat扩展方法
- `get_superchat_display_string(max_count: int = 10)`: 获取当前聊天的SuperChat显示字符串
- `get_superchat_summary_string()`: 获取当前聊天的SuperChat摘要字符串
- `get_superchat_statistics()`: 获取当前聊天的SuperChat统计信息
## 集成说明
SuperChat管理器已经集成到S4U聊天系统中：
1. **自动处理**: 当S4UChat收到SuperChat消息时，会自动调用管理器记录
2. **内存管理**: 管理器会自动清理过期的SuperChat，无需手动管理
3. **全局单例**: 使用全局单例模式，确保所有聊天共享同一个管理器实例
## 注意事项
1. SuperChat管理器是全局单例，在应用程序整个生命周期中保持运行
2. 过期时间基于消息金额自动计算，无需手动设置
3. 管理器会自动处理异常情况，如无效的价格格式等
4. 清理任务在后台异步运行，不会阻塞主要功能
## 示例文件
参考 `superchat_example.py` 文件查看完整的使用示例。

206
src/mais4u/mais4u_chat/body_emotion_action_manager.py
View File

@@ -1,6 +1,6 @@
import json
import time
import random
from src.chat.message_receive.message import MessageRecv
from src.llm_models.utils_model import LLMRequest
from src.common.logger import get_logger
@@ -8,10 +8,35 @@ from src.chat.utils.chat_message_builder import build_readable_messages, get_raw
from src.config.config import global_config
from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
from src.manager.async_task_manager import AsyncTask, async_task_manager
from src.plugin_system.apis import send_api
from json_repair import repair_json
from src.mais4u.s4u_config import s4u_config
logger = get_logger("action")
HEAD_CODE = {
"看向上方": "(0,0.5,0)",
"看向下方": "(0,-0.5,0)",
"看向左边": "(-1,0,0)",
"看向右边": "(1,0,0)",
"随意朝向": "random",
"看向摄像机": "camera",
"注视对方": "(0,0,0)",
"看向正前方": "(0,0,0)",
}
BODY_CODE = {
"双手背后向前弯腰": "010_0070",
"歪头双手合十": "010_0100",
"标准文静站立": "010_0101",
"双手交叠腹部站立": "010_0150",
"帅气的姿势": "010_0190",
"另一个帅气的姿势": "010_0191",
"手掌朝前可爱": "010_0210",
"平静，双手后放":"平静，双手后放",
"思考": "思考"
}
def init_prompt():
Prompt(
@@ -21,16 +46,15 @@ def init_prompt():
{indentify_block}
你现在的动作状态是：
- 手部：{hand_action}
- 上半身：{upper_body_action}
- 头部：{head_action}
- 身体动作：{body_action}
现在，因为你发送了消息，或者群里其他人发送了消息，引起了你的注意，你对其进行了阅读和思考，请你更新你的动作状态。
请只按照以下json格式输出，描述你新的动作状态，每个动作一到三个中文词，确保每个字段都存在：
身体动作可选：
{all_actions}
请只按照以下json格式输出，描述你新的动作状态，确保每个字段都存在：
{{
"hand_action": "...",
"upper_body_action": "...",
"head_action": "..."
"body_action": "..."
}}
""",
"change_action_prompt",
@@ -41,17 +65,16 @@ def init_prompt():
以上是群里最近的聊天记录
{indentify_block}
你之前的动作状态是：
- 手部：{hand_action}
- 上半身：{upper_body_action}
- 头部：{head_action}
你之前的动作状态是
- 身体动作：{body_action}
身体动作可选：
{all_actions}
距离你上次关注群里消息已经过去了一段时间，你冷静了下来，你的动作会趋于平缓或静止，请你输出你现在新的动作状态，用中文。
请只按照以下json格式输出，描述你新的动作状态，每个动作一到三个词，确保每个字段都存在：
请只按照以下json格式输出，描述你新的动作状态，确保每个字段都存在：
{{
"hand_action": "...",
"upper_body_action": "...",
"head_action": "..."
"body_action": "..."
}}
""",
"regress_action_prompt",
@@ -62,19 +85,38 @@ class ChatAction:
def __init__(self, chat_id: str):
self.chat_id: str = chat_id
self.hand_action: str = "双手放在桌面"
self.upper_body_action: str = "坐着"
self.body_action: str = "坐着"
self.head_action: str = "注视摄像机"
self.regression_count: int = 0
# 新增：body_action冷却池，key为动作名，value为剩余冷却次数
self.body_action_cooldown: dict[str, int] = {}
print(s4u_config.models.motion)
print(global_config.model.emotion)
self.action_model = LLMRequest(
model=global_config.model.emotion,
temperature=0.7,
request_type="action",
request_type="motion",
)
self.last_change_time = 0
async def send_action_update(self):
"""发送动作更新到前端"""
body_code = BODY_CODE.get(self.body_action, "")
await send_api.custom_to_stream(
message_type="body_action",
content=body_code,
stream_id=self.chat_id,
storage_message=False,
show_log=True,
)
async def update_action_by_message(self, message: MessageRecv):
self.regression_count = 0
@@ -104,29 +146,43 @@ class ChatAction:
prompt_personality = global_config.personality.personality_core
indentify_block = f"你的名字是{bot_name}{bot_nickname}，你{prompt_personality}："
try:
# 冷却池处理：过滤掉冷却中的动作
self._update_body_action_cooldown()
available_actions = [k for k in BODY_CODE.keys() if k not in self.body_action_cooldown]
all_actions = "\n".join(available_actions)
prompt = await global_prompt_manager.format_prompt(
"change_action_prompt",
chat_talking_prompt=chat_talking_prompt,
indentify_block=indentify_block,
body_action=self.body_action,
all_actions=all_actions,
)
prompt = await global_prompt_manager.format_prompt(
"change_action_prompt",
chat_talking_prompt=chat_talking_prompt,
indentify_block=indentify_block,
hand_action=self.hand_action,
upper_body_action=self.upper_body_action,
head_action=self.head_action,
)
logger.info(f"prompt: {prompt}")
response, (reasoning_content, model_name) = await self.action_model.generate_response_async(prompt=prompt)
logger.info(f"response: {response}")
logger.info(f"reasoning_content: {reasoning_content}")
logger.info(f"prompt: {prompt}")
response, (reasoning_content, model_name) = await self.action_model.generate_response_async(prompt=prompt)
logger.info(f"response: {response}")
logger.info(f"reasoning_content: {reasoning_content}")
action_data = json.loads(repair_json(response))
action_data = json.loads(repair_json(response))
if action_data:
# 记录原动作，切换后进入冷却
prev_body_action = self.body_action
new_body_action = action_data.get("body_action", self.body_action)
if new_body_action != prev_body_action:
if prev_body_action:
self.body_action_cooldown[prev_body_action] = 3
self.body_action = new_body_action
self.head_action = action_data.get("head_action", self.head_action)
# 发送动作更新
await self.send_action_update()
if action_data:
self.hand_action = action_data.get("hand_action", self.hand_action)
self.upper_body_action = action_data.get("upper_body_action", self.upper_body_action)
self.head_action = action_data.get("head_action", self.head_action)
self.last_change_time = message_time
self.last_change_time = message_time
except Exception as e:
logger.error(f"update_action_by_message error: {e}")
async def regress_action(self):
message_time = time.time()
@@ -134,7 +190,7 @@ class ChatAction:
chat_id=self.chat_id,
timestamp_start=self.last_change_time,
timestamp_end=message_time,
limit=15,
limit=10,
limit_mode="last",
)
chat_talking_prompt = build_readable_messages(
@@ -155,33 +211,56 @@ class ChatAction:
prompt_personality = global_config.personality.personality_core
indentify_block = f"你的名字是{bot_name}{bot_nickname}，你{prompt_personality}："
try:
prompt = await global_prompt_manager.format_prompt(
"regress_action_prompt",
chat_talking_prompt=chat_talking_prompt,
indentify_block=indentify_block,
hand_action=self.hand_action,
upper_body_action=self.upper_body_action,
head_action=self.head_action,
)
# 冷却池处理：过滤掉冷却中的动作
self._update_body_action_cooldown()
available_actions = [k for k in BODY_CODE.keys() if k not in self.body_action_cooldown]
all_actions = "\n".join(available_actions)
logger.info(f"prompt: {prompt}")
response, (reasoning_content, model_name) = await self.action_model.generate_response_async(prompt=prompt)
logger.info(f"response: {response}")
logger.info(f"reasoning_content: {reasoning_content}")
prompt = await global_prompt_manager.format_prompt(
"regress_action_prompt",
chat_talking_prompt=chat_talking_prompt,
indentify_block=indentify_block,
body_action=self.body_action,
all_actions=all_actions,
)
action_data = json.loads(repair_json(response))
if action_data:
self.hand_action = action_data.get("hand_action", self.hand_action)
self.upper_body_action = action_data.get("upper_body_action", self.upper_body_action)
self.head_action = action_data.get("head_action", self.head_action)
logger.info(f"prompt: {prompt}")
response, (reasoning_content, model_name) = await self.action_model.generate_response_async(prompt=prompt)
logger.info(f"response: {response}")
logger.info(f"reasoning_content: {reasoning_content}")
self.regression_count += 1
action_data = json.loads(repair_json(response))
if action_data:
prev_body_action = self.body_action
new_body_action = action_data.get("body_action", self.body_action)
if new_body_action != prev_body_action:
if prev_body_action:
self.body_action_cooldown[prev_body_action] = 6
self.body_action = new_body_action
# 发送动作更新
await self.send_action_update()
self.regression_count += 1
self.last_change_time = message_time
except Exception as e:
logger.error(f"regress_action error: {e}")
# 新增：冷却池维护方法
def _update_body_action_cooldown(self):
remove_keys = []
for k in self.body_action_cooldown:
self.body_action_cooldown[k] -= 1
if self.body_action_cooldown[k] <= 0:
remove_keys.append(k)
for k in remove_keys:
del self.body_action_cooldown[k]
class ActionRegressionTask(AsyncTask):
def __init__(self, action_manager: "ActionManager"):
super().__init__(task_name="ActionRegressionTask", run_interval=30)
super().__init__(task_name="ActionRegressionTask", run_interval=3)
self.action_manager = action_manager
async def run(self):
@@ -191,7 +270,7 @@ class ActionRegressionTask(AsyncTask):
if action_state.last_change_time == 0:
continue
if now - action_state.last_change_time > 180:
if now - action_state.last_change_time > 10:
if action_state.regression_count >= 3:
continue
@@ -225,15 +304,8 @@ class ActionManager:
self.action_state_list.append(new_action_state)
return new_action_state
def reset_action_state_by_chat_id(self, chat_id: str):
for action_state in self.action_state_list:
if action_state.chat_id == chat_id:
action_state.hand_action = "双手放在桌面"
action_state.upper_body_action = "坐着"
action_state.head_action = "注视摄像机"
action_state.regression_count = 0
return
self.action_state_list.append(ChatAction(chat_id))
init_prompt()

22
src/mais4u/mais4u_chat/loading.py
View File

@@ -1,22 +0,0 @@
from src.plugin_system.apis import send_api
async def send_loading(chat_id: str, content: str):
await send_api.custom_to_stream(
message_type="loading",
content=content,
stream_id=chat_id,
storage_message=False,
show_log=True,
)
async def send_unloading(chat_id: str):
await send_api.custom_to_stream(
message_type="loading",
content="",
stream_id=chat_id,
storage_message=False,
show_log=True,
)

110
src/mais4u/mais4u_chat/priority_manager.py
View File

@@ -1,110 +0,0 @@
import time
import heapq
import math
import json
from typing import List, Optional
from src.common.logger import get_logger
logger = get_logger("normal_chat")
class PrioritizedMessage:
"""带有优先级的消息对象"""
def __init__(self, message_data: dict, interest_scores: List[float], is_vip: bool = False):
self.message_data = message_data
self.arrival_time = time.time()
self.interest_scores = interest_scores
self.is_vip = is_vip
self.priority = self.calculate_priority()
def calculate_priority(self, decay_rate: float = 0.01) -> float:
"""
计算优先级分数。
优先级 = 兴趣分 * exp(-衰减率 * 消息年龄)
"""
age = time.time() - self.arrival_time
decay_factor = math.exp(-decay_rate * age)
return sum(self.interest_scores) + decay_factor
def __lt__(self, other: "PrioritizedMessage") -> bool:
"""用于堆排序的比较函数，我们想要一个最大堆，所以用 >"""
return self.priority > other.priority
class PriorityManager:
"""
管理消息队列，根据优先级选择消息进行处理。
"""
def __init__(self, normal_queue_max_size: int = 5):
self.vip_queue: List[PrioritizedMessage] = [] # VIP 消息队列 (最大堆)
self.normal_queue: List[PrioritizedMessage] = [] # 普通消息队列 (最大堆)
self.normal_queue_max_size = normal_queue_max_size
def add_message(self, message_data: dict, interest_score: float = 0):
"""
添加新消息到合适的队列中。
"""
user_id = message_data.get("user_id")
priority_info_raw = message_data.get("priority_info")
priority_info = {}
if isinstance(priority_info_raw, str):
priority_info = json.loads(priority_info_raw)
elif isinstance(priority_info_raw, dict):
priority_info = priority_info_raw
is_vip = priority_info.get("message_type") == "vip"
message_priority = priority_info.get("message_priority", 0.0)
p_message = PrioritizedMessage(message_data, [interest_score, message_priority], is_vip)
if is_vip:
heapq.heappush(self.vip_queue, p_message)
logger.debug(f"消息来自VIP用户 {user_id}, 已添加到VIP队列. 当前VIP队列长度: {len(self.vip_queue)}")
else:
if len(self.normal_queue) >= self.normal_queue_max_size:
# 如果队列已满，只在消息优先级高于最低优先级消息时才添加
if p_message.priority > self.normal_queue[0].priority:
heapq.heapreplace(self.normal_queue, p_message)
logger.debug(f"普通队列已满，但新消息优先级更高，已替换. 用户: {user_id}")
else:
logger.debug(f"普通队列已满且新消息优先级较低，已忽略. 用户: {user_id}")
else:
heapq.heappush(self.normal_queue, p_message)
logger.debug(
f"消息来自普通用户 {user_id}, 已添加到普通队列. 当前普通队列长度: {len(self.normal_queue)}"
)
def get_highest_priority_message(self) -> Optional[dict]:
"""
从VIP和普通队列中获取当前最高优先级的消息。
"""
# 更新所有消息的优先级
for p_msg in self.vip_queue:
p_msg.priority = p_msg.calculate_priority()
for p_msg in self.normal_queue:
p_msg.priority = p_msg.calculate_priority()
# 重建堆
heapq.heapify(self.vip_queue)
heapq.heapify(self.normal_queue)
vip_msg = self.vip_queue[0] if self.vip_queue else None
normal_msg = self.normal_queue[0] if self.normal_queue else None
if vip_msg:
return heapq.heappop(self.vip_queue).message_data
elif normal_msg:
return heapq.heappop(self.normal_queue).message_data
else:
return None
def is_empty(self) -> bool:
"""检查所有队列是否为空"""
return not self.vip_queue and not self.normal_queue
def get_queue_status(self) -> str:
"""获取队列状态信息"""
return f"VIP队列: {len(self.vip_queue)}, 普通队列: {len(self.normal_queue)}"

56
src/mais4u/mais4u_chat/s4u_chat.py
View File

@@ -13,11 +13,12 @@ from src.common.message.api import get_global_api
from src.chat.message_receive.storage import MessageStorage
from .s4u_watching_manager import watching_manager
import json
from .s4u_mood_manager import mood_manager
from src.person_info.relationship_builder_manager import relationship_builder_manager
from .loading import send_loading, send_unloading
from src.mais4u.s4u_config import s4u_config
from src.person_info.person_info import PersonInfoManager
from .super_chat_manager import get_super_chat_manager
from .yes_or_no import yes_or_no_head
logger = get_logger("S4U_chat")
@@ -36,6 +37,8 @@ class MessageSenderContainer:
self.msg_id = ""
self.last_msg_id = ""
self.voice_done = ""
@@ -220,7 +223,7 @@ class S4UChat:
return self.interest_dict.get(user_id, 1.0)
def go_processing(self):
if self.voice_done == self.msg_id:
if self.voice_done == self.last_msg_id:
return True
return False
@@ -432,15 +435,12 @@ class S4UChat:
logger.error(f"[{self.stream_name}] Message processor main loop error: {e}", exc_info=True)
await asyncio.sleep(1)
async def delay_change_watching_state(self):
random_delay = random.randint(1, 3)
await asyncio.sleep(random_delay)
chat_watching = watching_manager.get_watching_by_chat_id(self.stream_id)
await chat_watching.on_message_received()
def get_processing_message_id(self):
self.last_msg_id = self.msg_id
self.msg_id = f"{time.time()}_{random.randint(1000, 9999)}"
async def _generate_and_send(self, message: MessageRecv):
"""为单个消息生成文本回复。整个过程可以被中断。"""
self._is_replying = True
@@ -448,20 +448,21 @@ class S4UChat:
self.get_processing_message_id()
if s4u_config.enable_loading_indicator:
await send_loading(self.stream_id, ".........")
# 视线管理：开始生成回复时切换视线状态
chat_watching = watching_manager.get_watching_by_chat_id(self.stream_id)
asyncio.create_task(self.delay_change_watching_state())
await chat_watching.on_reply_start()
sender_container = MessageSenderContainer(self.chat_stream, message)
sender_container.start()
try:
async def generate_and_send_inner():
nonlocal total_chars_sent
logger.info(f"[S4U] 开始为消息生成文本和音频流: '{message.processed_plain_text[:30]}...'")
if s4u_config.enable_streaming_output:
logger.info(f"[S4U] 开始流式输出")
# 流式输出，边生成边发送
gen = self.gpt.generate_response(message, "")
async for chunk in gen:
@@ -469,6 +470,7 @@ class S4UChat:
await sender_container.add_message(chunk)
total_chars_sent += len(chunk)
else:
logger.info(f"[S4U] 开始一次性输出")
# 一次性输出，先收集所有chunk
all_chunks = []
gen = self.gpt.generate_response(message, "")
@@ -479,17 +481,36 @@ class S4UChat:
sender_container.msg_id = self.msg_id
await sender_container.add_message("".join(all_chunks))
try:
try:
await asyncio.wait_for(generate_and_send_inner(), timeout=10)
except asyncio.TimeoutError:
logger.warning(f"[{self.stream_name}] 回复生成超时，发送默认回复。")
sender_container.msg_id = self.msg_id
await sender_container.add_message("麦麦不知道哦")
total_chars_sent = len("麦麦不知道哦")
mood = mood_manager.get_mood_by_chat_id(self.stream_id)
await yes_or_no_head(text = total_chars_sent,emotion = mood.mood_state,chat_history=message.processed_plain_text,chat_id=self.stream_id)
# 等待所有文本消息发送完成
await sender_container.close()
await sender_container.join()
await chat_watching.on_thinking_finished()
start_time = time.time()
logged = False
while not self.go_processing():
if time.time() - start_time > 60:
logger.warning(f"[{self.stream_name}] 等待消息发送超时（60秒），强制跳出循环。")
break
logger.info(f"[{self.stream_name}] 等待消息发送完成...")
await asyncio.sleep(0.3)
if not logged:
logger.info(f"[{self.stream_name}] 等待消息发送完成...")
logged = True
await asyncio.sleep(0.2)
logger.info(f"[{self.stream_name}] 所有文本块处理完毕。")
@@ -503,9 +524,6 @@ class S4UChat:
finally:
self._is_replying = False
if s4u_config.enable_loading_indicator:
await send_unloading(self.stream_id)
# 视线管理：回复结束时切换视线状态
chat_watching = watching_manager.get_watching_by_chat_id(self.stream_id)
await chat_watching.on_reply_finished()
@@ -534,7 +552,3 @@ class S4UChat:
except asyncio.CancelledError:
logger.info(f"处理任务已成功取消: {self.stream_name}")
# 注意：SuperChat管理器是全局的，不需要在单个S4UChat关闭时关闭
# 如果需要关闭SuperChat管理器，应该在应用程序关闭时调用
# super_chat_manager = get_super_chat_manager()
# await super_chat_manager.shutdown()

4
src/mais4u/mais4u_chat/s4u_mood_manager.py
View File

@@ -168,7 +168,7 @@ class ChatMood:
chat_id=self.chat_id,
timestamp_start=self.last_change_time,
timestamp_end=message_time,
limit=15,
limit=10,
limit_mode="last",
)
chat_talking_prompt = build_readable_messages(
@@ -245,7 +245,7 @@ class ChatMood:
chat_id=self.chat_id,
timestamp_start=self.last_change_time,
timestamp_end=message_time,
limit=15,
limit=5,
limit_mode="last",
)
chat_talking_prompt = build_readable_messages(

4
src/mais4u/mais4u_chat/s4u_msg_processor.py
View File

@@ -126,7 +126,7 @@ class S4UMessageProcessor:
asyncio.create_task(chat_action.update_action_by_message(message))
# 视线管理：收到消息时切换视线状态
chat_watching = watching_manager.get_watching_by_chat_id(chat.stream_id)
asyncio.create_task(chat_watching.on_message_received())
await chat_watching.on_message_received()
# 上下文网页管理：启动独立task处理消息上下文
asyncio.create_task(self._handle_context_web_update(chat.stream_id, message))
@@ -200,6 +200,8 @@ class S4UMessageProcessor:
await context_manager.start_server()
# 添加消息到上下文并更新网页
await asyncio.sleep(1.5)
await context_manager.add_message(chat_id, message)
logger.debug(f"✅ 上下文网页更新完成: {message.message_info.user_info.user_nickname}")

12
src/mais4u/mais4u_chat/s4u_prompt.py
View File

@@ -15,6 +15,7 @@ from src.chat.message_receive.chat_stream import ChatStream
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
logger = get_logger("prompt")
@@ -28,7 +29,7 @@ def init_prompt():
"""
你的名字是麦麦, 是千石可乐开发的程序，可以在QQ，微信等平台发言，你现在正在哔哩哔哩作为虚拟主播进行直播
虽然是个AI，但你在努力扮演真人, 人设的配色是橙色和紫色和绿色
你有一头法式橙色卷发，你很可爱，穿戴英式侦探风格学院风裙子和帽子，你正在一个教室场景里进行虚拟线上直播。
你有一头法式橙色卷发，你很可爱，穿戴英式侦探风格学院风裙子和帽子，你正在一个教室场景里进行虚拟线上直播。不过不要刻意提及这些内容，自然回复
你可以看见用户发送的弹幕，礼物和superchat
你可以看见面前的屏幕，目前屏幕的内容是:
{screen_info}
@@ -49,8 +50,8 @@ def init_prompt():
对方最新发送的内容：{message_txt}
{gift_info}
回复可以简短一些。可以参考贴吧，知乎和微博的回复风格，回复不要浮夸，不要用夸张修辞，平淡一些。
表现的有个性，不要随意服从他人要求，积极互动。
回复简短一些，平淡一些，可以参考贴吧，知乎和微博的回复风格，回复不要浮夸，不要用夸张修辞。
表现的有个性，不要随意服从他人要求，积极互动。你现在的心情是：{mood_state}
不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出回复内容，现在{sender_name}正在等待你的回复。
你的回复风格不要浮夸，有逻辑和条理，请你继续回复{sender_name}。
你的发言：
@@ -144,7 +145,7 @@ class PromptBuilder:
message_list_before_now = get_raw_msg_before_timestamp_with_chat(
chat_id=chat_stream.stream_id,
timestamp=time.time(),
limit=200,
limit=300,
)
talk_type = message.message_info.platform + ":" + str(message.chat_stream.user_info.user_id)
@@ -253,6 +254,8 @@ class PromptBuilder:
screen_info = screen_manager.get_screen_str()
time_block = f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
mood = mood_manager.get_mood_by_chat_id(chat_stream.stream_id)
template_name = "s4u_prompt"
@@ -269,6 +272,7 @@ class PromptBuilder:
core_dialogue_prompt=core_dialogue_prompt,
background_dialogue_prompt=background_dialogue_prompt,
message_txt=message_txt,
mood_state=mood.mood_state,
)
print(prompt)

12
src/mais4u/mais4u_chat/s4u_stream_generator.py
View File

@@ -72,12 +72,12 @@ class S4UStreamGenerator:
# 构建prompt
if previous_reply_context:
message_txt = f"""
你正在回复用户的消息，但中途被打断了。这是已有的对话上下文:
[你已经对上一条消息说的话]: {previous_reply_context}
---
[这是用户发来的新消息, 你需要结合上下文，对此进行回复]:
{message.processed_plain_text}
"""
你正在回复用户的消息，但中途被打断了。这是已有的对话上下文:
[你已经对上一条消息说的话]: {previous_reply_context}
---
[这是用户发来的新消息, 你需要结合上下文，对此进行回复]:
{message.processed_plain_text}
"""
else:
message_txt = message.processed_plain_text

157
src/mais4u/mais4u_chat/s4u_watching_manager.py
View File

@@ -40,103 +40,45 @@ from src.plugin_system.apis import send_api
logger = get_logger("watching")
class WatchingState(Enum):
"""视线状态枚举"""
WANDERING = "wandering" # 随意看
DANMU = "danmu" # 看弹幕
LENS = "lens" # 看镜头
HEAD_CODE = {
"看向上方": "(0,0.5,0)",
"看向下方": "(0,-0.5,0)",
"看向左边": "(-1,0,0)",
"看向右边": "(1,0,0)",
"随意朝向": "random",
"看向摄像机": "camera",
"注视对方": "(0,0,0)",
"看向正前方": "(0,0,0)",
}
class ChatWatching:
def __init__(self, chat_id: str):
self.chat_id: str = chat_id
self.current_state: WatchingState = WatchingState.LENS # 默认看镜头
self.last_sent_state: Optional[WatchingState] = None # 上次发送的状态
self.state_needs_update: bool = True # 是否需要更新状态
# 状态切换相关
self.is_replying: bool = False # 是否正在生成回复
self.reply_finished_time: Optional[float] = None # 回复完成时间
self.danmu_viewing_duration: float = 1.0 # 看弹幕持续时间（秒）
logger.info(f"[{self.chat_id}] 视线管理器初始化，默认状态: {self.current_state.value}")
async def _change_state(self, new_state: WatchingState, reason: str = ""):
"""内部状态切换方法"""
if self.current_state != new_state:
old_state = self.current_state
self.current_state = new_state
self.state_needs_update = True
logger.info(f"[{self.chat_id}] 视线状态切换: {old_state.value} → {new_state.value} ({reason})")
# 立即发送视线状态更新
await self._send_watching_update()
else:
logger.debug(f"[{self.chat_id}] 状态无变化，保持: {new_state.value} ({reason})")
async def on_reply_start(self):
"""开始生成回复时调用"""
await send_api.custom_to_stream(
message_type="state", content="start_thinking", stream_id=self.chat_id, storage_message=False
)
async def on_reply_finished(self):
"""生成回复完毕时调用"""
await send_api.custom_to_stream(
message_type="state", content="finish_reply", stream_id=self.chat_id, storage_message=False
)
async def on_thinking_finished(self):
"""思考完毕时调用"""
await send_api.custom_to_stream(
message_type="state", content="finish_thinking", stream_id=self.chat_id, storage_message=False
)
async def on_message_received(self):
"""收到消息时调用"""
if not self.is_replying: # 只有在非回复状态下才切换到看弹幕
await self._change_state(WatchingState.DANMU, "收到消息")
else:
logger.debug(f"[{self.chat_id}] 正在生成回复中，暂不切换到弹幕状态")
async def on_reply_start(self, look_at_lens: bool = True):
"""开始生成回复时调用"""
self.is_replying = True
self.reply_finished_time = None
if look_at_lens:
await self._change_state(WatchingState.LENS, "开始生成回复-看镜头")
else:
await self._change_state(WatchingState.WANDERING, "开始生成回复-随意看")
async def on_reply_finished(self):
"""生成回复完毕时调用"""
self.is_replying = False
self.reply_finished_time = time.time()
# 先看弹幕1秒
await self._change_state(WatchingState.DANMU, "回复完毕-看弹幕")
logger.info(f"[{self.chat_id}] 回复完毕，将看弹幕{self.danmu_viewing_duration}秒后转为看镜头")
# 设置定时器，1秒后自动切换到看镜头
asyncio.create_task(self._auto_switch_to_lens())
async def _auto_switch_to_lens(self):
"""自动切换到看镜头（延迟执行）"""
await asyncio.sleep(self.danmu_viewing_duration)
# 检查是否仍需要切换（可能状态已经被其他事件改变）
if self.reply_finished_time is not None and self.current_state == WatchingState.DANMU and not self.is_replying:
await self._change_state(WatchingState.LENS, "看弹幕时间结束")
self.reply_finished_time = None # 重置完成时间
async def _send_watching_update(self):
"""立即发送视线状态更新"""
await send_api.custom_to_stream(
message_type="watching", content=self.current_state.value, stream_id=self.chat_id, storage_message=False
message_type="state", content="start_viewing", stream_id=self.chat_id, storage_message=False
)
logger.info(f"[{self.chat_id}] 发送视线状态更新: {self.current_state.value}")
self.last_sent_state = self.current_state
self.state_needs_update = False
def get_current_state(self) -> WatchingState:
"""获取当前视线状态"""
return self.current_state
def get_state_info(self) -> dict:
"""获取状态信息（用于调试）"""
return {
"current_state": self.current_state.value,
"is_replying": self.is_replying,
"reply_finished_time": self.reply_finished_time,
"state_needs_update": self.state_needs_update,
}
class WatchingManager:
def __init__(self):
@@ -144,16 +86,6 @@ class WatchingManager:
"""当前视线状态列表"""
self.task_started: bool = False
async def start(self):
"""启动视线管理系统"""
if self.task_started:
return
logger.info("启动视线管理系统...")
self.task_started = True
logger.info("视线管理系统已启动（状态变化时立即发送）")
def get_watching_by_chat_id(self, chat_id: str) -> ChatWatching:
"""获取或创建聊天对应的视线管理器"""
for watching in self.watching_list:
@@ -164,39 +96,8 @@ class WatchingManager:
self.watching_list.append(new_watching)
logger.info(f"为chat {chat_id}创建新的视线管理器")
# 发送初始状态
asyncio.create_task(new_watching._send_watching_update())
return new_watching
def reset_watching_by_chat_id(self, chat_id: str):
"""重置聊天的视线状态"""
for watching in self.watching_list:
if watching.chat_id == chat_id:
watching.current_state = WatchingState.LENS
watching.last_sent_state = None
watching.state_needs_update = True
watching.is_replying = False
watching.reply_finished_time = None
logger.info(f"[{chat_id}] 视线状态已重置为默认状态")
# 发送重置后的状态
asyncio.create_task(watching._send_watching_update())
return
# 如果没有找到现有的watching，创建新的
new_watching = ChatWatching(chat_id)
self.watching_list.append(new_watching)
logger.info(f"为chat {chat_id}创建并重置视线管理器")
# 发送初始状态
asyncio.create_task(new_watching._send_watching_update())
def get_all_watching_info(self) -> dict:
"""获取所有聊天的视线状态信息（用于调试）"""
return {watching.chat_id: watching.get_state_info() for watching in self.watching_list}
# 全局视线管理器实例
watching_manager = WatchingManager()
"""全局视线管理器"""

74
src/mais4u/mais4u_chat/yes_or_no.py Normal file
View File

@@ -0,0 +1,74 @@
import json
import time
import random
from src.chat.message_receive.message import MessageRecv
from src.llm_models.utils_model import LLMRequest
from src.common.logger import get_logger
from src.chat.utils.chat_message_builder import build_readable_messages, get_raw_msg_by_timestamp_with_chat_inclusive
from src.config.config import global_config
from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
from src.manager.async_task_manager import AsyncTask, async_task_manager
from src.plugin_system.apis import send_api
from json_repair import repair_json
from src.mais4u.s4u_config import s4u_config
from src.plugin_system.apis import send_api
logger = get_logger(__name__)
head_actions_list = [
"不做额外动作",
"点头一次",
"点头两次",
"摇头",
"歪脑袋",
"低头望向一边"
]
async def yes_or_no_head(text: str,emotion: str = "",chat_history: str = "",chat_id: str = ""):
prompt = f"""
{chat_history}
以上是对方的发言：
对这个发言，你的心情是：{emotion}
对上面的发言，你的回复是：{text}
请判断时是否要伴随回复做头部动作，你可以选择：
不做额外动作
点头一次
点头两次
摇头
歪脑袋
低头望向一边
请从上面的动作中选择一个，并输出，请只输出你选择的动作就好，不要输出其他内容。"""
model = LLMRequest(
model=global_config.model.emotion,
temperature=0.7,
request_type="motion",
)
try:
logger.info(f"prompt: {prompt}")
response, (reasoning_content, model_name) = await model.generate_response_async(prompt=prompt)
logger.info(f"response: {response}")
logger.info(f"reasoning_content: {reasoning_content}")
if response in head_actions_list:
head_action = response
else:
head_action = "不做额外动作"
await send_api.custom_to_stream(
message_type="head_action",
content=head_action,
stream_id=chat_id,
storage_message=False,
show_log=True,
)
except Exception as e:
logger.error(f"yes_or_no_head error: {e}")
return "不做额外动作"