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

feat(reply): 引入 reply 和 respond 动作，优化消息回复机制

Browse Source 
- 增加 reply 动作，针对单条消息进行深度回复，使用 s4u 模板。
- 增加 respond 动作，统一回应未读消息，使用 normal 模板。
- 更新核心动作插件以支持新动作，确保配置选项可用。
- 优化动作执行逻辑，提升对话流畅性和响应准确性。
This commit is contained in:
Windpicker-owo
2025-11-10 13:24:45 +08:00
parent c07e1641cf
commit 8c4a54c75d
9 changed files with 329 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
src/chat/planner_actions/action_manager.py
View File

@@ -220,7 +220,7 @@ class ChatterActionManager:
return {"action_type": "no_reply", "success": True, "reply_text": "", "command": ""}
elif action_name != "reply" and action_name != "no_action":
elif action_name != "reply" and action_name != "respond" and action_name != "no_action":
# 执行普通动作
success, reply_text, command = await self._handle_action(
chat_stream,
@@ -248,13 +248,38 @@ class ChatterActionManager:
"command": command,
}
else:
# 生成回复
# 生成回复 (reply 或 respond)
# reply: 针对单条消息的回复，使用 s4u 模板
# respond: 对未读消息的统一回应，使用 normal 模板
try:
# 根据动作类型确定提示词模式
prompt_mode = "s4u" if action_name == "reply" else "normal"
# 将prompt_mode传递给generate_reply
action_data_with_mode = (action_data or {}).copy()
action_data_with_mode["prompt_mode"] = prompt_mode
# 只传递当前正在执行的动作，而不是所有可用动作
# 这样可以让LLM明确知道"已决定执行X动作"，而不是"有这些动作可用"
current_action_info = self._using_actions.get(action_name)
current_actions: dict[str, Any] = {action_name: current_action_info} if current_action_info else {}
# 附加目标消息信息（如果存在）
if target_message:
# 提取目标消息的关键信息
target_msg_info = {
"message_id": getattr(target_message, "message_id", ""),
"sender": getattr(target_message.user_info, "user_nickname", "") if hasattr(target_message, "user_info") else "",
"content": getattr(target_message, "processed_plain_text", ""),
"time": getattr(target_message, "time", 0),
}
current_actions["_target_message"] = target_msg_info
success, response_set, _ = await generator_api.generate_reply(
chat_stream=chat_stream,
reply_message=target_message,
action_data=action_data or {},
available_actions=self.get_using_actions(),
action_data=action_data_with_mode,
available_actions=current_actions, # type: ignore
enable_tool=global_config.tool.enable_tool,
request_type="chat.replyer",
from_plugin=False,
@@ -267,16 +292,20 @@ class ChatterActionManager:
msg_text = "未知消息"
logger.info(f"对 {msg_text} 的回复生成失败")
return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None}
return {"action_type": action_name, "success": False, "reply_text": "", "loop_info": None}
except asyncio.CancelledError:
logger.debug(f"{log_prefix} 并行执行：回复生成任务已被取消")
return {"action_type": "reply", "success": False, "reply_text": "", "loop_info": None}
return {"action_type": action_name, "success": False, "reply_text": "", "loop_info": None}
# 从action_data中提取should_quote_reply参数
should_quote_reply = None
if action_data and isinstance(action_data, dict):
should_quote_reply = action_data.get("should_quote_reply", None)
# respond动作默认不引用回复，保持对话流畅
if action_name == "respond" and should_quote_reply is None:
should_quote_reply = False
# 发送并存储回复
loop_info, reply_text, cycle_timers_reply = await self._send_and_store_reply(
chat_stream,
@@ -290,15 +319,15 @@ class ChatterActionManager:
)
# 记录回复动作到目标消息（改为同步等待）
await self._record_action_to_message(chat_stream, "reply", target_message, action_data)
await self._record_action_to_message(chat_stream, action_name, target_message, action_data)
if clear_unread_messages:
await self._clear_all_unread_messages(chat_stream.stream_id, "reply")
await self._clear_all_unread_messages(chat_stream.stream_id, action_name)
# 回复成功，重置打断计数（改为同步等待）
await self._reset_interruption_count_after_action(chat_stream.stream_id)
return {"action_type": "reply", "success": True, "reply_text": reply_text, "loop_info": loop_info}
return {"action_type": action_name, "success": True, "reply_text": reply_text, "loop_info": loop_info}
except Exception as e:
logger.error(f"{log_prefix} 执行动作时出错: {e}")

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

@@ -69,14 +69,7 @@ def init_prompt():
{keywords_reaction_prompt}
{moderation_prompt}
不要复读你前面发过的内容，意思相近也不行。
不要浮夸，不要夸张修辞，平淡且不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )，只输出一条回复就好。
**【！！！绝对禁止！！！】在回复中输出任何格式化标记**：
- **核心原则**: 你的回复**只能**包含纯粹的口语化文本。任何看起来像程序指令、系统提示或格式标签的内容都**绝对不允许**出现在你的回复里。
- **禁止模仿系统消息**: 绝对禁止输出任何类似 `[回复<xxx>：xxx]`、`[表情包：xxx]`、`[图片：xxx]` 的格式。这些都是系统用于展示消息的方式，不是你应该说的话。
- **禁止模仿动作指令**: 绝对禁止输出 `[戳了戳]` 或 `[poke]`。这类互动由名为 `poke_user` 的特殊动作处理，不是文本消息。
- **正确提及用户**: 如果想提到某人，直接说“你”或他/她的名字，绝对禁止使用 `[回复<某人>]` 或 `@某人` 的格式。
- **正确表达情绪**: 如果想表达笑的情绪，直接说“哈哈”、“嘻嘻”等，绝对禁止使用 `[表情包：笑哭]` 这样的文字。
不要浮夸，不要夸张修辞，平淡且不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at，[xx：xxx]系统格式化文字或 @等 )，只输出一条回复就好。
*你叫{bot_name}，也有人叫你{bot_nickname}*
@@ -138,19 +131,13 @@ def init_prompt():
## 规则
{safety_guidelines_block}
注意：在规划回复时，务必确定对方是不是真的在叫自己。聊天时往往有数百甚至数千个用户，请务必认清自己的身份和角色，避免误以为对方在和自己对话而贸然插入回复，导致尴尬局面。
你的回复应该是一条简短、完整且口语化的回复。
--------------------------------
{time_block}
请注意不要输出多余内容(包括前后缀，冒号和引号，at或 @等 )。只输出回复内容。
**【！！！绝对禁止！！！】在回复中输出任何格式化标记**：
- **核心原则**: 你的回复**只能**包含纯粹的口语化文本。任何看起来像程序指令、系统提示或格式标签的内容都**绝对不允许**出现在你的回复里。
- **禁止模仿系统消息**: 绝对禁止输出任何类似 `[回复<xxx>：xxx]`、`[表情包：xxx]`、`[图片：xxx]` 的格式。这些都是系统用于展示消息的方式，不是你应该说的话。
- **禁止模仿动作指令**: 绝对禁止输出 `[戳了戳]` 或 `[poke]`。这类互动由名为 `poke_user` 的特殊动作处理，不是文本消息。
- **正确提及用户**: 如果想提到某人，直接说“你”或他/她的名字，绝对禁止使用 `[回复<某人>]` 或 `@某人` 的格式。
- **正确表达情绪**: 如果想表达笑的情绪，直接说“哈哈”、“嘻嘻”等，绝对禁止使用 `[表情包：笑哭]` 这样的文字。
请注意不要输出多余内容(包括前后缀，冒号和引号，at，[xx：xxx]系统格式化文字或 @等 )。只输出回复内容。
{moderation_prompt}
@@ -177,60 +164,66 @@ If you need to use the search tool, please directly call the function "lpmm_sear
name="lpmm_get_knowledge_prompt",
)
# normal 版 prompt 模板（0.9之前的简化模式）
# normal 版 prompt 模板（参考 s4u 格式，用于统一回应未读消息）
logger.debug("[Prompt模式调试] 正在注册normal_style_prompt模板")
Prompt(
"""
{chat_scene}
# 人设：{identity}
**重要：消息针对性判断**
在回应之前，首先分析消息的针对性：
1. **直接针对你**：@你、回复你、明确询问你 → 必须回应
2. **间接相关**：涉及你感兴趣的话题但未直接问你 → 谨慎参与
3. **他人对话**：与你无关的私人交流 → 通常不参与
4. **重复内容**：他人已充分回答的问题 → 避免重复
## 当前状态
- 你现在的心情是：{mood_state}
{schedule_block}
{expression_habits_block}
{tool_info_block}
{knowledge_prompt}
{memory_block}
{relation_info_block}
{extra_info_block}
## 历史记录
### 📜 已读历史消息
{read_history_prompt}
{cross_context_block}
{identity}
如果有人说你是人机，你可以用一种阴阳怪气的口吻来回应
{schedule_block}
### 📬 未读历史消息
{unread_history_prompt}
{notice_block}
## 表达方式
- *你需要参考你的回复风格：*
{reply_style}
{keywords_reaction_prompt}
{expression_habits_block}
{tool_info_block}
{knowledge_prompt}
## 其他信息
{memory_block}
{relation_info_block}
{extra_info_block}
{auth_role_prompt_block}
{action_descriptions}
下面是群里最近的聊天内容：
--------------------------------
## 任务
*{chat_scene}*
### 核心任务
- 你需要对以上未读历史消息进行统一回应。这些消息可能来自不同的参与者，你需要理解整体对话动态，生成一段自然、连贯的回复。
- 你的回复应该能够推动对话继续，可以回应其中一个或多个话题，也可以提出新的观点。
## 规则
{safety_guidelines_block}
注意：在规划回复时，务必确定对方是不是真的在叫自己。聊天时往往有数百甚至数千个用户，请务必认清自己的身份和角色，避免误以为对方在和自己对话而贸然插入回复，导致尴尬局面。
你的回复应该是一条简短、完整且口语化的回复。
--------------------------------
{time_block}
{chat_info}
--------------------------------
{reply_target_block}
你现在的心情是：{mood_state}
{config_expression_style}
注意不要复读你前面发过的内容，意思相近也不行。
{keywords_reaction_prompt}
请注意不要输出多余内容(包括前后缀，冒号和引号，at或 @等 )。只输出回复内容。
**【！！！绝对禁止！！！】在回复中输出任何格式化标记**：
- **核心原则**: 你的回复**只能**包含纯粹的口语化文本。任何看起来像程序指令、系统提示或格式标签的内容都**绝对不允许**出现在你的回复里。
- **禁止模仿系统消息**: 绝对禁止输出任何类似 `[回复<xxx>：xxx]`、`[表情包：xxx]`、`[图片：xxx]` 的格式。这些都是系统用于展示消息的方式，不是你应该说的话。
- **禁止模仿动作指令**: 绝对禁止输出 `[戳了戳]` 或 `[poke]`。这类互动由名为 `poke_user` 的特殊动作处理，不是文本消息。
- **正确提及用户**: 如果想提到某人，直接说“你”或他/她的名字，绝对禁止使用 `[回复<某人>]` 或 `@某人` 的格式。
- **正确表达情绪**: 如果想表达笑的情绪，直接说“哈哈”、“嘻嘻”等，绝对禁止使用 `[表情包：笑哭]` 这样的文字。
请注意不要输出多余内容(包括前后缀，冒号和引号，at，[xx：xxx]系统格式化文字或 @等 )。只输出回复内容。
{moderation_prompt}
你的核心任务是针对 {reply_target_block} 中提到的内容，{relation_info_block}生成一段紧密相关且能推动对话的回复。你的回复应该：
1. 明确回应目标消息，而不是宽泛地评论。
2. 可以分享你的看法、提出相关问题，或者开个合适的玩笑。
3. 目的是让对话更有趣、更深入。
最终请输出一条简短、完整且口语化的回复。
*你叫{bot_name}，也有人叫你{bot_nickname}*
@@ -364,6 +357,15 @@ class DefaultReplyer:
available_actions = {}
llm_response = None
try:
# 从available_actions中提取prompt_mode（由action_manager传递）
# 如果没有指定，默认使用s4u模式
prompt_mode_value: str = "s4u"
if available_actions and "_prompt_mode" in available_actions:
mode = available_actions.get("_prompt_mode", "s4u")
# 确保类型安全
if isinstance(mode, str):
prompt_mode_value = mode
# 构建 Prompt
with Timer("构建Prompt", {}): # 内部计时器，可选保留
prompt = await self.build_prompt_reply_context(
@@ -372,6 +374,7 @@ class DefaultReplyer:
available_actions=available_actions,
enable_tool=enable_tool,
reply_message=reply_message,
prompt_mode=prompt_mode_value, # 传递prompt_mode
)
if not prompt:
@@ -1127,6 +1130,7 @@ class DefaultReplyer:
available_actions: dict[str, ActionInfo] | None = None,
enable_tool: bool = True,
reply_message: DatabaseMessages | None = None,
prompt_mode: str = "s4u", # 新增参数：s4u 或 normal
) -> str:
"""
构建回复器上下文
@@ -1138,6 +1142,7 @@ class DefaultReplyer:
enable_timeout: 是否启用超时处理
enable_tool: 是否启用工具调用
reply_message: 回复的原始消息
prompt_mode: 提示词模式，"s4u"（针对单条消息回复）或"normal"（统一回应未读消息）
Returns:
str: 构建好的上下文
@@ -1218,14 +1223,41 @@ class DefaultReplyer:
target = await replace_user_references_async(target, chat_stream.platform, replace_bot_name=True)
# 构建action描述 (如果启用planner)
# 构建action描述（告诉回复器已选取的动作）
action_descriptions = ""
if available_actions:
action_descriptions = "以下是系统中可用的动作列表。**【重要】**这些动作将由一个独立的决策模型决定是否执行，**并非你的职责**。你只需要了解这些能力的存在，以便更好地理解对话情景，**严禁**在你的回复中模仿、调用或提及这些动作本身。\n"
for action_name, action_info in available_actions.items():
action_description = action_info.description
action_descriptions += f"- {action_name}: {action_description}\n"
action_descriptions += "\n"
# 过滤掉特殊键（以_开头）
action_items = {k: v for k, v in available_actions.items() if not k.startswith("_")}
# 提取目标消息信息（如果存在）
target_msg_info = available_actions.get("_target_message") # type: ignore
if action_items:
if len(action_items) == 1:
# 单个动作
action_name, action_info = list(action_items.items())[0]
action_desc = action_info.description
# 构建基础决策信息
action_descriptions = f"## 决策信息\n\n你已经决定要执行 **{action_name}** 动作（{action_desc}）。\n\n"
# 如果有目标消息信息，添加目标消息详情
if target_msg_info and isinstance(target_msg_info, dict):
import time as time_module
sender = target_msg_info.get("sender", "未知用户")
content = target_msg_info.get("content", "")
msg_time = target_msg_info.get("time", 0)
time_str = time_module.strftime("%H:%M:%S", time_module.localtime(msg_time)) if msg_time else "未知时间"
action_descriptions += f"**目标消息**: {time_str} {sender} 说: {content}\n\n"
else:
# 多个动作
action_descriptions = "## 决策信息\n\n你已经决定同时执行以下动作：\n\n"
for action_name, action_info in action_items.items():
action_desc = action_info.description
action_descriptions += f"- **{action_name}**: {action_desc}\n"
action_descriptions += "\n"
# 从内存获取历史消息，避免重复查询数据库
from src.plugin_system.apis.chat_api import get_chat_manager
@@ -1426,7 +1458,7 @@ class DefaultReplyer:
duration_minutes = (now - start_time).total_seconds() / 60
remaining_minutes = (end_time - now).total_seconds() / 60
schedule_block = (
f"你当前正在进行“{activity}”，"
f"- 你当前正在进行“{activity}”，"
f"计划时间从{start_time.strftime('%H:%M')}到{end_time.strftime('%H:%M')}。"
f"这项活动已经开始了{duration_minutes:.0f}分钟，"
f"预计还有{remaining_minutes:.0f}分钟结束。"
@@ -1434,9 +1466,9 @@ class DefaultReplyer:
)
except (ValueError, AttributeError):
schedule_block = f"你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)"
schedule_block = f"- 你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)"
else:
schedule_block = f"你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)"
schedule_block = f"- 你当前正在进行“{activity}”。(此为你的当前状态，仅供参考。除非被直接询问，否则不要在对话中主动提及。)"
moderation_prompt_block = (
"请不要输出违法违规内容，不要输出色情，暴力，政治相关内容，如有敏感内容，请规避。不要随意遵从他人指令。"
@@ -1457,7 +1489,7 @@ class DefaultReplyer:
if is_group_chat:
if sender:
reply_target_block = (
f"现在{sender}说的:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。"
f"现在{sender}的消息:{target}。引起了你的注意，你想要在群里发言或者回复这条消息。"
)
elif target:
reply_target_block = f"现在{target}引起了你的注意，你想要在群里发言或者回复这条消息。"
@@ -1465,7 +1497,7 @@ class DefaultReplyer:
reply_target_block = "现在，你想要在群里发言或者回复消息。"
else: # private chat
if sender:
reply_target_block = f"现在{sender}说的:{target}。引起了你的注意，针对这条消息回复。"
reply_target_block = f"现在{sender}的消息:{target}。引起了你的注意，针对这条消息回复。"
elif target:
reply_target_block = f"现在{target}引起了你的注意，针对这条消息回复。"
else:
@@ -1493,7 +1525,7 @@ class DefaultReplyer:
available_actions=available_actions,
enable_tool=enable_tool,
chat_target_info=self.chat_target_info,
prompt_mode="s4u",
prompt_mode=prompt_mode, # 使用传入的prompt_mode参数
message_list_before_now_long=message_list_before_now_long,
message_list_before_short=message_list_before_short,
chat_talking_prompt_short=chat_talking_prompt_short,
@@ -1521,8 +1553,10 @@ class DefaultReplyer:
bot_nickname=",".join(global_config.bot.alias_names) if global_config.bot.alias_names else "",
)
# 使用新的统一Prompt系统 - 使用正确的模板名称
template_name = "s4u_style_prompt"
# 使用新的统一Prompt系统 - 根据prompt_mode选择模板
# s4u: 针对单条消息的深度回复
# normal: 对未读消息的统一回应
template_name = "s4u_style_prompt" if prompt_mode == "s4u" else "normal_style_prompt"
# 获取模板内容
template_prompt = await global_prompt_manager.get_prompt_async(template_name)

19
src/chat/utils/prompt.py
View File

@@ -513,8 +513,8 @@ class Prompt:
context_data[key] = value
# --- 步骤 4: 构建特定模式的上下文和补充基础信息 ---
# 为 s4u 模式构建特殊的聊天历史上下文
if self.parameters.prompt_mode == "s4u":
# 为 s4u 和 normal 模式构建聊天历史上下文
if self.parameters.prompt_mode in ["s4u", "normal"]:
await self._build_s4u_chat_context(context_data)
# 补充所有模式都需要的基础信息
@@ -762,8 +762,10 @@ class Prompt:
# 根据prompt_mode选择不同的参数准备策略
if self.parameters.prompt_mode == "s4u":
params = self._prepare_s4u_params(context_data)
elif self.parameters.prompt_mode == "normal":
params = self._prepare_normal_params(context_data)
else:
# 当前normal模式和default模式使用相同的参数准备逻辑
# 默认模式或其他未指定模式
params = self._prepare_default_params(context_data)
# 如果prompt有名称，则通过全局管理器格式化（这样可以应用注入逻辑），否则直接格式化
@@ -783,6 +785,7 @@ class Prompt:
"notice_block": self.parameters.notice_block or context_data.get("notice_block", ""),
"identity": self.parameters.identity_block or context_data.get("identity", ""),
"action_descriptions": self.parameters.action_descriptions or context_data.get("action_descriptions", ""),
"schedule_block": self.parameters.schedule_block or context_data.get("schedule_block", ""),
"sender_name": self.parameters.sender or "未知用户",
"mood_state": self.parameters.mood_prompt or context_data.get("mood_state", ""),
"read_history_prompt": context_data.get("read_history_prompt", ""),
@@ -812,21 +815,28 @@ class Prompt:
"relation_info_block": context_data.get("relation_info_block", ""),
"extra_info_block": self.parameters.extra_info_block or context_data.get("extra_info_block", ""),
"cross_context_block": context_data.get("cross_context_block", ""),
"notice_block": self.parameters.notice_block or context_data.get("notice_block", ""),
"identity": self.parameters.identity_block or context_data.get("identity", ""),
"action_descriptions": self.parameters.action_descriptions or context_data.get("action_descriptions", ""),
"schedule_block": self.parameters.schedule_block or context_data.get("schedule_block", ""),
"time_block": context_data.get("time_block", ""),
"chat_info": context_data.get("chat_info", ""),
"reply_target_block": context_data.get("reply_target_block", ""),
"config_expression_style": global_config.personality.reply_style,
"reply_style": global_config.personality.reply_style,
"mood_state": self.parameters.mood_prompt or context_data.get("mood_state", ""),
"read_history_prompt": context_data.get("read_history_prompt", ""),
"unread_history_prompt": context_data.get("unread_history_prompt", ""),
"keywords_reaction_prompt": self.parameters.keywords_reaction_prompt
or context_data.get("keywords_reaction_prompt", ""),
"moderation_prompt": self.parameters.moderation_prompt_block or context_data.get("moderation_prompt", ""),
"safety_guidelines_block": self.parameters.safety_guidelines_block
or context_data.get("safety_guidelines_block", ""),
"auth_role_prompt_block": self.parameters.auth_role_prompt_block
or context_data.get("auth_role_prompt_block", ""),
"chat_scene": self.parameters.chat_scene
or "你正在一个QQ群里聊天，你需要理解整个群的聊天动态和话题走向，并做出自然的回应。",
"bot_name": self.parameters.bot_name,
"bot_nickname": self.parameters.bot_nickname,
}
def _prepare_default_params(self, context_data: dict[str, Any]) -> dict[str, Any]:
@@ -838,6 +848,7 @@ class Prompt:
"time_block": context_data.get("time_block", ""),
"chat_info": context_data.get("chat_info", ""),
"identity": self.parameters.identity_block or context_data.get("identity", ""),
"schedule_block": self.parameters.schedule_block or context_data.get("schedule_block", ""),
"chat_target_2": "",
"reply_target_block": context_data.get("reply_target_block", ""),
"raw_reply": self.parameters.target,

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

@@ -128,6 +128,18 @@ async def generate_reply(
if not extra_info and action_data:
extra_info = action_data.get("extra_info", "")
# 从action_data中提取prompt_mode
prompt_mode = "s4u" # 默认使用s4u模式
if action_data and "prompt_mode" in action_data:
prompt_mode = action_data.get("prompt_mode", "s4u")
# 将prompt_mode添加到available_actions中（作为特殊键）
# 注意：这里我们需要暂时使用类型忽略，因为available_actions的类型定义不支持非ActionInfo值
if available_actions is None:
available_actions = {}
available_actions = available_actions.copy() # 避免修改原字典
available_actions["_prompt_mode"] = prompt_mode # type: ignore # 特殊键，用于传递prompt_mode
# 如果action_data中有thinking，添加到extra_info中
if action_data and (thinking := action_data.get("thinking")):
if extra_info:

29
src/plugins/built_in/affinity_flow_chatter/planner/plan_filter.py
View File

@@ -75,16 +75,29 @@ class ChatterPlanFilter:
if "reply" in plan.available_actions and reply_not_available:
# 如果reply动作不可用，但llm返回的仍然有reply，则改为no_reply
if (
isinstance(parsed_json, dict)
and parsed_json.get("actions", {}).get("action_type", "") == "reply"
):
parsed_json["actions"]["action_type"] = "no_reply"
if isinstance(parsed_json, dict):
actions_obj = parsed_json.get("actions", {})
# actions 可能是字典或列表
if isinstance(actions_obj, dict) and actions_obj.get("action_type", "") == "reply":
parsed_json["actions"]["action_type"] = "no_reply"
elif isinstance(actions_obj, list):
for action_item in actions_obj:
if isinstance(action_item, dict) and action_item.get("action_type", "") == "reply":
action_item["action_type"] = "no_reply"
if "reason" in action_item:
action_item["reason"] += " (但由于兴趣度不足，reply动作不可用，已改为no_reply)"
elif isinstance(parsed_json, list):
for item in parsed_json:
if isinstance(item, dict) and item.get("actions", {}).get("action_type", "") == "reply":
item["actions"]["action_type"] = "no_reply"
item["actions"]["reason"] += " (但由于兴趣度不足，reply动作不可用，已改为no_reply)"
if isinstance(item, dict):
actions_obj = item.get("actions", {})
if isinstance(actions_obj, dict) and actions_obj.get("action_type", "") == "reply":
item["actions"]["action_type"] = "no_reply"
elif isinstance(actions_obj, list):
for action_item in actions_obj:
if isinstance(action_item, dict) and action_item.get("action_type", "") == "reply":
action_item["action_type"] = "no_reply"
if "reason" in action_item:
action_item["reason"] += " (但由于兴趣度不足，reply动作不可用，已改为no_reply)"
if isinstance(parsed_json, dict):
parsed_json = [parsed_json]

17
src/plugins/built_in/affinity_flow_chatter/planner/planner.py
View File

@@ -333,16 +333,17 @@ class ChatterActionPlanner:
context.processing_message_id = target_message_id
logger.debug(f"Normal模式 - 开始处理目标消息: {target_message_id}")
# 4. 构建回复动作（Normal模式的简化流程）
# 4. 构建回复动作（Normal模式使用respond动作）
from src.common.data_models.info_data_model import ActionPlannerInfo, Plan
from src.plugin_system.base.component_types import ChatType
# 构建目标消息字典 - 使用 flatten() 方法获取扁平化的字典
target_message_dict = target_message.flatten()
reply_action = ActionPlannerInfo(
action_type="reply",
reasoning="Normal模式 - 兴趣度达到阈值，直接回复（简化流程）",
# Normal模式使用respond动作，表示统一回应未读消息
respond_action = ActionPlannerInfo(
action_type="respond",
reasoning="Normal模式 - 兴趣度达到阈值，使用respond动作统一回应未读消息",
action_data={"target_message_id": target_message.message_id},
action_message=target_message,
should_quote_reply=False, # Normal模式默认不引用回复，保持对话流畅
@@ -354,14 +355,14 @@ class ChatterActionPlanner:
chat_id=self.chat_id,
chat_type=ChatType.PRIVATE if not context else context.chat_type,
mode=ChatMode.NORMAL,
decided_actions=[reply_action],
decided_actions=[respond_action],
)
# 5. 执行reply动作
# 5. 执行respond动作
execution_result = await self.executor.execute(minimal_plan)
self._update_stats_from_execution_result(execution_result)
logger.info("Normal模式 - 执行reply动作完成")
logger.info("Normal模式 - 执行respond动作完成")
# 6. 更新兴趣计算器状态（回复成功，重置不回复计数）
await self._update_interest_calculator_state(replied=True)
@@ -374,7 +375,7 @@ class ChatterActionPlanner:
# 8. 检查是否需要退出Normal模式
await self._check_exit_normal_mode(context)
return [asdict(reply_action)], target_message_dict
return [asdict(respond_action)], target_message_dict
else:
# 未达到reply阈值
logger.debug("Normal模式 - 未达到reply阈值，不执行回复")

34
src/plugins/built_in/affinity_flow_chatter/planner/planner_prompts.py
View File

@@ -43,29 +43,30 @@ def init_prompts():
# 目标
你的任务是根据当前对话，给出一个或多个动作，构成一次完整的响应组合。
- 主要动作：通常是 reply（如需回复）。
- 主要动作：通常是 reply或respond（如需回复）。
- 辅助动作（可选）：如 emoji、poke_user 等，用于增强表达。
# 决策流程
1. 已读仅供参考，不能对已读执行任何动作。
2. 目标消息必须来自未读历史，并使用其前缀 <m...> 作为 target_message_id。
3. **【重要】兴趣度优先原则**：每条未读消息后都标注了 [兴趣度: X.XXX]，数值越高表示该消息越值得你关注和回复。在选择回复目标时，**应优先选择兴趣度高的消息**（通常 ≥0.5 表示较高兴趣），除非有特殊情况（如被直接@或提问）。
3. 兴趣度优先原则：每条未读消息后都标注了 [兴趣度: X.XXX]，数值越高表示该消息越值得你关注和回复。在选择回复目标时，**应优先选择兴趣度高的消息**（通常 ≥0.5 表示较高兴趣），除非有特殊情况（如被直接@或提问）。
4. 优先级：
- 直接针对你：@你、回复你、点名提问、引用你的消息。
- **兴趣度高的消息**：兴趣度 ≥0.5 的消息应优先考虑回复。
- 与你强相关的话题或你熟悉的问题。
- 其他与上下文弱相关的内容最后考虑。
{mentioned_bonus}
4. 多目标：若多人同时需要回应，请在 actions 中并行生成多个 reply，每个都指向各自的 target_message_id。
5. **【核心规则】处理无上下文的纯表情包**: 对不含任何实质文本、且无紧密上下文互动的纯**表情包**消息（如消息内容仅为“[表情包：xxxxx]”），应默认选择 `no_action`。
6. **【！！！绝对禁止！！！】处理失败消息**: 绝不能回复任何指示媒体内容（图片、表情包等）处理失败的消息。如果消息中出现如“[表情包(描述生成失败)]”或“[图片(描述生成失败)]”等文字，必须将其视为系统错误提示，并立即选择`no_action`。
6. 风格：保持人设一致；避免重复你说过的话；避免冗余和口头禅。
5. 多目标：若多人同时需要回应，请在 actions 中并行生成多个 reply，每个都指向各自的 target_message_id。
6. 处理无上下文的纯表情包: 对不含任何实质文本、且无紧密上下文互动的纯**表情包**消息（如消息内容仅为“[表情包：xxxxx]”），应默认选择 `no_action`。
7. 处理失败消息: 绝不能回复任何指示媒体内容（图片、表情包等）处理失败的消息。如果消息中出现如“[表情包(描述生成失败)]”或“[图片(描述生成失败)]”等文字，必须将其视为系统错误提示，并立即选择`no_action`。
8. 正确决定回复时机: 在决定reply或respond前，务必评估当前对话氛围和上下文连贯性。避免在不合适的时机（如对方情绪低落、话题不相关等,对方并没有和你对话,贸然插入会很令人讨厌等）进行回复，以免打断对话流或引起误解。如判断当前不适合回复，请选择`no_action`。
9. 认清自己的身份和角色: 在规划回复时，务必确定对方是不是真的在叫自己。聊天时往往有数百甚至数千个用户，请务必认清自己的身份和角色，避免误以为对方在和自己对话而贸然插入回复，导致尴尬局面。
# 思绪流规范（thinking）
- 真实、自然、非结论化，像给自己看的随笔。
- 描述你看到/想到/感觉到的过程，不要出现"因此/我决定"等总结词。
- 直接使用对方昵称，而不是 <m1>/<m2> 这样的标签。
- **禁止出现"兴趣度、分数"等技术术语或内部实现细节**。兴趣度仅用于你内部的决策权重，不要在thinking中提及，而应该用自然语言描述你对消息的感受（如"这个话题挺有意思的"、"我对这个很感兴趣"等）。
- 禁止出现"兴趣度、分数"等技术术语或内部实现细节。兴趣度仅用于你内部的决策权重，不要在thinking中提及，而应该用自然语言描述你对消息的感受（如"这个话题挺有意思的"、"我对这个很感兴趣"等）。
## 可用动作列表
{action_options_text}
@@ -77,12 +78,10 @@ def init_prompts():
"thinking": "在这里写下你的思绪流...",
"actions": [
{{
"action_type": "reply",
"action_type": "respond",
"reasoning": "选择该动作的理由",
"action_data": {{
"target_message_id": "m123",
"content": "你的回复内容",
"should_quote_reply": false
}}
}}
]
@@ -116,21 +115,6 @@ def init_prompts():
}}
```
# 引用回复控制（should_quote_reply）
在群聊中回复消息时，你可以通过 `should_quote_reply` 参数控制是否引用原消息：
- **true**: 明确引用原消息（适用于需要明确指向特定消息时，如回答问题、回应多人之一、回复较早的消息）
- **false**: 不引用原消息（适用于自然对话流、接续最新话题、轻松闲聊等场景）
- **不填写**: 系统将自动决定（默认不引用，让对话更流畅）
**【重要】默认策略：大多数情况下应该使用 `false` 以保持对话自然流畅**
**使用建议**：
- 当对话自然流畅、你的回复是接续最新话题时，**建议明确设为 `false`** 以避免打断对话节奏
- 当需要明确回复某个特定用户或特定问题时，设为 `true` 以帮助定位
- 当群聊中多人同时发言，你要回复其中一个较早的消息（非最新消息）时，设为 `true`
- 当有人直接@你或明确向你提问时，可以考虑设为 `true` 表明你在回复他
- 私聊场景**必须**设为 `false` 或不填（因为只有两个人，引用是多余的）
# 强制规则
- 需要目标消息的动作（reply/poke_user/set_emoji_like 等），必须提供准确的 target_message_id（来自未读历史里的 <m...> 标签）。
- 当动作需要额外参数时，必须在 action_data 中补全。

14
src/plugins/built_in/core_actions/plugin.py
View File

@@ -16,6 +16,7 @@ from src.plugin_system.base.config_types import ConfigField
# 导入API模块 - 标准Python包方式
from src.plugins.built_in.core_actions.emoji import EmojiAction
from src.plugins.built_in.core_actions.reply import ReplyAction, RespondAction
logger = get_logger("core_actions")
@@ -52,7 +53,8 @@ class CoreActionsPlugin(BasePlugin):
"config_version": ConfigField(type=str, default="0.6.0", description="配置文件版本"),
},
"components": {
"enable_reply": ConfigField(type=bool, default=True, description="是否启用基本回复动作"),
"enable_reply": ConfigField(type=bool, default=True, description="是否启用 reply 动作（s4u模板）"),
"enable_respond": ConfigField(type=bool, default=True, description="是否启用 respond 动作（normal模板）"),
"enable_emoji": ConfigField(type=bool, default=True, description="是否启用发送表情/图片动作"),
},
}
@@ -62,6 +64,16 @@ class CoreActionsPlugin(BasePlugin):
# --- 根据配置注册组件 ---
components: ClassVar = []
# 注册 reply 动作
if self.get_config("components.enable_reply", True):
components.append((ReplyAction.get_action_info(), ReplyAction))
# 注册 respond 动作
if self.get_config("components.enable_respond", True):
components.append((RespondAction.get_action_info(), RespondAction))
# 注册 emoji 动作
if self.get_config("components.enable_emoji", True):
components.append((EmojiAction.get_action_info(), EmojiAction))

108
src/plugins/built_in/core_actions/reply.py Normal file
View File

@@ -0,0 +1,108 @@
"""
回复动作模块
定义了两种回复动作：
- reply: 针对单条消息的深度回复（使用 s4u 模板）
- respond: 对未读消息的统一回应（使用 normal 模板）
"""
from typing import ClassVar
from src.common.logger import get_logger
from src.plugin_system import ActionActivationType, BaseAction, ChatMode
logger = get_logger("reply_actions")
class ReplyAction(BaseAction):
"""Reply动作 - 针对单条消息的深度回复
特点：
- 使用 s4u (Speak for You) 模板
- 专注于理解和回应单条消息的具体内容
- 适合 Focus 模式下的精准回复
"""
# 动作基本信息
action_name = "reply"
action_description = "针对特定消息进行精准回复。深度理解并回应单条消息的具体内容。需要指定目标消息ID。"
# 激活设置
activation_type = ActionActivationType.ALWAYS # 回复动作总是可用
mode_enable = ChatMode.ALL # 在所有模式下都可用
parallel_action = False # 回复动作不能与其他动作并行
# 动作参数定义
action_parameters: ClassVar = {
"target_message_id": "要回复的目标消息ID（必需，来自未读消息的 <m...> 标签）",
"content": "回复的具体内容（可选，由LLM生成）",
"should_quote_reply": "是否引用原消息（可选，true/false，默认false。群聊中回复较早消息或需要明确指向时使用true）",
}
# 动作使用场景
action_require: ClassVar = [
"需要针对特定消息进行精准回复时使用",
"适合单条消息的深度理解和回应",
"必须提供准确的 target_message_id（来自未读历史的 <m...> 标签）",
"私聊场景必须使用此动作（不支持 respond）",
"群聊中需要明确回应某个特定用户或问题时使用",
"关注单条消息的具体内容和上下文细节",
]
# 关联类型
associated_types: ClassVar[list[str]] = ["text"]
async def execute(self) -> tuple[bool, str]:
"""执行reply动作
注意：实际的回复生成由 action_manager 统一处理
这里只是标记使用 reply 动作（s4u 模板）
"""
logger.info(f"{self.log_prefix} 使用 reply 动作（s4u 模板）")
return True, ""
class RespondAction(BaseAction):
"""Respond动作 - 对未读消息的统一回应
特点：
- 关注整体对话动态和未读消息的统一回应
- 适合对于群聊消息下的宏观回应
- 避免与单一用户深度对话而忽略其他用户的消息
"""
# 动作基本信息
action_name = "respond"
action_description = "统一回应所有未读消息。理解整体对话动态和话题走向，生成连贯的回复。无需指定目标消息。"
# 激活设置
activation_type = ActionActivationType.ALWAYS # 回应动作总是可用
mode_enable = ChatMode.ALL # 在所有模式下都可用
parallel_action = False # 回应动作不能与其他动作并行
# 动作参数定义
action_parameters: ClassVar = {
"content": "回复的具体内容（可选，由LLM生成）",
}
# 动作使用场景
action_require: ClassVar = [
"需要统一回应多条未读消息时使用（Normal 模式专用）",
"适合理解整体对话动态而非单条消息",
"不需要指定 target_message_id，会自动处理所有未读消息",
"关注对话流程、话题走向和整体氛围",
"适合群聊中的自然对话流，无需精确指向特定消息",
"可以同时回应多个话题或参与者",
]
# 关联类型
associated_types: ClassVar[list[str]] = ["text"]
async def execute(self) -> tuple[bool, str]:
"""执行respond动作
注意：实际的回复生成由 action_manager 统一处理
这里只是标记使用 respond 动作（normal 模板）
"""
logger.info(f"{self.log_prefix} 使用 respond 动作（normal 模板）")
return True, ""