527 lines
21 KiB
Python
527 lines
21 KiB
Python
import random
|
||
import time
|
||
from dataclasses import dataclass, field
|
||
from datetime import datetime
|
||
from typing import Awaitable, Callable, Dict, List, Optional, Tuple
|
||
|
||
from rich.console import Group, RenderableType
|
||
from rich.panel import Panel
|
||
from rich.text import Text
|
||
|
||
from src.chat.message_receive.chat_manager import BotChatSession
|
||
from src.chat.message_receive.message import SessionMessage
|
||
from src.cli.console import console
|
||
from src.common.data_models.message_component_data_model import MessageSequence, TextComponent
|
||
from src.common.data_models.reply_generation_data_models import (
|
||
GenerationMetrics,
|
||
LLMCompletionResult,
|
||
ReplyGenerationResult,
|
||
)
|
||
from src.common.logger import get_logger
|
||
from src.common.prompt_i18n import load_prompt
|
||
from src.config.config import global_config
|
||
from src.core.types import ActionInfo
|
||
from src.llm_models.payload_content.message import ImageMessagePart, Message, MessageBuilder, RoleType, TextMessagePart
|
||
from src.maisaka.monitor_events import emit_replier_request, emit_replier_response
|
||
from src.services.llm_service import LLMServiceClient
|
||
|
||
from src.maisaka.context_messages import (
|
||
AssistantMessage,
|
||
LLMContextMessage,
|
||
ReferenceMessage,
|
||
SessionBackedMessage,
|
||
ToolResultMessage,
|
||
)
|
||
from .maisaka_expression_selector import maisaka_expression_selector
|
||
from src.maisaka.message_adapter import clone_message_sequence, parse_speaker_content
|
||
from src.maisaka.prompt_cli_renderer import PromptCLIVisualizer
|
||
|
||
logger = get_logger("replyer")
|
||
|
||
|
||
@dataclass
|
||
class MaisakaReplyContext:
|
||
"""Maisaka replyer 使用的回复上下文。"""
|
||
|
||
expression_habits: str = ""
|
||
selected_expression_ids: List[int] = field(default_factory=list)
|
||
|
||
|
||
class MaisakaReplyGenerator:
|
||
"""生成 Maisaka 的最终可见回复（多模态管线）。"""
|
||
|
||
def __init__(
|
||
self,
|
||
chat_stream: Optional[BotChatSession] = None,
|
||
request_type: str = "maisaka_replyer",
|
||
) -> None:
|
||
self.chat_stream = chat_stream
|
||
self.request_type = request_type
|
||
self.express_model = LLMServiceClient(
|
||
task_name="replyer",
|
||
request_type=request_type,
|
||
)
|
||
self._personality_prompt = self._build_personality_prompt()
|
||
|
||
def _build_personality_prompt(self) -> str:
|
||
"""构建 replyer 使用的人设提示。"""
|
||
try:
|
||
bot_name = global_config.bot.nickname
|
||
alias_names = global_config.bot.alias_names
|
||
bot_aliases = f"，也有人叫你{','.join(alias_names)}" if alias_names else ""
|
||
|
||
prompt_personality = global_config.personality.personality
|
||
if (
|
||
hasattr(global_config.personality, "states")
|
||
and global_config.personality.states
|
||
and hasattr(global_config.personality, "state_probability")
|
||
and global_config.personality.state_probability > 0
|
||
and random.random() < global_config.personality.state_probability
|
||
):
|
||
prompt_personality = random.choice(global_config.personality.states)
|
||
|
||
return f"你的名字是{bot_name}{bot_aliases}，你{prompt_personality};"
|
||
except Exception as exc:
|
||
logger.warning(f"构建 Maisaka 人设提示词失败: {exc}")
|
||
return "你的名字是麦麦，你是一个活泼可爱的 AI 助手。"
|
||
|
||
@staticmethod
|
||
def _normalize_content(content: str, limit: int = 500) -> str:
|
||
normalized = " ".join((content or "").split())
|
||
if len(normalized) > limit:
|
||
return normalized[:limit] + "..."
|
||
return normalized
|
||
|
||
@staticmethod
|
||
def _extract_visible_assistant_reply(message: AssistantMessage) -> str:
|
||
del message
|
||
return ""
|
||
|
||
def _extract_guided_bot_reply(self, message: SessionBackedMessage) -> str:
|
||
speaker_name, body = parse_speaker_content(message.processed_plain_text.strip())
|
||
bot_nickname = global_config.bot.nickname.strip() or "Bot"
|
||
if speaker_name == bot_nickname:
|
||
return self._normalize_content(body.strip())
|
||
return ""
|
||
|
||
@staticmethod
|
||
def _split_user_message_segments(raw_content: str) -> List[tuple[Optional[str], str]]:
|
||
segments: List[tuple[Optional[str], str]] = []
|
||
current_speaker: Optional[str] = None
|
||
current_lines: List[str] = []
|
||
|
||
for raw_line in raw_content.splitlines():
|
||
speaker_name, content_body = parse_speaker_content(raw_line)
|
||
if speaker_name is not None:
|
||
if current_lines:
|
||
segments.append((current_speaker, "\n".join(current_lines)))
|
||
current_speaker = speaker_name
|
||
current_lines = [content_body]
|
||
continue
|
||
|
||
current_lines.append(raw_line)
|
||
|
||
if current_lines:
|
||
segments.append((current_speaker, "\n".join(current_lines)))
|
||
|
||
return segments
|
||
|
||
def _build_target_message_block(self, reply_message: Optional[SessionMessage]) -> str:
|
||
if reply_message is None:
|
||
return ""
|
||
|
||
user_info = reply_message.message_info.user_info
|
||
sender_name = user_info.user_cardname or user_info.user_nickname or user_info.user_id
|
||
target_message_id = reply_message.message_id.strip() if reply_message.message_id else "未知"
|
||
target_content = self._normalize_content((reply_message.processed_plain_text or "").strip(), limit=300)
|
||
if not target_content:
|
||
target_content = "[无可见文本内容]"
|
||
|
||
return (
|
||
"【本次回复目标】\n"
|
||
f"- 目标消息ID：{target_message_id}\n"
|
||
f"- 发送者：{sender_name}\n"
|
||
f"- 消息内容：{target_content}\n"
|
||
"- 你这次要回复的就是这条目标消息，请结合整段上下文理解，但不要把其他历史消息当成当前回复对象。"
|
||
)
|
||
|
||
def _build_system_prompt(
|
||
self,
|
||
reply_message: Optional[SessionMessage],
|
||
reply_reason: str,
|
||
expression_habits: str = "",
|
||
) -> str:
|
||
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||
target_message_block = self._build_target_message_block(reply_message)
|
||
|
||
try:
|
||
system_prompt = load_prompt(
|
||
"maisaka_replyer",
|
||
bot_name=global_config.bot.nickname,
|
||
time_block=f"当前时间：{current_time}",
|
||
identity=self._personality_prompt,
|
||
reply_style=global_config.personality.reply_style,
|
||
)
|
||
except Exception:
|
||
system_prompt = "你是一个友好的 AI 助手，请根据聊天记录自然回复。"
|
||
|
||
sections: List[str] = []
|
||
if expression_habits.strip():
|
||
sections.append(expression_habits.strip())
|
||
if target_message_block:
|
||
sections.append(target_message_block)
|
||
if reply_reason.strip():
|
||
sections.append(f"【回复信息参考】\n{reply_reason}")
|
||
if not sections:
|
||
return system_prompt
|
||
return f"{system_prompt}\n\n" + "\n\n".join(sections)
|
||
|
||
def _build_reply_instruction(self) -> str:
|
||
return "请基于以上上下文，自然地继续回复。直接输出你要说的话，不需要额外解释。"
|
||
|
||
def _build_multimodal_user_message(
|
||
self,
|
||
message: SessionBackedMessage,
|
||
default_user_name: str,
|
||
) -> Optional[Message]:
|
||
speaker_name, _ = parse_speaker_content(message.processed_plain_text.strip())
|
||
visible_speaker = speaker_name or default_user_name
|
||
|
||
raw_message = clone_message_sequence(message.raw_message)
|
||
if not raw_message.components:
|
||
raw_message = MessageSequence([TextComponent(f"[{visible_speaker}]")])
|
||
elif isinstance(raw_message.components[0], TextComponent):
|
||
first_text = raw_message.components[0].text or ""
|
||
raw_message.components[0] = TextComponent(f"[{visible_speaker}]{first_text}")
|
||
else:
|
||
raw_message.components.insert(0, TextComponent(f"[{visible_speaker}]"))
|
||
|
||
multimodal_message = SessionBackedMessage(
|
||
raw_message=raw_message,
|
||
visible_text=f"[{visible_speaker}]{message.processed_plain_text}",
|
||
timestamp=message.timestamp,
|
||
message_id=message.message_id,
|
||
original_message=message.original_message,
|
||
source_kind=message.source_kind,
|
||
)
|
||
return multimodal_message.to_llm_message()
|
||
|
||
def _build_history_messages(self, chat_history: List[LLMContextMessage]) -> List[Message]:
|
||
bot_nickname = global_config.bot.nickname.strip() or "Bot"
|
||
default_user_name = global_config.maisaka.cli_user_name.strip() or "User"
|
||
messages: List[Message] = []
|
||
|
||
for message in chat_history:
|
||
if isinstance(message, (ReferenceMessage, ToolResultMessage)):
|
||
continue
|
||
|
||
if isinstance(message, SessionBackedMessage):
|
||
guided_reply = self._extract_guided_bot_reply(message)
|
||
if guided_reply:
|
||
messages.append(
|
||
MessageBuilder().set_role(RoleType.Assistant).add_text_content(guided_reply).build()
|
||
)
|
||
continue
|
||
|
||
multimodal_message = self._build_multimodal_user_message(message, default_user_name)
|
||
if multimodal_message is not None:
|
||
messages.append(multimodal_message)
|
||
continue
|
||
|
||
for speaker_name, content_body in self._split_user_message_segments(message.processed_plain_text):
|
||
content = self._normalize_content(content_body)
|
||
if not content:
|
||
continue
|
||
|
||
visible_speaker = speaker_name or default_user_name
|
||
if visible_speaker == bot_nickname:
|
||
messages.append(
|
||
MessageBuilder().set_role(RoleType.Assistant).add_text_content(content).build()
|
||
)
|
||
continue
|
||
|
||
user_content = f"[{visible_speaker}]{content}"
|
||
messages.append(MessageBuilder().set_role(RoleType.User).add_text_content(user_content).build())
|
||
continue
|
||
|
||
if isinstance(message, AssistantMessage):
|
||
visible_reply = self._extract_visible_assistant_reply(message)
|
||
if visible_reply:
|
||
messages.append(
|
||
MessageBuilder().set_role(RoleType.Assistant).add_text_content(visible_reply).build()
|
||
)
|
||
|
||
return messages
|
||
|
||
def _build_request_messages(
|
||
self,
|
||
chat_history: List[LLMContextMessage],
|
||
reply_message: Optional[SessionMessage],
|
||
reply_reason: str,
|
||
expression_habits: str = "",
|
||
) -> List[Message]:
|
||
messages: List[Message] = []
|
||
system_prompt = self._build_system_prompt(
|
||
reply_message=reply_message,
|
||
reply_reason=reply_reason,
|
||
expression_habits=expression_habits,
|
||
)
|
||
instruction = self._build_reply_instruction()
|
||
|
||
messages.append(MessageBuilder().set_role(RoleType.System).add_text_content(system_prompt).build())
|
||
messages.extend(self._build_history_messages(chat_history))
|
||
messages.append(MessageBuilder().set_role(RoleType.User).add_text_content(instruction).build())
|
||
return messages
|
||
|
||
@staticmethod
|
||
def _build_request_prompt_preview(messages: List[Message]) -> str:
|
||
preview_lines: List[str] = []
|
||
for message in messages:
|
||
role_name = message.role.value.capitalize()
|
||
part_previews: List[str] = []
|
||
for part in message.parts:
|
||
if isinstance(part, TextMessagePart):
|
||
part_previews.append(part.text)
|
||
continue
|
||
if isinstance(part, ImageMessagePart):
|
||
part_previews.append(f"[图片:{part.normalized_image_format}]")
|
||
preview_lines.append(f"{role_name}: {''.join(part_previews)}")
|
||
return "\n\n".join(preview_lines)
|
||
|
||
def _resolve_session_id(self, stream_id: Optional[str]) -> str:
|
||
if stream_id:
|
||
return stream_id
|
||
if self.chat_stream is not None:
|
||
return self.chat_stream.session_id
|
||
return ""
|
||
|
||
async def _build_reply_context(
|
||
self,
|
||
chat_history: List[LLMContextMessage],
|
||
reply_message: Optional[SessionMessage],
|
||
reply_reason: str,
|
||
stream_id: Optional[str],
|
||
sub_agent_runner: Optional[Callable[[str], Awaitable[str]]],
|
||
) -> MaisakaReplyContext:
|
||
session_id = self._resolve_session_id(stream_id)
|
||
if not session_id:
|
||
logger.warning("构建 Maisaka 回复上下文失败：缺少会话标识")
|
||
return MaisakaReplyContext()
|
||
|
||
if sub_agent_runner is None:
|
||
logger.info("表达方式选择跳过：缺少子代理执行器")
|
||
return MaisakaReplyContext()
|
||
|
||
selection_result = await maisaka_expression_selector.select_for_reply(
|
||
session_id=session_id,
|
||
chat_history=chat_history,
|
||
reply_message=reply_message,
|
||
reply_reason=reply_reason,
|
||
sub_agent_runner=sub_agent_runner,
|
||
)
|
||
return MaisakaReplyContext(
|
||
expression_habits=selection_result.expression_habits,
|
||
selected_expression_ids=selection_result.selected_expression_ids,
|
||
)
|
||
|
||
async def generate_reply_with_context(
|
||
self,
|
||
extra_info: str = "",
|
||
reply_reason: str = "",
|
||
available_actions: Optional[Dict[str, ActionInfo]] = None,
|
||
chosen_actions: Optional[List[object]] = None,
|
||
from_plugin: bool = True,
|
||
stream_id: Optional[str] = None,
|
||
reply_message: Optional[SessionMessage] = None,
|
||
reply_time_point: Optional[float] = None,
|
||
think_level: int = 1,
|
||
unknown_words: Optional[List[str]] = None,
|
||
log_reply: bool = True,
|
||
chat_history: Optional[List[LLMContextMessage]] = None,
|
||
expression_habits: str = "",
|
||
selected_expression_ids: Optional[List[int]] = None,
|
||
sub_agent_runner: Optional[Callable[[str], Awaitable[str]]] = None,
|
||
) -> Tuple[bool, ReplyGenerationResult]:
|
||
del available_actions
|
||
del chosen_actions
|
||
del extra_info
|
||
del from_plugin
|
||
del log_reply
|
||
del reply_time_point
|
||
del think_level
|
||
del unknown_words
|
||
|
||
result = ReplyGenerationResult()
|
||
if chat_history is None:
|
||
result.error_message = "聊天历史为空"
|
||
return False, result
|
||
|
||
logger.info(
|
||
f"Maisaka 回复器开始生成: 流={stream_id} 原因={reply_reason!r} "
|
||
f"历史条数={len(chat_history)} 目标ID={reply_message.message_id if reply_message else None}"
|
||
)
|
||
|
||
filtered_history = [
|
||
message
|
||
for message in chat_history
|
||
if not isinstance(message, (ReferenceMessage, ToolResultMessage))
|
||
]
|
||
|
||
if self.express_model is None:
|
||
logger.error("回复模型未初始化")
|
||
result.error_message = "回复模型尚未初始化"
|
||
return False, result
|
||
|
||
try:
|
||
reply_context = await self._build_reply_context(
|
||
chat_history=filtered_history,
|
||
reply_message=reply_message,
|
||
reply_reason=reply_reason or "",
|
||
stream_id=stream_id,
|
||
sub_agent_runner=sub_agent_runner,
|
||
)
|
||
except Exception as exc:
|
||
import traceback
|
||
logger.error(f"构建回复上下文失败: {exc}\n{traceback.format_exc()}")
|
||
result.error_message = f"构建回复上下文失败: {exc}"
|
||
return False, result
|
||
|
||
merged_expression_habits = expression_habits.strip() or reply_context.expression_habits
|
||
result.selected_expression_ids = (
|
||
list(selected_expression_ids)
|
||
if selected_expression_ids is not None
|
||
else list(reply_context.selected_expression_ids)
|
||
)
|
||
|
||
logger.info(
|
||
f"回复上下文完成: 流={stream_id} 已选表达={result.selected_expression_ids!r}"
|
||
)
|
||
|
||
try:
|
||
request_messages = self._build_request_messages(
|
||
chat_history=filtered_history,
|
||
reply_message=reply_message,
|
||
reply_reason=reply_reason or "",
|
||
expression_habits=merged_expression_habits,
|
||
)
|
||
except Exception as exc:
|
||
import traceback
|
||
logger.error(f"构建提示词失败: {exc}\n{traceback.format_exc()}")
|
||
result.error_message = f"构建提示词失败: {exc}"
|
||
return False, result
|
||
|
||
prompt_preview = self._build_request_prompt_preview(request_messages)
|
||
|
||
def message_factory(_client: object) -> List[Message]:
|
||
return request_messages
|
||
|
||
result.completion.request_prompt = prompt_preview
|
||
preview_chat_id = self._resolve_session_id(stream_id)
|
||
replyer_prompt_section: RenderableType | None = None
|
||
if global_config.debug.show_replyer_prompt:
|
||
replyer_prompt_section = PromptCLIVisualizer.build_text_section(
|
||
prompt_preview,
|
||
category="replyer",
|
||
chat_id=preview_chat_id,
|
||
request_kind="replyer",
|
||
subtitle=f"流ID: {preview_chat_id}",
|
||
folded=global_config.debug.fold_maisaka_thinking,
|
||
)
|
||
|
||
started_at = time.perf_counter()
|
||
|
||
# 向监控前端广播回复器请求事件
|
||
await emit_replier_request(
|
||
session_id=preview_chat_id,
|
||
messages=request_messages,
|
||
model_name=getattr(self.express_model, "model_name", ""),
|
||
)
|
||
|
||
try:
|
||
generation_result = await self.express_model.generate_response_with_messages(
|
||
message_factory=message_factory
|
||
)
|
||
except Exception as exc:
|
||
logger.exception("Maisaka 回复器调用失败")
|
||
result.error_message = str(exc)
|
||
result.metrics = GenerationMetrics(
|
||
overall_ms=round((time.perf_counter() - started_at) * 1000, 2),
|
||
)
|
||
return False, result
|
||
|
||
response_text = (generation_result.response or "").strip()
|
||
result.success = bool(response_text)
|
||
result.completion = LLMCompletionResult(
|
||
request_prompt=prompt_preview,
|
||
response_text=response_text,
|
||
reasoning_text=generation_result.reasoning or "",
|
||
model_name=generation_result.model_name or "",
|
||
tool_calls=generation_result.tool_calls or [],
|
||
)
|
||
result.metrics = GenerationMetrics(
|
||
overall_ms=round((time.perf_counter() - started_at) * 1000, 2),
|
||
)
|
||
|
||
# 向监控前端广播回复器响应事件
|
||
await emit_replier_response(
|
||
session_id=preview_chat_id,
|
||
content=response_text,
|
||
reasoning=generation_result.reasoning or "",
|
||
model_name=generation_result.model_name or "",
|
||
prompt_tokens=generation_result.prompt_tokens,
|
||
completion_tokens=generation_result.completion_tokens,
|
||
total_tokens=generation_result.total_tokens,
|
||
duration_ms=result.metrics.overall_ms or 0.0,
|
||
success=result.success,
|
||
)
|
||
|
||
if global_config.debug.show_replyer_reasoning and result.completion.reasoning_text:
|
||
logger.info(f"Maisaka 回复器思考内容：\n{result.completion.reasoning_text}")
|
||
|
||
if not result.success:
|
||
result.error_message = "回复器返回了空内容"
|
||
logger.warning("Maisaka 回复器返回了空内容")
|
||
return False, result
|
||
|
||
logger.info(
|
||
f"Maisaka 回复器生成成功: 文本={response_text!r} 总耗时ms={result.metrics.overall_ms} 已选表达={result.selected_expression_ids!r}"
|
||
)
|
||
if global_config.debug.show_replyer_prompt or global_config.debug.show_replyer_reasoning:
|
||
summary_lines = [
|
||
f"流ID: {preview_chat_id or 'unknown'}",
|
||
f"耗时: {result.metrics.overall_ms} ms",
|
||
]
|
||
if result.selected_expression_ids:
|
||
summary_lines.append(f"表达编号: {result.selected_expression_ids!r}")
|
||
|
||
renderables: List[RenderableType] = [Text("\n".join(summary_lines))]
|
||
if replyer_prompt_section is not None:
|
||
renderables.append(replyer_prompt_section)
|
||
if global_config.debug.show_replyer_reasoning and result.completion.reasoning_text:
|
||
renderables.append(
|
||
Panel(
|
||
Text(result.completion.reasoning_text),
|
||
title="思考内容",
|
||
border_style="magenta",
|
||
padding=(0, 1),
|
||
)
|
||
)
|
||
renderables.append(
|
||
Panel(
|
||
Text(response_text),
|
||
title="回复结果",
|
||
border_style="green",
|
||
padding=(0, 1),
|
||
)
|
||
)
|
||
console.print(
|
||
Panel(
|
||
Group(*renderables),
|
||
title="MaiSaka 回复器",
|
||
border_style="bright_yellow",
|
||
padding=(0, 1),
|
||
)
|
||
)
|
||
result.text_fragments = [response_text]
|
||
return True, result
|