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

fix：让麦麦可以回复自己的消息,replyer现在可以接受 原因

Browse Source
This commit is contained in:
SengokuCola
2025-08-11 14:07:57 +08:00
parent 3ae95a4014
commit 9c0f56f6c7
5 changed files with 163 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/chat/chat_loop/heartFC_chat.py
View File

@@ -295,7 +295,6 @@ class HeartFChatting:
async def _send_and_store_reply(
self,
response_set,
loop_start_time,
action_message,
cycle_timers: Dict[str, float],
thinking_id,
@@ -303,7 +302,7 @@ class HeartFChatting:
) -> Tuple[Dict[str, Any], str, Dict[str, float]]:
with Timer("回复发送", cycle_timers):
reply_text = await self._send_response(response_set, loop_start_time, action_message)
reply_text = await self._send_response(response_set, action_message)
# 存储reply action信息
person_info_manager = get_person_info_manager()
@@ -383,7 +382,6 @@ class HeartFChatting:
await send_typing()
async with global_prompt_manager.async_message_scope(self.chat_stream.context.get_template_name()):
loop_start_time = time.time()
await self.relationship_builder.build_relation()
await self.expression_learner.trigger_learning_for_chat()
@@ -411,7 +409,7 @@ class HeartFChatting:
with Timer("规划器", cycle_timers):
actions, _= await self.action_planner.plan(
mode=mode,
loop_start_time=loop_start_time,
loop_start_time=self.last_read_time,
available_actions=available_actions,
)
@@ -467,6 +465,7 @@ class HeartFChatting:
chat_stream=self.chat_stream,
reply_message = action_info["action_message"],
available_actions=available_actions,
reply_reason=action_info.get("reasoning", ""),
enable_tool=global_config.tool.enable_tool,
request_type="chat.replyer",
from_plugin=False,
@@ -492,7 +491,6 @@ class HeartFChatting:
loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(
response_set,
loop_start_time,
action_info["action_message"],
cycle_timers,
thinking_id,
@@ -684,10 +682,9 @@ class HeartFChatting:
traceback.print_exc()
return False, "", ""
async def _send_response(self, reply_set, thinking_start_time, message_data) -> str:
current_time = time.time()
async def _send_response(self, reply_set, message_data) -> str:
new_message_count = message_api.count_new_messages(
chat_id=self.chat_stream.stream_id, start_time=thinking_start_time, end_time=current_time
chat_id=self.chat_stream.stream_id, start_time=self.last_read_time, end_time=time.time()
)
need_reply = new_message_count >= random.randint(2, 4)
@@ -713,7 +710,7 @@ class HeartFChatting:
text=data,
stream_id=self.chat_stream.stream_id,
reply_to_message = message_data,
set_reply=need_reply,
set_reply=False,
typing=True,
)
reply_text += data

17
src/chat/planner_actions/planner.py
View File

@@ -48,16 +48,15 @@ def init_prompt():
- 你想要闲聊或者随便附
- {mentioned_bonus}
- 如果你刚刚进行了回复，不要对同一个话题重复回应
- 不要回复自己发送的消息
{{
"action": "reply",
"target_message_id":"触发action的消息id",
"target_message_id":"想要回复的消息id",
"reason":"回复的原因"
}}
{action_options_text}
你必须从上面列出的可用action中选择一个，并说明触发action的消息id（不是消息原文）和选择该action的原因。
你必须从上面列出的可用action中选择一个，并说明触发action的消息id（不是消息原文）和选择该action的原因。消息id格式:m+数字
请根据动作示例，以严格的 JSON 格式输出，且仅包含 JSON 内容：
""",
@@ -192,7 +191,7 @@ class ActionPlanner:
parsed_json = {}
action = parsed_json.get("action", "no_reply")
reasoning = parsed_json.get("reasoning", "未提供原因")
reasoning = parsed_json.get("reason", "未提供原因")
# 将所有其他属性添加到action_data
for key, value in parsed_json.items():
@@ -320,10 +319,18 @@ class ActionPlanner:
if mode == ChatMode.FOCUS:
no_action_block = """重要说明：
no_action_block = """
- 'no_reply' 表示不进行回复，等待合适的回复时机
- 当你刚刚发送了消息，没有人回复时，选择no_reply
- 当你一次发送了太多消息，为了避免打扰聊天节奏，选择no_reply
动作：no_reply
动作描述：不进行回复，等待合适的回复时机
- 当你刚刚发送了消息，没有人回复时，选择no_reply
- 当你一次发送了太多消息，为了避免打扰聊天节奏，选择no_reply
{{
"action": "no_reply",
"reason":"不回复的原因"
}}
"""
else:
no_action_block = """重要说明：

198
src/chat/replyer/default_generator.py
View File

@@ -97,8 +97,39 @@ def init_prompt():
不要浮夸，不要夸张修辞，不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出一条回复内容就好
现在，你说：
""",
"s4u_style_prompt",
"replyer_prompt",
)
Prompt(
"""
{expression_habits_block}
{tool_info_block}
{knowledge_prompt}
{memory_block}
{relation_info_block}
{extra_info_block}
{identity}
{action_descriptions}
{time_block}
你现在正在一个QQ群里聊天，以下是正在进行的聊天内容：
{background_dialogue_prompt}
你现在想补充说明你刚刚自己的发言内容：{target}
请你根据聊天内容，组织一条新回复。
你现在的心情是：{mood_state}
{reply_style}
{keywords_reaction_prompt}
请注意不要输出多余内容(包括前后缀，冒号和引号，at或 @等 )。只输出回复内容。
{moderation_prompt}
不要浮夸，不要夸张修辞，不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出一条回复内容就好
现在，你说：
""",
"replyer_self_prompt",
)
Prompt(
"""
@@ -136,8 +167,8 @@ class DefaultReplyer:
async def generate_reply_with_context(
self,
reply_to: str = "",
extra_info: str = "",
reply_reason: str = "",
available_actions: Optional[Dict[str, ActionInfo]] = None,
enable_tool: bool = True,
from_plugin: bool = True,
@@ -150,6 +181,7 @@ class DefaultReplyer:
Args:
reply_to: 回复对象，格式为 "发送者:消息内容"
extra_info: 额外信息，用于补充上下文
reply_reason: 回复原因
available_actions: 可用的动作信息字典
enable_tool: 是否启用工具调用
from_plugin: 是否来自插件
@@ -164,11 +196,11 @@ class DefaultReplyer:
# 3. 构建 Prompt
with Timer("构建Prompt", {}): # 内部计时器，可选保留
prompt = await self.build_prompt_reply_context(
reply_to=reply_to,
extra_info=extra_info,
available_actions=available_actions,
enable_tool=enable_tool,
reply_message=reply_message,
reply_reason=reply_reason,
)
if not prompt:
@@ -620,8 +652,8 @@ class DefaultReplyer:
async def build_prompt_reply_context(
self,
reply_to: str,
extra_info: str = "",
reply_reason: str = "",
available_actions: Optional[Dict[str, ActionInfo]] = None,
enable_tool: bool = True,
reply_message: Optional[Dict[str, Any]] = None,
@@ -630,8 +662,8 @@ class DefaultReplyer:
构建回复器上下文
Args:
reply_to: 回复对象，格式为 "发送者:消息内容"
extra_info: 额外信息，用于补充上下文
reply_reason: 回复原因
available_actions: 可用动作
enable_timeout: 是否启用超时处理
enable_tool: 是否启用工具调用
@@ -645,35 +677,27 @@ class DefaultReplyer:
chat_id = chat_stream.stream_id
person_info_manager = get_person_info_manager()
is_group_chat = bool(chat_stream.group_info)
platform = chat_stream.platform
user_id = reply_message.get("user_id","")
if user_id:
person_id = person_info_manager.get_person_id(platform,user_id)
person_name = await person_info_manager.get_value(person_id, "person_name")
sender = person_name
target = reply_message.get('processed_plain_text')
else:
person_id = ""
person_name = "用户"
sender = "用户"
target = "消息"
if global_config.mood.enable_mood:
chat_mood = mood_manager.get_mood_by_chat_id(chat_id)
mood_prompt = chat_mood.mood_state
else:
mood_prompt = ""
if reply_to:
#兼容旧的reply_to
sender, target = self._parse_reply_target(reply_to)
else:
# 获取 platform，如果不存在则从 chat_stream 获取，如果还是 None 则使用默认值
platform = reply_message.get("chat_info_platform")
person_id = person_info_manager.get_person_id(
platform, # type: ignore
reply_message.get("user_id"), # type: ignore
)
person_name = await person_info_manager.get_value(person_id, "person_name")
sender = person_name
target = reply_message.get('processed_plain_text')
person_info_manager = get_person_info_manager()
person_id = person_info_manager.get_person_id_by_person_name(sender)
user_id = person_info_manager.get_value_sync(person_id, "user_id")
platform = chat_stream.platform
if user_id == global_config.bot.qq_account and platform == global_config.bot.platform:
logger.warning("选取了自身作为回复对象，跳过构建prompt")
return ""
target = replace_user_references_sync(target, chat_stream.platform, replace_bot_name=True)
# 构建action描述 (如果启用planner)
@@ -759,27 +783,16 @@ class DefaultReplyer:
"请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。"
)
if sender and target:
if sender:
if is_group_chat:
if sender:
reply_target_block = (
f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。"
)
elif target:
reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。"
else:
reply_target_block = "现在，你想要在群里发言或者回复消息。"
reply_target_block = (
f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。原因是{reply_reason}"
)
else: # private chat
if sender:
reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。"
elif target:
reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。"
else:
reply_target_block = "现在，你想要回复。"
reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。原因是{reply_reason}"
else:
reply_target_block = ""
template_name = "default_generator_prompt"
if is_group_chat:
chat_target_1 = await global_prompt_manager.get_prompt_async("chat_target_group1")
chat_target_2 = await global_prompt_manager.get_prompt_async("chat_target_group2")
@@ -796,69 +809,52 @@ class DefaultReplyer:
"chat_target_private2", sender_name=chat_target_name
)
target_user_id = ""
person_id = ""
if sender:
# 根据sender通过person_info_manager反向查找person_id，再获取user_id
person_id = person_info_manager.get_person_id_by_person_name(sender)
# 使用 s4u 对话构建模式：分离当前对话对象和其他对话
try:
user_id_value = await person_info_manager.get_value(person_id, "user_id")
if user_id_value:
target_user_id = str(user_id_value)
except Exception as e:
logger.warning(f"无法从person_id {person_id} 获取user_id: {e}")
target_user_id = ""
# 构建分离的对话 prompt
core_dialogue_prompt, background_dialogue_prompt = self.build_s4u_chat_history_prompts(
message_list_before_now_long, target_user_id, sender
message_list_before_now_long, user_id, sender
)
self.build_mai_think_context(
chat_id=chat_id,
memory_block=memory_block,
relation_info=relation_info,
time_block=time_block,
chat_target_1=chat_target_1,
chat_target_2=chat_target_2,
mood_prompt=mood_prompt,
identity_block=identity_block,
sender=sender,
target=target,
chat_info=f"""
{background_dialogue_prompt}
--------------------------------
{time_block}
这是你和{sender}的对话，你们正在交流中：
{core_dialogue_prompt}""",
)
# 使用 s4u 风格的模板
template_name = "s4u_style_prompt"
return await global_prompt_manager.format_prompt(
template_name,
expression_habits_block=expression_habits_block,
tool_info_block=tool_info,
knowledge_prompt=prompt_info,
memory_block=memory_block,
relation_info_block=relation_info,
extra_info_block=extra_info_block,
identity=identity_block,
action_descriptions=action_descriptions,
sender_name=sender,
mood_state=mood_prompt,
background_dialogue_prompt=background_dialogue_prompt,
time_block=time_block,
core_dialogue_prompt=core_dialogue_prompt,
reply_target_block=reply_target_block,
message_txt=target,
reply_style=global_config.personality.reply_style,
keywords_reaction_prompt=keywords_reaction_prompt,
moderation_prompt=moderation_prompt_block,
)
if global_config.bot.qq_account == user_id and platform == global_config.bot.platform:
return await global_prompt_manager.format_prompt(
"replyer_self_prompt",
expression_habits_block=expression_habits_block,
tool_info_block=tool_info,
knowledge_prompt=prompt_info,
memory_block=memory_block,
relation_info_block=relation_info,
extra_info_block=extra_info_block,
identity=identity_block,
action_descriptions=action_descriptions,
mood_state=mood_prompt,
background_dialogue_prompt=background_dialogue_prompt,
time_block=time_block,
target = target,
reply_style=global_config.personality.reply_style,
keywords_reaction_prompt=keywords_reaction_prompt,
moderation_prompt=moderation_prompt_block,
)
else:
return await global_prompt_manager.format_prompt(
"replyer_prompt",
expression_habits_block=expression_habits_block,
tool_info_block=tool_info,
knowledge_prompt=prompt_info,
memory_block=memory_block,
relation_info_block=relation_info,
extra_info_block=extra_info_block,
identity=identity_block,
action_descriptions=action_descriptions,
sender_name=sender,
mood_state=mood_prompt,
background_dialogue_prompt=background_dialogue_prompt,
time_block=time_block,
core_dialogue_prompt=core_dialogue_prompt,
reply_target_block=reply_target_block,
reply_style=global_config.personality.reply_style,
keywords_reaction_prompt=keywords_reaction_prompt,
moderation_prompt=moderation_prompt_block,
)
async def build_prompt_rewrite_context(
self,

16
src/plugin_system/apis/generator_api.py
View File

@@ -77,6 +77,7 @@ async def generate_reply(
reply_to: str = "",
reply_message: Optional[Dict[str, Any]] = None,
extra_info: str = "",
reply_reason: str = "",
available_actions: Optional[Dict[str, ActionInfo]] = None,
enable_tool: bool = False,
enable_splitter: bool = True,
@@ -92,8 +93,9 @@ async def generate_reply(
chat_id: 聊天ID（备用）
action_data: 动作数据（向下兼容，包含reply_to和extra_info）
reply_to: 回复对象，格式为 "发送者:消息内容"
reply_message: 回复的原始消息
reply_message: 回复消息
extra_info: 额外信息，用于补充上下文
reply_reason: 回复原因
available_actions: 可用动作
enable_tool: 是否启用工具调用
enable_splitter: 是否启用消息分割器
@@ -115,21 +117,25 @@ async def generate_reply(
return False, [], None
logger.debug("[GeneratorAPI] 开始生成回复")
if reply_to:
logger.warning("[GeneratorAPI] 在0.10.0, reply_to 参数已弃用，请使用 reply_message 参数")
if not reply_to and action_data:
reply_to = action_data.get("reply_to", "")
if not extra_info and action_data:
extra_info = action_data.get("extra_info", "")
if not reply_reason and action_data:
reply_reason = action_data.get("reason", "")
# 调用回复器生成回复
success, llm_response_dict, prompt = await replyer.generate_reply_with_context(
reply_to=reply_to,
extra_info=extra_info,
available_actions=available_actions,
enable_tool=enable_tool,
reply_message=reply_message,
reply_reason=reply_reason,
from_plugin=from_plugin,
stream_id=chat_stream.stream_id if chat_stream else chat_id,
reply_message=reply_message,
)
if not success:
logger.warning("[GeneratorAPI] 回复生成失败")

129
src/plugin_system/apis/send_api.py
View File

@@ -100,7 +100,7 @@ async def _send_to_target(
message_segment = Seg(type=message_type, data=content) # type: ignore
if reply_to_message:
anchor_message = MessageRecv(message_dict=reply_to_message)
anchor_message = message_dict_to_message_recv(reply_to_message)
anchor_message.update_chat_stream(target_stream)
reply_to_platform_id = (
f"{anchor_message.message_info.platform}:{anchor_message.message_info.user_info.user_id}"
@@ -145,111 +145,56 @@ async def _send_to_target(
return False
async def _find_reply_message(target_stream, reply_to: str) -> Optional[MessageRecv]:
# sourcery skip: inline-variable, use-named-expression
def message_dict_to_message_recv(message_dict: Dict[str, Any]) -> Optional[MessageRecv]:
"""查找要回复的消息
Args:
target_stream: 目标聊天流
reply_to: 回复格式，如"发送者:消息内容"或"发送者：消息内容"
message_dict: 消息字典
Returns:
Optional[MessageRecv]: 找到的消息，如果没找到则返回None
"""
try:
# 解析reply_to参数
if ":" in reply_to:
parts = reply_to.split(":", 1)
elif "：" in reply_to:
parts = reply_to.split("：", 1)
else:
logger.warning(f"[SendAPI] reply_to格式不正确: {reply_to}")
return None
# 构建MessageRecv对象
user_info = {
"platform": message_dict.get("user_platform", ""),
"user_id": message_dict.get("user_id", ""),
"user_nickname": message_dict.get("user_nickname", ""),
"user_cardname": message_dict.get("user_cardname", ""),
}
if len(parts) != 2:
logger.warning(f"[SendAPI] reply_to格式不正确: {reply_to}")
return None
sender = parts[0].strip()
text = parts[1].strip()
# 获取聊天流的最新20条消息
reverse_talking_message = get_raw_msg_before_timestamp_with_chat(
target_stream.stream_id,
time.time(), # 当前时间之前的消息
20, # 最新的20条消息
)
# 反转列表，使最新的消息在前面
reverse_talking_message = list(reversed(reverse_talking_message))
find_msg = None
for message in reverse_talking_message:
user_id = message["user_id"]
platform = message["chat_info_platform"]
person_id = get_person_info_manager().get_person_id(platform, user_id)
person_name = await get_person_info_manager().get_value(person_id, "person_name")
if person_name == sender:
translate_text = message["processed_plain_text"]
# 使用独立函数处理用户引用格式
translate_text = await replace_user_references_async(translate_text, platform)
similarity = difflib.SequenceMatcher(None, text, translate_text).ratio()
if similarity >= 0.9:
find_msg = message
break
if not find_msg:
logger.info("[SendAPI] 未找到匹配的回复消息")
return None
# 构建MessageRecv对象
user_info = {
"platform": find_msg.get("user_platform", ""),
"user_id": find_msg.get("user_id", ""),
"user_nickname": find_msg.get("user_nickname", ""),
"user_cardname": find_msg.get("user_cardname", ""),
group_info = {}
if message_dict.get("chat_info_group_id"):
group_info = {
"platform": message_dict.get("chat_info_group_platform", ""),
"group_id": message_dict.get("chat_info_group_id", ""),
"group_name": message_dict.get("chat_info_group_name", ""),
}
group_info = {}
if find_msg.get("chat_info_group_id"):
group_info = {
"platform": find_msg.get("chat_info_group_platform", ""),
"group_id": find_msg.get("chat_info_group_id", ""),
"group_name": find_msg.get("chat_info_group_name", ""),
}
format_info = {"content_format": "", "accept_format": ""}
template_info = {"template_items": {}}
format_info = {"content_format": "", "accept_format": ""}
template_info = {"template_items": {}}
message_info = {
"platform": message_dict.get("chat_info_platform", ""),
"message_id": message_dict.get("message_id"),
"time": message_dict.get("time"),
"group_info": group_info,
"user_info": user_info,
"additional_config": message_dict.get("additional_config"),
"format_info": format_info,
"template_info": template_info,
}
message_info = {
"platform": target_stream.platform,
"message_id": find_msg.get("message_id"),
"time": find_msg.get("time"),
"group_info": group_info,
"user_info": user_info,
"additional_config": find_msg.get("additional_config"),
"format_info": format_info,
"template_info": template_info,
}
message_dict = {
"message_info": message_info,
"raw_message": message_dict.get("processed_plain_text"),
"processed_plain_text": message_dict.get("processed_plain_text"),
}
message_dict = {
"message_info": message_info,
"raw_message": find_msg.get("processed_plain_text"),
"processed_plain_text": find_msg.get("processed_plain_text"),
}
message_recv = MessageRecv(message_dict)
logger.info(f"[SendAPI] 找到匹配的回复消息，发送者: {message_dict.get('user_nickname', '')}")
return message_recv
find_rec_msg = MessageRecv(message_dict)
find_rec_msg.update_chat_stream(target_stream)
logger.info(f"[SendAPI] 找到匹配的回复消息，发送者: {sender}")
return find_rec_msg
except Exception as e:
logger.error(f"[SendAPI] 查找回复消息时出错: {e}")
traceback.print_exc()
return None
# =============================================================================