Losita/mai-bot
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

FEAT:PPPPfc in群聊，优化聊天流相关功能，新增获取聊天流名称的方法，调整日志输出以包含流名称，改进心流对话的提示信息，移除冗余代码，增强代码可读性。

Browse Source
This commit is contained in:
SengokuCola
2025-04-18 00:26:44 +08:00
parent e3d22b571b
commit 09160d2499
5 changed files with 190 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

221
src/plugins/chat_module/heartFC_chat/pf_chatting.py
View File

@@ -92,11 +92,18 @@ class PFChatting:
self._loop_active: bool = False # Is the loop currently running?
self._loop_task: Optional[asyncio.Task] = None # Stores the main loop task
self._trigger_count_this_activation: int = 0 # Counts triggers within an active period
self._initial_duration: float = 10.0 # 首次触发增加的时间
self._last_added_duration: float = self._initial_duration # <--- 新增：存储上次增加的时间
# Removed pending_replies as processing is now serial within the loop
# self.pending_replies: Dict[str, PendingReply] = {}
def _get_log_prefix(self) -> str:
"""获取日志前缀，包含可读的流名称"""
stream_name = chat_manager.get_stream_name(self.stream_id) or self.stream_id
return f"[{stream_name}]"
async def _initialize(self) -> bool:
"""
Lazy initialization to resolve chat_stream and sub_hf using the provided identifier.
@@ -105,95 +112,97 @@ class PFChatting:
async with self._init_lock:
if self._initialized:
return True
log_prefix = self._get_log_prefix() # 获取前缀
try:
self.chat_stream = chat_manager.get_stream(self.stream_id)
if not self.chat_stream:
logger.error(f"PFChatting-{self.stream_id} 获取ChatStream失败。")
logger.error(f"{log_prefix} 获取ChatStream失败。")
return False
# 子心流(SubHeartflow)可能初始不存在但后续会被创建
# 在需要它的方法中应优雅处理其可能缺失的情况
self.sub_hf = heartflow.get_subheartflow(self.stream_id)
if not self.sub_hf:
logger.warning(f"PFChatting-{self.stream_id} 获取SubHeartflow失败。一些功能可能受限。")
logger.warning(f"{log_prefix} 获取SubHeartflow失败。一些功能可能受限。")
# 决定是否继续初始化。目前允许初始化。
self._initialized = True
logger.info(f"PFChatting-{self.stream_id} 初始化成功。")
logger.info(f"麦麦感觉到了，激发了PFChatting{log_prefix} 初始化成功。")
return True
except Exception as e:
logger.error(f"PFChatting-{self.stream_id} 初始化失败: {e}")
logger.error(f"{log_prefix} 初始化失败: {e}")
logger.error(traceback.format_exc())
return False
async def add_time(self):
"""
Adds time to the loop timer with decay and starts the loop if it's not active.
Called externally (e.g., by HeartFC_Chat) to trigger or extend activity.
Durations: 1st trigger = 10s, 2nd = 5s, 3rd+ = 2s.
First trigger adds initial duration, subsequent triggers add 50% of the previous addition.
"""
log_prefix = self._get_log_prefix()
if not self._initialized:
if not await self._initialize():
logger.error(f"PFChatting-{self.stream_id} 无法添加时间: 未初始化。")
logger.error(f"{log_prefix} 无法添加时间: 未初始化。")
return
async with self._timer_lock:
duration_to_add: float = 0.0
if not self._loop_active: # First trigger for this activation cycle
duration_to_add = 10.0
self._trigger_count_this_activation = 1 # Start counting for this activation
logger.info(f"[{self.stream_id}] First trigger in activation. Adding {duration_to_add:.1f}s.")
else: # Loop is already active, apply decay
duration_to_add = self._initial_duration # 使用初始值
self._last_added_duration = duration_to_add # 更新上次增加的值
self._trigger_count_this_activation = 1 # Start counting
logger.info(f"{log_prefix} First trigger in activation. Adding {duration_to_add:.2f}s.")
else: # Loop is already active, apply 50% reduction
self._trigger_count_this_activation += 1
if self._trigger_count_this_activation == 2:
duration_to_add = 5.0
logger.info(f"[{self.stream_id}] 2nd trigger in activation. Adding {duration_to_add:.1f}s.")
else: # 3rd trigger or more
duration_to_add = 2.0
logger.info(f"[{self.stream_id}] {self._trigger_count_this_activation}rd/+ trigger in activation. Adding {duration_to_add:.1f}s.")
duration_to_add = self._last_added_duration * 0.5
self._last_added_duration = duration_to_add # 更新上次增加的值
logger.info(f"{log_prefix} Trigger #{self._trigger_count_this_activation}. Adding {duration_to_add:.2f}s (50% of previous). Timer was {self._loop_timer:.1f}s.")
# 添加计算出的时间
new_timer_value = self._loop_timer + duration_to_add
self._loop_timer = max(0, new_timer_value) # Ensure timer doesn't go negative conceptually
logger.info(f"[{self.stream_id}] Timer is now {self._loop_timer:.1f}s.")
self._loop_timer = max(0, new_timer_value)
logger.info(f"{log_prefix} Timer is now {self._loop_timer:.1f}s.")
# Start the loop if it wasn't active and timer is positive
if not self._loop_active and self._loop_timer > 0:
logger.info(f"[{self.stream_id}] Timer > 0 and loop not active. Starting PF loop.")
logger.info(f"{log_prefix} Timer > 0 and loop not active. Starting PF loop.")
self._loop_active = True
# Cancel previous task just in case (shouldn't happen if logic is correct)
if self._loop_task and not self._loop_task.done():
logger.warning(f"[{self.stream_id}] Found existing loop task unexpectedly during start. Cancelling it.")
logger.warning(f"{log_prefix} Found existing loop task unexpectedly during start. Cancelling it.")
self._loop_task.cancel()
self._loop_task = asyncio.create_task(self._run_pf_loop())
# Add callback to reset state if loop finishes or errors out
self._loop_task.add_done_callback(self._handle_loop_completion)
elif self._loop_active:
logger.debug(f"[{self.stream_id}] Loop already active. Timer extended.")
logger.debug(f"{log_prefix} Loop already active. Timer extended.")
def _handle_loop_completion(self, task: asyncio.Task):
"""Callback executed when the _run_pf_loop task finishes."""
log_prefix = self._get_log_prefix()
try:
# Check if the task raised an exception
exception = task.exception()
if exception:
logger.error(f"[{self.stream_id}] PF loop task completed with error: {exception}")
logger.error(f"{log_prefix} PF loop task completed with error: {exception}")
logger.error(traceback.format_exc())
else:
logger.info(f"[{self.stream_id}] PF loop task completed normally (timer likely expired or cancelled).")
logger.info(f"{log_prefix} PF loop task completed normally (timer likely expired or cancelled).")
except asyncio.CancelledError:
logger.info(f"[{self.stream_id}] PF loop task was cancelled.")
logger.info(f"{log_prefix} PF loop task was cancelled.")
finally:
# Reset state regardless of how the task finished
self._loop_active = False
self._loop_task = None
self._last_added_duration = self._initial_duration # <--- 重置下次首次触发的增加时间
self._trigger_count_this_activation = 0 # 重置计数器
# Ensure lock is released if the loop somehow exited while holding it
if self._processing_lock.locked():
logger.warning(f"[{self.stream_id}] Releasing processing lock after loop task completion.")
logger.warning(f"{log_prefix} Releasing processing lock after loop task completion.")
self._processing_lock.release()
logger.info(f"[{self.stream_id}] Loop state reset.")
logger.info(f"{log_prefix} Loop state reset.")
async def _run_pf_loop(self):
@@ -201,14 +210,14 @@ class PFChatting:
主循环，当计时器>0时持续进行计划并可能回复消息
管理每个循环周期的处理锁
"""
logger.info(f"[{self.stream_id}] 开始执行PF循环")
logger.info(f"{self._get_log_prefix()} 开始执行PF循环")
try:
while True:
# 使用计时器锁安全地检查当前计时器值
async with self._timer_lock:
current_timer = self._loop_timer
if current_timer <= 0:
logger.info(f"[{self.stream_id}] 计时器为零或负数({current_timer:.1f}秒)，退出PF循环")
logger.info(f"{self._get_log_prefix()} 计时器为零或负数({current_timer:.1f}秒)，退出PF循环")
break # 退出条件：计时器到期
# 记录循环开始时间
@@ -221,7 +230,7 @@ class PFChatting:
try:
await self._processing_lock.acquire()
acquired_lock = True
logger.debug(f"[{self.stream_id}] 循环获取到处理锁")
logger.debug(f"{self._get_log_prefix()} 循环获取到处理锁")
# --- Planner ---
# Planner decides action, reasoning, emoji_query, etc.
@@ -234,16 +243,16 @@ class PFChatting:
observed_messages = planner_result.get("observed_messages", []) # Planner needs to return this
if action == "text_reply":
logger.info(f"[{self.stream_id}] 计划循环决定: 回复文本.")
logger.info(f"{self._get_log_prefix()} 计划循环决定: 回复文本.")
action_taken_this_cycle = True
# --- 回复器 ---
anchor_message = await self._get_anchor_message(observed_messages)
if not anchor_message:
logger.error(f"[{self.stream_id}] 循环: 无法获取锚点消息用于回复. 跳过周期.")
logger.error(f"{self._get_log_prefix()} 循环: 无法获取锚点消息用于回复. 跳过周期.")
else:
thinking_id = await self.heartfc_chat._create_thinking_message(anchor_message)
if not thinking_id:
logger.error(f"[{self.stream_id}] 循环: 无法创建思考ID. 跳过周期.")
logger.error(f"{self._get_log_prefix()} 循环: 无法创建思考ID. 跳过周期.")
else:
replier_result = None
try:
@@ -256,7 +265,7 @@ class PFChatting:
send_emoji=send_emoji_from_tools
)
except Exception as e_replier:
logger.error(f"[{self.stream_id}] 循环: 回复器工作失败: {e_replier}")
logger.error(f"{self._get_log_prefix()} 循环: 回复器工作失败: {e_replier}")
self._cleanup_thinking_message(thinking_id) # 清理思考消息
# 继续循环, 视为非操作周期
@@ -264,61 +273,61 @@ class PFChatting:
# --- Sender ---
try:
await self._sender(thinking_id, anchor_message, replier_result)
logger.info(f"[{self.stream_id}] 循环: 发送器完成成功.")
logger.info(f"{self._get_log_prefix()} 循环: 发送器完成成功.")
except Exception as e_sender:
logger.error(f"[{self.stream_id}] 循环: 发送器失败: {e_sender}")
logger.error(f"{self._get_log_prefix()} 循环: 发送器失败: {e_sender}")
self._cleanup_thinking_message(thinking_id) # 确保发送失败时清理
# 继续循环, 视为非操作周期
else:
# Replier failed to produce result
logger.warning(f"[{self.stream_id}] 循环: 回复器未产生结果. 跳过发送.")
logger.warning(f"{self._get_log_prefix()} 循环: 回复器未产生结果. 跳过发送.")
self._cleanup_thinking_message(thinking_id) # 清理思考消息
elif action == "emoji_reply":
logger.info(f"[{self.stream_id}] 计划循环决定: 回复表情 ('{emoji_query}').")
logger.info(f"{self._get_log_prefix()} 计划循环决定: 回复表情 ('{emoji_query}').")
action_taken_this_cycle = True
anchor = await self._get_anchor_message(observed_messages)
if anchor:
try:
await self.heartfc_chat._handle_emoji(anchor, [], emoji_query)
except Exception as e_emoji:
logger.error(f"[{self.stream_id}] 循环: 发送表情失败: {e_emoji}")
logger.error(f"{self._get_log_prefix()} 循环: 发送表情失败: {e_emoji}")
else:
logger.warning(f"[{self.stream_id}] 循环: 无法发送表情, 无法获取锚点.")
logger.warning(f"{self._get_log_prefix()} 循环: 无法发送表情, 无法获取锚点.")
elif action == "no_reply":
logger.info(f"[{self.stream_id}] 计划循环决定: 不回复. 原因: {reasoning}")
logger.info(f"{self._get_log_prefix()} 计划循环决定: 不回复. 原因: {reasoning}")
# Do nothing else, action_taken_this_cycle remains False
elif action == "error":
logger.error(f"[{self.stream_id}] 计划循环返回错误或失败. 原因: {reasoning}")
logger.error(f"{self._get_log_prefix()} 计划循环返回错误或失败. 原因: {reasoning}")
# 视为非操作周期
else: # Unknown action
logger.warning(f"[{self.stream_id}] 计划循环返回未知动作: {action}. 视为不回复.")
logger.warning(f"{self._get_log_prefix()} 计划循环返回未知动作: {action}. 视为不回复.")
# 视为非操作周期
except Exception as e_cycle:
# Catch errors occurring within the locked section (e.g., planner crash)
logger.error(f"[{self.stream_id}] 循环周期执行时发生错误: {e_cycle}")
logger.error(f"{self._get_log_prefix()} 循环周期执行时发生错误: {e_cycle}")
logger.error(traceback.format_exc())
# Ensure lock is released if an error occurs before the finally block
if acquired_lock and self._processing_lock.locked():
self._processing_lock.release()
acquired_lock = False # 防止在 finally 块中重复释放
logger.warning(f"[{self.stream_id}] 由于循环周期中的错误释放了处理锁.")
logger.warning(f"{self._get_log_prefix()} 由于循环周期中的错误释放了处理锁.")
finally:
# Ensure the lock is always released after a cycle
if acquired_lock:
self._processing_lock.release()
logger.debug(f"[{self.stream_id}] 循环释放了处理锁.")
logger.debug(f"{self._get_log_prefix()} 循环释放了处理锁.")
# --- Timer Decrement ---
cycle_duration = time.monotonic() - loop_cycle_start_time
async with self._timer_lock:
self._loop_timer -= cycle_duration
logger.debug(f"[{self.stream_id}] 循环周期耗时 {cycle_duration:.2f}s. 计时器剩余: {self._loop_timer:.1f}s.")
logger.debug(f"{self._get_log_prefix()} 循环周期耗时 {cycle_duration:.2f}s. 计时器剩余: {self._loop_timer:.1f}s.")
# --- Delay ---
# Add a small delay, especially if no action was taken, to prevent busy-waiting
@@ -329,21 +338,21 @@ class PFChatting:
elif cycle_duration < 0.2: # Minimum delay even if action was taken
await asyncio.sleep(0.2)
except asyncio.CancelledError:
logger.info(f"[{self.stream_id}] Sleep interrupted, likely loop cancellation.")
logger.info(f"{self._get_log_prefix()} Sleep interrupted, likely loop cancellation.")
break # Exit loop if cancelled during sleep
except asyncio.CancelledError:
logger.info(f"[{self.stream_id}] PF loop task received cancellation request.")
logger.info(f"{self._get_log_prefix()} PF loop task received cancellation request.")
except Exception as e_loop_outer:
# Catch errors outside the main cycle lock (should be rare)
logger.error(f"[{self.stream_id}] PF loop encountered unexpected outer error: {e_loop_outer}")
logger.error(f"{self._get_log_prefix()} PF loop encountered unexpected outer error: {e_loop_outer}")
logger.error(traceback.format_exc())
finally:
# Reset trigger count when loop finishes
async with self._timer_lock:
self._trigger_count_this_activation = 0
logger.debug(f"[{self.stream_id}] Trigger count reset to 0 as loop finishes.")
logger.info(f"[{self.stream_id}] PF loop finished execution run.")
logger.debug(f"{self._get_log_prefix()} Trigger count reset to 0 as loop finishes.")
logger.info(f"{self._get_log_prefix()} PF loop finished execution run.")
# State reset (_loop_active, _loop_task) is handled by _handle_loop_completion callback
async def _planner(self) -> Dict[str, Any]:
@@ -353,6 +362,7 @@ class PFChatting:
{'action': str, 'reasoning': str, 'emoji_query': str, 'current_mind': str,
'send_emoji_from_tools': str, 'observed_messages': List[dict]}
"""
log_prefix = self._get_log_prefix()
observed_messages: List[dict] = []
tool_result_info = {}
get_mid_memory_id = []
@@ -363,14 +373,14 @@ class PFChatting:
try:
if self.sub_hf and self.sub_hf._get_primary_observation():
observation = self.sub_hf._get_primary_observation()
logger.debug(f"[{self.stream_id}][Planner] 调用 observation.observe()...")
logger.debug(f"{log_prefix}[Planner] 调用 observation.observe()...")
await observation.observe() # 主动观察以获取最新消息
observed_messages = observation.talking_message # 获取更新后的消息列表
logger.debug(f"[{self.stream_id}][Planner] 获取到 {len(observed_messages)} 条观察消息。")
logger.debug(f"{log_prefix}[Planner] 获取到 {len(observed_messages)} 条观察消息。")
else:
logger.warning(f"[{self.stream_id}][Planner] 无法获取 SubHeartflow 或 Observation 来获取消息。")
logger.warning(f"{log_prefix}[Planner] 无法获取 SubHeartflow 或 Observation 来获取消息。")
except Exception as e:
logger.error(f"[{self.stream_id}][Planner] 获取观察信息时出错: {e}")
logger.error(f"{log_prefix}[Planner] 获取观察信息时出错: {e}")
logger.error(traceback.format_exc())
# --- 结束获取观察信息 ---
@@ -380,7 +390,7 @@ class PFChatting:
if observed_messages:
context_texts = [msg.get('detailed_plain_text', '') for msg in observed_messages if msg.get('detailed_plain_text')]
observation_context_text = "\n".join(context_texts)
logger.debug(f"[{self.stream_id}][Planner] Context for tools: {observation_context_text[:100]}...")
logger.debug(f"{log_prefix}[Planner] Context for tools: {observation_context_text[:100]}...")
if observation_context_text and self.sub_hf:
# Ensure SubHeartflow exists for tool use context
@@ -391,16 +401,16 @@ class PFChatting:
)
if tool_result.get("used_tools", False):
tool_result_info = tool_result.get("structured_info", {})
logger.debug(f"[{self.stream_id}][Planner] Tool results: {tool_result_info}")
logger.debug(f"{log_prefix}[Planner] Tool results: {tool_result_info}")
if "mid_chat_mem" in tool_result_info:
get_mid_memory_id = [mem["content"] for mem in tool_result_info["mid_chat_mem"] if "content" in mem]
if "send_emoji" in tool_result_info and tool_result_info["send_emoji"]:
send_emoji_from_tools = tool_result_info["send_emoji"][0].get("content", "") # Use renamed var
elif not self.sub_hf:
logger.warning(f"[{self.stream_id}][Planner] Skipping tool use because SubHeartflow is not available.")
logger.warning(f"{log_prefix}[Planner] Skipping tool use because SubHeartflow is not available.")
except Exception as e_tool:
logger.error(f"[PFChatting-{self.stream_id}][Planner] Tool use failed: {e_tool}")
logger.error(f"{log_prefix}[Planner] Tool use failed: {e_tool}")
# Continue even if tool use fails
# --- 结束工具使用 ---
@@ -413,13 +423,13 @@ class PFChatting:
extra_info=tool_result_info,
obs_id=get_mid_memory_id,
)
logger.info(f"[{self.stream_id}][Planner] SubHeartflow thought: {current_mind}")
logger.info(f"{log_prefix}[Planner] SubHeartflow thought: {current_mind}")
else:
logger.warning(f"[{self.stream_id}][Planner] Skipping SubHeartflow thinking because it is not available.")
logger.warning(f"{log_prefix}[Planner] Skipping SubHeartflow thinking because it is not available.")
current_mind = "[心流思考不可用]" # Set a default/indicator value
except Exception as e_shf:
logger.error(f"[PFChatting-{self.stream_id}][Planner] SubHeartflow thinking failed: {e_shf}")
logger.error(f"{log_prefix}[Planner] SubHeartflow thinking failed: {e_shf}")
logger.error(traceback.format_exc())
current_mind = "[心流思考出错]"
@@ -433,7 +443,7 @@ class PFChatting:
try:
# 构建提示 (Now includes current_mind)
prompt = self._build_planner_prompt(observed_messages, current_mind)
logger.trace(f"[{self.stream_id}][Planner] Prompt: {prompt}")
logger.debug(f"{log_prefix}[Planner] Prompt: {prompt}")
# 准备 LLM 请求 Payload
payload = {
@@ -443,7 +453,7 @@ class PFChatting:
"tool_choice": {"type": "function", "function": {"name": "decide_reply_action"}}, # 强制调用此工具
}
logger.debug(f"[{self.stream_id}][Planner] 发送 Planner LLM 请求...")
logger.debug(f"{log_prefix}[Planner] 发送 Planner LLM 请求...")
# 调用 LLM
response = await self.planner_llm._execute_request(
endpoint="/chat/completions", payload=payload, prompt=prompt
@@ -463,25 +473,25 @@ class PFChatting:
if action == "emoji_reply":
# Planner's decision overrides tool's emoji if action is emoji_reply
emoji_query = arguments.get("emoji_query", send_emoji_from_tools) # Use tool emoji as default if planner asks for emoji
logger.info(f"[{self.stream_id}][Planner] LLM 决策: {action}, 理由: {reasoning}, EmojiQuery: '{emoji_query}'")
logger.info(f"{log_prefix}[Planner] LLM 决策: {action}, 理由: {reasoning}, EmojiQuery: '{emoji_query}'")
except json.JSONDecodeError as json_e:
logger.error(f"[{self.stream_id}][Planner] 解析工具参数失败: {json_e}. Arguments: {tool_call['function'].get('arguments')}")
logger.error(f"{log_prefix}[Planner] 解析工具参数失败: {json_e}. Arguments: {tool_call['function'].get('arguments')}")
action = "error"; reasoning = "工具参数解析失败"; llm_error = True
except Exception as parse_e:
logger.error(f"[{self.stream_id}][Planner] 处理工具参数时出错: {parse_e}")
logger.error(f"{log_prefix}[Planner] 处理工具参数时出错: {parse_e}")
action = "error"; reasoning = "处理工具参数时出错"; llm_error = True
else:
logger.warning(f"[{self.stream_id}][Planner] LLM 未按预期调用 'decide_reply_action' 工具。Tool calls: {tool_calls}")
logger.warning(f"{log_prefix}[Planner] LLM 未按预期调用 'decide_reply_action' 工具。Tool calls: {tool_calls}")
action = "error"; reasoning = "LLM未调用预期工具"; llm_error = True
else:
logger.warning(f"[{self.stream_id}][Planner] LLM 响应中未包含有效的工具调用。Tool calls: {tool_calls}")
logger.warning(f"{log_prefix}[Planner] LLM 响应中未包含有效的工具调用。Tool calls: {tool_calls}")
action = "error"; reasoning = "LLM响应无工具调用"; llm_error = True
else:
logger.warning(f"[{self.stream_id}][Planner] LLM 未返回预期的工具调用响应。Response parts: {len(response)}")
logger.warning(f"{log_prefix}[Planner] LLM 未返回预期的工具调用响应。Response parts: {len(response)}")
action = "error"; reasoning = "LLM响应格式错误"; llm_error = True
except Exception as llm_e:
logger.error(f"[{self.stream_id}][Planner] Planner LLM 调用失败: {llm_e}")
logger.error(f"{log_prefix}[Planner] Planner LLM 调用失败: {llm_e}")
logger.error(traceback.format_exc())
action = "error"; reasoning = f"LLM 调用失败: {llm_e}"; llm_error = True
@@ -503,7 +513,7 @@ class PFChatting:
如果重构失败或观察为空，则创建一个占位符。
"""
if not self.chat_stream:
logger.error(f"[PFChatting-{self.stream_id}] 无法获取锚点消息: ChatStream 不可用.")
logger.error(f"{self._get_log_prefix()} 无法获取锚点消息: ChatStream 不可用.")
return None
try:
@@ -518,12 +528,12 @@ class PFChatting:
# Basic validation
if not (anchor_message and anchor_message.message_info and anchor_message.message_info.message_id and anchor_message.message_info.user_info):
raise ValueError("重构的 MessageRecv 缺少必要信息.")
logger.debug(f"[{self.stream_id}] 重构的锚点消息: ID={anchor_message.message_info.message_id}")
logger.debug(f"{self._get_log_prefix()} 重构的锚点消息: ID={anchor_message.message_info.message_id}")
return anchor_message
except Exception as e_reconstruct:
logger.warning(f"[{self.stream_id}] 从观察到的消息重构 MessageRecv 失败: {e_reconstruct}. 创建占位符.")
logger.warning(f"{self._get_log_prefix()} 从观察到的消息重构 MessageRecv 失败: {e_reconstruct}. 创建占位符.")
else:
logger.warning(f"[{self.stream_id}] observed_messages 为空. 创建占位符锚点消息.")
logger.warning(f"{self._get_log_prefix()} observed_messages 为空. 创建占位符锚点消息.")
# --- Create Placeholder ---
placeholder_id = f"mid_pf_{int(time.time() * 1000)}"
@@ -543,11 +553,11 @@ class PFChatting:
}
anchor_message = MessageRecv(placeholder_msg_dict)
anchor_message.update_chat_stream(self.chat_stream) # Associate with the stream
logger.info(f"[{self.stream_id}] Created placeholder anchor message: ID={anchor_message.message_info.message_id}")
logger.info(f"{self._get_log_prefix()} Created placeholder anchor message: ID={anchor_message.message_info.message_id}")
return anchor_message
except Exception as e:
logger.error(f"[PFChatting-{self.stream_id}] Error getting/creating anchor message: {e}")
logger.error(f"{self._get_log_prefix()} Error getting/creating anchor message: {e}")
logger.error(traceback.format_exc())
return None
@@ -556,9 +566,9 @@ class PFChatting:
try:
container = MessageManager().get_container(self.stream_id)
container.remove_message(thinking_id, msg_type=MessageThinking)
logger.debug(f"[{self.stream_id}] Cleaned up thinking message {thinking_id}.")
logger.debug(f"{self._get_log_prefix()} Cleaned up thinking message {thinking_id}.")
except Exception as e:
logger.error(f"[{self.stream_id}] Error cleaning up thinking message {thinking_id}: {e}")
logger.error(f"{self._get_log_prefix()} Error cleaning up thinking message {thinking_id}: {e}")
async def _sender(self, thinking_id: str, anchor_message: MessageRecv, replier_result: Dict[str, Any]):
@@ -573,7 +583,7 @@ class PFChatting:
send_emoji = replier_result.get("send_emoji", "") # Emoji determined by tools, passed via replier
if not response_set:
logger.error(f"[PFChatting-{self.stream_id}][Sender-{thinking_id}] Called with empty response_set.")
logger.error(f"{self._get_log_prefix()}[Sender-{thinking_id}] Called with empty response_set.")
# Clean up thinking message before raising error
self._cleanup_thinking_message(thinking_id)
raise ValueError("Sender called with no response_set") # Signal failure to loop
@@ -582,44 +592,44 @@ class PFChatting:
send_success = False
try:
# --- Send the main text response ---
logger.debug(f"[{self.stream_id}][Sender-{thinking_id}] Sending response messages...")
logger.debug(f"{self._get_log_prefix()}[Sender-{thinking_id}] Sending response messages...")
# This call implicitly handles replacing the MessageThinking with MessageSending/MessageSet
first_bot_msg = await self.heartfc_chat._send_response_messages(anchor_message, response_set, thinking_id)
if first_bot_msg:
send_success = True # Mark success
logger.info(f"[PFChatting-{self.stream_id}][Sender-{thinking_id}] Successfully sent reply.")
logger.info(f"{self._get_log_prefix()}[Sender-{thinking_id}] Successfully sent reply.")
# --- Handle associated emoji (if determined by tools) ---
if send_emoji:
logger.info(f"[PFChatting-{self.stream_id}][Sender-{thinking_id}] Sending associated emoji: {send_emoji}")
logger.info(f"{self._get_log_prefix()}[Sender-{thinking_id}] Sending associated emoji: {send_emoji}")
try:
# Use first_bot_msg as anchor if available, otherwise fallback to original anchor
emoji_anchor = first_bot_msg if first_bot_msg else anchor_message
await self.heartfc_chat._handle_emoji(emoji_anchor, response_set, send_emoji)
except Exception as e_emoji:
logger.error(f"[PFChatting-{self.stream_id}][Sender-{thinking_id}] Failed to send associated emoji: {e_emoji}")
logger.error(f"{self._get_log_prefix()}[Sender-{thinking_id}] Failed to send associated emoji: {e_emoji}")
# Log error but don't fail the whole send process for emoji failure
# --- Update relationship ---
try:
await self.heartfc_chat._update_relationship(anchor_message, response_set)
logger.debug(f"[PFChatting-{self.stream_id}][Sender-{thinking_id}] Updated relationship.")
logger.debug(f"{self._get_log_prefix()}[Sender-{thinking_id}] Updated relationship.")
except Exception as e_rel:
logger.error(f"[PFChatting-{self.stream_id}][Sender-{thinking_id}] Failed to update relationship: {e_rel}")
logger.error(f"{self._get_log_prefix()}[Sender-{thinking_id}] Failed to update relationship: {e_rel}")
# Log error but don't fail the whole send process for relationship update failure
else:
# Sending failed (e.g., _send_response_messages found thinking message already gone)
send_success = False
logger.warning(f"[PFChatting-{self.stream_id}][Sender-{thinking_id}] Failed to send reply (maybe thinking message expired or was removed?).")
logger.warning(f"{self._get_log_prefix()}[Sender-{thinking_id}] Failed to send reply (maybe thinking message expired or was removed?).")
# No need to clean up thinking message here, _send_response_messages implies it's gone or handled
raise RuntimeError("Sending reply failed, _send_response_messages returned None.") # Signal failure
except Exception as e:
# Catch potential errors during sending or post-send actions
logger.error(f"[PFChatting-{self.stream_id}][Sender-{thinking_id}] Error during sending process: {e}")
logger.error(f"{self._get_log_prefix()}[Sender-{thinking_id}] Error during sending process: {e}")
logger.error(traceback.format_exc())
# Ensure thinking message is cleaned up if send failed mid-way and wasn't handled
if not send_success:
@@ -633,21 +643,21 @@ class PFChatting:
"""
Gracefully shuts down the PFChatting instance by cancelling the active loop task.
"""
logger.info(f"[{self.stream_id}] Shutting down PFChatting...")
logger.info(f"{self._get_log_prefix()} Shutting down PFChatting...")
if self._loop_task and not self._loop_task.done():
logger.info(f"[{self.stream_id}] Cancelling active PF loop task.")
logger.info(f"{self._get_log_prefix()} Cancelling active PF loop task.")
self._loop_task.cancel()
try:
# Wait briefly for the task to acknowledge cancellation
await asyncio.wait_for(self._loop_task, timeout=5.0)
except asyncio.CancelledError:
logger.info(f"[{self.stream_id}] PF loop task cancelled successfully.")
logger.info(f"{self._get_log_prefix()} PF loop task cancelled successfully.")
except asyncio.TimeoutError:
logger.warning(f"[{self.stream_id}] Timeout waiting for PF loop task cancellation.")
logger.warning(f"{self._get_log_prefix()} Timeout waiting for PF loop task cancellation.")
except Exception as e:
logger.error(f"[{self.stream_id}] Error during loop task cancellation: {e}")
logger.error(f"{self._get_log_prefix()} Error during loop task cancellation: {e}")
else:
logger.info(f"[{self.stream_id}] No active PF loop task found to cancel.")
logger.info(f"{self._get_log_prefix()} No active PF loop task found to cancel.")
# Ensure loop state is reset even if task wasn't running or cancellation failed
self._loop_active = False
@@ -655,15 +665,14 @@ class PFChatting:
# Double-check lock state (should be released by loop completion/cancellation handler)
if self._processing_lock.locked():
logger.warning(f"[{self.stream_id}] Releasing processing lock during shutdown.")
logger.warning(f"{self._get_log_prefix()} Releasing processing lock during shutdown.")
self._processing_lock.release()
logger.info(f"[{self.stream_id}] PFChatting shutdown complete.")
logger.info(f"{self._get_log_prefix()} PFChatting shutdown complete.")
def _build_planner_prompt(self, observed_messages: List[dict], current_mind: Optional[str]) -> str:
"""构建 Planner LLM 的提示词 (现在包含 current_mind)"""
prompt = "你是一个聊天机器人助手，正在决定是否以及如何回应当前的聊天。\n"
prompt += f"你的名字是 {global_config.BOT_NICKNAME}。\n"
prompt = f"你的名字是 {global_config.BOT_NICKNAME}。是一个女大二学生，正在QQ聊天，正在决定是否以及如何回应当前的聊天。\n"
# Add current mind state if available
if current_mind:
@@ -684,6 +693,7 @@ class PFChatting:
prompt += "1. 如果聊天内容无聊、与你无关、或者你的内部想法认为不适合回复，选择 'no_reply'。\n"
prompt += "2. 如果聊天内容值得回应，且适合用文字表达（参考你的内部想法），选择 'text_reply'。\n"
prompt += "3. 如果聊天内容或你的内部想法适合用一个表情来回应，选择 'emoji_reply' 并提供表情主题 'emoji_query'。\n"
prompt += "4. 如果你已经回复过消息，也没有人又回复你，选择'no_reply'。"
prompt += "必须调用 'decide_reply_action' 工具并提供 'action' 和 'reasoning'。"
return prompt
@@ -695,12 +705,13 @@ class PFChatting:
被 _run_pf_loop 直接调用和 await。
Returns dict with 'response_set' and 'send_emoji' or None on failure.
"""
log_prefix = self._get_log_prefix()
response_set: Optional[List[str]] = None
try:
# --- Tool Use and SubHF Thinking are now in _planner ---
# --- Generate Response with LLM ---
logger.debug(f"[{self.stream_id}][Replier-{thinking_id}] Calling LLM to generate response...")
logger.debug(f"{log_prefix}[Replier-{thinking_id}] Calling LLM to generate response...")
# 注意：实际的生成调用是在 self.heartfc_chat.gpt.generate_response 中
response_set = await self.heartfc_chat.gpt.generate_response(
anchor_message,
@@ -710,17 +721,17 @@ class PFChatting:
)
if not response_set:
logger.warning(f"[{self.stream_id}][Replier-{thinking_id}] LLM生成了一个空回复集。")
logger.warning(f"{log_prefix}[Replier-{thinking_id}] LLM生成了一个空回复集。")
return None # Indicate failure
# --- 准备并返回结果 ---
logger.info(f"[{self.stream_id}][Replier-{thinking_id}] 成功生成了回复集: {' '.join(response_set)[:50]}...")
logger.info(f"{log_prefix}[Replier-{thinking_id}] 成功生成了回复集: {' '.join(response_set)[:50]}...")
return {
"response_set": response_set,
"send_emoji": send_emoji, # Pass through the emoji determined earlier (usually by tools)
}
except Exception as e:
logger.error(f"[PFChatting-{self.stream_id}][Replier-{thinking_id}] Unexpected error in replier_work: {e}")
logger.error(f"{log_prefix}[Replier-{thinking_id}] Unexpected error in replier_work: {e}")
logger.error(traceback.format_exc())
return None # Indicate failure