fix: make bot identity platform-aware

src/bw_learner/expression_learner.py

@@ -155,7 +155,7 @@ class ExpressionLearner:
 
         for i, msg in enumerate(self._messages_cache):
             # 跳过机器人自己的消息
-            if is_bot_self(msg.message_info.user_info.user_id, msg.platform):
+            if is_bot_self(msg.platform, msg.message_info.user_info.user_id):
                 continue
 
             # 获取消息文本
@@ -238,7 +238,7 @@ class ExpressionLearner:
 
             # 检查是否是机器人自己的消息
             target_msg = self._messages_cache[line_index]
-            if is_bot_self(target_msg.message_info.user_info.user_id, target_msg.platform):
+            if is_bot_self(target_msg.platform, target_msg.message_info.user_info.user_id):
                 logger.info(f"跳过引用机器人自身消息的黑话：content={content}, source_id={source_id}")
                 continue
 
@@ -298,7 +298,7 @@ class ExpressionLearner:
             # 当前行的原始消息
             current_msg = self._messages_cache[line_index]
             # 过滤掉从 bot 自己发言中提取到的表达方式
-            if is_bot_self(current_msg.message_info.user_info.user_id, current_msg.platform):
+            if is_bot_self(current_msg.platform, current_msg.message_info.user_info.user_id):
                 continue
             # 过滤掉无上下文的表达方式
             context = (current_msg.processed_plain_text or "").strip()

src/chat/brain_chat/PFC/message_sender.py

@@ -1,14 +1,16 @@
 import time
 from typing import Optional
-from src.common.logger import get_logger
+
 from maim_message import Seg
+from rich.traceback import install
 
 from src.common.data_models.mai_message_data_model import MaiMessage, UserInfo
 from src.chat.message_receive.chat_manager import BotChatSession
 from src.chat.message_receive.message import MessageSending
 from src.chat.message_receive.uni_message_sender import UniversalMessageSender
+from src.chat.utils.utils import get_bot_account
+from src.common.logger import get_logger
 from src.config.config import global_config
-from rich.traceback import install
 
 install(extra_lines=3)
 
@@ -41,7 +43,7 @@ class DirectMessageSender:
 
             # 获取麦麦的信息
             bot_user_info = UserInfo(
-                user_id=global_config.bot.qq_account,
+                user_id=get_bot_account(chat_stream.platform),
                 user_nickname=global_config.bot.nickname,
             )
 

src/chat/planner_actions/planner.py

@@ -122,7 +122,11 @@ class ActionPlanner:
             msg_text = re.sub(pic_pattern, replace_pic_id, msg_text)
 
             # 替换用户引用格式：回复<aaa:bbb> 和 @<aaa:bbb>
-            platform = message.platform or "qq"
+            platform = message.platform or ""
+            if not platform:
+                logger.warning(
+                    f"{self.log_prefix}planner: message {message.message_id} has no platform set, bot-self detection will be skipped"
+                )
             msg_text = replace_user_references(msg_text, platform, replace_bot_name=True)
 
             # 替换单独的 <用户名:用户ID> 格式（replace_user_references 已处理回复<和@<格式）
@@ -135,7 +139,7 @@ class ActionPlanner:
                 user_id = user_match.group(2)
                 try:
                     # 检查是否是机器人自己
-                    if user_id == global_config.bot.qq_account:
+                    if is_bot_self(platform, str(user_id)):
                         return f"{global_config.bot.nickname}(你)"
                     person = Person(platform=platform, user_id=user_id)
                     return person.person_name or user_name

src/chat/replyer/group_generator.py

@@ -19,7 +19,7 @@ from src.chat.message_receive.message import SessionMessage
 from src.chat.message_receive.chat_manager import BotChatSession
 from src.chat.message_receive.uni_message_sender import UniversalMessageSender
 from src.chat.utils.timer_calculator import Timer  # <--- Import Timer
-from src.chat.utils.utils import get_chat_type_and_target_info, is_bot_self
+from src.chat.utils.utils import get_bot_account, get_chat_type_and_target_info, is_bot_self
 from src.prompt.prompt_manager import prompt_manager
 from src.services.message_service import (
     build_readable_messages,
@@ -1122,7 +1122,7 @@ class DefaultReplyer:
                 message_id=message_id,
                 time=thinking_start_time,
                 user_info=MaimUserInfo(
-                    user_id=str(global_config.bot.qq_account),
+                    user_id=get_bot_account(self.chat_stream.platform),
                     user_nickname=global_config.bot.nickname,
                 ),
                 additional_config={},

src/chat/replyer/private_generator.py

@@ -18,7 +18,7 @@ from src.chat.message_receive.message import SessionMessage
 from src.chat.message_receive.chat_manager import BotChatSession
 from src.chat.message_receive.uni_message_sender import UniversalMessageSender
 from src.chat.utils.timer_calculator import Timer
-from src.chat.utils.utils import get_chat_type_and_target_info, is_bot_self
+from src.chat.utils.utils import get_bot_account, get_chat_type_and_target_info, is_bot_self
 from src.prompt.prompt_manager import prompt_manager
 from src.chat.utils.common_utils import TempMethodsExpression
 from src.services.message_service import (
@@ -962,7 +962,7 @@ class PrivateReplyer:
                 message_id=message_id,
                 time=thinking_start_time,
                 user_info=MaimUserInfo(
-                    user_id=str(global_config.bot.qq_account),
+                    user_id=get_bot_account(self.chat_stream.platform),
                     user_nickname=global_config.bot.nickname,
                 ),
                 group_info=None,

src/chat/utils/statistic.py

@@ -2106,12 +2106,7 @@ class StatisticOutputTask(AsyncTask):
         total_replies = [0] * len(time_points)
         total_online_hours = [0.0] * len(time_points)
 
-        # 获取bot的QQ账号
-        bot_qq_account = (
-            str(global_config.bot.qq_account)
-            if hasattr(global_config, "bot") and hasattr(global_config.bot, "qq_account")
-            else ""
-        )
+        from src.chat.utils.utils import is_bot_self
 
         interval_seconds = interval_hours * 3600
 
@@ -2148,7 +2143,7 @@ class StatisticOutputTask(AsyncTask):
             if 0 <= interval_index < len(time_points):
                 total_messages[interval_index] += 1
                 # 检查是否是bot发送的消息（回复）
-                if bot_qq_account and message.user_id == bot_qq_account:
+                if is_bot_self(message.platform or "", message.user_id or ""):
                     total_replies[interval_index] += 1
 
         # 查询在线时间记录

src/chat/utils/utils.py

@@ -1,18 +1,18 @@
+import ast
+import json
+import os
 import random
 import re
 import time
-import jieba
-import json
-import ast
-import os
 from datetime import datetime
-
 from typing import Optional, Tuple, List, TYPE_CHECKING
 
+import jieba
+
+from src.chat.message_receive.chat_manager import chat_manager as _chat_manager
+from src.chat.message_receive.message import SessionMessage
 from src.common.logger import get_logger
 from src.config.config import global_config, model_config
-from src.chat.message_receive.message import SessionMessage
-from src.chat.message_receive.chat_manager import chat_manager as _chat_manager
 from src.llm_models.utils_model import LLMRequest
 from src.person_info.person_info import Person
 from .typo_generator import ChineseTypoGenerator
@@ -37,33 +37,64 @@ def parse_platform_accounts(platforms: list[str]) -> dict[str, str]:
     Returns:
         字典，键为平台名，值为账号
     """
-    result = {}
+    result: dict[str, str] = {}
     for platform_entry in platforms:
         if ":" in platform_entry:
             platform_name, account = platform_entry.split(":", 1)
-            result[platform_name.strip()] = account.strip()
+            normalized_platform = platform_name.lower().strip()
+            account_str = account.strip()
+            if normalized_platform and account_str:
+                result[normalized_platform] = account_str
     return result
 
 
-def get_current_platform_account(platform: str, platform_accounts: dict[str, str], qq_account: str) -> str:
-    """根据当前平台获取对应的账号
+def _get_configured_qq_account() -> str:
+    qq_account = str(getattr(global_config.bot, "qq_account", "")).strip()
+    if qq_account in {"", "0"}:
+        return ""
+    return qq_account
 
-    Args:
-        platform: 当前消息的平台
-        platform_accounts: 从 platforms 列表解析的平台账号映射
-        qq_account: QQ 账号（兼容旧配置）
 
-    Returns:
-        当前平台对应的账号
-    """
-    if platform == "qq":
+def get_bot_account(platform: str) -> str:
+    """根据当前平台获取对应的机器人账号。"""
+    normalized_platform = str(platform or "").strip().lower()
+    if not normalized_platform:
+        return ""
+
+    qq_account = _get_configured_qq_account()
+    if normalized_platform in {"qq", "webui"}:
         return qq_account
-    elif platform == "telegram":
-        # 优先使用 tg，其次使用 telegram
+
+    platforms_list = getattr(global_config.bot, "platforms", []) or []
+    platform_accounts = parse_platform_accounts(platforms_list)
+    if normalized_platform in {"tg", "telegram"}:
         return platform_accounts.get("tg", "") or platform_accounts.get("telegram", "")
-    else:
-        # 其他平台直接使用平台名作为键
-        return platform_accounts.get(platform, "")
+
+    return platform_accounts.get(normalized_platform, "")
+
+
+def get_all_bot_accounts() -> dict[str, str]:
+    """获取所有已配置的机器人运行时身份。"""
+    bot_accounts: dict[str, str] = {}
+    qq_account = _get_configured_qq_account()
+    if qq_account:
+        bot_accounts["qq"] = qq_account
+        bot_accounts["webui"] = qq_account
+
+    platforms_list = getattr(global_config.bot, "platforms", []) or []
+    platform_accounts = parse_platform_accounts(platforms_list)
+
+    telegram_account = platform_accounts.get("tg", "") or platform_accounts.get("telegram", "")
+    if telegram_account:
+        bot_accounts["telegram"] = telegram_account
+        bot_accounts["tg"] = telegram_account
+
+    for platform_name, account in platform_accounts.items():
+        if platform_name in {"tg", "telegram"}:
+            continue
+        bot_accounts[platform_name] = account
+
+    return bot_accounts
 
 
 def is_bot_self(platform: str, user_id: str) -> bool:
@@ -78,39 +109,21 @@ def is_bot_self(platform: str, user_id: str) -> bool:
     Returns:
         bool: 如果是机器人自己则返回 True，否则返回 False
     """
-    if not platform or not user_id:
+    normalized_platform = str(platform or "").strip().lower()
+    if not normalized_platform or not user_id:
         return False
 
     # 将 user_id 转为字符串进行比较
-    user_id_str = str(user_id)
+    user_id_str = str(user_id).strip()
+    if not user_id_str:
+        return False
 
-    # 获取机器人的 QQ 账号（主账号）
-    qq_account = str(global_config.bot.qq_account or "")
+    bot_account = get_bot_account(normalized_platform)
+    if bot_account:
+        return user_id_str == bot_account
 
-    # QQ 平台：直接比较 QQ 账号
-    if platform == "qq":
-        return user_id_str == qq_account
-
-    # WebUI 平台：机器人回复时使用的是 QQ 账号，所以也比较 QQ 账号
-    if platform == "webui":
-        return user_id_str == qq_account
-
-    # 获取各平台账号映射
-    platforms_list = getattr(global_config.bot, "platforms", []) or []
-    platform_accounts = parse_platform_accounts(platforms_list)
-
-    # Telegram 平台
-    if platform == "telegram":
-        tg_account = platform_accounts.get("tg", "") or platform_accounts.get("telegram", "")
-        return user_id_str == tg_account if tg_account else False
-
-    # 其他平台：尝试从 platforms 配置中查找
-    platform_account = platform_accounts.get(platform, "")
-    if platform_account:
-        return user_id_str == platform_account
-
-    # 默认情况：与主 QQ 账号比较（兼容性）
-    return user_id_str == qq_account
+    logger.warning(f"平台 {normalized_platform} 未配置机器人账号，无法判断用户 {user_id_str} 是否为机器人自己")
+    return False
 
 
 def is_mentioned_bot_in_message(message: SessionMessage) -> tuple[bool, bool, float]:
@@ -118,13 +131,8 @@ def is_mentioned_bot_in_message(message: SessionMessage) -> tuple[bool, bool, fl
     text = message.processed_plain_text or ""
     platform = message.platform or ""
 
-    # 获取各平台账号
-    platforms_list = getattr(global_config.bot, "platforms", []) or []
-    platform_accounts = parse_platform_accounts(platforms_list)
-    qq_account = str(getattr(global_config.bot, "qq_account", "") or "")
-
     # 获取当前平台对应的账号
-    current_account = get_current_platform_account(platform, platform_accounts, qq_account)
+    current_account = get_bot_account(platform)
 
     nickname = str(global_config.bot.nickname or "")
     alias_names = list(getattr(global_config.bot, "alias_names", []) or [])

src/common/message_repository.py

@@ -1,17 +1,16 @@
-import traceback
 from datetime import datetime
 from typing import Any
 
 import json
+import traceback
 
-from sqlalchemy import func
+from sqlalchemy import and_, func, not_, or_
 from sqlmodel import col, select
 
 from src.common.database.database import get_db_session
 from src.common.database.database_model import Messages
 from src.chat.message_receive.message import SessionMessage
 from src.common.logger import get_logger
-from src.config.config import global_config
 
 logger = get_logger(__name__)
 
@@ -163,7 +162,17 @@ def find_messages(
             after_time=after_time,
         )
         if filter_bot:
-            conditions.append(Messages.user_id != global_config.bot.qq_account)
+            from src.chat.utils.utils import get_all_bot_accounts
+
+            bot_accounts = get_all_bot_accounts()
+            if bot_accounts:
+                bot_identity_predicate = or_(
+                    *[
+                        and_(Messages.platform == platform_name, Messages.user_id == account)
+                        for platform_name, account in bot_accounts.items()
+                    ]
+                )
+                conditions.append(not_(bot_identity_predicate))
         if filter_command:
             conditions.append(Messages.is_command == False)  # noqa: E712
 

src/common/utils/system_utils.py

@@ -1,8 +1,10 @@
-# TODO: 这个函数的实现非常临时，后续需要替换为更完善的实现，比如直接从配置文件中读取机器人自己的 ID，或者通过 API 获取机器人自己的信息等
-def is_bot_self(user_id: str, platform: str) -> bool:
+# TODO: 这个兼容包装层后续可以删除，统一直接使用 src.chat.utils.utils.is_bot_self
+def is_bot_self(platform: str, user_id: str) -> bool:
     """
-    判断用户 ID 是否是机器人自己
+    判断用户 ID 是否是机器人自己。
 
-    临时方法，后续会替换为更完善的实现
+    当前仅保留兼容入口，真实实现委托给统一的多平台判断函数。
     """
-    return user_id == "bot_self" and platform == "test_platform"
+    from src.chat.utils.utils import is_bot_self as _is_bot_self
+
+    return _is_bot_self(platform, user_id)

src/common/utils/utils_message.py

@@ -367,7 +367,7 @@ class MessageUtils:
             anonymous_name = anonymize_mapping[msg_usr_info.user_id][0]
             new_message.message_info.user_info.user_nickname = anonymous_name
             new_message.message_info.user_info.user_cardname = anonymous_name
-        if replace_bot_name and target_bot_name and is_bot_self(msg_usr_info.user_id, platform):
+        if replace_bot_name and target_bot_name and is_bot_self(platform, msg_usr_info.user_id):
             new_message.message_info.user_info.user_nickname = target_bot_name
             new_message.message_info.user_info.user_cardname = target_bot_name
         return new_message
@@ -437,7 +437,7 @@ class MessageUtils:
             anonymous_name = anonymize_mapping[user_id][0]
             component.target_user_nickname = anonymous_name
             component.target_user_cardname = anonymous_name
-        if replace_bot_name and target_bot_name and is_bot_self(user_id, platform):
+        if replace_bot_name and target_bot_name and is_bot_self(platform, user_id):
             component.target_user_nickname = target_bot_name
             component.target_user_cardname = target_bot_name
         return component
@@ -473,7 +473,7 @@ class MessageUtils:
                 anonymous_name = anonymize_mapping[user_id][0]
                 comp.user_nickname = anonymous_name
                 comp.user_cardname = anonymous_name
-            if replace_bot_name and target_bot_name and is_bot_self(user_id, platform):
+            if replace_bot_name and target_bot_name and is_bot_self(platform, user_id):
                 comp.user_nickname = target_bot_name
                 comp.user_cardname = target_bot_name
             comp.content = [  # 递归处理转发消息中的组件
@@ -512,7 +512,7 @@ class MessageUtils:
                 anonymous_name = anonymize_mapping[user_id][0]
                 component.target_message_sender_nickname = anonymous_name
                 component.target_message_sender_cardname = anonymous_name
-            if replace_bot_name and target_bot_name and is_bot_self(user_id, platform):
+            if replace_bot_name and target_bot_name and is_bot_self(platform, user_id):
                 component.target_message_sender_nickname = target_bot_name
                 component.target_message_sender_cardname = target_bot_name
         else:

src/person_info/person_info.py

@@ -256,43 +256,9 @@ class Person:
         Returns:
             bool: 如果是机器人自己则返回 True，否则返回 False
         """
-        if not platform or not user_id:
-            return False
+        from src.chat.utils.utils import is_bot_self
 
-        # 将 user_id 转为字符串进行比较
-        user_id_str = str(user_id)
-
-        # 获取机器人的 QQ 账号（主账号）
-        qq_account = str(global_config.bot.qq_account or "")
-
-        # QQ 平台：直接比较 QQ 账号
-        if platform == "qq":
-            return user_id_str == qq_account
-
-        # WebUI 平台：机器人回复时使用的是 QQ 账号，所以也比较 QQ 账号
-        if platform == "webui":
-            return user_id_str == qq_account
-
-        # 获取各平台账号映射
-        platforms_list = getattr(global_config.bot, "platforms", []) or []
-        platform_accounts = {}
-        for platform_entry in platforms_list:
-            if ":" in platform_entry:
-                platform_name, account = platform_entry.split(":", 1)
-                platform_accounts[platform_name.strip()] = account.strip()
-
-        # Telegram 平台
-        if platform == "telegram":
-            tg_account = platform_accounts.get("tg", "") or platform_accounts.get("telegram", "")
-            return user_id_str == tg_account if tg_account else False
-
-        # 其他平台：尝试从 platforms 配置中查找
-        platform_account = platform_accounts.get(platform, "")
-        if platform_account:
-            return user_id_str == platform_account
-
-        # 默认情况：与主 QQ 账号比较（兼容性）
-        return user_id_str == qq_account
+        return is_bot_self(platform, user_id)
 
     def __init__(self, platform: str = "", user_id: str = "", person_id: str = "", person_name: str = ""):
         # 使用统一的机器人识别函数（支持多平台，包括 WebUI）
@@ -731,15 +697,15 @@ class PersonInfoManager:
             bot_name = global_config.bot.nickname
 
             qv_name_prompt = f"你是{bot_name}，一个伪装成人类的AI，你不能让别人发现这一点，"
-            qv_name_prompt += f"现在你想给一个用户取一个昵称，用户的qq昵称是{user_nickname}，"
-            qv_name_prompt += f"用户的qq群昵称名是{user_cardname}，"
+            qv_name_prompt += f"现在你想给一个用户取一个昵称，用户的昵称是{user_nickname}，"
+            qv_name_prompt += f"用户的群昵称名是{user_cardname}，"
             if user_avatar:
-                qv_name_prompt += f"用户的qq头像是{user_avatar}，"
+                qv_name_prompt += f"用户的头像是{user_avatar}，"
             if old_name:
                 qv_name_prompt += f"你之前叫他{old_name}，是因为{old_reason}，"
 
             qv_name_prompt += f"\n其他取名的要求是：{request}，不要太浮夸，简短，"
-            qv_name_prompt += "\n请根据以上用户信息，想想你叫他什么比较好，不要太浮夸，请最好使用用户的qq昵称或群昵称原文，可以稍作修改，优先使用原文。优先使用用户的qq昵称或者群昵称原文。"
+            qv_name_prompt += "\n请根据以上用户信息，想想你叫他什么比较好，不要太浮夸，请最好使用用户的昵称或群昵称原文，可以稍作修改，优先使用原文。优先使用用户的昵称或者群昵称原文。"
 
             if existing_names_str:
                 qv_name_prompt += f"\n请注意，以下名称已被你尝试过或已知存在，请避免：{existing_names_str}。\n"

src/services/send_service.py

@@ -4,15 +4,17 @@
 提供发送各种类型消息的核心功能。
 """
 
+from typing import Dict, List, Optional, TYPE_CHECKING
+
 import time
 import traceback
-from typing import Dict, List, Optional, TYPE_CHECKING
 
 from maim_message import BaseMessageInfo, GroupInfo as MaimGroupInfo, MessageBase, Seg, UserInfo as MaimUserInfo
 
 from src.chat.message_receive.chat_manager import chat_manager as _chat_manager
 from src.chat.message_receive.message import SessionMessage
 from src.chat.message_receive.uni_message_sender import UniversalMessageSender
+from src.chat.utils.utils import get_bot_account
 from src.common.data_models.mai_message_data_model import MaiMessage
 from src.common.data_models.message_component_data_model import DictComponent, MessageSequence
 from src.common.logger import get_logger
@@ -88,7 +90,7 @@ async def _send_to_target(
                 message_id=message_id,
                 time=current_time,
                 user_info=MaimUserInfo(
-                    user_id=str(global_config.bot.qq_account),
+                    user_id=get_bot_account(target_stream.platform),
                     user_nickname=global_config.bot.nickname,
                     platform=target_stream.platform,
                 ),

src/webui/routers/chat/support.py

@@ -11,11 +11,11 @@ from sqlmodel import col, delete, select
 
 from src.chat.message_receive.bot import chat_bot
 from src.chat.message_receive.message import SessionMessage
+from src.chat.utils.utils import is_bot_self
 from src.common.database.database import get_db_session
 from src.common.database.database_model import Messages, PersonInfo
 from src.common.logger import get_logger
 from src.common.message_repository import find_messages
-from src.common.utils.system_utils import is_bot_self
 from src.common.utils.utils_session import SessionUtils
 from src.config.config import global_config
 from src.webui.core import get_token_manager
@@ -62,12 +62,7 @@ class ChatHistoryManager:
     def _message_to_dict(self, msg: SessionMessage, group_id: Optional[str] = None) -> dict[str, Any]:
         user_info = msg.message_info.user_info
         user_id = user_info.user_id or ""
-        is_bot = is_bot_self(user_id, msg.platform)
-
-        if not is_bot and group_id and group_id.startswith(VIRTUAL_GROUP_ID_PREFIX):
-            is_bot = user_id == str(global_config.bot.qq_account)
-        elif not is_bot:
-            is_bot = not user_id.startswith(WEBUI_USER_ID_PREFIX)
+        is_bot = is_bot_self(msg.platform, user_id)
 
         return {
             "id": msg.message_id,
@@ -611,4 +606,4 @@ async def dispatch_chat_event(
         )
         return current_user_name, next_virtual_config
 
-    return current_user_name, current_virtual_config
+    return current_user_name, current_virtual_config