""" Maisaka runtime for non-CLI integrations. """ from datetime import datetime from pathlib import Path from typing import Optional import asyncio from src.chat.message_receive.chat_manager import BotChatSession, chat_manager from src.chat.message_receive.message import SessionMessage from src.common.data_models.mai_message_data_model import GroupInfo, MaiMessage, UserInfo from src.common.data_models.message_component_data_model import MessageSequence from src.common.logger import get_logger from src.config.config import global_config from src.llm_models.payload_content.tool_option import ToolCall from src.services import send_service from .config import ( DIRECT_IMAGE_INPUT, ENABLE_KNOWLEDGE_MODULE, ENABLE_LIST_FILES, ENABLE_MCP, ENABLE_READ_FILE, ENABLE_WRITE_FILE, MERGE_USER_MESSAGES, ) from .knowledge import retrieve_relevant_knowledge from .llm_service import MaiSakaLLMService from .mcp_client import MCPManager from .message_adapter import ( build_message, build_visible_text_from_sequence, clone_message_sequence, format_speaker_content, get_message_role, remove_last_perception, ) from .tool_handlers import handle_list_files, handle_mcp_tool, handle_read_file, handle_unknown_tool, handle_write_file logger = get_logger("maisaka_runtime") class MaisakaHeartFlowChatting: """Session-scoped Maisaka runtime that replaces the HFC planner and reply loop.""" def __init__(self, session_id: str): self.session_id = session_id self.chat_stream: Optional[BotChatSession] = chat_manager.get_session_by_session_id(session_id) if self.chat_stream is None: raise ValueError(f"Session not found for Maisaka runtime: {session_id}") session_name = chat_manager.get_session_name(session_id) or session_id self.log_prefix = f"[{session_name}]" self._llm_service = MaiSakaLLMService(api_key="", base_url=None, model="") self._chat_history: list[MaiMessage] = [] self._mcp_manager: Optional[MCPManager] = None self._pending_messages: list[SessionMessage] = [] self._source_messages_by_id: dict[str, SessionMessage] = {} self._running = False self._loop_task: Optional[asyncio.Task] = None self._loop_lock = asyncio.Lock() self._new_message_event = asyncio.Event() self._max_internal_rounds = 6 self._chat_start_time: Optional[datetime] = None self._last_user_input_time: Optional[datetime] = None self._last_assistant_response_time: Optional[datetime] = None self._user_input_times: list[datetime] = [] self._max_context_size = max(1, int(global_config.chat.max_context_size)) async def start(self) -> None: """Start the runtime loop.""" if self._running: return if ENABLE_MCP: await self._init_mcp() self._running = True self._loop_task = asyncio.create_task(self._main_loop()) logger.info(f"{self.log_prefix} MaiSaka 运行时已启动") async def stop(self) -> None: """Stop the runtime loop.""" if not self._running: return self._running = False self._new_message_event.set() if self._loop_task is not None: self._loop_task.cancel() try: await self._loop_task except asyncio.CancelledError: pass finally: self._loop_task = None if self._mcp_manager is not None: await self._mcp_manager.close() self._mcp_manager = None logger.info(f"{self.log_prefix} MaiSaka 运行时已停止") def adjust_talk_frequency(self, frequency: float) -> None: """Compatibility shim for the existing manager API.""" _ = frequency async def register_message(self, message: SessionMessage) -> None: """Queue a newly received message for Maisaka processing.""" self._pending_messages.append(message) self._source_messages_by_id[message.message_id] = message self._new_message_event.set() async def _main_loop(self) -> None: try: while self._running: await self._new_message_event.wait() self._new_message_event.clear() async with self._loop_lock: pending_messages = self._drain_pending_messages() if not pending_messages: continue await self._ingest_messages(pending_messages) await self._run_internal_loop(anchor_message=pending_messages[-1]) except asyncio.CancelledError: logger.info(f"{self.log_prefix} MaiSaka 运行循环已取消") def _drain_pending_messages(self) -> list[SessionMessage]: drained_messages = list(self._pending_messages) self._pending_messages.clear() return drained_messages async def _init_mcp(self) -> None: """Initialize MCP tools for the runtime and inject them into the planner.""" config_path = Path(__file__).with_name("mcp_config.json") self._mcp_manager = await MCPManager.from_config(str(config_path)) if self._mcp_manager is None: logger.info(f"{self.log_prefix} MaiSaka 运行时的 MCP 不可用") return mcp_tools = self._mcp_manager.get_openai_tools() if not mcp_tools: logger.info(f"{self.log_prefix} MCP 管理器已初始化，但未暴露任何工具") return self._llm_service.set_extra_tools(mcp_tools) logger.info( f"{self.log_prefix} 已为 MaiSaka 运行时加载 {len(mcp_tools)} 个 MCP 工具：\n" f"{self._mcp_manager.get_tool_summary()}" ) async def _ingest_messages(self, messages: list[SessionMessage]) -> None: if self._chat_start_time is None: self._chat_start_time = messages[0].timestamp self._last_user_input_time = messages[-1].timestamp self._user_input_times.extend(message.timestamp for message in messages) if MERGE_USER_MESSAGES: merged_sequence = await self._merge_messages(messages) merged_content = build_visible_text_from_sequence(merged_sequence).strip() if not merged_sequence.components: return self._chat_history.append( build_message( role="user", content=merged_content, source="user", timestamp=messages[-1].timestamp, platform=messages[-1].platform, session_id=self.session_id, group_info=self._build_group_info(messages[-1]), user_info=self._build_runtime_user_info(), raw_message=merged_sequence, display_text=merged_content, ) ) self._trim_chat_history() return for message in messages: history_message = await self._build_user_history_message(message) if history_message is None: continue self._chat_history.append(history_message) self._trim_chat_history() async def _merge_messages(self, messages: list[SessionMessage]) -> MessageSequence: merged_sequence = MessageSequence([]) for message in messages: user_info = message.message_info.user_info speaker_name = user_info.user_cardname or user_info.user_nickname or user_info.user_id prefix = format_speaker_content(speaker_name, "", message.timestamp, message.message_id) merged_sequence.text(prefix) appended_component = False if DIRECT_IMAGE_INPUT: source_sequence = getattr(message, "maisaka_original_raw_message", message.raw_message) else: source_sequence = message.raw_message for component in clone_message_sequence(source_sequence).components: merged_sequence.components.append(component) appended_component = True if not appended_component: if not message.processed_plain_text: await message.process() content = (message.processed_plain_text or "").strip() if content: merged_sequence.text(content) merged_sequence.text("\n") return merged_sequence async def _build_user_history_message(self, message: SessionMessage) -> Optional[MaiMessage]: user_sequence = await self._build_message_sequence(message) visible_text = build_visible_text_from_sequence(user_sequence).strip() if not user_sequence.components: return None return build_message( role="user", content=visible_text, source="user", timestamp=message.timestamp, platform=message.platform, session_id=self.session_id, group_info=self._build_group_info(message), user_info=self._build_runtime_user_info(), raw_message=user_sequence, display_text=visible_text, ) async def _build_message_sequence(self, message: SessionMessage) -> MessageSequence: message_sequence = MessageSequence([]) user_info = message.message_info.user_info speaker_name = user_info.user_cardname or user_info.user_nickname or user_info.user_id message_sequence.text(format_speaker_content(speaker_name, "", message.timestamp, message.message_id)) appended_component = False if DIRECT_IMAGE_INPUT: source_sequence = getattr(message, "maisaka_original_raw_message", message.raw_message) else: source_sequence = message.raw_message for component in clone_message_sequence(source_sequence).components: message_sequence.components.append(component) appended_component = True if not appended_component: if not message.processed_plain_text: await message.process() content = (message.processed_plain_text or "").strip() if content: message_sequence.text(content) return message_sequence async def _run_internal_loop(self, anchor_message: SessionMessage) -> None: last_had_tool_calls = True for round_index in range(self._max_internal_rounds): logger.info( f"{self.log_prefix} 内部循环第 {round_index + 1}/{self._max_internal_rounds} 轮已开始" f"（历史消息数={len(self._chat_history)}）" ) if last_had_tool_calls: logger.info(f"{self.log_prefix} 调用规划器前正在构建感知快照") await self._append_perception_snapshot() logger.info(f"{self.log_prefix} 感知快照步骤已完成") logger.info(f"{self.log_prefix} 正在调用 MaiSaka 对话循环步骤") response = await self._llm_service.chat_loop_step(self._chat_history) logger.info( f"{self.log_prefix} 对话循环步骤已返回" f"（内容长度={len(response.content or '')}，工具调用数={len(response.tool_calls)}）" ) response.raw_message.platform = anchor_message.platform response.raw_message.session_id = self.session_id response.raw_message.message_info.group_info = self._build_group_info(anchor_message) self._chat_history.append(response.raw_message) self._last_assistant_response_time = datetime.now() if response.tool_calls: logger.info(f"{self.log_prefix} 正在处理 {len(response.tool_calls)} 个工具调用") should_pause = await self._handle_tool_calls(response.tool_calls, response.content or "", anchor_message) logger.info(f"{self.log_prefix} 工具处理已完成（是否应暂停={should_pause}）") if should_pause: return last_had_tool_calls = True continue if response.content: logger.info(f"{self.log_prefix} 规划器返回了内容但没有工具调用，继续内部循环") last_had_tool_calls = False continue logger.info(f"{self.log_prefix} 规划器返回空内容且没有工具调用，退出内部循环") return logger.info(f"{self.log_prefix} MaiSaka 内部循环已达到最大轮次并暂停") def _trim_chat_history(self) -> None: """Trim the oldest history until the user-message count is below the configured limit.""" user_message_count = sum(1 for message in self._chat_history if get_message_role(message) == "user") if user_message_count <= self._max_context_size: return trimmed_history = list(self._chat_history) removed_count = 0 while user_message_count >= self._max_context_size and trimmed_history: removed_message = trimmed_history.pop(0) removed_count += 1 if get_message_role(removed_message) == "user": user_message_count -= 1 self._chat_history = trimmed_history logger.info( f"{self.log_prefix} 已裁剪 MaiSaka 历史消息 {removed_count} 条；" f"当前用户消息数为 {user_message_count}。" ) async def _append_perception_snapshot(self) -> None: tasks = [] if ENABLE_KNOWLEDGE_MODULE: tasks.append(("knowledge", retrieve_relevant_knowledge(self._llm_service, self._chat_history))) if not tasks: return results = await asyncio.gather(*[task for _, task in tasks], return_exceptions=True) perception_parts: list[str] = [] for (task_name, _), result in zip(tasks, results): if isinstance(result, Exception): analysis_name = { "emotion": "情绪", "cognition": "认知", "knowledge": "知识", }.get(task_name, task_name) logger.warning(f"{self.log_prefix} MaiSaka 的{analysis_name}分析失败: {result}") continue if result: perception_parts.append(f"{task_name.title()}\n{result}") remove_last_perception(self._chat_history) if not perception_parts: return self._chat_history.append( build_message( role="assistant", content="\n\n".join(perception_parts), message_kind="perception", source="assistant", platform=self.chat_stream.platform, session_id=self.session_id, group_info=self._build_group_info(), user_info=self._build_runtime_bot_user_info(), ) ) async def _handle_tool_calls( self, tool_calls: list[ToolCall], latest_thought: str, anchor_message: SessionMessage, ) -> bool: for tool_call in tool_calls: if tool_call.func_name == "reply": reply_sent = await self._handle_reply(tool_call, latest_thought, anchor_message) if reply_sent: return True continue if tool_call.func_name == "no_reply": self._chat_history.append( self._build_tool_message( tool_call, "No visible reply was sent for this round.", ) ) continue if tool_call.func_name == "wait": seconds = (tool_call.args or {}).get("seconds", 30) self._chat_history.append( self._build_tool_message( tool_call, f"Waiting for future input for up to {seconds} seconds.", ) ) return True if tool_call.func_name == "stop": self._chat_history.append( self._build_tool_message( tool_call, "Conversation loop paused until a new message arrives.", ) ) return True if tool_call.func_name == "write_file" and ENABLE_WRITE_FILE: await handle_write_file(tool_call, self._chat_history) continue if tool_call.func_name == "read_file" and ENABLE_READ_FILE: await handle_read_file(tool_call, self._chat_history) continue if tool_call.func_name == "list_files" and ENABLE_LIST_FILES: await handle_list_files(tool_call, self._chat_history) continue if self._mcp_manager and self._mcp_manager.is_mcp_tool(tool_call.func_name): await handle_mcp_tool(tool_call, self._chat_history, self._mcp_manager) continue await handle_unknown_tool(tool_call, self._chat_history) return False async def _handle_reply(self, tool_call: ToolCall, latest_thought: str, anchor_message: SessionMessage) -> bool: target_message_id = str((tool_call.args or {}).get("message_id", "")).strip() if not target_message_id: self._chat_history.append( self._build_tool_message(tool_call, "reply requires a valid message_id argument.") ) return False target_message = self._source_messages_by_id.get(target_message_id) if target_message is None: self._chat_history.append( self._build_tool_message(tool_call, f"reply target message_id not found: {target_message_id}") ) return False reply_text = await self._llm_service.generate_reply(latest_thought, self._chat_history) sent = await send_service.text_to_stream( text=reply_text, stream_id=self.session_id, set_reply=True, reply_message=target_message, typing=False, ) tool_result = "Visible reply generated and sent." if sent else "Visible reply generation succeeded but send failed." self._chat_history.append(self._build_tool_message(tool_call, tool_result)) if not sent: return False bot_name = global_config.bot.nickname.strip() or "MaiSaka" self._chat_history.append( build_message( role="user", content=format_speaker_content(bot_name, reply_text, datetime.now()), source="guided_reply", platform=target_message.platform or anchor_message.platform, session_id=self.session_id, group_info=self._build_group_info(target_message), user_info=self._build_runtime_user_info(), ) ) return True def _build_tool_message(self, tool_call: ToolCall, content: str) -> MaiMessage: return build_message( role="tool", content=content, source="tool", tool_call_id=tool_call.call_id, platform=self.chat_stream.platform, session_id=self.session_id, group_info=self._build_group_info(), user_info=UserInfo(user_id="maisaka_tool", user_nickname="tool", user_cardname=None), ) def _build_runtime_user_info(self) -> UserInfo: if self.chat_stream.user_id: return UserInfo( user_id=self.chat_stream.user_id, user_nickname=global_config.maisaka.user_name.strip() or "User", user_cardname=None, ) return UserInfo(user_id="maisaka_user", user_nickname="user", user_cardname=None) def _build_runtime_bot_user_info(self) -> UserInfo: return UserInfo( user_id=str(global_config.bot.qq_account) if global_config.bot.qq_account else "maisaka_assistant", user_nickname=global_config.bot.nickname.strip() or "MaiSaka", user_cardname=None, ) def _build_group_info(self, message: Optional[SessionMessage] = None) -> Optional[GroupInfo]: group_info = None if message is not None: group_info = message.message_info.group_info elif self.chat_stream.context and self.chat_stream.context.message: group_info = self.chat_stream.context.message.message_info.group_info if group_info is None: return None return GroupInfo(group_id=group_info.group_id, group_name=group_info.group_name)