Merge branch 'debug' into debug

2025-03-11 13:47:43 +09:00
parent 3750ebd15b 5e069f74e2
commit 3765c79e3a
33 changed files with 1784 additions and 330 deletions
--- a/src/plugins/chat/init.py
+++ b/src/plugins/chat/init.py
@@ -122,9 +122,9 @@ async def build_memory_task():
@scheduler.scheduled_job("interval", seconds=global_config.forget_memory_interval, id="forget_memory")
 async def forget_memory_task():
    """每30秒执行一次记忆构建"""
-    # print("\033[1;32m[记忆遗忘]\033[0m 开始遗忘记忆...")
-    # await hippocampus.operation_forget_topic(percentage=0.1)
-    # print("\033[1;32m[记忆遗忘]\033[0m 记忆遗忘完成")
+    print("\033[1;32m[记忆遗忘]\033[0m 开始遗忘记忆...")
+    await hippocampus.operation_forget_topic(percentage=0.1)
+    print("\033[1;32m[记忆遗忘]\033[0m 记忆遗忘完成")


@scheduler.scheduled_job("interval", seconds=global_config.build_memory_interval + 10, id="merge_memory")
--- a/src/plugins/chat/bot.py
+++ b/src/plugins/chat/bot.py
@@ -1,3 +1,4 @@
+import re
 import time
 from random import random

@@ -75,6 +76,14 @@ class ChatBot:
                logger.info(f"[过滤词识别]消息中含有{word}，filtered")
                return

+        # 正则表达式过滤
+        for pattern in global_config.ban_msgs_regex:
+            if re.search(pattern, message.raw_message):
+                logger.info(
+                    f"[{message.group_name}]{message.user_nickname}:{message.raw_message}")
+                logger.info(f"[正则表达式过滤]消息匹配到{pattern}，filtered")
+                return
+
        current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(message.time))

        # topic=await topic_identifier.identify_topic_llm(message.processed_plain_text)
@@ -129,7 +138,7 @@ class ChatBot:

            # 如果找不到思考消息，直接返回
            if not thinking_message:
-                logger.warning(f"未找到对应的思考消息，可能已超时被移除")
+                logger.warning("未找到对应的思考消息，可能已超时被移除")
                return

            # 记录开始思考的时间，避免从思考到回复的时间太久
@@ -178,7 +187,7 @@ class ChatBot:

                # 检查是否 <没有找到> emoji
                if emoji_raw != None:
-                    emoji_path, discription = emoji_raw
+                    emoji_path, description = emoji_raw

                    emoji_cq = CQCode.create_emoji_cq(emoji_path)

@@ -194,7 +203,7 @@ class ChatBot:
                        raw_message=emoji_cq,
                        plain_text=emoji_cq,
                        processed_plain_text=emoji_cq,
-                        detailed_plain_text=discription,
+                        detailed_plain_text=description,
                        user_nickname=global_config.BOT_NICKNAME,
                        group_name=message.group_name,
                        time=bot_response_time,
--- a/src/plugins/chat/config.py
+++ b/src/plugins/chat/config.py
@@ -1,6 +1,6 @@
 import os
 from dataclasses import dataclass, field
-from typing import Dict, Optional
+from typing import Dict, List, Optional

 import tomli
 from loguru import logger
@@ -12,10 +12,12 @@ from packaging.specifiers import SpecifierSet, InvalidSpecifier
@dataclass
 class BotConfig:
    """机器人配置类"""
+
    INNER_VERSION: Version = None

    BOT_QQ: Optional[int] = 1
    BOT_NICKNAME: Optional[str] = None
+    BOT_ALIAS_NAMES: List[str] = field(default_factory=list)  # 别名，可以通过这个叫它

    # 消息处理相关配置
    MIN_TEXT_LENGTH: int = 2  # 最小处理文本长度
@@ -43,6 +45,7 @@ class BotConfig:
    EMOJI_CHECK_PROMPT: str = "符合公序良俗"  # 表情包过滤要求

    ban_words = set()
+    ban_msgs_regex = set()

    max_response_length: int = 1024  # 最大回复长度

@@ -81,23 +84,25 @@ class BotConfig:
    PROMPT_PERSONALITY = [
        "曾经是一个学习地质的女大学生，现在学习心理学和脑科学，你会刷贴吧",
        "是一个女大学生，你有黑色头发，你会刷小红书",
-        "是一个女大学生，你会刷b站，对ACG文化感兴趣"
+        "是一个女大学生，你会刷b站，对ACG文化感兴趣",
    ]

-    PROMPT_SCHEDULE_GEN="一个曾经学习地质,现在学习心理学和脑科学的女大学生，喜欢刷qq，贴吧，知乎和小红书"
-    
-    PERSONALITY_1: float = 0.6 # 第一种人格概率
-    PERSONALITY_2: float = 0.3 # 第二种人格概率
-    PERSONALITY_3: float = 0.1 # 第三种人格概率
-    
-    memory_ban_words: list = field(default_factory=lambda: ['表情包', '图片', '回复', '聊天记录'])  # 添加新的配置项默认值
-    
+    PROMPT_SCHEDULE_GEN = "一个曾经学习地质,现在学习心理学和脑科学的女大学生，喜欢刷qq，贴吧，知乎和小红书"
+
+    PERSONALITY_1: float = 0.6  # 第一种人格概率
+    PERSONALITY_2: float = 0.3  # 第二种人格概率
+    PERSONALITY_3: float = 0.1  # 第三种人格概率
+
+    memory_ban_words: list = field(
+        default_factory=lambda: ["表情包", "图片", "回复", "聊天记录"]
+    )  # 添加新的配置项默认值
+
    @staticmethod
    def get_config_dir() -> str:
        """获取配置文件目录"""
        current_dir = os.path.dirname(os.path.abspath(__file__))
-        root_dir = os.path.abspath(os.path.join(current_dir, '..', '..', '..'))
-        config_dir = os.path.join(root_dir, 'config')
+        root_dir = os.path.abspath(os.path.join(current_dir, "..", "..", ".."))
+        config_dir = os.path.join(root_dir, "config")
        if not os.path.exists(config_dir):
            os.makedirs(config_dir)
        return config_dir
@@ -108,35 +113,32 @@ class BotConfig:
        Args:
            value[str]: 版本表达式(字符串)
        Returns:
-            SpecifierSet 
+            SpecifierSet
        """

        try:
            converted = SpecifierSet(value)
-        except InvalidSpecifier as e:
-            logger.error(
-                f"{value} 分类使用了错误的版本约束表达式\n",
-                "请阅读 https://semver.org/lang/zh-CN/ 修改代码"
-            )
+        except InvalidSpecifier:
+            logger.error(f"{value} 分类使用了错误的版本约束表达式\n", "请阅读 https://semver.org/lang/zh-CN/ 修改代码")
            exit(1)

        return converted

    @classmethod
    def get_config_version(cls, toml: dict) -> Version:
-        """提取配置文件的 SpecifierSet 版本数据 
+        """提取配置文件的 SpecifierSet 版本数据
        Args:
            toml[dict]: 输入的配置文件字典
        Returns:
-            Version 
+            Version
        """

-        if 'inner' in toml:
+        if "inner" in toml:
            try:
                config_version: str = toml["inner"]["version"]
            except KeyError as e:
-                logger.error(f"配置文件中 inner 段 不存在, 这是错误的配置文件")
-                raise KeyError(f"配置文件中 inner 段 不存在 {e}, 这是错误的配置文件")
+                logger.error("配置文件中 inner 段 不存在, 这是错误的配置文件")
+                raise KeyError(f"配置文件中 inner 段 不存在 {e}, 这是错误的配置文件") from e
        else:
            toml["inner"] = {"version": "0.0.0"}
            config_version = toml["inner"]["version"]
@@ -149,7 +151,7 @@ class BotConfig:
                "请阅读 https://semver.org/lang/zh-CN/ 修改配置，并参考本项目指定的模板进行修改\n"
                "本项目在不同的版本下有不同的模板，请注意识别"
            )
-            raise InvalidVersion("配置文件中 inner段 的 version 键是错误的版本描述\n")
+            raise InvalidVersion("配置文件中 inner段 的 version 键是错误的版本描述\n") from e

        return ver

@@ -159,26 +161,26 @@ class BotConfig:
        config = cls()

        def personality(parent: dict):
-            personality_config = parent['personality']
-            personality = personality_config.get('prompt_personality')
+            personality_config = parent["personality"]
+            personality = personality_config.get("prompt_personality")
            if len(personality) >= 2:
                logger.debug(f"载入自定义人格:{personality}")
-                config.PROMPT_PERSONALITY = personality_config.get('prompt_personality', config.PROMPT_PERSONALITY)
+                config.PROMPT_PERSONALITY = personality_config.get("prompt_personality", config.PROMPT_PERSONALITY)
            logger.info(f"载入自定义日程prompt:{personality_config.get('prompt_schedule', config.PROMPT_SCHEDULE_GEN)}")
-            config.PROMPT_SCHEDULE_GEN = personality_config.get('prompt_schedule', config.PROMPT_SCHEDULE_GEN)
+            config.PROMPT_SCHEDULE_GEN = personality_config.get("prompt_schedule", config.PROMPT_SCHEDULE_GEN)

            if config.INNER_VERSION in SpecifierSet(">=0.0.2"):
-                config.PERSONALITY_1 = personality_config.get('personality_1_probability', config.PERSONALITY_1)
-                config.PERSONALITY_2 = personality_config.get('personality_2_probability', config.PERSONALITY_2)
-                config.PERSONALITY_3 = personality_config.get('personality_3_probability', config.PERSONALITY_3)
+                config.PERSONALITY_1 = personality_config.get("personality_1_probability", config.PERSONALITY_1)
+                config.PERSONALITY_2 = personality_config.get("personality_2_probability", config.PERSONALITY_2)
+                config.PERSONALITY_3 = personality_config.get("personality_3_probability", config.PERSONALITY_3)

        def emoji(parent: dict):
            emoji_config = parent["emoji"]
            config.EMOJI_CHECK_INTERVAL = emoji_config.get("check_interval", config.EMOJI_CHECK_INTERVAL)
            config.EMOJI_REGISTER_INTERVAL = emoji_config.get("register_interval", config.EMOJI_REGISTER_INTERVAL)
-            config.EMOJI_CHECK_PROMPT = emoji_config.get('check_prompt', config.EMOJI_CHECK_PROMPT)
-            config.EMOJI_SAVE = emoji_config.get('auto_save', config.EMOJI_SAVE)
-            config.EMOJI_CHECK = emoji_config.get('enable_check', config.EMOJI_CHECK)
+            config.EMOJI_CHECK_PROMPT = emoji_config.get("check_prompt", config.EMOJI_CHECK_PROMPT)
+            config.EMOJI_SAVE = emoji_config.get("auto_save", config.EMOJI_SAVE)
+            config.EMOJI_CHECK = emoji_config.get("enable_check", config.EMOJI_CHECK)

        def cq_code(parent: dict):
            cq_code_config = parent["cq_code"]
@@ -191,12 +193,16 @@ class BotConfig:
            config.BOT_QQ = int(bot_qq)
            config.BOT_NICKNAME = bot_config.get("nickname", config.BOT_NICKNAME)

+            if config.INNER_VERSION in SpecifierSet(">=0.0.5"):
+                config.BOT_ALIAS_NAMES = bot_config.get("alias_names", config.BOT_ALIAS_NAMES)
+
        def response(parent: dict):
            response_config = parent["response"]
            config.MODEL_R1_PROBABILITY = response_config.get("model_r1_probability", config.MODEL_R1_PROBABILITY)
            config.MODEL_V3_PROBABILITY = response_config.get("model_v3_probability", config.MODEL_V3_PROBABILITY)
-            config.MODEL_R1_DISTILL_PROBABILITY = response_config.get("model_r1_distill_probability",
-                                                                      config.MODEL_R1_DISTILL_PROBABILITY)
+            config.MODEL_R1_DISTILL_PROBABILITY = response_config.get(
+                "model_r1_distill_probability", config.MODEL_R1_DISTILL_PROBABILITY
+            )
            config.max_response_length = response_config.get("max_response_length", config.max_response_length)

        def model(parent: dict):
@@ -213,7 +219,7 @@ class BotConfig:
                "llm_emotion_judge",
                "vlm",
                "embedding",
-                "moderation"
+                "moderation",
            ]

            for item in config_list:
@@ -222,13 +228,7 @@ class BotConfig:

                    # base_url 的例子： SILICONFLOW_BASE_URL
                    # key 的例子： SILICONFLOW_KEY
-                    cfg_target = {
-                        "name": "",
-                        "base_url": "",
-                        "key": "",
-                        "pri_in": 0,
-                        "pri_out": 0
-                    }
+                    cfg_target = {"name": "", "base_url": "", "key": "", "pri_in": 0, "pri_out": 0}

                    if config.INNER_VERSION in SpecifierSet("<=0.0.0"):
                        cfg_target = cfg_item
@@ -247,7 +247,7 @@ class BotConfig:
                                    cfg_target[i] = cfg_item[i]
                                except KeyError as e:
                                    logger.error(f"{item} 中的必要字段不存在，请检查")
-                                    raise KeyError(f"{item} 中的必要字段 {e} 不存在，请检查")
+                                    raise KeyError(f"{item} 中的必要字段 {e} 不存在，请检查") from e

                        provider = cfg_item.get("provider")
                        if provider is None:
@@ -272,17 +272,22 @@ class BotConfig:

            if config.INNER_VERSION in SpecifierSet(">=0.0.2"):
                config.thinking_timeout = msg_config.get("thinking_timeout", config.thinking_timeout)
-                config.response_willing_amplifier = msg_config.get("response_willing_amplifier",
-                                                                   config.response_willing_amplifier)
-                config.response_interested_rate_amplifier = msg_config.get("response_interested_rate_amplifier",
-                                                                           config.response_interested_rate_amplifier)
+                config.response_willing_amplifier = msg_config.get(
+                    "response_willing_amplifier", config.response_willing_amplifier
+                )
+                config.response_interested_rate_amplifier = msg_config.get(
+                    "response_interested_rate_amplifier", config.response_interested_rate_amplifier
+                )
                config.down_frequency_rate = msg_config.get("down_frequency_rate", config.down_frequency_rate)
+            
+            if config.INNER_VERSION in SpecifierSet(">=0.0.6"):
+                config.ban_msgs_regex = msg_config.get("ban_msgs_regex", config.ban_msgs_regex)

        def memory(parent: dict):
            memory_config = parent["memory"]
            config.build_memory_interval = memory_config.get("build_memory_interval", config.build_memory_interval)
            config.forget_memory_interval = memory_config.get("forget_memory_interval", config.forget_memory_interval)
-            
+
            # 在版本 >= 0.0.4 时才处理新增的配置项
            if config.INNER_VERSION in SpecifierSet(">=0.0.4"):
                config.memory_ban_words = set(memory_config.get("memory_ban_words", []))
@@ -303,10 +308,12 @@ class BotConfig:
            config.chinese_typo_enable = chinese_typo_config.get("enable", config.chinese_typo_enable)
            config.chinese_typo_error_rate = chinese_typo_config.get("error_rate", config.chinese_typo_error_rate)
            config.chinese_typo_min_freq = chinese_typo_config.get("min_freq", config.chinese_typo_min_freq)
-            config.chinese_typo_tone_error_rate = chinese_typo_config.get("tone_error_rate",
-                                                                          config.chinese_typo_tone_error_rate)
-            config.chinese_typo_word_replace_rate = chinese_typo_config.get("word_replace_rate",
-                                                                            config.chinese_typo_word_replace_rate)
+            config.chinese_typo_tone_error_rate = chinese_typo_config.get(
+                "tone_error_rate", config.chinese_typo_tone_error_rate
+            )
+            config.chinese_typo_word_replace_rate = chinese_typo_config.get(
+                "word_replace_rate", config.chinese_typo_word_replace_rate
+            )

        def groups(parent: dict):
            groups_config = parent["groups"]
@@ -325,61 +332,19 @@ class BotConfig:
        # 例如："notice": "personality 将在 1.3.2 后被移除"，那么在有效版本中的用户就会虽然可以
        # 正常执行程序，但是会看到这条自定义提示
        include_configs = {
-            "personality": {
-                "func": personality,
-                "support": ">=0.0.0"
-            },
-            "emoji": {
-                "func": emoji,
-                "support": ">=0.0.0"
-            },
-            "cq_code": {
-                "func": cq_code,
-                "support": ">=0.0.0"
-            },
-            "bot": {
-                "func": bot,
-                "support": ">=0.0.0"
-            },
-            "response": {
-                "func": response,
-                "support": ">=0.0.0"
-            },
-            "model": {
-                "func": model,
-                "support": ">=0.0.0"
-            },
-            "message": {
-                "func": message,
-                "support": ">=0.0.0"
-            },
-            "memory": {
-                "func": memory,
-                "support": ">=0.0.0",
-                "necessary": False
-            },
-            "mood": {
-                "func": mood,
-                "support": ">=0.0.0"
-            },
-            "keywords_reaction": {
-                "func": keywords_reaction,
-                "support": ">=0.0.2",
-                "necessary": False
-            },
-            "chinese_typo": {
-                "func": chinese_typo,
-                "support": ">=0.0.3",
-                "necessary": False
-            },
-            "groups": {
-                "func": groups,
-                "support": ">=0.0.0"
-            },
-            "others": {
-                "func": others,
-                "support": ">=0.0.0"
-            }
+            "personality": {"func": personality, "support": ">=0.0.0"},
+            "emoji": {"func": emoji, "support": ">=0.0.0"},
+            "cq_code": {"func": cq_code, "support": ">=0.0.0"},
+            "bot": {"func": bot, "support": ">=0.0.0"},
+            "response": {"func": response, "support": ">=0.0.0"},
+            "model": {"func": model, "support": ">=0.0.0"},
+            "message": {"func": message, "support": ">=0.0.0"},
+            "memory": {"func": memory, "support": ">=0.0.0", "necessary": False},
+            "mood": {"func": mood, "support": ">=0.0.0"},
+            "keywords_reaction": {"func": keywords_reaction, "support": ">=0.0.2", "necessary": False},
+            "chinese_typo": {"func": chinese_typo, "support": ">=0.0.3", "necessary": False},
+            "groups": {"func": groups, "support": ">=0.0.0"},
+            "others": {"func": others, "support": ">=0.0.0"},
        }

        # 原地修改，将 字符串版本表达式 转换成 版本对象
@@ -391,7 +356,7 @@ class BotConfig:
            with open(config_path, "rb") as f:
                try:
                    toml_dict = tomli.load(f)
-                except(tomli.TOMLDecodeError) as e:
+                except tomli.TOMLDecodeError as e:
                    logger.critical(f"配置文件bot_config.toml填写有误，请检查第{e.lineno}行第{e.colno}处：{e.msg}")
                    exit(1)

@@ -406,7 +371,7 @@ class BotConfig:
                        # 检查配置文件版本是否在支持范围内
                        if config.INNER_VERSION in group_specifierset:
                            # 如果版本在支持范围内，检查是否存在通知
-                            if 'notice' in include_configs[key]:
+                            if "notice" in include_configs[key]:
                                logger.warning(include_configs[key]["notice"])

                            include_configs[key]["func"](toml_dict)
@@ -420,7 +385,7 @@ class BotConfig:
                            raise InvalidVersion(f"当前程序仅支持以下版本范围: {group_specifierset}")

                    # 如果 necessary 项目存在，而且显式声明是 False，进入特殊处理
-                    elif "necessary" in include_configs[key] and include_configs[key].get("necessary") == False:
+                    elif "necessary" in include_configs[key] and include_configs[key].get("necessary") is False:
                        # 通过 pass 处理的项虽然直接忽略也是可以的，但是为了不增加理解困难，依然需要在这里显式处理
                        if key == "keywords_reaction":
                            pass
--- a/src/plugins/chat/cq_code.py
+++ b/src/plugins/chat/cq_code.py
@@ -1,6 +1,5 @@
 import base64
 import html
-import os
 import time
 from dataclasses import dataclass
 from typing import Dict, Optional
@@ -17,7 +16,7 @@ from urllib3.util import create_urllib3_context
 from ..models.utils_model import LLM_request
 from .config import global_config
 from .mapper import emojimapper
-from .utils_image import storage_emoji, storage_image
+from .utils_image import image_path_to_base64, storage_emoji, storage_image
 from .utils_user import get_user_nickname

 driver = get_driver()
@@ -155,8 +154,8 @@ class CQCode:
                    logger.error(f"最终请求失败: {str(e)}")
                time.sleep(1.5 ** retry)  # 指数退避

-            except Exception as e:
-                logger.exception(f"[未知错误]")
+            except Exception:
+                logger.exception("[未知错误]")
                return None

        return None
@@ -281,7 +280,7 @@ class CQCode:
            logger.debug(f"合并后的转发消息: {combined_messages}")
            return f"[转发消息:\n{combined_messages}]"

-        except Exception as e:
+        except Exception:
            logger.exception("处理转发消息失败")
            return '[转发消息]'

@@ -328,15 +327,10 @@ class CQCode:
        Returns:
            表情包CQ码字符串
        """
-        # 确保使用绝对路径
-        abs_path = os.path.abspath(file_path)
-        # 转义特殊字符
-        escaped_path = abs_path.replace('&', '&amp;') \
-            .replace('[', '&#91;') \
-            .replace(']', '&#93;') \
-            .replace(',', '&#44;')
+        base64_content = image_path_to_base64(file_path)
+
        # 生成CQ码，设置sub_type=1表示这是表情包
-        return f"[CQ:image,file=file:///{escaped_path},sub_type=1]"
+        return f"[CQ:image,file=base64://{base64_content},sub_type=1]"


 class CQCode_tool:
--- a/src/plugins/chat/emoji_manager.py
+++ b/src/plugins/chat/emoji_manager.py
@@ -33,7 +33,7 @@ class EmojiManager:
        self.db = Database.get_instance()
        self._scan_task = None
        self.vlm = LLM_request(model=global_config.vlm, temperature=0.3, max_tokens=1000)
-        self.llm_emotion_judge = LLM_request(model=global_config.llm_normal_minor, max_tokens=60,
+        self.llm_emotion_judge = LLM_request(model=global_config.llm_emotion_judge, max_tokens=60,
                                             temperature=0.8)  # 更高的温度，更少的token（后续可以根据情绪来调整温度）


@@ -51,8 +51,8 @@ class EmojiManager:
                self._initialized = True
                # 启动时执行一次完整性检查
                self.check_emoji_file_integrity()
-            except Exception as e:
-                logger.exception(f"初始化表情管理器失败")
+            except Exception:
+                logger.exception("初始化表情管理器失败")

    def _ensure_db(self):
        """确保数据库已初始化"""
@@ -87,8 +87,8 @@ class EmojiManager:
                {'_id': emoji_id},
                {'$inc': {'usage_count': 1}}
            )
-        except Exception as e:
-            logger.exception(f"记录表情使用失败")
+        except Exception:
+            logger.exception("记录表情使用失败")

    async def get_emoji_for_text(self, text: str) -> Optional[str]:
        """根据文本内容获取相关表情包
@@ -117,7 +117,7 @@ class EmojiManager:

            try:
                # 获取所有表情包
-                all_emojis = list(self.db.db.emoji.find({}, {'_id': 1, 'path': 1, 'embedding': 1, 'discription': 1}))
+                all_emojis = list(self.db.db.emoji.find({}, {'_id': 1, 'path': 1, 'embedding': 1, 'description': 1}))

                if not all_emojis:
                    logger.warning("数据库中没有任何表情包")
@@ -160,9 +160,9 @@ class EmojiManager:
                        {'$inc': {'usage_count': 1}}
                    )
                    logger.success(
-                        f"找到匹配的表情包: {selected_emoji.get('discription', '无描述')} (相似度: {similarity:.4f})")
+                        f"找到匹配的表情包: {selected_emoji.get('description', '无描述')} (相似度: {similarity:.4f})")
                    # 稍微改一下文本描述，不然容易产生幻觉，描述已经包含 表情包 了
-                    return selected_emoji['path'], "[ %s ]" % selected_emoji.get('discription', '无描述')
+                    return selected_emoji['path'], "[ %s ]" % selected_emoji.get('description', '无描述')

            except Exception as search_error:
                logger.error(f"搜索表情包失败: {str(search_error)}")
@@ -174,7 +174,7 @@ class EmojiManager:
            logger.error(f"获取表情包失败: {str(e)}")
            return None

-    async def _get_emoji_discription(self, image_base64: str) -> str:
+    async def _get_emoji_description(self, image_base64: str) -> str:
        """获取表情包的标签"""
        try:
            prompt = '这是一个表情包，使用中文简洁的描述一下表情包的内容和表情包所表达的情感'
@@ -203,7 +203,7 @@ class EmojiManager:
        try:
            prompt = f'这是{global_config.BOT_NICKNAME}将要发送的消息内容:\n{text}\n若要为其配上表情包，请你输出这个表情包应该表达怎样的情感，应该给人什么样的感觉，不要太简洁也不要太长，注意不要输出任何对消息内容的分析内容，只输出\"一种什么样的感觉\"中间的形容词部分。'

-            content, _ = await self.llm_emotion_judge.generate_response_async(prompt)
+            content, _ = await self.llm_emotion_judge.generate_response_async(prompt,temperature=1.5)
            logger.info(f"输出描述: {content}")
            return content

@@ -236,36 +236,36 @@ class EmojiManager:
                    continue

                # 获取表情包的描述
-                discription = await self._get_emoji_discription(image_base64)
+                description = await self._get_emoji_description(image_base64)
                if global_config.EMOJI_CHECK:
                    check = await self._check_emoji(image_base64)
                    if '是' not in check:
                        os.remove(image_path)
-                        logger.info(f"描述: {discription}")
+                        logger.info(f"描述: {description}")
                        logger.info(f"其不满足过滤规则，被剔除 {check}")
                        continue
                    logger.info(f"check通过 {check}")
                
-                if discription is not None:
-                    embedding = await get_embedding(discription)
+                if description is not None:
+                    embedding = await get_embedding(description)
                    # 准备数据库记录
                    emoji_record = {
                        'filename': filename,
                        'path': image_path,
                        'embedding': embedding,
-                        'discription': discription,
+                        'description': description,
                        'timestamp': int(time.time())
                    }

                    # 保存到数据库
                    self.db.db['emoji'].insert_one(emoji_record)
                    logger.success(f"注册新表情包: {filename}")
-                    logger.info(f"描述: {discription}")
+                    logger.info(f"描述: {description}")
                else:
                    logger.warning(f"跳过表情包: {filename}")

-        except Exception as e:
-            logger.exception(f"扫描表情包失败")
+        except Exception:
+            logger.exception("扫描表情包失败")

    async def _periodic_scan(self, interval_MINS: int = 10):
        """定期扫描新表情包"""
--- a/src/plugins/chat/llm_generator.py
+++ b/src/plugins/chat/llm_generator.py
@@ -94,7 +94,7 @@ class ResponseGenerator:
        try:
            content, reasoning_content = await model.generate_response(prompt)
        except Exception:
-            logger.exception(f"生成回复时出错")
+            logger.exception("生成回复时出错")
            return None
        
        # 保存到数据库
@@ -146,7 +146,7 @@ class ResponseGenerator:
                return ["neutral"]
            
        except Exception:
-            logger.exception(f"获取情感标签时出错")
+            logger.exception("获取情感标签时出错")
            return ["neutral"]
    
    async def _process_response(self, content: str) -> Tuple[List[str], List[str]]:
--- a/src/plugins/chat/message_sender.py
+++ b/src/plugins/chat/message_sender.py
@@ -61,7 +61,7 @@ class Message_Sender:
                auto_escape=auto_escape
            )
            logger.debug(f"发送消息{message}成功")
-        except Exception as e:
+        except Exception:
            logger.exception(f"发送消息{message}失败")


@@ -120,7 +120,7 @@ class MessageContainer:
                return True
            return False
        except Exception:
-            logger.exception(f"移除消息时发生错误")
+            logger.exception("移除消息时发生错误")
            return False

    def has_messages(self) -> bool:
@@ -214,7 +214,7 @@ class MessageManager:
                        if not container.remove_message(msg):
                            logger.warning("尝试删除不存在的消息")
                    except Exception:
-                        logger.exception(f"处理超时消息时发生错误")
+                        logger.exception("处理超时消息时发生错误")
                        continue

    async def start_processor(self):
--- a/src/plugins/chat/prompt_builder.py
+++ b/src/plugins/chat/prompt_builder.py
@@ -131,18 +131,19 @@ class PromptBuilder:
        probability_1 = global_config.PERSONALITY_1
        probability_2 = global_config.PERSONALITY_2
        probability_3 = global_config.PERSONALITY_3
-        prompt_personality = ''
+        
+        prompt_personality = f'{activate_prompt}你的网名叫{global_config.BOT_NICKNAME}，你还有很多别名:{"/".join(global_config.BOT_ALIAS_NAMES)}，'
        personality_choice = random.random()
        if personality_choice < probability_1:  # 第一种人格
-            prompt_personality = f'''{activate_prompt}你的网名叫{global_config.BOT_NICKNAME}，{personality[0]}, 你正在浏览qq群,{promt_info_prompt},
+            prompt_personality += f'''{personality[0]}, 你正在浏览qq群,{promt_info_prompt},
            现在请你给出日常且口语化的回复，平淡一些，尽量简短一些。{keywords_reaction_prompt}
            请注意把握群里的聊天内容，不要刻意突出自身学科背景，不要回复的太有条理，可以有个性。'''
        elif personality_choice < probability_1 + probability_2:  # 第二种人格
-            prompt_personality = f'''{activate_prompt}你的网名叫{global_config.BOT_NICKNAME}，{personality[1]}, 你正在浏览qq群，{promt_info_prompt},
+            prompt_personality += f'''{personality[1]}, 你正在浏览qq群，{promt_info_prompt},
            现在请你给出日常且口语化的回复，请表现你自己的见解，不要一昧迎合，尽量简短一些。{keywords_reaction_prompt}
            请你表达自己的见解和观点。可以有个性。'''
        else:  # 第三种人格
-            prompt_personality = f'''{activate_prompt}你的网名叫{global_config.BOT_NICKNAME}，{personality[2]}, 你正在浏览qq群，{promt_info_prompt},
+            prompt_personality += f'''{personality[2]}, 你正在浏览qq群，{promt_info_prompt},
            现在请你给出日常且口语化的回复，请表现你自己的见解，不要一昧迎合，尽量简短一些。{keywords_reaction_prompt}
            请你表达自己的见解和观点。可以有个性。'''

--- a/src/plugins/chat/storage.py
+++ b/src/plugins/chat/storage.py
@@ -45,6 +45,6 @@ class MessageStorage:

            self.db.db.messages.insert_one(message_data)
        except Exception:
-            logger.exception(f"存储消息失败")
+            logger.exception("存储消息失败")

 # 如果需要其他存储相关的函数，可以在这里添加
--- a/src/plugins/chat/utils.py
+++ b/src/plugins/chat/utils.py
@@ -53,19 +53,13 @@ def db_message_to_str(message_dict: Dict) -> str:
    return result


-def is_mentioned_bot_in_message(message: Message) -> bool:
-    """检查消息是否提到了机器人"""
-    keywords = [global_config.BOT_NICKNAME]
-    for keyword in keywords:
-        if keyword in message.processed_plain_text:
-            return True
-    return False
-
-
 def is_mentioned_bot_in_txt(message: str) -> bool:
    """检查消息是否提到了机器人"""
-    keywords = [global_config.BOT_NICKNAME]
-    for keyword in keywords:
+    if global_config.BOT_NICKNAME is None:
+        return True
+    if global_config.BOT_NICKNAME in message:
+        return True
+    for keyword in global_config.BOT_ALIAS_NAMES:
        if keyword in message:
            return True
    return False