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

src/chat/chat_loop/heartFC_chat.py

@@ -254,6 +254,53 @@ class HeartFChatting:
         )
         person_name = await person_info_manager.get_value(person_id, "person_name")
         return f"{person_name}:{message_data.get('processed_plain_text')}"
+    
+    async def _send_and_store_reply(
+        self,
+        response_set, 
+        reply_to_str, 
+        loop_start_time, 
+        action_message, 
+        cycle_timers, 
+        thinking_id,
+        plan_result):
+        with Timer("回复发送", cycle_timers):
+            reply_text = await self._send_response(response_set, reply_to_str, loop_start_time, action_message)
+
+                # 存储reply action信息
+        person_info_manager = get_person_info_manager()
+        person_id = person_info_manager.get_person_id(
+            action_message.get("chat_info_platform", ""),
+            action_message.get("user_id", ""),
+        )
+        person_name = await person_info_manager.get_value(person_id, "person_name")
+        action_prompt_display = f"你对{person_name}进行了回复：{reply_text}"
+        
+        await database_api.store_action_info(
+            chat_stream=self.chat_stream,
+            action_build_into_prompt=False,
+            action_prompt_display=action_prompt_display,
+            action_done=True,
+            thinking_id=thinking_id,
+            action_data={"reply_text": reply_text, "reply_to": reply_to_str},
+            action_name="reply",
+        )
+        
+        
+        # 构建循环信息
+        loop_info = {
+            "loop_plan_info": {
+                "action_result": plan_result.get("action_result", {}),
+            },
+            "loop_action_info": {
+                "action_taken": True,
+                "reply_text": reply_text,
+                "command": "",
+                "taken_time": time.time(),
+            },
+        }
+        
+        return loop_info, reply_text,cycle_timers
 
     async def _observe(self, message_data: Optional[Dict[str, Any]] = None):
         # sourcery skip: hoist-statement-from-if, merge-comparisons, reintroduce-else
@@ -319,7 +366,11 @@ class HeartFChatting:
                 # 如果normal模式且不跳过规划器，开始一个回复生成进程，先准备好回复（其实是和planer同时进行的）
                 if not skip_planner:
                     reply_to_str = await self.build_reply_to_str(message_data)
-                    gen_task = asyncio.create_task(self._generate_response(message_data, available_actions, reply_to_str, "chat.replyer.normal"))
+                    gen_task = asyncio.create_task(self._generate_response(
+                        message_data=message_data, 
+                        available_actions=available_actions, 
+                        reply_to=reply_to_str, 
+                        request_type="chat.replyer.normal"))
                     
             if not skip_planner:
                 with Timer("规划器", cycle_timers):
@@ -360,33 +411,29 @@ class HeartFChatting:
 
 
             action_message: Dict[str, Any] = message_data or target_message  # type: ignore
-            if action_type == "reply" or is_parallel:
+            if action_type == "reply":
                 # 等待回复生成完毕
                 if self.loop_mode == ChatMode.NORMAL:
                     # 只有在gen_task存在时才等待
-                    if gen_task is not None:
+                    if not gen_task:
-                        gather_timeout = global_config.chat.thinking_timeout
+                        reply_to_str = await self.build_reply_to_str(message_data)
-                        try:
+                        gen_task = asyncio.create_task(self._generate_response(
-                            response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout)
+                            message_data=message_data, 
-                        except asyncio.TimeoutError:
+                            available_actions=available_actions, 
-                            logger.warning(f"{self.log_prefix} 回复生成超时>{global_config.chat.thinking_timeout}s，已跳过")
+                            reply_to=reply_to_str, 
-                            response_set = None
+                            request_type="chat.replyer.normal"))
 
-                        # 模型炸了或超时，没有回复内容生成
+                    gather_timeout = global_config.chat.thinking_timeout
-                        if not response_set:
+                    try:
-                            logger.warning(f"{self.log_prefix}模型未生成回复内容")
+                        response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout)
-                            return False
+                    except asyncio.TimeoutError:
-                    else:
+                        logger.warning(f"{self.log_prefix} 回复生成超时>{global_config.chat.thinking_timeout}s，已跳过")
-                        # 如果没有预生成任务，直接生成回复
+                        response_set = None
-                        if not reply_to_str:
+
-                            reply_to_str = await self.build_reply_to_str(action_message)
+                    # 模型炸了或超时，没有回复内容生成
-                        
+                    if not response_set:
-                        with Timer("回复生成", cycle_timers):
+                        logger.warning(f"{self.log_prefix}模型未生成回复内容")
-                            response_set = await self._generate_response(action_message, available_actions, reply_to_str, "chat.replyer.normal")
+                        return False
-                        
-                        if not response_set:
-                            logger.warning(f"{self.log_prefix}模型未生成回复内容")
-                            return False
                 else:
                     logger.info(f"{self.log_prefix}{global_config.bot.nickname} 决定进行回复 (focus模式)")
                     
@@ -395,90 +442,118 @@ class HeartFChatting:
                     
                     # 生成回复
                     with Timer("回复生成", cycle_timers):
-                        response_set = await self._generate_response(action_message, available_actions, reply_to_str, request_type="chat.replyer.focus")
+                        response_set = await self._generate_response(
+                            message_data=action_message, 
+                            available_actions=available_actions, 
+                            reply_to=reply_to_str, 
+                            request_type="chat.replyer.focus")
                     
                     if not response_set:
                         logger.warning(f"{self.log_prefix}模型未生成回复内容")
                         return False
                     
-                # 发送回复
+                loop_info, reply_text,cycle_timers = await self._send_and_store_reply(response_set, reply_to_str, loop_start_time, action_message, cycle_timers, thinking_id, plan_result)
-                with Timer("回复发送", cycle_timers):
-                    reply_text = await self._send_response(response_set, reply_to_str, loop_start_time, action_message)
-                    
-                # 存储reply action信息
-                person_info_manager = get_person_info_manager()
-                person_id = person_info_manager.get_person_id(
-                    action_message.get("chat_info_platform", ""),
-                    action_message.get("user_id", ""),
-                )
-                person_name = await person_info_manager.get_value(person_id, "person_name")
-                action_prompt_display = f"你对{person_name}进行了回复：{reply_text}"
-                
-                await database_api.store_action_info(
-                    chat_stream=self.chat_stream,
-                    action_build_into_prompt=False,
-                    action_prompt_display=action_prompt_display,
-                    action_done=True,
-                    thinking_id=thinking_id,
-                    action_data={"reply_text": reply_text, "reply_to": reply_to_str},
-                    action_name="reply",
-                )
-                
-                
-                # 构建循环信息
-                loop_info = {
-                    "loop_plan_info": {
-                        "action_result": plan_result.get("action_result", {}),
-                    },
-                    "loop_action_info": {
-                        "action_taken": True,
-                        "reply_text": reply_text,
-                        "command": "",
-                        "taken_time": time.time(),
-                    },
-                }
-                
-                success = True
-                command = ""
                 
                 return True
 
             else:
-                # 如果是并行执行且在normal模式下，需要等待预生成的回复任务完成
+                # 并行执行：同时进行回复发送和动作执行
-                # if self.loop_mode == ChatMode.NORMAL and is_parallel and gen_task:
+                tasks = []
-                #     # 等待预生成的回复任务完成
-                #     gather_timeout = global_config.chat.thinking_timeout
-                #     try:
-                #         response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout)
-                #         if response_set:
-                #             # 发送回复
-                #             with Timer("回复发送", cycle_timers):
-                #                 reply_text_parallel = await self._send_response(response_set, reply_to_str, loop_start_time, action_message)
-                #             logger.info(f"{self.log_prefix} 并行执行：已发送回复内容")
-                #         else:
-                #             logger.warning(f"{self.log_prefix} 并行执行：预生成回复内容为空")
-                #     except asyncio.TimeoutError:
-                #         logger.warning(f"{self.log_prefix} 并行执行：回复生成超时>{global_config.chat.thinking_timeout}s，已跳过")
-                #     except asyncio.CancelledError:
-                #         logger.debug(f"{self.log_prefix} 并行执行：回复生成任务已被取消")
                 
-                # 动作执行计时
+                # 如果是并行执行且在normal模式下，需要等待预生成的回复任务完成并发送回复
-                with Timer("动作执行", cycle_timers):
+                if self.loop_mode == ChatMode.NORMAL and is_parallel and gen_task:
-                    success, reply_text, command = await self._handle_action(
+                    async def handle_reply_task():
-                        action_type, reasoning, action_data, cycle_timers, thinking_id, action_message
+                        # 等待预生成的回复任务完成
-                    )
+                        gather_timeout = global_config.chat.thinking_timeout
+                        try:
+                            response_set = await asyncio.wait_for(gen_task, timeout=gather_timeout)
+                            
+                        except asyncio.TimeoutError:
+                            logger.warning(f"{self.log_prefix} 并行执行：回复生成超时>{global_config.chat.thinking_timeout}s，已跳过")
+                            return None, "", {}
+                        except asyncio.CancelledError:
+                            logger.debug(f"{self.log_prefix} 并行执行：回复生成任务已被取消")
+                            return None, "", {}
+                    
+                        if not response_set:
+                            logger.warning(f"{self.log_prefix} 模型超时或生成回复内容为空")
+                            return None, "", {}
+                            
+                        reply_to_str = await self.build_reply_to_str(action_message)
+                        loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(response_set, reply_to_str, loop_start_time, action_message, cycle_timers, thinking_id, plan_result)
+                        return loop_info, reply_text, cycle_timers_reply
+                    
+                    # 添加回复任务到并行任务列表
+                    tasks.append(asyncio.create_task(handle_reply_task()))
+                
+                # 动作执行任务
+                async def handle_action_task():
+                    with Timer("动作执行", cycle_timers):
+                        success, reply_text, command = await self._handle_action(
+                            action_type, reasoning, action_data, cycle_timers, thinking_id, action_message
+                        )
+                    return success, reply_text, command
+                
+                # 添加动作执行任务到并行任务列表
+                tasks.append(asyncio.create_task(handle_action_task()))
+                
+                # 并行执行所有任务
+                results = await asyncio.gather(*tasks, return_exceptions=True)
+                
+                # 处理结果
+                reply_loop_info = None
+                reply_text_from_reply = ""
+                action_success = False
+                action_reply_text = ""
+                action_command = ""
+                
+                if len(tasks) == 2:  # 有回复任务和动作任务
+                    # 处理回复任务结果
+                    reply_result = results[0]
+                    if isinstance(reply_result, Exception):
+                        logger.error(f"{self.log_prefix} 回复任务执行异常: {reply_result}")
+                    elif reply_result and reply_result[0] is not None:
+                        reply_loop_info, reply_text_from_reply, _ = reply_result
+                    
+                    # 处理动作任务结果
+                    action_result = results[1]
+                    if isinstance(action_result, Exception):
+                        logger.error(f"{self.log_prefix} 动作任务执行异常: {action_result}")
+                    else:
+                        action_success, action_reply_text, action_command = action_result
+                        
+                else:  # 只有动作任务
+                    action_result = results[0]
+                    if isinstance(action_result, Exception):
+                        logger.error(f"{self.log_prefix} 动作任务执行异常: {action_result}")
+                    else:
+                        action_success, action_reply_text, action_command = action_result
 
-                loop_info = {
+                # 构建最终的循环信息
-                    "loop_plan_info": {
+                if reply_loop_info:
-                        "action_result": plan_result.get("action_result", {}),
+                    # 如果有回复信息，使用回复的loop_info作为基础
-                    },
+                    loop_info = reply_loop_info
-                    "loop_action_info": {
+                    # 更新动作执行信息
-                        "action_taken": success,
+                    loop_info["loop_action_info"].update({
-                        "reply_text": reply_text,
+                        "action_taken": action_success,
-                        "command": command,
+                        "command": action_command,
                         "taken_time": time.time(),
-                    },
+                    })
-                }
+                    reply_text = reply_text_from_reply
+                else:
+                    # 没有回复信息，构建纯动作的loop_info
+                    loop_info = {
+                        "loop_plan_info": {
+                            "action_result": plan_result.get("action_result", {}),
+                        },
+                        "loop_action_info": {
+                            "action_taken": action_success,
+                            "reply_text": action_reply_text,
+                            "command": action_command,
+                            "taken_time": time.time(),
+                        },
+                    }
+                    reply_text = action_reply_text
 
 
         if ENABLE_S4U:

src/chat/express/expression_learner.py

@@ -51,7 +51,7 @@ def init_prompt() -> None:
 当"想说明某个具体的事实观点，但懒得明说，或者不便明说，或表达一种默契"，使用"懂的都懂"
 当"当涉及游戏相关时，表示意外的夸赞，略带戏谑意味"时，使用"这么强！"
 
-注意不要总结你自己（SELF）的发言
+请注意：不要总结你自己（SELF）的发言
 现在请你概括
 """
     Prompt(learn_style_prompt, "learn_style_prompt")

src/chat/express/expression_selector.py

@@ -279,6 +279,7 @@ class ExpressionSelector:
 
             if not isinstance(result, dict) or "selected_situations" not in result:
                 logger.error("LLM返回格式错误")
+                logger.info(f"LLM返回结果: \n{content}")
                 return []
 
             selected_indices = result["selected_situations"]

src/chat/replyer/default_generator.py

@@ -158,7 +158,17 @@ class DefaultReplyer:
         enable_timeout: bool = False,
     ) -> Tuple[bool, Optional[str], Optional[str]]:
         """
-        回复器 (Replier): 核心逻辑，负责生成回复文本。
+        回复器 (Replier): 负责生成回复文本的核心逻辑。
+        
+        Args:
+            reply_to: 回复对象，格式为 "发送者:消息内容"
+            extra_info: 额外信息，用于补充上下文
+            available_actions: 可用的动作信息字典
+            enable_tool: 是否启用工具调用
+            enable_timeout: 是否启用超时处理
+            
+        Returns:
+            Tuple[bool, Optional[str], Optional[str]]: (是否成功, 生成的回复内容, 使用的prompt)
         """
         prompt = None
         if available_actions is None:
@@ -219,25 +229,30 @@ class DefaultReplyer:
 
     async def rewrite_reply_with_context(
         self,
-        reply_data: Dict[str, Any],
         raw_reply: str = "",
         reason: str = "",
         reply_to: str = "",
-        relation_info: str = "",
     ) -> Tuple[bool, Optional[str]]:
         """
-        表达器 (Expressor): 核心逻辑，负责生成回复文本。
+        表达器 (Expressor): 负责重写和优化回复文本。
+        
+        Args:
+            raw_reply: 原始回复内容
+            reason: 回复原因
+            reply_to: 回复对象，格式为 "发送者:消息内容"
+            relation_info: 关系信息
+            
+        Returns:
+            Tuple[bool, Optional[str]]: (是否成功, 重写后的回复内容)
         """
         try:
-            if not reply_data:
-                reply_data = {
-                    "reply_to": reply_to,
-                    "relation_info": relation_info,
-                }
 
+            
             with Timer("构建Prompt", {}):  # 内部计时器，可选保留
                 prompt = await self.build_prompt_rewrite_context(
-                    reply_data=reply_data,
+                    raw_reply=raw_reply,
+                    reason=reason,
+                    reply_to=reply_to,
                 )
 
             content = None
@@ -296,7 +311,16 @@ class DefaultReplyer:
 
         return await relationship_fetcher.build_relation_info(person_id, points_num=5)
 
-    async def build_expression_habits(self, chat_history, target):
+    async def build_expression_habits(self, chat_history: str, target: str) -> str:
+        """构建表达习惯块
+        
+        Args:
+            chat_history: 聊天历史记录
+            target: 目标消息内容
+            
+        Returns:
+            str: 表达习惯信息字符串
+        """
         if not global_config.expression.enable_expression:
             return ""
 
@@ -346,7 +370,16 @@ class DefaultReplyer:
 
         return expression_habits_block
 
-    async def build_memory_block(self, chat_history, target):
+    async def build_memory_block(self, chat_history: str, target: str) -> str:
+        """构建记忆块
+        
+        Args:
+            chat_history: 聊天历史记录
+            target: 目标消息内容
+            
+        Returns:
+            str: 记忆信息字符串
+        """
         if not global_config.memory.enable_memory:
             return ""
 
@@ -374,12 +407,13 @@ class DefaultReplyer:
 
         return memory_str
 
-    async def build_tool_info(self, chat_history, reply_to: str = "", enable_tool: bool = True):
+    async def build_tool_info(self, chat_history: str, reply_to: str = "", enable_tool: bool = True) -> str:
         """构建工具信息块
 
         Args:
-            reply_data: 回复数据，包含要回复的消息内容
+            chat_history: 聊天历史记录
-            chat_history: 聊天历史
+            reply_to: 回复对象，格式为 "发送者:消息内容"
+            enable_tool: 是否启用工具调用
 
         Returns:
             str: 工具信息字符串
@@ -423,7 +457,15 @@ class DefaultReplyer:
             logger.error(f"工具信息获取失败: {e}")
             return ""
 
-    def _parse_reply_target(self, target_message: str) -> tuple:
+    def _parse_reply_target(self, target_message: str) -> Tuple[str, str]:
+        """解析回复目标消息
+        
+        Args:
+            target_message: 目标消息，格式为 "发送者:消息内容" 或 "发送者：消息内容"
+            
+        Returns:
+            Tuple[str, str]: (发送者名称, 消息内容)
+        """
         sender = ""
         target = ""
         # 添加None检查，防止NoneType错误
@@ -437,7 +479,15 @@ class DefaultReplyer:
                 target = parts[1].strip()
         return sender, target
 
-    async def build_keywords_reaction_prompt(self, target):
+    async def build_keywords_reaction_prompt(self, target: Optional[str]) -> str:
+        """构建关键词反应提示
+        
+        Args:
+            target: 目标消息内容
+            
+        Returns:
+            str: 关键词反应提示字符串
+        """
         # 关键词检测与反应
         keywords_reaction_prompt = ""
         try:
@@ -471,15 +521,23 @@ class DefaultReplyer:
 
         return keywords_reaction_prompt
 
-    async def _time_and_run_task(self, coroutine, name: str):
+    async def _time_and_run_task(self, coroutine, name: str) -> Tuple[str, Any, float]:
-        """一个简单的帮助函数，用于计时和运行异步任务，返回任务名、结果和耗时"""
+        """计时并运行异步任务的辅助函数
+        
+        Args:
+            coroutine: 要执行的协程
+            name: 任务名称
+            
+        Returns:
+            Tuple[str, Any, float]: (任务名称, 任务结果, 执行耗时)
+        """
         start_time = time.time()
         result = await coroutine
         end_time = time.time()
         duration = end_time - start_time
         return name, result, duration
 
-    def build_s4u_chat_history_prompts(self, message_list_before_now: list, target_user_id: str) -> tuple[str, str]:
+    def build_s4u_chat_history_prompts(self, message_list_before_now: List[Dict[str, Any]], target_user_id: str) -> Tuple[str, str]:
         """
         构建 s4u 风格的分离对话 prompt
 
@@ -488,7 +546,7 @@ class DefaultReplyer:
             target_user_id: 目标用户ID（当前对话对象）
 
         Returns:
-            tuple: (核心对话prompt, 背景对话prompt)
+            Tuple[str, str]: (核心对话prompt, 背景对话prompt)
         """
         core_dialogue_list = []
         background_dialogue_list = []
@@ -507,7 +565,7 @@ class DefaultReplyer:
                     # 其他用户的对话
                     background_dialogue_list.append(msg_dict)
             except Exception as e:
-                logger.error(f"![1753364551656](image/default_generator/1753364551656.png)记录: {msg_dict}, 错误: {e}")
+                logger.error(f"处理消息记录时出错: {msg_dict}, 错误: {e}")
 
         # 构建背景对话 prompt
         background_dialogue_prompt = ""
@@ -552,8 +610,25 @@ class DefaultReplyer:
         sender: str,
         target: str,
         chat_info: str,
-    ):
+    ) -> Any:
-        """构建 mai_think 上下文信息"""
+        """构建 mai_think 上下文信息
+        
+        Args:
+            chat_id: 聊天ID
+            memory_block: 记忆块内容
+            relation_info: 关系信息
+            time_block: 时间块内容
+            chat_target_1: 聊天目标1
+            chat_target_2: 聊天目标2
+            mood_prompt: 情绪提示
+            identity_block: 身份块内容
+            sender: 发送者名称
+            target: 目标消息内容
+            chat_info: 聊天信息
+            
+        Returns:
+            Any: mai_think 实例
+        """
         mai_think = mai_thinking_manager.get_mai_think(chat_id)
         mai_think.memory_block = memory_block
         mai_think.relation_info_block = relation_info
@@ -799,15 +874,14 @@ class DefaultReplyer:
 
     async def build_prompt_rewrite_context(
         self,
-        reply_data: Dict[str, Any],
+        raw_reply: str,
+        reason: str,
+        reply_to: str,
     ) -> str:
         chat_stream = self.chat_stream
         chat_id = chat_stream.stream_id
         is_group_chat = bool(chat_stream.group_info)
 
-        reply_to = reply_data.get("reply_to", "none")
-        raw_reply = reply_data.get("raw_reply", "")
-        reason = reply_data.get("reason", "")
         sender, target = self._parse_reply_target(reply_to)
 
         # 添加情绪状态获取
@@ -834,7 +908,7 @@ class DefaultReplyer:
         # 并行执行2个构建任务
         expression_habits_block, relation_info = await asyncio.gather(
             self.build_expression_habits(chat_talking_prompt_half, target),
-            self.build_relation_info(reply_data),
+            self.build_relation_info(reply_to),
         )
 
         keywords_reaction_prompt = await self.build_keywords_reaction_prompt(target)

src/plugin_system/apis/generator_api.py

@@ -140,6 +140,7 @@ async def generate_reply(
 
     except Exception as e:
         logger.error(f"[GeneratorAPI] 生成回复时出错: {e}")
+        logger.error(traceback.format_exc())
         return False, [], None
 
 
@@ -150,15 +151,22 @@ async def rewrite_reply(
     enable_splitter: bool = True,
     enable_chinese_typo: bool = True,
     model_configs: Optional[List[Dict[str, Any]]] = None,
+    raw_reply: str = "",
+    reason: str = "",
+    reply_to: str = "",
 ) -> Tuple[bool, List[Tuple[str, Any]]]:
     """重写回复
 
     Args:
         chat_stream: 聊天流对象（优先）
-        reply_data: 回复数据
+        reply_data: 回复数据字典（备用，当其他参数缺失时从此获取）
         chat_id: 聊天ID（备用）
         enable_splitter: 是否启用消息分割器
         enable_chinese_typo: 是否启用错字生成器
+        model_configs: 模型配置列表
+        raw_reply: 原始回复内容
+        reason: 回复原因
+        reply_to: 回复对象
 
     Returns:
         Tuple[bool, List[Tuple[str, Any]]]: (是否成功, 回复集合)
@@ -172,8 +180,18 @@ async def rewrite_reply(
 
         logger.info("[GeneratorAPI] 开始重写回复")
 
+        # 如果参数缺失，从reply_data中获取
+        if reply_data:
+            raw_reply = raw_reply or reply_data.get("raw_reply", "")
+            reason = reason or reply_data.get("reason", "")
+            reply_to = reply_to or reply_data.get("reply_to", "")
+
         # 调用回复器重写回复
-        success, content = await replyer.rewrite_reply_with_context(reply_data=reply_data or {})
+        success, content = await replyer.rewrite_reply_with_context(
+            raw_reply=raw_reply,
+            reason=reason,
+            reply_to=reply_to,
+        )
         reply_set = []
         if content:
             reply_set = await process_human_text(content, enable_splitter, enable_chinese_typo)

template/template.env

@@ -1,11 +1,17 @@
 HOST=127.0.0.1
 PORT=8000
 
-#key and url
+# 密钥和url
+
+# 硅基流动
 SILICONFLOW_BASE_URL=https://api.siliconflow.cn/v1/
+# DeepSeek官方
 DEEP_SEEK_BASE_URL=https://api.deepseek.com/v1
-CHAT_ANY_WHERE_BASE_URL=https://api.chatanywhere.tech/v1
+# 阿里百炼
 BAILIAN_BASE_URL = https://dashscope.aliyuncs.com/compatible-mode/v1
+# 火山引擎
+HUOSHAN_BASE_URL = 
+# xxxxx平台
 xxxxxxx_BASE_URL=https://xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
 # 定义你要用的api的key(需要去对应网站申请哦)
@@ -13,4 +19,5 @@ DEEP_SEEK_KEY=
 CHAT_ANY_WHERE_KEY=
 SILICONFLOW_KEY=
 BAILIAN_KEY = 
-xxxxxxx_KEY=
+HUOSHAN_KEY = 
+xxxxxxx_KEY=