chore: format code and remove redundant blank lines

This commit applies automated code formatting across the project. The changes primarily involve removing unnecessary blank lines and ensuring consistent code style, improving readability and maintainability without altering functionality.

src/chat/chat_loop/cycle_processor.py

@@ -32,7 +32,7 @@ class CycleProcessor:
             context: HFC聊天上下文对象，包含聊天流、能量值等信息
             response_handler: 响应处理器，负责生成和发送回复
             cycle_tracker: 循环跟踪器，负责记录和管理每次思考循环的信息
-        """    
+        """
         self.context = context
         self.response_handler = response_handler
         self.cycle_tracker = cycle_tracker
@@ -57,12 +57,12 @@ class CycleProcessor:
 
             # 存储reply action信息
         person_info_manager = get_person_info_manager()
-        
+
         # 获取 platform，如果不存在则从 chat_stream 获取，如果还是 None 则使用默认值
         platform = action_message.get("chat_info_platform")
         if platform is None:
             platform = getattr(self.context.chat_stream, "platform", "unknown")
-        
+
         person_id = person_info_manager.get_person_id(
             platform,
             action_message.get("user_id", ""),
@@ -94,8 +94,8 @@ class CycleProcessor:
         }
 
         return loop_info, reply_text, cycle_timers
-    
-    async def observe(self,interest_value:float = 0.0) -> bool:
+
+    async def observe(self, interest_value: float = 0.0) -> bool:
         """
         观察和处理单次思考循环的核心方法
 
@@ -114,7 +114,7 @@ class CycleProcessor:
         """
         action_type = "no_action"
         reply_text = ""  # 初始化reply_text变量，避免UnboundLocalError
-        
+
         # 使用sigmoid函数将interest_value转换为概率
         # 当interest_value为0时，概率接近0（使用Focus模式）
         # 当interest_value很高时，概率接近1（使用Normal模式）
@@ -127,16 +127,24 @@ class CycleProcessor:
             k = 2.0  # 控制曲线陡峭程度
             x0 = 1.0  # 控制曲线中心点
             return 1.0 / (1.0 + math.exp(-k * (interest_val - x0)))
-        
-        normal_mode_probability = calculate_normal_mode_probability(interest_value) * 0.5 / global_config.chat.get_current_talk_frequency(self.context.stream_id)
-        
+
+        normal_mode_probability = (
+            calculate_normal_mode_probability(interest_value)
+            * 0.5
+            / global_config.chat.get_current_talk_frequency(self.context.stream_id)
+        )
+
         # 根据概率决定使用哪种模式
         if random.random() < normal_mode_probability:
             mode = ChatMode.NORMAL
-            logger.info(f"{self.log_prefix} 基于兴趣值 {interest_value:.2f}，概率 {normal_mode_probability:.2f}，选择Normal planner模式")
+            logger.info(
+                f"{self.log_prefix} 基于兴趣值 {interest_value:.2f}，概率 {normal_mode_probability:.2f}，选择Normal planner模式"
+            )
         else:
             mode = ChatMode.FOCUS
-            logger.info(f"{self.log_prefix} 基于兴趣值 {interest_value:.2f}，概率 {normal_mode_probability:.2f}，选择Focus planner模式")
+            logger.info(
+                f"{self.log_prefix} 基于兴趣值 {interest_value:.2f}，概率 {normal_mode_probability:.2f}，选择Focus planner模式"
+            )
 
         cycle_timers, thinking_id = self.cycle_tracker.start_cycle()
         logger.info(f"{self.log_prefix} 开始第{self.context.cycle_counter}次思考")
@@ -165,12 +173,14 @@ class CycleProcessor:
             from src.plugin_system.core.event_manager import event_manager
             from src.plugin_system import EventType
 
-            result = await event_manager.trigger_event(EventType.ON_PLAN,plugin_name="SYSTEM", stream_id=self.context.chat_stream)
+            result = await event_manager.trigger_event(
+                EventType.ON_PLAN, plugin_name="SYSTEM", stream_id=self.context.chat_stream
+            )
             if not result.all_continue_process():
                 raise UserWarning(f"插件{result.get_summary().get('stopped_handlers', '')}于规划前中断了内容生成")
-            
+
             with Timer("规划器", cycle_timers):
-                actions, _= await self.action_planner.plan(
+                actions, _ = await self.action_planner.plan(
                     mode=mode,
                     loop_start_time=loop_start_time,
                     available_actions=available_actions,
@@ -183,7 +193,7 @@ class CycleProcessor:
                     # 直接处理no_reply逻辑，不再通过动作系统
                     reason = action_info.get("reasoning", "选择不回复")
                     logger.info(f"{self.log_prefix} 选择不回复，原因: {reason}")
-                    
+
                     # 存储no_reply信息到数据库
                     await database_api.store_action_info(
                         chat_stream=self.context.chat_stream,
@@ -194,13 +204,8 @@ class CycleProcessor:
                         action_data={"reason": reason},
                         action_name="no_reply",
                     )
-                    
-                    return {
-                        "action_type": "no_reply",
-                        "success": True,
-                        "reply_text": "",
-                        "command": ""
-                    }
+
+                    return {"action_type": "no_reply", "success": True, "reply_text": "", "command": ""}
                 elif action_info["action_type"] != "reply":
                     # 执行普通动作
                     with Timer("动作执行", cycle_timers):
@@ -210,40 +215,32 @@ class CycleProcessor:
                             action_info["action_data"],
                             cycle_timers,
                             thinking_id,
-                            action_info["action_message"]
+                            action_info["action_message"],
                         )
                     return {
                         "action_type": action_info["action_type"],
                         "success": success,
                         "reply_text": reply_text,
-                        "command": command
+                        "command": command,
                     }
                 else:
                     try:
                         success, response_set, _ = await generator_api.generate_reply(
                             chat_stream=self.context.chat_stream,
-                            reply_message = action_info["action_message"],
+                            reply_message=action_info["action_message"],
                             available_actions=available_actions,
                             enable_tool=global_config.tool.enable_tool,
                             request_type="chat.replyer",
                             from_plugin=False,
-                        )     
+                        )
                         if not success or not response_set:
-                            logger.info(f"对 {action_info['action_message'].get('processed_plain_text')} 的回复生成失败")
-                            return {
-                                "action_type": "reply",
-                                "success": False,
-                                "reply_text": "",
-                                "loop_info": None
-                            }
+                            logger.info(
+                                f"对 {action_info['action_message'].get('processed_plain_text')} 的回复生成失败"
+                            )
+                            return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None}
                     except asyncio.CancelledError:
                         logger.debug(f"{self.log_prefix} 并行执行：回复生成任务已被取消")
-                        return {
-                            "action_type": "reply",
-                            "success": False,
-                            "reply_text": "",
-                            "loop_info": None
-                        }
+                        return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None}
 
                     loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(
                         response_set,
@@ -253,12 +250,7 @@ class CycleProcessor:
                         thinking_id,
                         actions,
                     )
-                    return {
-                        "action_type": "reply",
-                        "success": True,
-                        "reply_text": reply_text,
-                        "loop_info": loop_info
-                    }
+                    return {"action_type": "reply", "success": True, "reply_text": reply_text, "loop_info": loop_info}
             except Exception as e:
                 logger.error(f"{self.log_prefix} 执行动作时出错: {e}")
                 logger.error(f"{self.log_prefix} 错误信息: {traceback.format_exc()}")
@@ -267,9 +259,9 @@ class CycleProcessor:
                     "success": False,
                     "reply_text": "",
                     "loop_info": None,
-                    "error": str(e)
+                    "error": str(e),
                 }
-            
+
         # 创建所有动作的后台任务
         action_tasks = [asyncio.create_task(execute_action(action)) for action in actions]
 
@@ -282,12 +274,12 @@ class CycleProcessor:
         action_success = False
         action_reply_text = ""
         action_command = ""
-        
+
         for i, result in enumerate(results):
             if isinstance(result, BaseException):
                 logger.error(f"{self.log_prefix} 动作执行异常: {result}")
                 continue
-            
+
             action_info = actions[i]
             if result["action_type"] != "reply":
                 action_success = result["success"]
@@ -327,7 +319,7 @@ class CycleProcessor:
                 },
             }
             reply_text = action_reply_text
-        
+
         if ENABLE_S4U:
             await stop_typing()
 
@@ -342,7 +334,7 @@ class CycleProcessor:
             self.context.no_reply_consecutive = 0
             logger.debug(f"{self.log_prefix} 执行了{action_type}动作，重置no_reply计数器")
             return True
-            
+
         if action_type == "no_reply":
             self.context.no_reply_consecutive += 1
             self.context.chat_instance._determine_form_type()

src/chat/chat_loop/cycle_tracker.py

@@ -91,25 +91,24 @@ class CycleTracker:
 
         # 获取动作类型，兼容新旧格式
         action_type = "未知动作"
-        if hasattr(self, '_current_cycle_detail') and self._current_cycle_detail:
+        if hasattr(self, "_current_cycle_detail") and self._current_cycle_detail:
             loop_plan_info = self._current_cycle_detail.loop_plan_info
             if isinstance(loop_plan_info, dict):
-                action_result = loop_plan_info.get('action_result', {})
+                action_result = loop_plan_info.get("action_result", {})
                 if isinstance(action_result, dict):
                     # 旧格式：action_result是字典
-                    action_type = action_result.get('action_type', '未知动作')
+                    action_type = action_result.get("action_type", "未知动作")
                 elif isinstance(action_result, list) and action_result:
                     # 新格式：action_result是actions列表
-                    action_type = action_result[0].get('action_type', '未知动作')
+                    action_type = action_result[0].get("action_type", "未知动作")
             elif isinstance(loop_plan_info, list) and loop_plan_info:
                 # 直接是actions列表的情况
-                action_type = loop_plan_info[0].get('action_type', '未知动作')
+                action_type = loop_plan_info[0].get("action_type", "未知动作")
 
         if self.context.current_cycle_detail.end_time and self.context.current_cycle_detail.start_time:
             duration = self.context.current_cycle_detail.end_time - self.context.current_cycle_detail.start_time
             logger.info(
                 f"{self.context.log_prefix} 第{self.context.current_cycle_detail.cycle_id}次思考,"
                 f"耗时: {duration:.1f}秒, "
-                f"选择动作: {action_type}"
-                + (f"\n详情: {'; '.join(timer_strings)}" if timer_strings else "")
+                f"选择动作: {action_type}" + (f"\n详情: {'; '.join(timer_strings)}" if timer_strings else "")
             )

src/chat/chat_loop/heartFC_chat.py

@@ -56,7 +56,7 @@ class HeartFChatting:
 
         self._loop_task: Optional[asyncio.Task] = None
         self._proactive_monitor_task: Optional[asyncio.Task] = None
-        
+
         # 记录最近3次的兴趣度
         self.recent_interest_records: deque = deque(maxlen=3)
         self._initialize_chat_mode()
@@ -183,7 +183,7 @@ class HeartFChatting:
                     event = ProactiveTriggerEvent(
                         source="silence_monitor",
                         reason=f"聊天已沉默 {formatted_time}",
-                        metadata={"silence_duration": silence_duration}
+                        metadata={"silence_duration": silence_duration},
                     )
                     await self.proactive_thinker.think(event)
                     self.context.last_message_time = current_time
@@ -205,21 +205,30 @@ class HeartFChatting:
         stream_parts = self.context.stream_id.split(":")
         current_chat_identifier = f"{stream_parts}:{stream_parts}" if len(stream_parts) >= 2 else self.context.stream_id
 
-        enable_list = getattr(global_config.chat, "proactive_thinking_enable_in_groups" if is_group_chat else "proactive_thinking_enable_in_private", [])
+        enable_list = getattr(
+            global_config.chat,
+            "proactive_thinking_enable_in_groups" if is_group_chat else "proactive_thinking_enable_in_private",
+            [],
+        )
         return not enable_list or current_chat_identifier in enable_list
 
     def _get_dynamic_thinking_interval(self) -> float:
         try:
             from src.utils.timing_utils import get_normal_distributed_interval
+
             base_interval = global_config.chat.proactive_thinking_interval
             delta_sigma = getattr(global_config.chat, "delta_sigma", 120)
 
-            if base_interval <= 0: base_interval = abs(base_interval)
-            if delta_sigma < 0: delta_sigma = abs(delta_sigma)
+            if base_interval <= 0:
+                base_interval = abs(base_interval)
+            if delta_sigma < 0:
+                delta_sigma = abs(delta_sigma)
+
+            if base_interval == 0 and delta_sigma == 0:
+                return 300
+            if delta_sigma == 0:
+                return base_interval
 
-            if base_interval == 0 and delta_sigma == 0: return 300
-            if delta_sigma == 0: return base_interval
-            
             sigma_percentage = delta_sigma / base_interval if base_interval > 0 else delta_sigma / 1000
             return get_normal_distributed_interval(base_interval, sigma_percentage, 1, 86400, use_3sigma_rule=True)
 
@@ -335,29 +344,30 @@ class HeartFChatting:
 
             # 根据聊天模式处理新消息
             # 统一使用 _should_process_messages 判断是否应该处理
-            should_process,interest_value = await self._should_process_messages(recent_messages)
+            should_process, interest_value = await self._should_process_messages(recent_messages)
             if should_process:
                 self.context.last_read_time = time.time()
-                await self.cycle_processor.observe(interest_value = interest_value)
+                await self.cycle_processor.observe(interest_value=interest_value)
             else:
                 # Normal模式：消息数量不足，等待
                 await asyncio.sleep(0.5)
                 return True
-        
+
             if not await self._should_process_messages(recent_messages):
                 return has_new_messages
-                
+
             # 处理新消息
             for message in recent_messages:
-                await self.cycle_processor.observe(interest_value = interest_value)
-                    
+                await self.cycle_processor.observe(interest_value=interest_value)
+
             # 如果成功观察，增加能量值并重置累积兴趣值
             if has_new_messages:
                 self.context.energy_value += 1 / global_config.chat.focus_value
                 # 重置累积兴趣值，因为消息已经被成功处理
                 self.context.breaking_accumulated_interest = 0.0
-                logger.info(f"{self.context.log_prefix} 能量值增加，当前能量值：{self.context.energy_value:.1f}，重置累积兴趣值")
-                  
+                logger.info(
+                    f"{self.context.log_prefix} 能量值增加，当前能量值：{self.context.energy_value:.1f}，重置累积兴趣值"
+                )
 
         # 更新上一帧的睡眠状态
         self.context.was_sleeping = is_sleeping
@@ -378,7 +388,6 @@ class HeartFChatting:
 
         return has_new_messages
 
-
     def _handle_wakeup_messages(self, messages):
         """
         处理休眠状态下的消息，累积唤醒度
@@ -421,7 +430,7 @@ class HeartFChatting:
             logger.info(f"{self.context.log_prefix} breaking模式已禁用，使用waiting形式")
             self.context.focus_energy = 1
             return "waiting"
-            
+
         # 如果连续no_reply次数少于3次，使用waiting形式
         if self.context.no_reply_consecutive <= 3:
             self.context.focus_energy = 1
@@ -429,12 +438,14 @@ class HeartFChatting:
         else:
             # 使用累积兴趣值而不是最近3次的记录
             total_interest = self.context.breaking_accumulated_interest
-          
+
             # 计算调整后的阈值
             adjusted_threshold = 1 / global_config.chat.get_current_talk_frequency(self.context.stream_id)
-            
-            logger.info(f"{self.context.log_prefix} 累积兴趣值: {total_interest:.2f}, 调整后阈值: {adjusted_threshold:.2f}")
-        
+
+            logger.info(
+                f"{self.context.log_prefix} 累积兴趣值: {total_interest:.2f}, 调整后阈值: {adjusted_threshold:.2f}"
+            )
+
             # 如果累积兴趣值小于阈值，进入breaking形式
             if total_interest < adjusted_threshold:
                 logger.info(f"{self.context.log_prefix} 累积兴趣度不足，进入breaking形式")
@@ -445,7 +456,7 @@ class HeartFChatting:
                 self.context.focus_energy = 1
                 return "waiting"
 
-    async def _should_process_messages(self, new_message: List[Dict[str, Any]]) -> tuple[bool,float]:
+    async def _should_process_messages(self, new_message: List[Dict[str, Any]]) -> tuple[bool, float]:
         """
         统一判断是否应该处理消息的函数
         根据当前循环模式和消息内容决定是否继续处理
@@ -459,37 +470,39 @@ class HeartFChatting:
 
         modified_exit_count_threshold = self.context.focus_energy * 0.5 / talk_frequency
         modified_exit_interest_threshold = 1.5 / talk_frequency
-        
+
         # 计算当前批次消息的兴趣值
         batch_interest = 0.0
         for msg_dict in new_message:
             interest_value = msg_dict.get("interest_value", 0.0)
             if msg_dict.get("processed_plain_text", ""):
                 batch_interest += interest_value
-        
+
         # 在breaking形式下累积所有消息的兴趣值
         if new_message_count > 0:
             self.context.breaking_accumulated_interest += batch_interest
             total_interest = self.context.breaking_accumulated_interest
         else:
             total_interest = self.context.breaking_accumulated_interest
-        
+
         if new_message_count >= modified_exit_count_threshold:
             # 记录兴趣度到列表
             self.recent_interest_records.append(total_interest)
             # 重置累积兴趣值，因为已经达到了消息数量阈值
             self.context.breaking_accumulated_interest = 0.0
-            
+
             logger.info(
                 f"{self.context.log_prefix} 累计消息数量达到{new_message_count}条(>{modified_exit_count_threshold:.1f})，结束等待，累积兴趣值: {total_interest:.2f}"
             )
-            return True,total_interest/new_message_count
+            return True, total_interest / new_message_count
 
         # 检查累计兴趣值
         if new_message_count > 0:
             # 只在兴趣值变化时输出log
             if not hasattr(self, "_last_accumulated_interest") or total_interest != self._last_accumulated_interest:
-                logger.info(f"{self.context.log_prefix} breaking形式当前累积兴趣值: {total_interest:.2f}, 专注度: {global_config.chat.focus_value:.1f}")
+                logger.info(
+                    f"{self.context.log_prefix} breaking形式当前累积兴趣值: {total_interest:.2f}, 专注度: {global_config.chat.focus_value:.1f}"
+                )
                 self._last_accumulated_interest = total_interest
             if total_interest >= modified_exit_interest_threshold:
                 # 记录兴趣度到列表
@@ -499,13 +512,16 @@ class HeartFChatting:
                 logger.info(
                     f"{self.context.log_prefix} 累计兴趣值达到{total_interest:.2f}(>{modified_exit_interest_threshold:.1f})，结束等待"
                 )
-                return True,total_interest/new_message_count
-            
+                return True, total_interest / new_message_count
+
         # 每10秒输出一次等待状态
-        if int(time.time() - self.context.last_read_time) > 0 and int(time.time() - self.context.last_read_time) % 10 == 0:
+        if (
+            int(time.time() - self.context.last_read_time) > 0
+            and int(time.time() - self.context.last_read_time) % 10 == 0
+        ):
             logger.info(
                 f"{self.context.log_prefix} 已等待{time.time() - self.context.last_read_time:.0f}秒，累计{new_message_count}条消息，累积兴趣{total_interest:.1f}，继续等待..."
             )
             await asyncio.sleep(0.5)
-        
-        return False,0.0
+
+        return False, 0.0

src/chat/chat_loop/hfc_context.py

@@ -44,13 +44,13 @@ class HfcContext:
 
         self.energy_value = self.chat_stream.energy_value
         self.sleep_pressure = self.chat_stream.sleep_pressure
-        self.was_sleeping = False # 用于检测睡眠状态的切换
-        
+        self.was_sleeping = False  # 用于检测睡眠状态的切换
+
         self.last_message_time = time.time()
         self.last_read_time = time.time() - 10
-        
+
         # 从聊天流恢复breaking累积兴趣值
-        self.breaking_accumulated_interest = getattr(self.chat_stream, 'breaking_accumulated_interest', 0.0)
+        self.breaking_accumulated_interest = getattr(self.chat_stream, "breaking_accumulated_interest", 0.0)
 
         self.action_manager = ActionManager()
 
@@ -79,4 +79,4 @@ class HfcContext:
             self.chat_stream.sleep_pressure = self.sleep_pressure
             self.chat_stream.focus_energy = self.focus_energy
             self.chat_stream.no_reply_consecutive = self.no_reply_consecutive
-            self.chat_stream.breaking_accumulated_interest = self.breaking_accumulated_interest
+            self.chat_stream.breaking_accumulated_interest = self.breaking_accumulated_interest

src/chat/chat_loop/hfc_utils.py

@@ -122,6 +122,7 @@ class CycleDetail:
         self.loop_plan_info = loop_info["loop_plan_info"]
         self.loop_action_info = loop_info["loop_action_info"]
 
+
 async def send_typing():
     """
     发送打字状态指示

src/chat/chat_loop/proactive/events.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass, field
 from typing import Optional, Dict, Any
 
+
 @dataclass
 class ProactiveTriggerEvent:
     """
     主动思考触发事件的数据类
     """
+
     source: str  # 触发源的标识，例如 "silence_monitor", "insomnia_manager"
     reason: str  # 触发的具体原因，例如 "聊天已沉默10分钟", "深夜emo"
-    metadata: Optional[Dict[str, Any]] = field(default_factory=dict)  # 可选的元数据，用于传递额外信息
+    metadata: Optional[Dict[str, Any]] = field(default_factory=dict)  # 可选的元数据，用于传递额外信息

src/chat/chat_loop/proactive/proactive_thinker.py

@@ -37,8 +37,10 @@ class ProactiveThinker:
         Args:
             trigger_event: 描述触发上下文的事件对象
         """
-        logger.info(f"{self.context.log_prefix} 接收到主动思考事件: "
-                    f"来源='{trigger_event.source}', 原因='{trigger_event.reason}'")
+        logger.info(
+            f"{self.context.log_prefix} 接收到主动思考事件: "
+            f"来源='{trigger_event.source}', 原因='{trigger_event.reason}'"
+        )
 
         try:
             # 1. 根据事件类型执行前置操作
@@ -63,6 +65,7 @@ class ProactiveThinker:
 
         try:
             from src.mood.mood_manager import mood_manager
+
             mood_obj = mood_manager.get_mood_by_chat_id(self.context.stream_id)
             new_mood = None
 
@@ -76,8 +79,10 @@ class ProactiveThinker:
             if new_mood:
                 mood_obj.mood_state = new_mood
                 mood_obj.last_change_time = time.time()
-                logger.info(f"{self.context.log_prefix} 因 '{trigger_event.reason}'，"
-                            f"情绪状态被强制更新为: {mood_obj.mood_state}")
+                logger.info(
+                    f"{self.context.log_prefix} 因 '{trigger_event.reason}'，"
+                    f"情绪状态被强制更新为: {mood_obj.mood_state}"
+                )
 
         except Exception as e:
             logger.error(f"{self.context.log_prefix} 设置失眠情绪时出错: {e}")
@@ -91,19 +96,17 @@ class ProactiveThinker:
         """
         try:
             # 直接调用 planner 的 PROACTIVE 模式
-            actions, target_message = await self.cycle_processor.action_planner.plan(
-                mode=ChatMode.PROACTIVE
-            )
-            
+            actions, target_message = await self.cycle_processor.action_planner.plan(mode=ChatMode.PROACTIVE)
+
             # 获取第一个规划出的动作作为主要决策
             action_result = actions[0] if actions else {}
 
             # 如果决策不是 do_nothing，则执行
             if action_result and action_result.get("action_type") != "do_nothing":
-
                 # 在主动思考时，如果 target_message 为 None，则默认选取最新 message 作为 target_message
                 if target_message is None and self.context.chat_stream and self.context.chat_stream.context:
                     from src.chat.message_receive.message import MessageRecv
+
                     latest_message = self.context.chat_stream.context.get_last_message()
                     if isinstance(latest_message, MessageRecv):
                         user_info = latest_message.message_info.user_info

src/chat/chat_loop/response_handler.py

@@ -157,7 +157,7 @@ class ResponseHandler:
                 await send_api.text_to_stream(
                     text=data,
                     stream_id=self.context.stream_id,
-                    reply_to_message = message_data,
+                    reply_to_message=message_data,
                     set_reply=need_reply,
                     typing=False,
                 )

src/chat/emoji_system/emoji_manager.py

@@ -724,7 +724,7 @@ class EmojiManager:
             if not emoji.is_deleted and emoji.hash == emoji_hash:
                 return emoji
         return None  # 如果循环结束还没找到，则返回 None
-    
+
     async def get_emoji_tag_by_hash(self, emoji_hash: str) -> Optional[str]:
         """根据哈希值获取已注册表情包的描述
 
@@ -755,7 +755,7 @@ class EmojiManager:
         except Exception as e:
             logger.error(f"获取表情包描述失败 (Hash: {emoji_hash}): {str(e)}")
             return None
-        
+
     async def get_emoji_description_by_hash(self, emoji_hash: str) -> Optional[str]:
         """根据哈希值获取已注册表情包的描述
 

src/chat/message_receive/chat_stream.py

@@ -259,7 +259,7 @@ class ChatManager:
                     "user_cardname": model_instance.user_cardname or "",
                 }
                 group_info_data = None
-                if model_instance and getattr(model_instance, 'group_id', None):
+                if model_instance and getattr(model_instance, "group_id", None):
                     group_info_data = {
                         "platform": model_instance.group_platform,
                         "group_id": model_instance.group_id,
@@ -405,7 +405,7 @@ class ChatManager:
                         "user_cardname": model_instance.user_cardname or "",
                     }
                     group_info_data = None
-                    if model_instance and getattr(model_instance, 'group_id', None):
+                    if model_instance and getattr(model_instance, "group_id", None):
                         group_info_data = {
                             "platform": model_instance.group_platform,
                             "group_id": model_instance.group_id,

src/chat/message_receive/message.py

@@ -120,7 +120,7 @@ class MessageRecv(Message):
         self.priority_mode = "interest"
         self.priority_info = None
         self.interest_value: float = 0.0
-        
+
         self.key_words = []
         self.key_words_lite = []
 

src/chat/message_receive/storage.py

@@ -21,7 +21,7 @@ class MessageStorage:
         if isinstance(keywords, list):
             return orjson.dumps(keywords).decode("utf-8")
         return "[]"
-    
+
     @staticmethod
     def _deserialize_keywords(keywords_str: str) -> list:
         """将JSON字符串反序列化为关键词列表"""

src/chat/planner_actions/action_modifier.py

@@ -161,10 +161,8 @@ class ActionModifier:
 
         available_actions = list(self.action_manager.get_using_actions().keys())
         available_actions_text = "、".join(available_actions) if available_actions else "无"
-        
-        logger.info(
-            f"{self.log_prefix} 当前可用动作: {available_actions_text}||移除: {removals_summary}"
-        )
+
+        logger.info(f"{self.log_prefix} 当前可用动作: {available_actions_text}||移除: {removals_summary}")
 
     def _check_action_associated_types(self, all_actions: Dict[str, ActionInfo], chat_context: ChatMessageContext):
         type_mismatched_actions: List[Tuple[str, str]] = []

src/chat/planner_actions/planner.py

@@ -188,15 +188,12 @@ class ActionPlanner:
             param_text = ""
             if action_info.action_parameters:
                 param_text = "\n" + "\n".join(
-                    f'    "{p_name}":"{p_desc}"'
-                    for p_name, p_desc in action_info.action_parameters.items()
+                    f'    "{p_name}":"{p_desc}"' for p_name, p_desc in action_info.action_parameters.items()
                 )
 
             require_text = "\n".join(f"- {req}" for req in action_info.action_require)
 
-            using_action_prompt = await global_prompt_manager.get_prompt_async(
-                "action_prompt"
-            )
+            using_action_prompt = await global_prompt_manager.get_prompt_async("action_prompt")
             action_options_block += using_action_prompt.format(
                 action_name=action_name,
                 action_description=action_info.description,
@@ -205,9 +202,7 @@ class ActionPlanner:
             )
         return action_options_block
 
-    def find_message_by_id(
-        self, message_id: str, message_id_list: list
-    ) -> Optional[Dict[str, Any]]:
+    def find_message_by_id(self, message_id: str, message_id_list: list) -> Optional[Dict[str, Any]]:
         # sourcery skip: use-next
         """
         根据message_id从message_id_list中查找对应的原始消息
@@ -245,7 +240,7 @@ class ActionPlanner:
     async def plan(
         self,
         mode: ChatMode = ChatMode.FOCUS,
-        loop_start_time:float = 0.0,
+        loop_start_time: float = 0.0,
         available_actions: Optional[Dict[str, ActionInfo]] = None,
     ) -> Tuple[List[Dict[str, Any]], Optional[Dict[str, Any]]]:
         """
@@ -324,11 +319,15 @@ class ActionPlanner:
                             # 如果获取的target_message为None，输出warning并重新plan
                             if target_message is None:
                                 self.plan_retry_count += 1
-                                logger.warning(f"{self.log_prefix}无法找到target_message_id '{target_message_id}' 对应的消息，重试次数: {self.plan_retry_count}/{self.max_plan_retries}")
-                                
+                                logger.warning(
+                                    f"{self.log_prefix}无法找到target_message_id '{target_message_id}' 对应的消息，重试次数: {self.plan_retry_count}/{self.max_plan_retries}"
+                                )
+
                                 # 如果连续三次plan均为None，输出error并选取最新消息
                                 if self.plan_retry_count >= self.max_plan_retries:
-                                    logger.error(f"{self.log_prefix}连续{self.max_plan_retries}次plan获取target_message失败，选择最新消息作为target_message")
+                                    logger.error(
+                                        f"{self.log_prefix}连续{self.max_plan_retries}次plan获取target_message失败，选择最新消息作为target_message"
+                                    )
                                     target_message = self.get_latest_message(message_id_list)
                                     self.plan_retry_count = 0  # 重置计数器
                                 else:
@@ -339,8 +338,7 @@ class ActionPlanner:
                                 self.plan_retry_count = 0
                         else:
                             logger.warning(f"{self.log_prefix}动作'{action}'缺少target_message_id")
-                    
-                    
+
                     if action != "no_reply" and action != "reply" and action not in current_available_actions:
                         logger.warning(
                             f"{self.log_prefix}LLM 返回了当前不可用或无效的动作: '{action}' (可用: {list(current_available_actions.keys())})，将强制使用 'no_reply'"
@@ -363,36 +361,35 @@ class ActionPlanner:
         is_parallel = False
         if mode == ChatMode.NORMAL and action in current_available_actions:
             is_parallel = current_available_actions[action].parallel_action
-            
-            
+
         action_data["loop_start_time"] = loop_start_time
-        
+
         actions = []
-            
+
         # 1. 添加Planner取得的动作
-        actions.append({
-            "action_type": action,
-            "reasoning": reasoning,
-            "action_data": action_data,
-            "action_message": target_message,
-            "available_actions": available_actions  # 添加这个字段
-        })
-        
-        if action != "reply" and is_parallel:
-            actions.append({
-                "action_type": "reply",
+        actions.append(
+            {
+                "action_type": action,
+                "reasoning": reasoning,
+                "action_data": action_data,
                 "action_message": target_message,
-                "available_actions": available_actions
-            })
-            
-        return actions,target_message
+                "available_actions": available_actions,  # 添加这个字段
+            }
+        )
+
+        if action != "reply" and is_parallel:
+            actions.append(
+                {"action_type": "reply", "action_message": target_message, "available_actions": available_actions}
+            )
+
+        return actions, target_message
 
     async def build_planner_prompt(
         self,
         is_group_chat: bool,  # Now passed as argument
         chat_target_info: Optional[dict],  # Now passed as argument
         current_available_actions: Dict[str, ActionInfo],
-        refresh_time :bool = False,
+        refresh_time: bool = False,
         mode: ChatMode = ChatMode.FOCUS,
     ) -> tuple[str, list]:  # sourcery skip: use-join
         """构建 Planner LLM 的提示词 (获取模板并填充数据)"""
@@ -401,21 +398,15 @@ class ActionPlanner:
             time_block = f"当前时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
             bot_name = global_config.bot.nickname
             bot_nickname = (
-                f",也有人叫你{','.join(global_config.bot.alias_names)}"
-                if global_config.bot.alias_names
-                else ""
+                f",也有人叫你{','.join(global_config.bot.alias_names)}" if global_config.bot.alias_names else ""
             )
             bot_core_personality = global_config.personality.personality_core
-            identity_block = (
-                f"你的名字是{bot_name}{bot_nickname}，你{bot_core_personality}："
-            )
+            identity_block = f"你的名字是{bot_name}{bot_nickname}，你{bot_core_personality}："
 
             schedule_block = ""
             if global_config.schedule.enable:
                 if current_activity := schedule_manager.get_current_activity():
-                    schedule_block = (
-                        f"你当前正在：{current_activity},但注意它与群聊的聊天无关。"
-                    )
+                    schedule_block = f"你当前正在：{current_activity},但注意它与群聊的聊天无关。"
 
             mood_block = ""
             if global_config.mood.enable_mood:
@@ -425,13 +416,9 @@ class ActionPlanner:
             # --- 根据模式构建不同的Prompt ---
             if mode == ChatMode.PROACTIVE:
                 long_term_memory_block = await self._get_long_term_memory_context()
-                action_options_text = await self._build_action_options(
-                    current_available_actions, mode
-                )
+                action_options_text = await self._build_action_options(current_available_actions, mode)
 
-                prompt_template = await global_prompt_manager.get_prompt_async(
-                    "proactive_planner_prompt"
-                )
+                prompt_template = await global_prompt_manager.get_prompt_async("proactive_planner_prompt")
                 prompt = prompt_template.format(
                     time_block=time_block,
                     identity_block=identity_block,
@@ -464,12 +451,8 @@ class ActionPlanner:
                 limit=5,
             )
 
-            actions_before_now_block = build_readable_actions(
-                actions=actions_before_now
-            )
-            actions_before_now_block = (
-                f"你刚刚选择并执行过的action是：\n{actions_before_now_block}"
-            )
+            actions_before_now_block = build_readable_actions(actions=actions_before_now)
+            actions_before_now_block = f"你刚刚选择并执行过的action是：\n{actions_before_now_block}"
 
             if refresh_time:
                 self.last_obs_time_mark = time.time()
@@ -505,30 +488,22 @@ class ActionPlanner:
 }}"""
 
             chat_context_description = "你现在正在一个群聊中"
-            chat_target_name = None 
+            chat_target_name = None
             if not is_group_chat and chat_target_info:
                 chat_target_name = (
-                    chat_target_info.get("person_name")
-                    or chat_target_info.get("user_nickname")
-                    or "对方"
+                    chat_target_info.get("person_name") or chat_target_info.get("user_nickname") or "对方"
                 )
                 chat_context_description = f"你正在和 {chat_target_name} 私聊"
 
-            action_options_block = await self._build_action_options(
-                current_available_actions, mode
-            )
+            action_options_block = await self._build_action_options(current_available_actions, mode)
 
             moderation_prompt_block = "请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。"
 
             custom_prompt_block = ""
             if global_config.custom_prompt.planner_custom_prompt_content:
-                custom_prompt_block = (
-                    global_config.custom_prompt.planner_custom_prompt_content
-                )
+                custom_prompt_block = global_config.custom_prompt.planner_custom_prompt_content
 
-            planner_prompt_template = await global_prompt_manager.get_prompt_async(
-                "planner_prompt"
-            )
+            planner_prompt_template = await global_prompt_manager.get_prompt_async("planner_prompt")
             prompt = planner_prompt_template.format(
                 schedule_block=schedule_block,
                 mood_block=mood_block,
@@ -557,9 +532,7 @@ class ActionPlanner:
         """
         is_group_chat = True
         is_group_chat, chat_target_info = get_chat_type_and_target_info(self.chat_id)
-        logger.debug(
-            f"{self.log_prefix}获取到聊天信息 - 群聊: {is_group_chat}, 目标信息: {chat_target_info}"
-        )
+        logger.debug(f"{self.log_prefix}获取到聊天信息 - 群聊: {is_group_chat}, 目标信息: {chat_target_info}")
 
         current_available_actions_dict = self.action_manager.get_using_actions()
 
@@ -570,13 +543,9 @@ class ActionPlanner:
         current_available_actions = {}
         for action_name in current_available_actions_dict:
             if action_name in all_registered_actions:
-                current_available_actions[action_name] = all_registered_actions[
-                    action_name
-                ]
+                current_available_actions[action_name] = all_registered_actions[action_name]
             else:
-                logger.warning(
-                    f"{self.log_prefix}使用中的动作 {action_name} 未在已注册动作中找到"
-                )
+                logger.warning(f"{self.log_prefix}使用中的动作 {action_name} 未在已注册动作中找到")
 
         # 将no_reply作为系统级特殊动作添加到可用动作中
         # no_reply虽然是系统级决策，但需要让规划器认为它是可用的

src/chat/replyer/default_generator.py

@@ -705,16 +705,16 @@ class DefaultReplyer:
             # 检查最新五条消息中是否包含bot自己说的消息
             latest_5_messages = core_dialogue_list[-5:] if len(core_dialogue_list) >= 5 else core_dialogue_list
             has_bot_message = any(str(msg.get("user_id")) == bot_id for msg in latest_5_messages)
-            
+
             # logger.info(f"最新五条消息：{latest_5_messages}")
             # logger.info(f"最新五条消息中是否包含bot自己说的消息：{has_bot_message}")
-            
+
             # 如果最新五条消息中不包含bot的消息，则返回空字符串
             if not has_bot_message:
                 core_dialogue_prompt = ""
             else:
                 core_dialogue_list = core_dialogue_list[-int(global_config.chat.max_context_size * 2) :]  # 限制消息数量
-                
+
                 core_dialogue_prompt_str = build_readable_messages(
                     core_dialogue_list,
                     replace_bot_name=True,
@@ -863,7 +863,7 @@ class DefaultReplyer:
             mood_prompt = ""
 
         if reply_to:
-            #兼容旧的reply_to
+            # 兼容旧的reply_to
             sender, target = self._parse_reply_target(reply_to)
         else:
             # 获取 platform，如果不存在则从 chat_stream 获取，如果还是 None 则使用默认值
@@ -874,7 +874,7 @@ class DefaultReplyer:
             )
             person_name = await person_info_manager.get_value(person_id, "person_name")
             sender = person_name
-            target = reply_message.get('processed_plain_text')
+            target = reply_message.get("processed_plain_text")
 
         person_info_manager = get_person_info_manager()
         person_id = person_info_manager.get_person_id_by_person_name(sender)
@@ -1051,7 +1051,7 @@ class DefaultReplyer:
         chat_stream = self.chat_stream
         chat_id = chat_stream.stream_id
         is_group_chat = bool(chat_stream.group_info)
-            
+
         if reply_message:
             sender = reply_message.get("sender")
             target = reply_message.get("target")
@@ -1209,7 +1209,9 @@ class DefaultReplyer:
             else:
                 logger.debug(f"\n{prompt}\n")
 
-            content, (reasoning_content, model_name, tool_calls) = await self.express_model.generate_response_async(prompt)
+            content, (reasoning_content, model_name, tool_calls) = await self.express_model.generate_response_async(
+                prompt
+            )
 
             logger.debug(f"replyer生成内容: {content}")
         return content, reasoning_content, model_name, tool_calls

src/chat/utils/chat_message_builder.py

@@ -1245,7 +1245,7 @@ async def get_person_id_list(messages: List[Dict[str, Any]]) -> List[str]:
         # 检查必要信息是否存在 且 不是机器人自己
         if not all([platform, user_id]) or user_id == global_config.bot.qq_account:
             continue
-        
+
         # 添加空值检查，防止 platform 为 None 时出错
         if platform is None:
             platform = "unknown"

src/chat/utils/prompt_utils.py

@@ -12,6 +12,7 @@ from src.config.config import global_config
 from src.chat.message_receive.chat_stream import get_chat_manager
 from src.person_info.person_info import get_person_info_manager
 from src.plugin_system.apis import cross_context_api
+
 logger = get_logger("prompt_utils")
 
 
@@ -80,29 +81,29 @@ class PromptUtils:
 
     @staticmethod
     async def build_cross_context(
-            chat_id: str, target_user_info: Optional[Dict[str, Any]], current_prompt_mode: str
-        ) -> str:
-            """
-            构建跨群聊上下文 - 统一实现，完全继承DefaultReplyer功能
-            """
-            if not global_config.cross_context.enable:
-                return ""
-
-            other_chat_raw_ids = cross_context_api.get_context_groups(chat_id)
-            if not other_chat_raw_ids:
-                return ""
-
-            chat_stream = get_chat_manager().get_stream(chat_id)
-            if not chat_stream:
-                return ""
-
-            if current_prompt_mode == "normal":
-                return await cross_context_api.build_cross_context_normal(chat_stream, other_chat_raw_ids)
-            elif current_prompt_mode == "s4u":
-                return await cross_context_api.build_cross_context_s4u(chat_stream, other_chat_raw_ids, target_user_info)
-
+        chat_id: str, target_user_info: Optional[Dict[str, Any]], current_prompt_mode: str
+    ) -> str:
+        """
+        构建跨群聊上下文 - 统一实现，完全继承DefaultReplyer功能
+        """
+        if not global_config.cross_context.enable:
             return ""
 
+        other_chat_raw_ids = cross_context_api.get_context_groups(chat_id)
+        if not other_chat_raw_ids:
+            return ""
+
+        chat_stream = get_chat_manager().get_stream(chat_id)
+        if not chat_stream:
+            return ""
+
+        if current_prompt_mode == "normal":
+            return await cross_context_api.build_cross_context_normal(chat_stream, other_chat_raw_ids)
+        elif current_prompt_mode == "s4u":
+            return await cross_context_api.build_cross_context_s4u(chat_stream, other_chat_raw_ids, target_user_info)
+
+        return ""
+
     @staticmethod
     def parse_reply_target_id(reply_to: str) -> str:
         """

src/chat/utils/smart_prompt.py

@@ -194,7 +194,7 @@ class SmartPromptBuilder:
         core_dialogue, background_dialogue = await self._build_s4u_chat_history_prompts(
             params.message_list_before_now_long,
             params.target_user_info.get("user_id") if params.target_user_info else "",
-            params.sender
+            params.sender,
         )
 
         context_data["core_dialogue_prompt"] = core_dialogue
@@ -245,16 +245,16 @@ class SmartPromptBuilder:
             # 检查最新五条消息中是否包含bot自己说的消息
             latest_5_messages = core_dialogue_list[-5:] if len(core_dialogue_list) >= 5 else core_dialogue_list
             has_bot_message = any(str(msg.get("user_id")) == bot_id for msg in latest_5_messages)
-            
+
             # logger.info(f"最新五条消息：{latest_5_messages}")
             # logger.info(f"最新五条消息中是否包含bot自己说的消息：{has_bot_message}")
-            
+
             # 如果最新五条消息中不包含bot的消息，则返回空字符串
             if not has_bot_message:
                 core_dialogue_prompt = ""
             else:
                 core_dialogue_list = core_dialogue_list[-int(global_config.chat.max_context_size * 2) :]  # 限制消息数量
-                
+
                 core_dialogue_prompt_str = build_readable_messages(
                     core_dialogue_list,
                     replace_bot_name=True,

src/chat/utils/utils_image.py

@@ -27,16 +27,15 @@ logger = get_logger("chat_image")
 def is_image_message(message: Dict[str, Any]) -> bool:
     """
     判断消息是否为图片消息
-    
+
     Args:
         message: 消息字典
-        
+
     Returns:
         bool: 是否为图片消息
     """
     return message.get("type") == "image" or (
-        isinstance(message.get("content"), dict) and 
-        message["content"].get("type") == "image"
+        isinstance(message.get("content"), dict) and message["content"].get("type") == "image"
     )
 
 
@@ -596,7 +595,6 @@ class ImageManager:
             return "", "[图片]"
 
 
-
 # 创建全局单例
 image_manager = None