Merge branch 'dev' of https://github.com/MaiM-with-u/MaiBot into dev

src/chat/chat_loop/heartFC_chat.py

@@ -51,6 +51,8 @@ NO_ACTION = {
     "action_prompt": "",
 }
 
+IS_MAI4U = False
+
 install(extra_lines=3)
 
 # 注释：原来的动作修改超时常量已移除，因为改为顺序执行
@@ -256,31 +258,29 @@ 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_typing(self):
-        group_info = GroupInfo(platform = "amaidesu_default",group_id = 114514,group_name = "内心")
-        
-        chat =  await get_chat_manager().get_or_create_stream(
-            platform = "amaidesu_default",
-            user_info = None,
-            group_info = group_info
+        group_info = GroupInfo(platform="amaidesu_default", group_id="114514", group_name="内心")
+
+        chat = await get_chat_manager().get_or_create_stream(
+            platform="amaidesu_default",
+            user_info=None,
+            group_info=group_info,
         )
-        
-        
+
         await send_api.custom_to_stream(
             message_type="state", content="typing", stream_id=chat.stream_id, storage_message=False
         )
-        
+
     async def stop_typing(self):
-        group_info = GroupInfo(platform = "amaidesu_default",group_id = 114514,group_name = "内心")
-        
-        chat =  await get_chat_manager().get_or_create_stream(
-            platform = "amaidesu_default",
-            user_info = None,
-            group_info = group_info
+        group_info = GroupInfo(platform="amaidesu_default", group_id="114514", group_name="内心")
+
+        chat = await get_chat_manager().get_or_create_stream(
+            platform="amaidesu_default",
+            user_info=None,
+            group_info=group_info,
         )
-        
-        
+
         await send_api.custom_to_stream(
             message_type="state", content="stop_typing", stream_id=chat.stream_id, storage_message=False
         )
@@ -373,7 +373,6 @@ class HeartFChatting:
                 if ENABLE_THINKING:
                     await self.stop_typing()
                     await mai_thinking_manager.get_mai_think(self.stream_id).do_think_after_response(reply_text)
-                
 
                 return True
 
@@ -505,10 +504,9 @@ class HeartFChatting:
         """
 
         interested_rate = (message_data.get("interest_value") or 0.0) * self.willing_amplifier
-    
+
         self.willing_manager.setup(message_data, self.chat_stream)
-    
-    
+
         reply_probability = await self.willing_manager.get_reply_probability(message_data.get("message_id", ""))
 
         talk_frequency = -1.00
@@ -518,7 +516,7 @@ class HeartFChatting:
             if additional_config and "maimcore_reply_probability_gain" in additional_config:
                 reply_probability += additional_config["maimcore_reply_probability_gain"]
                 reply_probability = min(max(reply_probability, 0), 1)  # 确保概率在 0-1 之间
-            
+
             talk_frequency = global_config.chat.get_current_talk_frequency(self.stream_id)
             reply_probability = talk_frequency * reply_probability
 
@@ -528,9 +526,9 @@ class HeartFChatting:
 
         # 打印消息信息
         mes_name = self.chat_stream.group_info.group_name if self.chat_stream.group_info else "私聊"
-        
+
         # logger.info(f"[{mes_name}] 当前聊天频率: {talk_frequency:.2f},兴趣值: {interested_rate:.2f},回复概率: {reply_probability * 100:.1f}%")
-        
+
         if reply_probability > 0.05:
             logger.info(
                 f"[{mes_name}]"
@@ -546,7 +544,6 @@ class HeartFChatting:
         # 意愿管理器：注销当前message信息 (无论是否回复，只要处理过就删除)
         self.willing_manager.delete(message_data.get("message_id", ""))
         return False
-        
 
     async def _generate_response(
         self, message_data: dict, available_actions: Optional[Dict[str, ActionInfo]], reply_to: str
@@ -571,7 +568,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):
         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
@@ -593,13 +590,27 @@ class HeartFChatting:
             if not first_replied:
                 if need_reply:
                     await send_api.text_to_stream(
-                        text=data, stream_id=self.chat_stream.stream_id, reply_to=reply_to, reply_to_platform_id=reply_to_platform_id, typing=False
+                        text=data,
+                        stream_id=self.chat_stream.stream_id,
+                        reply_to=reply_to,
+                        reply_to_platform_id=reply_to_platform_id,
+                        typing=False,
                     )
                 else:
-                    await send_api.text_to_stream(text=data, stream_id=self.chat_stream.stream_id, reply_to_platform_id=reply_to_platform_id, typing=False)
+                    await send_api.text_to_stream(
+                        text=data,
+                        stream_id=self.chat_stream.stream_id,
+                        reply_to_platform_id=reply_to_platform_id,
+                        typing=False,
+                    )
                 first_replied = True
             else:
-                await send_api.text_to_stream(text=data, stream_id=self.chat_stream.stream_id, reply_to_platform_id=reply_to_platform_id, typing=True)
+                await send_api.text_to_stream(
+                    text=data,
+                    stream_id=self.chat_stream.stream_id,
+                    reply_to_platform_id=reply_to_platform_id,
+                    typing=True,
+                )
             reply_text += data
 
         return reply_text

src/chat/message_receive/bot.py

@@ -13,7 +13,7 @@ from src.chat.message_receive.message import MessageRecv, MessageRecvS4U
 from src.chat.message_receive.storage import MessageStorage
 from src.chat.heart_flow.heartflow_message_processor import HeartFCMessageReceiver
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
-from src.plugin_system.core import component_registry, events_manager  # 导入新插件系统
+from src.plugin_system.core import component_registry, events_manager, global_announcement_manager
 from src.plugin_system.base import BaseCommand, EventType
 from src.mais4u.mais4u_chat.s4u_msg_processor import S4UMessageProcessor
 
@@ -91,8 +91,20 @@ class ChatBot:
             # 使用新的组件注册中心查找命令
             command_result = component_registry.find_command_by_text(text)
             if command_result:
+                command_class, matched_groups, command_info = command_result
+                intercept_message = command_info.intercept_message
+                plugin_name = command_info.plugin_name
+                command_name = command_info.name
+                if (
+                    message.chat_stream
+                    and message.chat_stream.stream_id
+                    and command_name
+                    in global_announcement_manager.get_disabled_chat_commands(message.chat_stream.stream_id)
+                ):
+                    logger.info("用户禁用的命令，跳过处理")
+                    return False, None, True
+
                 message.is_command = True
-                command_class, matched_groups, intercept_message, plugin_name = command_result
 
                 # 获取插件配置
                 plugin_config = component_registry.get_plugin_config(plugin_name)
@@ -134,13 +146,12 @@ class ChatBot:
         except Exception as e:
             logger.error(f"处理命令时出错: {e}")
             return False, None, True  # 出错时继续处理消息
-        
+
     async def hanle_notice_message(self, message: MessageRecv):
         if message.message_info.message_id == "notice":
             logger.info("收到notice消息，暂时不支持处理")
             return True
-    
-    
+
     async def do_s4u(self, message_data: Dict[str, Any]):
         message = MessageRecvS4U(message_data)
         group_info = message.message_info.group_info
@@ -162,7 +173,6 @@ class ChatBot:
 
         return
 
-
     async def message_process(self, message_data: Dict[str, Any]) -> None:
         """处理转化后的统一格式消息
         这个函数本质是预处理一些数据，根据配置信息和消息内容，预处理消息，并分发到合适的消息处理器中
@@ -178,8 +188,6 @@ class ChatBot:
         - 性能计时
         """
         try:
-
-            
             # 确保所有任务已启动
             await self._ensure_started()
 
@@ -200,11 +208,10 @@ class ChatBot:
             # print(message_data)
             # logger.debug(str(message_data))
             message = MessageRecv(message_data)
-            
+
             if await self.hanle_notice_message(message):
                 return
-            
-            
+
             group_info = message.message_info.group_info
             user_info = message.message_info.user_info
             if message.message_info.additional_config:
@@ -228,11 +235,10 @@ class ChatBot:
 
             # 处理消息内容，生成纯文本
             await message.process()
-            
+
             # if await self.check_ban_content(message):
             #     logger.warning(f"检测到消息中含有违法，色情，暴力，反动，敏感内容，消息内容：{message.processed_plain_text}，发送者：{message.message_info.user_info.user_nickname}")
             #     return
-            
 
             # 过滤检查
             if _check_ban_words(message.processed_plain_text, chat, user_info) or _check_ban_regex(  # type: ignore

src/chat/message_receive/chat_stream.py

@@ -163,20 +163,25 @@ class ChatManager:
         """注册消息到聊天流"""
         stream_id = self._generate_stream_id(
             message.message_info.platform,  # type: ignore
-            message.message_info.user_info,  # type: ignore
+            message.message_info.user_info,
             message.message_info.group_info,
         )
         self.last_messages[stream_id] = message
         # logger.debug(f"注册消息到聊天流: {stream_id}")
 
     @staticmethod
-    def _generate_stream_id(platform: str, user_info: UserInfo, group_info: Optional[GroupInfo] = None) -> str:
+    def _generate_stream_id(
+        platform: str, user_info: Optional[UserInfo], group_info: Optional[GroupInfo] = None
+    ) -> str:
         """生成聊天流唯一ID"""
+        if not user_info and not group_info:
+            raise ValueError("用户信息或群组信息必须提供")
+
         if group_info:
             # 组合关键信息
             components = [platform, str(group_info.group_id)]
         else:
-            components = [platform, str(user_info.user_id), "private"]
+            components = [platform, str(user_info.user_id), "private"]  # type: ignore
 
         # 使用MD5生成唯一ID
         key = "_".join(components)

src/chat/planner_actions/action_manager.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Type
+from typing import Dict, Optional, Type
 from src.plugin_system.base.base_action import BaseAction
 from src.chat.message_receive.chat_stream import ChatStream
 from src.common.logger import get_logger
@@ -22,53 +22,14 @@ class ActionManager:
 
     def __init__(self):
         """初始化动作管理器"""
-        # 所有注册的动作集合
-        self._registered_actions: Dict[str, ActionInfo] = {}
+
         # 当前正在使用的动作集合，默认加载默认动作
         self._using_actions: Dict[str, ActionInfo] = {}
 
-        # 加载插件动作
-        self._load_plugin_actions()
-
         # 初始化时将默认动作加载到使用中的动作
         self._using_actions = component_registry.get_default_actions()
 
-    def _load_plugin_actions(self) -> None:
-        """
-        加载所有插件系统中的动作
-        """
-        try:
-            # 从新插件系统获取Action组件
-            self._load_plugin_system_actions()
-            logger.debug("从插件系统加载Action组件成功")
-
-        except Exception as e:
-            logger.error(f"加载插件动作失败: {e}")
-
-    def _load_plugin_system_actions(self) -> None:
-        """从插件系统的component_registry加载Action组件"""
-        try:
-            # 获取所有Action组件
-            action_components: Dict[str, ActionInfo] = component_registry.get_components_by_type(ComponentType.ACTION)  # type: ignore
-
-            for action_name, action_info in action_components.items():
-                if action_name in self._registered_actions:
-                    logger.debug(f"Action组件 {action_name} 已存在，跳过")
-                    continue
-
-                self._registered_actions[action_name] = action_info
-
-                logger.debug(
-                    f"从插件系统加载Action组件: {action_name} (插件: {getattr(action_info, 'plugin_name', 'unknown')})"
-                )
-
-            logger.info(f"加载了 {len(action_components)} 个Action动作")
-
-        except Exception as e:
-            logger.error(f"从插件系统加载Action组件失败: {e}")
-            import traceback
-
-            logger.error(traceback.format_exc())
+    # === 执行Action方法 ===
 
     def create_action(
         self,
@@ -139,36 +100,11 @@ class ActionManager:
             logger.error(traceback.format_exc())
             return None
 
-    def get_registered_actions(self) -> Dict[str, ActionInfo]:
-        """获取所有已注册的动作集"""
-        return self._registered_actions.copy()
-
     def get_using_actions(self) -> Dict[str, ActionInfo]:
         """获取当前正在使用的动作集合"""
         return self._using_actions.copy()
 
-    def add_action_to_using(self, action_name: str) -> bool:
-        """
-        添加已注册的动作到当前使用的动作集
-
-        Args:
-            action_name: 动作名称
-
-        Returns:
-            bool: 添加是否成功
-        """
-        if action_name not in self._registered_actions:
-            logger.warning(f"添加失败: 动作 {action_name} 未注册")
-            return False
-
-        if action_name in self._using_actions:
-            logger.info(f"动作 {action_name} 已经在使用中")
-            return True
-
-        self._using_actions[action_name] = self._registered_actions[action_name]
-        logger.info(f"添加动作 {action_name} 到使用集")
-        return True
-
+    # === Modify相关方法 ===
     def remove_action_from_using(self, action_name: str) -> bool:
         """
         从当前使用的动作集中移除指定动作
@@ -187,79 +123,8 @@ class ActionManager:
         logger.debug(f"已从使用集中移除动作 {action_name}")
         return True
 
-    # def add_action(self, action_name: str, description: str, parameters: Dict = None, require: List = None) -> bool:
-    #     """
-    #     添加新的动作到注册集
-
-    #     Args:
-    #         action_name: 动作名称
-    #         description: 动作描述
-    #         parameters: 动作参数定义，默认为空字典
-    #         require: 动作依赖项，默认为空列表
-
-    #     Returns:
-    #         bool: 添加是否成功
-    #     """
-    #     if action_name in self._registered_actions:
-    #         return False
-
-    #     if parameters is None:
-    #         parameters = {}
-    #     if require is None:
-    #         require = []
-
-    #     action_info = {"description": description, "parameters": parameters, "require": require}
-
-    #     self._registered_actions[action_name] = action_info
-    #     return True
-
-    def remove_action(self, action_name: str) -> bool:
-        """从注册集移除指定动作"""
-        if action_name not in self._registered_actions:
-            return False
-        del self._registered_actions[action_name]
-        # 如果在使用集中也存在，一并移除
-        if action_name in self._using_actions:
-            del self._using_actions[action_name]
-        return True
-
-    def temporarily_remove_actions(self, actions_to_remove: List[str]) -> None:
-        """临时移除使用集中的指定动作"""
-        for name in actions_to_remove:
-            self._using_actions.pop(name, None)
-
     def restore_actions(self) -> None:
         """恢复到默认动作集"""
         actions_to_restore = list(self._using_actions.keys())
         self._using_actions = component_registry.get_default_actions()
         logger.debug(f"恢复动作集: 从 {actions_to_restore} 恢复到默认动作集 {list(self._using_actions.keys())}")
-
-    def add_system_action_if_needed(self, action_name: str) -> bool:
-        """
-        根据需要添加系统动作到使用集
-
-        Args:
-            action_name: 动作名称
-
-        Returns:
-            bool: 是否成功添加
-        """
-        if action_name in self._registered_actions and action_name not in self._using_actions:
-            self._using_actions[action_name] = self._registered_actions[action_name]
-            logger.info(f"临时添加系统动作到使用集: {action_name}")
-            return True
-        return False
-
-    def get_action(self, action_name: str) -> Optional[Type[BaseAction]]:
-        """
-        获取指定动作的处理器类
-
-        Args:
-            action_name: 动作名称
-
-        Returns:
-            Optional[Type[BaseAction]]: 动作处理器类，如果不存在则返回None
-        """
-        from src.plugin_system.core.component_registry import component_registry
-
-        return component_registry.get_component_class(action_name, ComponentType.ACTION)  # type: ignore

src/chat/planner_actions/action_modifier.py

@@ -2,7 +2,7 @@ import random
 import asyncio
 import hashlib
 import time
-from typing import List, Any, Dict, TYPE_CHECKING
+from typing import List, Any, Dict, TYPE_CHECKING, Tuple
 
 from src.common.logger import get_logger
 from src.config.config import global_config
@@ -11,6 +11,7 @@ from src.chat.message_receive.chat_stream import get_chat_manager, ChatMessageCo
 from src.chat.planner_actions.action_manager import ActionManager
 from src.chat.utils.chat_message_builder import get_raw_msg_before_timestamp_with_chat, build_readable_messages
 from src.plugin_system.base.component_types import ActionInfo, ActionActivationType
+from src.plugin_system.core.global_announcement_manager import global_announcement_manager
 
 if TYPE_CHECKING:
     from src.chat.message_receive.chat_stream import ChatStream
@@ -47,7 +48,6 @@ class ActionModifier:
 
     async def modify_actions(
         self,
-        history_loop=None,
         message_content: str = "",
     ):  # sourcery skip: use-named-expression
         """
@@ -61,8 +61,9 @@ class ActionModifier:
         """
         logger.debug(f"{self.log_prefix}开始完整动作修改流程")
 
-        removals_s1 = []
-        removals_s2 = []
+        removals_s1: List[Tuple[str, str]] = []
+        removals_s2: List[Tuple[str, str]] = []
+        removals_s3: List[Tuple[str, str]] = []
 
         self.action_manager.restore_actions()
         all_actions = self.action_manager.get_using_actions()
@@ -84,25 +85,28 @@ class ActionModifier:
         if message_content:
             chat_content = chat_content + "\n" + f"现在，最新的消息是：{message_content}"
 
-        # === 第一阶段：传统观察处理 ===
-        # if history_loop:
-        # removals_from_loop = await self.analyze_loop_actions(history_loop)
-        # if removals_from_loop:
-        # removals_s1.extend(removals_from_loop)
+        # === 第一阶段：去除用户自行禁用的 ===
+        disabled_actions = global_announcement_manager.get_disabled_chat_actions(self.chat_id)
+        if disabled_actions:
+            for disabled_action_name in disabled_actions:
+                if disabled_action_name in all_actions:
+                    removals_s1.append((disabled_action_name, "用户自行禁用"))
+                    self.action_manager.remove_action_from_using(disabled_action_name)
+                    logger.debug(f"{self.log_prefix}阶段一移除动作: {disabled_action_name}，原因: 用户自行禁用")
 
-        # 检查动作的关联类型
+        # === 第二阶段：检查动作的关联类型 ===
         chat_context = self.chat_stream.context
         type_mismatched_actions = self._check_action_associated_types(all_actions, chat_context)
 
         if type_mismatched_actions:
-            removals_s1.extend(type_mismatched_actions)
+            removals_s2.extend(type_mismatched_actions)
 
-        # 应用第一阶段的移除
-        for action_name, reason in removals_s1:
+        # 应用第二阶段的移除
+        for action_name, reason in removals_s2:
             self.action_manager.remove_action_from_using(action_name)
-            logger.debug(f"{self.log_prefix}阶段一移除动作: {action_name}，原因: {reason}")
+            logger.debug(f"{self.log_prefix}阶段二移除动作: {action_name}，原因: {reason}")
 
-        # === 第二阶段：激活类型判定 ===
+        # === 第三阶段：激活类型判定 ===
         if chat_content is not None:
             logger.debug(f"{self.log_prefix}开始激活类型判定阶段")
 
@@ -110,18 +114,18 @@ class ActionModifier:
             current_using_actions = self.action_manager.get_using_actions()
 
             # 获取因激活类型判定而需要移除的动作
-            removals_s2 = await self._get_deactivated_actions_by_type(
+            removals_s3 = await self._get_deactivated_actions_by_type(
                 current_using_actions,
                 chat_content,
             )
 
-            # 应用第二阶段的移除
-            for action_name, reason in removals_s2:
+            # 应用第三阶段的移除
+            for action_name, reason in removals_s3:
                 self.action_manager.remove_action_from_using(action_name)
-                logger.debug(f"{self.log_prefix}阶段二移除动作: {action_name}，原因: {reason}")
+                logger.debug(f"{self.log_prefix}阶段三移除动作: {action_name}，原因: {reason}")
 
         # === 统一日志记录 ===
-        all_removals = removals_s1 + removals_s2
+        all_removals = removals_s1 + removals_s2 + removals_s3
         removals_summary: str = ""
         if all_removals:
             removals_summary = " | ".join([f"{name}({reason})" for name, reason in all_removals])
@@ -131,7 +135,7 @@ class ActionModifier:
         )
 
     def _check_action_associated_types(self, all_actions: Dict[str, ActionInfo], chat_context: ChatMessageContext):
-        type_mismatched_actions = []
+        type_mismatched_actions: List[Tuple[str, str]] = []
         for action_name, action_info in all_actions.items():
             if action_info.associated_types and not chat_context.check_types(action_info.associated_types):
                 associated_types_str = ", ".join(action_info.associated_types)
@@ -318,7 +322,7 @@ class ActionModifier:
         action_name: str,
         action_info: ActionInfo,
         chat_content: str = "",
-    ) -> bool:
+    ) -> bool:  # sourcery skip: move-assign-in-block, use-named-expression
         """
         使用LLM判定是否应该激活某个action
 

src/chat/planner_actions/planner.py

@@ -1,7 +1,7 @@
 import json
 import time
 import traceback
-from typing import Dict, Any, Optional, Tuple
+from typing import Dict, Any, Optional, Tuple, List
 from rich.traceback import install
 from datetime import datetime
 from json_repair import repair_json
@@ -19,8 +19,8 @@ from src.chat.utils.chat_message_builder import (
 from src.chat.utils.utils import get_chat_type_and_target_info
 from src.chat.planner_actions.action_manager import ActionManager
 from src.chat.message_receive.chat_stream import get_chat_manager
-from src.plugin_system.base.component_types import ActionInfo, ChatMode
-
+from src.plugin_system.base.component_types import ActionInfo, ChatMode, ComponentType
+from src.plugin_system.core.component_registry import component_registry
 
 logger = get_logger("planner")
 
@@ -99,7 +99,7 @@ class ActionPlanner:
 
     async def plan(
         self, mode: ChatMode = ChatMode.FOCUS
-    ) -> Tuple[Dict[str, Dict[str, Any] | str], Optional[Dict[str, Any]]]:  # sourcery skip: dict-comprehension
+    ) -> Tuple[Dict[str, Dict[str, Any] | str], Optional[Dict[str, Any]]]:
         """
         规划器 (Planner): 使用LLM根据上下文决定做出什么动作。
         """
@@ -113,16 +113,17 @@ class ActionPlanner:
 
         try:
             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}")
 
             current_available_actions_dict = self.action_manager.get_using_actions()
 
             # 获取完整的动作信息
-            all_registered_actions = self.action_manager.get_registered_actions()
-
-            for action_name in current_available_actions_dict.keys():
+            all_registered_actions: List[ActionInfo] = list(
+                component_registry.get_components_by_type(ComponentType.ACTION).values()  # type: ignore
+            )
+            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]
                 else:
@@ -234,10 +235,13 @@ class ActionPlanner:
             "is_parallel": is_parallel,
         }
 
-        return {
-            "action_result": action_result,
-            "action_prompt": prompt,
-        }, target_message
+        return (
+            {
+                "action_result": action_result,
+                "action_prompt": prompt,
+            },
+            target_message,
+        )
 
     async def build_planner_prompt(
         self,

src/chat/utils/utils.py

@@ -619,9 +619,7 @@ def get_chat_type_and_target_info(chat_id: str) -> Tuple[bool, Optional[Dict]]:
     chat_target_info = None
 
     try:
-        chat_stream = get_chat_manager().get_stream(chat_id)
-
-        if chat_stream:
+        if chat_stream := get_chat_manager().get_stream(chat_id):
             if chat_stream.group_info:
                 is_group_chat = True
                 chat_target_info = None  # Explicitly None for group chat
@@ -660,8 +658,6 @@ def get_chat_type_and_target_info(chat_id: str) -> Tuple[bool, Optional[Dict]]:
                 chat_target_info = target_info
         else:
             logger.warning(f"无法获取 chat_stream for {chat_id} in utils")
-            # Keep defaults: is_group_chat=False, chat_target_info=None
-
     except Exception as e:
         logger.error(f"获取聊天类型和目标信息时出错 for {chat_id}: {e}", exc_info=True)
         # Keep defaults on error