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