调整对应的调用

src/chat/emoji_system/emoji_manager.py

@@ -8,15 +8,15 @@ import traceback
 import io
 import re
 import binascii
+
 from typing import Optional, Tuple, List, Any
 from PIL import Image
 from rich.traceback import install
 
-
 from src.common.database.database_model import Emoji
 from src.common.database.database import db as peewee_db
 from src.common.logger import get_logger
-from src.config.config import global_config
+from src.config.config import global_config, model_config
 from src.chat.utils.utils_image import image_path_to_base64, get_image_manager
 from src.llm_models.utils_model import LLMRequest
 
@@ -379,9 +379,9 @@ class EmojiManager:
 
         self._scan_task = None
 
-        self.vlm = LLMRequest(model=global_config.model.vlm, temperature=0.3, max_tokens=1000, request_type="emoji")
+        self.vlm = LLMRequest(model_set=model_config.model_task_config.vlm, request_type="emoji")
         self.llm_emotion_judge = LLMRequest(
-            model=global_config.model.utils, max_tokens=600, request_type="emoji"
+            model_set=model_config.model_task_config.utils, request_type="emoji"
         )  # 更高的温度，更少的token（后续可以根据情绪来调整温度）
 
         self.emoji_num = 0
@@ -492,6 +492,7 @@ class EmojiManager:
             return None
 
     def _levenshtein_distance(self, s1: str, s2: str) -> int:
+        # sourcery skip: simplify-empty-collection-comparison, simplify-len-comparison, simplify-str-len-comparison
         """计算两个字符串的编辑距离
 
         Args:
@@ -629,11 +630,11 @@ class EmojiManager:
                         if success:
                             # 注册成功则跳出循环
                             break
-                        else:
-                            # 注册失败则删除对应文件
-                            file_path = os.path.join(EMOJI_DIR, filename)
-                            os.remove(file_path)
-                            logger.warning(f"[清理] 删除注册失败的表情包文件: {filename}")
+
+                        # 注册失败则删除对应文件
+                        file_path = os.path.join(EMOJI_DIR, filename)
+                        os.remove(file_path)
+                        logger.warning(f"[清理] 删除注册失败的表情包文件: {filename}")
                 except Exception as e:
                     logger.error(f"[错误] 扫描表情包目录失败: {str(e)}")
 
@@ -694,6 +695,7 @@ class EmojiManager:
             return []
 
     async def get_emoji_from_manager(self, emoji_hash: str) -> Optional["MaiEmoji"]:
+        # sourcery skip: use-next
         """从内存中的 emoji_objects 列表获取表情包
 
         参数:
@@ -709,10 +711,10 @@ class EmojiManager:
 
     async def get_emoji_description_by_hash(self, emoji_hash: str) -> Optional[str]:
         """根据哈希值获取已注册表情包的描述
-        
+
         Args:
             emoji_hash: 表情包的哈希值
-            
+
         Returns:
             Optional[str]: 表情包描述，如果未找到则返回None
         """
@@ -722,7 +724,7 @@ class EmojiManager:
             if emoji and emoji.description:
                 logger.info(f"[缓存命中] 从内存获取表情包描述: {emoji.description[:50]}...")
                 return emoji.description
-            
+
             # 如果内存中没有，从数据库查找
             self._ensure_db()
             try:
@@ -732,9 +734,9 @@ class EmojiManager:
                     return emoji_record.description
             except Exception as e:
                 logger.error(f"从数据库查询表情包描述时出错: {e}")
-            
+
             return None
-            
+
         except Exception as e:
             logger.error(f"获取表情包描述失败 (Hash: {emoji_hash}): {str(e)}")
             return None
@@ -779,6 +781,7 @@ class EmojiManager:
             return False
 
     async def replace_a_emoji(self, new_emoji: "MaiEmoji") -> bool:
+        # sourcery skip: use-getitem-for-re-match-groups
         """替换一个表情包
 
         Args:
@@ -820,7 +823,7 @@ class EmojiManager:
             )
 
             # 调用大模型进行决策
-            decision, _ = await self.llm_emotion_judge.generate_response_async(prompt, temperature=0.8)
+            decision, _ = await self.llm_emotion_judge.generate_response_async(prompt, temperature=0.8, max_tokens=600)
             logger.info(f"[决策] 结果: {decision}")
 
             # 解析决策结果
@@ -828,9 +831,7 @@ class EmojiManager:
                 logger.info("[决策] 不删除任何表情包")
                 return False
 
-            # 尝试从决策中提取表情包编号
-            match = re.search(r"删除编号(\d+)", decision)
-            if match:
+            if match := re.search(r"删除编号(\d+)", decision):
                 emoji_index = int(match.group(1)) - 1  # 转换为0-based索引
 
                 # 检查索引是否有效
@@ -889,6 +890,7 @@ class EmojiManager:
             existing_description = None
             try:
                 from src.common.database.database_model import Images
+
                 existing_image = Images.get_or_none((Images.emoji_hash == image_hash) & (Images.type == "emoji"))
                 if existing_image and existing_image.description:
                     existing_description = existing_image.description
@@ -902,15 +904,21 @@ class EmojiManager:
                 logger.info("[优化] 复用已有的详细描述，跳过VLM调用")
             else:
                 logger.info("[VLM分析] 生成新的详细描述")
-                if image_format == "gif" or image_format == "GIF":
+                if image_format in ["gif", "GIF"]:
                     image_base64 = get_image_manager().transform_gif(image_base64)  # type: ignore
                     if not image_base64:
                         raise RuntimeError("GIF表情包转换失败")
                     prompt = "这是一个动态图表情包，每一张图代表了动态图的某一帧，黑色背景代表透明，描述一下表情包表达的情感和内容，描述细节，从互联网梗,meme的角度去分析"
-                    description, _ = await self.vlm.generate_response_for_image(prompt, image_base64, "jpg")
+                    description, _ = await self.vlm.generate_response_for_image(
+                        prompt, image_base64, "jpg", temperature=0.3, max_tokens=1000
+                    )
                 else:
-                    prompt = "这是一个表情包，请详细描述一下表情包所表达的情感和内容，描述细节，从互联网梗,meme的角度去分析"
-                    description, _ = await self.vlm.generate_response_for_image(prompt, image_base64, image_format)
+                    prompt = (
+                        "这是一个表情包，请详细描述一下表情包所表达的情感和内容，描述细节，从互联网梗,meme的角度去分析"
+                    )
+                    description, _ = await self.vlm.generate_response_for_image(
+                        prompt, image_base64, image_format, temperature=0.3, max_tokens=1000
+                    )
 
             # 审核表情包
             if global_config.emoji.content_filtration:
@@ -922,7 +930,9 @@ class EmojiManager:
                     4. 不要出现5个以上文字
                     请回答这个表情包是否满足上述要求，是则回答是，否则回答否，不要出现任何其他内容
                 '''
-                content, _ = await self.vlm.generate_response_for_image(prompt, image_base64, image_format)
+                content, _ = await self.vlm.generate_response_for_image(
+                    prompt, image_base64, image_format, temperature=0.3, max_tokens=1000
+                )
                 if content == "否":
                     return "", []
 
@@ -933,7 +943,9 @@ class EmojiManager:
             你可以关注其幽默和讽刺意味，动用贴吧，微博，小红书的知识，必须从互联网梗,meme的角度去分析
             请直接输出描述，不要出现任何其他内容，如果有多个描述，可以用逗号分隔
             """
-            emotions_text, _ = await self.llm_emotion_judge.generate_response_async(emotion_prompt, temperature=0.7)
+            emotions_text, _ = await self.llm_emotion_judge.generate_response_async(
+                emotion_prompt, temperature=0.7, max_tokens=600
+            )
 
             # 处理情感列表
             emotions = [e.strip() for e in emotions_text.split(",") if e.strip()]

src/chat/express/expression_learner.py

@@ -7,12 +7,12 @@ from datetime import datetime
 from typing import List, Dict, Optional, Any, Tuple
 
 from src.common.logger import get_logger
+from src.common.database.database_model import Expression
 from src.llm_models.utils_model import LLMRequest
-from src.config.config import global_config
+from src.config.config import model_config
 from src.chat.utils.chat_message_builder import get_raw_msg_by_timestamp_random, build_anonymous_messages
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
 from src.chat.message_receive.chat_stream import get_chat_manager
-from src.common.database.database_model import Expression
 
 
 MAX_EXPRESSION_COUNT = 300
@@ -80,11 +80,8 @@ def init_prompt() -> None:
 
 class ExpressionLearner:
     def __init__(self) -> None:
-        # TODO: API-Adapter修改标记
         self.express_learn_model: LLMRequest = LLMRequest(
-            model=global_config.model.replyer_1,
-            temperature=0.3,
-            request_type="expressor.learner",
+            model_set=model_config.model_task_config.replyer_1, request_type="expressor.learner"
         )
         self.llm_model = None
         self._ensure_expression_directories()
@@ -101,7 +98,7 @@ class ExpressionLearner:
             os.path.join(base_dir, "learnt_style"),
             os.path.join(base_dir, "learnt_grammar"),
         ]
-        
+
         for directory in directories_to_create:
             try:
                 os.makedirs(directory, exist_ok=True)
@@ -116,7 +113,7 @@ class ExpressionLearner:
         """
         base_dir = os.path.join("data", "expression")
         done_flag = os.path.join(base_dir, "done.done")
-        
+
         # 确保基础目录存在
         try:
             os.makedirs(base_dir, exist_ok=True)
@@ -124,28 +121,28 @@ class ExpressionLearner:
         except Exception as e:
             logger.error(f"创建表达方式目录失败: {e}")
             return
-        
+
         if os.path.exists(done_flag):
             logger.info("表达方式JSON已迁移，无需重复迁移。")
             return
-            
+
         logger.info("开始迁移表达方式JSON到数据库...")
         migrated_count = 0
-        
+
         for type in ["learnt_style", "learnt_grammar"]:
             type_str = "style" if type == "learnt_style" else "grammar"
             type_dir = os.path.join(base_dir, type)
             if not os.path.exists(type_dir):
                 logger.debug(f"目录不存在，跳过: {type_dir}")
                 continue
-                
+
             try:
                 chat_ids = os.listdir(type_dir)
                 logger.debug(f"在 {type_dir} 中找到 {len(chat_ids)} 个聊天ID目录")
             except Exception as e:
                 logger.error(f"读取目录失败 {type_dir}: {e}")
                 continue
-                
+
             for chat_id in chat_ids:
                 expr_file = os.path.join(type_dir, chat_id, "expressions.json")
                 if not os.path.exists(expr_file):
@@ -153,24 +150,24 @@ class ExpressionLearner:
                 try:
                     with open(expr_file, "r", encoding="utf-8") as f:
                         expressions = json.load(f)
-                    
+
                     if not isinstance(expressions, list):
                         logger.warning(f"表达方式文件格式错误，跳过: {expr_file}")
                         continue
-                        
+
                     for expr in expressions:
                         if not isinstance(expr, dict):
                             continue
-                            
+
                         situation = expr.get("situation")
                         style_val = expr.get("style")
                         count = expr.get("count", 1)
                         last_active_time = expr.get("last_active_time", time.time())
-                        
+
                         if not situation or not style_val:
                             logger.warning(f"表达方式缺少必要字段，跳过: {expr}")
                             continue
-                        
+
                         # 查重：同chat_id+type+situation+style
                         from src.common.database.database_model import Expression
 
@@ -201,7 +198,7 @@ class ExpressionLearner:
                     logger.error(f"JSON解析失败 {expr_file}: {e}")
                 except Exception as e:
                     logger.error(f"迁移表达方式 {expr_file} 失败: {e}")
-        
+
         # 标记迁移完成
         try:
             # 确保done.done文件的父目录存在
@@ -209,7 +206,7 @@ class ExpressionLearner:
             if not os.path.exists(done_parent_dir):
                 os.makedirs(done_parent_dir, exist_ok=True)
                 logger.debug(f"为done.done创建父目录: {done_parent_dir}")
-            
+
             with open(done_flag, "w", encoding="utf-8") as f:
                 f.write("done\n")
             logger.info(f"表达方式JSON迁移已完成，共迁移 {migrated_count} 个表达方式，已写入done.done标记文件")
@@ -229,13 +226,13 @@ class ExpressionLearner:
             # 查找所有create_date为空的表达方式
             old_expressions = Expression.select().where(Expression.create_date.is_null())
             updated_count = 0
-            
+
             for expr in old_expressions:
                 # 使用last_active_time作为create_date
                 expr.create_date = expr.last_active_time
                 expr.save()
                 updated_count += 1
-            
+
             if updated_count > 0:
                 logger.info(f"已为 {updated_count} 个老的表达方式设置创建日期")
         except Exception as e:
@@ -287,25 +284,29 @@ class ExpressionLearner:
         获取指定chat_id的表达方式创建信息，按创建日期排序
         """
         try:
-            expressions = (Expression.select()
-                         .where(Expression.chat_id == chat_id)
-                         .order_by(Expression.create_date.desc())
-                         .limit(limit))
-            
+            expressions = (
+                Expression.select()
+                .where(Expression.chat_id == chat_id)
+                .order_by(Expression.create_date.desc())
+                .limit(limit)
+            )
+
             result = []
             for expr in expressions:
                 create_date = expr.create_date if expr.create_date is not None else expr.last_active_time
-                result.append({
-                    "situation": expr.situation,
-                    "style": expr.style,
-                    "type": expr.type,
-                    "count": expr.count,
-                    "create_date": create_date,
-                    "create_date_formatted": format_create_date(create_date),
-                    "last_active_time": expr.last_active_time,
-                    "last_active_formatted": format_create_date(expr.last_active_time),
-                })
-            
+                result.append(
+                    {
+                        "situation": expr.situation,
+                        "style": expr.style,
+                        "type": expr.type,
+                        "count": expr.count,
+                        "create_date": create_date,
+                        "create_date_formatted": format_create_date(create_date),
+                        "last_active_time": expr.last_active_time,
+                        "last_active_formatted": format_create_date(expr.last_active_time),
+                    }
+                )
+
             return result
         except Exception as e:
             logger.error(f"获取表达方式创建信息失败: {e}")
@@ -355,19 +356,19 @@ class ExpressionLearner:
         try:
             # 获取所有表达方式
             all_expressions = Expression.select()
-            
+
             updated_count = 0
             deleted_count = 0
-            
+
             for expr in all_expressions:
                 # 计算时间差
                 last_active = expr.last_active_time
                 time_diff_days = (current_time - last_active) / (24 * 3600)  # 转换为天
-                
+
                 # 计算衰减值
                 decay_value = self.calculate_decay_factor(time_diff_days)
                 new_count = max(0.01, expr.count - decay_value)
-                
+
                 if new_count <= 0.01:
                     # 如果count太小，删除这个表达方式
                     expr.delete_instance()
@@ -377,10 +378,10 @@ class ExpressionLearner:
                     expr.count = new_count
                     expr.save()
                     updated_count += 1
-            
+
             if updated_count > 0 or deleted_count > 0:
                 logger.info(f"全局衰减完成：更新了 {updated_count} 个表达方式，删除了 {deleted_count} 个表达方式")
-                
+
         except Exception as e:
             logger.error(f"数据库全局衰减失败: {e}")
 
@@ -527,7 +528,7 @@ class ExpressionLearner:
         logger.debug(f"学习{type_str}的prompt: {prompt}")
 
         try:
-            response, _ = await self.express_learn_model.generate_response_async(prompt)
+            response, _ = await self.express_learn_model.generate_response_async(prompt, temperature=0.3)
         except Exception as e:
             logger.error(f"学习{type_str}失败: {e}")
             return None

src/chat/express/expression_selector.py

@@ -1,16 +1,17 @@
 import json
 import time
 import random
+import hashlib
 
 from typing import List, Dict, Tuple, Optional, Any
 from json_repair import repair_json
 
 from src.llm_models.utils_model import LLMRequest
-from src.config.config import global_config
+from src.config.config import global_config, model_config
 from src.common.logger import get_logger
+from src.common.database.database_model import Expression
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
 from .expression_learner import get_expression_learner
-from src.common.database.database_model import Expression
 
 logger = get_logger("expression_selector")
 
@@ -75,10 +76,8 @@ def weighted_sample(population: List[Dict], weights: List[float], k: int) -> Lis
 class ExpressionSelector:
     def __init__(self):
         self.expression_learner = get_expression_learner()
-        # TODO: API-Adapter修改标记
         self.llm_model = LLMRequest(
-            model=global_config.model.utils_small,
-            request_type="expression.selector",
+            model_set=model_config.model_task_config.utils_small, request_type="expression.selector"
         )
 
     @staticmethod
@@ -92,7 +91,6 @@ class ExpressionSelector:
             id_str = parts[1]
             stream_type = parts[2]
             is_group = stream_type == "group"
-            import hashlib
             if is_group:
                 components = [platform, str(id_str)]
             else:
@@ -108,8 +106,7 @@ class ExpressionSelector:
         for group in groups:
             group_chat_ids = []
             for stream_config_str in group:
-                chat_id_candidate = self._parse_stream_config_to_chat_id(stream_config_str)
-                if chat_id_candidate:
+                if chat_id_candidate := self._parse_stream_config_to_chat_id(stream_config_str):
                     group_chat_ids.append(chat_id_candidate)
             if chat_id in group_chat_ids:
                 return group_chat_ids
@@ -118,9 +115,10 @@ class ExpressionSelector:
     def get_random_expressions(
         self, chat_id: str, total_num: int, style_percentage: float, grammar_percentage: float
     ) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+        # sourcery skip: extract-duplicate-method, move-assign
         # 支持多chat_id合并抽选
         related_chat_ids = self.get_related_chat_ids(chat_id)
-        
+
         # 优化：一次性查询所有相关chat_id的表达方式
         style_query = Expression.select().where(
             (Expression.chat_id.in_(related_chat_ids)) & (Expression.type == "style")
@@ -128,7 +126,7 @@ class ExpressionSelector:
         grammar_query = Expression.select().where(
             (Expression.chat_id.in_(related_chat_ids)) & (Expression.type == "grammar")
         )
-        
+
         style_exprs = [
             {
                 "situation": expr.situation,
@@ -138,9 +136,10 @@ class ExpressionSelector:
                 "source_id": expr.chat_id,
                 "type": "style",
                 "create_date": expr.create_date if expr.create_date is not None else expr.last_active_time,
-            } for expr in style_query
+            }
+            for expr in style_query
         ]
-        
+
         grammar_exprs = [
             {
                 "situation": expr.situation,
@@ -150,9 +149,10 @@ class ExpressionSelector:
                 "source_id": expr.chat_id,
                 "type": "grammar",
                 "create_date": expr.create_date if expr.create_date is not None else expr.last_active_time,
-            } for expr in grammar_query
+            }
+            for expr in grammar_query
         ]
-        
+
         style_num = int(total_num * style_percentage)
         grammar_num = int(total_num * grammar_percentage)
         # 按权重抽样（使用count作为权重）
@@ -174,22 +174,22 @@ class ExpressionSelector:
             return
         updates_by_key = {}
         for expr in expressions_to_update:
-            source_id = expr.get("source_id")
-            expr_type = expr.get("type", "style")
-            situation = expr.get("situation")
-            style = expr.get("style")
+            source_id: str = expr.get("source_id")  # type: ignore
+            expr_type: str = expr.get("type", "style")
+            situation: str = expr.get("situation")  # type: ignore
+            style: str = expr.get("style")  # type: ignore
             if not source_id or not situation or not style:
                 logger.warning(f"表达方式缺少必要字段，无法更新: {expr}")
                 continue
             key = (source_id, expr_type, situation, style)
             if key not in updates_by_key:
                 updates_by_key[key] = expr
-        for (chat_id, expr_type, situation, style), _expr in updates_by_key.items():
+        for chat_id, expr_type, situation, style in updates_by_key:
             query = Expression.select().where(
-                (Expression.chat_id == chat_id) &
-                (Expression.type == expr_type) &
-                (Expression.situation == situation) &
-                (Expression.style == style)
+                (Expression.chat_id == chat_id)
+                & (Expression.type == expr_type)
+                & (Expression.situation == situation)
+                & (Expression.style == style)
             )
             if query.exists():
                 expr_obj = query.get()
@@ -264,7 +264,7 @@ class ExpressionSelector:
 
         # 4. 调用LLM
         try:
-            content, (_, _) = await self.llm_model.generate_response_async(prompt=prompt)
+            content, _ = await self.llm_model.generate_response_async(prompt=prompt)
 
             # logger.info(f"{self.log_prefix} LLM返回结果: {content}")
 

src/chat/memory_system/Hippocampus.py

@@ -5,25 +5,27 @@ import random
 import time
 import re
 import json
-from itertools import combinations
-
 import jieba
 import networkx as nx
 import numpy as np
+
+from itertools import combinations
+from typing import List, Tuple, Coroutine, Any, Dict, Set
 from collections import Counter
-from ...llm_models.utils_model import LLMRequest
+from rich.traceback import install
+
+from src.llm_models.utils_model import LLMRequest
+from src.config.config import global_config, model_config
+from src.common.database.database_model import Messages, GraphNodes, GraphEdges  # Peewee Models导入
 from src.common.logger import get_logger
 from src.chat.memory_system.sample_distribution import MemoryBuildScheduler  # 分布生成器
-from ..utils.chat_message_builder import (
+from src.chat.utils.chat_message_builder import (
     get_raw_msg_by_timestamp,
     build_readable_messages,
     get_raw_msg_by_timestamp_with_chat,
 )  # 导入 build_readable_messages
-from ..utils.utils import translate_timestamp_to_human_readable
-from rich.traceback import install
+from src.chat.utils.utils import translate_timestamp_to_human_readable
 
-from ...config.config import global_config
-from src.common.database.database_model import Messages, GraphNodes, GraphEdges  # Peewee Models导入
 
 install(extra_lines=3)
 
@@ -198,8 +200,7 @@ class Hippocampus:
         self.parahippocampal_gyrus = ParahippocampalGyrus(self)
         # 从数据库加载记忆图
         self.entorhinal_cortex.sync_memory_from_db()
-        # TODO: API-Adapter修改标记
-        self.model_summary = LLMRequest(global_config.model.memory, request_type="memory.builder")
+        self.model_summary = LLMRequest(model_set=model_config.model_task_config.memory, request_type="memory.builder")
 
     def get_all_node_names(self) -> list:
         """获取记忆图中所有节点的名字列表"""
@@ -339,9 +340,7 @@ class Hippocampus:
         else:
             topic_num = 5  # 51+字符: 5个关键词 (其余长文本)
 
-        topics_response, (reasoning_content, model_name) = await self.model_summary.generate_response_async(
-            self.find_topic_llm(text, topic_num)
-        )
+        topics_response, _ = await self.model_summary.generate_response_async(self.find_topic_llm(text, topic_num))
 
         # 提取关键词
         keywords = re.findall(r"<([^>]+)>", topics_response)
@@ -353,12 +352,11 @@ class Hippocampus:
                 for keyword in ",".join(keywords).replace("，", ",").replace("、", ",").replace(" ", ",").split(",")
                 if keyword.strip()
             ]
-        
+
         if keywords:
             logger.info(f"提取关键词: {keywords}")
-        
-        return keywords 
-        
+
+        return keywords
 
     async def get_memory_from_text(
         self,
@@ -1245,7 +1243,7 @@ class ParahippocampalGyrus:
 
         # 2. 使用LLM提取关键主题
         topic_num = self.hippocampus.calculate_topic_num(input_text, compress_rate)
-        topics_response, (reasoning_content, model_name) = await self.hippocampus.model_summary.generate_response_async(
+        topics_response, _ = await self.hippocampus.model_summary.generate_response_async(
             self.hippocampus.find_topic_llm(input_text, topic_num)
         )
 
@@ -1269,7 +1267,7 @@ class ParahippocampalGyrus:
         logger.debug(f"过滤后话题: {filtered_topics}")
 
         # 4. 创建所有话题的摘要生成任务
-        tasks = []
+        tasks: List[Tuple[str, Coroutine[Any, Any, Tuple[str, Tuple[str, str, List[Dict[str, Any]] | None]]]]] = []
         for topic in filtered_topics:
             # 调用修改后的 topic_what，不再需要 time_info
             topic_what_prompt = self.hippocampus.topic_what(input_text, topic)
@@ -1281,7 +1279,7 @@ class ParahippocampalGyrus:
                 continue
 
         # 等待所有任务完成
-        compressed_memory = set()
+        compressed_memory: Set[Tuple[str, str]] = set()
         similar_topics_dict = {}
 
         for topic, task in tasks:

src/chat/memory_system/instant_memory.py

@@ -3,13 +3,16 @@ import time
 import re
 import json
 import ast
-from json_repair import repair_json
-from src.llm_models.utils_model import LLMRequest
-from src.common.logger import get_logger
 import traceback
 
-from src.config.config import global_config
+from json_repair import repair_json
+from datetime import datetime, timedelta
+
+from src.llm_models.utils_model import LLMRequest
+from src.common.logger import get_logger
 from src.common.database.database_model import Memory  # Peewee Models导入
+from src.config.config import model_config
+
 
 logger = get_logger(__name__)
 
@@ -35,8 +38,7 @@ class InstantMemory:
         self.chat_id = chat_id
         self.last_view_time = time.time()
         self.summary_model = LLMRequest(
-            model=global_config.model.memory,
-            temperature=0.5,
+            model_set=model_config.model_task_config.memory,
             request_type="memory.summary",
         )
 
@@ -48,14 +50,11 @@ class InstantMemory:
         """
 
         try:
-            response, _ = await self.summary_model.generate_response_async(prompt)
+            response, _ = await self.summary_model.generate_response_async(prompt, temperature=0.5)
             print(prompt)
             print(response)
 
-            if "1" in response:
-                return True
-            else:
-                return False
+            return "1" in response
         except Exception as e:
             logger.error(f"判断是否需要记忆出现错误：{str(e)} {traceback.format_exc()}")
             return False
@@ -71,9 +70,9 @@ class InstantMemory:
         }}
         """
         try:
-            response, _ = await self.summary_model.generate_response_async(prompt)
-            print(prompt)
-            print(response)
+            response, _ = await self.summary_model.generate_response_async(prompt, temperature=0.5)
+            # print(prompt)
+            # print(response)
             if not response:
                 return None
             try:
@@ -142,7 +141,7 @@ class InstantMemory:
         请只输出json格式，不要输出其他多余内容
         """
         try:
-            response, _ = await self.summary_model.generate_response_async(prompt)
+            response, _ = await self.summary_model.generate_response_async(prompt, temperature=0.5)
             print(prompt)
             print(response)
             if not response:
@@ -177,7 +176,7 @@ class InstantMemory:
 
                 for mem in query:
                     # 对每条记忆
-                    mem_keywords = mem.keywords or []
+                    mem_keywords = mem.keywords or ""
                     parsed = ast.literal_eval(mem_keywords)
                     if isinstance(parsed, list):
                         mem_keywords = [str(k).strip() for k in parsed if str(k).strip()]
@@ -201,6 +200,7 @@ class InstantMemory:
             return None
 
     def _parse_time_range(self, time_str):
+        # sourcery skip: extract-duplicate-method, use-contextlib-suppress
         """
         支持解析如下格式：
         - 具体日期时间：YYYY-MM-DD HH:MM:SS
@@ -208,8 +208,6 @@ class InstantMemory:
         - 相对时间：今天，昨天，前天，N天前，N个月前
         - 空字符串：返回(None, None)
         """
-        from datetime import datetime, timedelta
-
         now = datetime.now()
         if not time_str:
             return 0, now
@@ -239,14 +237,12 @@ class InstantMemory:
             start = (now - timedelta(days=2)).replace(hour=0, minute=0, second=0, microsecond=0)
             end = start + timedelta(days=1)
             return start, end
-        m = re.match(r"(\d+)天前", time_str)
-        if m:
+        if m := re.match(r"(\d+)天前", time_str):
             days = int(m.group(1))
             start = (now - timedelta(days=days)).replace(hour=0, minute=0, second=0, microsecond=0)
             end = start + timedelta(days=1)
             return start, end
-        m = re.match(r"(\d+)个月前", time_str)
-        if m:
+        if m := re.match(r"(\d+)个月前", time_str):
             months = int(m.group(1))
             # 近似每月30天
             start = (now - timedelta(days=months * 30)).replace(hour=0, minute=0, second=0, microsecond=0)

src/chat/memory_system/memory_activator.py

@@ -1,13 +1,15 @@
-from src.llm_models.utils_model import LLMRequest
-from src.config.config import global_config
-from src.common.logger import get_logger
-from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
-from datetime import datetime
-from src.chat.memory_system.Hippocampus import hippocampus_manager
-from typing import List, Dict
 import difflib
 import json
+
 from json_repair import repair_json
+from typing import List, Dict
+from datetime import datetime
+
+from src.llm_models.utils_model import LLMRequest
+from src.config.config import global_config, model_config
+from src.common.logger import get_logger
+from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
+from src.chat.memory_system.Hippocampus import hippocampus_manager
 
 
 logger = get_logger("memory_activator")
@@ -61,11 +63,8 @@ def init_prompt():
 
 class MemoryActivator:
     def __init__(self):
-        # TODO: API-Adapter修改标记
-
         self.key_words_model = LLMRequest(
-            model=global_config.model.utils_small,
-            temperature=0.5,
+            model_set=model_config.model_task_config.utils_small,
             request_type="memory.activator",
         )
 
@@ -92,7 +91,9 @@ class MemoryActivator:
 
         # logger.debug(f"prompt: {prompt}")
 
-        response, (reasoning_content, model_name) = await self.key_words_model.generate_response_async(prompt)
+        response, (reasoning_content, model_name, _) = await self.key_words_model.generate_response_async(
+            prompt, temperature=0.5
+        )
 
         keywords = list(get_keywords_from_json(response))
 

src/chat/message_receive/message.py

@@ -203,7 +203,7 @@ class MessageRecvS4U(MessageRecv):
         self.is_superchat = False
         self.gift_info = None
         self.gift_name = None
-        self.gift_count = None
+        self.gift_count: Optional[str] = None
         self.superchat_info = None
         self.superchat_price = None
         self.superchat_message_text = None

src/chat/planner_actions/action_manager.py

@@ -1,9 +1,10 @@
 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
 from src.plugin_system.core.component_registry import component_registry
 from src.plugin_system.base.component_types import ComponentType, ActionInfo
+from src.plugin_system.base.base_action import BaseAction
 
 logger = get_logger("action_manager")
 

src/chat/planner_actions/action_modifier.py

@@ -5,7 +5,7 @@ import time
 from typing import List, Any, Dict, TYPE_CHECKING, Tuple
 
 from src.common.logger import get_logger
-from src.config.config import global_config
+from src.config.config import global_config, model_config
 from src.llm_models.utils_model import LLMRequest
 from src.chat.message_receive.chat_stream import get_chat_manager, ChatMessageContext
 from src.chat.planner_actions.action_manager import ActionManager
@@ -36,10 +36,7 @@ class ActionModifier:
         self.action_manager = action_manager
 
         # 用于LLM判定的小模型
-        self.llm_judge = LLMRequest(
-            model=global_config.model.utils_small,
-            request_type="action.judge",
-        )
+        self.llm_judge = LLMRequest(model_set=model_config.model_task_config.utils_small, request_type="action.judge")
 
         # 缓存相关属性
         self._llm_judge_cache = {}  # 缓存LLM判定结果
@@ -438,4 +435,4 @@ class ActionModifier:
             return True
         else:
             logger.debug(f"{self.log_prefix}动作 {action_name} 未匹配到任何关键词: {activation_keywords}")
-            return False
+            return False

src/chat/planner_actions/planner.py

@@ -7,7 +7,7 @@ from datetime import datetime
 from json_repair import repair_json
 
 from src.llm_models.utils_model import LLMRequest
-from src.config.config import global_config
+from src.config.config import global_config, model_config
 from src.common.logger import get_logger
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
 from src.chat.utils.chat_message_builder import (
@@ -73,10 +73,7 @@ class ActionPlanner:
         self.log_prefix = f"[{get_chat_manager().get_stream_name(chat_id) or chat_id}]"
         self.action_manager = action_manager
         # LLM规划器配置
-        self.planner_llm = LLMRequest(
-            model=global_config.model.planner,
-            request_type="planner",  # 用于动作规划
-        )
+        self.planner_llm = LLMRequest(model_set=model_config.model_task_config.planner, request_type="planner")  # 用于动作规划
 
         self.last_obs_time_mark = 0.0
 
@@ -140,7 +137,7 @@ class ActionPlanner:
             # --- 调用 LLM (普通文本生成) ---
             llm_content = None
             try:
-                llm_content, (reasoning_content, _) = await self.planner_llm.generate_response_async(prompt=prompt)
+                llm_content, (reasoning_content, _, _) = await self.planner_llm.generate_response_async(prompt=prompt)
 
                 if global_config.debug.show_prompt:
                     logger.info(f"{self.log_prefix}规划器原始提示词: {prompt}")

src/chat/replyer/default_generator.py

@@ -8,7 +8,8 @@ from typing import List, Optional, Dict, Any, Tuple
 from datetime import datetime
 from src.mais4u.mai_think import mai_thinking_manager
 from src.common.logger import get_logger
-from src.config.config import global_config
+from src.config.config import global_config, model_config
+from src.config.api_ada_configs import TaskConfig
 from src.individuality.individuality import get_individuality
 from src.llm_models.utils_model import LLMRequest
 from src.chat.message_receive.message import UserInfo, Seg, MessageRecv, MessageSending
@@ -106,31 +107,36 @@ class DefaultReplyer:
     def __init__(
         self,
         chat_stream: ChatStream,
-        model_configs: Optional[List[Dict[str, Any]]] = None,
+        model_set_with_weight: Optional[List[Tuple[TaskConfig, float]]] = None,
         request_type: str = "focus.replyer",
     ):
         self.request_type = request_type
 
-        if model_configs:
-            self.express_model_configs = model_configs
+        if model_set_with_weight:
+            # self.express_model_configs = model_configs
+            self.model_set: List[Tuple[TaskConfig, float]] = model_set_with_weight
         else:
             # 当未提供配置时，使用默认配置并赋予默认权重
 
-            model_config_1 = global_config.model.replyer_1.copy()
-            model_config_2 = global_config.model.replyer_2.copy()
+            # model_config_1 = global_config.model.replyer_1.copy()
+            # model_config_2 = global_config.model.replyer_2.copy()
             prob_first = global_config.chat.replyer_random_probability
 
-            model_config_1["weight"] = prob_first
-            model_config_2["weight"] = 1.0 - prob_first
+            # model_config_1["weight"] = prob_first
+            # model_config_2["weight"] = 1.0 - prob_first
 
-            self.express_model_configs = [model_config_1, model_config_2]
+            # self.express_model_configs = [model_config_1, model_config_2]
+            self.model_set = [
+                (model_config.model_task_config.replyer_1, prob_first),
+                (model_config.model_task_config.replyer_2, 1.0 - prob_first),
+            ]
 
-        if not self.express_model_configs:
-            logger.warning("未找到有效的模型配置，回复生成可能会失败。")
-            # 提供一个最终的回退，以防止在空列表上调用 random.choice
-            fallback_config = global_config.model.replyer_1.copy()
-            fallback_config.setdefault("weight", 1.0)
-            self.express_model_configs = [fallback_config]
+        # if not self.express_model_configs:
+        #     logger.warning("未找到有效的模型配置，回复生成可能会失败。")
+        #     # 提供一个最终的回退，以防止在空列表上调用 random.choice
+        #     fallback_config = global_config.model.replyer_1.copy()
+        #     fallback_config.setdefault("weight", 1.0)
+        #     self.express_model_configs = [fallback_config]
 
         self.chat_stream = chat_stream
         self.is_group_chat, self.chat_target_info = get_chat_type_and_target_info(self.chat_stream.stream_id)
@@ -139,14 +145,15 @@ class DefaultReplyer:
         self.memory_activator = MemoryActivator()
         self.instant_memory = InstantMemory(chat_id=self.chat_stream.stream_id)
 
-        from src.plugin_system.core.tool_use import ToolExecutor # 延迟导入ToolExecutor，不然会循环依赖
+        from src.plugin_system.core.tool_use import ToolExecutor  # 延迟导入ToolExecutor，不然会循环依赖
+
         self.tool_executor = ToolExecutor(chat_id=self.chat_stream.stream_id, enable_cache=True, cache_ttl=3)
 
-    def _select_weighted_model_config(self) -> Dict[str, Any]:
+    def _select_weighted_models_config(self) -> Tuple[TaskConfig, float]:
         """使用加权随机选择来挑选一个模型配置"""
-        configs = self.express_model_configs
+        configs = self.model_set
         # 提取权重，如果模型配置中没有'weight'键，则默认为1.0
-        weights = [config.get("weight", 1.0) for config in configs]
+        weights = [weight for _, weight in configs]
 
         return random.choices(population=configs, weights=weights, k=1)[0]
 
@@ -188,12 +195,11 @@ class DefaultReplyer:
 
             # 4. 调用 LLM 生成回复
             content = None
-            # TODO: 复活这里
-            # reasoning_content = None
-            # model_name = "unknown_model"
+            reasoning_content = None
+            model_name = "unknown_model"
 
             try:
-                content = await self.llm_generate_content(prompt)
+                content, reasoning_content, model_name, _ = await self.llm_generate_content(prompt)
                 logger.debug(f"replyer生成内容: {content}")
 
             except Exception as llm_e:
@@ -236,15 +242,14 @@ class DefaultReplyer:
                 )
 
             content = None
-            # TODO: 复活这里
-            # reasoning_content = None
-            # model_name = "unknown_model"
+            reasoning_content = None
+            model_name = "unknown_model"
             if not prompt:
                 logger.error("Prompt 构建失败，无法生成回复。")
                 return False, None, None
 
             try:
-                content = await self.llm_generate_content(prompt)
+                content, reasoning_content, model_name, _ = await self.llm_generate_content(prompt)
                 logger.info(f"想要表达：{raw_reply}||理由：{reason}||生成回复: {content}\n")
 
             except Exception as llm_e:
@@ -843,7 +848,7 @@ class DefaultReplyer:
         raw_reply: str,
         reason: str,
         reply_to: str,
-    ) -> str:
+    ) -> str:  # sourcery skip: remove-redundant-if
         chat_stream = self.chat_stream
         chat_id = chat_stream.stream_id
         is_group_chat = bool(chat_stream.group_info)
@@ -977,30 +982,23 @@ class DefaultReplyer:
             display_message=display_message,
         )
 
-    async def llm_generate_content(self, prompt: str) -> str:
+    async def llm_generate_content(self, prompt: str):
         with Timer("LLM生成", {}):  # 内部计时器，可选保留
             # 加权随机选择一个模型配置
-            selected_model_config = self._select_weighted_model_config()
-            model_display_name = selected_model_config.get('model_name') or selected_model_config.get('name', 'N/A')
-            logger.info(
-                f"使用模型生成回复: {model_display_name} (选中概率: {selected_model_config.get('weight', 1.0)})"
-            )
+            selected_model_config, weight = self._select_weighted_models_config()
+            logger.info(f"使用模型集生成回复: {selected_model_config} (选中概率: {weight})")
 
-            express_model = LLMRequest(
-                model=selected_model_config,
-                request_type=self.request_type,
-            )
+            express_model = LLMRequest(model_set=selected_model_config, request_type=self.request_type)
 
             if global_config.debug.show_prompt:
                 logger.info(f"\n{prompt}\n")
             else:
                 logger.debug(f"\n{prompt}\n")
 
-            # TODO: 这里的_应该做出替换
-            content, _ = await express_model.generate_response_async(prompt)
+            content, (reasoning_content, model_name, tool_calls) = await express_model.generate_response_async(prompt)
 
             logger.debug(f"replyer生成内容: {content}")
-        return content
+        return content, reasoning_content, model_name, tool_calls
 
 
 def weighted_sample_no_replacement(items, weights, k) -> list:

src/chat/replyer/replyer_manager.py

@@ -1,6 +1,7 @@
-from typing import Dict, Any, Optional, List
+from typing import Dict, Optional, List, Tuple
 
 from src.common.logger import get_logger
+from src.config.api_ada_configs import TaskConfig
 from src.chat.message_receive.chat_stream import ChatStream, get_chat_manager
 from src.chat.replyer.default_generator import DefaultReplyer
 
@@ -15,7 +16,7 @@ class ReplyerManager:
         self,
         chat_stream: Optional[ChatStream] = None,
         chat_id: Optional[str] = None,
-        model_configs: Optional[List[Dict[str, Any]]] = None,
+        model_set_with_weight: Optional[List[Tuple[TaskConfig, float]]] = None,
         request_type: str = "replyer",
     ) -> Optional[DefaultReplyer]:
         """
@@ -49,7 +50,7 @@ class ReplyerManager:
         # model_configs 只在此时（初始化时）生效
         replyer = DefaultReplyer(
             chat_stream=target_stream,
-            model_configs=model_configs,  # 可以是None，此时使用默认模型
+            model_set_with_weight=model_set_with_weight,  # 可以是None，此时使用默认模型
             request_type=request_type,
         )
         self._repliers[stream_id] = replyer

src/chat/utils/utils.py

@@ -11,7 +11,7 @@ from typing import Optional, Tuple, Dict, List, Any
 
 from src.common.logger import get_logger
 from src.common.message_repository import find_messages, count_messages
-from src.config.config import global_config
+from src.config.config import global_config, model_config
 from src.chat.message_receive.message import MessageRecv
 from src.chat.message_receive.chat_stream import get_chat_manager
 from src.llm_models.utils_model import LLMRequest
@@ -109,13 +109,11 @@ def is_mentioned_bot_in_message(message: MessageRecv) -> tuple[bool, float]:
     return is_mentioned, reply_probability
 
 
-async def get_embedding(text, request_type="embedding"):
+async def get_embedding(text, request_type="embedding") -> Optional[List[float]]:
     """获取文本的embedding向量"""
-    # TODO: API-Adapter修改标记
-    llm = LLMRequest(model=global_config.model.embedding, request_type=request_type)
-    # return llm.get_embedding_sync(text)
+    llm = LLMRequest(model_set=model_config.model_task_config.embedding, request_type=request_type)
     try:
-        embedding = await llm.get_embedding(text)
+        embedding, _ = await llm.get_embedding(text)
     except Exception as e:
         logger.error(f"获取embedding失败: {str(e)}")
         embedding = None

src/chat/utils/utils_image.py

@@ -14,7 +14,7 @@ from rich.traceback import install
 from src.common.logger import get_logger
 from src.common.database.database import db
 from src.common.database.database_model import Images, ImageDescriptions
-from src.config.config import global_config
+from src.config.config import global_config, model_config
 from src.llm_models.utils_model import LLMRequest
 
 install(extra_lines=3)
@@ -37,7 +37,7 @@ class ImageManager:
             self._ensure_image_dir()
 
             self._initialized = True
-            self.vlm = LLMRequest(model=global_config.model.vlm, temperature=0.4, max_tokens=300, request_type="image")
+            self.vlm = LLMRequest(model_set=model_config.model_task_config.vlm, request_type="image")
 
             try:
                 db.connect(reuse_if_open=True)
@@ -107,6 +107,7 @@ class ImageManager:
             # 优先使用EmojiManager查询已注册表情包的描述
             try:
                 from src.chat.emoji_system.emoji_manager import get_emoji_manager
+
                 emoji_manager = get_emoji_manager()
                 cached_emoji_description = await emoji_manager.get_emoji_description_by_hash(image_hash)
                 if cached_emoji_description:
@@ -116,13 +117,12 @@ class ImageManager:
                 logger.debug(f"查询EmojiManager时出错: {e}")
 
             # 查询ImageDescriptions表的缓存描述
-            cached_description = self._get_description_from_db(image_hash, "emoji")
-            if cached_description:
+            if cached_description := self._get_description_from_db(image_hash, "emoji"):
                 logger.info(f"[缓存命中] 使用ImageDescriptions表中的描述: {cached_description[:50]}...")
                 return f"[表情包：{cached_description}]"
 
             # === 二步走识别流程 ===
-            
+
             # 第一步：VLM视觉分析 - 生成详细描述
             if image_format in ["gif", "GIF"]:
                 image_base64_processed = self.transform_gif(image_base64)
@@ -130,10 +130,16 @@ class ImageManager:
                     logger.warning("GIF转换失败，无法获取描述")
                     return "[表情包(GIF处理失败)]"
                 vlm_prompt = "这是一个动态图表情包，每一张图代表了动态图的某一帧，黑色背景代表透明，描述一下表情包表达的情感和内容，描述细节，从互联网梗,meme的角度去分析"
-                detailed_description, _ = await self.vlm.generate_response_for_image(vlm_prompt, image_base64_processed, "jpg")
+                detailed_description, _ = await self.vlm.generate_response_for_image(
+                    vlm_prompt, image_base64_processed, "jpg", temperature=0.4, max_tokens=300
+                )
             else:
-                vlm_prompt = "这是一个表情包，请详细描述一下表情包所表达的情感和内容，描述细节，从互联网梗,meme的角度去分析"
-                detailed_description, _ = await self.vlm.generate_response_for_image(vlm_prompt, image_base64, image_format)
+                vlm_prompt = (
+                    "这是一个表情包，请详细描述一下表情包所表达的情感和内容，描述细节，从互联网梗,meme的角度去分析"
+                )
+                detailed_description, _ = await self.vlm.generate_response_for_image(
+                    vlm_prompt, image_base64, image_format, temperature=0.4, max_tokens=300
+                )
 
             if detailed_description is None:
                 logger.warning("VLM未能生成表情包详细描述")
@@ -150,31 +156,32 @@ class ImageManager:
             3. 输出简短精准，不要解释
             4. 如果有多个词用逗号分隔
             """
-            
+
             # 使用较低温度确保输出稳定
-            emotion_llm = LLMRequest(model=global_config.model.utils, temperature=0.3, max_tokens=50, request_type="emoji")
-            emotion_result, _ = await emotion_llm.generate_response_async(emotion_prompt)
+            emotion_llm = LLMRequest(model_set=model_config.model_task_config.utils, request_type="emoji")
+            emotion_result, _ = await emotion_llm.generate_response_async(
+                emotion_prompt, temperature=0.3, max_tokens=50
+            )
 
             if emotion_result is None:
                 logger.warning("LLM未能生成情感标签，使用详细描述的前几个词")
                 # 降级处理：从详细描述中提取关键词
                 import jieba
+
                 words = list(jieba.cut(detailed_description))
                 emotion_result = "，".join(words[:2]) if len(words) >= 2 else (words[0] if words else "表情")
 
             # 处理情感结果，取前1-2个最重要的标签
             emotions = [e.strip() for e in emotion_result.replace("，", ",").split(",") if e.strip()]
             final_emotion = emotions[0] if emotions else "表情"
-            
+
             # 如果有第二个情感且不重复，也包含进来
             if len(emotions) > 1 and emotions[1] != emotions[0]:
                 final_emotion = f"{emotions[0]}，{emotions[1]}"
 
             logger.info(f"[emoji识别] 详细描述: {detailed_description[:50]}... -> 情感标签: {final_emotion}")
 
-            # 再次检查缓存，防止并发写入时重复生成
-            cached_description = self._get_description_from_db(image_hash, "emoji")
-            if cached_description:
+            if cached_description := self._get_description_from_db(image_hash, "emoji"):
                 logger.warning(f"虽然生成了描述，但是找到缓存表情包描述: {cached_description}")
                 return f"[表情包：{cached_description}]"
 
@@ -242,9 +249,7 @@ class ImageManager:
                     logger.debug(f"[缓存命中] 使用Images表中的图片描述: {existing_image.description[:50]}...")
                     return f"[图片：{existing_image.description}]"
 
-            # 查询ImageDescriptions表的缓存描述
-            cached_description = self._get_description_from_db(image_hash, "image")
-            if cached_description:
+            if cached_description := self._get_description_from_db(image_hash, "image"):
                 logger.debug(f"[缓存命中] 使用ImageDescriptions表中的描述: {cached_description[:50]}...")
                 return f"[图片：{cached_description}]"
 
@@ -252,7 +257,9 @@ class ImageManager:
             image_format = Image.open(io.BytesIO(image_bytes)).format.lower()  # type: ignore
             prompt = global_config.custom_prompt.image_prompt
             logger.info(f"[VLM调用] 为图片生成新描述 (Hash: {image_hash[:8]}...)")
-            description, _ = await self.vlm.generate_response_for_image(prompt, image_base64, image_format)
+            description, _ = await self.vlm.generate_response_for_image(
+                prompt, image_base64, image_format, temperature=0.4, max_tokens=300
+            )
 
             if description is None:
                 logger.warning("AI未能生成图片描述")
@@ -445,10 +452,7 @@ class ImageManager:
             image_bytes = base64.b64decode(image_base64)
             image_hash = hashlib.md5(image_bytes).hexdigest()
 
-            # 检查图片是否已存在
-            existing_image = Images.get_or_none(Images.emoji_hash == image_hash)
-
-            if existing_image:
+            if existing_image := Images.get_or_none(Images.emoji_hash == image_hash):
                 # 检查是否缺少必要字段，如果缺少则创建新记录
                 if (
                     not hasattr(existing_image, "image_id")
@@ -524,9 +528,7 @@ class ImageManager:
 
             # 优先检查是否已有其他相同哈希的图片记录包含描述
             existing_with_description = Images.get_or_none(
-                (Images.emoji_hash == image_hash) & 
-                (Images.description.is_null(False)) & 
-                (Images.description != "")
+                (Images.emoji_hash == image_hash) & (Images.description.is_null(False)) & (Images.description != "")
             )
             if existing_with_description and existing_with_description.id != image.id:
                 logger.debug(f"[缓存复用] 从其他相同图片记录复用描述: {existing_with_description.description[:50]}...")
@@ -538,8 +540,7 @@ class ImageManager:
                 return
 
             # 检查ImageDescriptions表的缓存描述
-            cached_description = self._get_description_from_db(image_hash, "image")
-            if cached_description:
+            if cached_description := self._get_description_from_db(image_hash, "image"):
                 logger.debug(f"[缓存复用] 从ImageDescriptions表复用描述: {cached_description[:50]}...")
                 image.description = cached_description
                 image.vlm_processed = True
@@ -554,15 +555,15 @@ class ImageManager:
 
             # 获取VLM描述
             logger.info(f"[VLM异步调用] 为图片生成描述 (ID: {image_id}, Hash: {image_hash[:8]}...)")
-            description, _ = await self.vlm.generate_response_for_image(prompt, image_base64, image_format)
+            description, _ = await self.vlm.generate_response_for_image(
+                prompt, image_base64, image_format, temperature=0.4, max_tokens=300
+            )
 
             if description is None:
                 logger.warning("VLM未能生成图片描述")
                 description = "无法生成描述"
 
-            # 再次检查缓存，防止并发写入时重复生成
-            cached_description = self._get_description_from_db(image_hash, "image")
-            if cached_description:
+            if cached_description := self._get_description_from_db(image_hash, "image"):
                 logger.warning(f"虽然生成了描述，但是找到缓存图片描述: {cached_description}")
                 description = cached_description
 
@@ -606,7 +607,7 @@ def image_path_to_base64(image_path: str) -> str:
         raise FileNotFoundError(f"图片文件不存在: {image_path}")
 
     with open(image_path, "rb") as f:
-        image_data = f.read()
-        if not image_data:
+        if image_data := f.read():
+            return base64.b64encode(image_data).decode("utf-8")
+        else:
             raise IOError(f"读取图片文件失败: {image_path}")
-        return base64.b64encode(image_data).decode("utf-8")

src/chat/utils/utils_voice.py

@@ -1,6 +1,6 @@
 import base64
 
-from src.config.config import global_config
+from src.config.config import global_config, model_config
 from src.llm_models.utils_model import LLMRequest
 
 from src.common.logger import get_logger
@@ -20,7 +20,7 @@ async def get_voice_text(voice_base64: str) -> str:
         if isinstance(voice_base64, str):
             voice_base64 = voice_base64.encode("ascii", errors="ignore").decode("ascii")
         voice_bytes = base64.b64decode(voice_base64)
-        _llm = LLMRequest(model=global_config.model.voice, request_type="voice")
+        _llm = LLMRequest(model_set=model_config.model_task_config.voice, request_type="voice")
         text = await _llm.generate_response_for_voice(voice_bytes)
         if text is None:
             logger.warning("未能生成语音文本")

src/chat/willing/mode_mxp.py

@@ -19,13 +19,13 @@ Mxp 模式：梦溪畔独家赞助
 下下策是询问一个菜鸟（@梦溪畔）
 """
 
-from .willing_manager import BaseWillingManager
 from typing import Dict
 import asyncio
 import time
 import math
 
 from src.chat.message_receive.chat_stream import ChatStream
+from .willing_manager import BaseWillingManager
 
 
 class MxpWillingManager(BaseWillingManager):