fix：修复maisaka调用Prompt的问题

src/maisaka/llm_service.py

@@ -0,0 +1,568 @@
+"""
+MaiSaka LLM 服务 - 使用主项目 LLM 系统
+将主项目的 LLMRequest 适配为 MaiSaka 需要的接口
+"""
+
+import json
+import os
+from dataclasses import dataclass
+from typing import List, Optional, Literal
+
+from src.common.logger import get_logger
+from src.config.config import config_manager
+from src.llm_models.utils_model import LLMRequest
+from src.prompt.prompt_manager import prompt_manager
+from src.llm_models.payload_content.message import MessageBuilder, RoleType
+from src.llm_models.payload_content.tool_option import ToolCall as ToolCallOption, ToolOption
+from builtin_tools import get_builtin_tools
+
+import config
+
+logger = get_logger("maisaka_llm")
+
+# ──────────────────── 消息类型 ────────────────────
+
+MessageType = Literal["user", "assistant", "system", "perception"]
+
+# 内部使用的字段前缀，用于标记不应发送给 API 的元数据
+INTERNAL_FIELD_PREFIX = "_"
+
+# 消息类型字段名
+MSG_TYPE_FIELD = "_type"
+
+
+@dataclass
+class ToolCall:
+    """工具调用信息"""
+    id: str
+    name: str
+    arguments: dict
+
+
+@dataclass
+class ChatResponse:
+    """LLM 对话循环单步响应"""
+    content: Optional[str]
+    tool_calls: List[ToolCall]
+    raw_message: dict  # 可直接追加到对话历史的消息字典
+
+
+# ──────────────────── 工具函数 ────────────────────
+
+def build_message(role: str, content: str, msg_type: MessageType = "user", **kwargs) -> dict:
+    """构建消息字典，包含消息类型标记。"""
+    msg = {"role": role, "content": content, MSG_TYPE_FIELD: msg_type, **kwargs}
+    return msg
+
+
+def remove_last_perception(messages: list[dict]) -> None:
+    """移除最后一条感知消息（直接修改原列表）。"""
+    for i in range(len(messages) - 1, -1, -1):
+        if messages[i].get(MSG_TYPE_FIELD) == "perception":
+            messages.pop(i)
+            break
+
+
+class MaiSakaLLMService:
+    """MaiSaka LLM 服务 - 适配主项目 LLM 系统"""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        model: Optional[str] = None,
+        chat_system_prompt: Optional[str] = None,
+        temperature: float = 0.5,
+        max_tokens: int = 2048,
+        enable_thinking: Optional[bool] = None,
+    ):
+        """
+        初始化 LLM 服务
+
+        参数仅为兼容性保留，实际使用主项目配置
+        """
+        self._temperature = temperature
+        self._max_tokens = max_tokens
+        self._enable_thinking = enable_thinking
+        self._extra_tools: List[dict] = []
+
+        # 获取主项目模型配置
+        try:
+            model_config = config_manager.get_model_config()
+            self._model_configs = model_config.model_task_config
+        except Exception:
+            # 如果配置加载失败，使用默认配置
+            from src.config.model_configs import ModelTaskConfig
+            self._model_configs = ModelTaskConfig()
+            logger.warning("无法加载主项目模型配置，使用默认配置")
+
+        # 初始化 LLMRequest 实例（只使用 tool_use 和 replyer）
+        self._llm_tool_use = LLMRequest(
+            model_set=self._model_configs.tool_use,
+            request_type="maisaka_tool_use"
+        )
+        # 主对话也使用 tool_use 模型（因为需要工具调用支持）
+        self._llm_chat = self._llm_tool_use
+        # 分析模块也使用 tool_use 模型
+        self._llm_utils = self._llm_tool_use
+        # 回复生成使用 replyer 模型
+        self._llm_replyer = LLMRequest(
+            model_set=self._model_configs.replyer,
+            request_type="maisaka_replyer"
+        )
+
+        # 尝试修复数据库 schema（忽略错误）
+        self._try_fix_database_schema()
+
+        # 加载系统提示词
+        if chat_system_prompt is None:
+            try:
+                chat_prompt = prompt_manager.get_prompt("maidairy_chat")
+                logger.info("成功加载 maidairy_chat 提示词模板")
+                tools_section = ""
+                if config.ENABLE_WRITE_FILE:
+                    tools_section += "\n• write_file(filename, content) — 在 mai_files 目录下写入文件。"
+                if config.ENABLE_READ_FILE:
+                    tools_section += "\n• read_file(filename) — 读取 mai_files 目录下的文件内容。"
+                if config.ENABLE_LIST_FILES:
+                    tools_section += "\n• list_files() — 获取 mai_files 目录下所有文件的元信息列表。"
+                if config.ENABLE_QQ_TOOLS:
+                    tools_section += "\n• get_qq_chat_info(chat, limit) — 获取指定 QQ 聊天的聊天记录。"
+                    tools_section += "\n• send_info(chat, message) — 发送消息到指定的 QQ 聊天。"
+                    tools_section += "\n• list_qq_chats() — 获取所有可用的 QQ 聊天列表。"
+
+                chat_prompt.add_context("file_tools_section", tools_section if tools_section else "")
+                import asyncio
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    self._chat_system_prompt = loop.run_until_complete(prompt_manager.render_prompt(chat_prompt))
+                    logger.info(f"系统提示词已渲染，长度: {len(self._chat_system_prompt)}")
+                finally:
+                    loop.close()
+            except Exception as e:
+                logger.error(f"加载系统提示词失败: {e}")
+                self._chat_system_prompt = "你是一个友好的 AI 助手。"
+        else:
+            self._chat_system_prompt = chat_system_prompt
+
+        # 获取模型名称用于显示
+        self._model_name = self._model_configs.tool_use.model_list[0] if self._model_configs.tool_use.model_list else "未配置"
+
+        # 加载子模块提示词
+        self._emotion_prompt: Optional[str] = None
+        self._cognition_prompt: Optional[str] = None
+        self._timing_prompt: Optional[str] = None
+        self._context_summarize_prompt: Optional[str] = None
+
+        try:
+            import asyncio
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                self._emotion_prompt = loop.run_until_complete(prompt_manager.render_prompt(
+                    prompt_manager.get_prompt("maidairy_emotion")
+                ))
+                self._cognition_prompt = loop.run_until_complete(prompt_manager.render_prompt(
+                    prompt_manager.get_prompt("maidairy_cognition")
+                ))
+                self._timing_prompt = loop.run_until_complete(prompt_manager.render_prompt(
+                    prompt_manager.get_prompt("maidairy_timing")
+                ))
+                self._context_summarize_prompt = loop.run_until_complete(prompt_manager.render_prompt(
+                    prompt_manager.get_prompt("maidairy_context_summarize")
+                ))
+                logger.info("成功加载 MaiSaka 子模块提示词")
+            finally:
+                loop.close()
+        except Exception as e:
+            logger.warning(f"加载子模块提示词失败，将使用默认提示词: {e}")
+
+    def _try_fix_database_schema(self) -> None:
+        """尝试修复数据库 schema，添加缺失的列"""
+        try:
+            from src.common.database.database_client import get_db_session
+            from sqlalchemy import text
+
+            with get_db_session() as session:
+                # 检查 model_api_provider_name 列是否存在
+                result = session.execute(text("PRAGMA table_info(llm_usage)"))
+                columns = [row[1] for row in result.fetchall()]
+
+                if "model_api_provider_name" not in columns:
+                    # 添加缺失的列
+                    session.execute(text(
+                        "ALTER TABLE llm_usage ADD COLUMN model_api_provider_name VARCHAR(255)"
+                    ))
+                    session.commit()
+                    logger.info("数据库 schema 已修复：添加 model_api_provider_name 列")
+        except Exception:
+            # 静默忽略任何错误，不影响正常流程
+            pass
+
+    def set_extra_tools(self, tools: List[dict]) -> None:
+        """设置额外的工具定义（如 MCP 工具）"""
+        self._extra_tools = list(tools)
+
+    @staticmethod
+    def _tool_option_to_dict(tool: 'ToolOption') -> dict:
+        """将 ToolOption 对象转换为主项目期望的 dict 格式
+
+        主项目的 _build_tool_options() 期望的格式:
+        {
+            "name": str,
+            "description": str,
+            "parameters": List[Tuple[name, ToolParamType, description, required, enum_values]]
+        }
+        """
+        params = []
+        if tool.params:
+            for param in tool.params:
+                params.append((
+                    param.name,
+                    param.param_type,
+                    param.description,
+                    param.required,
+                    param.enum_values
+                ))
+        return {
+            "name": tool.name,
+            "description": tool.description,
+            "parameters": params
+        }
+
+    async def chat_loop_step(self, chat_history: List[dict]) -> ChatResponse:
+        """执行对话循环的一步 - 使用 tool_use 模型"""
+
+        def message_factory(client) -> List:
+            """将 MaiSaka 的 chat_history 转换为主项目的 Message 格式"""
+            messages = []
+
+            # 首先添加系统提示词
+            system_msg = MessageBuilder().set_role(RoleType.System)
+            system_msg.add_text_content(self._chat_system_prompt)
+            messages.append(system_msg.build())
+
+            # 然后添加对话历史
+            for msg in chat_history:
+                role = msg.get("role", "")
+                content = msg.get("content", "")
+
+                # 跳过内部字段类型的消息和系统消息（已经有系统提示词了）
+                if role in ("perception", "system"):
+                    continue
+
+                # 映射角色类型
+                if role == "user":
+                    role_type = RoleType.User
+                elif role == "assistant":
+                    role_type = RoleType.Assistant
+                elif role == "tool":
+                    role_type = RoleType.Tool
+                else:
+                    continue
+
+                builder = MessageBuilder().set_role(role_type)
+
+                # 处理工具调用
+                if role == "assistant" and "tool_calls" in msg:
+                    # 转换 tool_calls 格式：从 MaiSaka 格式转为主项目格式
+                    tool_calls_list = []
+                    for tc in msg["tool_calls"]:
+                        tc_func = tc.get("function", {})
+                        # 主项目的 ToolCall: call_id, func_name, args
+                        tool_calls_list.append(ToolCallOption(
+                            call_id=tc.get("id", ""),
+                            func_name=tc_func.get("name", ""),
+                            args=json.loads(tc_func.get("arguments", "{}")) if tc_func.get("arguments") else {}
+                        ))
+                    builder.set_tool_calls(tool_calls_list)
+                elif role == "tool" and "tool_call_id" in msg:
+                    builder.add_tool_call(msg["tool_call_id"])
+
+                # 添加文本内容
+                if content:
+                    builder.add_text_content(content)
+
+                messages.append(builder.build())
+
+            return messages
+
+        # 调用 LLM（使用带消息的接口）
+        # 合并内置工具和额外工具（将 ToolOption 对象转换为 dict）
+        all_tools = [self._tool_option_to_dict(t) for t in get_builtin_tools()] + (self._extra_tools if self._extra_tools else [])
+
+        # 打印消息列表
+        built_messages = message_factory(None)
+        print("\n" + "="*60)
+        print("MaiSaka LLM Request - chat_loop_step:")
+        for msg in built_messages:
+            print(f"  {msg}")
+        print("="*60 + "\n")
+
+        response, (reasoning, model, tool_calls) = await self._llm_chat.generate_response_with_message_async(
+            message_factory=message_factory,
+            tools=all_tools if all_tools else None,
+            temperature=self._temperature,
+            max_tokens=self._max_tokens,
+        )
+
+        # 转换 tool_calls 格式：从主项目格式转为 MaiSaka 格式
+        converted_tool_calls = []
+        if tool_calls:
+            for tc in tool_calls:
+                # 主项目的 ToolCall 有 call_id, func_name, args
+                call_id = tc.call_id if hasattr(tc, 'call_id') else ""
+                func_name = tc.func_name if hasattr(tc, 'func_name') else ""
+                args = tc.args if hasattr(tc, 'args') else {}
+
+                converted_tool_calls.append(ToolCall(
+                    id=call_id,
+                    name=func_name,
+                    arguments=args,
+                ))
+
+        # 构建原始消息格式（MaiSaka 风格）
+        raw_message = {"role": "assistant", "content": response}
+        if converted_tool_calls:
+            raw_message["tool_calls"] = [
+                {
+                    "id": tc.id,
+                    "type": "function",
+                    "function": {
+                        "name": tc.name,
+                        "arguments": json.dumps(tc.arguments),
+                    },
+                }
+                for tc in converted_tool_calls
+            ]
+
+        return ChatResponse(
+            content=response,
+            tool_calls=converted_tool_calls,
+            raw_message=raw_message,
+        )
+
+    def _filter_for_api(self, chat_history: List[dict]) -> str:
+        """过滤对话历史为 API 格式"""
+        parts = []
+        for msg in chat_history:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+
+            # 跳过内部字段
+            if role in ("perception", "tool"):
+                continue
+
+            if role == "system":
+                parts.append(f"System: {content}")
+            elif role == "user":
+                parts.append(f"User: {content}")
+            elif role == "assistant":
+                # 处理工具调用
+                if "tool_calls" in msg:
+                    tool_desc = ", ".join([tc.get("name", "") for tc in msg["tool_calls"]])
+                    parts.append(f"Assistant (called tools: {tool_desc})")
+                else:
+                    parts.append(f"Assistant: {content}")
+
+        return "\n\n".join(parts)
+
+    def build_chat_context(self, user_text: str) -> List[dict]:
+        """构建对话上下文"""
+        return [
+            {"role": "system", "content": self._chat_system_prompt},
+            {"role": "user", "content": user_text},
+        ]
+
+    # ──────── 分析模块（使用 utils 模型） ────────
+
+    async def analyze_emotion(self, chat_history: List[dict]) -> str:
+        """情绪分析 - 使用 utils 模型"""
+        filtered = [m for m in chat_history if m.get("_type") != "perception"]
+        recent = filtered[-10:] if len(filtered) > 10 else filtered
+
+        # 使用加载的系统提示词
+        system_prompt = self._emotion_prompt or "请分析以下对话中用户的情绪状态和言语态度："
+
+        prompt_parts = [f"{system_prompt}\n\n【对话内容】\n"]
+        for msg in recent:
+            if msg.get("role") == "user":
+                prompt_parts.append(f"用户: {msg.get('content', '')}")
+            elif msg.get("role") == "assistant":
+                prompt_parts.append(f"助手: {msg.get('content', '')}")
+
+        prompt = "\n".join(prompt_parts)
+
+        print("\n" + "="*60)
+        print("MaiSaka LLM Request - analyze_emotion:")
+        print(f"  {prompt}")
+        print("="*60 + "\n")
+
+        try:
+            response, _ = await self._llm_utils.generate_response_async(
+                prompt=prompt,
+                temperature=0.3,
+                max_tokens=512,
+            )
+
+            return response
+        except Exception as e:
+            logger.error(f"情绪分析 LLM 调用出错: {e}")
+            return ""
+
+    async def analyze_cognition(self, chat_history: List[dict]) -> str:
+        """认知分析 - 使用 utils 模型"""
+        filtered = [m for m in chat_history if m.get("_type") != "perception"]
+        recent = filtered[-10:] if len(filtered) > 10 else filtered
+
+        # 使用加载的系统提示词
+        system_prompt = self._cognition_prompt or "请分析以下对话中用户的意图、认知状态和目的："
+
+        prompt_parts = [f"{system_prompt}\n\n【对话内容】\n"]
+        for msg in recent:
+            if msg.get("role") == "user":
+                prompt_parts.append(f"用户: {msg.get('content', '')}")
+            elif msg.get("role") == "assistant":
+                prompt_parts.append(f"助手: {msg.get('content', '')}")
+
+        prompt = "\n".join(prompt_parts)
+
+        print("\n" + "="*60)
+        print("MaiSaka LLM Request - analyze_cognition:")
+        print(f"  {prompt}")
+        print("="*60 + "\n")
+
+        try:
+            response, _ = await self._llm_utils.generate_response_async(
+                prompt=prompt,
+                temperature=0.3,
+                max_tokens=512,
+            )
+
+            return response
+        except Exception as e:
+            logger.error(f"认知分析 LLM 调用出错: {e}")
+            return ""
+
+    async def analyze_timing(self, chat_history: List[dict], timing_info: str) -> str:
+        """时间分析 - 使用 utils 模型"""
+        filtered = [m for m in chat_history if m.get("_type") not in ("perception", "system")]
+
+        # 使用加载的系统提示词
+        system_prompt = self._timing_prompt or "请分析以下对话的时间节奏和用户状态："
+
+        prompt_parts = [f"{system_prompt}\n\n【系统时间戳信息】\n{timing_info}\n\n【当前对话记录】\n"]
+        for msg in filtered:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+            if role == "user":
+                prompt_parts.append(f"用户: {content}")
+            elif role == "assistant":
+                prompt_parts.append(f"助手: {content}")
+
+        prompt = "\n".join(prompt_parts)
+
+        print("\n" + "="*60)
+        print("MaiSaka LLM Request - analyze_timing:")
+        print(f"  {prompt}")
+        print("="*60 + "\n")
+
+        try:
+            response, _ = await self._llm_utils.generate_response_async(
+                prompt=prompt,
+                temperature=0.3,
+                max_tokens=512,
+            )
+
+            return response
+        except Exception as e:
+            logger.error(f"时间分析 LLM 调用出错: {e}")
+            return ""
+
+    async def summarize_context(self, context_messages: List[dict]) -> str:
+        """上下文总结 - 使用 utils 模型"""
+        filtered = [m for m in context_messages if m.get("role") != "system"]
+
+        # 使用加载的系统提示词
+        system_prompt = self._context_summarize_prompt or "请对以下对话内容进行总结："
+
+        prompt_parts = [f"{system_prompt}\n\n【对话内容】\n"]
+        for msg in filtered:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+            if role == "user":
+                prompt_parts.append(f"用户: {content}")
+            elif role == "assistant":
+                prompt_parts.append(f"助手: {content}")
+
+        prompt = "\n".join(prompt_parts)
+
+        print("\n" + "="*60)
+        print("MaiSaka LLM Request - summarize_context:")
+        print(f"  {prompt}")
+        print("="*60 + "\n")
+
+        try:
+            response, _ = await self._llm_utils.generate_response_async(
+                prompt=prompt,
+                temperature=0.3,
+                max_tokens=1024,
+            )
+
+            return response
+        except Exception as e:
+            logger.error(f"上下文总结 LLM 调用出错: {e}")
+            return ""
+
+    # ──────── 回复生成（使用 replyer 模型） ────────
+
+    async def generate_reply(self, reason: str, chat_history: List[dict]) -> str:
+        """
+        生成回复 - 使用 replyer 模型
+        可供 Replyer 类直接调用
+        """
+        from datetime import datetime
+        from replyer import format_chat_history
+
+        current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        # 格式化对话历史
+        filtered_history = [
+            msg for msg in chat_history
+            if msg.get("role") != "system" and msg.get("_type") != "perception"
+        ]
+        formatted_history = format_chat_history(filtered_history)
+
+        # 获取回复提示词
+        try:
+            replyer_prompt = prompt_manager.get_prompt("maidairy_replyer")
+            system_prompt = await prompt_manager.render_prompt(replyer_prompt)
+        except Exception:
+            system_prompt = "你是一个友好的 AI 助手，请根据用户的想法生成自然的回复。"
+
+        user_prompt = (
+            f"当前时间：{current_time}\n\n"
+            f"【聊天记录】\n{formatted_history}\n\n"
+            f"【你的想法】\n{reason}\n\n"
+            f"现在，你说："
+        )
+
+        messages = f"System: {system_prompt}\n\nUser: {user_prompt}"
+
+        print("\n" + "="*60)
+        print("MaiSaka LLM Request - generate_reply:")
+        print(f"  {messages}")
+        print("="*60 + "\n")
+
+        try:
+            response, _ = await self._llm_replyer.generate_response_async(
+                prompt=messages,
+                temperature=0.8,
+                max_tokens=512,
+            )
+
+            return response.strip() if response else "..."
+        except Exception as e:
+            logger.error(f"回复生成 LLM 调用出错: {e}")
+            return "..."