为PFC的输出添加容易区分的聊天流标识

src/plugins/PFC/action_planner.py

@@ -97,7 +97,7 @@ class ActionPlanner:
         self.identity_detail_info = Individuality.get_instance().get_prompt(type="identity", x_person=2, level=2)
         self.name = global_config.BOT_NICKNAME
         self.private_name = private_name
-        self.chat_observer = ChatObserver.get_instance(stream_id)
+        self.chat_observer = ChatObserver.get_instance(stream_id, private_name)
         # self.action_planner_info = ActionPlannerInfo() # 移除未使用的变量
 
     # 修改 plan 方法签名，增加 last_successful_reply_action 参数
@@ -138,11 +138,11 @@ class ActionPlanner:
                             )
                         break
             else:
-                logger.debug("Observation info chat history is empty or not available for bot time check.")
+                logger.debug(f"[私聊][{self.private_name}]Observation info chat history is empty or not available for bot time check.")
         except AttributeError:
-            logger.warning("ObservationInfo object might not have chat_history attribute yet for bot time check.")
+            logger.warning(f"[私聊][{self.private_name}]ObservationInfo object might not have chat_history attribute yet for bot time check.")
         except Exception as e:
-            logger.warning(f"获取 Bot 上次发言时间时出错: {e}")
+            logger.warning(f"[私聊][{self.private_name}]获取 Bot 上次发言时间时出错: {e}")
 
         # --- 获取超时提示信息 ---
         # (这部分逻辑不变)
@@ -159,14 +159,14 @@ class ActionPlanner:
                         except Exception:
                             timeout_context = "重要提示：对方已经长时间没有回复你的消息了（这可能代表对方繁忙/不想回复/没注意到你的消息等情况，或在对方看来本次聊天已告一段落），请基于此情况规划下一步。\n"
             else:
-                logger.debug("Conversation info goal_list is empty or not available for timeout check.")
+                logger.debug(f"[私聊][{self.private_name}]Conversation info goal_list is empty or not available for timeout check.")
         except AttributeError:
-            logger.warning("ConversationInfo object might not have goal_list attribute yet for timeout check.")
+            logger.warning(f"[私聊][{self.private_name}]ConversationInfo object might not have goal_list attribute yet for timeout check.")
         except Exception as e:
-            logger.warning(f"检查超时目标时出错: {e}")
+            logger.warning(f"[私聊][{self.private_name}]检查超时目标时出错: {e}")
 
         # --- 构建通用 Prompt 参数 ---
-        logger.debug(f"开始规划行动：当前目标: {getattr(conversation_info, 'goal_list', '不可用')}")
+        logger.debug(f"[私聊][{self.private_name}]开始规划行动：当前目标: {getattr(conversation_info, 'goal_list', '不可用')}")
 
         # 构建对话目标 (goals_str)
         goals_str = ""
@@ -189,10 +189,10 @@ class ActionPlanner:
             else:
                 goals_str = "- 目前没有明确对话目标，请考虑设定一个。\n"
         except AttributeError:
-            logger.warning("ConversationInfo object might not have goal_list attribute yet.")
+            logger.warning(f"[私聊][{self.private_name}]ConversationInfo object might not have goal_list attribute yet.")
             goals_str = "- 获取对话目标时出错。\n"
         except Exception as e:
-            logger.error(f"构建对话目标字符串时出错: {e}")
+            logger.error(f"[私聊][{self.private_name}]构建对话目标字符串时出错: {e}")
             goals_str = "- 构建对话目标时出错。\n"
 
         # 获取聊天历史记录 (chat_history_text)
@@ -220,13 +220,13 @@ class ActionPlanner:
                     )
                 else:
                     logger.warning(
-                        "ObservationInfo has new_messages_count > 0 but unprocessed_messages is empty or missing."
+                        f"[私聊][{self.private_name}]ObservationInfo has new_messages_count > 0 but unprocessed_messages is empty or missing."
                     )
         except AttributeError:
-            logger.warning("ObservationInfo object might be missing expected attributes for chat history.")
+            logger.warning(f"[私聊][{self.private_name}]ObservationInfo object might be missing expected attributes for chat history.")
             chat_history_text = "获取聊天记录时出错。\n"
         except Exception as e:
-            logger.error(f"处理聊天记录时发生未知错误: {e}")
+            logger.error(f"[私聊][{self.private_name}]处理聊天记录时发生未知错误: {e}")
             chat_history_text = "处理聊天记录时出错。\n"
 
         # 构建 Persona 文本 (persona_text)
@@ -255,11 +255,11 @@ class ActionPlanner:
             if hasattr(conversation_info, "done_action") and conversation_info.done_action:
                 action_history_list = conversation_info.done_action[-5:]
             else:
-                logger.debug("Conversation info done_action is empty or not available.")
+                logger.debug(f"[私聊][{self.private_name}]Conversation info done_action is empty or not available.")
         except AttributeError:
-            logger.warning("ConversationInfo object might not have done_action attribute yet.")
+            logger.warning(f"[私聊][{self.private_name}]ConversationInfo object might not have done_action attribute yet.")
         except Exception as e:
-            logger.error(f"访问行动历史时出错: {e}")
+            logger.error(f"[私聊][{self.private_name}]访问行动历史时出错: {e}")
 
         if not action_history_list:
             action_history_summary += "- 还没有执行过行动。\n"
@@ -316,10 +316,10 @@ class ActionPlanner:
         # --- 选择 Prompt ---
         if last_successful_reply_action in ["direct_reply", "send_new_message"]:
             prompt_template = PROMPT_FOLLOW_UP
-            logger.debug("使用 PROMPT_FOLLOW_UP (追问决策)")
+            logger.debug(f"[私聊][{self.private_name}]使用 PROMPT_FOLLOW_UP (追问决策)")
         else:
             prompt_template = PROMPT_INITIAL_REPLY
-            logger.debug("使用 PROMPT_INITIAL_REPLY (首次/非连续回复决策)")
+            logger.debug(f"[私聊][{self.private_name}]使用 PROMPT_INITIAL_REPLY (首次/非连续回复决策)")
 
         # --- 格式化最终的 Prompt ---
         prompt = prompt_template.format(
@@ -332,13 +332,14 @@ class ActionPlanner:
             chat_history_text=chat_history_text if chat_history_text.strip() else "还没有聊天记录。",
         )
 
-        logger.debug(f"发送到LLM的最终提示词:\n------\n{prompt}\n------")
+        logger.debug(f"[私聊][{self.private_name}]发送到LLM的最终提示词:\n------\n{prompt}\n------")
         try:
             content, _ = await self.llm.generate_response_async(prompt)
-            logger.debug(f"LLM原始返回内容: {content}")
+            logger.debug(f"[私聊][{self.private_name}]LLM原始返回内容: {content}")
 
             success, result = get_items_from_json(
                 content,
+                self.private_name,
                 "action",
                 "reason",
                 default_values={"action": "wait", "reason": "LLM返回格式错误或未提供原因，默认等待"},
@@ -360,14 +361,14 @@ class ActionPlanner:
                 "block_and_ignore",
             ]
             if action not in valid_actions:
-                logger.warning(f"LLM返回了未知的行动类型: '{action}'，强制改为 wait")
+                logger.warning(f"[私聊][{self.private_name}]LLM返回了未知的行动类型: '{action}'，强制改为 wait")
                 reason = f"(原始行动'{action}'无效，已强制改为wait) {reason}"
                 action = "wait"
 
-            logger.info(f"规划的行动: {action}")
-            logger.info(f"行动原因: {reason}")
+            logger.info(f"[私聊][{self.private_name}]规划的行动: {action}")
+            logger.info(f"[私聊][{self.private_name}]行动原因: {reason}")
             return action, reason
 
         except Exception as e:
-            logger.error(f"规划行动时调用 LLM 或处理结果出错: {str(e)}")
+            logger.error(f"[私聊][{self.private_name}]规划行动时调用 LLM 或处理结果出错: {str(e)}")
             return "wait", f"行动规划处理中发生错误，暂时等待: {str(e)}"

src/plugins/PFC/chat_observer.py

@@ -18,7 +18,7 @@ class ChatObserver:
     _instances: Dict[str, "ChatObserver"] = {}
 
     @classmethod
-    def get_instance(cls, stream_id: str) -> "ChatObserver":
+    def get_instance(cls, stream_id: str, private_name: str) -> "ChatObserver":
         """获取或创建观察器实例
 
         Args:
@@ -28,10 +28,10 @@ class ChatObserver:
             ChatObserver: 观察器实例
         """
         if stream_id not in cls._instances:
-            cls._instances[stream_id] = cls(stream_id)
+            cls._instances[stream_id] = cls(stream_id, private_name)
         return cls._instances[stream_id]
 
-    def __init__(self, stream_id: str):
+    def __init__(self, stream_id: str, private_name: str):
         """初始化观察器
 
         Args:
@@ -41,6 +41,7 @@ class ChatObserver:
             raise RuntimeError(f"ChatObserver for {stream_id} already exists. Use get_instance() instead.")
 
         self.stream_id = stream_id
+        self.private_name = private_name
         self.message_storage = MongoDBMessageStorage()
 
         # self.last_user_speak_time: Optional[float] = None  # 对方上次发言时间
@@ -76,12 +77,12 @@ class ChatObserver:
         Returns:
             bool: 是否有新消息
         """
-        logger.debug(f"检查距离上一次观察之后是否有了新消息: {self.last_check_time}")
+        logger.debug(f"[私聊][{self.private_name}]检查距离上一次观察之后是否有了新消息: {self.last_check_time}")
 
         new_message_exists = await self.message_storage.has_new_messages(self.stream_id, self.last_check_time)
 
         if new_message_exists:
-            logger.debug("发现新消息")
+            logger.debug(f"[私聊][{self.private_name}]发现新消息")
             self.last_check_time = time.time()
 
         return new_message_exists
@@ -100,7 +101,7 @@ class ChatObserver:
             # print(self.notification_manager)
             await self.notification_manager.send_notification(notification)
         except Exception as e:
-            logger.error(f"添加消息到历史记录时出错: {e}")
+            logger.error(f"[私聊][{self.private_name}]添加消息到历史记录时出错: {e}")
             print(traceback.format_exc())
 
         # 检查并更新冷场状态
@@ -140,11 +141,11 @@ class ChatObserver:
         """
 
         if self.last_message_time is None:
-            logger.debug("没有最后消息时间，返回 False")
+            logger.debug(f"[私聊][{self.private_name}]没有最后消息时间，返回 False")
             return False
 
         has_new = self.last_message_time > time_point
-        logger.debug(f"判断是否在指定时间点后有新消息: {self.last_message_time} > {time_point} = {has_new}")
+        logger.debug(f"[私聊][{self.private_name}]判断是否在指定时间点后有新消息: {self.last_message_time} > {time_point} = {has_new}")
         return has_new
 
     def get_message_history(
@@ -213,7 +214,7 @@ class ChatObserver:
         if new_messages:
             self.last_message_read = new_messages[-1]["message_id"]
 
-        logger.debug(f"获取指定时间点111之前的消息: {new_messages}")
+        logger.debug(f"[私聊][{self.private_name}]获取指定时间点111之前的消息: {new_messages}")
 
         return new_messages
 
@@ -226,9 +227,9 @@ class ChatObserver:
         #     messages = await self._fetch_new_messages_before(start_time)
         #     for message in messages:
         #         await self._add_message_to_history(message)
-        #     logger.debug(f"缓冲消息: {messages}")
+        #     logger.debug(f"[私聊][{self.private_name}]缓冲消息: {messages}")
         # except Exception as e:
-        #     logger.error(f"缓冲消息出错: {e}")
+        #     logger.error(f"[私聊][{self.private_name}]缓冲消息出错: {e}")
 
         while self._running:
             try:
@@ -256,8 +257,8 @@ class ChatObserver:
                 self._update_complete.set()
 
             except Exception as e:
-                logger.error(f"更新循环出错: {e}")
-                logger.error(traceback.format_exc())
+                logger.error(f"[私聊][{self.private_name}]更新循环出错: {e}")
+                logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}")
                 self._update_complete.set()  # 即使出错也要设置完成事件
 
     def trigger_update(self):
@@ -277,7 +278,7 @@ class ChatObserver:
             await asyncio.wait_for(self._update_complete.wait(), timeout=timeout)
             return True
         except asyncio.TimeoutError:
-            logger.warning(f"等待更新完成超时（{timeout}秒）")
+            logger.warning(f"[私聊][{self.private_name}]等待更新完成超时（{timeout}秒）")
             return False
 
     def start(self):
@@ -287,7 +288,7 @@ class ChatObserver:
 
         self._running = True
         self._task = asyncio.create_task(self._update_loop())
-        logger.debug(f"ChatObserver for {self.stream_id} started")
+        logger.debug(f"[私聊][{self.private_name}]ChatObserver for {self.stream_id} started")
 
     def stop(self):
         """停止观察器"""
@@ -296,7 +297,7 @@ class ChatObserver:
         self._update_complete.set()  # 设置完成事件以解除等待
         if self._task:
             self._task.cancel()
-        logger.debug(f"ChatObserver for {self.stream_id} stopped")
+        logger.debug(f"[私聊][{self.private_name}]ChatObserver for {self.stream_id} stopped")
 
     async def process_chat_history(self, messages: list):
         """处理聊天历史
@@ -314,7 +315,7 @@ class ChatObserver:
                 else:
                     self.update_user_speak_time(msg["time"])
             except Exception as e:
-                logger.warning(f"处理消息时间时出错: {e}")
+                logger.warning(f"[私聊][{self.private_name}]处理消息时间时出错: {e}")
                 continue
 
     def update_check_time(self):

src/plugins/PFC/conversation.py

@@ -51,35 +51,35 @@ class Conversation:
             self.action_planner = ActionPlanner(self.stream_id, self.private_name)
             self.goal_analyzer = GoalAnalyzer(self.stream_id, self.private_name)
             self.reply_generator = ReplyGenerator(self.stream_id, self.private_name)
-            self.knowledge_fetcher = KnowledgeFetcher()
+            self.knowledge_fetcher = KnowledgeFetcher(self.private_name)
             self.waiter = Waiter(self.stream_id, self.private_name)
-            self.direct_sender = DirectMessageSender()
+            self.direct_sender = DirectMessageSender(self.private_name)
 
             # 获取聊天流信息
             self.chat_stream = chat_manager.get_stream(self.stream_id)
 
             self.stop_action_planner = False
         except Exception as e:
-            logger.error(f"初始化对话实例：注册运行组件失败: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"[私聊][{self.private_name}]初始化对话实例：注册运行组件失败: {e}")
+            logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}")
             raise
 
         try:
             # 决策所需要的信息，包括自身自信和观察信息两部分
             # 注册观察器和观测信息
-            self.chat_observer = ChatObserver.get_instance(self.stream_id)
+            self.chat_observer = ChatObserver.get_instance(self.stream_id, self.private_name)
             self.chat_observer.start()
-            self.observation_info = ObservationInfo()
-            self.observation_info.bind_to_chat_observer(self.chat_observer)
+            self.observation_info = ObservationInfo(self.private_name)
+            self.observation_info.bind_to_chat_observer(self.chat_observer, self.private_name)
             # print(self.chat_observer.get_cached_messages(limit=)
 
             self.conversation_info = ConversationInfo()
         except Exception as e:
-            logger.error(f"初始化对话实例：注册信息组件失败: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"[私聊][{self.private_name}]初始化对话实例：注册信息组件失败: {e}")
+            logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}")
             raise
         try:
-            logger.info(f"为 {self.stream_id} 加载初始聊天记录...")
+            logger.info(f"[私聊][{self.private_name}]为 {self.stream_id} 加载初始聊天记录...")
             initial_messages = get_raw_msg_before_timestamp_with_chat(  #
                 chat_id=self.stream_id,
                 timestamp=time.time(),
@@ -106,17 +106,17 @@ class Conversation:
                 self.observation_info.last_message_content = last_msg.get("processed_plain_text", "")
 
                 logger.info(
-                    f"成功加载 {len(initial_messages)} 条初始聊天记录。最后一条消息时间: {self.observation_info.last_message_time}"
+                    f"[私聊][{self.private_name}]成功加载 {len(initial_messages)} 条初始聊天记录。最后一条消息时间: {self.observation_info.last_message_time}"
                 )
 
                 # 让 ChatObserver 从加载的最后一条消息之后开始同步
                 self.chat_observer.last_message_time = self.observation_info.last_message_time
                 self.chat_observer.last_message_read = last_msg  # 更新 observer 的最后读取记录
             else:
-                logger.info("没有找到初始聊天记录。")
+                logger.info(f"[私聊][{self.private_name}]没有找到初始聊天记录。")
 
         except Exception as load_err:
-            logger.error(f"加载初始聊天记录时出错: {load_err}")
+            logger.error(f"[私聊][{self.private_name}]加载初始聊天记录时出错: {load_err}")
             # 出错也要继续，只是没有历史记录而已
         # 组件准备完成，启动该论对话
         self.should_continue = True
@@ -125,10 +125,10 @@ class Conversation:
     async def start(self):
         """开始对话流程"""
         try:
-            logger.info("对话系统启动中...")
+            logger.info(f"[私聊][{self.private_name}]对话系统启动中...")
             asyncio.create_task(self._plan_and_action_loop())
         except Exception as e:
-            logger.error(f"启动对话系统失败: {e}")
+            logger.error(f"[私聊][{self.private_name}]启动对话系统失败: {e}")
             raise
 
     async def _plan_and_action_loop(self):
@@ -139,7 +139,7 @@ class Conversation:
                 await asyncio.sleep(30)
                 continue
             elif self.ignore_until_timestamp and time.time() >= self.ignore_until_timestamp:
-                logger.info(f"忽略时间已到 {self.stream_id}，准备结束对话。")
+                logger.info(f"[私聊][{self.private_name}]忽略时间已到 {self.stream_id}，准备结束对话。")
                 self.ignore_until_timestamp = None
                 self.should_continue = False
                 continue
@@ -149,7 +149,7 @@ class Conversation:
                 if hasattr(self.observation_info, "new_messages_count"):
                     initial_new_message_count = self.observation_info.new_messages_count + 1  # 算上麦麦自己发的那一条
                 else:
-                    logger.warning("ObservationInfo missing 'new_messages_count' before planning.")
+                    logger.warning(f"[私聊][{self.private_name}]ObservationInfo missing 'new_messages_count' before planning.")
 
                 # --- 调用 Action Planner ---
                 # 传递 self.conversation_info.last_successful_reply_action
@@ -162,11 +162,11 @@ class Conversation:
                 if hasattr(self.observation_info, "new_messages_count"):
                     current_new_message_count = self.observation_info.new_messages_count
                 else:
-                    logger.warning("ObservationInfo missing 'new_messages_count' after planning.")
+                    logger.warning(f"[私聊][{self.private_name}]ObservationInfo missing 'new_messages_count' after planning.")
 
                 if current_new_message_count > initial_new_message_count + 2:
                     logger.info(
-                        f"规划期间发现新增消息 ({initial_new_message_count} -> {current_new_message_count})，跳过本次行动，重新规划"
+                        f"[私聊][{self.private_name}]规划期间发现新增消息 ({initial_new_message_count} -> {current_new_message_count})，跳过本次行动，重新规划"
                     )
                     # 如果规划期间有新消息，也应该重置上次回复状态，因为现在要响应新消息了
                     self.conversation_info.last_successful_reply_action = None
@@ -176,12 +176,12 @@ class Conversation:
                 #  包含 send_new_message
                 if initial_new_message_count > 0 and action in ["direct_reply", "send_new_message"]:
                     if hasattr(self.observation_info, "clear_unprocessed_messages"):
-                        logger.debug(f"准备执行 {action}，清理 {initial_new_message_count} 条规划时已知的新消息。")
+                        logger.debug(f"[私聊][{self.private_name}]准备执行 {action}，清理 {initial_new_message_count} 条规划时已知的新消息。")
                         await self.observation_info.clear_unprocessed_messages()
                         if hasattr(self.observation_info, "new_messages_count"):
                             self.observation_info.new_messages_count = 0
                     else:
-                        logger.error("无法清理未处理消息: ObservationInfo 缺少 clear_unprocessed_messages 方法！")
+                        logger.error(f"[私聊][{self.private_name}]无法清理未处理消息: ObservationInfo 缺少 clear_unprocessed_messages 方法！")
 
                 await self._handle_action(action, reason, self.observation_info, self.conversation_info)
 
@@ -198,34 +198,34 @@ class Conversation:
 
                 if goal_ended:
                     self.should_continue = False
-                    logger.info("检测到'结束对话'目标，停止循环。")
+                    logger.info(f"[私聊][{self.private_name}]检测到'结束对话'目标，停止循环。")
 
             except Exception as loop_err:
-                logger.error(f"PFC主循环出错: {loop_err}")
-                logger.error(traceback.format_exc())
+                logger.error(f"[私聊][{self.private_name}]PFC主循环出错: {loop_err}")
+                logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}")
                 await asyncio.sleep(1)
 
             if self.should_continue:
                 await asyncio.sleep(0.1)
 
-        logger.info(f"PFC 循环结束 for stream_id: {self.stream_id}")
+        logger.info(f"[私聊][{self.private_name}]PFC 循环结束 for stream_id: {self.stream_id}")
 
     def _check_new_messages_after_planning(self):
         """检查在规划后是否有新消息"""
         # 检查 ObservationInfo 是否已初始化并且有 new_messages_count 属性
         if not hasattr(self, "observation_info") or not hasattr(self.observation_info, "new_messages_count"):
-            logger.warning("ObservationInfo 未初始化或缺少 'new_messages_count' 属性，无法检查新消息。")
+            logger.warning(f"[私聊][{self.private_name}]ObservationInfo 未初始化或缺少 'new_messages_count' 属性，无法检查新消息。")
             return False  # 或者根据需要抛出错误
 
         if self.observation_info.new_messages_count > 2:
             logger.info(
-                f"生成/执行动作期间收到 {self.observation_info.new_messages_count} 条新消息，取消当前动作并重新规划"
+                f"[私聊][{self.private_name}]生成/执行动作期间收到 {self.observation_info.new_messages_count} 条新消息，取消当前动作并重新规划"
             )
             # 如果有新消息，也应该重置上次回复状态
             if hasattr(self, "conversation_info"):  # 确保 conversation_info 已初始化
                 self.conversation_info.last_successful_reply_action = None
             else:
-                logger.warning("ConversationInfo 未初始化，无法重置 last_successful_reply_action。")
+                logger.warning(f"[私聊][{self.private_name}]ConversationInfo 未初始化，无法重置 last_successful_reply_action。")
             return True
         return False
 
@@ -254,7 +254,7 @@ class Conversation:
                 detailed_plain_text=msg_dict.get("detailed_plain_text", ""),
             )
         except Exception as e:
-            logger.warning(f"转换消息时出错: {e}")
+            logger.warning(f"[私聊][{self.private_name}]转换消息时出错: {e}")
             # 可以选择返回 None 或重新抛出异常，这里选择重新抛出以指示问题
             raise ValueError(f"无法将字典转换为 Message 对象: {e}") from e
 
@@ -263,7 +263,7 @@ class Conversation:
     ):
         """处理规划的行动"""
 
-        logger.debug(f"执行行动: {action}, 原因: {reason}")
+        logger.debug(f"[私聊][{self.private_name}]执行行动: {action}, 原因: {reason}")
 
         # 记录action历史 (逻辑不变)
         current_action_record = {
@@ -294,14 +294,14 @@ class Conversation:
 
             while reply_attempt_count < max_reply_attempts and not is_suitable:
                 reply_attempt_count += 1
-                logger.info(f"尝试生成追问回复 (第 {reply_attempt_count}/{max_reply_attempts} 次)...")
+                logger.info(f"[私聊][{self.private_name}]尝试生成追问回复 (第 {reply_attempt_count}/{max_reply_attempts} 次)...")
                 self.state = ConversationState.GENERATING
 
                 # 1. 生成回复 (调用 generate 时传入 action_type)
                 self.generated_reply = await self.reply_generator.generate(
                     observation_info, conversation_info, action_type="send_new_message"
                 )
-                logger.info(f"第 {reply_attempt_count} 次生成的追问回复: {self.generated_reply}")
+                logger.info(f"[私聊][{self.private_name}]第 {reply_attempt_count} 次生成的追问回复: {self.generated_reply}")
 
                 # 2. 检查回复 (逻辑不变)
                 self.state = ConversationState.CHECKING
@@ -315,18 +315,18 @@ class Conversation:
                         retry_count=reply_attempt_count - 1,
                     )
                     logger.info(
-                        f"第 {reply_attempt_count} 次追问检查结果: 合适={is_suitable}, 原因='{check_reason}', 需重新规划={need_replan}"
+                        f"[私聊][{self.private_name}]第 {reply_attempt_count} 次追问检查结果: 合适={is_suitable}, 原因='{check_reason}', 需重新规划={need_replan}"
                     )
                     if is_suitable:
                         final_reply_to_send = self.generated_reply
                         break
                     elif need_replan:
                         logger.warning(
-                            f"第 {reply_attempt_count} 次追问检查建议重新规划，停止尝试。原因: {check_reason}"
+                            f"[私聊][{self.private_name}]第 {reply_attempt_count} 次追问检查建议重新规划，停止尝试。原因: {check_reason}"
                         )
                         break
                 except Exception as check_err:
-                    logger.error(f"第 {reply_attempt_count} 次调用 ReplyChecker (追问) 时出错: {check_err}")
+                    logger.error(f"[私聊][{self.private_name}]第 {reply_attempt_count} 次调用 ReplyChecker (追问) 时出错: {check_err}")
                     check_reason = f"第 {reply_attempt_count} 次检查过程出错: {check_err}"
                     break
 
@@ -334,7 +334,7 @@ class Conversation:
             if is_suitable:
                 # 检查是否有新消息
                 if self._check_new_messages_after_planning():
-                    logger.info("生成追问回复期间收到新消息，取消发送，重新规划行动")
+                    logger.info(f"[私聊][{self.private_name}]生成追问回复期间收到新消息，取消发送，重新规划行动")
                     conversation_info.done_action[action_index].update(
                         {"status": "recall", "final_reason": f"有新消息，取消发送追问: {final_reply_to_send}"}
                     )
@@ -351,7 +351,7 @@ class Conversation:
 
             else:
                 # 追问失败
-                logger.warning(f"经过 {reply_attempt_count} 次尝试，未能生成合适的追问回复。最终原因: {check_reason}")
+                logger.warning(f"[私聊][{self.private_name}]经过 {reply_attempt_count} 次尝试，未能生成合适的追问回复。最终原因: {check_reason}")
                 conversation_info.done_action[action_index].update(
                     {"status": "recall", "final_reason": f"追问尝试{reply_attempt_count}次后失败: {check_reason}"}
                 )
@@ -359,7 +359,7 @@ class Conversation:
                 self.conversation_info.last_successful_reply_action = None
 
                 # 执行 Wait 操作
-                logger.info("由于无法生成合适追问回复，执行 'wait' 操作...")
+                logger.info(f"[私聊][{self.private_name}]由于无法生成合适追问回复，执行 'wait' 操作...")
                 self.state = ConversationState.WAITING
                 await self.waiter.wait(self.conversation_info)
                 wait_action_record = {
@@ -381,14 +381,14 @@ class Conversation:
 
             while reply_attempt_count < max_reply_attempts and not is_suitable:
                 reply_attempt_count += 1
-                logger.info(f"尝试生成首次回复 (第 {reply_attempt_count}/{max_reply_attempts} 次)...")
+                logger.info(f"[私聊][{self.private_name}]尝试生成首次回复 (第 {reply_attempt_count}/{max_reply_attempts} 次)...")
                 self.state = ConversationState.GENERATING
 
                 # 1. 生成回复
                 self.generated_reply = await self.reply_generator.generate(
                     observation_info, conversation_info, action_type="direct_reply"
                 )
-                logger.info(f"第 {reply_attempt_count} 次生成的首次回复: {self.generated_reply}")
+                logger.info(f"[私聊][{self.private_name}]第 {reply_attempt_count} 次生成的首次回复: {self.generated_reply}")
 
                 # 2. 检查回复
                 self.state = ConversationState.CHECKING
@@ -402,18 +402,18 @@ class Conversation:
                         retry_count=reply_attempt_count - 1,
                     )
                     logger.info(
-                        f"第 {reply_attempt_count} 次首次回复检查结果: 合适={is_suitable}, 原因='{check_reason}', 需重新规划={need_replan}"
+                        f"[私聊][{self.private_name}]第 {reply_attempt_count} 次首次回复检查结果: 合适={is_suitable}, 原因='{check_reason}', 需重新规划={need_replan}"
                     )
                     if is_suitable:
                         final_reply_to_send = self.generated_reply
                         break
                     elif need_replan:
                         logger.warning(
-                            f"第 {reply_attempt_count} 次首次回复检查建议重新规划，停止尝试。原因: {check_reason}"
+                            f"[私聊][{self.private_name}]第 {reply_attempt_count} 次首次回复检查建议重新规划，停止尝试。原因: {check_reason}"
                         )
                         break
                 except Exception as check_err:
-                    logger.error(f"第 {reply_attempt_count} 次调用 ReplyChecker (首次回复) 时出错: {check_err}")
+                    logger.error(f"[私聊][{self.private_name}]第 {reply_attempt_count} 次调用 ReplyChecker (首次回复) 时出错: {check_err}")
                     check_reason = f"第 {reply_attempt_count} 次检查过程出错: {check_err}"
                     break
 
@@ -421,7 +421,7 @@ class Conversation:
             if is_suitable:
                 # 检查是否有新消息
                 if self._check_new_messages_after_planning():
-                    logger.info("生成首次回复期间收到新消息，取消发送，重新规划行动")
+                    logger.info(f"[私聊][{self.private_name}]生成首次回复期间收到新消息，取消发送，重新规划行动")
                     conversation_info.done_action[action_index].update(
                         {"status": "recall", "final_reason": f"有新消息，取消发送首次回复: {final_reply_to_send}"}
                     )
@@ -438,7 +438,7 @@ class Conversation:
 
             else:
                 # 首次回复失败
-                logger.warning(f"经过 {reply_attempt_count} 次尝试，未能生成合适的首次回复。最终原因: {check_reason}")
+                logger.warning(f"[私聊][{self.private_name}]经过 {reply_attempt_count} 次尝试，未能生成合适的首次回复。最终原因: {check_reason}")
                 conversation_info.done_action[action_index].update(
                     {"status": "recall", "final_reason": f"首次回复尝试{reply_attempt_count}次后失败: {check_reason}"}
                 )
@@ -446,7 +446,7 @@ class Conversation:
                 self.conversation_info.last_successful_reply_action = None
 
                 # 执行 Wait 操作 (保持原有逻辑)
-                logger.info("由于无法生成合适首次回复，执行 'wait' 操作...")
+                logger.info(f"[私聊][{self.private_name}]由于无法生成合适首次回复，执行 'wait' 操作...")
                 self.state = ConversationState.WAITING
                 await self.waiter.wait(self.conversation_info)
                 wait_action_record = {
@@ -464,11 +464,11 @@ class Conversation:
             try:
                 # 检查 knowledge_fetcher 是否存在
                 if not hasattr(self, "knowledge_fetcher"):
-                    logger.error("KnowledgeFetcher 未初始化，无法获取知识。")
+                    logger.error(f"[私聊][{self.private_name}]KnowledgeFetcher 未初始化，无法获取知识。")
                     raise AttributeError("KnowledgeFetcher not initialized")
 
                 knowledge, source = await self.knowledge_fetcher.fetch(knowledge_query, observation_info.chat_history)
-                logger.info(f"获取到知识: {knowledge[:100]}..., 来源: {source}")
+                logger.info(f"[私聊][{self.private_name}]获取到知识: {knowledge[:100]}..., 来源: {source}")
                 if knowledge:
                     # 确保 knowledge_list 存在
                     if not hasattr(conversation_info, "knowledge_list"):
@@ -478,7 +478,7 @@ class Conversation:
                     )
                 action_successful = True
             except Exception as fetch_err:
-                logger.error(f"获取知识时出错: {fetch_err}")
+                logger.error(f"[私聊][{self.private_name}]获取知识时出错: {fetch_err}")
                 conversation_info.done_action[action_index].update(
                     {"status": "recall", "final_reason": f"获取知识失败: {fetch_err}"}
                 )
@@ -489,12 +489,12 @@ class Conversation:
             try:
                 # 检查 goal_analyzer 是否存在
                 if not hasattr(self, "goal_analyzer"):
-                    logger.error("GoalAnalyzer 未初始化，无法重新思考目标。")
+                    logger.error(f"[私聊][{self.private_name}]GoalAnalyzer 未初始化，无法重新思考目标。")
                     raise AttributeError("GoalAnalyzer not initialized")
                 await self.goal_analyzer.analyze_goal(conversation_info, observation_info)
                 action_successful = True
             except Exception as rethink_err:
-                logger.error(f"重新思考目标时出错: {rethink_err}")
+                logger.error(f"[私聊][{self.private_name}]重新思考目标时出错: {rethink_err}")
                 conversation_info.done_action[action_index].update(
                     {"status": "recall", "final_reason": f"重新思考目标失败: {rethink_err}"}
                 )
@@ -502,16 +502,16 @@ class Conversation:
 
         elif action == "listening":
             self.state = ConversationState.LISTENING
-            logger.info("倾听对方发言...")
+            logger.info(f"[私聊][{self.private_name}]倾听对方发言...")
             try:
                 # 检查 waiter 是否存在
                 if not hasattr(self, "waiter"):
-                    logger.error("Waiter 未初始化，无法倾听。")
+                    logger.error(f"[私聊][{self.private_name}]Waiter 未初始化，无法倾听。")
                     raise AttributeError("Waiter not initialized")
                 await self.waiter.wait_listening(conversation_info)
                 action_successful = True  # Listening 完成就算成功
             except Exception as listen_err:
-                logger.error(f"倾听时出错: {listen_err}")
+                logger.error(f"[私聊][{self.private_name}]倾听时出错: {listen_err}")
                 conversation_info.done_action[action_index].update(
                     {"status": "recall", "final_reason": f"倾听失败: {listen_err}"}
                 )
@@ -519,29 +519,29 @@ class Conversation:
 
         elif action == "end_conversation":
             self.should_continue = False
-            logger.info("决定结束对话...")
+            logger.info(f"[私聊][{self.private_name}]决定结束对话...")
             action_successful = True  # 标记动作成功
 
         elif action == "block_and_ignore":
-            logger.info("不想再理你了...")
+            logger.info(f"[私聊][{self.private_name}]不想再理你了...")
             ignore_duration_seconds = 10 * 60
             self.ignore_until_timestamp = time.time() + ignore_duration_seconds
-            logger.info(f"将忽略此对话直到: {datetime.datetime.fromtimestamp(self.ignore_until_timestamp)}")
+            logger.info(f"[私聊][{self.private_name}]将忽略此对话直到: {datetime.datetime.fromtimestamp(self.ignore_until_timestamp)}")
             self.state = ConversationState.IGNORED
             action_successful = True  # 标记动作成功
 
         else:  # 对应 'wait' 动作
             self.state = ConversationState.WAITING
-            logger.info("等待更多信息...")
+            logger.info(f"[私聊][{self.private_name}]等待更多信息...")
             try:
                 # 检查 waiter 是否存在
                 if not hasattr(self, "waiter"):
-                    logger.error("Waiter 未初始化，无法等待。")
+                    logger.error(f"[私聊][{self.private_name}]Waiter 未初始化，无法等待。")
                     raise AttributeError("Waiter not initialized")
                 _timeout_occurred = await self.waiter.wait(self.conversation_info)
                 action_successful = True  # Wait 完成就算成功
             except Exception as wait_err:
-                logger.error(f"等待时出错: {wait_err}")
+                logger.error(f"[私聊][{self.private_name}]等待时出错: {wait_err}")
                 conversation_info.done_action[action_index].update(
                     {"status": "recall", "final_reason": f"等待失败: {wait_err}"}
                 )
@@ -559,13 +559,13 @@ class Conversation:
             # 重置状态: 对于非回复类动作的成功，清除上次回复状态
             if action not in ["direct_reply", "send_new_message"]:
                 self.conversation_info.last_successful_reply_action = None
-                logger.debug(f"动作 {action} 成功完成，重置 last_successful_reply_action")
+                logger.debug(f"[私聊][{self.private_name}]动作 {action} 成功完成，重置 last_successful_reply_action")
         # 如果动作是 recall 状态，在各自的处理逻辑中已经更新了 done_action
 
     async def _send_reply(self):
         """发送回复"""
         if not self.generated_reply:
-            logger.warning("没有生成回复内容，无法发送。")
+            logger.warning(f"[私聊][{self.private_name}]没有生成回复内容，无法发送。")
             return
 
         try:
@@ -574,10 +574,10 @@ class Conversation:
 
             # 发送消息 (确保 direct_sender 和 chat_stream 有效)
             if not hasattr(self, "direct_sender") or not self.direct_sender:
-                logger.error("DirectMessageSender 未初始化，无法发送回复。")
+                logger.error(f"[私聊][{self.private_name}]DirectMessageSender 未初始化，无法发送回复。")
                 return
             if not self.chat_stream:
-                logger.error("ChatStream 未初始化，无法发送回复。")
+                logger.error(f"[私聊][{self.private_name}]ChatStream 未初始化，无法发送回复。")
                 return
 
             await self.direct_sender.send_message(chat_stream=self.chat_stream, content=reply_content)
@@ -587,13 +587,13 @@ class Conversation:
             # 暂时注释掉，观察是否影响 ObservationInfo 的更新
             # self.chat_observer.trigger_update()
             # if not await self.chat_observer.wait_for_update():
-            #     logger.warning("等待 ChatObserver 更新完成超时")
+            #     logger.warning(f"[私聊][{self.private_name}]等待 ChatObserver 更新完成超时")
 
             self.state = ConversationState.ANALYZING  # 更新状态
 
         except Exception as e:
-            logger.error(f"发送消息或更新状态时失败: {str(e)}")
-            logger.error(traceback.format_exc())
+            logger.error(f"[私聊][{self.private_name}]发送消息或更新状态时失败: {str(e)}")
+            logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}")
             self.state = ConversationState.ANALYZING
 
     async def _send_timeout_message(self):
@@ -608,4 +608,4 @@ class Conversation:
                 chat_stream=self.chat_stream, content="TODO:超时消息", reply_to_message=latest_message
             )
         except Exception as e:
-            logger.error(f"发送超时消息失败: {str(e)}")
+            logger.error(f"[私聊][{self.private_name}]发送超时消息失败: {str(e)}")

src/plugins/PFC/message_sender.py

@@ -19,6 +19,7 @@ class DirectMessageSender:
         self,
         chat_stream: ChatStream,
         content: str,
+        private_name: str,
         reply_to_message: Optional[Message] = None,
     ) -> None:
         """发送消息到聊天流
@@ -43,8 +44,8 @@ class DirectMessageSender:
             message_set = MessageSet(chat_stream, message_sending.message_id)
             message_set.add_message(message_sending)
             message_manager.add_message(message_set)
-            logger.info(f"PFC消息已发送: {content}")
+            logger.info(f"[私聊][{private_name}]PFC消息已发送: {content}")
 
         except Exception as e:
-            logger.error(f"PFC消息发送失败: {str(e)}")
+            logger.error(f"[私聊][{private_name}]PFC消息发送失败: {str(e)}")
             raise

src/plugins/PFC/observation_info.py

@@ -15,13 +15,14 @@ logger = get_module_logger("observation_info")
 class ObservationInfoHandler(NotificationHandler):
     """ObservationInfo的通知处理器"""
 
-    def __init__(self, observation_info: "ObservationInfo"):
+    def __init__(self, observation_info: "ObservationInfo", private_name: str):
         """初始化处理器
 
         Args:
             observation_info: 要更新的ObservationInfo实例
         """
         self.observation_info = observation_info
+        self.private_name = private_name
 
     async def handle_notification(self, notification):
         # 获取通知类型和数据
@@ -30,7 +31,7 @@ class ObservationInfoHandler(NotificationHandler):
 
         if notification_type == NotificationType.NEW_MESSAGE:
             # 处理新消息通知
-            logger.debug(f"收到新消息通知data: {data}")
+            logger.debug(f"[私聊][{self.private_name}]收到新消息通知data: {data}")
             message_id = data.get("message_id")
             processed_plain_text = data.get("processed_plain_text")
             detailed_plain_text = data.get("detailed_plain_text")
@@ -89,7 +90,7 @@ class ObservationInfoHandler(NotificationHandler):
         elif notification_type == NotificationType.ERROR:
             # 处理错误通知
             error_msg = data.get("error", "")
-            logger.error(f"收到错误通知: {error_msg}")
+            logger.error(f"[私聊][{self.private_name}]收到错误通知: {error_msg}")
 
 
 @dataclass
@@ -122,12 +123,13 @@ class ObservationInfo:
     # #spec
     # meta_plan_trigger: bool = False
 
-    def __post_init__(self):
+    def __post_init__(self, private_name: str = None):
         """初始化后创建handler"""
         self.chat_observer = None
-        self.handler = ObservationInfoHandler(self)
+        self.handler = ObservationInfoHandler(self, private_name)
+        self.private_name = private_name
 
-    def bind_to_chat_observer(self, chat_observer: ChatObserver):
+    def bind_to_chat_observer(self, chat_observer: ChatObserver, private_name: str):
         """绑定到指定的chat_observer
 
         Args:
@@ -158,7 +160,7 @@ class ObservationInfo:
         Args:
             message: 消息数据
         """
-        # logger.debug(f"更新信息from_message: {message}")
+        # logger.debug(f"[私聊][{self.private_name}]更新信息from_message: {message}")
         self.last_message_time = message["time"]
         self.last_message_id = message["message_id"]
 

src/plugins/PFC/pfc.py

@@ -40,7 +40,7 @@ class GoalAnalyzer:
         self.name = global_config.BOT_NICKNAME
         self.nick_name = global_config.BOT_ALIAS_NAMES
         self.private_name = private_name
-        self.chat_observer = ChatObserver.get_instance(stream_id)
+        self.chat_observer = ChatObserver.get_instance(stream_id, private_name)
 
         # 多目标存储结构
         self.goals = []  # 存储多个目标
@@ -135,27 +135,27 @@ class GoalAnalyzer:
 
 输出格式示例：
 [
-  {{
+{{
     "goal": "回答用户关于Python编程的具体问题",
     "reasoning": "用户提出了关于Python的技术问题，需要专业且准确的解答"
-  }},
-  {{
+}},
+{{
     "goal": "回答用户关于python安装的具体问题",
     "reasoning": "用户提出了关于Python的技术问题，需要专业且准确的解答"
-  }}
+}}
 ]"""
 
-        logger.debug(f"发送到LLM的提示词: {prompt}")
+        logger.debug(f"[私聊][{self.private_name}]发送到LLM的提示词: {prompt}")
         try:
             content, _ = await self.llm.generate_response_async(prompt)
-            logger.debug(f"LLM原始返回内容: {content}")
+            logger.debug(f"[私聊][{self.private_name}]LLM原始返回内容: {content}")
         except Exception as e:
-            logger.error(f"分析对话目标时出错: {str(e)}")
+            logger.error(f"[私聊][{self.private_name}]分析对话目标时出错: {str(e)}")
             content = ""
 
         # 使用改进后的get_items_from_json函数处理JSON数组
         success, result = get_items_from_json(
-            content, "goal", "reasoning", required_types={"goal": str, "reasoning": str}, allow_array=True
+            content, self.private_name, "goal", "reasoning", required_types={"goal": str, "reasoning": str}, allow_array=True
         )
 
         if success:
@@ -287,11 +287,12 @@ class GoalAnalyzer:
 
         try:
             content, _ = await self.llm.generate_response_async(prompt)
-            logger.debug(f"LLM原始返回内容: {content}")
+            logger.debug(f"[私聊][{self.private_name}]LLM原始返回内容: {content}")
 
             # 尝试解析JSON
             success, result = get_items_from_json(
                 content,
+                self.private_name,
                 "goal_achieved",
                 "stop_conversation",
                 "reason",
@@ -299,7 +300,7 @@ class GoalAnalyzer:
             )
 
             if not success:
-                logger.error("无法解析对话分析结果JSON")
+                logger.error(f"[私聊][{self.private_name}]无法解析对话分析结果JSON")
                 return False, False, "解析结果失败"
 
             goal_achieved = result["goal_achieved"]
@@ -309,16 +310,17 @@ class GoalAnalyzer:
             return goal_achieved, stop_conversation, reason
 
         except Exception as e:
-            logger.error(f"分析对话状态时出错: {str(e)}")
+            logger.error(f"[私聊][{self.private_name}]分析对话状态时出错: {str(e)}")
             return False, False, f"分析出错: {str(e)}"
 
 
 class DirectMessageSender:
     """直接发送消息到平台的发送器"""
 
-    def __init__(self):
+    def __init__(self, private_name: str):
         self.logger = get_module_logger("direct_sender")
         self.storage = MessageStorage()
+        self.private_name = private_name
 
     async def send_via_ws(self, message: MessageSending) -> None:
         try:
@@ -368,6 +370,6 @@ class DirectMessageSender:
         try:
             await self.send_via_ws(message)
             await self.storage.store_message(message, chat_stream)
-            logger.success(f"PFC消息已发送: {content}")
+            logger.success(f"[私聊][{self.private_name}]PFC消息已发送: {content}")
         except Exception as e:
-            logger.error(f"PFC消息发送失败: {str(e)}")
+            logger.error(f"[私聊][{self.private_name}]PFC消息发送失败: {str(e)}")

src/plugins/PFC/pfc_KnowledgeFetcher.py

@@ -13,13 +13,14 @@ logger = get_module_logger("knowledge_fetcher")
 class KnowledgeFetcher:
     """知识调取器"""
 
-    def __init__(self):
+    def __init__(self, private_name: str):
         self.llm = LLMRequest(
             model=global_config.llm_normal,
             temperature=global_config.llm_normal["temp"],
             max_tokens=1000,
             request_type="knowledge_fetch",
         )
+        self.private_name = private_name
 
     def _lpmm_get_knowledge(self, query: str) -> str:
         """获取相关知识
@@ -31,13 +32,13 @@ class KnowledgeFetcher:
             str: 构造好的,带相关度的知识
         """
 
-        logger.debug("正在从LPMM知识库中获取知识")
+        logger.debug(f"[私聊][{self.private_name}]正在从LPMM知识库中获取知识")
         try:
             knowledge_info = qa_manager.get_knowledge(query)
-            logger.debug(f"LPMM知识库查询结果: {knowledge_info:150}")
+            logger.debug(f"[私聊][{self.private_name}]LPMM知识库查询结果: {knowledge_info:150}")
             return knowledge_info
         except Exception as e:
-            logger.error(f"LPMM知识库搜索工具执行失败: {str(e)}")
+            logger.error(f"[私聊][{self.private_name}]LPMM知识库搜索工具执行失败: {str(e)}")
             return "未找到匹配的知识"
 
     async def fetch(self, query: str, chat_history: List[Message]) -> Tuple[str, str]:

src/plugins/PFC/pfc_manager.py

@@ -39,11 +39,11 @@ class PFCManager:
         """
         # 检查是否已经有实例
         if stream_id in self._initializing and self._initializing[stream_id]:
-            logger.debug(f"会话实例正在初始化中: {stream_id}")
+            logger.debug(f"[私聊][{private_name}]会话实例正在初始化中: {stream_id}")
             return None
 
         if stream_id in self._instances and self._instances[stream_id].should_continue:
-            logger.debug(f"使用现有会话实例: {stream_id}")
+            logger.debug(f"[私聊][{private_name}]使用现有会话实例: {stream_id}")
             return self._instances[stream_id]
         if stream_id in self._instances:
             instance = self._instances[stream_id]
@@ -52,19 +52,19 @@ class PFCManager:
                 and instance.ignore_until_timestamp
                 and time.time() < instance.ignore_until_timestamp
             ):
-                logger.debug(f"会话实例当前处于忽略状态: {stream_id}")
+                logger.debug(f"[私聊][{private_name}]会话实例当前处于忽略状态: {stream_id}")
                 # 返回 None 阻止交互。或者可以返回实例但标记它被忽略了喵？
                 # 还是返回 None 吧喵。
                 return None
 
             # 检查 should_continue 状态
             if instance.should_continue:
-                logger.debug(f"使用现有会话实例: {stream_id}")
+                logger.debug(f"[私聊][{private_name}]使用现有会话实例: {stream_id}")
                 return instance
         # else: 实例存在但不应继续
         try:
             # 创建新实例
-            logger.info(f"创建新的对话实例: {stream_id}")
+            logger.info(f"[私聊][{private_name}]创建新的对话实例: {stream_id}")
             self._initializing[stream_id] = True
             # 创建实例
             conversation_instance = Conversation(stream_id, private_name)
@@ -73,7 +73,7 @@ class PFCManager:
             # 启动实例初始化
             await self._initialize_conversation(conversation_instance)
         except Exception as e:
-            logger.error(f"创建会话实例失败: {stream_id}, 错误: {e}")
+            logger.error(f"[私聊][{private_name}]创建会话实例失败: {stream_id}, 错误: {e}")
             return None
 
         return conversation_instance
@@ -85,20 +85,21 @@ class PFCManager:
             conversation: 要初始化的会话实例
         """
         stream_id = conversation.stream_id
+        private_name = conversation.private_name
 
         try:
-            logger.info(f"开始初始化会话实例: {stream_id}")
+            logger.info(f"[私聊][{private_name}]开始初始化会话实例: {stream_id}")
             # 启动初始化流程
             await conversation._initialize()
 
             # 标记初始化完成
             self._initializing[stream_id] = False
 
-            logger.info(f"会话实例 {stream_id} 初始化完成")
+            logger.info(f"[私聊][{private_name}]会话实例 {stream_id} 初始化完成")
 
         except Exception as e:
-            logger.error(f"管理器初始化会话实例失败: {stream_id}, 错误: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"[私聊][{private_name}]管理器初始化会话实例失败: {stream_id}, 错误: {e}")
+            logger.error(f"[私聊][{private_name}]{traceback.format_exc()}")
             # 清理失败的初始化
 
     async def get_conversation(self, stream_id: str) -> Optional[Conversation]:

src/plugins/PFC/pfc_utils.py

@@ -8,6 +8,7 @@ logger = get_module_logger("pfc_utils")
 
 def get_items_from_json(
     content: str,
+    private_name: str,
     *items: str,
     default_values: Optional[Dict[str, Any]] = None,
     required_types: Optional[Dict[str, type]] = None,
@@ -78,9 +79,9 @@ def get_items_from_json(
                     if valid_items:
                         return True, valid_items
         except json.JSONDecodeError:
-            logger.debug("JSON数组解析失败，尝试解析单个JSON对象")
+            logger.debug(f"[私聊][{private_name}]JSON数组解析失败，尝试解析单个JSON对象")
         except Exception as e:
-            logger.debug(f"尝试解析JSON数组时出错: {str(e)}")
+            logger.debug(f"[私聊][{private_name}]尝试解析JSON数组时出错: {str(e)}")
 
     # 尝试解析JSON对象
     try:
@@ -93,10 +94,10 @@ def get_items_from_json(
             try:
                 json_data = json.loads(json_match.group())
             except json.JSONDecodeError:
-                logger.error("提取的JSON内容解析失败")
+                logger.error(f"[私聊][{private_name}]提取的JSON内容解析失败")
                 return False, result
         else:
-            logger.error("无法在返回内容中找到有效的JSON")
+            logger.error(f"[私聊][{private_name}]无法在返回内容中找到有效的JSON")
             return False, result
 
     # 提取字段
@@ -106,20 +107,20 @@ def get_items_from_json(
 
     # 验证必需字段
     if not all(item in result for item in items):
-        logger.error(f"JSON缺少必要字段，实际内容: {json_data}")
+        logger.error(f"[私聊][{private_name}]JSON缺少必要字段，实际内容: {json_data}")
         return False, result
 
     # 验证字段类型
     if required_types:
         for field, expected_type in required_types.items():
             if field in result and not isinstance(result[field], expected_type):
-                logger.error(f"{field} 必须是 {expected_type.__name__} 类型")
+                logger.error(f"[私聊][{private_name}]{field} 必须是 {expected_type.__name__} 类型")
                 return False, result
 
     # 验证字符串字段不为空
     for field in items:
         if isinstance(result[field], str) and not result[field].strip():
-            logger.error(f"{field} 不能为空")
+            logger.error(f"[私聊][{private_name}]{field} 不能为空")
             return False, result
 
     return True, result

src/plugins/PFC/reply_checker.py

@@ -12,12 +12,13 @@ logger = get_module_logger("reply_checker")
 class ReplyChecker:
     """回复检查器"""
 
-    def __init__(self, stream_id: str):
+    def __init__(self, stream_id: str, private_name: str):
         self.llm = LLMRequest(
             model=global_config.llm_PFC_reply_checker, temperature=0.50, max_tokens=1000, request_type="reply_check"
         )
         self.name = global_config.BOT_NICKNAME
-        self.chat_observer = ChatObserver.get_instance(stream_id)
+        self.private_name = private_name
+        self.chat_observer = ChatObserver.get_instance(stream_id, private_name)
         self.max_retries = 3  # 最大重试次数
 
     async def check(
@@ -49,7 +50,7 @@ class ReplyChecker:
                 # 可以用简单比较，或者更复杂的相似度库 (如 difflib)
                 # 简单比较：是否完全相同
                 if reply == bot_messages[0]:  # 和最近一条完全一样
-                    logger.warning(f"ReplyChecker 检测到回复与上一条 Bot 消息完全相同: '{reply}'")
+                    logger.warning(f"[私聊][{self.private_name}]ReplyChecker 检测到回复与上一条 Bot 消息完全相同: '{reply}'")
                     return (
                         False,
                         "回复内容与你上一条发言完全相同，请修改，可以选择深入话题或寻找其它话题或等待",
@@ -60,13 +61,13 @@ class ReplyChecker:
 
                 # 计算编辑距离相似度，ratio() 返回 0 到 1 之间的浮点数
                 similarity_ratio = difflib.SequenceMatcher(None, reply, bot_messages[0]).ratio()
-                logger.debug(f"ReplyChecker - 相似度: {similarity_ratio:.2f}")
+                logger.debug(f"[私聊][{self.private_name}]ReplyChecker - 相似度: {similarity_ratio:.2f}")
 
                 # 设置一个相似度阈值
                 similarity_threshold = 0.9
                 if similarity_ratio > similarity_threshold:
                     logger.warning(
-                        f"ReplyChecker 检测到回复与上一条 Bot 消息高度相似 (相似度 {similarity_ratio:.2f}): '{reply}'"
+                        f"[私聊][{self.private_name}]ReplyChecker 检测到回复与上一条 Bot 消息高度相似 (相似度 {similarity_ratio:.2f}): '{reply}'"
                     )
                     return (
                         False,
@@ -77,8 +78,8 @@ class ReplyChecker:
         except Exception as e:
             import traceback
 
-            logger.error(f"检查回复时出错: 类型={type(e)}, 值={e}")
-            logger.error(traceback.format_exc())  # 打印详细的回溯信息
+            logger.error(f"[私聊][{self.private_name}]检查回复时出错: 类型={type(e)}, 值={e}")
+            logger.error(f"[私聊][{self.private_name}]{traceback.format_exc()}")  # 打印详细的回溯信息
 
         prompt = f"""请检查以下回复或消息是否合适：
 
@@ -118,7 +119,7 @@ class ReplyChecker:
 
         try:
             content, _ = await self.llm.generate_response_async(prompt)
-            logger.debug(f"检查回复的原始返回: {content}")
+            logger.debug(f"[私聊][{self.private_name}]检查回复的原始返回: {content}")
 
             # 清理内容，尝试提取JSON部分
             content = content.strip()
@@ -171,7 +172,7 @@ class ReplyChecker:
             return suitable, reason, need_replan
 
         except Exception as e:
-            logger.error(f"检查回复时出错: {e}")
+            logger.error(f"[私聊][{self.private_name}]检查回复时出错: {e}")
             # 如果出错且已达到最大重试次数，建议重新规划
             if retry_count >= self.max_retries:
                 return False, "多次检查失败，建议重新规划", True

src/plugins/PFC/reply_generator.py

@@ -72,8 +72,8 @@ class ReplyGenerator:
         self.identity_detail_info = Individuality.get_instance().get_prompt(type="identity", x_person=2, level=2)
         self.name = global_config.BOT_NICKNAME
         self.private_name = private_name
-        self.chat_observer = ChatObserver.get_instance(stream_id)
-        self.reply_checker = ReplyChecker(stream_id)
+        self.chat_observer = ChatObserver.get_instance(stream_id, private_name)
+        self.reply_checker = ReplyChecker(stream_id, private_name)
 
     # 修改 generate 方法签名，增加 action_type 参数
     async def generate(
@@ -90,7 +90,7 @@ class ReplyGenerator:
             str: 生成的回复
         """
         # 构建提示词
-        logger.debug(f"开始生成回复 (动作类型: {action_type})：当前目标: {conversation_info.goal_list}")
+        logger.debug(f"[私聊][{self.private_name}]开始生成回复 (动作类型: {action_type})：当前目标: {conversation_info.goal_list}")
 
         # --- 构建通用 Prompt 参数 ---
         # (这部分逻辑基本不变)
@@ -146,10 +146,10 @@ class ReplyGenerator:
         # --- 选择 Prompt ---
         if action_type == "send_new_message":
             prompt_template = PROMPT_SEND_NEW_MESSAGE
-            logger.info("使用 PROMPT_SEND_NEW_MESSAGE (追问生成)")
+            logger.info(f"[私聊][{self.private_name}]使用 PROMPT_SEND_NEW_MESSAGE (追问生成)")
         else:  # 默认使用 direct_reply 的 prompt
             prompt_template = PROMPT_DIRECT_REPLY
-            logger.info("使用 PROMPT_DIRECT_REPLY (首次/非连续回复生成)")
+            logger.info(f"[私聊][{self.private_name}]使用 PROMPT_DIRECT_REPLY (首次/非连续回复生成)")
 
         # --- 格式化最终的 Prompt ---
         prompt = prompt_template.format(
@@ -157,15 +157,15 @@ class ReplyGenerator:
         )
 
         # --- 调用 LLM 生成 ---
-        logger.debug(f"发送到LLM的生成提示词:\n------\n{prompt}\n------")
+        logger.debug(f"[私聊][{self.private_name}]发送到LLM的生成提示词:\n------\n{prompt}\n------")
         try:
             content, _ = await self.llm.generate_response_async(prompt)
-            logger.debug(f"生成的回复: {content}")
+            logger.debug(f"[私聊][{self.private_name}]生成的回复: {content}")
             # 移除旧的检查新消息逻辑，这应该由 conversation 控制流处理
             return content
 
         except Exception as e:
-            logger.error(f"生成回复时出错: {e}")
+            logger.error(f"[私聊][{self.private_name}]生成回复时出错: {e}")
             return "抱歉，我现在有点混乱，让我重新思考一下..."
 
     # check_reply 方法保持不变

src/plugins/PFC/waiter.py

@@ -18,7 +18,7 @@ class Waiter:
     """等待处理类"""
 
     def __init__(self, stream_id: str, private_name: str):
-        self.chat_observer = ChatObserver.get_instance(stream_id)
+        self.chat_observer = ChatObserver.get_instance(stream_id, private_name)
         self.name = global_config.BOT_NICKNAME
         self.private_name = private_name
         # self.wait_accumulated_time = 0 # 不再需要累加计时
@@ -26,52 +26,52 @@ class Waiter:
     async def wait(self, conversation_info: ConversationInfo) -> bool:
         """等待用户新消息或超时"""
         wait_start_time = time.time()
-        logger.info(f"进入常规等待状态 (超时: {DESIRED_TIMEOUT_SECONDS} 秒)...")
+        logger.info(f"[私聊][{self.private_name}]进入常规等待状态 (超时: {DESIRED_TIMEOUT_SECONDS} 秒)...")
 
         while True:
             # 检查是否有新消息
             if self.chat_observer.new_message_after(wait_start_time):
-                logger.info("等待结束，收到新消息")
+                logger.info(f"[私聊][{self.private_name}]等待结束，收到新消息")
                 return False  # 返回 False 表示不是超时
 
             # 检查是否超时
             elapsed_time = time.time() - wait_start_time
             if elapsed_time > DESIRED_TIMEOUT_SECONDS:
-                logger.info(f"等待超过 {DESIRED_TIMEOUT_SECONDS} 秒...添加思考目标。")
+                logger.info(f"[私聊][{self.private_name}]等待超过 {DESIRED_TIMEOUT_SECONDS} 秒...添加思考目标。")
                 wait_goal = {
                     "goal": f"你等待了{elapsed_time / 60:.1f}分钟，注意可能在对方看来聊天已经结束，思考接下来要做什么",
                     "reasoning": "对方很久没有回复你的消息了",
                 }
                 conversation_info.goal_list.append(wait_goal)
-                logger.info(f"添加目标: {wait_goal}")
+                logger.info(f"[私聊][{self.private_name}]添加目标: {wait_goal}")
                 return True  # 返回 True 表示超时
 
             await asyncio.sleep(5)  # 每 5 秒检查一次
-            logger.debug("等待中...")  # 可以考虑把这个频繁日志注释掉，只在超时或收到消息时输出
+            logger.debug(f"[私聊][{self.private_name}]等待中...")  # 可以考虑把这个频繁日志注释掉，只在超时或收到消息时输出
 
     async def wait_listening(self, conversation_info: ConversationInfo) -> bool:
         """倾听用户发言或超时"""
         wait_start_time = time.time()
-        logger.info(f"进入倾听等待状态 (超时: {DESIRED_TIMEOUT_SECONDS} 秒)...")
+        logger.info(f"[私聊][{self.private_name}]进入倾听等待状态 (超时: {DESIRED_TIMEOUT_SECONDS} 秒)...")
 
         while True:
             # 检查是否有新消息
             if self.chat_observer.new_message_after(wait_start_time):
-                logger.info("倾听等待结束，收到新消息")
+                logger.info(f"[私聊][{self.private_name}]倾听等待结束，收到新消息")
                 return False  # 返回 False 表示不是超时
 
             # 检查是否超时
             elapsed_time = time.time() - wait_start_time
             if elapsed_time > DESIRED_TIMEOUT_SECONDS:
-                logger.info(f"倾听等待超过 {DESIRED_TIMEOUT_SECONDS} 秒...添加思考目标。")
+                logger.info(f"[私聊][{self.private_name}]倾听等待超过 {DESIRED_TIMEOUT_SECONDS} 秒...添加思考目标。")
                 wait_goal = {
                     # 保持 goal 文本一致
                     "goal": f"你等待了{elapsed_time / 60:.1f}分钟，对方似乎话说一半突然消失了，可能忙去了？也可能忘记了回复？要问问吗？还是结束对话？或继续等待？思考接下来要做什么",
                     "reasoning": "对方话说一半消失了，很久没有回复",
                 }
                 conversation_info.goal_list.append(wait_goal)
-                logger.info(f"添加目标: {wait_goal}")
+                logger.info(f"[私聊][{self.private_name}]添加目标: {wait_goal}")
                 return True  # 返回 True 表示超时
 
             await asyncio.sleep(5)  # 每 5 秒检查一次
-            logger.debug("倾听等待中...")  # 同上，可以考虑注释掉
+            logger.debug(f"[私聊][{self.private_name}]倾听等待中...")  # 同上，可以考虑注释掉