fix：表情包管理插件可工作

src/chat/express/expression_learner.py

@@ -62,6 +62,7 @@ class ExpressionLearner:
             model_set=model_config.model_task_config.replyer, request_type="expression.learner"
         )
         self.chat_id = chat_id
+        self.chat_stream = get_chat_manager().get_stream(chat_id)
         self.chat_name = get_chat_manager().get_stream_name(chat_id) or chat_id
 
         # 维护每个chat的上次学习时间
@@ -69,24 +70,8 @@ class ExpressionLearner:
 
         # 学习参数
         self.min_messages_for_learning = 25  # 触发学习所需的最少消息数
-        self.min_learning_interval = 300  # 最短学习时间间隔（秒）
-
-    def can_learn_for_chat(self) -> bool:
-        """
-        检查指定聊天流是否允许学习表达
-
-        Args:
-            chat_id: 聊天流ID
-
-        Returns:
-            bool: 是否允许学习
-        """
-        try:
-            use_expression, enable_learning, _ = global_config.expression.get_expression_config_for_chat(self.chat_id)
-            return enable_learning
-        except Exception as e:
-            logger.error(f"检查学习权限失败: {e}")
-            return False
+        _, self.enable_learning, self.learning_intensity = global_config.expression.get_expression_config_for_chat(self.chat_id)
+        self.min_learning_interval = 300 / self.learning_intensity
 
     def should_trigger_learning(self) -> bool:
         """
@@ -98,27 +83,13 @@ class ExpressionLearner:
         Returns:
             bool: 是否应该触发学习
         """
-        current_time = time.time()
-
-        # 获取该聊天流的学习强度
-        try:
-            _, enable_learning, learning_intensity = global_config.expression.get_expression_config_for_chat(
-                self.chat_id
-            )
-        except Exception as e:
-            logger.error(f"获取聊天流 {self.chat_id} 的学习配置失败: {e}")
-            return False
-
         # 检查是否允许学习
-        if not enable_learning:
+        if not self.enable_learning:
             return False
 
-        # 根据学习强度计算最短学习时间间隔
-        min_interval = self.min_learning_interval / learning_intensity
-
         # 检查时间间隔
-        time_diff = current_time - self.last_learning_time
-        if time_diff < min_interval:
+        time_diff = time.time() - self.last_learning_time
+        if time_diff < self.min_learning_interval:
             return False
 
         # 检查消息数量（只检查指定聊天流的消息）
@@ -228,32 +199,17 @@ class ExpressionLearner:
         """
         学习并存储表达方式
         """
-        # 检查是否允许在此聊天流中学习（在函数最前面检查）
-        if not self.can_learn_for_chat():
-            logger.debug(f"聊天流 {self.chat_name} 不允许学习表达，跳过学习")
-            return []
-
         res = await self.learn_expression(num)
 
         if res is None:
+            logger.info("没有学习到表达风格")
             return []
         learnt_expressions, chat_id = res
-
-        chat_stream = get_chat_manager().get_stream(chat_id)
-        if chat_stream is None:
-            group_name = f"聊天流 {chat_id}"
-        elif chat_stream.group_info:
-            group_name = chat_stream.group_info.group_name
-        else:
-            group_name = f"{chat_stream.user_info.user_nickname}的私聊"
         learnt_expressions_str = ""
         for _chat_id, situation, style in learnt_expressions:
             learnt_expressions_str += f"{situation}->{style}\n"
-        logger.info(f"在 {group_name} 学习到表达风格:\n{learnt_expressions_str}")
-
-        if not learnt_expressions:
-            logger.info("没有学习到表达风格")
-            return []
+            
+        logger.info(f"在 {self.chat_name} 学习到表达风格:\n{learnt_expressions_str}")
 
         # 按chat_id分组
         chat_dict: Dict[str, List[Dict[str, Any]]] = {}
@@ -316,7 +272,7 @@ class ExpressionLearner:
 
         current_time = time.time()
 
-        # 获取上次学习时间
+        # 获取上次学习之后的消息
         random_msg = get_raw_msg_by_timestamp_with_chat_inclusive(
             chat_id=self.chat_id,
             timestamp_start=self.last_learning_time,
@@ -330,14 +286,15 @@ class ExpressionLearner:
         chat_id: str = random_msg[0].chat_id
         # random_msg_str: str = build_readable_messages(random_msg, timestamp_mode="normal")
         random_msg_str: str = await build_anonymous_messages(random_msg)
-        # print(f"random_msg_str:{random_msg_str}")
+        
 
         prompt: str = await global_prompt_manager.format_prompt(
             prompt,
             chat_str=random_msg_str,
         )
 
-        logger.debug(f"学习{type_str}的prompt: {prompt}")
+        print(f"random_msg_str:{random_msg_str}")
+        logger.info(f"学习{type_str}的prompt: {prompt}")
 
         try:
             response, _ = await self.express_learn_model.generate_response_async(prompt, temperature=0.3)

src/chat/heart_flow/heartFC_chat.py

@@ -344,6 +344,10 @@ class HeartFChatting:
                         available_actions=available_actions,
                     )
                 )
+                
+            logger.info(
+            f"{self.log_prefix}决定执行{len(action_to_use_info)}个动作: {' '.join([a.action_type for a in action_to_use_info])}"
+        )
 
             # 3. 并行执行所有动作
             action_tasks = [

src/chat/planner_actions/planner.py

@@ -502,8 +502,8 @@ class ActionPlanner:
             action.action_data = action.action_data or {}
             action.action_data["loop_start_time"] = loop_start_time
 
-        logger.info(
-            f"{self.log_prefix}规划器决定执行{len(actions)}个动作: {' '.join([a.action_type for a in actions])}"
+        logger.debug(
+            f"{self.log_prefix}规划器选择了{len(actions)}个动作: {' '.join([a.action_type for a in actions])}"
         )
 
         return actions

src/plugins/built_in/emoji_plugin/emoji.py

@@ -46,8 +46,9 @@ class EmojiAction(BaseAction):
         """执行表情动作"""
         try:
             # 1. 获取发送表情的原因
-            reason = self.action_data.get("reason", "表达当前情绪")
-
+            # reason = self.action_data.get("reason", "表达当前情绪")
+            reason = self.reasoning
+            
             # 2. 随机获取20个表情包
             sampled_emojis = await emoji_api.get_random(30)
             if not sampled_emojis:
@@ -62,6 +63,9 @@ class EmojiAction(BaseAction):
                 emotion_map[emo].append((b64, desc))
 
             available_emotions = list(emotion_map.keys())
+            available_emotions_str = ""
+            for emotion in available_emotions:
+                available_emotions_str += f"{emotion}\n"
 
             if not available_emotions:
                 logger.warning(f"{self.log_prefix} 获取到的表情包均无情感标签, 将随机发送")
@@ -80,14 +84,15 @@ class EmojiAction(BaseAction):
                     )
 
                 # 4. 构建prompt让LLM选择情感
-                prompt = f"""
-                你是一个正在进行聊天的网友，你需要根据一个理由和最近的聊天记录，从一个情感标签列表中选择最匹配的一个。
-                这是最近的聊天记录：
-                {messages_text}
-                
-                这是理由：“{reason}”
-                这里是可用的情感标签：{available_emotions}
-                请直接返回最匹配的那个情感标签，不要进行任何解释或添加其他多余的文字。
+                prompt = f"""你正在进行QQ聊天，你需要根据聊天记录，选出一个合适的情感标签。
+请你根据以下原因和聊天记录进行选择
+原因：{reason}
+聊天记录：
+{messages_text}
+
+这里是可用的情感标签：
+{available_emotions_str}
+请直接返回最匹配的那个情感标签，不要进行任何解释或添加其他多余的文字。
                 """
 
                 if global_config.debug.show_prompt:
@@ -97,10 +102,10 @@ class EmojiAction(BaseAction):
 
                 # 5. 调用LLM
                 models = llm_api.get_available_models()
-                chat_model_config = models.get("utils_small")  # 使用字典访问方式
+                chat_model_config = models.get("replyer")  # 使用字典访问方式
                 if not chat_model_config:
-                    logger.error(f"{self.log_prefix} 未找到'utils_small'模型配置，无法调用LLM")
-                    return False, "未找到'utils_small'模型配置"
+                    logger.error(f"{self.log_prefix} 未找到'replyer'模型配置，无法调用LLM")
+                    return False, "未找到'replyer'模型配置"
 
                 success, chosen_emotion, _, _ = await llm_api.generate_with_model(
                     prompt, model_config=chat_model_config, request_type="emoji"