gardel/Mofox-Core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

🤖 自动格式化代码 [skip ci]

Browse Source
This commit is contained in:
github-actions[bot]
2025-04-18 03:37:20 +00:00
parent c0dcd578c9
commit dfe788c65c
12 changed files with 610 additions and 487 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/plugins/chat/bot.py
View File

@@ -122,11 +122,9 @@ class ChatBot:
# logger.debug(f"开始群聊模式{str(message_data)[:50]}...")
if global_config.response_mode == "heart_flow":
# logger.info(f"启动最新最好的思维流FC模式{str(message_data)[:50]}...")
await self.heartFC_processor.process_message(message_data)
elif global_config.response_mode == "reasoning":
# logger.debug(f"开始推理模式{str(message_data)[:50]}...")
await self.reasoning_chat.process_message(message_data)

12
src/plugins/chat_module/heartFC_chat/heartFC__generator.py
View File

@@ -37,7 +37,11 @@ class ResponseGenerator:
self.current_model_type = "r1" # 默认使用 R1
self.current_model_name = "unknown model"
async def generate_response(self, message: MessageRecv, thinking_id: str,) -> Optional[List[str]]:
async def generate_response(
self,
message: MessageRecv,
thinking_id: str,
) -> Optional[List[str]]:
"""根据当前模型类型选择对应的生成函数"""
logger.info(
@@ -47,16 +51,12 @@ class ResponseGenerator:
arousal_multiplier = MoodManager.get_instance().get_arousal_multiplier()
with Timer() as t_generate_response:
current_model = self.model_normal
current_model.temperature = (
global_config.llm_normal["temp"] * arousal_multiplier
) # 激活度越高，温度越高
current_model.temperature = global_config.llm_normal["temp"] * arousal_multiplier # 激活度越高，温度越高
model_response = await self._generate_response_with_model(
message, current_model, thinking_id, mode="normal"
)
if model_response:
logger.info(
f"{global_config.BOT_NICKNAME}的回复是：{model_response},生成回复时间: {t_generate_response.human_readable}"

147
src/plugins/chat_module/heartFC_chat/heartFC_chat.py
View File

@@ -33,15 +33,16 @@ logger = get_module_logger("heartFC_chat", config=chat_config)
# 新增常量
INTEREST_MONITOR_INTERVAL_SECONDS = 1
class HeartFC_Chat:
_instance = None # For potential singleton access if needed by MessageManager
_instance = None # For potential singleton access if needed by MessageManager
def __init__(self):
# --- Updated Init ---
if HeartFC_Chat._instance is not None:
# Prevent re-initialization if used as a singleton
return
self.logger = logger # Make logger accessible via self
self.logger = logger # Make logger accessible via self
self.gpt = ResponseGenerator()
self.mood_manager = MoodManager.get_instance()
self.mood_manager.start_mood_update()
@@ -52,13 +53,14 @@ class HeartFC_Chat:
self.pf_chatting_instances: Dict[str, PFChatting] = {}
self._pf_chatting_lock = Lock()
# --- End New PFChatting Management ---
HeartFC_Chat._instance = self # Register instance
HeartFC_Chat._instance = self # Register instance
# --- End Updated Init ---
# --- Added Class Method for Singleton Access ---
@classmethod
def get_instance(cls):
return cls._instance
# --- End Added Class Method ---
async def start(self):
@@ -76,8 +78,8 @@ class HeartFC_Chat:
self._interest_monitor_task = loop.create_task(self._interest_monitor_loop())
logger.info(f"兴趣监控任务已创建。监控间隔: {INTEREST_MONITOR_INTERVAL_SECONDS}秒。")
except RuntimeError:
logger.error("创建兴趣监控任务失败：没有运行中的事件循环。")
raise
logger.error("创建兴趣监控任务失败：没有运行中的事件循环。")
raise
else:
logger.warning("跳过兴趣监控任务创建：任务已存在或正在运行。")
@@ -95,6 +97,7 @@ class HeartFC_Chat:
return None
self.pf_chatting_instances[stream_id] = instance
return self.pf_chatting_instances[stream_id]
# --- End Added PFChatting Instance Manager ---
async def _interest_monitor_loop(self):
@@ -107,7 +110,7 @@ class HeartFC_Chat:
# logger.trace(f"检查 {len(active_stream_ids)} 个活跃流是否足以开启心流对话...") # 调试日志
for stream_id in active_stream_ids:
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
sub_hf = heartflow.get_subheartflow(stream_id)
if not sub_hf:
logger.warning(f"监控循环: 无法获取活跃流 {stream_name} 的 sub_hf")
@@ -121,7 +124,9 @@ class HeartFC_Chat:
# if should_trigger:
# logger.info(f"[{stream_name}] 基于兴趣概率决定启动交流模式 (概率: {interest_chatting.current_reply_probability:.4f})。")
else:
logger.trace(f"[{stream_name}] 没有找到对应的 InterestChatting 实例，跳过基于兴趣的触发检查。")
logger.trace(
f"[{stream_name}] 没有找到对应的 InterestChatting 实例，跳过基于兴趣的触发检查。"
)
except Exception as e:
logger.error(f"检查兴趣触发器时出错 流 {stream_name}: {e}")
logger.error(traceback.format_exc())
@@ -140,7 +145,7 @@ class HeartFC_Chat:
except Exception as e:
logger.error(f"兴趣监控循环错误: {e}")
logger.error(traceback.format_exc())
await asyncio.sleep(5) # 发生错误时等待
await asyncio.sleep(5) # 发生错误时等待
async def _create_thinking_message(self, anchor_message: Optional[MessageRecv]):
"""创建思考消息 (尝试锚定到 anchor_message)"""
@@ -162,14 +167,16 @@ class HeartFC_Chat:
message_id=thinking_id,
chat_stream=chat,
bot_user_info=bot_user_info,
reply=anchor_message, # 回复的是锚点消息
reply=anchor_message, # 回复的是锚点消息
thinking_start_time=thinking_time_point,
)
MessageManager().add_message(thinking_message)
return thinking_id
async def _send_response_messages(self, anchor_message: Optional[MessageRecv], response_set: List[str], thinking_id) -> Optional[MessageSending]:
async def _send_response_messages(
self, anchor_message: Optional[MessageRecv], response_set: List[str], thinking_id
) -> Optional[MessageSending]:
"""发送回复消息 (尝试锚定到 anchor_message)"""
if not anchor_message or not anchor_message.chat_stream:
logger.error("无法发送回复，缺少有效的锚点消息或聊天流。")
@@ -184,7 +191,7 @@ class HeartFC_Chat:
container.messages.remove(msg)
break
if not thinking_message:
stream_name = chat_manager.get_stream_name(chat.stream_id) or chat.stream_id # 获取流名称
stream_name = chat_manager.get_stream_name(chat.stream_id) or chat.stream_id # 获取流名称
logger.warning(f"[{stream_name}] 未找到对应的思考消息 {thinking_id}，可能已超时被移除")
return None
@@ -195,16 +202,16 @@ class HeartFC_Chat:
for msg_text in response_set:
message_segment = Seg(type="text", data=msg_text)
bot_message = MessageSending(
message_id=thinking_id, # 使用 thinking_id 作为批次标识
message_id=thinking_id, # 使用 thinking_id 作为批次标识
chat_stream=chat,
bot_user_info=UserInfo(
user_id=global_config.BOT_QQ,
user_nickname=global_config.BOT_NICKNAME,
platform=anchor_message.message_info.platform,
),
sender_info=anchor_message.message_info.user_info, # 发送给锚点消息的用户
sender_info=anchor_message.message_info.user_info, # 发送给锚点消息的用户
message_segment=message_segment,
reply=anchor_message, # 回复锚点消息
reply=anchor_message, # 回复锚点消息
is_head=not mark_head,
is_emoji=False,
thinking_start_time=thinking_start_time,
@@ -214,19 +221,19 @@ class HeartFC_Chat:
first_bot_msg = bot_message
message_set.add_message(bot_message)
if message_set.messages: # 确保有消息才添加
if message_set.messages: # 确保有消息才添加
MessageManager().add_message(message_set)
return first_bot_msg
else:
stream_name = chat_manager.get_stream_name(chat.stream_id) or chat.stream_id # 获取流名称
stream_name = chat_manager.get_stream_name(chat.stream_id) or chat.stream_id # 获取流名称
logger.warning(f"[{stream_name}] 没有生成有效的回复消息集，无法发送。")
return None
async def _handle_emoji(self, anchor_message: Optional[MessageRecv], response_set, send_emoji=""):
"""处理表情包 (尝试锚定到 anchor_message)"""
if not anchor_message or not anchor_message.chat_stream:
logger.error("无法处理表情包，缺少有效的锚点消息或聊天流。")
return
logger.error("无法处理表情包，缺少有效的锚点消息或聊天流。")
return
chat = anchor_message.chat_stream
if send_emoji:
@@ -242,7 +249,7 @@ class HeartFC_Chat:
thinking_time_point = round(time.time(), 2)
message_segment = Seg(type="emoji", data=emoji_cq)
bot_message = MessageSending(
message_id="me" + str(thinking_time_point), # 使用不同的 ID 前缀?
message_id="me" + str(thinking_time_point), # 使用不同的 ID 前缀?
chat_stream=chat,
bot_user_info=UserInfo(
user_id=global_config.BOT_QQ,
@@ -251,7 +258,7 @@ class HeartFC_Chat:
),
sender_info=anchor_message.message_info.user_info,
message_segment=message_segment,
reply=anchor_message, # 回复锚点消息
reply=anchor_message, # 回复锚点消息
is_head=False,
is_emoji=True,
)
@@ -260,8 +267,8 @@ class HeartFC_Chat:
async def _update_relationship(self, anchor_message: Optional[MessageRecv], response_set):
"""更新关系情绪 (尝试基于 anchor_message)"""
if not anchor_message or not anchor_message.chat_stream:
logger.error("无法更新关系情绪，缺少有效的锚点消息或聊天流。")
return
logger.error("无法更新关系情绪，缺少有效的锚点消息或聊天流。")
return
# 关系更新依赖于理解回复是针对谁的，以及原始消息的上下文
# 这里的实现可能需要调整，取决于关系管理器如何工作
@@ -269,18 +276,18 @@ class HeartFC_Chat:
# 注意：anchor_message.processed_plain_text 是锚点消息的文本，不一定是思考的全部上下文
stance, emotion = await self.gpt._get_emotion_tags(ori_response, anchor_message.processed_plain_text)
await relationship_manager.calculate_update_relationship_value(
chat_stream=anchor_message.chat_stream, # 使用锚点消息的流
chat_stream=anchor_message.chat_stream, # 使用锚点消息的流
label=emotion,
stance=stance
stance=stance,
)
self.mood_manager.update_mood_from_emotion(emotion, global_config.mood_intensity_factor)
async def trigger_reply_generation(self, stream_id: str, observed_messages: List[dict]):
"""根据 SubHeartflow 的触发信号生成回复 (基于观察)"""
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # <--- 在开始时获取名称
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # <--- 在开始时获取名称
chat = None
sub_hf = None
anchor_message: Optional[MessageRecv] = None # <--- 重命名，用于锚定回复的消息对象
anchor_message: Optional[MessageRecv] = None # <--- 重命名，用于锚定回复的消息对象
userinfo: Optional[UserInfo] = None
messageinfo: Optional[BaseMessageInfo] = None
@@ -303,9 +310,9 @@ class HeartFC_Chat:
logger.error(f"[{stream_name}] 无法找到子心流对象，无法生成回复。")
return
except Exception as e:
logger.error(f"[{stream_name}] 获取 ChatStream 或 SubHeartflow 时出错: {e}")
logger.error(traceback.format_exc())
return
logger.error(f"[{stream_name}] 获取 ChatStream 或 SubHeartflow 时出错: {e}")
logger.error(traceback.format_exc())
return
# --- 2. 尝试从 observed_messages 重建最后一条消息作为锚点, 失败则创建占位符 --- #
try:
@@ -314,36 +321,49 @@ class HeartFC_Chat:
if observed_messages:
try:
last_msg_dict = observed_messages[-1]
logger.debug(f"[{stream_name}] Attempting to reconstruct MessageRecv from last observed message.")
logger.debug(
f"[{stream_name}] Attempting to reconstruct MessageRecv from last observed message."
)
anchor_message = MessageRecv(last_msg_dict, chat_stream=chat)
if not (anchor_message and anchor_message.message_info and anchor_message.message_info.message_id and anchor_message.message_info.user_info):
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("Reconstructed MessageRecv missing essential info.")
userinfo = anchor_message.message_info.user_info
messageinfo = anchor_message.message_info
logger.debug(f"[{stream_name}] Successfully reconstructed anchor message: ID={messageinfo.message_id}, Sender={userinfo.user_nickname}")
logger.debug(
f"[{stream_name}] Successfully reconstructed anchor message: ID={messageinfo.message_id}, Sender={userinfo.user_nickname}"
)
except Exception as e_reconstruct:
logger.warning(f"[{stream_name}] Reconstructing MessageRecv from observed message failed: {e_reconstruct}. Will create placeholder.")
logger.warning(
f"[{stream_name}] Reconstructing MessageRecv from observed message failed: {e_reconstruct}. Will create placeholder."
)
reconstruction_failed = True
else:
logger.warning(f"[{stream_name}] observed_messages is empty. Will create placeholder anchor message.")
reconstruction_failed = True # Treat empty observed_messages as a failure to reconstruct
logger.warning(
f"[{stream_name}] observed_messages is empty. Will create placeholder anchor message."
)
reconstruction_failed = True # Treat empty observed_messages as a failure to reconstruct
# 如果重建失败或 observed_messages 为空，创建占位符
if reconstruction_failed:
placeholder_id = f"mid_{int(time.time() * 1000)}" # 使用毫秒时间戳增加唯一性
placeholder_id = f"mid_{int(time.time() * 1000)}" # 使用毫秒时间戳增加唯一性
placeholder_user = UserInfo(user_id="system_trigger", user_nickname="系统触发")
placeholder_msg_info = BaseMessageInfo(
message_id=placeholder_id,
platform=chat.platform,
group_info=chat.group_info,
user_info=placeholder_user,
time=time.time()
time=time.time(),
# 其他 BaseMessageInfo 可能需要的字段设为默认值或 None
)
# 创建 MessageRecv 实例，注意它需要消息字典结构，我们创建一个最小化的
placeholder_msg_dict = {
"message_info": placeholder_msg_info.to_dict(),
"processed_plain_text": "", # 提供空文本
"processed_plain_text": "", # 提供空文本
"raw_message": "",
"time": placeholder_msg_info.time,
}
@@ -353,18 +373,20 @@ class HeartFC_Chat:
anchor_message.update_chat_stream(chat)
userinfo = anchor_message.message_info.user_info
messageinfo = anchor_message.message_info
logger.info(f"[{stream_name}] Created placeholder anchor message: ID={messageinfo.message_id}, Sender={userinfo.user_nickname}")
logger.info(
f"[{stream_name}] Created placeholder anchor message: ID={messageinfo.message_id}, Sender={userinfo.user_nickname}"
)
except Exception as e:
logger.error(f"[{stream_name}] 获取或创建锚点消息时出错: {e}")
logger.error(traceback.format_exc())
anchor_message = None # 确保出错时 anchor_message 为 None
anchor_message = None # 确保出错时 anchor_message 为 None
# --- 4. 检查并发思考限制 (使用 anchor_message 简化获取) ---
try:
container = MessageManager().get_container(chat.stream_id)
thinking_count = container.count_thinking_messages()
max_thinking_messages = getattr(global_config, 'max_concurrent_thinking_messages', 3)
max_thinking_messages = getattr(global_config, "max_concurrent_thinking_messages", 3)
if thinking_count >= max_thinking_messages:
logger.warning(f"聊天流 {stream_name} 已有 {thinking_count} 条思考消息，取消回复。")
return
@@ -393,7 +415,7 @@ class HeartFC_Chat:
get_mid_memory_id = []
tool_result_info = {}
send_emoji = ""
observation_context_text = "" # 从 observation 获取上下文文本
observation_context_text = "" # 从 observation 获取上下文文本
try:
# --- 使用传入的 observed_messages 构建上下文文本 --- #
if observed_messages:
@@ -403,20 +425,22 @@ class HeartFC_Chat:
for msg_dict in observed_messages:
# 假设 detailed_plain_text 字段包含所需文本
# 你可能需要更复杂的逻辑来格式化，例如添加发送者和时间
text = msg_dict.get('detailed_plain_text', '')
if text:
text = msg_dict.get("detailed_plain_text", "")
if text:
context_texts.append(text)
observation_context_text = "\n".join(context_texts)
logger.debug(f"[{stream_name}] Context for tools:\n{observation_context_text[-200:]}...") # 打印部分上下文
logger.debug(
f"[{stream_name}] Context for tools:\n{observation_context_text[-200:]}..."
) # 打印部分上下文
else:
logger.warning(f"[{stream_name}] observed_messages 列表为空，无法为工具提供上下文。")
if observation_context_text:
with Timer("思考前使用工具", timing_results):
tool_result = await self.tool_user.use_tool(
message_txt=observation_context_text, # <--- 使用观察上下文
message_txt=observation_context_text, # <--- 使用观察上下文
chat_stream=chat,
sub_heartflow=sub_hf
sub_heartflow=sub_hf,
)
if tool_result.get("used_tools", False):
if "structured_info" in tool_result:
@@ -446,9 +470,9 @@ class HeartFC_Chat:
except Exception as e:
logger.error(f"[{stream_name}] SubHeartflow 思考失败: {e}")
logger.error(traceback.format_exc())
if info_catcher:
if info_catcher:
info_catcher.done_catch()
return # 思考失败则不继续
return # 思考失败则不继续
if info_catcher:
info_catcher.catch_afer_shf_step(timing_results.get("生成内心想法(SubHF)"), past_mind, current_mind)
@@ -458,16 +482,16 @@ class HeartFC_Chat:
# response_set = await self.gpt.generate_response(anchor_message, thinking_id, current_mind=current_mind)
response_set = await self.gpt.generate_response(anchor_message, thinking_id)
except Exception as e:
logger.error(f"[{stream_name}] GPT 生成回复失败: {e}")
logger.error(traceback.format_exc())
if info_catcher:
info_catcher.done_catch()
return
logger.error(f"[{stream_name}] GPT 生成回复失败: {e}")
logger.error(traceback.format_exc())
if info_catcher:
info_catcher.done_catch()
return
if info_catcher:
info_catcher.catch_after_generate_response(timing_results.get("生成最终回复(GPT)"))
if not response_set:
logger.info(f"[{stream_name}] 回复生成失败或为空。")
if info_catcher:
if info_catcher:
info_catcher.done_catch()
return
@@ -481,7 +505,7 @@ class HeartFC_Chat:
logger.error(traceback.format_exc())
if info_catcher:
info_catcher.catch_after_response(timing_results.get("发送消息"), response_set, first_bot_msg)
info_catcher.done_catch() # 完成捕捉
info_catcher.done_catch() # 完成捕捉
# --- 11. 处理表情包 (使用 anchor_message) ---
try:
@@ -496,10 +520,12 @@ class HeartFC_Chat:
# --- 12. 记录性能日志 --- #
timing_str = " | ".join([f"{step}: {duration:.2f}秒" for step, duration in timing_results.items()])
response_msg = " ".join(response_set) if response_set else "无回复"
logger.info(f"[{stream_name}] 回复任务完成 (Observation Triggered): | 思维消息: {response_msg[:30]}... | 性能计时: {timing_str}")
logger.info(
f"[{stream_name}] 回复任务完成 (Observation Triggered): | 思维消息: {response_msg[:30]}... | 性能计时: {timing_str}"
)
# --- 13. 更新关系情绪 (使用 anchor_message) ---
if first_bot_msg: # 仅在成功发送消息后
if first_bot_msg: # 仅在成功发送消息后
try:
with Timer("更新关系情绪", timing_results):
await self._update_relationship(anchor_message, response_set)
@@ -512,8 +538,9 @@ class HeartFC_Chat:
logger.error(traceback.format_exc())
finally:
# 可以在这里添加清理逻辑，如果有的话
pass
# 可以在这里添加清理逻辑，如果有的话
pass
# --- 结束重构 ---
# _create_thinking_message, _send_response_messages, _handle_emoji, _update_relationship

44
src/plugins/chat_module/heartFC_chat/heartFC_processor.py
View File

@@ -12,7 +12,7 @@ from ...chat.chat_stream import chat_manager
from ...chat.message_buffer import message_buffer
from ...utils.timer_calculater import Timer
from .interest import InterestManager
from .heartFC_chat import HeartFC_Chat # 导入 HeartFC_Chat 以调用回复生成
from .heartFC_chat import HeartFC_Chat # 导入 HeartFC_Chat 以调用回复生成
# 定义日志配置
processor_config = LogConfig(
@@ -24,15 +24,18 @@ logger = get_module_logger("heartFC_processor", config=processor_config)
# # 定义兴趣度增加触发回复的阈值 (移至 InterestManager)
# INTEREST_INCREASE_THRESHOLD = 0.5
class HeartFC_Processor:
def __init__(self, chat_instance: HeartFC_Chat):
self.storage = MessageStorage()
self.interest_manager = InterestManager() # TODO: 可能需要传递 chat_instance 给 InterestManager 或修改其方法签名
self.chat_instance = chat_instance # 持有 HeartFC_Chat 实例
self.interest_manager = (
InterestManager()
) # TODO: 可能需要传递 chat_instance 给 InterestManager 或修改其方法签名
self.chat_instance = chat_instance # 持有 HeartFC_Chat 实例
async def process_message(self, message_data: str) -> None:
"""处理接收到的消息，更新状态，并将回复决策委托给 InterestManager"""
timing_results = {} # 初始化 timing_results
timing_results = {} # 初始化 timing_results
message = None
try:
message = MessageRecv(message_data)
@@ -50,7 +53,9 @@ class HeartFC_Processor:
group_info=groupinfo,
)
if not chat:
logger.error(f"无法为消息创建或获取聊天流: user {userinfo.user_id}, group {groupinfo.group_id if groupinfo else 'None'}")
logger.error(
f"无法为消息创建或获取聊天流: user {userinfo.user_id}, group {groupinfo.group_id if groupinfo else 'None'}"
)
return
message.update_chat_stream(chat)
@@ -77,9 +82,11 @@ class HeartFC_Processor:
if message.message_segment.type != "seglist":
F_type = message.message_segment.type
else:
if (isinstance(message.message_segment.data, list)
and all(isinstance(x, Seg) for x in message.message_segment.data)
and len(message.message_segment.data) == 1):
if (
isinstance(message.message_segment.data, list)
and all(isinstance(x, Seg) for x in message.message_segment.data)
and len(message.message_segment.data) == 1
):
F_type = message.message_segment.data[0].type
if F_type == "text":
logger.debug(f"触发缓冲，消息：{message.processed_plain_text}")
@@ -87,7 +94,7 @@ class HeartFC_Processor:
logger.debug("触发缓冲，表情包/图片等待中")
elif F_type == "seglist":
logger.debug("触发缓冲，消息列表等待中")
return # 被缓冲器拦截，不生成回复
return # 被缓冲器拦截，不生成回复
# ---- 只有通过缓冲的消息才进行存储和后续处理 ----
@@ -103,11 +110,12 @@ class HeartFC_Processor:
# 激活度计算 (使用可能被缓冲器更新过的 message.processed_plain_text)
is_mentioned, _ = is_mentioned_bot_in_message(message)
interested_rate = 0.0 # 默认值
interested_rate = 0.0 # 默认值
try:
with Timer("记忆激活", timing_results):
interested_rate = await HippocampusManager.get_instance().get_activate_from_text(
message.processed_plain_text, fast_retrieval=True # 使用更新后的文本
message.processed_plain_text,
fast_retrieval=True, # 使用更新后的文本
)
logger.trace(f"记忆激活率 (通过缓冲后): {interested_rate:.2f}")
except Exception as e:
@@ -120,11 +128,13 @@ class HeartFC_Processor:
# 更新兴趣度
try:
self.interest_manager.increase_interest(chat.stream_id, value=interested_rate)
current_interest = self.interest_manager.get_interest(chat.stream_id) # 获取更新后的值用于日志
logger.trace(f"使用激活率 {interested_rate:.2f} 更新后 (通过缓冲后)，当前兴趣度: {current_interest:.2f}")
current_interest = self.interest_manager.get_interest(chat.stream_id) # 获取更新后的值用于日志
logger.trace(
f"使用激活率 {interested_rate:.2f} 更新后 (通过缓冲后)，当前兴趣度: {current_interest:.2f}"
)
except Exception as e:
logger.error(f"更新兴趣度失败: {e}") # 调整日志消息
logger.error(f"更新兴趣度失败: {e}") # 调整日志消息
logger.error(traceback.format_exc())
# ---- 兴趣度计算和更新结束 ----
@@ -143,8 +153,8 @@ class HeartFC_Processor:
except Exception as e:
logger.error(f"消息处理失败 (process_message V3): {e}")
logger.error(traceback.format_exc())
if message: # 记录失败的消息内容
logger.error(f"失败消息原始内容: {message.raw_message}")
if message: # 记录失败的消息内容
logger.error(f"失败消息原始内容: {message.raw_message}")
def _check_ban_words(self, text: str, chat, userinfo) -> bool:
"""检查消息中是否包含过滤词"""
@@ -166,4 +176,4 @@ class HeartFC_Processor:
)
logger.info(f"[正则表达式过滤]消息匹配到{pattern}，filtered")
return True
return False
return False

196
src/plugins/chat_module/heartFC_chat/interest.py
View File

@@ -2,57 +2,60 @@ import time
import math
import asyncio
import threading
import json # 引入 json
import os # 引入 os
from typing import Optional # <--- 添加导入
import random # <--- 添加导入 random
from src.common.logger import get_module_logger, LogConfig, DEFAULT_CONFIG # 引入 DEFAULT_CONFIG
from src.plugins.chat.chat_stream import chat_manager # *** Import ChatManager ***
import json # 引入 json
import os # 引入 os
from typing import Optional # <--- 添加导入
import random # <--- 添加导入 random
from src.common.logger import get_module_logger, LogConfig, DEFAULT_CONFIG # 引入 DEFAULT_CONFIG
from src.plugins.chat.chat_stream import chat_manager # *** Import ChatManager ***
# 定义日志配置 (使用 loguru 格式)
interest_log_config = LogConfig(
console_format=DEFAULT_CONFIG["console_format"], # 使用默认控制台格式
file_format=DEFAULT_CONFIG["file_format"] # 使用默认文件格式
console_format=DEFAULT_CONFIG["console_format"], # 使用默认控制台格式
file_format=DEFAULT_CONFIG["file_format"], # 使用默认文件格式
)
logger = get_module_logger("InterestManager", config=interest_log_config)
# 定义常量
DEFAULT_DECAY_RATE_PER_SECOND = 0.98 # 每秒衰减率 (兴趣保留 99%)
MAX_INTEREST = 15.0 # 最大兴趣值
MAX_INTEREST = 15.0 # 最大兴趣值
# MIN_INTEREST_THRESHOLD = 0.1 # 低于此值可能被清理 (可选)
CLEANUP_INTERVAL_SECONDS = 3600 # 清理任务运行间隔 (例如：1小时)
CLEANUP_INTERVAL_SECONDS = 3600 # 清理任务运行间隔 (例如：1小时)
INACTIVE_THRESHOLD_SECONDS = 3600 # 不活跃时间阈值 (例如：1小时)
LOG_INTERVAL_SECONDS = 3 # 日志记录间隔 (例如：30秒)
LOG_DIRECTORY = "logs/interest" # 日志目录
LOG_FILENAME = "interest_log.json" # 快照日志文件名 (保留，以防其他地方用到)
HISTORY_LOG_FILENAME = "interest_history.log" # 新的历史日志文件名
LOG_DIRECTORY = "logs/interest" # 日志目录
LOG_FILENAME = "interest_log.json" # 快照日志文件名 (保留，以防其他地方用到)
HISTORY_LOG_FILENAME = "interest_history.log" # 新的历史日志文件名
# 移除阈值，将移至 HeartFC_Chat
# INTEREST_INCREASE_THRESHOLD = 0.5
# --- 新增：概率回复相关常量 ---
REPLY_TRIGGER_THRESHOLD = 3.0 # 触发概率回复的兴趣阈值 (示例值)
BASE_REPLY_PROBABILITY = 0.05 # 首次超过阈值时的基础回复概率 (示例值)
PROBABILITY_INCREASE_RATE_PER_SECOND = 0.02 # 高于阈值时，每秒概率增加量 (线性增长, 示例值)
REPLY_TRIGGER_THRESHOLD = 3.0 # 触发概率回复的兴趣阈值 (示例值)
BASE_REPLY_PROBABILITY = 0.05 # 首次超过阈值时的基础回复概率 (示例值)
PROBABILITY_INCREASE_RATE_PER_SECOND = 0.02 # 高于阈值时，每秒概率增加量 (线性增长, 示例值)
PROBABILITY_DECAY_FACTOR_PER_SECOND = 0.3 # 低于阈值时，每秒概率衰减因子 (指数衰减, 示例值)
MAX_REPLY_PROBABILITY = 1 # 回复概率上限 (示例值)
MAX_REPLY_PROBABILITY = 1 # 回复概率上限 (示例值)
# --- 结束：概率回复相关常量 ---
class InterestChatting:
def __init__(self,
decay_rate=DEFAULT_DECAY_RATE_PER_SECOND,
max_interest=MAX_INTEREST,
trigger_threshold=REPLY_TRIGGER_THRESHOLD,
base_reply_probability=BASE_REPLY_PROBABILITY,
increase_rate=PROBABILITY_INCREASE_RATE_PER_SECOND,
decay_factor=PROBABILITY_DECAY_FACTOR_PER_SECOND,
max_probability=MAX_REPLY_PROBABILITY):
def __init__(
self,
decay_rate=DEFAULT_DECAY_RATE_PER_SECOND,
max_interest=MAX_INTEREST,
trigger_threshold=REPLY_TRIGGER_THRESHOLD,
base_reply_probability=BASE_REPLY_PROBABILITY,
increase_rate=PROBABILITY_INCREASE_RATE_PER_SECOND,
decay_factor=PROBABILITY_DECAY_FACTOR_PER_SECOND,
max_probability=MAX_REPLY_PROBABILITY,
):
self.interest_level: float = 0.0
self.last_update_time: float = time.time() # 同时作为兴趣和概率的更新时间基准
self.last_update_time: float = time.time() # 同时作为兴趣和概率的更新时间基准
self.decay_rate_per_second: float = decay_rate
self.max_interest: float = max_interest
self.last_increase_amount: float = 0.0
self.last_interaction_time: float = self.last_update_time # 新增：最后交互时间
self.last_interaction_time: float = self.last_update_time # 新增：最后交互时间
# --- 新增：概率回复相关属性 ---
self.trigger_threshold: float = trigger_threshold
@@ -61,7 +64,7 @@ class InterestChatting:
self.probability_decay_factor: float = decay_factor
self.max_reply_probability: float = max_probability
self.current_reply_probability: float = 0.0
self.is_above_threshold: bool = False # 标记兴趣值是否高于阈值
self.is_above_threshold: bool = False # 标记兴趣值是否高于阈值
# --- 结束：概率回复相关属性 ---
def _calculate_decay(self, current_time: float):
@@ -76,24 +79,30 @@ class InterestChatting:
else:
# 检查 decay_rate_per_second 是否为非正数，避免 math domain error
if self.decay_rate_per_second <= 0:
logger.warning(f"InterestChatting encountered non-positive decay rate: {self.decay_rate_per_second}. Setting interest to 0.")
self.interest_level = 0.0
logger.warning(
f"InterestChatting encountered non-positive decay rate: {self.decay_rate_per_second}. Setting interest to 0."
)
self.interest_level = 0.0
# 检查 interest_level 是否为负数，虽然理论上不应发生，但以防万一
elif self.interest_level < 0:
logger.warning(f"InterestChatting encountered negative interest level: {self.interest_level}. Setting interest to 0.")
self.interest_level = 0.0
logger.warning(
f"InterestChatting encountered negative interest level: {self.interest_level}. Setting interest to 0."
)
self.interest_level = 0.0
else:
try:
decay_factor = math.pow(self.decay_rate_per_second, time_delta)
self.interest_level *= decay_factor
except ValueError as e:
# 捕获潜在的 math domain error，例如对负数开非整数次方（虽然已加保护）
logger.error(f"Math error during decay calculation: {e}. Rate: {self.decay_rate_per_second}, Delta: {time_delta}, Level: {self.interest_level}. Setting interest to 0.")
logger.error(
f"Math error during decay calculation: {e}. Rate: {self.decay_rate_per_second}, Delta: {time_delta}, Level: {self.interest_level}. Setting interest to 0."
)
self.interest_level = 0.0
# 防止低于阈值 (如果需要)
# self.interest_level = max(self.interest_level, MIN_INTEREST_THRESHOLD)
# 只有在兴趣值发生变化时才更新时间戳
if old_interest != self.interest_level:
self.last_update_time = current_time
@@ -102,7 +111,7 @@ class InterestChatting:
"""根据当前兴趣是否超过阈值及时间差，更新回复概率"""
time_delta = current_time - self.last_update_time
if time_delta <= 0:
return # 时间未前进，无需更新
return # 时间未前进，无需更新
currently_above = self.interest_level >= self.trigger_threshold
@@ -110,7 +119,9 @@ class InterestChatting:
if not self.is_above_threshold:
# 刚跨过阈值，重置为基础概率
self.current_reply_probability = self.base_reply_probability
logger.debug(f"兴趣跨过阈值 ({self.trigger_threshold}). 概率重置为基础值: {self.base_reply_probability:.4f}")
logger.debug(
f"兴趣跨过阈值 ({self.trigger_threshold}). 概率重置为基础值: {self.base_reply_probability:.4f}"
)
else:
# 持续高于阈值，线性增加概率
increase_amount = self.probability_increase_rate * time_delta
@@ -120,7 +131,7 @@ class InterestChatting:
# 限制概率不超过最大值
self.current_reply_probability = min(self.current_reply_probability, self.max_reply_probability)
else: # 低于阈值
else: # 低于阈值
# if self.is_above_threshold:
# # 刚低于阈值，开始衰减
# logger.debug(f"兴趣低于阈值 ({self.trigger_threshold}). 概率衰减开始于 {self.current_reply_probability:.4f}")
@@ -140,8 +151,8 @@ class InterestChatting:
elif self.probability_decay_factor <= 0:
# 如果衰减因子无效或为0，直接清零
if self.current_reply_probability > 0:
logger.warning(f"无效的衰减因子 ({self.probability_decay_factor}). 设置概率为0.")
self.current_reply_probability = 0.0
logger.warning(f"无效的衰减因子 ({self.probability_decay_factor}). 设置概率为0.")
self.current_reply_probability = 0.0
# else: decay_factor >= 1, probability will not decay or increase, which might be intended in some cases.
# 确保概率不低于0
@@ -160,9 +171,9 @@ class InterestChatting:
self.last_increase_amount = value
# 应用增加
self.interest_level += value
self.interest_level = min(self.interest_level, self.max_interest) # 不超过最大值
self.last_update_time = current_time # 更新时间戳
self.last_interaction_time = current_time # 更新最后交互时间
self.interest_level = min(self.interest_level, self.max_interest) # 不超过最大值
self.last_update_time = current_time # 更新时间戳
self.last_interaction_time = current_time # 更新最后交互时间
def decrease_interest(self, current_time: float, value: float):
"""降低兴趣值并更新时间 (确保不低于0)"""
@@ -170,9 +181,9 @@ class InterestChatting:
self._update_reply_probability(current_time)
# 注意：降低兴趣度是否需要先衰减？取决于具体逻辑，这里假设不衰减直接减
self.interest_level -= value
self.interest_level = max(self.interest_level, 0.0) # 确保不低于0
self.last_update_time = current_time # 降低也更新时间戳
self.last_interaction_time = current_time # 更新最后交互时间
self.interest_level = max(self.interest_level, 0.0) # 确保不低于0
self.last_update_time = current_time # 降低也更新时间戳
self.last_interaction_time = current_time # 更新最后交互时间
def reset_trigger_info(self):
"""重置触发相关信息，在外部任务处理后调用"""
@@ -184,7 +195,7 @@ class InterestChatting:
current_time = time.time()
self._update_reply_probability(current_time)
self._calculate_decay(current_time)
self.last_update_time = current_time # 更新时间戳
self.last_update_time = current_time # 更新时间戳
return self.interest_level
def get_state(self) -> dict:
@@ -194,9 +205,9 @@ class InterestChatting:
return {
"interest_level": round(interest, 2),
"last_update_time": self.last_update_time,
"current_reply_probability": round(self.current_reply_probability, 4), # 添加概率到状态
"is_above_threshold": self.is_above_threshold, # 添加阈值状态
"last_interaction_time": self.last_interaction_time # 新增：添加最后交互时间到状态
"current_reply_probability": round(self.current_reply_probability, 4), # 添加概率到状态
"is_above_threshold": self.is_above_threshold, # 添加阈值状态
"last_interaction_time": self.last_interaction_time, # 新增：添加最后交互时间到状态
# 可以选择性地暴露 last_increase_amount 给状态，方便调试
# "last_increase_amount": round(self.last_increase_amount, 2)
}
@@ -222,7 +233,7 @@ class InterestChatting:
# # self.current_reply_probability = self.base_reply_probability # 例如，触发后降回基础概率
# # self.current_reply_probability *= 0.5 # 例如，触发后概率减半
# else:
# logger.debug(f"回复概率评估未触发。概率: {self.current_reply_probability:.4f}")
# logger.debug(f"回复概率评估未触发。概率: {self.current_reply_probability:.4f}")
return trigger
else:
# logger.debug(f"Reply evaluation check: Below threshold or zero probability. Probability: {self.current_reply_probability:.4f}")
@@ -256,10 +267,10 @@ class InterestManager:
self._history_log_file_path = os.path.join(LOG_DIRECTORY, HISTORY_LOG_FILENAME)
self._ensure_log_directory()
self._cleanup_task = None
self._logging_task = None # 添加日志任务变量
self._logging_task = None # 添加日志任务变量
self._initialized = True
logger.info("InterestManager initialized.") # 修改日志消息
self._decay_task = None # 新增：衰减任务变量
logger.info("InterestManager initialized.") # 修改日志消息
self._decay_task = None # 新增：衰减任务变量
def _ensure_log_directory(self):
"""确保日志目录存在"""
@@ -283,14 +294,14 @@ class InterestManager:
# logger.debug(f"运行定期历史记录 (间隔: {interval_seconds}秒)...")
try:
current_timestamp = time.time()
all_states = self.get_all_interest_states() # 获取当前所有状态
all_states = self.get_all_interest_states() # 获取当前所有状态
# 以追加模式打开历史日志文件
with open(self._history_log_file_path, 'a', encoding='utf-8') as f:
with open(self._history_log_file_path, "a", encoding="utf-8") as f:
count = 0
for stream_id, state in all_states.items():
# *** Get group name from ChatManager ***
group_name = stream_id # Default to stream_id
group_name = stream_id # Default to stream_id
try:
# Use the imported chat_manager instance
chat_stream = chat_manager.get_stream(stream_id)
@@ -298,7 +309,11 @@ class InterestManager:
group_name = chat_stream.group_info.group_name
elif chat_stream and not chat_stream.group_info:
# Handle private chats - maybe use user nickname?
group_name = f"私聊_{chat_stream.user_info.user_nickname}" if chat_stream.user_info else stream_id
group_name = (
f"私聊_{chat_stream.user_info.user_nickname}"
if chat_stream.user_info
else stream_id
)
except Exception as e:
logger.warning(f"Could not get group name for stream_id {stream_id}: {e}")
# Fallback to stream_id is already handled by default value
@@ -306,25 +321,25 @@ class InterestManager:
log_entry = {
"timestamp": round(current_timestamp, 2),
"stream_id": stream_id,
"interest_level": state.get("interest_level", 0.0), # 确保有默认值
"group_name": group_name, # *** Add group_name ***
"interest_level": state.get("interest_level", 0.0), # 确保有默认值
"group_name": group_name, # *** Add group_name ***
# --- 新增：记录概率相关信息 ---
"reply_probability": state.get("current_reply_probability", 0.0),
"is_above_threshold": state.get("is_above_threshold", False)
"is_above_threshold": state.get("is_above_threshold", False),
# --- 结束新增 ---
}
# 将每个条目作为单独的 JSON 行写入
f.write(json.dumps(log_entry, ensure_ascii=False) + '\n')
f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
count += 1
# logger.debug(f"Successfully appended {count} interest history entries to {self._history_log_file_path}")
# 注意：不再写入快照文件 interest_log.json
# 如果需要快照文件，可以在这里单独写入 self._snapshot_log_file_path
# 例如：
# with open(self._snapshot_log_file_path, 'w', encoding='utf-8') as snap_f:
# json.dump(all_states, snap_f, indent=4, ensure_ascii=False)
# logger.debug(f"Successfully wrote snapshot to {self._snapshot_log_file_path}")
except IOError as e:
logger.error(f"Error writing interest history log to {self._history_log_file_path}: {e}")
except Exception as e:
@@ -333,7 +348,7 @@ class InterestManager:
async def _periodic_decay_task(self):
"""后台衰减任务的异步函数，每秒更新一次所有实例的衰减"""
while True:
await asyncio.sleep(1) # 每秒运行一次
await asyncio.sleep(1) # 每秒运行一次
current_time = time.time()
# logger.debug("Running periodic decay calculation...") # 调试日志，可能过于频繁
@@ -355,27 +370,24 @@ class InterestManager:
if self._cleanup_task is None or self._cleanup_task.done():
self._cleanup_task = asyncio.create_task(
self._periodic_cleanup_task(
interval_seconds=CLEANUP_INTERVAL_SECONDS,
max_age_seconds=INACTIVE_THRESHOLD_SECONDS
interval_seconds=CLEANUP_INTERVAL_SECONDS, max_age_seconds=INACTIVE_THRESHOLD_SECONDS
)
)
logger.info(f"已创建定期清理任务。间隔时间: {CLEANUP_INTERVAL_SECONDS}秒, 不活跃阈值: {INACTIVE_THRESHOLD_SECONDS}秒")
logger.info(
f"已创建定期清理任务。间隔时间: {CLEANUP_INTERVAL_SECONDS}秒, 不活跃阈值: {INACTIVE_THRESHOLD_SECONDS}秒"
)
else:
logger.warning("跳过创建清理任务:任务已在运行或存在。")
if self._logging_task is None or self._logging_task.done():
self._logging_task = asyncio.create_task(
self._periodic_log_task(interval_seconds=LOG_INTERVAL_SECONDS)
)
self._logging_task = asyncio.create_task(self._periodic_log_task(interval_seconds=LOG_INTERVAL_SECONDS))
logger.info(f"已创建定期日志任务。间隔时间: {LOG_INTERVAL_SECONDS}秒")
else:
logger.warning("跳过创建日志任务:任务已在运行或存在。")
# 启动新的衰减任务
if self._decay_task is None or self._decay_task.done():
self._decay_task = asyncio.create_task(
self._periodic_decay_task()
)
self._decay_task = asyncio.create_task(self._periodic_decay_task())
logger.info("已创建定期衰减任务。间隔时间: 1秒")
else:
logger.warning("跳过创建衰减任务:任务已在运行或存在。")
@@ -391,7 +403,7 @@ class InterestManager:
# 直接调用 get_state，它会使用内部的 get_interest 获取已更新的值
states[stream_id] = chatting.get_state()
except Exception as e:
logger.warning(f"Error getting state for stream_id {stream_id}: {e}")
logger.warning(f"Error getting state for stream_id {stream_id}: {e}")
return states
def get_interest_chatting(self, stream_id: str) -> Optional[InterestChatting]:
@@ -410,11 +422,11 @@ class InterestManager:
# --- 修改：创建时传入概率相关参数 (如果需要定制化，否则使用默认值) ---
self.interest_dict[stream_id] = InterestChatting(
# decay_rate=..., max_interest=..., # 可以从配置读取
trigger_threshold=REPLY_TRIGGER_THRESHOLD, # 使用全局常量
trigger_threshold=REPLY_TRIGGER_THRESHOLD, # 使用全局常量
base_reply_probability=BASE_REPLY_PROBABILITY,
increase_rate=PROBABILITY_INCREASE_RATE_PER_SECOND,
decay_factor=PROBABILITY_DECAY_FACTOR_PER_SECOND,
max_probability=MAX_REPLY_PROBABILITY
max_probability=MAX_REPLY_PROBABILITY,
)
# --- 结束修改 ---
# 首次创建时兴趣为 0，由第一次消息的 activate rate 决定初始值
@@ -433,8 +445,10 @@ class InterestManager:
interest_chatting = self._get_or_create_interest_chatting(stream_id)
# 调用修改后的 increase_interest，不再传入 message
interest_chatting.increase_interest(current_time, value)
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
logger.debug(f"增加了聊天流 {stream_name} 的兴趣度 {value:.2f}，当前值为 {interest_chatting.interest_level:.2f}") # 更新日志
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
logger.debug(
f"增加了聊天流 {stream_name} 的兴趣度 {value:.2f}，当前值为 {interest_chatting.interest_level:.2f}"
) # 更新日志
def decrease_interest(self, stream_id: str, value: float):
"""降低指定聊天流的兴趣度"""
@@ -443,10 +457,12 @@ class InterestManager:
interest_chatting = self.get_interest_chatting(stream_id)
if interest_chatting:
interest_chatting.decrease_interest(current_time, value)
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
logger.debug(f"降低了聊天流 {stream_name} 的兴趣度 {value:.2f}，当前值为 {interest_chatting.interest_level:.2f}")
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
logger.debug(
f"降低了聊天流 {stream_name} 的兴趣度 {value:.2f}，当前值为 {interest_chatting.interest_level:.2f}"
)
else:
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
logger.warning(f"尝试降低不存在的聊天流 {stream_name} 的兴趣度")
def cleanup_inactive_chats(self, max_age_seconds=INACTIVE_THRESHOLD_SECONDS):
@@ -465,29 +481,31 @@ class InterestManager:
# 先计算当前兴趣，确保是最新的
# 加锁保护 chatting 对象状态的读取和可能的修改
# with self._lock: # 如果 InterestChatting 内部操作不是原子的
last_interaction = chatting.last_interaction_time # 使用最后交互时间
last_interaction = chatting.last_interaction_time # 使用最后交互时间
should_remove = False
reason = ""
# 只有设置了 max_age_seconds 才检查时间
if max_age_seconds is not None and (current_time - last_interaction) > max_age_seconds: # 使用 last_interaction
if (
max_age_seconds is not None and (current_time - last_interaction) > max_age_seconds
): # 使用 last_interaction
should_remove = True
reason = f"inactive time ({current_time - last_interaction:.0f}s) > max age ({max_age_seconds}s)" # 更新日志信息
reason = f"inactive time ({current_time - last_interaction:.0f}s) > max age ({max_age_seconds}s)" # 更新日志信息
if should_remove:
keys_to_remove.append(stream_id)
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
stream_name = chat_manager.get_stream_name(stream_id) or stream_id # 获取流名称
logger.debug(f"Marking stream {stream_name} for removal. Reason: {reason}")
if keys_to_remove:
logger.info(f"清理识别到 {len(keys_to_remove)} 个不活跃/低兴趣的流。")
# with self._lock: # 确保删除操作的原子性
for key in keys_to_remove:
# 再次检查 key 是否存在，以防万一在迭代和删除之间状态改变
# 再次检查 key 是否存在，以防万一在迭代和删除之间状态改变
if key in self.interest_dict:
del self.interest_dict[key]
stream_name = chat_manager.get_stream_name(key) or key # 获取流名称
stream_name = chat_manager.get_stream_name(key) or key # 获取流名称
logger.debug(f"移除了流: {stream_name}")
final_count = initial_count - len(keys_to_remove)
logger.info(f"清理完成。移除了 {len(keys_to_remove)} 个流。当前数量: {final_count}")
else:
logger.info(f"清理完成。没有流符合移除条件。当前数量: {initial_count}")
logger.info(f"清理完成。没有流符合移除条件。当前数量: {initial_count}")

12
src/plugins/chat_module/heartFC_chat/messagesender.py
View File

@@ -23,6 +23,7 @@ logger = get_module_logger("msg_sender", config=sender_config)
class MessageSender:
"""发送器"""
_instance = None
def __new__(cls, *args, **kwargs):
@@ -32,7 +33,7 @@ class MessageSender:
def __init__(self):
# 确保 __init__ 只被调用一次
if not hasattr(self, '_initialized'):
if not hasattr(self, "_initialized"):
self.message_interval = (0.5, 1) # 消息间隔时间范围(秒)
self.last_send_time = 0
self._current_bot = None
@@ -42,7 +43,6 @@ class MessageSender:
"""设置当前bot实例"""
pass
async def send_via_ws(self, message: MessageSending) -> None:
try:
await global_api.send_message(message)
@@ -56,7 +56,6 @@ class MessageSender:
"""发送消息"""
if isinstance(message, MessageSending):
typing_time = calculate_typing_time(
input_string=message.processed_plain_text,
thinking_start_time=message.thinking_start_time,
@@ -143,6 +142,7 @@ class MessageContainer:
class MessageManager:
"""管理所有聊天流的消息容器"""
_instance = None
def __new__(cls, *args, **kwargs):
@@ -152,7 +152,7 @@ class MessageManager:
def __init__(self):
# 确保 __init__ 只被调用一次
if not hasattr(self, '_initialized'):
if not hasattr(self, "_initialized"):
self.containers: Dict[str, MessageContainer] = {} # chat_id -> MessageContainer
self.storage = MessageStorage()
self._running = True
@@ -232,10 +232,10 @@ class MessageManager:
while self._running:
await asyncio.sleep(1)
tasks = []
for chat_id in list(self.containers.keys()): # 使用 list 复制 key，防止在迭代时修改字典
for chat_id in list(self.containers.keys()): # 使用 list 复制 key，防止在迭代时修改字典
tasks.append(self.process_chat_messages(chat_id))
if tasks: # 仅在有任务时执行 gather
if tasks: # 仅在有任务时执行 gather
await asyncio.gather(*tasks)

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

@@ -11,15 +11,15 @@ from ...message import UserInfo
from src.heart_flow.heartflow import heartflow, SubHeartflow
from src.plugins.chat.chat_stream import chat_manager
from .messagesender import MessageManager
from src.common.logger import get_module_logger, LogConfig, DEFAULT_CONFIG # 引入 DEFAULT_CONFIG
from src.common.logger import get_module_logger, LogConfig, DEFAULT_CONFIG # 引入 DEFAULT_CONFIG
from src.plugins.models.utils_model import LLMRequest
# 定义日志配置 (使用 loguru 格式)
interest_log_config = LogConfig(
console_format=DEFAULT_CONFIG["console_format"], # 使用默认控制台格式
file_format=DEFAULT_CONFIG["file_format"] # 使用默认文件格式
console_format=DEFAULT_CONFIG["console_format"], # 使用默认控制台格式
file_format=DEFAULT_CONFIG["file_format"], # 使用默认文件格式
)
logger = get_module_logger("PFChattingLoop", config=interest_log_config) # Logger Name Changed
logger = get_module_logger("PFChattingLoop", config=interest_log_config) # Logger Name Changed
# Forward declaration for type hinting
@@ -38,30 +38,29 @@ PLANNER_TOOL_DEFINITION = [
"action": {
"type": "string",
"enum": ["no_reply", "text_reply", "emoji_reply"],
"description": "决定采取的行动：'no_reply'(不回复), 'text_reply'(文本回复) 或 'emoji_reply'(表情回复)。"
"description": "决定采取的行动：'no_reply'(不回复), 'text_reply'(文本回复) 或 'emoji_reply'(表情回复)。",
},
"reasoning": {
"type": "string",
"description": "做出此决定的简要理由。"
},
"reasoning": {"type": "string", "description": "做出此决定的简要理由。"},
"emoji_query": {
"type": "string",
"description": '如果行动是\'emoji_reply\',则指定表情的主题或概念（例如，"开心"、"困惑"）。仅在需要表情回复时提供。'
}
"description": '如果行动是\'emoji_reply\',则指定表情的主题或概念（例如，"开心"、"困惑"）。仅在需要表情回复时提供。',
},
},
"required": ["action", "reasoning"] # 强制要求提供行动和理由
}
}
"required": ["action", "reasoning"], # 强制要求提供行动和理由
},
},
}
]
class PFChatting:
"""
Manages a continuous Plan-Filter-Check (now Plan-Replier-Sender) loop
for generating replies within a specific chat stream, controlled by a timer.
The loop runs as long as the timer > 0.
"""
def __init__(self, chat_id: str, heartfc_chat_instance: 'HeartFC_Chat'):
def __init__(self, chat_id: str, heartfc_chat_instance: "HeartFC_Chat"):
"""
初始化PFChatting实例。
@@ -69,34 +68,33 @@ class PFChatting:
chat_id: The identifier for the chat stream (e.g., stream_id).
heartfc_chat_instance: 访问共享资源和方法的主HeartFC_Chat实例。
"""
self.heartfc_chat = heartfc_chat_instance # 访问logger, gpt, tool_user, _send_response_messages等。
self.heartfc_chat = heartfc_chat_instance # 访问logger, gpt, tool_user, _send_response_messages等。
self.stream_id: str = chat_id
self.chat_stream: Optional[ChatStream] = None
self.sub_hf: Optional[SubHeartflow] = None
self._initialized = False
self._init_lock = asyncio.Lock() # Ensure initialization happens only once
self._processing_lock = asyncio.Lock() # 确保只有一个 Plan-Replier-Sender 周期在运行
self._timer_lock = asyncio.Lock() # 用于安全更新计时器
self._init_lock = asyncio.Lock() # Ensure initialization happens only once
self._processing_lock = asyncio.Lock() # 确保只有一个 Plan-Replier-Sender 周期在运行
self._timer_lock = asyncio.Lock() # 用于安全更新计时器
self.planner_llm = LLMRequest(
model=global_config.llm_normal,
temperature=global_config.llm_normal["temp"],
max_tokens=1000,
request_type="action_planning"
request_type="action_planning",
)
# Internal state for loop control
self._loop_timer: float = 0.0 # Remaining time for the loop in seconds
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 = 30.0 # 首次触发增加的时间
self._last_added_duration: float = self._initial_duration # <--- 新增：存储上次增加的时间
self._loop_timer: float = 0.0 # Remaining time for the loop in seconds
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 = 30.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
@@ -110,7 +108,7 @@ class PFChatting:
async with self._init_lock:
if self._initialized:
return True
log_prefix = self._get_log_prefix() # 获取前缀
log_prefix = self._get_log_prefix() # 获取前缀
try:
self.chat_stream = chat_manager.get_stream(self.stream_id)
@@ -140,23 +138,25 @@ class PFChatting:
"""
log_prefix = self._get_log_prefix()
if not self._initialized:
if not await self._initialize():
logger.error(f"{log_prefix} 无法添加时间: 未初始化。")
return
if not await self._initialize():
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 = self._initial_duration # 使用初始值
self._last_added_duration = duration_to_add # 更新上次增加的值
self._trigger_count_this_activation = 1 # Start counting
if not self._loop_active: # First trigger for this activation cycle
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
else: # Loop is already active, apply 50% reduction
self._trigger_count_this_activation += 1
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.")
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
@@ -174,8 +174,7 @@ class PFChatting:
self._loop_task = asyncio.create_task(self._run_pf_loop())
self._loop_task.add_done_callback(self._handle_loop_completion)
elif self._loop_active:
logger.debug(f"{log_prefix} Loop already active. Timer extended.")
logger.debug(f"{log_prefix} Loop already active. Timer extended.")
def _handle_loop_completion(self, task: asyncio.Task):
"""当 _run_pf_loop 任务完成时执行的回调。"""
@@ -194,14 +193,13 @@ class PFChatting:
# 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 # 重置计数器
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"{log_prefix} PFChatting: 锁没有正常释放")
self._processing_lock.release()
async def _run_pf_loop(self):
"""
主循环，当计时器>0时持续进行计划并可能回复消息
@@ -214,13 +212,15 @@ class PFChatting:
async with self._timer_lock:
current_timer = self._loop_timer
if current_timer <= 0:
logger.info(f"{self._get_log_prefix()} PFChatting: 聊太久了，麦麦打算休息一下(已经聊了{current_timer:.1f}秒)，退出PFChatting")
logger.info(
f"{self._get_log_prefix()} PFChatting: 聊太久了，麦麦打算休息一下(已经聊了{current_timer:.1f}秒)，退出PFChatting"
)
break # 退出条件：计时器到期
# 记录循环开始时间
loop_cycle_start_time = time.monotonic()
# 标记本周期是否执行了操作
action_taken_this_cycle = False
action_taken_this_cycle = False
# 获取处理锁，确保每个计划-回复-发送周期独占执行
acquired_lock = False
@@ -231,13 +231,13 @@ class PFChatting:
# --- Planner ---
# Planner decides action, reasoning, emoji_query, etc.
planner_result = await self._planner() # Modify planner to return decision dict
planner_result = await self._planner() # Modify planner to return decision dict
action = planner_result.get("action", "error")
reasoning = planner_result.get("reasoning", "Planner did not provide reasoning.")
emoji_query = planner_result.get("emoji_query", "")
current_mind = planner_result.get("current_mind", "[Mind unavailable]")
send_emoji_from_tools = planner_result.get("send_emoji_from_tools", "")
observed_messages = planner_result.get("observed_messages", []) # Planner needs to return this
observed_messages = planner_result.get("observed_messages", []) # Planner needs to return this
if action == "text_reply":
logger.info(f"{self._get_log_prefix()} PFChatting: 麦麦决定回复文本.")
@@ -245,7 +245,7 @@ class PFChatting:
# --- 回复器 ---
anchor_message = await self._get_anchor_message(observed_messages)
if not anchor_message:
logger.error(f"{self._get_log_prefix()} 循环: 无法获取锚点消息用于回复. 跳过周期.")
logger.error(f"{self._get_log_prefix()} 循环: 无法获取锚点消息用于回复. 跳过周期.")
else:
thinking_id = await self.heartfc_chat._create_thinking_message(anchor_message)
if not thinking_id:
@@ -259,12 +259,12 @@ class PFChatting:
anchor_message=anchor_message,
thinking_id=thinking_id,
current_mind=current_mind,
send_emoji=send_emoji_from_tools
send_emoji=send_emoji_from_tools,
)
except Exception as e_replier:
logger.error(f"{self._get_log_prefix()} 循环: 回复器工作失败: {e_replier}")
self._cleanup_thinking_message(thinking_id) # 清理思考消息
# 继续循环, 视为非操作周期
logger.error(f"{self._get_log_prefix()} 循环: 回复器工作失败: {e_replier}")
self._cleanup_thinking_message(thinking_id) # 清理思考消息
# 继续循环, 视为非操作周期
if replier_result:
# --- Sender ---
@@ -272,13 +272,13 @@ class PFChatting:
await self._sender(thinking_id, anchor_message, replier_result)
logger.info(f"{self._get_log_prefix()} 循环: 发送器完成成功.")
except Exception as e_sender:
logger.error(f"{self._get_log_prefix()} 循环: 发送器失败: {e_sender}")
self._cleanup_thinking_message(thinking_id) # 确保发送失败时清理
# 继续循环, 视为非操作周期
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._get_log_prefix()} 循环: 回复器未产生结果. 跳过发送.")
self._cleanup_thinking_message(thinking_id) # 清理思考消息
# Replier failed to produce result
logger.warning(f"{self._get_log_prefix()} 循环: 回复器未产生结果. 跳过发送.")
self._cleanup_thinking_message(thinking_id) # 清理思考消息
elif action == "emoji_reply":
logger.info(f"{self._get_log_prefix()} PFChatting: 麦麦决定回复表情 ('{emoji_query}').")
@@ -290,19 +290,19 @@ class PFChatting:
except Exception as e_emoji:
logger.error(f"{self._get_log_prefix()} 循环: 发送表情失败: {e_emoji}")
else:
logger.warning(f"{self._get_log_prefix()} 循环: 无法发送表情, 无法获取锚点.")
logger.warning(f"{self._get_log_prefix()} 循环: 无法发送表情, 无法获取锚点.")
elif action == "no_reply":
logger.info(f"{self._get_log_prefix()} PFChatting: 麦麦决定不回复. 原因: {reasoning}")
# Do nothing else, action_taken_this_cycle remains False
elif action == "error":
logger.error(f"{self._get_log_prefix()} PFChatting: 麦麦回复出错. 原因: {reasoning}")
# 视为非操作周期
logger.error(f"{self._get_log_prefix()} PFChatting: 麦麦回复出错. 原因: {reasoning}")
# 视为非操作周期
else: # Unknown action
logger.warning(f"{self._get_log_prefix()} PFChatting: 麦麦做了奇怪的事情. 原因: {reasoning}")
# 视为非操作周期
else: # Unknown action
logger.warning(f"{self._get_log_prefix()} PFChatting: 麦麦做了奇怪的事情. 原因: {reasoning}")
# 视为非操作周期
except Exception as e_cycle:
# Catch errors occurring within the locked section (e.g., planner crash)
@@ -310,9 +310,9 @@ class PFChatting:
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._get_log_prefix()} 由于循环周期中的错误释放了处理锁.")
self._processing_lock.release()
acquired_lock = False # 防止在 finally 块中重复释放
logger.warning(f"{self._get_log_prefix()} 由于循环周期中的错误释放了处理锁.")
finally:
# Ensure the lock is always released after a cycle
@@ -324,26 +324,28 @@ class PFChatting:
cycle_duration = time.monotonic() - loop_cycle_start_time
async with self._timer_lock:
self._loop_timer -= cycle_duration
logger.debug(f"{self._get_log_prefix()} PFChatting: 麦麦聊了{cycle_duration:.2f}秒. 还能聊: {self._loop_timer:.1f}s.")
logger.debug(
f"{self._get_log_prefix()} PFChatting: 麦麦聊了{cycle_duration:.2f}秒. 还能聊: {self._loop_timer:.1f}s."
)
# --- Delay ---
# Add a small delay, especially if no action was taken, to prevent busy-waiting
try:
if not action_taken_this_cycle and cycle_duration < 1.5:
# If nothing happened and cycle was fast, wait a bit longer
await asyncio.sleep(1.5 - cycle_duration)
elif cycle_duration < 0.2: # Minimum delay even if action was taken
await asyncio.sleep(0.2)
# If nothing happened and cycle was fast, wait a bit longer
await asyncio.sleep(1.5 - cycle_duration)
elif cycle_duration < 0.2: # Minimum delay even if action was taken
await asyncio.sleep(0.2)
except asyncio.CancelledError:
logger.info(f"{self._get_log_prefix()} Sleep interrupted, likely loop cancellation.")
break # Exit loop if cancelled during sleep
break # Exit loop if cancelled during sleep
except asyncio.CancelledError:
logger.info(f"{self._get_log_prefix()} PFChatting: 麦麦的聊天被取消了")
logger.info(f"{self._get_log_prefix()} PFChatting: 麦麦的聊天被取消了")
except Exception as e_loop_outer:
# Catch errors outside the main cycle lock (should be rare)
logger.error(f"{self._get_log_prefix()} PFChatting: 麦麦的聊天出错了: {e_loop_outer}")
logger.error(traceback.format_exc())
# Catch errors outside the main cycle lock (should be rare)
logger.error(f"{self._get_log_prefix()} PFChatting: 麦麦的聊天出错了: {e_loop_outer}")
logger.error(traceback.format_exc())
finally:
# Reset trigger count when loop finishes
async with self._timer_lock:
@@ -363,7 +365,7 @@ class PFChatting:
observed_messages: List[dict] = []
tool_result_info = {}
get_mid_memory_id = []
send_emoji_from_tools = "" # Renamed for clarity
send_emoji_from_tools = "" # Renamed for clarity
current_mind: Optional[str] = None
# --- 获取最新的观察信息 ---
@@ -371,8 +373,8 @@ class PFChatting:
if self.sub_hf and self.sub_hf._get_primary_observation():
observation = self.sub_hf._get_primary_observation()
logger.debug(f"{log_prefix}[Planner] 调用 observation.observe()...")
await observation.observe() # 主动观察以获取最新消息
observed_messages = observation.talking_message # 获取更新后的消息列表
await observation.observe() # 主动观察以获取最新消息
observed_messages = observation.talking_message # 获取更新后的消息列表
logger.debug(f"{log_prefix}[Planner] 获取到 {len(observed_messages)} 条观察消息。")
else:
logger.warning(f"{log_prefix}[Planner] 无法获取 SubHeartflow 或 Observation 来获取消息。")
@@ -385,26 +387,28 @@ class PFChatting:
try:
observation_context_text = ""
if observed_messages:
context_texts = [msg.get('detailed_plain_text', '') for msg in observed_messages if msg.get('detailed_plain_text')]
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"{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
# Ensure SubHeartflow exists for tool use context
tool_result = await self.heartfc_chat.tool_user.use_tool(
message_txt=observation_context_text,
chat_stream=self.chat_stream,
sub_heartflow=self.sub_hf
message_txt=observation_context_text, chat_stream=self.chat_stream, sub_heartflow=self.sub_hf
)
if tool_result.get("used_tools", False):
tool_result_info = tool_result.get("structured_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]
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
send_emoji_from_tools = tool_result_info["send_emoji"][0].get("content", "") # Use renamed var
elif not self.sub_hf:
logger.warning(f"{log_prefix}[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"{log_prefix}[Planner] Tool use failed: {e_tool}")
@@ -422,20 +426,19 @@ class PFChatting:
)
logger.info(f"{log_prefix}[Planner] SubHeartflow thought: {current_mind}")
else:
logger.warning(f"{log_prefix}[Planner] Skipping SubHeartflow thinking because it is not available.")
current_mind = "[心流思考不可用]" # Set a default/indicator value
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"{log_prefix}[Planner] SubHeartflow thinking failed: {e_shf}")
logger.error(traceback.format_exc())
current_mind = "[心流思考出错]"
logger.error(f"{log_prefix}[Planner] SubHeartflow thinking failed: {e_shf}")
logger.error(traceback.format_exc())
current_mind = "[心流思考出错]"
# --- 使用 LLM 进行决策 ---
action = "no_reply" # Default action
action = "no_reply" # Default action
emoji_query = ""
reasoning = "默认决策或获取决策失败"
llm_error = False # Flag for LLM failure
llm_error = False # Flag for LLM failure
try:
# 构建提示 (Now includes current_mind)
@@ -447,7 +450,7 @@ class PFChatting:
"model": self.planner_llm.model_name,
"messages": [{"role": "user", "content": prompt}],
"tools": PLANNER_TOOL_DEFINITION,
"tool_choice": {"type": "function", "function": {"name": "decide_reply_action"}}, # 强制调用此工具
"tool_choice": {"type": "function", "function": {"name": "decide_reply_action"}}, # 强制调用此工具
}
logger.debug(f"{log_prefix}[Planner] 发送 Planner LLM 请求...")
@@ -457,32 +460,43 @@ class PFChatting:
)
# 解析 LLM 响应
if len(response) == 3: # 期望返回 content, reasoning_content, tool_calls
if len(response) == 3: # 期望返回 content, reasoning_content, tool_calls
_, _, tool_calls = response
if tool_calls and isinstance(tool_calls, list) and len(tool_calls) > 0:
# 通常强制调用后只会有一个 tool_call
tool_call = tool_calls[0]
if tool_call.get("type") == "function" and tool_call.get("function", {}).get("name") == "decide_reply_action":
if (
tool_call.get("type") == "function"
and tool_call.get("function", {}).get("name") == "decide_reply_action"
):
try:
arguments = json.loads(tool_call["function"]["arguments"])
action = arguments.get("action", "no_reply")
reasoning = arguments.get("reasoning", "未提供理由")
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"{log_prefix}[Planner] LLM 决策: {action}, 理由: {reasoning}, EmojiQuery: '{emoji_query}'")
emoji_query = arguments.get(
"emoji_query", send_emoji_from_tools
) # Use tool emoji as default if planner asks for emoji
logger.info(
f"{log_prefix}[Planner] LLM 决策: {action}, 理由: {reasoning}, EmojiQuery: '{emoji_query}'"
)
except json.JSONDecodeError as json_e:
logger.error(f"{log_prefix}[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"{log_prefix}[Planner] 处理工具参数时出错: {parse_e}")
action = "error"
reasoning = "处理工具参数时出错"
reasoning = "处理工具参数时出错"
llm_error = True
else:
logger.warning(f"{log_prefix}[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
@@ -509,11 +523,11 @@ class PFChatting:
return {
"action": action,
"reasoning": reasoning,
"emoji_query": emoji_query, # Specific query if action is emoji_reply
"emoji_query": emoji_query, # Specific query if action is emoji_reply
"current_mind": current_mind,
"send_emoji_from_tools": send_emoji_from_tools, # Emoji suggested by pre-thinking tools
"send_emoji_from_tools": send_emoji_from_tools, # Emoji suggested by pre-thinking tools
"observed_messages": observed_messages,
"llm_error": llm_error # Indicate if LLM decision process failed
"llm_error": llm_error, # Indicate if LLM decision process failed
}
async def _get_anchor_message(self, observed_messages: List[dict]) -> Optional[MessageRecv]:
@@ -535,34 +549,47 @@ class PFChatting:
# Attempt reconstruction from the last observed message dictionary
anchor_message = MessageRecv(last_msg_dict, chat_stream=self.chat_stream)
# 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):
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._get_log_prefix()} 重构的锚点消息: 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._get_log_prefix()} 从观察到的消息重构 MessageRecv 失败: {e_reconstruct}. 创建占位符.")
logger.warning(
f"{self._get_log_prefix()} 从观察到的消息重构 MessageRecv 失败: {e_reconstruct}. 创建占位符."
)
else:
logger.warning(f"{self._get_log_prefix()} observed_messages 为空. 创建占位符锚点消息.")
# --- Create Placeholder ---
placeholder_id = f"mid_pf_{int(time.time() * 1000)}"
placeholder_user = UserInfo(user_id="system_trigger", user_nickname="System Trigger", platform=self.chat_stream.platform)
placeholder_user = UserInfo(
user_id="system_trigger", user_nickname="System Trigger", platform=self.chat_stream.platform
)
placeholder_msg_info = BaseMessageInfo(
message_id=placeholder_id,
platform=self.chat_stream.platform,
group_info=self.chat_stream.group_info,
user_info=placeholder_user,
time=time.time()
time=time.time(),
)
placeholder_msg_dict = {
"message_info": placeholder_msg_info.to_dict(),
"processed_plain_text": "[System Trigger Context]", # Placeholder text
"processed_plain_text": "[System Trigger Context]", # Placeholder text
"raw_message": "",
"time": placeholder_msg_info.time,
}
anchor_message = MessageRecv(placeholder_msg_dict)
anchor_message.update_chat_stream(self.chat_stream) # Associate with the stream
logger.info(f"{self._get_log_prefix()} Created placeholder anchor message: ID={anchor_message.message_info.message_id}")
anchor_message.update_chat_stream(self.chat_stream) # Associate with the stream
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:
@@ -579,7 +606,6 @@ class PFChatting:
except Exception as 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]):
"""
发送器 (Sender): 使用HeartFC_Chat的方法发送生成的回复。
@@ -589,13 +615,13 @@ class PFChatting:
"""
# replier_result should contain 'response_set' and 'send_emoji'
response_set = replier_result.get("response_set")
send_emoji = replier_result.get("send_emoji", "") # Emoji determined by tools, passed via replier
send_emoji = replier_result.get("send_emoji", "") # Emoji determined by tools, passed via replier
if not 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
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
first_bot_msg: Optional[MessageSending] = None
send_success = False
@@ -606,18 +632,22 @@ class PFChatting:
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
send_success = True # Mark success
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"{self._get_log_prefix()}[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"{self._get_log_prefix()}[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 ---
@@ -625,16 +655,19 @@ class PFChatting:
await self.heartfc_chat._update_relationship(anchor_message, response_set)
logger.debug(f"{self._get_log_prefix()}[Sender-{thinking_id}] Updated relationship.")
except Exception as e_rel:
logger.error(f"{self._get_log_prefix()}[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"{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
# Sending failed (e.g., _send_response_messages found thinking message already gone)
send_success = False
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
@@ -643,11 +676,10 @@ class PFChatting:
# Ensure thinking message is cleaned up if send failed mid-way and wasn't handled
if not send_success:
self._cleanup_thinking_message(thinking_id)
raise # Re-raise the exception to signal failure to the loop
raise # Re-raise the exception to signal failure to the loop
# No finally block needed for lock management
async def shutdown(self):
"""
Gracefully shuts down the PFChatting instance by cancelling the active loop task.
@@ -660,13 +692,13 @@ class PFChatting:
# 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._get_log_prefix()} PF loop task cancelled successfully.")
logger.info(f"{self._get_log_prefix()} PF loop task cancelled successfully.")
except asyncio.TimeoutError:
logger.warning(f"{self._get_log_prefix()} 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._get_log_prefix()} Error during loop task cancellation: {e}")
logger.error(f"{self._get_log_prefix()} Error during loop task cancellation: {e}")
else:
logger.info(f"{self._get_log_prefix()} 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
@@ -685,30 +717,43 @@ class PFChatting:
# Add current mind state if available
if current_mind:
prompt += f"\n你当前的内部想法是：\n---\n{current_mind}\n---\n\n"
prompt += f"\n你当前的内部想法是：\n---\n{current_mind}\n---\n\n"
else:
prompt += "\n你当前没有特别的内部想法。\n"
prompt += "\n你当前没有特别的内部想法。\n"
if observed_messages:
context_text = "\n".join([msg.get('detailed_plain_text', '') for msg in observed_messages if msg.get('detailed_plain_text')])
context_text = "\n".join(
[msg.get("detailed_plain_text", "") for msg in observed_messages if msg.get("detailed_plain_text")]
)
prompt += "观察到的最新聊天内容如下：\n---\n"
prompt += context_text[:1500] # Limit context length
prompt += context_text[:1500] # Limit context length
prompt += "\n---\n"
else:
prompt += "当前没有观察到新的聊天内容。\n"
prompt += "\n请结合你的内部想法和观察到的聊天内容，分析情况并使用 'decide_reply_action' 工具来决定你的最终行动。\n"
prompt += (
"\n请结合你的内部想法和观察到的聊天内容，分析情况并使用 'decide_reply_action' 工具来决定你的最终行动。\n"
)
prompt += "决策依据：\n"
prompt += "1. 如果聊天内容无聊、与你无关、或者你的内部想法认为不适合回复，选择 'no_reply'。\n"
prompt += "2. 如果聊天内容值得回应，且适合用文字表达（参考你的内部想法），选择 'text_reply'。\n"
prompt += "3. 如果聊天内容或你的内部想法适合用一个表情来回应，选择 'emoji_reply' 并提供表情主题 'emoji_query'。\n"
prompt += (
"3. 如果聊天内容或你的内部想法适合用一个表情来回应，选择 'emoji_reply' 并提供表情主题 'emoji_query'。\n"
)
prompt += "4. 如果你已经回复过消息，也没有人又回复你，选择'no_reply'。"
prompt += "必须调用 'decide_reply_action' 工具并提供 'action' 和 'reasoning'。"
return prompt
return prompt
# --- 回复器 (Replier) 的定义 --- #
async def _replier_work(self, observed_messages: List[dict], anchor_message: MessageRecv, thinking_id: str, current_mind: Optional[str], send_emoji: str) -> Optional[Dict[str, Any]]:
async def _replier_work(
self,
observed_messages: List[dict],
anchor_message: MessageRecv,
thinking_id: str,
current_mind: Optional[str],
send_emoji: str,
) -> Optional[Dict[str, Any]]:
"""
回复器 (Replier): 核心逻辑用于生成回复。
被 _run_pf_loop 直接调用和 await。
@@ -724,23 +769,23 @@ class PFChatting:
# 注意：实际的生成调用是在 self.heartfc_chat.gpt.generate_response 中
response_set = await self.heartfc_chat.gpt.generate_response(
anchor_message,
thinking_id
thinking_id,
# current_mind 不再直接传递给 gpt.generate_response，
# 因为 generate_response 内部会通过 thinking_id 或其他方式获取所需上下文
)
if not response_set:
logger.warning(f"{log_prefix}[Replier-{thinking_id}] LLM生成了一个空回复集。")
return None # Indicate failure
return None # Indicate failure
# --- 准备并返回结果 ---
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)
"send_emoji": send_emoji, # Pass through the emoji determined earlier (usually by tools)
}
except Exception as e:
logger.error(f"{log_prefix}[Replier-{thinking_id}] Unexpected error in replier_work: {e}")
logger.error(traceback.format_exc())
return None # Indicate failure
return None # Indicate failure