Losita/mai-bot
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

汉化日志

Browse Source
This commit is contained in:
DrSmoothl
2026-03-30 21:56:18 +08:00
parent 0e14cb5de9
commit e7dbaa1a70
7 changed files with 230 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
src/maisaka/chat_loop_service.py
View File

@@ -165,6 +165,18 @@ class MaisakaChatLoopService:
return "bold white on magenta"
return "bold white on bright_black"
@staticmethod
def _get_role_badge_label(role: str) -> str:
if role == "system":
return "系统"
if role == "user":
return "用户"
if role == "assistant":
return "助手"
if role == "tool":
return "工具"
return "未知"
@staticmethod
def _build_terminal_image_preview(image_base64: str) -> Optional[str]:
ascii_chars = " .:-=+*#%@"
@@ -209,7 +221,7 @@ class MaisakaChatLoopService:
approx_size = max(0, len(image_base64) * 3 // 4)
size_text = f"{approx_size / 1024:.1f} KB" if approx_size >= 1024 else f"{approx_size} B"
preview_parts: List[object] = [
Text(f"image/{image_format} {size_text}\nbase64 omitted", style="magenta")
Text(f"图片格式 image/{image_format} {size_text}\nbase64 内容已省略", style="magenta")
]
if global_config.maisaka.terminal_image_preview:
preview_text = cls._build_terminal_image_preview(image_base64)
@@ -252,7 +264,7 @@ class MaisakaChatLoopService:
def _render_tool_call_panel(self, tool_call: Any, index: int, parent_index: int) -> Panel:
title = Text.assemble(
Text(" TOOL CALL ", style="bold white on magenta"),
Text(" 工具调用 ", style="bold white on magenta"),
Text(f" #{parent_index}.{index}", style="muted"),
)
return Panel(
@@ -274,26 +286,26 @@ class MaisakaChatLoopService:
role = raw_role.value if hasattr(raw_role, "value") else str(raw_role)
title = Text.assemble(
Text(f" {role.upper()} ", style=self._get_role_badge_style(role)),
Text(f" {self._get_role_badge_label(role)} ", style=self._get_role_badge_style(role)),
Text(f" #{index}", style="muted"),
)
parts: List[object] = []
if content not in (None, "", []):
parts.append(Text(" message ", style="bold cyan"))
parts.append(Text(" 消息 ", style="bold cyan"))
parts.append(self._render_message_content(content))
if tool_call_id:
parts.append(
Text.assemble(
Text(" tool_call_id ", style="bold magenta"),
Text(" 工具调用编号 ", style="bold magenta"),
Text(" "),
Text(str(tool_call_id), style="magenta"),
)
)
if not parts:
parts.append(Text("[empty message]", style="muted"))
parts.append(Text("[空消息]", style="muted"))
return Panel(
Group(*parts),
@@ -334,7 +346,7 @@ class MaisakaChatLoopService:
console.print(
Panel(
Group(*ordered_panels),
title="MaiSaka LLM Request - chat_loop_step",
title="MaiSaka 大模型请求 - 对话单步",
subtitle=selection_reason,
border_style="cyan",
padding=(0, 1),
@@ -343,11 +355,11 @@ class MaisakaChatLoopService:
request_started_at = perf_counter()
logger.info(
"planner 请求开始: "
f"selected_history={len(selected_history)} "
f"llm_messages={len(built_messages)} "
f"tool_count={len(all_tools)} "
f"interrupt_enabled={self._interrupt_flag is not None}"
"规划器请求开始: "
f"已选上下文消息数={len(selected_history)} "
f"大模型消息数={len(built_messages)} "
f"工具数={len(all_tools)} "
f"启用打断={self._interrupt_flag is not None}"
)
generation_result = await self._llm_chat.generate_response_with_messages(
message_factory=message_factory,
@@ -359,19 +371,19 @@ class MaisakaChatLoopService:
),
)
request_elapsed = perf_counter() - request_started_at
logger.info(f"planner 请求完成，elapsed={request_elapsed:.3f}s")
logger.info(f"规划器请求完成，耗时={request_elapsed:.3f} 秒")
tool_call_summaries = [
{
"id": getattr(tool_call, "call_id", getattr(tool_call, "id", None)),
"name": getattr(tool_call, "func_name", getattr(tool_call, "name", None)),
"args": getattr(tool_call, "args", getattr(tool_call, "arguments", None)),
"调用编号": getattr(tool_call, "call_id", getattr(tool_call, "id", None)),
"工具名": getattr(tool_call, "func_name", getattr(tool_call, "name", None)),
"参数": getattr(tool_call, "args", getattr(tool_call, "arguments", None)),
}
for tool_call in (generation_result.tool_calls or [])
]
logger.info(
f"Maisaka planner returned content={generation_result.response or ''!r} "
f"tool_calls={tool_call_summaries}"
f"Maisaka 规划器返回结果: 内容={generation_result.response or ''!r} "
f"工具调用={tool_call_summaries}"
)
raw_message = AssistantMessage(

165
src/maisaka/reasoning_engine.py
View File

@@ -74,11 +74,11 @@ class MaisakaReasoningEngine:
anchor_message = self._get_timeout_anchor_message()
if anchor_message is None:
logger.warning(
f"{self._runtime.log_prefix} wait 超时后缺少可复用的锚点消息，跳过本轮继续思考"
f"{self._runtime.log_prefix} 等待超时后缺少可复用的锚点消息，跳过本轮继续思考"
)
self._runtime._internal_turn_queue.task_done()
continue
logger.info(f"{self._runtime.log_prefix} wait 超时后开始新一轮思考")
logger.info(f"{self._runtime.log_prefix} 等待超时后开始新一轮思考")
self._runtime._chat_history.append(self._build_wait_timeout_message())
self._trim_chat_history()
try:
@@ -88,10 +88,10 @@ class MaisakaReasoningEngine:
try:
planner_started_at = time.time()
logger.info(
f"{self._runtime.log_prefix} planner 开始: "
f"round={round_index + 1} "
f"history_size={len(self._runtime._chat_history)} "
f"started_at={planner_started_at:.3f}"
f"{self._runtime.log_prefix} 规划器开始执行: "
f"回合={round_index + 1} "
f"历史消息数={len(self._runtime._chat_history)} "
f"开始时间={planner_started_at:.3f}"
)
interrupt_flag = asyncio.Event()
self._runtime._planner_interrupt_flag = interrupt_flag
@@ -104,16 +104,16 @@ class MaisakaReasoningEngine:
self._runtime._chat_loop_service.set_interrupt_flag(None)
cycle_detail.time_records["planner"] = time.time() - planner_started_at
logger.info(
f"{self._runtime.log_prefix} planner 完成: "
f"round={round_index + 1} "
f"elapsed={cycle_detail.time_records['planner']:.3f}s"
f"{self._runtime.log_prefix} 规划器执行完成: "
f"回合={round_index + 1} "
f"耗时={cycle_detail.time_records['planner']:.3f} 秒"
)
reasoning_content = response.content or ""
if self._should_replace_reasoning(reasoning_content):
response.content = "让我根据新情况重新思考："
response.raw_message.content = "让我根据新情况重新思考："
logger.info(f"{self._runtime.log_prefix} reasoning content replaced due to high similarity")
logger.info(f"{self._runtime.log_prefix} 当前思考与上一轮过于相似，已替换为重新思考提示")
self._last_reasoning_content = reasoning_content
self._runtime._chat_history.append(response.raw_message)
@@ -137,11 +137,11 @@ class MaisakaReasoningEngine:
except ReqAbortException:
interrupted_at = time.time()
logger.info(
f"{self._runtime.log_prefix} planner 打断成功: "
f"round={round_index + 1} "
f"started_at={planner_started_at:.3f} "
f"interrupted_at={interrupted_at:.3f} "
f"elapsed={interrupted_at - planner_started_at:.3f}s"
f"{self._runtime.log_prefix} 规划器打断成功: "
f"回合={round_index + 1} "
f"开始时间={planner_started_at:.3f} "
f"打断时间={interrupted_at:.3f} "
f"耗时={interrupted_at - planner_started_at:.3f} 秒"
)
break
finally:
@@ -154,7 +154,7 @@ class MaisakaReasoningEngine:
self._runtime._log_internal_loop_cancelled()
raise
except Exception:
logger.exception("%s Maisaka internal loop crashed", self._runtime.log_prefix)
logger.exception(f"{self._runtime.log_prefix} Maisaka 内部循环发生异常")
logger.error(traceback.format_exc())
raise
@@ -169,7 +169,7 @@ class MaisakaReasoningEngine:
tool_call_id = self._runtime._pending_wait_tool_call_id or "wait_timeout"
self._runtime._pending_wait_tool_call_id = None
return ToolResultMessage(
content="wait 已超时，期间没有收到新的用户输入。请基于现有上下文继续下一轮思考。",
content="等待已超时，期间没有收到新的用户输入。请基于现有上下文继续下一轮思考。",
timestamp=datetime.now(),
tool_call_id=tool_call_id,
tool_name="wait",
@@ -184,7 +184,7 @@ class MaisakaReasoningEngine:
self._runtime._pending_wait_tool_call_id = None
self._runtime._chat_history.append(
ToolResultMessage(
content="wait 被新的用户输入打断，已继续处理最新消息。",
content="等待过程被新的用户输入打断，已继续处理最新消息。",
timestamp=datetime.now(),
tool_call_id=tool_call_id,
tool_name="wait",
@@ -337,14 +337,14 @@ class MaisakaReasoningEngine:
"""
if not self._last_reasoning_content or not current_content:
logger.info(
f"{self._runtime.log_prefix} reasoning similarity skipped: "
f"last_empty={not bool(self._last_reasoning_content)} "
f"current_empty={not bool(current_content)} similarity=0.00"
f"{self._runtime.log_prefix} 跳过思考相似度判定: "
f"上一轮为空={not bool(self._last_reasoning_content)} "
f"当前为空={not bool(current_content)} 相似度=0.00"
)
return False
similarity = self._calculate_similarity(current_content, self._last_reasoning_content)
logger.info(f"{self._runtime.log_prefix} reasoning similarity: {similarity:.2f}")
logger.info(f"{self._runtime.log_prefix} 思考内容相似度: {similarity:.2f}")
return similarity > 0.9
@staticmethod
@@ -371,7 +371,7 @@ class MaisakaReasoningEngine:
reply_sent = await self._handle_reply(tool_call, latest_thought, anchor_message)
if not reply_sent:
logger.warning(
f"{self._runtime.log_prefix} reply tool did not produce a visible message, continuing loop"
f"{self._runtime.log_prefix} 回复工具未生成可见消息，将继续下一轮循环"
)
continue
@@ -379,7 +379,7 @@ class MaisakaReasoningEngine:
self._runtime._chat_history.append(
self._build_tool_message(
tool_call,
"No visible reply was sent for this round.",
"本轮未发送可见回复。",
)
)
continue
@@ -406,7 +406,7 @@ class MaisakaReasoningEngine:
self._runtime._chat_history.append(
self._build_tool_message(
tool_call,
"Conversation loop paused until a new message arrives.",
"当前对话循环已暂停，等待新消息到来。",
)
)
self._runtime._enter_stop_state()
@@ -430,7 +430,7 @@ class MaisakaReasoningEngine:
if not isinstance(raw_words, list):
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "query_jargon requires a words array.")
self._build_tool_message(tool_call, "查询黑话工具需要提供 `words` 数组参数。")
)
return
@@ -447,11 +447,11 @@ class MaisakaReasoningEngine:
if not words:
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "query_jargon requires at least one non-empty word.")
self._build_tool_message(tool_call, "查询黑话工具至少需要一个非空词条。")
)
return
logger.info(f"{self._runtime.log_prefix} query_jargon triggered: words={words!r}")
logger.info(f"{self._runtime.log_prefix} 已触发黑话查询: 词条={words!r}")
results: list[dict[str, object]] = []
for word in words:
@@ -478,7 +478,7 @@ class MaisakaReasoningEngine:
}
)
logger.info(f"{self._runtime.log_prefix} query_jargon finished: results={results!r}")
logger.info(f"{self._runtime.log_prefix} 黑话查询完成: 结果={results!r}")
self._runtime._chat_history.append(
self._build_tool_message(
tool_call,
@@ -494,14 +494,14 @@ class MaisakaReasoningEngine:
if not isinstance(raw_person_name, str):
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "query_person_info requires a person_name string.")
self._build_tool_message(tool_call, "查询人物信息工具需要提供字符串类型的 `person_name` 参数。")
)
return
person_name = raw_person_name.strip()
if not person_name:
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "query_person_info requires a non-empty person_name.")
self._build_tool_message(tool_call, "查询人物信息工具需要提供非空的 `person_name` 参数。")
)
return
@@ -511,8 +511,8 @@ class MaisakaReasoningEngine:
limit = 3
logger.info(
f"{self._runtime.log_prefix} query_person_info triggered: "
f"person_name={person_name!r} limit={limit}"
f"{self._runtime.log_prefix} 已触发人物信息查询: "
f"人物名={person_name!r} 限制条数={limit}"
)
persons = self._query_person_records(person_name, limit)
@@ -523,8 +523,8 @@ class MaisakaReasoningEngine:
}
logger.info(
f"{self._runtime.log_prefix} query_person_info finished: "
f"persons={len(result['persons'])} related_knowledge={len(result['related_knowledge'])}"
f"{self._runtime.log_prefix} 人物信息查询完成: "
f"人物记录数={len(result['persons'])} 相关知识数={len(result['related_knowledge'])}"
)
self._runtime._chat_history.append(
self._build_tool_message(
@@ -641,22 +641,22 @@ class MaisakaReasoningEngine:
unknown_words = raw_unknown_words if isinstance(raw_unknown_words, list) else None
if not target_message_id:
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "reply requires a valid msg_id argument.")
self._build_tool_message(tool_call, "回复工具需要提供有效的 `msg_id` 参数。")
)
return False
target_message = self._runtime._source_messages_by_id.get(target_message_id)
if target_message is None:
self._runtime._chat_history.append(
self._build_tool_message(tool_call, f"reply target msg_id not found: {target_message_id}")
self._build_tool_message(tool_call, f"未找到要回复的目标消息，msg_id={target_message_id}")
)
return False
logger.info(
f"{self._runtime.log_prefix} reply tool triggered: "
f"target_msg_id={target_message_id} quote={quote_reply} latest_thought={latest_thought!r}"
f"{self._runtime.log_prefix} 已触发回复工具: "
f"目标消息编号={target_message_id} 引用回复={quote_reply} 最新思考={latest_thought!r}"
)
logger.info(f"{self._runtime.log_prefix} acquiring Maisaka reply generator")
logger.info(f"{self._runtime.log_prefix} 正在获取 Maisaka 回复生成器")
try:
replyer = replyer_manager.get_replyer(
chat_stream=self._runtime.chat_stream,
@@ -665,24 +665,24 @@ class MaisakaReasoningEngine:
)
except Exception:
logger.exception(
f"{self._runtime.log_prefix} replyer_manager.get_replyer crashed: "
f"target_msg_id={target_message_id}"
f"{self._runtime.log_prefix} 获取回复生成器时发生异常: "
f"目标消息编号={target_message_id}"
)
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "Maisaka reply generator acquisition crashed.")
self._build_tool_message(tool_call, "获取 Maisaka 回复生成器时发生异常。")
)
return False
if replyer is None:
logger.error(f"{self._runtime.log_prefix} failed to acquire Maisaka reply generator")
logger.error(f"{self._runtime.log_prefix} 获取 Maisaka 回复生成器失败")
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "Maisaka reply generator is unavailable.")
self._build_tool_message(tool_call, "Maisaka 回复生成器当前不可用。")
)
return False
logger.info(f"{self._runtime.log_prefix} acquired Maisaka reply generator successfully")
logger.info(f"{self._runtime.log_prefix} 已成功获取 Maisaka 回复生成器")
logger.info(f"{self._runtime.log_prefix} calling generate_reply_with_context: target_msg_id={target_message_id}")
logger.info(f"{self._runtime.log_prefix} 正在调用回复生成接口: 目标消息编号={target_message_id}")
try:
success, reply_result = await replyer.generate_reply_with_context(
reply_reason=latest_thought,
@@ -695,41 +695,41 @@ class MaisakaReasoningEngine:
except Exception as exc:
import traceback
logger.error(
f"{self._runtime.log_prefix} reply generator crashed: target_msg_id={target_message_id} "
f"exc_type={type(exc).__name__} exc_msg={str(exc)}\n{traceback.format_exc()}"
f"{self._runtime.log_prefix} 回复生成器执行异常: 目标消息编号={target_message_id} "
f"异常类型={type(exc).__name__} 异常信息={str(exc)}\n{traceback.format_exc()}"
)
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "Visible reply generation crashed.")
self._build_tool_message(tool_call, "生成可见回复时发生异常。")
)
return False
logger.info(
f"{self._runtime.log_prefix} reply generator finished: "
f"success={success} response_text={reply_result.completion.response_text!r} "
f"error={reply_result.error_message!r}"
f"{self._runtime.log_prefix} 回复生成完成: "
f"成功={success} 回复文本={reply_result.completion.response_text!r} "
f"错误信息={reply_result.error_message!r}"
)
reply_text = reply_result.completion.response_text.strip() if success else ""
if not reply_text:
logger.warning(
f"{self._runtime.log_prefix} reply generator returned empty text: "
f"target_msg_id={target_message_id} error={reply_result.error_message!r}"
f"{self._runtime.log_prefix} 回复生成器返回空文本: "
f"目标消息编号={target_message_id} 错误信息={reply_result.error_message!r}"
)
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "Visible reply generation failed.")
self._build_tool_message(tool_call, "生成可见回复失败。")
)
return False
reply_segments = self._post_process_reply_text(reply_text)
combined_reply_text = "".join(reply_segments)
logger.info(
f"{self._runtime.log_prefix} reply post process finished: "
f"target_msg_id={target_message_id} segment_count={len(reply_segments)} "
f"segments={reply_segments!r}"
f"{self._runtime.log_prefix} 回复后处理完成: "
f"目标消息编号={target_message_id} 分段数={len(reply_segments)} "
f"分段内容={reply_segments!r}"
)
logger.info(
f"{self._runtime.log_prefix} sending guided reply: "
f"target_msg_id={target_message_id} quote={quote_reply} reply_segments={reply_segments!r}"
f"{self._runtime.log_prefix} 正在发送引导回复: "
f"目标消息编号={target_message_id} 引用回复={quote_reply} 回复分段={reply_segments!r}"
)
try:
sent = False
@@ -746,19 +746,18 @@ class MaisakaReasoningEngine:
break
except Exception:
logger.exception(
f"{self._runtime.log_prefix} send_service.text_to_stream crashed "
f"for target_msg_id={target_message_id}"
f"{self._runtime.log_prefix} 发送文字消息时发生异常，目标消息编号={target_message_id}"
)
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "Visible reply send crashed.")
self._build_tool_message(tool_call, "发送可见回复时发生异常。")
)
return False
logger.info(
f"{self._runtime.log_prefix} guided reply send result: "
f"target_msg_id={target_message_id} sent={sent}"
f"{self._runtime.log_prefix} 引导回复发送结果: "
f"目标消息编号={target_message_id} 发送成功={sent}"
)
tool_result = "Visible reply generated and sent." if sent else "Visible reply generation succeeded but send failed."
tool_result = "可见回复已生成并发送。" if sent else "可见回复生成成功，但发送失败。"
self._runtime._chat_history.append(self._build_tool_message(tool_call, tool_result))
if not sent:
return False
@@ -821,12 +820,12 @@ class MaisakaReasoningEngine:
tool_args = tool_call.args or {}
emotion = str(tool_args.get("emotion") or "").strip()
logger.info(f"{self._runtime.log_prefix} send_emoji tool triggered: emotion={emotion!r}")
logger.info(f"{self._runtime.log_prefix} 已触发表情包发送工具: 情绪={emotion!r}")
# 获取表情包列表
if not emoji_manager.emojis:
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "No emojis available in the emoji library.")
self._build_tool_message(tool_call, "当前表情包库中没有可用表情。")
)
return
@@ -841,16 +840,16 @@ class MaisakaReasoningEngine:
if matching_emojis:
selected_emoji = random.choice(matching_emojis)
logger.info(
f"{self._runtime.log_prefix} found {len(matching_emojis)} emojis matching emotion '{emotion}', "
f"selected: {selected_emoji.description}"
f"{self._runtime.log_prefix} 找到 {len(matching_emojis)} 个匹配情绪 {emotion!r} 的表情包，"
f"已选择：{selected_emoji.description}"
)
# 如果没有找到匹配的情感表情包，随机选择一个
if selected_emoji is None:
selected_emoji = random.choice(emoji_manager.emojis)
logger.info(
f"{self._runtime.log_prefix} no emoji matched emotion '{emotion}', "
f"randomly selected: {selected_emoji.description}"
f"{self._runtime.log_prefix} 没有表情包匹配情绪 {emotion!r}，"
f"已随机选择：{selected_emoji.description}"
)
# 更新表情包使用次数
@@ -860,13 +859,13 @@ class MaisakaReasoningEngine:
try:
emoji_base64 = ImageUtils.image_path_to_base64(str(selected_emoji.full_path))
if not emoji_base64:
raise ValueError("Failed to convert emoji image to base64")
raise ValueError("表情图片转换为 base64 失败")
except Exception as exc:
logger.error(
f"{self._runtime.log_prefix} failed to convert emoji to base64: {exc}"
f"{self._runtime.log_prefix} 表情图片转换为 base64 失败: {exc}"
)
self._runtime._chat_history.append(
self._build_tool_message(tool_call, f"Failed to send emoji: {exc}")
self._build_tool_message(tool_call, f"发送表情包失败：{exc}")
)
return
@@ -881,28 +880,28 @@ class MaisakaReasoningEngine:
)
except Exception as exc:
logger.exception(
f"{self._runtime.log_prefix} send_service.emoji_to_stream crashed: {exc}"
f"{self._runtime.log_prefix} 发送表情包时发生异常: {exc}"
)
self._runtime._chat_history.append(
self._build_tool_message(tool_call, f"Emoji send crashed: {exc}")
self._build_tool_message(tool_call, f"发送表情包时发生异常：{exc}")
)
return
if sent:
logger.info(
f"{self._runtime.log_prefix} emoji sent successfully: "
f"description={selected_emoji.description!r} emotion={selected_emoji.emotion}"
f"{self._runtime.log_prefix} 表情包发送成功: "
f"描述={selected_emoji.description!r} 情绪标签={selected_emoji.emotion}"
)
self._runtime._chat_history.append(
self._build_tool_message(
tool_call,
f"Sent emoji: {selected_emoji.description} (emotion: {', '.join(selected_emoji.emotion)})"
f"已发送表情包：{selected_emoji.description}（情绪：{', '.join(selected_emoji.emotion)}）"
)
)
else:
logger.warning(f"{self._runtime.log_prefix} emoji send failed")
logger.warning(f"{self._runtime.log_prefix} 表情包发送失败")
self._runtime._chat_history.append(
self._build_tool_message(tool_call, "Failed to send emoji.")
self._build_tool_message(tool_call, "发送表情包失败。")
)
def _build_tool_message(self, tool_call: ToolCall, content: str) -> ToolResultMessage:

116
src/maisaka/runtime.py
View File

@@ -36,7 +36,7 @@ class MaisakaHeartFlowChatting:
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}")
raise ValueError(f"未找到会话 {session_id} 对应的 Maisaka 运行时")
session_name = chat_manager.get_session_name(session_id) or session_id
self.log_prefix = f"[{session_name}]"
@@ -89,7 +89,7 @@ class MaisakaHeartFlowChatting:
self._running = True
self._ensure_background_tasks_running()
logger.info(f"{self.log_prefix} Maisaka runtime started")
logger.info(f"{self.log_prefix} Maisaka 运行时已启动")
async def stop(self) -> None:
"""Stop the runtime loop."""
@@ -123,7 +123,7 @@ class MaisakaHeartFlowChatting:
await self._mcp_manager.close()
self._mcp_manager = None
logger.info(f"{self.log_prefix} Maisaka runtime stopped")
logger.info(f"{self.log_prefix} Maisaka 运行时已停止")
def adjust_talk_frequency(self, frequency: float) -> None:
"""Compatibility shim for the existing manager API."""
@@ -137,9 +137,9 @@ class MaisakaHeartFlowChatting:
self._source_messages_by_id[message.message_id] = message
if self._agent_state == self._STATE_RUNNING and self._planner_interrupt_flag is not None:
logger.info(
f"{self.log_prefix} 收到新消息，发起 planner 打断; "
f"msg_id={message.message_id} cache_size={len(self.message_cache)} "
f"timestamp={time.time():.3f}"
f"{self.log_prefix} 收到新消息，发起规划器打断; "
f"消息编号={message.message_id} 缓存条数={len(self.message_cache)} "
f"时间戳={time.time():.3f}"
)
self._planner_interrupt_flag.set()
if self._agent_state in (self._STATE_WAIT, self._STATE_STOP):
@@ -158,9 +158,9 @@ class MaisakaHeartFlowChatting:
except Exception:
exc = None
if exc is not None:
logger.error(f"{self.log_prefix} internal loop task exited unexpectedly: {exc}")
logger.error(f"{self.log_prefix} 内部循环任务异常退出: {exc}")
self._internal_loop_task = asyncio.create_task(self._reasoning_engine.run_loop())
logger.warning(f"{self.log_prefix} restarted Maisaka internal loop task")
logger.warning(f"{self.log_prefix} 已重新拉起 Maisaka 内部循环任务")
if self._loop_task is None or self._loop_task.done():
if self._loop_task is not None and not self._loop_task.cancelled():
@@ -169,9 +169,9 @@ class MaisakaHeartFlowChatting:
except Exception:
exc = None
if exc is not None:
logger.error(f"{self.log_prefix} main loop task exited unexpectedly: {exc}")
logger.error(f"{self.log_prefix} 主循环任务异常退出: {exc}")
self._loop_task = asyncio.create_task(self._main_loop())
logger.warning(f"{self.log_prefix} restarted Maisaka main loop task")
logger.warning(f"{self.log_prefix} 已重新拉起 Maisaka 主循环任务")
async def _main_loop(self) -> None:
try:
@@ -195,8 +195,8 @@ class MaisakaHeartFlowChatting:
self._new_message_event.clear()
if trigger_reason == "timeout":
# wait 超时后继续下一轮内部思考，但不要重复注入旧消息。
logger.info(f"{self.log_prefix} wait 超时后投递继续思考触发")
# 等待超时后继续下一轮内部思考，但不要重复注入旧消息。
logger.info(f"{self.log_prefix} 等待超时后已投递继续思考触发信号")
await self._internal_turn_queue.put(None)
continue
@@ -207,7 +207,7 @@ class MaisakaHeartFlowChatting:
await self._internal_turn_queue.put(cached_messages)
asyncio.create_task(self._trigger_batch_learning(cached_messages))
except asyncio.CancelledError:
logger.info(f"{self.log_prefix} Maisaka runtime loop cancelled")
logger.info(f"{self.log_prefix} Maisaka 运行时主循环已取消")
def _has_pending_messages(self) -> bool:
return self._last_processed_index < len(self.message_cache)
@@ -230,8 +230,8 @@ class MaisakaHeartFlowChatting:
self._last_processed_index = len(self.message_cache)
logger.info(
f"{self.log_prefix} collected {len(unique_messages)} new messages "
f"from message_cache[{start_index}:{self._last_processed_index}]"
f"{self.log_prefix} 已从消息缓存区[{start_index}:{self._last_processed_index}] "
f"收集 {len(unique_messages)} 条新消息"
)
return unique_messages
@@ -247,7 +247,7 @@ class MaisakaHeartFlowChatting:
timeout = self._wait_until - time.time()
if timeout <= 0:
logger.info(f"{self.log_prefix} Maisaka wait timed out")
logger.info(f"{self.log_prefix} Maisaka 等待已超时")
self._agent_state = self._STATE_RUNNING
self._wait_until = None
return "timeout"
@@ -256,7 +256,7 @@ class MaisakaHeartFlowChatting:
await asyncio.wait_for(self._new_message_event.wait(), timeout=timeout)
return "message"
except asyncio.TimeoutError:
logger.info(f"{self.log_prefix} Maisaka wait timed out")
logger.info(f"{self.log_prefix} Maisaka 等待已超时")
self._agent_state = self._STATE_RUNNING
self._wait_until = None
return "timeout"
@@ -281,110 +281,110 @@ class MaisakaHeartFlowChatting:
return_exceptions=True,
)
if isinstance(expression_result, Exception):
logger.error(f"{self.log_prefix} expression learning task crashed: {expression_result}")
logger.error(f"{self.log_prefix} 表达学习任务异常退出: {expression_result}")
if isinstance(knowledge_result, Exception):
logger.error(f"{self.log_prefix} knowledge learning task crashed: {knowledge_result}")
logger.error(f"{self.log_prefix} 知识学习任务异常退出: {knowledge_result}")
async def _trigger_expression_learning(self, messages: list[SessionMessage]) -> None:
"""Trigger expression learning from the newly collected batch."""
self._expression_learner.add_messages(messages)
if not self._enable_expression_learning:
logger.debug(f"{self.log_prefix} expression learning disabled, skip this batch")
logger.debug(f"{self.log_prefix} 表达学习未启用，跳过当前批次")
return
elapsed = time.time() - self._last_expression_extraction_time
if elapsed < self._min_extraction_interval:
logger.debug(
f"{self.log_prefix} expression learning interval not reached: "
f"elapsed={elapsed:.2f}s threshold={self._min_extraction_interval}s"
f"{self.log_prefix} 表达学习尚未达到触发间隔: "
f"已过={elapsed:.2f} 秒 阈值={self._min_extraction_interval} 秒"
)
return
cache_size = self._expression_learner.get_cache_size()
if cache_size < self._min_messages_for_extraction:
logger.debug(
f"{self.log_prefix} expression learning skipped due to cache size: "
f"learner_cache={cache_size} threshold={self._min_messages_for_extraction} "
f"message_cache_total={len(self.message_cache)}"
f"{self.log_prefix} 表达学习因缓存数量不足而跳过: "
f"学习器缓存={cache_size} 阈值={self._min_messages_for_extraction} "
f"消息总缓存={len(self.message_cache)}"
)
return
self._last_expression_extraction_time = time.time()
logger.info(
f"{self.log_prefix} starting expression learning: "
f"new_batch={len(messages)} learner_cache={cache_size} "
f"message_cache_total={len(self.message_cache)} "
f"enable_jargon_learning={self._enable_jargon_learning}"
f"{self.log_prefix} 开始表达学习: "
f"新批次消息数={len(messages)} 学习器缓存={cache_size} "
f"消息总缓存={len(self.message_cache)} "
f"启用黑话学习={self._enable_jargon_learning}"
)
try:
jargon_miner = self._jargon_miner if self._enable_jargon_learning else None
learnt_style = await self._expression_learner.learn(jargon_miner)
if learnt_style:
logger.info(f"{self.log_prefix} expression learning finished")
logger.info(f"{self.log_prefix} 表达学习已完成")
else:
logger.debug(f"{self.log_prefix} expression learning finished without usable result")
logger.debug(f"{self.log_prefix} 表达学习已完成，但没有可用结果")
except Exception:
logger.exception(f"{self.log_prefix} expression learning failed")
logger.exception(f"{self.log_prefix} 表达学习失败")
async def _trigger_knowledge_learning(self, messages: list[SessionMessage]) -> None:
"""Trigger knowledge learning from the newly collected batch."""
self._knowledge_learner.add_messages(messages)
if not global_config.maisaka.enable_knowledge_module:
logger.debug(f"{self.log_prefix} knowledge learning disabled, skip this batch")
logger.debug(f"{self.log_prefix} 知识学习未启用，跳过当前批次")
return
elapsed = time.time() - self._last_knowledge_extraction_time
if elapsed < self._min_extraction_interval:
logger.debug(
f"{self.log_prefix} knowledge learning interval not reached: "
f"elapsed={elapsed:.2f}s threshold={self._min_extraction_interval}s"
f"{self.log_prefix} 知识学习尚未达到触发间隔: "
f"已过={elapsed:.2f} 秒 阈值={self._min_extraction_interval} 秒"
)
return
cache_size = self._knowledge_learner.get_cache_size()
if cache_size < self._min_messages_for_extraction:
logger.debug(
f"{self.log_prefix} knowledge learning skipped due to cache size: "
f"learner_cache={cache_size} threshold={self._min_messages_for_extraction} "
f"message_cache_total={len(self.message_cache)}"
f"{self.log_prefix} 知识学习因缓存数量不足而跳过: "
f"学习器缓存={cache_size} 阈值={self._min_messages_for_extraction} "
f"消息总缓存={len(self.message_cache)}"
)
return
self._last_knowledge_extraction_time = time.time()
logger.info(
f"{self.log_prefix} starting knowledge learning: "
f"new_batch={len(messages)} learner_cache={cache_size} "
f"message_cache_total={len(self.message_cache)}"
f"{self.log_prefix} 开始知识学习: "
f"新批次消息数={len(messages)} 学习器缓存={cache_size} "
f"消息总缓存={len(self.message_cache)}"
)
try:
added_count = await self._knowledge_learner.learn()
if added_count > 0:
logger.info(f"{self.log_prefix} knowledge learning finished: added={added_count}")
logger.info(f"{self.log_prefix} 知识学习已完成: 新增条目数={added_count}")
else:
logger.debug(f"{self.log_prefix} knowledge learning finished without usable result")
logger.debug(f"{self.log_prefix} 知识学习已完成，但没有可用结果")
except Exception:
logger.exception(f"{self.log_prefix} knowledge learning failed")
logger.exception(f"{self.log_prefix} 知识学习失败")
async def _init_mcp(self) -> None:
"""Initialize MCP tools and inject them into the planner."""
config_path = Path(__file__).resolve().parents[2] / "config" / "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} MCP manager is unavailable")
logger.info(f"{self.log_prefix} MCP 管理器不可用")
return
mcp_tools = self._mcp_manager.get_openai_tools()
if not mcp_tools:
logger.info(f"{self.log_prefix} No MCP tools were exposed to Maisaka")
logger.info(f"{self.log_prefix} 没有可供 Maisaka 使用的 MCP 工具")
return
self._chat_loop_service.set_extra_tools(mcp_tools)
logger.info(
f"{self.log_prefix} Loaded {len(mcp_tools)} MCP tools into Maisaka:\n"
f"{self.log_prefix} 已向 Maisaka 加载 {len(mcp_tools)} 个 MCP 工具:\n"
f"{self._mcp_manager.get_tool_summary()}"
)
@@ -392,10 +392,10 @@ class MaisakaHeartFlowChatting:
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_nickname=global_config.maisaka.user_name.strip() or "用户",
user_cardname=None,
)
return UserInfo(user_id="maisaka_user", user_nickname="user", user_cardname=None)
return UserInfo(user_id="maisaka_user", user_nickname="用户", user_cardname=None)
def _build_group_info(self, message: Optional[SessionMessage] = None) -> Optional[GroupInfo]:
group_info = None
@@ -411,23 +411,23 @@ class MaisakaHeartFlowChatting:
def _log_cycle_started(self, cycle_detail: CycleDetail, round_index: int) -> None:
logger.info(
f"{self.log_prefix} MaiSaka cycle={cycle_detail.cycle_id} "
f"round={round_index + 1}/{self._max_internal_rounds} "
f"context_size={len(self._chat_history)}"
f"{self.log_prefix} MaiSaka 轮次开始: 循环编号={cycle_detail.cycle_id} "
f"回合={round_index + 1}/{self._max_internal_rounds} "
f"上下文消息数={len(self._chat_history)}"
)
def _log_cycle_completed(self, cycle_detail: CycleDetail, timer_strings: list[str]) -> None:
logger.info(
f"{self.log_prefix} MaiSaka cycle={cycle_detail.cycle_id} completed "
f"in {cycle_detail.end_time - cycle_detail.start_time:.2f}s; "
f"stages={', '.join(timer_strings) if timer_strings else 'none'}"
f"{self.log_prefix} MaiSaka 轮次结束: 循环编号={cycle_detail.cycle_id} "
f"总耗时={cycle_detail.end_time - cycle_detail.start_time:.2f} 秒; "
f"阶段耗时={', '.join(timer_strings) if timer_strings else '无'}"
)
def _log_history_trimmed(self, removed_count: int, user_message_count: int) -> None:
logger.info(
f"{self.log_prefix} Trimmed {removed_count} history messages; "
f"remaining_user_messages={user_message_count}"
f"{self.log_prefix} 已裁剪 {removed_count} 条历史消息; "
f"剩余计入上下文的消息数={user_message_count}"
)
def _log_internal_loop_cancelled(self) -> None:
logger.info(f"{self.log_prefix} Maisaka internal loop cancelled")
logger.info(f"{self.log_prefix} Maisaka 内部循环已取消")

2
src/maisaka/tool_handlers.py
View File

@@ -102,7 +102,7 @@ async def handle_mcp_tool(tc: ToolCall, chat_history: list[LLMContextMessage], m
console.print(
Panel(
display_text,
title=f"MCP: {tc.func_name}",
title=f"MCP 工具：{tc.func_name}",
border_style="bright_green",
padding=(0, 1),
)