924 lines
36 KiB
Python
924 lines
36 KiB
Python
"""Maisaka 对话循环服务。"""
|
||
|
||
from dataclasses import dataclass
|
||
from datetime import datetime
|
||
from time import perf_counter
|
||
from typing import Any, List, Optional, Sequence
|
||
|
||
import asyncio
|
||
import json
|
||
import random
|
||
|
||
from pydantic import BaseModel, Field as PydanticField
|
||
from rich.console import Group
|
||
from rich.panel import Panel
|
||
|
||
from src.cli.console import console
|
||
from src.common.data_models.llm_service_data_models import LLMGenerationOptions
|
||
from src.common.data_models.message_component_data_model import MessageSequence, TextComponent
|
||
from src.common.logger import get_logger
|
||
from src.common.prompt_i18n import load_prompt
|
||
from src.common.utils.utils_session import SessionUtils
|
||
from src.config.config import global_config
|
||
from src.core.tooling import ToolRegistry, ToolSpec
|
||
from src.know_u.knowledge import extract_category_ids_from_result
|
||
from src.llm_models.model_client.base_client import BaseClient
|
||
from src.llm_models.payload_content.message import Message, MessageBuilder, RoleType
|
||
from src.llm_models.payload_content.resp_format import RespFormat, RespFormatType
|
||
from src.llm_models.payload_content.tool_option import ToolCall, ToolDefinitionInput, ToolOption, normalize_tool_options
|
||
from src.plugin_runtime.hook_payloads import (
|
||
deserialize_prompt_messages,
|
||
deserialize_tool_calls,
|
||
serialize_prompt_messages,
|
||
serialize_tool_calls,
|
||
serialize_tool_definitions,
|
||
)
|
||
from src.plugin_runtime.hook_schema_utils import build_object_schema
|
||
from src.plugin_runtime.host.hook_spec_registry import HookSpec, HookSpecRegistry
|
||
from src.services.llm_service import LLMServiceClient
|
||
|
||
from .builtin_tool import get_builtin_tools
|
||
from .context_messages import AssistantMessage, LLMContextMessage, SessionBackedMessage, ToolResultMessage
|
||
from .message_adapter import format_speaker_content
|
||
from .planner_message_utils import build_session_backed_text_message
|
||
from .prompt_cli_renderer import PromptCLIVisualizer
|
||
|
||
|
||
@dataclass(slots=True)
|
||
class ChatResponse:
|
||
"""LLM 对话循环单步响应。"""
|
||
|
||
content: Optional[str]
|
||
tool_calls: List[ToolCall]
|
||
raw_message: AssistantMessage
|
||
selected_history_count: int
|
||
prompt_tokens: int
|
||
built_message_count: int
|
||
completion_tokens: int
|
||
total_tokens: int
|
||
|
||
|
||
class ToolFilterSelection(BaseModel):
|
||
"""工具筛选响应。"""
|
||
|
||
selected_tool_names: list[str] = PydanticField(default_factory=list)
|
||
"""经过预筛后保留的候选工具名称列表。"""
|
||
|
||
|
||
logger = get_logger("maisaka_chat_loop")
|
||
|
||
|
||
def register_maisaka_hook_specs(registry: HookSpecRegistry) -> List[HookSpec]:
|
||
"""注册 Maisaka 规划器内置 Hook 规格。
|
||
|
||
Args:
|
||
registry: 目标 Hook 规格注册中心。
|
||
|
||
Returns:
|
||
List[HookSpec]: 实际注册的 Hook 规格列表。
|
||
"""
|
||
|
||
return registry.register_hook_specs(
|
||
[
|
||
HookSpec(
|
||
name="maisaka.planner.before_request",
|
||
description="在 Maisaka 向模型发起规划请求前触发，可改写消息窗口与工具定义。",
|
||
parameters_schema=build_object_schema(
|
||
{
|
||
"messages": {
|
||
"type": "array",
|
||
"description": "即将发给模型的 PromptMessage 列表。",
|
||
},
|
||
"tool_definitions": {
|
||
"type": "array",
|
||
"description": "当前候选工具定义列表。",
|
||
},
|
||
"selected_history_count": {
|
||
"type": "integer",
|
||
"description": "当前选中的上下文消息数量。",
|
||
},
|
||
"built_message_count": {
|
||
"type": "integer",
|
||
"description": "实际发送给模型的消息数量。",
|
||
},
|
||
"selection_reason": {
|
||
"type": "string",
|
||
"description": "上下文选择说明。",
|
||
},
|
||
"session_id": {
|
||
"type": "string",
|
||
"description": "当前会话 ID。",
|
||
},
|
||
},
|
||
required=[
|
||
"messages",
|
||
"tool_definitions",
|
||
"selected_history_count",
|
||
"built_message_count",
|
||
"selection_reason",
|
||
"session_id",
|
||
],
|
||
),
|
||
default_timeout_ms=6000,
|
||
allow_abort=False,
|
||
allow_kwargs_mutation=True,
|
||
),
|
||
HookSpec(
|
||
name="maisaka.planner.after_response",
|
||
description="在 Maisaka 收到模型响应后触发，可调整文本结果与工具调用列表。",
|
||
parameters_schema=build_object_schema(
|
||
{
|
||
"response": {
|
||
"type": "string",
|
||
"description": "模型返回的文本内容。",
|
||
},
|
||
"tool_calls": {
|
||
"type": "array",
|
||
"description": "模型返回的工具调用列表。",
|
||
},
|
||
"selected_history_count": {
|
||
"type": "integer",
|
||
"description": "当前选中的上下文消息数量。",
|
||
},
|
||
"built_message_count": {
|
||
"type": "integer",
|
||
"description": "实际发送给模型的消息数量。",
|
||
},
|
||
"selection_reason": {
|
||
"type": "string",
|
||
"description": "上下文选择说明。",
|
||
},
|
||
"session_id": {
|
||
"type": "string",
|
||
"description": "当前会话 ID。",
|
||
},
|
||
"prompt_tokens": {
|
||
"type": "integer",
|
||
"description": "输入 Token 数。",
|
||
},
|
||
"completion_tokens": {
|
||
"type": "integer",
|
||
"description": "输出 Token 数。",
|
||
},
|
||
"total_tokens": {
|
||
"type": "integer",
|
||
"description": "总 Token 数。",
|
||
},
|
||
},
|
||
required=[
|
||
"response",
|
||
"tool_calls",
|
||
"selected_history_count",
|
||
"built_message_count",
|
||
"selection_reason",
|
||
"session_id",
|
||
"prompt_tokens",
|
||
"completion_tokens",
|
||
"total_tokens",
|
||
],
|
||
),
|
||
default_timeout_ms=6000,
|
||
allow_abort=False,
|
||
allow_kwargs_mutation=True,
|
||
),
|
||
]
|
||
)
|
||
|
||
|
||
class MaisakaChatLoopService:
|
||
"""负责 Maisaka 主对话循环、系统提示词和终端渲染。"""
|
||
|
||
def __init__(
|
||
self,
|
||
chat_system_prompt: Optional[str] = None,
|
||
session_id: Optional[str] = None,
|
||
is_group_chat: Optional[bool] = None,
|
||
temperature: float = 0.5,
|
||
max_tokens: int = 2048,
|
||
) -> None:
|
||
"""初始化 Maisaka 对话循环服务。
|
||
|
||
Args:
|
||
chat_system_prompt: 可选的系统提示词。
|
||
session_id: 当前会话 ID，用于匹配会话级额外提示。
|
||
is_group_chat: 当前会话是否为群聊。
|
||
temperature: 规划器温度参数。
|
||
max_tokens: 规划器最大输出长度。
|
||
"""
|
||
|
||
self._temperature = temperature
|
||
self._max_tokens = max_tokens
|
||
self._is_group_chat = is_group_chat
|
||
self._session_id = session_id or ""
|
||
self._extra_tools: List[ToolOption] = []
|
||
self._interrupt_flag: asyncio.Event | None = None
|
||
self._tool_registry: ToolRegistry | None = None
|
||
self._prompts_loaded = False
|
||
self._prompt_load_lock = asyncio.Lock()
|
||
self._personality_prompt = self._build_personality_prompt()
|
||
if chat_system_prompt is None:
|
||
self._chat_system_prompt = f"{self._personality_prompt}\n\nYou are a helpful AI assistant."
|
||
else:
|
||
self._chat_system_prompt = chat_system_prompt
|
||
self._llm_chat = LLMServiceClient(task_name="planner", request_type="maisaka_planner")
|
||
self._tool_filter_llm = LLMServiceClient(
|
||
task_name=global_config.maisaka.tool_filter_task_name,
|
||
request_type="maisaka_tool_filter",
|
||
)
|
||
|
||
@property
|
||
def personality_prompt(self) -> str:
|
||
"""返回当前人格提示词。"""
|
||
|
||
return self._personality_prompt
|
||
|
||
@staticmethod
|
||
def _get_runtime_manager() -> Any:
|
||
"""获取插件运行时管理器。
|
||
|
||
Returns:
|
||
Any: 插件运行时管理器单例。
|
||
"""
|
||
|
||
from src.plugin_runtime.integration import get_plugin_runtime_manager
|
||
|
||
return get_plugin_runtime_manager()
|
||
|
||
@staticmethod
|
||
def _coerce_int(value: Any, default: int) -> int:
|
||
"""将任意值安全转换为整数。
|
||
|
||
Args:
|
||
value: 待转换的输入值。
|
||
default: 转换失败时的默认值。
|
||
|
||
Returns:
|
||
int: 转换后的整数结果。
|
||
"""
|
||
|
||
try:
|
||
return int(value)
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
def _build_personality_prompt(self) -> str:
|
||
"""构造人格提示词。"""
|
||
|
||
try:
|
||
bot_name = global_config.bot.nickname
|
||
if global_config.bot.alias_names:
|
||
bot_nickname = f", also known as {','.join(global_config.bot.alias_names)}"
|
||
else:
|
||
bot_nickname = ""
|
||
|
||
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"Your name is {bot_name}{bot_nickname}; persona: {prompt_personality};"
|
||
except Exception:
|
||
return "Your name is MaiMai; persona: lively and cute AI assistant."
|
||
|
||
async def ensure_chat_prompt_loaded(self, tools_section: str = "") -> None:
|
||
"""确保主聊天提示词已经加载完成。
|
||
|
||
Args:
|
||
tools_section: 额外注入到提示词中的工具说明片段。
|
||
"""
|
||
async with self._prompt_load_lock:
|
||
try:
|
||
self._chat_system_prompt = load_prompt(
|
||
"maisaka_chat",
|
||
file_tools_section=tools_section,
|
||
bot_name=global_config.bot.nickname,
|
||
group_chat_attention_block=self._build_group_chat_attention_block(),
|
||
identity=self._personality_prompt,
|
||
)
|
||
except Exception:
|
||
self._chat_system_prompt = f"{self._personality_prompt}\n\nYou are a helpful AI assistant."
|
||
|
||
self._prompts_loaded = True
|
||
|
||
def _build_group_chat_attention_block(self) -> str:
|
||
"""构建当前聊天场景下的额外注意事项块。"""
|
||
|
||
prompt_lines: List[str] = []
|
||
|
||
if self._is_group_chat is True:
|
||
if group_chat_prompt := str(global_config.chat.group_chat_prompt or "").strip():
|
||
prompt_lines.append(f"通用注意事项：\n{group_chat_prompt}")
|
||
elif self._is_group_chat is False:
|
||
if private_chat_prompt := str(global_config.chat.private_chat_prompts or "").strip():
|
||
prompt_lines.append(f"通用注意事项：\n{private_chat_prompt}")
|
||
|
||
if self._session_id:
|
||
if chat_prompt := self._get_chat_prompt_for_chat(self._session_id, self._is_group_chat).strip():
|
||
prompt_lines.append(f"当前聊天额外注意事项：\n{chat_prompt}")
|
||
|
||
if not prompt_lines:
|
||
return ""
|
||
|
||
return f"在该聊天中的注意事项：\n" + "\n\n".join(prompt_lines) + "\n"
|
||
|
||
@staticmethod
|
||
def _get_chat_prompt_for_chat(chat_id: str, is_group_chat: Optional[bool]) -> str:
|
||
"""根据聊天流 ID 获取匹配的额外提示。"""
|
||
|
||
if not global_config.chat.chat_prompts:
|
||
return ""
|
||
|
||
for chat_prompt_item in global_config.chat.chat_prompts:
|
||
if hasattr(chat_prompt_item, "platform"):
|
||
platform = str(chat_prompt_item.platform or "").strip()
|
||
item_id = str(chat_prompt_item.item_id or "").strip()
|
||
rule_type = str(chat_prompt_item.rule_type or "").strip()
|
||
prompt_content = str(chat_prompt_item.prompt or "").strip()
|
||
elif isinstance(chat_prompt_item, str):
|
||
parts = chat_prompt_item.split(":", 3)
|
||
if len(parts) != 4:
|
||
continue
|
||
|
||
platform, item_id, rule_type, prompt_content = parts
|
||
platform = platform.strip()
|
||
item_id = item_id.strip()
|
||
rule_type = rule_type.strip()
|
||
prompt_content = prompt_content.strip()
|
||
else:
|
||
continue
|
||
|
||
if not platform or not item_id or not prompt_content:
|
||
continue
|
||
|
||
if rule_type == "group":
|
||
config_is_group = True
|
||
config_chat_id = SessionUtils.calculate_session_id(platform, group_id=item_id)
|
||
elif rule_type == "private":
|
||
config_is_group = False
|
||
config_chat_id = SessionUtils.calculate_session_id(platform, user_id=item_id)
|
||
else:
|
||
continue
|
||
|
||
if is_group_chat is not None and config_is_group != is_group_chat:
|
||
continue
|
||
|
||
if config_chat_id == chat_id:
|
||
logger.debug(f"匹配到 Maisaka 聊天额外提示，chat_id: {chat_id}, prompt: {prompt_content[:50]}...")
|
||
return prompt_content
|
||
|
||
return ""
|
||
|
||
def set_extra_tools(self, tools: Sequence[ToolDefinitionInput]) -> None:
|
||
"""设置额外工具定义。
|
||
|
||
Args:
|
||
tools: 兼容旧接口的额外工具定义列表。
|
||
"""
|
||
|
||
self._extra_tools = normalize_tool_options(list(tools)) or []
|
||
|
||
def set_tool_registry(self, tool_registry: ToolRegistry | None) -> None:
|
||
"""设置统一工具注册表。
|
||
|
||
Args:
|
||
tool_registry: 统一工具注册表；传入 ``None`` 时退回旧工具列表模式。
|
||
"""
|
||
|
||
self._tool_registry = tool_registry
|
||
|
||
def set_interrupt_flag(self, interrupt_flag: asyncio.Event | None) -> None:
|
||
"""设置当前 planner 请求使用的中断标记。"""
|
||
self._interrupt_flag = interrupt_flag
|
||
|
||
def _build_request_messages(self, selected_history: List[LLMContextMessage]) -> List[Message]:
|
||
"""构造发给大模型的消息列表。
|
||
|
||
Args:
|
||
selected_history: 已选中的上下文消息列表。
|
||
|
||
Returns:
|
||
List[Message]: 发送给大模型的消息列表。
|
||
"""
|
||
|
||
messages: List[Message] = []
|
||
system_msg = MessageBuilder().set_role(RoleType.System)
|
||
system_msg.add_text_content(self._chat_system_prompt)
|
||
messages.append(system_msg.build())
|
||
|
||
for msg in selected_history:
|
||
llm_message = msg.to_llm_message()
|
||
if llm_message is not None:
|
||
messages.append(llm_message)
|
||
|
||
return messages
|
||
|
||
@staticmethod
|
||
def _is_builtin_tool_spec(tool_spec: ToolSpec) -> bool:
|
||
"""判断一个工具是否属于默认内置工具。
|
||
|
||
Args:
|
||
tool_spec: 待判断的工具声明。
|
||
|
||
Returns:
|
||
bool: 是否为默认内置工具。
|
||
"""
|
||
|
||
return tool_spec.provider_type == "builtin" or tool_spec.provider_name == "maisaka_builtin"
|
||
|
||
@classmethod
|
||
def _split_builtin_and_candidate_tools(
|
||
cls,
|
||
tool_specs: List[ToolSpec],
|
||
) -> tuple[List[ToolSpec], List[ToolSpec]]:
|
||
"""拆分内置工具与可筛选工具列表。
|
||
|
||
Args:
|
||
tool_specs: 当前全部工具声明。
|
||
|
||
Returns:
|
||
tuple[List[ToolSpec], List[ToolSpec]]: `(内置工具, 可筛选工具)`。
|
||
"""
|
||
|
||
builtin_tool_specs: List[ToolSpec] = []
|
||
candidate_tool_specs: List[ToolSpec] = []
|
||
for tool_spec in tool_specs:
|
||
if cls._is_builtin_tool_spec(tool_spec):
|
||
builtin_tool_specs.append(tool_spec)
|
||
else:
|
||
candidate_tool_specs.append(tool_spec)
|
||
return builtin_tool_specs, candidate_tool_specs
|
||
|
||
@staticmethod
|
||
def _truncate_tool_filter_text(text: str, max_length: int = 180) -> str:
|
||
"""截断工具筛选阶段展示的文本。
|
||
|
||
Args:
|
||
text: 原始文本。
|
||
max_length: 最长保留字符数。
|
||
|
||
Returns:
|
||
str: 截断后的文本。
|
||
"""
|
||
|
||
normalized_text = text.strip()
|
||
if len(normalized_text) <= max_length:
|
||
return normalized_text
|
||
return f"{normalized_text[: max_length - 1]}…"
|
||
|
||
def _build_tool_filter_prompt(
|
||
self,
|
||
selected_history: List[LLMContextMessage],
|
||
candidate_tool_specs: List[ToolSpec],
|
||
max_keep: int,
|
||
) -> str:
|
||
"""构造小模型工具预筛选提示词。
|
||
|
||
Args:
|
||
selected_history: 已选中的对话上下文。
|
||
candidate_tool_specs: 非内置候选工具列表。
|
||
max_keep: 最多保留的候选工具数量。
|
||
|
||
Returns:
|
||
str: 用于工具预筛的小模型提示词。
|
||
"""
|
||
|
||
history_lines: List[str] = []
|
||
for message in selected_history[-10:]:
|
||
plain_text = message.processed_plain_text.strip()
|
||
if not plain_text:
|
||
continue
|
||
history_lines.append(
|
||
f"- {message.role}: {self._truncate_tool_filter_text(plain_text, max_length=200)}"
|
||
)
|
||
|
||
if history_lines:
|
||
history_section = "\n".join(history_lines)
|
||
else:
|
||
history_section = "- 当前没有可用的对话上下文。"
|
||
|
||
tool_lines = [
|
||
f"- {tool_spec.name}: {tool_spec.brief_description.strip() or '无简要描述'}"
|
||
for tool_spec in candidate_tool_specs
|
||
]
|
||
tool_section = "\n".join(tool_lines) if tool_lines else "- 当前没有候选工具。"
|
||
|
||
return (
|
||
"你是 Maisaka 的工具预筛选器。\n"
|
||
"你的任务是在正式进入 planner 前，根据当前情景从候选工具中挑出最可能马上会用到的工具。\n"
|
||
"默认内置工具已经自动保留，不在候选列表中，你不需要再次选择它们。\n"
|
||
"你只能参考工具的简要描述，不要假设未描述的隐藏能力。\n"
|
||
f"最多保留 {max_keep} 个候选工具；如果都不合适，可以返回空数组。\n"
|
||
"请严格返回 JSON 对象，格式为："
|
||
'{"selected_tool_names":["工具名1","工具名2"]}\n\n'
|
||
f"【最近对话】\n{history_section}\n\n"
|
||
f"【候选工具（仅简要描述）】\n{tool_section}"
|
||
)
|
||
|
||
@staticmethod
|
||
def _parse_tool_filter_response(
|
||
response_text: str,
|
||
candidate_tool_specs: List[ToolSpec],
|
||
max_keep: int,
|
||
) -> List[ToolSpec] | None:
|
||
"""解析工具预筛选响应。
|
||
|
||
Args:
|
||
response_text: 小模型返回的原始文本。
|
||
candidate_tool_specs: 非内置候选工具列表。
|
||
max_keep: 最多保留的候选工具数量。
|
||
|
||
Returns:
|
||
List[ToolSpec] | None: 成功解析时返回筛选后的工具列表；解析失败时返回 ``None``。
|
||
"""
|
||
|
||
normalized_response = response_text.strip()
|
||
if not normalized_response:
|
||
return None
|
||
|
||
selected_tool_names: List[str]
|
||
try:
|
||
selected_tool_names = ToolFilterSelection.model_validate_json(normalized_response).selected_tool_names
|
||
except Exception:
|
||
try:
|
||
parsed_payload = json.loads(normalized_response)
|
||
except json.JSONDecodeError:
|
||
return None
|
||
|
||
if isinstance(parsed_payload, dict):
|
||
raw_tool_names = parsed_payload.get("selected_tool_names", [])
|
||
elif isinstance(parsed_payload, list):
|
||
raw_tool_names = parsed_payload
|
||
else:
|
||
return None
|
||
|
||
if not isinstance(raw_tool_names, list):
|
||
return None
|
||
|
||
selected_tool_names = []
|
||
for item in raw_tool_names:
|
||
normalized_name = str(item).strip()
|
||
if normalized_name:
|
||
selected_tool_names.append(normalized_name)
|
||
|
||
candidate_map = {tool_spec.name: tool_spec for tool_spec in candidate_tool_specs}
|
||
filtered_tool_specs: List[ToolSpec] = []
|
||
seen_names: set[str] = set()
|
||
for tool_name in selected_tool_names:
|
||
normalized_name = tool_name.strip()
|
||
if not normalized_name or normalized_name in seen_names:
|
||
continue
|
||
tool_spec = candidate_map.get(normalized_name)
|
||
if tool_spec is None:
|
||
continue
|
||
|
||
seen_names.add(normalized_name)
|
||
filtered_tool_specs.append(tool_spec)
|
||
if len(filtered_tool_specs) >= max_keep:
|
||
break
|
||
|
||
return filtered_tool_specs
|
||
|
||
async def _filter_tool_specs_for_planner(
|
||
self,
|
||
selected_history: List[LLMContextMessage],
|
||
tool_specs: List[ToolSpec],
|
||
) -> List[ToolSpec]:
|
||
"""在将工具交给 planner 前进行快速预筛选。
|
||
|
||
Args:
|
||
selected_history: 已选中的对话上下文。
|
||
tool_specs: 当前全部可用工具声明。
|
||
|
||
Returns:
|
||
List[ToolSpec]: 最终交给 planner 的工具声明列表。
|
||
"""
|
||
|
||
threshold = max(1, int(global_config.maisaka.tool_filter_threshold))
|
||
max_keep = max(1, int(global_config.maisaka.tool_filter_max_keep))
|
||
if len(tool_specs) <= threshold:
|
||
return tool_specs
|
||
|
||
builtin_tool_specs, candidate_tool_specs = self._split_builtin_and_candidate_tools(tool_specs)
|
||
if not candidate_tool_specs:
|
||
return tool_specs
|
||
if len(candidate_tool_specs) <= max_keep:
|
||
return [*builtin_tool_specs, *candidate_tool_specs]
|
||
|
||
filter_prompt = self._build_tool_filter_prompt(selected_history, candidate_tool_specs, max_keep)
|
||
logger.info(
|
||
"工具预筛选开始: "
|
||
f"总工具数={len(tool_specs)} "
|
||
f"内置工具数={len(builtin_tool_specs)} "
|
||
f"候选工具数={len(candidate_tool_specs)} "
|
||
f"最多保留候选数={max_keep}"
|
||
)
|
||
|
||
try:
|
||
generation_result = await self._tool_filter_llm.generate_response(
|
||
prompt=filter_prompt,
|
||
options=LLMGenerationOptions(
|
||
temperature=0.0,
|
||
max_tokens=256,
|
||
response_format=RespFormat(
|
||
format_type=RespFormatType.JSON_SCHEMA,
|
||
schema=ToolFilterSelection,
|
||
),
|
||
),
|
||
)
|
||
except Exception as exc:
|
||
logger.warning(f"工具预筛选失败，保留全部工具。错误={exc}")
|
||
return tool_specs
|
||
|
||
filtered_candidate_tool_specs = self._parse_tool_filter_response(
|
||
generation_result.response or "",
|
||
candidate_tool_specs,
|
||
max_keep,
|
||
)
|
||
if filtered_candidate_tool_specs is None:
|
||
logger.warning(
|
||
"工具预筛选返回结果无法解析，保留全部工具。"
|
||
f" 原始返回={generation_result.response or ''!r}"
|
||
)
|
||
return tool_specs
|
||
|
||
filtered_tool_specs = [*builtin_tool_specs, *filtered_candidate_tool_specs]
|
||
if not filtered_tool_specs:
|
||
logger.warning("工具预筛选得到空结果，保留全部工具以避免主流程失去工具能力。")
|
||
return tool_specs
|
||
|
||
logger.info(
|
||
"工具预筛选完成: "
|
||
f"筛选前总数={len(tool_specs)} "
|
||
f"筛选后总数={len(filtered_tool_specs)} "
|
||
f"保留候选工具={[tool_spec.name for tool_spec in filtered_candidate_tool_specs]}"
|
||
)
|
||
return filtered_tool_specs
|
||
|
||
async def analyze_knowledge_need(
|
||
self,
|
||
chat_history: List[LLMContextMessage],
|
||
categories_summary: str,
|
||
) -> List[str]:
|
||
"""分析当前对话是否需要检索知识库分类。"""
|
||
visible_history: List[str] = []
|
||
for message in chat_history[-8:]:
|
||
if not message.processed_plain_text:
|
||
continue
|
||
visible_history.append(f"{message.role}: {message.processed_plain_text}")
|
||
|
||
if not visible_history or not categories_summary.strip():
|
||
return []
|
||
|
||
prompt = (
|
||
"你需要判断当前对话是否需要查询知识库。\n"
|
||
"请只返回最相关的分类编号，多个编号用空格分隔；如果完全不需要，返回 none。\n\n"
|
||
f"【可用分类】\n{categories_summary}\n\n"
|
||
f"【最近对话】\n{chr(10).join(visible_history)}"
|
||
)
|
||
|
||
try:
|
||
generation_result = await self._llm_chat.generate_response(
|
||
prompt=prompt,
|
||
options=LLMGenerationOptions(
|
||
temperature=0.1,
|
||
max_tokens=64,
|
||
),
|
||
)
|
||
except Exception:
|
||
return []
|
||
|
||
return extract_category_ids_from_result(generation_result.response or "")
|
||
|
||
async def chat_loop_step(self, chat_history: List[LLMContextMessage]) -> ChatResponse:
|
||
"""执行一轮 Maisaka 规划器请求。
|
||
|
||
Args:
|
||
chat_history: 当前对话历史。
|
||
|
||
Returns:
|
||
ChatResponse: 本轮规划器返回结果。
|
||
"""
|
||
|
||
await self.ensure_chat_prompt_loaded()
|
||
selected_history, selection_reason = self._select_llm_context_messages(chat_history)
|
||
built_messages = self._build_request_messages(selected_history)
|
||
|
||
def message_factory(_client: BaseClient) -> List[Message]:
|
||
"""返回当前轮次已经构建好的请求消息。
|
||
|
||
Args:
|
||
_client: 当前模型客户端；此处不依赖客户端能力。
|
||
|
||
Returns:
|
||
List[Message]: 已经构建好的消息列表。
|
||
"""
|
||
|
||
del _client
|
||
return built_messages
|
||
|
||
all_tools: List[ToolDefinitionInput]
|
||
if self._tool_registry is not None:
|
||
tool_specs = await self._tool_registry.list_tools()
|
||
filtered_tool_specs = await self._filter_tool_specs_for_planner(selected_history, tool_specs)
|
||
all_tools = [tool_spec.to_llm_definition() for tool_spec in filtered_tool_specs]
|
||
else:
|
||
all_tools = [*get_builtin_tools(), *self._extra_tools]
|
||
|
||
before_request_result = await self._get_runtime_manager().invoke_hook(
|
||
"maisaka.planner.before_request",
|
||
messages=serialize_prompt_messages(built_messages),
|
||
tool_definitions=serialize_tool_definitions(all_tools),
|
||
selected_history_count=len(selected_history),
|
||
built_message_count=len(built_messages),
|
||
selection_reason=selection_reason,
|
||
session_id=self._session_id,
|
||
)
|
||
before_request_kwargs = before_request_result.kwargs
|
||
raw_messages = before_request_kwargs.get("messages")
|
||
if isinstance(raw_messages, list):
|
||
try:
|
||
built_messages = deserialize_prompt_messages(raw_messages)
|
||
except Exception as exc:
|
||
logger.warning(f"Hook maisaka.planner.before_request 返回的 messages 无法反序列化，已忽略: {exc}")
|
||
raw_tool_definitions = before_request_kwargs.get("tool_definitions")
|
||
if isinstance(raw_tool_definitions, list):
|
||
all_tools = [item for item in raw_tool_definitions if isinstance(item, dict)]
|
||
|
||
ordered_panels = PromptCLIVisualizer.build_prompt_panels(
|
||
built_messages,
|
||
image_display_mode=global_config.maisaka.terminal_image_display_mode,
|
||
)
|
||
|
||
if global_config.maisaka.show_thinking and ordered_panels:
|
||
console.print(
|
||
Panel(
|
||
Group(*ordered_panels),
|
||
title="MaiSaka 大模型请求 - 对话单步",
|
||
subtitle=selection_reason,
|
||
border_style="cyan",
|
||
padding=(0, 1),
|
||
)
|
||
)
|
||
|
||
request_started_at = perf_counter()
|
||
logger.info(
|
||
"规划器请求开始: "
|
||
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,
|
||
options=LLMGenerationOptions(
|
||
tool_options=all_tools if all_tools else None,
|
||
temperature=self._temperature,
|
||
max_tokens=self._max_tokens,
|
||
interrupt_flag=self._interrupt_flag,
|
||
),
|
||
)
|
||
request_elapsed = perf_counter() - request_started_at
|
||
logger.info(f"规划器请求完成，耗时={request_elapsed:.3f} 秒")
|
||
|
||
prompt_stats_text = PromptCLIVisualizer.build_prompt_stats_text(
|
||
selected_history_count=len(selected_history),
|
||
built_message_count=len(built_messages),
|
||
prompt_tokens=generation_result.prompt_tokens,
|
||
completion_tokens=generation_result.completion_tokens,
|
||
total_tokens=generation_result.total_tokens,
|
||
)
|
||
logger.info(f"本轮Prompt统计: {prompt_stats_text}")
|
||
|
||
final_response = generation_result.response or ""
|
||
final_tool_calls = list(generation_result.tool_calls or [])
|
||
after_response_result = await self._get_runtime_manager().invoke_hook(
|
||
"maisaka.planner.after_response",
|
||
response=final_response,
|
||
tool_calls=serialize_tool_calls(final_tool_calls),
|
||
selected_history_count=len(selected_history),
|
||
built_message_count=len(built_messages),
|
||
selection_reason=selection_reason,
|
||
session_id=self._session_id,
|
||
prompt_tokens=generation_result.prompt_tokens,
|
||
completion_tokens=generation_result.completion_tokens,
|
||
total_tokens=generation_result.total_tokens,
|
||
)
|
||
after_response_kwargs = after_response_result.kwargs
|
||
if "response" in after_response_kwargs:
|
||
final_response = str(after_response_kwargs.get("response") or "")
|
||
raw_tool_calls = after_response_kwargs.get("tool_calls")
|
||
if isinstance(raw_tool_calls, list):
|
||
try:
|
||
final_tool_calls = deserialize_tool_calls(raw_tool_calls)
|
||
except Exception as exc:
|
||
logger.warning(f"Hook maisaka.planner.after_response 返回的 tool_calls 无法反序列化，已忽略: {exc}")
|
||
prompt_tokens = self._coerce_int(after_response_kwargs.get("prompt_tokens"), generation_result.prompt_tokens)
|
||
completion_tokens = self._coerce_int(
|
||
after_response_kwargs.get("completion_tokens"),
|
||
generation_result.completion_tokens,
|
||
)
|
||
total_tokens = self._coerce_int(after_response_kwargs.get("total_tokens"), generation_result.total_tokens)
|
||
|
||
tool_call_summaries = [
|
||
{
|
||
"调用编号": 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 final_tool_calls
|
||
]
|
||
logger.info(
|
||
f"Maisaka 规划器返回结果: 内容={final_response!r} "
|
||
f"工具调用={tool_call_summaries}"
|
||
)
|
||
|
||
raw_message = AssistantMessage(
|
||
content=final_response,
|
||
timestamp=datetime.now(),
|
||
tool_calls=final_tool_calls,
|
||
)
|
||
return ChatResponse(
|
||
content=final_response or None,
|
||
tool_calls=final_tool_calls,
|
||
raw_message=raw_message,
|
||
selected_history_count=len(selected_history),
|
||
prompt_tokens=prompt_tokens,
|
||
built_message_count=len(built_messages),
|
||
completion_tokens=completion_tokens,
|
||
total_tokens=total_tokens,
|
||
)
|
||
|
||
@staticmethod
|
||
def _select_llm_context_messages(chat_history: List[LLMContextMessage]) -> tuple[List[LLMContextMessage], str]:
|
||
"""选择真正发送给 LLM 的上下文消息。
|
||
|
||
Args:
|
||
chat_history: 当前全部对话历史。
|
||
|
||
Returns:
|
||
tuple[List[LLMContextMessage], str]: `(已选上下文, 选择说明)`。
|
||
"""
|
||
|
||
max_context_size = max(1, int(global_config.chat.max_context_size))
|
||
selected_indices: List[int] = []
|
||
counted_message_count = 0
|
||
|
||
for index in range(len(chat_history) - 1, -1, -1):
|
||
message = chat_history[index]
|
||
if message.to_llm_message() is None:
|
||
continue
|
||
|
||
selected_indices.append(index)
|
||
if message.count_in_context:
|
||
counted_message_count += 1
|
||
if counted_message_count >= max_context_size:
|
||
break
|
||
|
||
if not selected_indices:
|
||
return [], f"上下文判定：最近 {max_context_size} 条 user/assistant（当前 0 条）"
|
||
|
||
selected_indices.reverse()
|
||
selected_history = [chat_history[index] for index in selected_indices]
|
||
selected_history = MaisakaChatLoopService._drop_leading_orphan_tool_results(selected_history)
|
||
return (
|
||
selected_history,
|
||
(
|
||
f"上下文判定：最近 {max_context_size} 条 user/assistant；"
|
||
f"展示并发送窗口内消息 {len(selected_history)} 条"
|
||
),
|
||
)
|
||
|
||
@staticmethod
|
||
def _drop_leading_orphan_tool_results(
|
||
selected_history: List[LLMContextMessage],
|
||
) -> List[LLMContextMessage]:
|
||
"""移除窗口前缀中缺少对应 tool_call 的工具结果消息。"""
|
||
|
||
if not selected_history:
|
||
return selected_history
|
||
|
||
available_tool_call_ids = {
|
||
tool_call.call_id
|
||
for message in selected_history
|
||
if isinstance(message, AssistantMessage)
|
||
for tool_call in message.tool_calls
|
||
if tool_call.call_id
|
||
}
|
||
|
||
first_valid_index = 0
|
||
while first_valid_index < len(selected_history):
|
||
message = selected_history[first_valid_index]
|
||
if not isinstance(message, ToolResultMessage):
|
||
break
|
||
if message.tool_call_id in available_tool_call_ids:
|
||
break
|
||
first_valid_index += 1
|
||
|
||
if first_valid_index == 0:
|
||
return selected_history
|
||
return selected_history[first_valid_index:] |