feat：为HFC创建私聊特殊prompt模板

src/plugins/heartFC_chat/heartFC_chat.py

@@ -27,6 +27,7 @@ from src.plugins.chat.utils import process_llm_response
 from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
 from src.plugins.moods.moods import MoodManager
 from src.individuality.individuality import Individuality
+from src.heart_flow.utils_chat import get_chat_type_and_target_info
 
 
 WAITING_TIME_THRESHOLD = 300  # 等待新消息时间阈值，单位秒
@@ -194,7 +195,12 @@ class HeartFChatting:
         self.on_consecutive_no_reply_callback = on_consecutive_no_reply_callback
 
         # 日志前缀
-        self.log_prefix: str = f"[{chat_manager.get_stream_name(chat_id) or chat_id}]"
+        self.log_prefix: str = str(chat_id)  # Initial default, will be updated
+
+        # --- Initialize attributes (defaults) --- 
+        self.is_group_chat: bool = False
+        self.chat_target_info: Optional[dict] = None 
+        # --- End Initialization ---
 
         # 动作管理器
         self.action_manager = ActionManager()
@@ -234,22 +240,34 @@ class HeartFChatting:
 
     async def _initialize(self) -> bool:
         """
-        懒初始化以使用提供的标识符解析chat_stream。
-        确保实例已准备好处理触发器。
+        懒初始化，解析chat_stream, 获取聊天类型和目标信息。
         """
         if self._initialized:
             return True
-
-        self.chat_stream = chat_manager.get_stream(self.stream_id)
-        if not self.chat_stream:
-            logger.error(f"{self.log_prefix} 获取ChatStream失败。")
-            return False
-
-        # 更新日志前缀（以防流名称发生变化）
-        self.log_prefix = f"[{chat_manager.get_stream_name(self.stream_id) or self.stream_id}]"
+        
+        # --- Use utility function to determine chat type and fetch info ---
+        # Note: get_chat_type_and_target_info handles getting the chat_stream internally
+        self.is_group_chat, self.chat_target_info = await get_chat_type_and_target_info(self.stream_id)
+        
+        # Update log prefix based on potential stream name (if needed, or get it from chat_stream if util doesn't return it)
+        # Assuming get_chat_type_and_target_info focuses only on type/target
+        # We still need the chat_stream object itself for other operations
+        try:
+            self.chat_stream = await asyncio.to_thread(chat_manager.get_stream, self.stream_id)
+            if not self.chat_stream:
+                 logger.error(f"[HFC:{self.stream_id}] 获取ChatStream失败 during _initialize, though util func might have succeeded earlier.")
+                 return False # Cannot proceed without chat_stream object
+            # Update log prefix using the fetched stream object
+            self.log_prefix = f"[{chat_manager.get_stream_name(self.stream_id) or self.stream_id}]"
+        except Exception as e:
+             logger.error(f"[HFC:{self.stream_id}] 获取ChatStream时出错 in _initialize: {e}")
+             return False
+        
+        logger.debug(f"{self.log_prefix} HeartFChatting initialized: is_group={self.is_group_chat}, target_info={self.chat_target_info}")
+        # --- End using utility function ---
 
         self._initialized = True
-        logger.debug(f"{self.log_prefix}麦麦感觉到了，可以开始认真水群 ")
+        logger.debug(f"{self.log_prefix} 麦麦感觉到了，可以开始认真水群 ")
         return True
 
     async def start(self):

src/plugins/heartFC_chat/heartflow_prompt_builder.py

@@ -79,7 +79,7 @@ def init_prompt():
 - 避免重复或评价自己的发言
 - 不要和自己聊天
 
-【决策任务】
+决策任务
 {action_options_text}
 
 你必须从上面列出的可用行动中选择一个，并说明原因。
@@ -90,20 +90,6 @@ JSON 结构如下，包含三个字段 "action", "reasoning", "emoji_query":
   "reasoning": "string", // 做出此决定的详细理由和思考过程，说明你如何应用了回复原则
   "emoji_query": "string" // 可选。如果行动是 'emoji_reply'，必须提供表情主题(填写表情包的适用场合)；如果行动是 'text_reply' 且你想附带表情，也在此提供表情主题，否则留空字符串 ""。遵循回复原则，不要滥用。
 }}
-
-例如:
-{{
-  "action": "text_reply",
-  "reasoning": "用户提到了我，且问题比较具体，适合用文本回复。考虑到内容，可以带上一个微笑表情。",
-  "emoji_query": "微笑"
-}}
-或
-{{
-  "action": "no_reply",
-  "reasoning": "我已经连续回复了两次，而且这个话题我不太感兴趣，根据回复原则，选择不回复，等待其他人发言。",
-  "emoji_query": ""
-}}
-
 请输出你的决策 JSON：
 """,  # 使用三引号避免内部引号问题
         "planner_prompt",  # 保持名称不变，替换内容

src/plugins/heartFC_chat/normal_chat.py

@@ -19,6 +19,7 @@ from src.plugins.chat.chat_stream import ChatStream, chat_manager
 from src.plugins.person_info.relationship_manager import relationship_manager
 from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
 from src.plugins.utils.timer_calculator import Timer
+from src.heart_flow.utils_chat import get_chat_type_and_target_info
 
 
 logger = get_logger("chat")
@@ -26,28 +27,46 @@ logger = get_logger("chat")
 
 class NormalChat:
     def __init__(self, chat_stream: ChatStream, interest_dict: dict):
-        """
-        初始化 NormalChat 实例，针对特定的 ChatStream。
-
-        Args:
-            chat_stream (ChatStream): 此 NormalChat 实例关联的聊天流对象。
-        """
+        """初始化 NormalChat 实例。只进行同步操作。"""
 
+        # Basic info from chat_stream (sync)
         self.chat_stream = chat_stream
         self.stream_id = chat_stream.stream_id
-        self.stream_name = chat_manager.get_stream_name(self.stream_id) or self.stream_id
+        # Get initial stream name, might be updated in initialize
+        self.stream_name = chat_manager.get_stream_name(self.stream_id) or self.stream_id 
 
+        # Interest dict
         self.interest_dict = interest_dict
 
+        # --- Initialize attributes (defaults) --- 
+        self.is_group_chat: bool = False
+        self.chat_target_info: Optional[dict] = None 
+        # --- End Initialization ---
+
+        # Other sync initializations
         self.gpt = NormalChatGenerator()
-        self.mood_manager = MoodManager.get_instance()  # MoodManager 保持单例
-        # 存储此实例的兴趣监控任务
+        self.mood_manager = MoodManager.get_instance()
         self.start_time = time.time()
-
         self.last_speak_time = 0
-
         self._chat_task: Optional[asyncio.Task] = None
-        logger.info(f"[{self.stream_name}] NormalChat 实例初始化完成。")
+        self._initialized = False # Track initialization status
+        
+        # logger.info(f"[{self.stream_name}] NormalChat 实例 __init__ 完成 (同步部分)。") 
+        # Avoid logging here as stream_name might not be final
+
+    async def initialize(self):
+        """异步初始化，获取聊天类型和目标信息。"""
+        if self._initialized:
+            return
+            
+        # --- Use utility function to determine chat type and fetch info ---
+        self.is_group_chat, self.chat_target_info = await get_chat_type_and_target_info(self.stream_id)
+        # Update stream_name again after potential async call in util func
+        self.stream_name = chat_manager.get_stream_name(self.stream_id) or self.stream_id 
+        logger.debug(f"[{self.stream_name}] NormalChat initialized: is_group={self.is_group_chat}, target_info={self.chat_target_info}")
+        # --- End using utility function ---
+        self._initialized = True
+        logger.info(f"[{self.stream_name}] NormalChat 实例 initialize 完成 (异步部分)。")
 
     # 改为实例方法
     async def _create_thinking_message(self, message: MessageRecv) -> str:
@@ -416,22 +435,18 @@ class NormalChat:
     # 改为实例方法, 移除 chat 参数
 
     async def start_chat(self):
-        """为此 NormalChat 实例关联的 ChatStream 启动聊天任务（如果尚未运行），
-        并在后台处理一次初始的高兴趣消息。"""  # 文言文注释示例：启聊之始，若有遗珠，当于暗处拂拭，勿碍正途。
+        """先进行异步初始化，然后启动聊天任务。"""
+        if not self._initialized:
+             await self.initialize() # Ensure initialized before starting tasks
+             
         if self._chat_task is None or self._chat_task.done():
-            # --- 修改：使用 create_task 启动初始消息处理 ---
-            logger.info(f"[{self.stream_name}] 开始后台处理初始兴趣消息...")
-            # 创建一个任务来处理初始消息，不阻塞当前流程
-            _initial_process_task = asyncio.create_task(self._process_initial_interest_messages())
-            # 可以考虑给这个任务也添加完成回调来记录日志或处理错误
-            # initial_process_task.add_done_callback(...)
-            # --- 修改结束 ---
-
-            # 启动后台轮询任务 (这部分不变)
-            logger.info(f"[{self.stream_name}] 启动后台兴趣消息轮询任务...")
-            polling_task = asyncio.create_task(self._reply_interested_message())  # 注意变量名区分
+            logger.info(f"[{self.stream_name}] 开始后台处理初始兴趣消息和轮询任务...")
+            # Process initial messages first
+            await self._process_initial_interest_messages()
+            # Then start polling task
+            polling_task = asyncio.create_task(self._reply_interested_message())
             polling_task.add_done_callback(lambda t: self._handle_task_completion(t))
-            self._chat_task = polling_task  # self._chat_task 仍然指向主要的轮询任务
+            self._chat_task = polling_task
         else:
             logger.info(f"[{self.stream_name}] 聊天轮询任务已在运行中。")