Merge branch 'dev' into dev

src/chat/chat_loop/heartFC_chat.py

@@ -2,7 +2,7 @@ import asyncio
 import time
 import traceback
 import random
-from typing import List, Optional, Dict, Any
+from typing import List, Optional, Dict, Any, Tuple
 from rich.traceback import install
 
 from src.config.config import global_config
@@ -217,9 +217,11 @@ class HeartFChatting:
                 filter_bot=True,
             )
             if global_config.chat.focus_value != 0:
-                if len(new_messages_data) > 3 / pow(global_config.chat.focus_value,0.5):
+                if len(new_messages_data) > 3 / pow(global_config.chat.focus_value, 0.5):
                     self.loop_mode = ChatMode.FOCUS
-                    self.energy_value = 10 + (len(new_messages_data) / (3 / pow(global_config.chat.focus_value,0.5))) * 10
+                    self.energy_value = (
+                        10 + (len(new_messages_data) / (3 / pow(global_config.chat.focus_value, 0.5))) * 10
+                    )
                     return True
 
                 if self.energy_value >= 30:
@@ -254,20 +256,21 @@ class HeartFChatting:
         )
         person_name = await person_info_manager.get_value(person_id, "person_name")
         return f"{person_name}:{message_data.get('processed_plain_text')}"
-    
+
     async def _send_and_store_reply(
         self,
-        response_set, 
-        reply_to_str, 
-        loop_start_time, 
-        action_message, 
-        cycle_timers, 
+        response_set,
+        reply_to_str,
+        loop_start_time,
+        action_message,
+        cycle_timers: Dict[str, float],
         thinking_id,
-        plan_result):
+        plan_result,
+    ) -> Tuple[Dict[str, Any], str, Dict[str, float]]:
         with Timer("回复发送", cycle_timers):
             reply_text = await self._send_response(response_set, reply_to_str, loop_start_time, action_message)
 
-                # 存储reply action信息
+            # 存储reply action信息
         person_info_manager = get_person_info_manager()
         person_id = person_info_manager.get_person_id(
             action_message.get("chat_info_platform", ""),
@@ -275,7 +278,7 @@ class HeartFChatting:
         )
         person_name = await person_info_manager.get_value(person_id, "person_name")
         action_prompt_display = f"你对{person_name}进行了回复：{reply_text}"
-        
+
         await database_api.store_action_info(
             chat_stream=self.chat_stream,
             action_build_into_prompt=False,
@@ -285,10 +288,9 @@ class HeartFChatting:
             action_data={"reply_text": reply_text, "reply_to": reply_to_str},
             action_name="reply",
         )
-        
-        
+
         # 构建循环信息
-        loop_info = {
+        loop_info: Dict[str, Any] = {
             "loop_plan_info": {
                 "action_result": plan_result.get("action_result", {}),
             },
@@ -299,8 +301,8 @@ class HeartFChatting:
                 "taken_time": time.time(),
             },
         }
-        
-        return loop_info, reply_text,cycle_timers
+
+        return loop_info, reply_text, cycle_timers
 
     async def _observe(self, message_data: Optional[Dict[str, Any]] = None):
         # sourcery skip: hoist-statement-from-if, merge-comparisons, reintroduce-else
@@ -310,12 +312,12 @@ class HeartFChatting:
         reply_text = ""  # 初始化reply_text变量，避免UnboundLocalError
         gen_task = None  # 初始化gen_task变量，避免UnboundLocalError
         reply_to_str = ""  # 初始化reply_to_str变量
-        
+
         # 创建新的循环信息
         cycle_timers, thinking_id = self.start_cycle()
 
         logger.info(f"{self.log_prefix} 开始第{self._cycle_counter}次思考[模式：{self.loop_mode}]")
-        
+
         if ENABLE_S4U:
             await send_typing()
 
@@ -337,19 +339,20 @@ class HeartFChatting:
             skip_planner = False
             if self.loop_mode == ChatMode.NORMAL:
                 # 过滤掉reply相关的动作，检查是否还有其他动作
-                non_reply_actions = {k: v for k, v in available_actions.items() 
-                                if k not in ['reply', 'no_reply', 'no_action']}
-                
+                non_reply_actions = {
+                    k: v for k, v in available_actions.items() if k not in ["reply", "no_reply", "no_action"]
+                }
+
                 if not non_reply_actions:
                     skip_planner = True
                     logger.info(f"{self.log_prefix} Normal模式下没有可用动作，直接回复")
-                    
+
                     # 直接设置为reply动作
                     action_type = "reply"
                     reasoning = ""
                     action_data = {"loop_start_time": loop_start_time}
                     is_parallel = False
-                    
+
                     # 构建plan_result用于后续处理
                     plan_result = {
                         "action_result": {
@@ -361,22 +364,25 @@ class HeartFChatting:
                         },
                         "action_prompt": "",
                     }
-                    target_message = message_data            
-                
+                    target_message = message_data
+
                 # 如果normal模式且不跳过规划器，开始一个回复生成进程，先准备好回复（其实是和planer同时进行的）
                 if not skip_planner:
                     reply_to_str = await self.build_reply_to_str(message_data)
-                    gen_task = asyncio.create_task(self._generate_response(
-                        message_data=message_data, 
-                        available_actions=available_actions, 
-                        reply_to=reply_to_str, 
-                        request_type="chat.replyer.normal"))
-                    
+                    gen_task = asyncio.create_task(
+                        self._generate_response(
+                            message_data=message_data,
+                            available_actions=available_actions,
+                            reply_to=reply_to_str,
+                            request_type="chat.replyer.normal",
+                        )
+                    )
+
             if not skip_planner:
                 with Timer("规划器", cycle_timers):
                     plan_result, target_message = await self.action_planner.plan(mode=self.loop_mode)
 
-                action_result: dict = plan_result.get("action_result", {})  # type: ignore
+                action_result: Dict[str, Any] = plan_result.get("action_result", {})  # type: ignore
                 action_type, action_data, reasoning, is_parallel = (
                     action_result.get("action_type", "error"),
                     action_result.get("action_data", {}),
@@ -386,29 +392,27 @@ class HeartFChatting:
 
                 action_data["loop_start_time"] = loop_start_time
 
-
             if action_type == "reply":
                 logger.info(f"{self.log_prefix}{global_config.bot.nickname} 决定进行回复")
             elif is_parallel:
-                logger.info(
-                    f"{self.log_prefix}{global_config.bot.nickname} 决定进行回复, 同时执行{action_type}动作"
-                )
+                logger.info(f"{self.log_prefix}{global_config.bot.nickname} 决定进行回复, 同时执行{action_type}动作")
             else:
                 # 只有在gen_task存在时才进行相关操作
-                if gen_task is not None:
+                if gen_task:
                     if not gen_task.done():
                         gen_task.cancel()
                         logger.debug(f"{self.log_prefix} 已取消预生成的回复任务")
                         logger.info(
                             f"{self.log_prefix}{global_config.bot.nickname} 原本想要回复，但选择执行{action_type}，不发表回复"
                         )
-                    else:
-                        content = " ".join([item[1] for item in gen_task.result() if item[0] == "text"])
+                    elif generation_result := gen_task.result():
+                        content = " ".join([item[1] for item in generation_result if item[0] == "text"])
                         logger.debug(f"{self.log_prefix} 预生成的回复任务已完成")
                         logger.info(
                             f"{self.log_prefix}{global_config.bot.nickname} 原本想要回复：{content}，但选择执行{action_type}，不发表回复"
                         )
-
+                    else:
+                        logger.warning(f"{self.log_prefix} 预生成的回复任务未生成有效内容")
 
             action_message: Dict[str, Any] = message_data or target_message  # type: ignore
             if action_type == "reply":
@@ -417,11 +421,14 @@ class HeartFChatting:
                     # 只有在gen_task存在时才等待
                     if not gen_task:
                         reply_to_str = await self.build_reply_to_str(message_data)
-                        gen_task = asyncio.create_task(self._generate_response(
-                            message_data=message_data, 
-                            available_actions=available_actions, 
-                            reply_to=reply_to_str, 
-                            request_type="chat.replyer.normal"))
+                        gen_task = asyncio.create_task(
+                            self._generate_response(
+                                message_data=message_data,
+                                available_actions=available_actions,
+                                reply_to=reply_to_str,
+                                request_type="chat.replyer.normal",
+                            )
+                        )
 
                     gather_timeout = global_config.chat.thinking_timeout
                     try:
@@ -436,56 +443,71 @@ class HeartFChatting:
                         return False
                 else:
                     logger.info(f"{self.log_prefix}{global_config.bot.nickname} 决定进行回复 (focus模式)")
-                    
+
                     # 构建reply_to字符串
                     reply_to_str = await self.build_reply_to_str(action_message)
-                    
+
                     # 生成回复
                     with Timer("回复生成", cycle_timers):
                         response_set = await self._generate_response(
-                            message_data=action_message, 
-                            available_actions=available_actions, 
-                            reply_to=reply_to_str, 
-                            request_type="chat.replyer.focus")
-                    
+                            message_data=action_message,
+                            available_actions=available_actions,
+                            reply_to=reply_to_str,
+                            request_type="chat.replyer.focus",
+                        )
+
                     if not response_set:
                         logger.warning(f"{self.log_prefix}模型未生成回复内容")
                         return False
-                    
-                loop_info, reply_text,cycle_timers = await self._send_and_store_reply(response_set, reply_to_str, loop_start_time, action_message, cycle_timers, thinking_id, plan_result)
-                
+
+                loop_info, reply_text, cycle_timers = await self._send_and_store_reply(
+                    response_set, reply_to_str, loop_start_time, action_message, cycle_timers, thinking_id, plan_result
+                )
+
                 return True
 
             else:
                 # 并行执行：同时进行回复发送和动作执行
-                tasks = []
-                
+                # 先置空防止未定义错误
+                background_reply_task = None
+                background_action_task = None
                 # 如果是并行执行且在normal模式下，需要等待预生成的回复任务完成并发送回复
                 if self.loop_mode == ChatMode.NORMAL and is_parallel and gen_task:
-                    async def handle_reply_task():
+
+                    async def handle_reply_task() -> Tuple[Optional[Dict[str, Any]], str, Dict[str, float]]:
                         # 等待预生成的回复任务完成
                         gather_timeout = global_config.chat.thinking_timeout
                         try:
                             response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout)
-                            
+
                         except asyncio.TimeoutError:
-                            logger.warning(f"{self.log_prefix} 并行执行：回复生成超时>{global_config.chat.thinking_timeout}s，已跳过")
+                            logger.warning(
+                                f"{self.log_prefix} 并行执行：回复生成超时>{global_config.chat.thinking_timeout}s，已跳过"
+                            )
                             return None, "", {}
                         except asyncio.CancelledError:
                             logger.debug(f"{self.log_prefix} 并行执行：回复生成任务已被取消")
                             return None, "", {}
-                    
+
                         if not response_set:
                             logger.warning(f"{self.log_prefix} 模型超时或生成回复内容为空")
                             return None, "", {}
-                            
+
                         reply_to_str = await self.build_reply_to_str(action_message)
-                        loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(response_set, reply_to_str, loop_start_time, action_message, cycle_timers, thinking_id, plan_result)
+                        loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(
+                            response_set,
+                            reply_to_str,
+                            loop_start_time,
+                            action_message,
+                            cycle_timers,
+                            thinking_id,
+                            plan_result,
+                        )
                         return loop_info, reply_text, cycle_timers_reply
-                    
-                    # 添加回复任务到并行任务列表
-                    tasks.append(asyncio.create_task(handle_reply_task()))
-                
+
+                    # 执行回复任务并赋值到变量
+                    background_reply_task = asyncio.create_task(handle_reply_task())
+
                 # 动作执行任务
                 async def handle_action_task():
                     with Timer("动作执行", cycle_timers):
@@ -493,52 +515,55 @@ class HeartFChatting:
                             action_type, reasoning, action_data, cycle_timers, thinking_id, action_message
                         )
                     return success, reply_text, command
-                
-                # 添加动作执行任务到并行任务列表
-                tasks.append(asyncio.create_task(handle_action_task()))
-                
-                # 并行执行所有任务
-                results = await asyncio.gather(*tasks, return_exceptions=True)
-                
-                # 处理结果
+
+                # 执行动作任务并赋值到变量
+                background_action_task = asyncio.create_task(handle_action_task())
+
                 reply_loop_info = None
                 reply_text_from_reply = ""
                 action_success = False
                 action_reply_text = ""
                 action_command = ""
-                
-                if len(tasks) == 2:  # 有回复任务和动作任务
+
+                # 并行执行所有任务
+                if background_reply_task:
+                    results = await asyncio.gather(
+                        background_reply_task, background_action_task, return_exceptions=True
+                    )
                     # 处理回复任务结果
                     reply_result = results[0]
-                    if isinstance(reply_result, Exception):
+                    if isinstance(reply_result, BaseException):
                         logger.error(f"{self.log_prefix} 回复任务执行异常: {reply_result}")
                     elif reply_result and reply_result[0] is not None:
                         reply_loop_info, reply_text_from_reply, _ = reply_result
-                    
+
                     # 处理动作任务结果
-                    action_result = results[1]
-                    if isinstance(action_result, Exception):
-                        logger.error(f"{self.log_prefix} 动作任务执行异常: {action_result}")
+                    action_task_result = results[1]
+                    if isinstance(action_task_result, BaseException):
+                        logger.error(f"{self.log_prefix} 动作任务执行异常: {action_task_result}")
                     else:
-                        action_success, action_reply_text, action_command = action_result
-                        
-                else:  # 只有动作任务
-                    action_result = results[0]
-                    if isinstance(action_result, Exception):
-                        logger.error(f"{self.log_prefix} 动作任务执行异常: {action_result}")
+                        action_success, action_reply_text, action_command = action_task_result
+                else:
+                    results = await asyncio.gather(background_action_task, return_exceptions=True)
+                    # 只有动作任务
+                    action_task_result = results[0]
+                    if isinstance(action_task_result, BaseException):
+                        logger.error(f"{self.log_prefix} 动作任务执行异常: {action_task_result}")
                     else:
-                        action_success, action_reply_text, action_command = action_result
+                        action_success, action_reply_text, action_command = action_task_result
 
                 # 构建最终的循环信息
                 if reply_loop_info:
                     # 如果有回复信息，使用回复的loop_info作为基础
                     loop_info = reply_loop_info
                     # 更新动作执行信息
-                    loop_info["loop_action_info"].update({
-                        "action_taken": action_success,
-                        "command": action_command,
-                        "taken_time": time.time(),
-                    })
+                    loop_info["loop_action_info"].update(
+                        {
+                            "action_taken": action_success,
+                            "command": action_command,
+                            "taken_time": time.time(),
+                        }
+                    )
                     reply_text = reply_text_from_reply
                 else:
                     # 没有回复信息，构建纯动作的loop_info
@@ -555,11 +580,10 @@ class HeartFChatting:
                     }
                     reply_text = action_reply_text
 
-
         if ENABLE_S4U:
             await stop_typing()
             await mai_thinking_manager.get_mai_think(self.stream_id).do_think_after_response(reply_text)
-        
+
         self.end_cycle(loop_info, cycle_timers)
         self.print_cycle_info(cycle_timers)
 
@@ -603,7 +627,7 @@ class HeartFChatting:
         action: str,
         reasoning: str,
         action_data: dict,
-        cycle_timers: dict,
+        cycle_timers: Dict[str, float],
         thinking_id: str,
         action_message: dict,
     ) -> tuple[bool, str, str]:
@@ -712,7 +736,11 @@ class HeartFChatting:
         return False
 
     async def _generate_response(
-        self, message_data: dict, available_actions: Optional[Dict[str, ActionInfo]], reply_to: str, request_type: str = "chat.replyer.normal"
+        self,
+        message_data: dict,
+        available_actions: Optional[Dict[str, ActionInfo]],
+        reply_to: str,
+        request_type: str = "chat.replyer.normal",
     ) -> Optional[list]:
         """生成普通回复"""
         try:
@@ -734,7 +762,7 @@ class HeartFChatting:
             logger.error(f"{self.log_prefix}回复生成出现错误：{str(e)} {traceback.format_exc()}")
             return None
 
-    async def _send_response(self, reply_set, reply_to, thinking_start_time, message_data):
+    async def _send_response(self, reply_set, reply_to, thinking_start_time, message_data) -> str:
         current_time = time.time()
         new_message_count = message_api.count_new_messages(
             chat_id=self.chat_stream.stream_id, start_time=thinking_start_time, end_time=current_time
@@ -746,13 +774,9 @@ class HeartFChatting:
         need_reply = new_message_count >= random.randint(2, 4)
 
         if need_reply:
-            logger.info(
-                f"{self.log_prefix} 从思考到回复，共有{new_message_count}条新消息，使用引用回复"
-            )
+            logger.info(f"{self.log_prefix} 从思考到回复，共有{new_message_count}条新消息，使用引用回复")
         else:
-            logger.info(
-                f"{self.log_prefix} 从思考到回复，共有{new_message_count}条新消息，不使用引用回复"
-            )
+            logger.info(f"{self.log_prefix} 从思考到回复，共有{new_message_count}条新消息，不使用引用回复")
 
         reply_text = ""
         first_replied = False

src/chat/message_receive/message.py

@@ -444,7 +444,7 @@ class MessageSending(MessageProcessBase):
         is_emoji: bool = False,
         thinking_start_time: float = 0,
         apply_set_reply_logic: bool = False,
-        reply_to: str = None,  # type: ignore
+        reply_to: Optional[str] = None,
     ):
         # 调用父类初始化
         super().__init__(

src/chat/planner_actions/planner.py

@@ -211,9 +211,8 @@ class ActionPlanner:
             reasoning = f"Planner 内部处理错误: {outer_e}"
 
         is_parallel = False
-        if mode == ChatMode.NORMAL:
-            if action in current_available_actions:
-                is_parallel = current_available_actions[action].parallel_action
+        if mode == ChatMode.NORMAL and action in current_available_actions:
+            is_parallel = current_available_actions[action].parallel_action
 
         action_result = {
             "action_type": action,
@@ -256,7 +255,7 @@ class ActionPlanner:
 
             actions_before_now = get_actions_by_timestamp_with_chat(
                 chat_id=self.chat_id,
-                timestamp_start=time.time()-3600,
+                timestamp_start=time.time() - 3600,
                 timestamp_end=time.time(),
                 limit=5,
             )
@@ -264,7 +263,7 @@ class ActionPlanner:
             actions_before_now_block = build_readable_actions(
                 actions=actions_before_now,
             )
-            
+
             actions_before_now_block = f"你刚刚选择并执行过的action是：\n{actions_before_now_block}"
 
             self.last_obs_time_mark = time.time()
@@ -276,7 +275,6 @@ class ActionPlanner:
                 if global_config.chat.at_bot_inevitable_reply:
                     mentioned_bonus = "\n- 有人提到你，或者at你"
 
-                
                 by_what = "聊天内容"
                 target_prompt = '\n    "target_message_id":"触发action的消息id"'
                 no_action_block = f"""重要说明：

src/chat/replyer/default_generator.py

@@ -39,7 +39,7 @@ def init_prompt():
     Prompt("你正在和{sender_name}聊天，这是你们之前聊的内容：", "chat_target_private1")
     Prompt("在群里聊天", "chat_target_group2")
     Prompt("和{sender_name}聊天", "chat_target_private2")
-    
+
     Prompt(
         """
 {expression_habits_block}
@@ -156,10 +156,18 @@ class DefaultReplyer:
         extra_info: str = "",
         available_actions: Optional[Dict[str, ActionInfo]] = None,
         enable_tool: bool = True,
-        enable_timeout: bool = False,
     ) -> Tuple[bool, Optional[str], Optional[str]]:
         """
-        回复器 (Replier): 核心逻辑，负责生成回复文本。
+        回复器 (Replier): 负责生成回复文本的核心逻辑。
+
+        Args:
+            reply_to: 回复对象，格式为 "发送者:消息内容"
+            extra_info: 额外信息，用于补充上下文
+            available_actions: 可用的动作信息字典
+            enable_tool: 是否启用工具调用
+
+        Returns:
+            Tuple[bool, Optional[str], Optional[str]]: (是否成功, 生成的回复内容, 使用的prompt)
         """
         prompt = None
         if available_actions is None:
@@ -168,43 +176,25 @@ class DefaultReplyer:
             # 3. 构建 Prompt
             with Timer("构建Prompt", {}):  # 内部计时器，可选保留
                 prompt = await self.build_prompt_reply_context(
-                    reply_to = reply_to,
+                    reply_to=reply_to,
                     extra_info=extra_info,
                     available_actions=available_actions,
-                    enable_timeout=enable_timeout,
                     enable_tool=enable_tool,
                 )
-                
+
             if not prompt:
                 logger.warning("构建prompt失败，跳过回复生成")
                 return False, None, None
 
             # 4. 调用 LLM 生成回复
             content = None
-            reasoning_content = None
-            model_name = "unknown_model"
+            # TODO: 复活这里
+            # reasoning_content = None
+            # model_name = "unknown_model"
 
             try:
-                with Timer("LLM生成", {}):  # 内部计时器，可选保留
-                    # 加权随机选择一个模型配置
-                    selected_model_config = self._select_weighted_model_config()
-                    logger.info(
-                        f"使用模型生成回复: {selected_model_config.get('name', 'N/A')} (选中概率: {selected_model_config.get('weight', 1.0)})"
-                    )
-
-                    express_model = LLMRequest(
-                        model=selected_model_config,
-                        request_type=self.request_type,
-                    )
-
-                    if global_config.debug.show_prompt:
-                        logger.info(f"\n{prompt}\n")
-                    else:
-                        logger.debug(f"\n{prompt}\n")
-
-                    content, (reasoning_content, model_name) = await express_model.generate_response_async(prompt)
-
-                    logger.debug(f"replyer生成内容: {content}")
+                content = await self.llm_generate_content(prompt)
+                logger.debug(f"replyer生成内容: {content}")
 
             except Exception as llm_e:
                 # 精简报错信息
@@ -220,62 +210,54 @@ class DefaultReplyer:
 
     async def rewrite_reply_with_context(
         self,
-        reply_data: Dict[str, Any],
         raw_reply: str = "",
         reason: str = "",
         reply_to: str = "",
-        relation_info: str = "",
-    ) -> Tuple[bool, Optional[str]]:
+        return_prompt: bool = False,
+    ) -> Tuple[bool, Optional[str], Optional[str]]:
         """
-        表达器 (Expressor): 核心逻辑，负责生成回复文本。
+        表达器 (Expressor): 负责重写和优化回复文本。
+
+        Args:
+            raw_reply: 原始回复内容
+            reason: 回复原因
+            reply_to: 回复对象，格式为 "发送者:消息内容"
+            relation_info: 关系信息
+
+        Returns:
+            Tuple[bool, Optional[str]]: (是否成功, 重写后的回复内容)
         """
         try:
-            if not reply_data:
-                reply_data = {
-                    "reply_to": reply_to,
-                    "relation_info": relation_info,
-                }
-
             with Timer("构建Prompt", {}):  # 内部计时器，可选保留
                 prompt = await self.build_prompt_rewrite_context(
-                    reply_data=reply_data,
+                    raw_reply=raw_reply,
+                    reason=reason,
+                    reply_to=reply_to,
                 )
 
             content = None
-            reasoning_content = None
-            model_name = "unknown_model"
+            # TODO: 复活这里
+            # reasoning_content = None
+            # model_name = "unknown_model"
             if not prompt:
                 logger.error("Prompt 构建失败，无法生成回复。")
-                return False, None
+                return False, None, None
 
             try:
-                with Timer("LLM生成", {}):  # 内部计时器，可选保留
-                    # 加权随机选择一个模型配置
-                    selected_model_config = self._select_weighted_model_config()
-                    logger.info(
-                        f"使用模型重写回复: {selected_model_config.get('name', 'N/A')} (选中概率: {selected_model_config.get('weight', 1.0)})"
-                    )
-
-                    express_model = LLMRequest(
-                        model=selected_model_config,
-                        request_type=self.request_type,
-                    )
-
-                    content, (reasoning_content, model_name) = await express_model.generate_response_async(prompt)
-
-                    logger.info(f"想要表达：{raw_reply}||理由：{reason}||生成回复: {content}\n")
+                content = await self.llm_generate_content(prompt)
+                logger.info(f"想要表达：{raw_reply}||理由：{reason}||生成回复: {content}\n")
 
             except Exception as llm_e:
                 # 精简报错信息
                 logger.error(f"LLM 生成失败: {llm_e}")
-                return False, None  # LLM 调用失败则无法生成回复
+                return False, None, prompt if return_prompt else None  # LLM 调用失败则无法生成回复
 
-            return True, content
+            return True, content, prompt if return_prompt else None
 
         except Exception as e:
             logger.error(f"回复生成意外失败: {e}")
             traceback.print_exc()
-            return False, None
+            return False, None, prompt if return_prompt else None
 
     async def build_relation_info(self, reply_to: str = ""):
         if not global_config.relationship.enable_relationship:
@@ -297,7 +279,16 @@ class DefaultReplyer:
 
         return await relationship_fetcher.build_relation_info(person_id, points_num=5)
 
-    async def build_expression_habits(self, chat_history, target):
+    async def build_expression_habits(self, chat_history: str, target: str) -> str:
+        """构建表达习惯块
+
+        Args:
+            chat_history: 聊天历史记录
+            target: 目标消息内容
+
+        Returns:
+            str: 表达习惯信息字符串
+        """
         if not global_config.expression.enable_expression:
             return ""
 
@@ -343,11 +334,18 @@ class DefaultReplyer:
         if style_habits_str.strip() and grammar_habits_str.strip():
             expression_habits_title = "你可以参考以下的语言习惯和句法，如果情景合适就使用，不要盲目使用,不要生硬使用，以合理的方式结合到你的回复中："
 
-        expression_habits_block = f"{expression_habits_title}\n{expression_habits_block}"
+        return f"{expression_habits_title}\n{expression_habits_block}"
 
-        return expression_habits_block
+    async def build_memory_block(self, chat_history: str, target: str) -> str:
+        """构建记忆块
 
-    async def build_memory_block(self, chat_history, target):
+        Args:
+            chat_history: 聊天历史记录
+            target: 目标消息内容
+
+        Returns:
+            str: 记忆信息字符串
+        """
         if not global_config.memory.enable_memory:
             return ""
 
@@ -375,12 +373,13 @@ class DefaultReplyer:
 
         return memory_str
 
-    async def build_tool_info(self, chat_history, reply_to: str = "", enable_tool: bool = True):
+    async def build_tool_info(self, chat_history: str, reply_to: str = "", enable_tool: bool = True) -> str:
         """构建工具信息块
 
         Args:
-            reply_data: 回复数据，包含要回复的消息内容
-            chat_history: 聊天历史
+            chat_history: 聊天历史记录
+            reply_to: 回复对象，格式为 "发送者:消息内容"
+            enable_tool: 是否启用工具调用
 
         Returns:
             str: 工具信息字符串
@@ -424,7 +423,15 @@ class DefaultReplyer:
             logger.error(f"工具信息获取失败: {e}")
             return ""
 
-    def _parse_reply_target(self, target_message: str) -> tuple:
+    def _parse_reply_target(self, target_message: str) -> Tuple[str, str]:
+        """解析回复目标消息
+
+        Args:
+            target_message: 目标消息，格式为 "发送者:消息内容" 或 "发送者：消息内容"
+
+        Returns:
+            Tuple[str, str]: (发送者名称, 消息内容)
+        """
         sender = ""
         target = ""
         # 添加None检查，防止NoneType错误
@@ -438,7 +445,15 @@ class DefaultReplyer:
                 target = parts[1].strip()
         return sender, target
 
-    async def build_keywords_reaction_prompt(self, target):
+    async def build_keywords_reaction_prompt(self, target: Optional[str]) -> str:
+        """构建关键词反应提示
+
+        Args:
+            target: 目标消息内容
+
+        Returns:
+            str: 关键词反应提示字符串
+        """
         # 关键词检测与反应
         keywords_reaction_prompt = ""
         try:
@@ -472,15 +487,25 @@ class DefaultReplyer:
 
         return keywords_reaction_prompt
 
-    async def _time_and_run_task(self, coroutine, name: str):
-        """一个简单的帮助函数，用于计时和运行异步任务，返回任务名、结果和耗时"""
+    async def _time_and_run_task(self, coroutine, name: str) -> Tuple[str, Any, float]:
+        """计时并运行异步任务的辅助函数
+
+        Args:
+            coroutine: 要执行的协程
+            name: 任务名称
+
+        Returns:
+            Tuple[str, Any, float]: (任务名称, 任务结果, 执行耗时)
+        """
         start_time = time.time()
         result = await coroutine
         end_time = time.time()
         duration = end_time - start_time
         return name, result, duration
 
-    def build_s4u_chat_history_prompts(self, message_list_before_now: list, target_user_id: str) -> tuple[str, str]:
+    def build_s4u_chat_history_prompts(
+        self, message_list_before_now: List[Dict[str, Any]], target_user_id: str
+    ) -> Tuple[str, str]:
         """
         构建 s4u 风格的分离对话 prompt
 
@@ -489,7 +514,7 @@ class DefaultReplyer:
             target_user_id: 目标用户ID（当前对话对象）
 
         Returns:
-            tuple: (核心对话prompt, 背景对话prompt)
+            Tuple[str, str]: (核心对话prompt, 背景对话prompt)
         """
         core_dialogue_list = []
         background_dialogue_list = []
@@ -508,7 +533,7 @@ class DefaultReplyer:
                     # 其他用户的对话
                     background_dialogue_list.append(msg_dict)
             except Exception as e:
-                logger.error(f"![1753364551656](image/default_generator/1753364551656.png)记录: {msg_dict}, 错误: {e}")
+                logger.error(f"处理消息记录时出错: {msg_dict}, 错误: {e}")
 
         # 构建背景对话 prompt
         background_dialogue_prompt = ""
@@ -553,8 +578,25 @@ class DefaultReplyer:
         sender: str,
         target: str,
         chat_info: str,
-    ):
-        """构建 mai_think 上下文信息"""
+    ) -> Any:
+        """构建 mai_think 上下文信息
+
+        Args:
+            chat_id: 聊天ID
+            memory_block: 记忆块内容
+            relation_info: 关系信息
+            time_block: 时间块内容
+            chat_target_1: 聊天目标1
+            chat_target_2: 聊天目标2
+            mood_prompt: 情绪提示
+            identity_block: 身份块内容
+            sender: 发送者名称
+            target: 目标消息内容
+            chat_info: 聊天信息
+
+        Returns:
+            Any: mai_think 实例
+        """
         mai_think = mai_thinking_manager.get_mai_think(chat_id)
         mai_think.memory_block = memory_block
         mai_think.relation_info_block = relation_info
@@ -573,19 +615,17 @@ class DefaultReplyer:
         reply_to: str,
         extra_info: str = "",
         available_actions: Optional[Dict[str, ActionInfo]] = None,
-        enable_timeout: bool = False,
         enable_tool: bool = True,
     ) -> str:  # sourcery skip: merge-else-if-into-elif, remove-redundant-if
         """
         构建回复器上下文
 
         Args:
-            reply_data: 回复数据
-                replay_data 包含以下字段：
-                    structured_info: 结构化信息，一般是工具调用获得的信息
-                    reply_to: 回复对象
-                    extra_info/extra_info_block: 额外信息
+            reply_to: 回复对象，格式为 "发送者:消息内容"
+            extra_info: 额外信息，用于补充上下文
             available_actions: 可用动作
+            enable_timeout: 是否启用超时处理
+            enable_tool: 是否启用工具调用
 
         Returns:
             str: 构建好的上下文
@@ -800,15 +840,14 @@ class DefaultReplyer:
 
     async def build_prompt_rewrite_context(
         self,
-        reply_data: Dict[str, Any],
+        raw_reply: str,
+        reason: str,
+        reply_to: str,
     ) -> str:
         chat_stream = self.chat_stream
         chat_id = chat_stream.stream_id
         is_group_chat = bool(chat_stream.group_info)
 
-        reply_to = reply_data.get("reply_to", "none")
-        raw_reply = reply_data.get("raw_reply", "")
-        reason = reply_data.get("reason", "")
         sender, target = self._parse_reply_target(reply_to)
 
         # 添加情绪状态获取
@@ -835,7 +874,7 @@ class DefaultReplyer:
         # 并行执行2个构建任务
         expression_habits_block, relation_info = await asyncio.gather(
             self.build_expression_habits(chat_talking_prompt_half, target),
-            self.build_relation_info(reply_data),
+            self.build_relation_info(reply_to),
         )
 
         keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target)
@@ -938,6 +977,30 @@ class DefaultReplyer:
             display_message=display_message,
         )
 
+    async def llm_generate_content(self, prompt: str) -> str:
+        with Timer("LLM生成", {}):  # 内部计时器，可选保留
+            # 加权随机选择一个模型配置
+            selected_model_config = self._select_weighted_model_config()
+            logger.info(
+                f"使用模型生成回复: {selected_model_config.get('name', 'N/A')} (选中概率: {selected_model_config.get('weight', 1.0)})"
+            )
+
+            express_model = LLMRequest(
+                model=selected_model_config,
+                request_type=self.request_type,
+            )
+
+            if global_config.debug.show_prompt:
+                logger.info(f"\n{prompt}\n")
+            else:
+                logger.debug(f"\n{prompt}\n")
+
+            # TODO: 这里的_应该做出替换
+            content, _ = await express_model.generate_response_async(prompt)
+
+            logger.debug(f"replyer生成内容: {content}")
+        return content
+
 
 def weighted_sample_no_replacement(items, weights, k) -> list:
     """
@@ -996,9 +1059,7 @@ async def get_prompt_info(message: str, threshold: float):
             logger.debug(f"获取知识库内容耗时: {(end_time - start_time):.3f}秒")
             logger.debug(f"获取知识库内容，相关信息：{related_info[:100]}...，信息长度: {len(related_info)}")
 
-            # 格式化知识信息
-            formatted_prompt_info = f"你有以下这些**知识**：\n{related_info}\n请你**记住上面的知识**，之后可能会用到。\n"
-            return formatted_prompt_info
+            return f"你有以下这些**知识**：\n{related_info}\n请你**记住上面的知识**，之后可能会用到。\n"
         else:
             logger.debug("从LPMM知识库获取知识失败，可能是从未导入过知识，返回空知识...")
             return ""

src/llm_models/utils_model.py

@@ -851,7 +851,7 @@ class LLMRequest:
 
     def _default_response_handler(
         self, result: dict, user_id: str = "system", request_type: str = None, endpoint: str = "/chat/completions"
-    ) -> Tuple:
+    ):
         """默认响应解析"""
         if "choices" in result and result["choices"]:
             message = result["choices"][0]["message"]

src/plugin_system/__init__.py

@@ -46,7 +46,6 @@ from .apis import (
     person_api,
     plugin_manage_api,
     send_api,
-    utils_api,
     register_plugin,
     get_logger,
 )
@@ -68,7 +67,6 @@ __all__ = [
     "person_api",
     "plugin_manage_api",
     "send_api",
-    "utils_api",
     "register_plugin",
     "get_logger",
     # 基础类

src/plugin_system/apis/__init__.py

@@ -17,7 +17,6 @@ from src.plugin_system.apis import (
     person_api,
     plugin_manage_api,
     send_api,
-    utils_api,
 )
 from .logging_api import get_logger
 from .plugin_register_api import register_plugin
@@ -35,7 +34,6 @@ __all__ = [
     "person_api",
     "plugin_manage_api",
     "send_api",
-    "utils_api",
     "get_logger",
     "register_plugin",
 ]

src/plugin_system/apis/chat_api.py

@@ -210,7 +210,7 @@ class ChatManager:
             chat_stream: 聊天流对象
 
         Returns:
-            Dict[str, Any]: 聊天流信息字典
+            Dict ({str: Any}): 聊天流信息字典
 
         Raises:
             TypeError: 如果 chat_stream 不是 ChatStream 类型
@@ -285,41 +285,41 @@ class ChatManager:
 # =============================================================================
 
 
-def get_all_streams(platform: Optional[str] | SpecialTypes = "qq"):
+def get_all_streams(platform: Optional[str] | SpecialTypes = "qq") -> List[ChatStream]:
     """获取所有聊天流的便捷函数"""
     return ChatManager.get_all_streams(platform)
 
 
-def get_group_streams(platform: Optional[str] | SpecialTypes = "qq"):
+def get_group_streams(platform: Optional[str] | SpecialTypes = "qq") -> List[ChatStream]:
     """获取群聊聊天流的便捷函数"""
     return ChatManager.get_group_streams(platform)
 
 
-def get_private_streams(platform: Optional[str] | SpecialTypes = "qq"):
+def get_private_streams(platform: Optional[str] | SpecialTypes = "qq") -> List[ChatStream]:
     """获取私聊聊天流的便捷函数"""
     return ChatManager.get_private_streams(platform)
 
 
-def get_stream_by_group_id(group_id: str, platform: Optional[str] | SpecialTypes = "qq"):
+def get_stream_by_group_id(group_id: str, platform: Optional[str] | SpecialTypes = "qq") -> Optional[ChatStream]:
     """根据群ID获取聊天流的便捷函数"""
     return ChatManager.get_group_stream_by_group_id(group_id, platform)
 
 
-def get_stream_by_user_id(user_id: str, platform: Optional[str] | SpecialTypes = "qq"):
+def get_stream_by_user_id(user_id: str, platform: Optional[str] | SpecialTypes = "qq") -> Optional[ChatStream]:
     """根据用户ID获取私聊流的便捷函数"""
     return ChatManager.get_private_stream_by_user_id(user_id, platform)
 
 
-def get_stream_type(chat_stream: ChatStream):
+def get_stream_type(chat_stream: ChatStream) -> str:
     """获取聊天流类型的便捷函数"""
     return ChatManager.get_stream_type(chat_stream)
 
 
-def get_stream_info(chat_stream: ChatStream):
+def get_stream_info(chat_stream: ChatStream) -> Dict[str, Any]:
     """获取聊天流信息的便捷函数"""
     return ChatManager.get_stream_info(chat_stream)
 
 
-def get_streams_summary():
+def get_streams_summary() -> Dict[str, int]:
     """获取聊天流统计摘要的便捷函数"""
     return ChatManager.get_streams_summary()

src/plugin_system/apis/config_api.py

@@ -10,7 +10,6 @@
 from typing import Any
 from src.common.logger import get_logger
 from src.config.config import global_config
-from src.person_info.person_info import get_person_info_manager
 
 logger = get_logger("config_api")
 
@@ -26,7 +25,7 @@ def get_global_config(key: str, default: Any = None) -> Any:
     插件应使用此方法读取全局配置，以保证只读和隔离性。
 
     Args:
-        key: 命名空间式配置键名，支持嵌套访问，如 "section.subsection.key"，大小写敏感
+        key: 命名空间式配置键名，使用嵌套访问，如 "section.subsection.key"，大小写敏感
         default: 如果配置不存在时返回的默认值
 
     Returns:
@@ -76,50 +75,3 @@ def get_plugin_config(plugin_config: dict, key: str, default: Any = None) -> Any
     except Exception as e:
         logger.warning(f"[ConfigAPI] 获取插件配置 {key} 失败: {e}")
         return default
-
-
-# =============================================================================
-# 用户信息API函数
-# =============================================================================
-
-
-async def get_user_id_by_person_name(person_name: str) -> tuple[str, str]:
-    """根据内部用户名获取用户ID
-
-    Args:
-        person_name: 用户名
-
-    Returns:
-        tuple[str, str]: (平台, 用户ID)
-    """
-    try:
-        person_info_manager = get_person_info_manager()
-        person_id = person_info_manager.get_person_id_by_person_name(person_name)
-        user_id: str = await person_info_manager.get_value(person_id, "user_id")  # type: ignore
-        platform: str = await person_info_manager.get_value(person_id, "platform")  # type: ignore
-        return platform, user_id
-    except Exception as e:
-        logger.error(f"[ConfigAPI] 根据用户名获取用户ID失败: {e}")
-        return "", ""
-
-
-async def get_person_info(person_id: str, key: str, default: Any = None) -> Any:
-    """获取用户信息
-
-    Args:
-        person_id: 用户ID
-        key: 信息键名
-        default: 默认值
-
-    Returns:
-        Any: 用户信息值或默认值
-    """
-    try:
-        person_info_manager = get_person_info_manager()
-        response = await person_info_manager.get_value(person_id, key)
-        if not response:
-            raise ValueError(f"[ConfigAPI] 获取用户 {person_id} 的信息 '{key}' 失败，返回默认值")
-        return response
-    except Exception as e:
-        logger.error(f"[ConfigAPI] 获取用户信息失败: {e}")
-        return default

src/plugin_system/apis/database_api.py

@@ -152,10 +152,7 @@ async def db_query(
 
     except DoesNotExist:
         # 记录不存在
-        if query_type == "get" and single_result:
-            return None
-        return []
-
+        return None if query_type == "get" and single_result else []
     except Exception as e:
         logger.error(f"[DatabaseAPI] 数据库操作出错: {e}")
         traceback.print_exc()
@@ -170,7 +167,8 @@ async def db_query(
 
 async def db_save(
     model_class: Type[Model], data: Dict[str, Any], key_field: Optional[str] = None, key_value: Optional[Any] = None
-) -> Union[Dict[str, Any], None]:
+) -> Optional[Dict[str, Any]]:
+    # sourcery skip: inline-immediately-returned-variable
     """保存数据到数据库（创建或更新）
 
     如果提供了key_field和key_value，会先尝试查找匹配的记录进行更新；
@@ -203,10 +201,9 @@ async def db_save(
     try:
         # 如果提供了key_field和key_value，尝试更新现有记录
         if key_field and key_value is not None:
-            # 查找现有记录
-            existing_records = list(model_class.select().where(getattr(model_class, key_field) == key_value).limit(1))
-
-            if existing_records:
+            if existing_records := list(
+                model_class.select().where(getattr(model_class, key_field) == key_value).limit(1)
+            ):
                 # 更新现有记录
                 existing_record = existing_records[0]
                 for field, value in data.items():
@@ -244,8 +241,8 @@ async def db_get(
     Args:
         model_class: Peewee模型类
         filters: 过滤条件，字段名和值的字典
-        order_by: 排序字段，前缀'-'表示降序，例如'-time'表示按时间字段（即time字段）降序
         limit: 结果数量限制
+        order_by: 排序字段，前缀'-'表示降序，例如'-time'表示按时间字段（即time字段）降序
         single_result: 是否只返回单个结果，如果为True，则返回单个记录字典或None；否则返回记录字典列表或空列表
 
     Returns:
@@ -310,7 +307,7 @@ async def store_action_info(
     thinking_id: str = "",
     action_data: Optional[dict] = None,
     action_name: str = "",
-) -> Union[Dict[str, Any], None]:
+) -> Optional[Dict[str, Any]]:
     """存储动作信息到数据库
 
     将Action执行的相关信息保存到ActionRecords表中，用于后续的记忆和上下文构建。

src/plugin_system/apis/emoji_api.py

@@ -65,14 +65,14 @@ async def get_by_description(description: str) -> Optional[Tuple[str, str, str]]
         return None
 
 
-async def get_random(count: Optional[int] = 1) -> Optional[List[Tuple[str, str, str]]]:
+async def get_random(count: Optional[int] = 1) -> List[Tuple[str, str, str]]:
     """随机获取指定数量的表情包
 
     Args:
         count: 要获取的表情包数量，默认为1
 
     Returns:
-        Optional[List[Tuple[str, str, str]]]: 包含(base64编码, 表情包描述, 随机情感标签)的元组列表，如果失败则为None
+        List[Tuple[str, str, str]]: 包含(base64编码, 表情包描述, 随机情感标签)的元组列表，失败则返回空列表
 
     Raises:
         TypeError: 如果count不是整数类型
@@ -94,13 +94,13 @@ async def get_random(count: Optional[int] = 1) -> Optional[List[Tuple[str, str,
 
         if not all_emojis:
             logger.warning("[EmojiAPI] 没有可用的表情包")
-            return None
+            return []
 
         # 过滤有效表情包
         valid_emojis = [emoji for emoji in all_emojis if not emoji.is_deleted]
         if not valid_emojis:
             logger.warning("[EmojiAPI] 没有有效的表情包")
-            return None
+            return []
 
         if len(valid_emojis) < count:
             logger.warning(
@@ -127,14 +127,14 @@ async def get_random(count: Optional[int] = 1) -> Optional[List[Tuple[str, str,
 
         if not results and count > 0:
             logger.warning("[EmojiAPI] 随机获取表情包失败，没有一个可以成功处理")
-            return None
+            return []
 
         logger.info(f"[EmojiAPI] 成功获取 {len(results)} 个随机表情包")
         return results
 
     except Exception as e:
         logger.error(f"[EmojiAPI] 获取随机表情包失败: {e}")
-        return None
+        return []
 
 
 async def get_by_emotion(emotion: str) -> Optional[Tuple[str, str, str]]:
@@ -162,10 +162,11 @@ async def get_by_emotion(emotion: str) -> Optional[Tuple[str, str, str]]:
 
         # 筛选匹配情感的表情包
         matching_emojis = []
-        for emoji_obj in all_emojis:
-            if not emoji_obj.is_deleted and emotion.lower() in [e.lower() for e in emoji_obj.emotion]:
-                matching_emojis.append(emoji_obj)
-
+        matching_emojis.extend(
+            emoji_obj
+            for emoji_obj in all_emojis
+            if not emoji_obj.is_deleted and emotion.lower() in [e.lower() for e in emoji_obj.emotion]
+        )
         if not matching_emojis:
             logger.warning(f"[EmojiAPI] 未找到匹配情感 '{emotion}' 的表情包")
             return None
@@ -256,10 +257,11 @@ def get_descriptions() -> List[str]:
         emoji_manager = get_emoji_manager()
         descriptions = []
 
-        for emoji_obj in emoji_manager.emoji_objects:
-            if not emoji_obj.is_deleted and emoji_obj.description:
-                descriptions.append(emoji_obj.description)
-
+        descriptions.extend(
+            emoji_obj.description
+            for emoji_obj in emoji_manager.emoji_objects
+            if not emoji_obj.is_deleted and emoji_obj.description
+        )
         return descriptions
     except Exception as e:
         logger.error(f"[EmojiAPI] 获取表情包描述失败: {e}")

src/plugin_system/apis/generator_api.py

@@ -84,18 +84,23 @@ async def generate_reply(
     enable_chinese_typo: bool = True,
     return_prompt: bool = False,
     model_configs: Optional[List[Dict[str, Any]]] = None,
-    request_type: str = "",
-    enable_timeout: bool = False,
+    request_type: str = "generator_api",
 ) -> Tuple[bool, List[Tuple[str, Any]], Optional[str]]:
     """生成回复
 
     Args:
         chat_stream: 聊天流对象（优先）
         chat_id: 聊天ID（备用）
-        action_data: 动作数据
+        action_data: 动作数据（向下兼容，包含reply_to和extra_info）
+        reply_to: 回复对象，格式为 "发送者:消息内容"
+        extra_info: 额外信息，用于补充上下文
+        available_actions: 可用动作
+        enable_tool: 是否启用工具调用
         enable_splitter: 是否启用消息分割器
         enable_chinese_typo: 是否启用错字生成器
         return_prompt: 是否返回提示词
+        model_configs: 模型配置列表
+        request_type: 请求类型（可选，记录LLM使用）
     Returns:
         Tuple[bool, List[Tuple[str, Any]], Optional[str]]: (是否成功, 回复集合, 提示词)
     """
@@ -107,7 +112,7 @@ async def generate_reply(
             return False, [], None
 
         logger.debug("[GeneratorAPI] 开始生成回复")
-        
+
         if not reply_to and action_data:
             reply_to = action_data.get("reply_to", "")
         if not extra_info and action_data:
@@ -118,7 +123,6 @@ async def generate_reply(
             reply_to=reply_to,
             extra_info=extra_info,
             available_actions=available_actions,
-            enable_timeout=enable_timeout,
             enable_tool=enable_tool,
         )
         reply_set = []
@@ -151,15 +155,24 @@ async def rewrite_reply(
     enable_splitter: bool = True,
     enable_chinese_typo: bool = True,
     model_configs: Optional[List[Dict[str, Any]]] = None,
-) -> Tuple[bool, List[Tuple[str, Any]]]:
+    raw_reply: str = "",
+    reason: str = "",
+    reply_to: str = "",
+    return_prompt: bool = False,
+) -> Tuple[bool, List[Tuple[str, Any]], Optional[str]]:
     """重写回复
 
     Args:
         chat_stream: 聊天流对象（优先）
-        reply_data: 回复数据
+        reply_data: 回复数据字典（向下兼容备用，当其他参数缺失时从此获取）
         chat_id: 聊天ID（备用）
         enable_splitter: 是否启用消息分割器
         enable_chinese_typo: 是否启用错字生成器
+        model_configs: 模型配置列表
+        raw_reply: 原始回复内容
+        reason: 回复原因
+        reply_to: 回复对象
+        return_prompt: 是否返回提示词
 
     Returns:
         Tuple[bool, List[Tuple[str, Any]]]: (是否成功, 回复集合)
@@ -169,12 +182,23 @@ async def rewrite_reply(
         replyer = get_replyer(chat_stream, chat_id, model_configs=model_configs)
         if not replyer:
             logger.error("[GeneratorAPI] 无法获取回复器")
-            return False, []
+            return False, [], None
 
         logger.info("[GeneratorAPI] 开始重写回复")
 
+        # 如果参数缺失，从reply_data中获取
+        if reply_data:
+            raw_reply = raw_reply or reply_data.get("raw_reply", "")
+            reason = reason or reply_data.get("reason", "")
+            reply_to = reply_to or reply_data.get("reply_to", "")
+
         # 调用回复器重写回复
-        success, content = await replyer.rewrite_reply_with_context(reply_data=reply_data or {})
+        success, content, prompt = await replyer.rewrite_reply_with_context(
+            raw_reply=raw_reply,
+            reason=reason,
+            reply_to=reply_to,
+            return_prompt=return_prompt,
+        )
         reply_set = []
         if content:
             reply_set = await process_human_text(content, enable_splitter, enable_chinese_typo)
@@ -184,14 +208,14 @@ async def rewrite_reply(
         else:
             logger.warning("[GeneratorAPI] 重写回复失败")
 
-        return success, reply_set
+        return success, reply_set, prompt if return_prompt else None
 
     except ValueError as ve:
         raise ve
 
     except Exception as e:
         logger.error(f"[GeneratorAPI] 重写回复时出错: {e}")
-        return False, []
+        return False, [], None
 
 
 async def process_human_text(content: str, enable_splitter: bool, enable_chinese_typo: bool) -> List[Tuple[str, Any]]:
@@ -217,3 +241,27 @@ async def process_human_text(content: str, enable_splitter: bool, enable_chinese
     except Exception as e:
         logger.error(f"[GeneratorAPI] 处理人形文本时出错: {e}")
         return []
+
+async def generate_response_custom(
+    chat_stream: Optional[ChatStream] = None,
+    chat_id: Optional[str] = None,
+    model_configs: Optional[List[Dict[str, Any]]] = None,
+    prompt: str = "",
+) -> Optional[str]:
+    replyer = get_replyer(chat_stream, chat_id, model_configs=model_configs)
+    if not replyer:
+        logger.error("[GeneratorAPI] 无法获取回复器")
+        return None
+
+    try:
+        logger.debug("[GeneratorAPI] 开始生成自定义回复")
+        response = await replyer.llm_generate_content(prompt)
+        if response:
+            logger.debug("[GeneratorAPI] 自定义回复生成成功")
+            return response
+        else:
+            logger.warning("[GeneratorAPI] 自定义回复生成失败")
+            return None
+    except Exception as e:
+        logger.error(f"[GeneratorAPI] 生成自定义回复时出错: {e}")
+        return None

src/plugin_system/apis/llm_api.py

@@ -54,7 +54,7 @@ def get_available_models() -> Dict[str, Any]:
 
 async def generate_with_model(
     prompt: str, model_config: Dict[str, Any], request_type: str = "plugin.generate", **kwargs
-) -> Tuple[bool, str, str, str]:
+) -> Tuple[bool, str]:
     """使用指定模型生成内容
 
     Args:
@@ -73,10 +73,11 @@ async def generate_with_model(
 
         llm_request = LLMRequest(model=model_config, request_type=request_type, **kwargs)
 
-        response, (reasoning, model_name) = await llm_request.generate_response_async(prompt)
-        return True, response, reasoning, model_name
+        # TODO: 复活这个_
+        response, _ = await llm_request.generate_response_async(prompt)
+        return True, response
 
     except Exception as e:
         error_msg = f"生成内容时出错: {str(e)}"
         logger.error(f"[LLMAPI] {error_msg}")
-        return False, error_msg, "", ""
+        return False, error_msg

src/plugin_system/apis/message_api.py

@@ -207,7 +207,7 @@ def get_random_chat_messages(
 
 
 def get_messages_by_time_for_users(
-    start_time: float, end_time: float, person_ids: list, limit: int = 0, limit_mode: str = "latest"
+    start_time: float, end_time: float, person_ids: List[str], limit: int = 0, limit_mode: str = "latest"
 ) -> List[Dict[str, Any]]:
     """
     获取指定用户在所有聊天中指定时间范围内的消息
@@ -287,7 +287,7 @@ def get_messages_before_time_in_chat(
     return get_raw_msg_before_timestamp_with_chat(chat_id, timestamp, limit)
 
 
-def get_messages_before_time_for_users(timestamp: float, person_ids: list, limit: int = 0) -> List[Dict[str, Any]]:
+def get_messages_before_time_for_users(timestamp: float, person_ids: List[str], limit: int = 0) -> List[Dict[str, Any]]:
     """
     获取指定用户在指定时间戳之前的消息
 
@@ -372,7 +372,7 @@ def count_new_messages(chat_id: str, start_time: float = 0.0, end_time: Optional
     return num_new_messages_since(chat_id, start_time, end_time)
 
 
-def count_new_messages_for_users(chat_id: str, start_time: float, end_time: float, person_ids: list) -> int:
+def count_new_messages_for_users(chat_id: str, start_time: float, end_time: float, person_ids: List[str]) -> int:
     """
     计算指定聊天中指定用户从开始时间到结束时间的新消息数量
 

src/plugin_system/apis/plugin_manage_api.py

@@ -1,10 +1,12 @@
 from typing import Tuple, List
+
+
 def list_loaded_plugins() -> List[str]:
     """
     列出所有当前加载的插件。
 
     Returns:
-        list: 当前加载的插件名称列表。
+        List[str]: 当前加载的插件名称列表。
     """
     from src.plugin_system.core.plugin_manager import plugin_manager
 
@@ -16,17 +18,38 @@ def list_registered_plugins() -> List[str]:
     列出所有已注册的插件。
 
     Returns:
-        list: 已注册的插件名称列表。
+        List[str]: 已注册的插件名称列表。
     """
     from src.plugin_system.core.plugin_manager import plugin_manager
 
     return plugin_manager.list_registered_plugins()
 
 
+def get_plugin_path(plugin_name: str) -> str:
+    """
+    获取指定插件的路径。
+
+    Args:
+        plugin_name (str): 插件名称。
+
+    Returns:
+        str: 插件目录的绝对路径。
+        
+    Raises:
+        ValueError: 如果插件不存在。
+    """
+    from src.plugin_system.core.plugin_manager import plugin_manager
+
+    if plugin_path := plugin_manager.get_plugin_path(plugin_name):
+        return plugin_path
+    else:
+        raise ValueError(f"插件 '{plugin_name}' 不存在。")
+
+
 async def remove_plugin(plugin_name: str) -> bool:
     """
     卸载指定的插件。
-    
+
     **此函数是异步的，确保在异步环境中调用。**
 
     Args:
@@ -43,7 +66,7 @@ async def remove_plugin(plugin_name: str) -> bool:
 async def reload_plugin(plugin_name: str) -> bool:
     """
     重新加载指定的插件。
-    
+
     **此函数是异步的，确保在异步环境中调用。**
 
     Args:
@@ -71,6 +94,7 @@ def load_plugin(plugin_name: str) -> Tuple[bool, int]:
 
     return plugin_manager.load_registered_plugin_classes(plugin_name)
 
+
 def add_plugin_directory(plugin_directory: str) -> bool:
     """
     添加插件目录。
@@ -84,6 +108,7 @@ def add_plugin_directory(plugin_directory: str) -> bool:
 
     return plugin_manager.add_plugin_directory(plugin_directory)
 
+
 def rescan_plugin_directory() -> Tuple[int, int]:
     """
     重新扫描插件目录，加载新插件。
@@ -92,4 +117,4 @@ def rescan_plugin_directory() -> Tuple[int, int]:
     """
     from src.plugin_system.core.plugin_manager import plugin_manager
 
-    return plugin_manager.rescan_plugin_directory()
+    return plugin_manager.rescan_plugin_directory()

src/plugin_system/apis/send_api.py

@@ -49,7 +49,7 @@ async def _send_to_target(
     display_message: str = "",
     typing: bool = False,
     reply_to: str = "",
-    reply_to_platform_id: str = "",
+    reply_to_platform_id: Optional[str] = None,
     storage_message: bool = True,
     show_log: bool = True,
 ) -> bool:
@@ -60,8 +60,11 @@ async def _send_to_target(
         content: 消息内容
         stream_id: 目标流ID
         display_message: 显示消息
-        typing: 是否显示正在输入
-        reply_to: 回复消息的格式，如"发送者:消息内容"
+        typing: 是否模拟打字等待。
+        reply_to: 回复消息，格式为"发送者:消息内容"
+        reply_to_platform_id: 回复消息，格式为"平台:用户ID"，如果不提供则自动查找（插件开发者禁用！）
+        storage_message: 是否存储消息到数据库
+        show_log: 发送是否显示日志
 
     Returns:
         bool: 是否发送成功
@@ -97,6 +100,10 @@ async def _send_to_target(
         anchor_message = None
         if reply_to:
             anchor_message = await _find_reply_message(target_stream, reply_to)
+            if anchor_message and anchor_message.message_info.user_info and not reply_to_platform_id:
+                reply_to_platform_id = (
+                    f"{anchor_message.message_info.platform}:{anchor_message.message_info.user_info.user_id}"
+                )
 
         # 构建发送消息对象
         bot_message = MessageSending(
@@ -262,12 +269,22 @@ async def text_to_stream(
         stream_id: 聊天流ID
         typing: 是否显示正在输入
         reply_to: 回复消息，格式为"发送者:消息内容"
+        reply_to_platform_id: 回复消息，格式为"平台:用户ID"，如果不提供则自动查找（插件开发者禁用！）
         storage_message: 是否存储消息到数据库
 
     Returns:
         bool: 是否发送成功
     """
-    return await _send_to_target("text", text, stream_id, "", typing, reply_to, reply_to_platform_id, storage_message)
+    return await _send_to_target(
+        "text",
+        text,
+        stream_id,
+        "",
+        typing,
+        reply_to,
+        reply_to_platform_id=reply_to_platform_id,
+        storage_message=storage_message,
+    )
 
 
 async def emoji_to_stream(emoji_base64: str, stream_id: str, storage_message: bool = True) -> bool:
@@ -350,249 +367,3 @@ async def custom_to_stream(
         storage_message=storage_message,
         show_log=show_log,
     )
-
-
-async def text_to_group(
-    text: str,
-    group_id: str,
-    platform: str = "qq",
-    typing: bool = False,
-    reply_to: str = "",
-    storage_message: bool = True,
-) -> bool:
-    """向群聊发送文本消息
-
-    Args:
-        text: 要发送的文本内容
-        group_id: 群聊ID
-        platform: 平台，默认为"qq"
-        typing: 是否显示正在输入
-        reply_to: 回复消息，格式为"发送者:消息内容"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, group_id, True)
-
-    return await _send_to_target("text", text, stream_id, "", typing, reply_to, storage_message=storage_message)
-
-
-async def text_to_user(
-    text: str,
-    user_id: str,
-    platform: str = "qq",
-    typing: bool = False,
-    reply_to: str = "",
-    storage_message: bool = True,
-) -> bool:
-    """向用户发送私聊文本消息
-
-    Args:
-        text: 要发送的文本内容
-        user_id: 用户ID
-        platform: 平台，默认为"qq"
-        typing: 是否显示正在输入
-        reply_to: 回复消息，格式为"发送者:消息内容"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, user_id, False)
-    return await _send_to_target("text", text, stream_id, "", typing, reply_to, storage_message=storage_message)
-
-
-async def emoji_to_group(emoji_base64: str, group_id: str, platform: str = "qq", storage_message: bool = True) -> bool:
-    """向群聊发送表情包
-
-    Args:
-        emoji_base64: 表情包的base64编码
-        group_id: 群聊ID
-        platform: 平台，默认为"qq"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, group_id, True)
-    return await _send_to_target("emoji", emoji_base64, stream_id, "", typing=False, storage_message=storage_message)
-
-
-async def emoji_to_user(emoji_base64: str, user_id: str, platform: str = "qq", storage_message: bool = True) -> bool:
-    """向用户发送表情包
-
-    Args:
-        emoji_base64: 表情包的base64编码
-        user_id: 用户ID
-        platform: 平台，默认为"qq"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, user_id, False)
-    return await _send_to_target("emoji", emoji_base64, stream_id, "", typing=False, storage_message=storage_message)
-
-
-async def image_to_group(image_base64: str, group_id: str, platform: str = "qq", storage_message: bool = True) -> bool:
-    """向群聊发送图片
-
-    Args:
-        image_base64: 图片的base64编码
-        group_id: 群聊ID
-        platform: 平台，默认为"qq"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, group_id, True)
-    return await _send_to_target("image", image_base64, stream_id, "", typing=False, storage_message=storage_message)
-
-
-async def image_to_user(image_base64: str, user_id: str, platform: str = "qq", storage_message: bool = True) -> bool:
-    """向用户发送图片
-
-    Args:
-        image_base64: 图片的base64编码
-        user_id: 用户ID
-        platform: 平台，默认为"qq"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, user_id, False)
-    return await _send_to_target("image", image_base64, stream_id, "", typing=False)
-
-
-async def command_to_group(command: str, group_id: str, platform: str = "qq", storage_message: bool = True) -> bool:
-    """向群聊发送命令
-
-    Args:
-        command: 命令
-        group_id: 群聊ID
-        platform: 平台，默认为"qq"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, group_id, True)
-    return await _send_to_target("command", command, stream_id, "", typing=False, storage_message=storage_message)
-
-
-async def command_to_user(command: str, user_id: str, platform: str = "qq", storage_message: bool = True) -> bool:
-    """向用户发送命令
-
-    Args:
-        command: 命令
-        user_id: 用户ID
-        platform: 平台，默认为"qq"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, user_id, False)
-    return await _send_to_target("command", command, stream_id, "", typing=False, storage_message=storage_message)
-
-
-# =============================================================================
-# 通用发送函数 - 支持任意消息类型
-# =============================================================================
-
-
-async def custom_to_group(
-    message_type: str,
-    content: str,
-    group_id: str,
-    platform: str = "qq",
-    display_message: str = "",
-    typing: bool = False,
-    reply_to: str = "",
-    storage_message: bool = True,
-) -> bool:
-    """向群聊发送自定义类型消息
-
-    Args:
-        message_type: 消息类型，如"text"、"image"、"emoji"、"video"、"file"等
-        content: 消息内容（通常是base64编码或文本）
-        group_id: 群聊ID
-        platform: 平台，默认为"qq"
-        display_message: 显示消息
-        typing: 是否显示正在输入
-        reply_to: 回复消息，格式为"发送者:消息内容"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, group_id, True)
-    return await _send_to_target(
-        message_type, content, stream_id, display_message, typing, reply_to, storage_message=storage_message
-    )
-
-
-async def custom_to_user(
-    message_type: str,
-    content: str,
-    user_id: str,
-    platform: str = "qq",
-    display_message: str = "",
-    typing: bool = False,
-    reply_to: str = "",
-    storage_message: bool = True,
-) -> bool:
-    """向用户发送自定义类型消息
-
-    Args:
-        message_type: 消息类型，如"text"、"image"、"emoji"、"video"、"file"等
-        content: 消息内容（通常是base64编码或文本）
-        user_id: 用户ID
-        platform: 平台，默认为"qq"
-        display_message: 显示消息
-        typing: 是否显示正在输入
-        reply_to: 回复消息，格式为"发送者:消息内容"
-
-    Returns:
-        bool: 是否发送成功
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, user_id, False)
-    return await _send_to_target(
-        message_type, content, stream_id, display_message, typing, reply_to, storage_message=storage_message
-    )
-
-
-async def custom_message(
-    message_type: str,
-    content: str,
-    target_id: str,
-    is_group: bool = True,
-    platform: str = "qq",
-    display_message: str = "",
-    typing: bool = False,
-    reply_to: str = "",
-    storage_message: bool = True,
-) -> bool:
-    """发送自定义消息的通用接口
-
-    Args:
-        message_type: 消息类型，如"text"、"image"、"emoji"、"video"、"file"、"audio"等
-        content: 消息内容
-        target_id: 目标ID（群ID或用户ID）
-        is_group: 是否为群聊，True为群聊，False为私聊
-        platform: 平台，默认为"qq"
-        display_message: 显示消息
-        typing: 是否显示正在输入
-        reply_to: 回复消息，格式为"发送者:消息内容"
-
-    Returns:
-        bool: 是否发送成功
-
-    示例:
-        # 发送视频到群聊
-        await send_api.custom_message("video", video_base64, "123456", True)
-
-        # 发送文件到用户
-        await send_api.custom_message("file", file_base64, "987654", False)
-
-        # 发送音频到群聊并回复特定消息
-        await send_api.custom_message("audio", audio_base64, "123456", True, reply_to="张三:你好")
-    """
-    stream_id = get_chat_manager().get_stream_id(platform, target_id, is_group)
-    return await _send_to_target(
-        message_type, content, stream_id, display_message, typing, reply_to, storage_message=storage_message
-    )

src/plugin_system/apis/utils_api.py

@@ -1,168 +0,0 @@
-"""工具类API模块
-
-提供了各种辅助功能
-使用方式：
-    from src.plugin_system.apis import utils_api
-    plugin_path = utils_api.get_plugin_path()
-    data = utils_api.read_json_file("data.json")
-    timestamp = utils_api.get_timestamp()
-"""
-
-import os
-import json
-import time
-import inspect
-import datetime
-import uuid
-from typing import Any, Optional
-from src.common.logger import get_logger
-
-logger = get_logger("utils_api")
-
-
-# =============================================================================
-# 文件操作API函数
-# =============================================================================
-
-
-def get_plugin_path(caller_frame=None) -> str:
-    """获取调用者插件的路径
-
-    Args:
-        caller_frame: 调用者的栈帧，默认为None（自动获取）
-
-    Returns:
-        str: 插件目录的绝对路径
-    """
-    try:
-        if caller_frame is None:
-            caller_frame = inspect.currentframe().f_back  # type: ignore
-
-        plugin_module_path = inspect.getfile(caller_frame)  # type: ignore
-        plugin_dir = os.path.dirname(plugin_module_path)
-        return plugin_dir
-    except Exception as e:
-        logger.error(f"[UtilsAPI] 获取插件路径失败: {e}")
-        return ""
-
-
-def read_json_file(file_path: str, default: Any = None) -> Any:
-    """读取JSON文件
-
-    Args:
-        file_path: 文件路径，可以是相对于插件目录的路径
-        default: 如果文件不存在或读取失败时返回的默认值
-
-    Returns:
-        Any: JSON数据或默认值
-    """
-    try:
-        # 如果是相对路径，则相对于调用者的插件目录
-        if not os.path.isabs(file_path):
-            caller_frame = inspect.currentframe().f_back  # type: ignore
-            plugin_dir = get_plugin_path(caller_frame)
-            file_path = os.path.join(plugin_dir, file_path)
-
-        if not os.path.exists(file_path):
-            logger.warning(f"[UtilsAPI] 文件不存在: {file_path}")
-            return default
-
-        with open(file_path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except Exception as e:
-        logger.error(f"[UtilsAPI] 读取JSON文件出错: {e}")
-        return default
-
-
-def write_json_file(file_path: str, data: Any, indent: int = 2) -> bool:
-    """写入JSON文件
-
-    Args:
-        file_path: 文件路径，可以是相对于插件目录的路径
-        data: 要写入的数据
-        indent: JSON缩进
-
-    Returns:
-        bool: 是否写入成功
-    """
-    try:
-        # 如果是相对路径，则相对于调用者的插件目录
-        if not os.path.isabs(file_path):
-            caller_frame = inspect.currentframe().f_back  # type: ignore
-            plugin_dir = get_plugin_path(caller_frame)
-            file_path = os.path.join(plugin_dir, file_path)
-
-        # 确保目录存在
-        os.makedirs(os.path.dirname(file_path), exist_ok=True)
-
-        with open(file_path, "w", encoding="utf-8") as f:
-            json.dump(data, f, ensure_ascii=False, indent=indent)
-        return True
-    except Exception as e:
-        logger.error(f"[UtilsAPI] 写入JSON文件出错: {e}")
-        return False
-
-
-# =============================================================================
-# 时间相关API函数
-# =============================================================================
-
-
-def get_timestamp() -> int:
-    """获取当前时间戳
-
-    Returns:
-        int: 当前时间戳（秒）
-    """
-    return int(time.time())
-
-
-def format_time(timestamp: Optional[int | float] = None, format_str: str = "%Y-%m-%d %H:%M:%S") -> str:
-    """格式化时间
-
-    Args:
-        timestamp: 时间戳，如果为None则使用当前时间
-        format_str: 时间格式字符串
-
-    Returns:
-        str: 格式化后的时间字符串
-    """
-    try:
-        if timestamp is None:
-            timestamp = time.time()
-        return datetime.datetime.fromtimestamp(timestamp).strftime(format_str)
-    except Exception as e:
-        logger.error(f"[UtilsAPI] 格式化时间失败: {e}")
-        return ""
-
-
-def parse_time(time_str: str, format_str: str = "%Y-%m-%d %H:%M:%S") -> int:
-    """解析时间字符串为时间戳
-
-    Args:
-        time_str: 时间字符串
-        format_str: 时间格式字符串
-
-    Returns:
-        int: 时间戳（秒）
-    """
-    try:
-        dt = datetime.datetime.strptime(time_str, format_str)
-        return int(dt.timestamp())
-    except Exception as e:
-        logger.error(f"[UtilsAPI] 解析时间失败: {e}")
-        return 0
-
-
-# =============================================================================
-# 其他工具函数
-# =============================================================================
-
-
-def generate_unique_id() -> str:
-    """生成唯一ID
-
-    Returns:
-        str: 唯一ID
-    """
-    return str(uuid.uuid4())

src/plugin_system/base/base_action.py

@@ -208,7 +208,7 @@ class BaseAction(ABC):
             return False, f"等待新消息失败: {str(e)}"
 
     async def send_text(
-        self, content: str, reply_to: str = "", reply_to_platform_id: str = "", typing: bool = False
+        self, content: str, reply_to: str = "", typing: bool = False
     ) -> bool:
         """发送文本消息
 
@@ -227,7 +227,6 @@ class BaseAction(ABC):
             text=content,
             stream_id=self.chat_id,
             reply_to=reply_to,
-            reply_to_platform_id=reply_to_platform_id,
             typing=typing,
         )
 

src/plugin_system/core/plugin_manager.py

@@ -224,6 +224,18 @@ class PluginManager:
             list: 已注册的插件类名称列表。
         """
         return list(self.plugin_classes.keys())
+    
+    def get_plugin_path(self, plugin_name: str) -> Optional[str]:
+        """
+        获取指定插件的路径。
+
+        Args:
+            plugin_name: 插件名称
+
+        Returns:
+            Optional[str]: 插件目录的绝对路径，如果插件不存在则返回None。
+        """
+        return self.plugin_paths.get(plugin_name)
 
     # === 私有方法 ===
     # == 目录管理 ==
@@ -289,6 +301,7 @@ class PluginManager:
                 return False
 
             module = module_from_spec(spec)
+            module.__package__ = module_name  # 设置模块包名
             spec.loader.exec_module(module)
 
             logger.debug(f"插件模块加载成功: {plugin_file}")

src/plugins/built_in/core_actions/emoji.py

@@ -120,7 +120,7 @@ class EmojiAction(BaseAction):
                     logger.error(f"{self.log_prefix} 未找到'utils_small'模型配置，无法调用LLM")
                     return False, "未找到'utils_small'模型配置"
 
-                success, chosen_emotion, _, _ = await llm_api.generate_with_model(
+                success, chosen_emotion = await llm_api.generate_with_model(
                     prompt, model_config=chat_model_config, request_type="emoji"
                 )
 

src/plugins/built_in/plugin_management/plugin.py

@@ -11,6 +11,7 @@ from src.plugin_system import (
     component_manage_api,
     ComponentInfo,
     ComponentType,
+    send_api,
 )
 
 
@@ -27,8 +28,15 @@ class ManagementCommand(BaseCommand):
             or not self.message.message_info.user_info
             or str(self.message.message_info.user_info.user_id) not in self.get_config("plugin.permission", [])  # type: ignore
         ):
-            await self.send_text("你没有权限使用插件管理命令")
+            await self._send_message("你没有权限使用插件管理命令")
             return False, "没有权限", True
+        if not self.message.chat_stream:
+            await self._send_message("无法获取聊天流信息")
+            return False, "无法获取聊天流信息", True
+        self.stream_id = self.message.chat_stream.stream_id
+        if not self.stream_id:
+            await self._send_message("无法获取聊天流信息")
+            return False, "无法获取聊天流信息", True
         command_list = self.matched_groups["manage_command"].strip().split(" ")
         if len(command_list) == 1:
             await self.show_help("all")
@@ -42,7 +50,7 @@ class ManagementCommand(BaseCommand):
                 case "help":
                     await self.show_help("all")
                 case _:
-                    await self.send_text("插件管理命令不合法")
+                    await self._send_message("插件管理命令不合法")
                     return False, "命令不合法", True
         if len(command_list) == 3:
             if command_list[1] == "plugin":
@@ -56,7 +64,7 @@ class ManagementCommand(BaseCommand):
                     case "rescan":
                         await self._rescan_plugin_dirs()
                     case _:
-                        await self.send_text("插件管理命令不合法")
+                        await self._send_message("插件管理命令不合法")
                         return False, "命令不合法", True
             elif command_list[1] == "component":
                 if command_list[2] == "list":
@@ -64,10 +72,10 @@ class ManagementCommand(BaseCommand):
                 elif command_list[2] == "help":
                     await self.show_help("component")
                 else:
-                    await self.send_text("插件管理命令不合法")
+                    await self._send_message("插件管理命令不合法")
                     return False, "命令不合法", True
             else:
-                await self.send_text("插件管理命令不合法")
+                await self._send_message("插件管理命令不合法")
                 return False, "命令不合法", True
         if len(command_list) == 4:
             if command_list[1] == "plugin":
@@ -81,28 +89,28 @@ class ManagementCommand(BaseCommand):
                     case "add_dir":
                         await self._add_dir(command_list[3])
                     case _:
-                        await self.send_text("插件管理命令不合法")
+                        await self._send_message("插件管理命令不合法")
                         return False, "命令不合法", True
             elif command_list[1] == "component":
                 if command_list[2] != "list":
-                    await self.send_text("插件管理命令不合法")
+                    await self._send_message("插件管理命令不合法")
                     return False, "命令不合法", True
                 if command_list[3] == "enabled":
                     await self._list_enabled_components()
                 elif command_list[3] == "disabled":
                     await self._list_disabled_components()
                 else:
-                    await self.send_text("插件管理命令不合法")
+                    await self._send_message("插件管理命令不合法")
                     return False, "命令不合法", True
             else:
-                await self.send_text("插件管理命令不合法")
+                await self._send_message("插件管理命令不合法")
                 return False, "命令不合法", True
         if len(command_list) == 5:
             if command_list[1] != "component":
-                await self.send_text("插件管理命令不合法")
+                await self._send_message("插件管理命令不合法")
                 return False, "命令不合法", True
             if command_list[2] != "list":
-                await self.send_text("插件管理命令不合法")
+                await self._send_message("插件管理命令不合法")
                 return False, "命令不合法", True
             if command_list[3] == "enabled":
                 await self._list_enabled_components(target_type=command_list[4])
@@ -111,11 +119,11 @@ class ManagementCommand(BaseCommand):
             elif command_list[3] == "type":
                 await self._list_registered_components_by_type(command_list[4])
             else:
-                await self.send_text("插件管理命令不合法")
+                await self._send_message("插件管理命令不合法")
                 return False, "命令不合法", True
         if len(command_list) == 6:
             if command_list[1] != "component":
-                await self.send_text("插件管理命令不合法")
+                await self._send_message("插件管理命令不合法")
                 return False, "命令不合法", True
             if command_list[2] == "enable":
                 if command_list[3] == "global":
@@ -123,7 +131,7 @@ class ManagementCommand(BaseCommand):
                 elif command_list[3] == "local":
                     await self._locally_enable_component(command_list[4], command_list[5])
                 else:
-                    await self.send_text("插件管理命令不合法")
+                    await self._send_message("插件管理命令不合法")
                     return False, "命令不合法", True
             elif command_list[2] == "disable":
                 if command_list[3] == "global":
@@ -131,10 +139,10 @@ class ManagementCommand(BaseCommand):
                 elif command_list[3] == "local":
                     await self._locally_disable_component(command_list[4], command_list[5])
                 else:
-                    await self.send_text("插件管理命令不合法")
+                    await self._send_message("插件管理命令不合法")
                     return False, "命令不合法", True
             else:
-                await self.send_text("插件管理命令不合法")
+                await self._send_message("插件管理命令不合法")
                 return False, "命令不合法", True
 
         return True, "命令执行完成", True
@@ -180,51 +188,51 @@ class ManagementCommand(BaseCommand):
                 )
             case _:
                 return
-        await self.send_text(help_msg)
+        await self._send_message(help_msg)
 
     async def _list_loaded_plugins(self):
         plugins = plugin_manage_api.list_loaded_plugins()
-        await self.send_text(f"已加载的插件: {', '.join(plugins)}")
+        await self._send_message(f"已加载的插件: {', '.join(plugins)}")
 
     async def _list_registered_plugins(self):
         plugins = plugin_manage_api.list_registered_plugins()
-        await self.send_text(f"已注册的插件: {', '.join(plugins)}")
+        await self._send_message(f"已注册的插件: {', '.join(plugins)}")
 
     async def _rescan_plugin_dirs(self):
         plugin_manage_api.rescan_plugin_directory()
-        await self.send_text("插件目录重新扫描执行中")
+        await self._send_message("插件目录重新扫描执行中")
 
     async def _load_plugin(self, plugin_name: str):
         success, count = plugin_manage_api.load_plugin(plugin_name)
         if success:
-            await self.send_text(f"插件加载成功: {plugin_name}")
+            await self._send_message(f"插件加载成功: {plugin_name}")
         else:
             if count == 0:
-                await self.send_text(f"插件{plugin_name}为禁用状态")
-            await self.send_text(f"插件加载失败: {plugin_name}")
+                await self._send_message(f"插件{plugin_name}为禁用状态")
+            await self._send_message(f"插件加载失败: {plugin_name}")
 
     async def _unload_plugin(self, plugin_name: str):
         success = await plugin_manage_api.remove_plugin(plugin_name)
         if success:
-            await self.send_text(f"插件卸载成功: {plugin_name}")
+            await self._send_message(f"插件卸载成功: {plugin_name}")
         else:
-            await self.send_text(f"插件卸载失败: {plugin_name}")
+            await self._send_message(f"插件卸载失败: {plugin_name}")
 
     async def _reload_plugin(self, plugin_name: str):
         success = await plugin_manage_api.reload_plugin(plugin_name)
         if success:
-            await self.send_text(f"插件重新加载成功: {plugin_name}")
+            await self._send_message(f"插件重新加载成功: {plugin_name}")
         else:
-            await self.send_text(f"插件重新加载失败: {plugin_name}")
+            await self._send_message(f"插件重新加载失败: {plugin_name}")
 
     async def _add_dir(self, dir_path: str):
-        await self.send_text(f"正在添加插件目录: {dir_path}")
+        await self._send_message(f"正在添加插件目录: {dir_path}")
         success = plugin_manage_api.add_plugin_directory(dir_path)
         await asyncio.sleep(0.5)  # 防止乱序发送
         if success:
-            await self.send_text(f"插件目录添加成功: {dir_path}")
+            await self._send_message(f"插件目录添加成功: {dir_path}")
         else:
-            await self.send_text(f"插件目录添加失败: {dir_path}")
+            await self._send_message(f"插件目录添加失败: {dir_path}")
 
     def _fetch_all_registered_components(self) -> List[ComponentInfo]:
         all_plugin_info = component_manage_api.get_all_plugin_info()
@@ -255,29 +263,29 @@ class ManagementCommand(BaseCommand):
     async def _list_all_registered_components(self):
         components_info = self._fetch_all_registered_components()
         if not components_info:
-            await self.send_text("没有注册的组件")
+            await self._send_message("没有注册的组件")
             return
 
         all_components_str = ", ".join(
             f"{component.name} ({component.component_type})" for component in components_info
         )
-        await self.send_text(f"已注册的组件: {all_components_str}")
+        await self._send_message(f"已注册的组件: {all_components_str}")
 
     async def _list_enabled_components(self, target_type: str = "global"):
         components_info = self._fetch_all_registered_components()
         if not components_info:
-            await self.send_text("没有注册的组件")
+            await self._send_message("没有注册的组件")
             return
 
         if target_type == "global":
             enabled_components = [component for component in components_info if component.enabled]
             if not enabled_components:
-                await self.send_text("没有满足条件的已启用全局组件")
+                await self._send_message("没有满足条件的已启用全局组件")
                 return
             enabled_components_str = ", ".join(
                 f"{component.name} ({component.component_type})" for component in enabled_components
             )
-            await self.send_text(f"满足条件的已启用全局组件: {enabled_components_str}")
+            await self._send_message(f"满足条件的已启用全局组件: {enabled_components_str}")
         elif target_type == "local":
             locally_disabled_components = self._fetch_locally_disabled_components()
             enabled_components = [
@@ -286,28 +294,28 @@ class ManagementCommand(BaseCommand):
                 if (component.name not in locally_disabled_components and component.enabled)
             ]
             if not enabled_components:
-                await self.send_text("本聊天没有满足条件的已启用组件")
+                await self._send_message("本聊天没有满足条件的已启用组件")
                 return
             enabled_components_str = ", ".join(
                 f"{component.name} ({component.component_type})" for component in enabled_components
             )
-            await self.send_text(f"本聊天满足条件的已启用组件: {enabled_components_str}")
+            await self._send_message(f"本聊天满足条件的已启用组件: {enabled_components_str}")
 
     async def _list_disabled_components(self, target_type: str = "global"):
         components_info = self._fetch_all_registered_components()
         if not components_info:
-            await self.send_text("没有注册的组件")
+            await self._send_message("没有注册的组件")
             return
 
         if target_type == "global":
             disabled_components = [component for component in components_info if not component.enabled]
             if not disabled_components:
-                await self.send_text("没有满足条件的已禁用全局组件")
+                await self._send_message("没有满足条件的已禁用全局组件")
                 return
             disabled_components_str = ", ".join(
                 f"{component.name} ({component.component_type})" for component in disabled_components
             )
-            await self.send_text(f"满足条件的已禁用全局组件: {disabled_components_str}")
+            await self._send_message(f"满足条件的已禁用全局组件: {disabled_components_str}")
         elif target_type == "local":
             locally_disabled_components = self._fetch_locally_disabled_components()
             disabled_components = [
@@ -316,12 +324,12 @@ class ManagementCommand(BaseCommand):
                 if (component.name in locally_disabled_components or not component.enabled)
             ]
             if not disabled_components:
-                await self.send_text("本聊天没有满足条件的已禁用组件")
+                await self._send_message("本聊天没有满足条件的已禁用组件")
                 return
             disabled_components_str = ", ".join(
                 f"{component.name} ({component.component_type})" for component in disabled_components
             )
-            await self.send_text(f"本聊天满足条件的已禁用组件: {disabled_components_str}")
+            await self._send_message(f"本聊天满足条件的已禁用组件: {disabled_components_str}")
 
     async def _list_registered_components_by_type(self, target_type: str):
         match target_type:
@@ -332,18 +340,18 @@ class ManagementCommand(BaseCommand):
             case "event_handler":
                 component_type = ComponentType.EVENT_HANDLER
             case _:
-                await self.send_text(f"未知组件类型: {target_type}")
+                await self._send_message(f"未知组件类型: {target_type}")
                 return
 
         components_info = component_manage_api.get_components_info_by_type(component_type)
         if not components_info:
-            await self.send_text(f"没有注册的 {target_type} 组件")
+            await self._send_message(f"没有注册的 {target_type} 组件")
             return
 
         components_str = ", ".join(
             f"{name} ({component.component_type})" for name, component in components_info.items()
         )
-        await self.send_text(f"注册的 {target_type} 组件: {components_str}")
+        await self._send_message(f"注册的 {target_type} 组件: {components_str}")
 
     async def _globally_enable_component(self, component_name: str, component_type: str):
         match component_type:
@@ -354,12 +362,12 @@ class ManagementCommand(BaseCommand):
             case "event_handler":
                 target_component_type = ComponentType.EVENT_HANDLER
             case _:
-                await self.send_text(f"未知组件类型: {component_type}")
+                await self._send_message(f"未知组件类型: {component_type}")
                 return
         if component_manage_api.globally_enable_component(component_name, target_component_type):
-            await self.send_text(f"全局启用组件成功: {component_name}")
+            await self._send_message(f"全局启用组件成功: {component_name}")
         else:
-            await self.send_text(f"全局启用组件失败: {component_name}")
+            await self._send_message(f"全局启用组件失败: {component_name}")
 
     async def _globally_disable_component(self, component_name: str, component_type: str):
         match component_type:
@@ -370,13 +378,13 @@ class ManagementCommand(BaseCommand):
             case "event_handler":
                 target_component_type = ComponentType.EVENT_HANDLER
             case _:
-                await self.send_text(f"未知组件类型: {component_type}")
+                await self._send_message(f"未知组件类型: {component_type}")
                 return
         success = await component_manage_api.globally_disable_component(component_name, target_component_type)
         if success:
-            await self.send_text(f"全局禁用组件成功: {component_name}")
+            await self._send_message(f"全局禁用组件成功: {component_name}")
         else:
-            await self.send_text(f"全局禁用组件失败: {component_name}")
+            await self._send_message(f"全局禁用组件失败: {component_name}")
 
     async def _locally_enable_component(self, component_name: str, component_type: str):
         match component_type:
@@ -387,16 +395,16 @@ class ManagementCommand(BaseCommand):
             case "event_handler":
                 target_component_type = ComponentType.EVENT_HANDLER
             case _:
-                await self.send_text(f"未知组件类型: {component_type}")
+                await self._send_message(f"未知组件类型: {component_type}")
                 return
         if component_manage_api.locally_enable_component(
             component_name,
             target_component_type,
             self.message.chat_stream.stream_id,
         ):
-            await self.send_text(f"本地启用组件成功: {component_name}")
+            await self._send_message(f"本地启用组件成功: {component_name}")
         else:
-            await self.send_text(f"本地启用组件失败: {component_name}")
+            await self._send_message(f"本地启用组件失败: {component_name}")
 
     async def _locally_disable_component(self, component_name: str, component_type: str):
         match component_type:
@@ -407,16 +415,19 @@ class ManagementCommand(BaseCommand):
             case "event_handler":
                 target_component_type = ComponentType.EVENT_HANDLER
             case _:
-                await self.send_text(f"未知组件类型: {component_type}")
+                await self._send_message(f"未知组件类型: {component_type}")
                 return
         if component_manage_api.locally_disable_component(
             component_name,
             target_component_type,
             self.message.chat_stream.stream_id,
         ):
-            await self.send_text(f"本地禁用组件成功: {component_name}")
+            await self._send_message(f"本地禁用组件成功: {component_name}")
         else:
-            await self.send_text(f"本地禁用组件失败: {component_name}")
+            await self._send_message(f"本地禁用组件失败: {component_name}")
+    
+    async def _send_message(self, message: str):
+        await send_api.text_to_stream(message, self.stream_id, typing=False, storage_message=False)
 
 
 @register_plugin
@@ -430,7 +441,9 @@ class PluginManagementPlugin(BasePlugin):
         "plugin": {
             "enabled": ConfigField(bool, default=False, description="是否启用插件"),
             "config_version": ConfigField(type=str, default="1.1.0", description="配置文件版本"),
-            "permission": ConfigField(list, default=[], description="有权限使用插件管理命令的用户列表，请填写字符串形式的用户ID"),
+            "permission": ConfigField(
+                list, default=[], description="有权限使用插件管理命令的用户列表，请填写字符串形式的用户ID"
+            ),
         },
     }