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

remove：移除表达反思功能

Browse Source
This commit is contained in:
SengokuCola
2026-03-11 20:52:54 +08:00
parent 8b9cda4296
commit 8f13c4804b
10 changed files with 2 additions and 723 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
prompts/reflect_judge.prompt
View File

@@ -1,24 +0,0 @@
你是一个表达反思助手。Bot之前询问了表达方式是否合适。
你需要根据提供的上下文对话，判断是否对该表达方式做出了肯定或否定的评价。
**询问内容**
情景: {situation}
风格: {style}
**上下文对话**
{context_block}
**判断要求**
1. 判断对话中是否包含对上述询问的回答。
2. 如果是，判断是肯定（Approve）还是否定（Reject），或者是提供了修改意见。
3. 如果不是回答，或者是无关内容，请返回 "Ignore"。
4. 如果是否定并提供了修改意见，请提取修正后的情景和风格。
请输出JSON格式：
```json
{{
"judgment": "Approve" | "Reject" | "Ignore",
"corrected_situation": "...", // 如果有修改意见，提取修正后的情景，否则留空
"corrected_style": "..." // 如果有修改意见，提取修正后的风格，否则留空
}}
```

73
src/bw_learner/expression_reflect_tracker.py
View File

@@ -1,73 +0,0 @@
import json
import re
import time
from typing import TYPE_CHECKING, Any, Optional
from json_repair import repair_json
from src.chat.utils.chat_message_builder import (
build_readable_messages,
get_raw_msg_by_timestamp_with_chat,
)
from src.common.database.database import get_db_session
from src.common.logger import get_logger
from src.config.config import model_config
from src.llm_models.utils_model import LLMRequest
from src.prompt.prompt_manager import prompt_manager
if TYPE_CHECKING:
from src.common.data_models.expression_data_model import MaiExpression
judge_model = LLMRequest(model_set=model_config.model_task_config.tool_use, request_type="reflect.tracker")
logger = get_logger("reflect_tracker")
class ReflectTracker:
def __init__(self, session_id: str):
self.session_id = session_id
self.last_check_msg_count = 0
self.max_msg_count = 30
self.max_duration = 15 * 60 # 15 分钟
self.expression: Optional["MaiExpression"] = None # 当前正在追踪的表达，由外部设置
# 运行状态
self.tracking = False
self.tracking_start_time: float = 0.0
def register_expression_and_track(self, expression: "MaiExpression"):
"""注册需要追踪的表达"""
if self.tracking:
raise RuntimeError("ReflectTracker is already tracking an expression.")
self.expression = expression
self.tracking = True
self.tracking_start_time = time.time()
def reset_tracker(self):
"""重置追踪状态"""
self.expression = None
self.tracking = False
self.last_check_msg_count = 0
# TODO test it
async def trigger_tracker(self) -> bool:
"""
触发追踪检查
Returns:
return (bool): 如果返回True，表示追踪完成，Tracker运行结束（运行状态置为`False`）；如果返回False，表示继续追踪
"""
# 对于没有正在追踪的表达，直接返回False
if not self.tracking or not self.expression:
return False
# Type narrowing: expression is guaranteed non-None when tracking
assert self.expression is not None
expr = self.expression
# 检查是否超时（无论是消息数量还是时间）
if time.time() - self.tracking_start_time > self.max_duration:
self.reset_tracker()
return True
# TODO: 完成追踪检查逻辑

137
src/bw_learner/expression_reflector.py
View File

@@ -1,137 +0,0 @@
from rich.traceback import install
from sqlmodel import select
from typing import TYPE_CHECKING
import random
import time
from src.common.logger import get_logger
from src.config.config import global_config
from src.common.database.database_model import Expression
from src.common.database.database import get_db_session
from src.common.data_models.expression_data_model import MaiExpression
from src.common.utils.utils_session import SessionUtils
from .expression_reflect_tracker import ReflectTracker
if TYPE_CHECKING:
from src.config.official_configs import TargetItem
logger = get_logger("expression_reflector")
install(extra_lines=3)
LOG_PREFIX = "[Expression Reflector]"
class ExpressionReflector:
"""表达反思器，管理单个聊天流的表达反思提问，使用每个session_id独立的实例"""
def __init__(self, session_id: str):
self.session_id = session_id
self.last_ask_time: float = time.time()
self.reflect_tracker: ReflectTracker = ReflectTracker(session_id)
async def check_and_ask(self) -> bool:
"""
检查是否需要提问表达反思，如果需要则提问
Returns:
bool: 是否执行了提问
"""
if not await self.check_need_ask():
return False
operator_config = global_config.expression.manual_reflect_operator_id
if not operator_config:
logger.debug(f"{LOG_PREFIX} Operator ID 未配置，跳过")
return False
if await self.ask_reflection(operator_config):
self.last_ask_time = time.time()
return True
return False
async def check_need_ask(self) -> bool:
"""
检查是否需要提问表达反思
Returns:
bool: 是否执行了提问
"""
if not global_config.expression.expression_manual_reflect:
logger.debug(f"{LOG_PREFIX} 表达反思功能未启用，跳过")
return False
logger.debug(f"{LOG_PREFIX} 开始检查是否需要提问 (session_id: {self.session_id})")
operator_config = global_config.expression.manual_reflect_operator_id
if not operator_config:
logger.debug(f"{LOG_PREFIX} Operator ID 未配置，跳过")
return False
if self.reflect_tracker.tracking:
logger.info(f"{LOG_PREFIX} Operator {operator_config} 已有活跃的 Tracker，跳过本次提问")
return False
if allow_reflect_list := global_config.expression.allow_reflect:
# 转换配置项为session_id列表
allow_reflect_session_ids = [
self._parse_config_item_2_session_id(stream_config) for stream_config in allow_reflect_list
]
if self.session_id not in allow_reflect_session_ids:
logger.info(f"{LOG_PREFIX} 当前聊天流 {self.session_id} 不在允许列表中，跳过")
return False
# 检查上一次提问时间
current_time = time.time()
time_since_last_ask = current_time - self.last_ask_time
# 随机选择10-15分钟间隔
ask_interval = random.uniform(10 * 60, 15 * 60)
if time_since_last_ask < ask_interval:
logger.info(
f"{LOG_PREFIX} 距离上次提问时间 {time_since_last_ask:.2f} 秒，未达到随机间隔 {ask_interval:.2f} 秒，跳过"
)
return False
return True
async def ask_reflection(self, operator_config: "TargetItem") -> bool:
"""执行提问表达反思的操作"""
# 选取未检查过的表达
logger.info(f"{LOG_PREFIX} 查询未检查且未拒绝的表达")
try:
with get_db_session() as session:
statement = select(Expression).filter_by(checked=False, rejected=False).limit(50)
results = session.exec(statement).all()
if not results:
logger.info(f"{LOG_PREFIX} 未找到未检查且未拒绝的表达")
return False
logger.info(f"{LOG_PREFIX} 找到 {len(results)} 个未检查且未拒绝的表达")
except Exception as selected_expression:
logger.error(f"{LOG_PREFIX} 查询表达时发生错误: {selected_expression}")
return False
# 随机选取一个表达进行提问
selected_expression = MaiExpression.from_db_instance(random.choice(results))
item_id = selected_expression.item_id
situation = selected_expression.situation
style = selected_expression.style
logger.info(f"{LOG_PREFIX} 随机选择了表达 ID: {item_id}, Situation: {situation}, Style: {style}")
ask_text = (
f"我正在学习新的表达方式，请帮我看看这个是否合适？\n\n"
f"**学习到的表达信息**\n"
f"- 情景 (Situation): {situation}\n"
f"- 风格 (Style): {style}\n"
)
# TODO: 在发送相关API重构完成后完成发送给operator的逻辑
self.reflect_tracker.register_expression_and_track(selected_expression)
return True
def _parse_config_item_2_session_id(self, config_item: "TargetItem") -> str:
if config_item.rule_type == "group":
return SessionUtils.calculate_session_id(config_item.platform, group_id=str(config_item.item_id))
else:
return SessionUtils.calculate_session_id(config_item.platform, user_id=str(config_item.item_id))

250
src/bw_learner/expression_reflector_old.py
View File

@@ -1,250 +0,0 @@
import random
import time
from typing import Optional, Dict
from src.common.logger import get_logger
from src.common.database.database_model import Expression
from src.config.config import global_config
from src.chat.message_receive.chat_stream import get_chat_manager
from src.plugin_system.apis import send_api
logger = get_logger("expression_reflector")
class ExpressionReflector:
"""表达反思器，管理单个聊天流的表达反思提问"""
def __init__(self, chat_id: str):
self.chat_id = chat_id
self.last_ask_time: float = 0.0
async def check_and_ask(self) -> bool:
"""
检查是否需要提问表达反思，如果需要则提问
Returns:
bool: 是否执行了提问
"""
try:
logger.debug(f"[Expression Reflection] 开始检查是否需要提问 (stream_id: {self.chat_id})")
if not global_config.expression.expression_manual_reflect:
logger.debug("[Expression Reflection] 表达反思功能未启用，跳过")
return False
operator_config = global_config.expression.manual_reflect_operator_id
if not operator_config:
logger.debug("[Expression Reflection] Operator ID 未配置，跳过")
return False
# 检查是否在允许列表中
allow_reflect = global_config.expression.allow_reflect
if allow_reflect:
# 将 allow_reflect 中的 platform:id:type 格式转换为 chat_id 列表
allow_reflect_chat_ids = []
for stream_config in allow_reflect:
parsed_chat_id = global_config.expression._parse_stream_config_to_chat_id(stream_config)
if parsed_chat_id:
allow_reflect_chat_ids.append(parsed_chat_id)
else:
logger.warning(f"[Expression Reflection] 无法解析 allow_reflect 配置项: {stream_config}")
if self.chat_id not in allow_reflect_chat_ids:
logger.info(f"[Expression Reflection] 当前聊天流 {self.chat_id} 不在允许列表中，跳过")
return False
# 检查上一次提问时间
current_time = time.time()
time_since_last_ask = current_time - self.last_ask_time
# 5-10分钟间隔，随机选择
min_interval = 10 * 60 # 5分钟
max_interval = 15 * 60 # 10分钟
interval = random.uniform(min_interval, max_interval)
logger.info(
f"[Expression Reflection] 上次提问时间: {self.last_ask_time:.2f}, 当前时间: {current_time:.2f}, 已过时间: {time_since_last_ask:.2f}秒 ({time_since_last_ask / 60:.2f}分钟), 需要间隔: {interval:.2f}秒 ({interval / 60:.2f}分钟)"
)
if time_since_last_ask < interval:
remaining_time = interval - time_since_last_ask
logger.info(
f"[Expression Reflection] 距离上次提问时间不足，还需等待 {remaining_time:.2f}秒 ({remaining_time / 60:.2f}分钟)，跳过"
)
return False
# 检查是否已经有针对该 Operator 的 Tracker 在运行
logger.info(f"[Expression Reflection] 检查 Operator {operator_config} 是否已有活跃的 Tracker")
if await _check_tracker_exists(operator_config):
logger.info(f"[Expression Reflection] Operator {operator_config} 已有活跃的 Tracker，跳过本次提问")
return False
# 获取未检查的表达
try:
logger.info("[Expression Reflection] 查询未检查且未拒绝的表达")
expressions = Expression.select().where((~Expression.checked) & (~Expression.rejected)).limit(50)
expr_list = list(expressions)
logger.info(f"[Expression Reflection] 找到 {len(expr_list)} 个候选表达")
if not expr_list:
logger.info("[Expression Reflection] 没有可用的表达，跳过")
return False
target_expr: Expression = random.choice(expr_list)
logger.info(
f"[Expression Reflection] 随机选择了表达 ID: {target_expr.id}, Situation: {target_expr.situation}, Style: {target_expr.style}"
)
# 生成询问文本
ask_text = _generate_ask_text(target_expr)
if not ask_text:
logger.warning("[Expression Reflection] 生成询问文本失败，跳过")
return False
logger.info(f"[Expression Reflection] 准备向 Operator {operator_config} 发送提问")
# 发送给 Operator
await _send_to_operator(operator_config, ask_text, target_expr)
# 更新上一次提问时间
self.last_ask_time = current_time
logger.info(f"[Expression Reflection] 提问成功，已更新上次提问时间为 {current_time:.2f}")
return True
except Exception as e:
logger.error(f"[Expression Reflection] 检查或提问过程中出错: {e}")
import traceback
logger.error(traceback.format_exc())
return False
except Exception as e:
logger.error(f"[Expression Reflection] 检查或提问过程中出错: {e}")
import traceback
logger.error(traceback.format_exc())
return False
class ExpressionReflectorManager:
"""表达反思管理器，管理多个聊天流的表达反思实例"""
def __init__(self):
self.reflectors: Dict[str, ExpressionReflector] = {}
def get_or_create_reflector(self, chat_id: str) -> ExpressionReflector:
"""获取或创建指定聊天流的表达反思实例"""
if chat_id not in self.reflectors:
self.reflectors[chat_id] = ExpressionReflector(chat_id)
return self.reflectors[chat_id]
# 创建全局实例
expression_reflector_manager = ExpressionReflectorManager()
async def _check_tracker_exists(operator_config: str) -> bool:
"""检查指定 Operator 是否已有活跃的 Tracker"""
from src.bw_learner.reflect_tracker import reflect_tracker_manager
chat_manager = get_chat_manager()
chat_stream = None
# 尝试解析配置字符串 "platform:id:type"
parts = operator_config.split(":")
if len(parts) == 3:
platform = parts[0]
id_str = parts[1]
stream_type = parts[2]
user_info = None
group_info = None
from maim_message import UserInfo, GroupInfo
if stream_type == "group":
group_info = GroupInfo(group_id=id_str, platform=platform)
user_info = UserInfo(user_id="system", user_nickname="System", platform=platform)
elif stream_type == "private":
user_info = UserInfo(user_id=id_str, platform=platform, user_nickname="Operator")
else:
return False
if user_info:
try:
chat_stream = await chat_manager.get_or_create_stream(platform, user_info, group_info)
except Exception as e:
logger.error(f"Failed to get or create chat stream for checking tracker: {e}")
return False
else:
chat_stream = chat_manager.get_stream(operator_config)
if not chat_stream:
return False
return reflect_tracker_manager.get_tracker(chat_stream.stream_id) is not None
def _generate_ask_text(expr: Expression) -> Optional[str]:
try:
ask_text = (
f"我正在学习新的表达方式，请帮我看看这个是否合适？\n\n"
f"**学习到的表达信息**\n"
f"- 情景 (Situation): {expr.situation}\n"
f"- 风格 (Style): {expr.style}\n"
)
return ask_text
except Exception as e:
logger.error(f"Failed to generate ask text: {e}")
return None
async def _send_to_operator(operator_config: str, text: str, expr: Expression):
chat_manager = get_chat_manager()
chat_stream = None
# 尝试解析配置字符串 "platform:id:type"
parts = operator_config.split(":")
if len(parts) == 3:
platform = parts[0]
id_str = parts[1]
stream_type = parts[2]
user_info = None
group_info = None
from maim_message import UserInfo, GroupInfo
if stream_type == "group":
group_info = GroupInfo(group_id=id_str, platform=platform)
user_info = UserInfo(user_id="system", user_nickname="System", platform=platform)
elif stream_type == "private":
user_info = UserInfo(user_id=id_str, platform=platform, user_nickname="Operator")
else:
logger.warning(f"Unknown stream type in operator config: {stream_type}")
return
if user_info:
try:
chat_stream = await chat_manager.get_or_create_stream(platform, user_info, group_info)
except Exception as e:
logger.error(f"Failed to get or create chat stream for operator {operator_config}: {e}")
return
else:
chat_stream = chat_manager.get_stream(operator_config)
if not chat_stream:
logger.warning(f"Could not find or create chat stream for operator: {operator_config}")
return
stream_id = chat_stream.stream_id
# 注册 Tracker
from src.bw_learner.reflect_tracker import ReflectTracker, reflect_tracker_manager
tracker = ReflectTracker(chat_stream=chat_stream, expression=expr, created_time=time.time())
reflect_tracker_manager.add_tracker(stream_id, tracker)
# 发送消息
await send_api.text_to_stream(text=text, stream_id=stream_id, typing=True)
logger.info(f"Sent expression reflect query to operator {operator_config} for expr {expr.id}")

162
src/bw_learner/reflect_tracker.py
View File

@@ -1,162 +0,0 @@
import time
from typing import Optional, Dict, TYPE_CHECKING
from src.common.logger import get_logger
from src.common.database.database_model import Expression
from src.llm_models.utils_model import LLMRequest
from src.prompt.prompt_manager import prompt_manager
from src.config.config import model_config
from src.chat.message_receive.chat_manager import BotChatSession
from src.chat.utils.chat_message_builder import (
get_raw_msg_by_timestamp_with_chat,
build_readable_messages,
)
logger = get_logger("reflect_tracker")
class ReflectTracker:
def __init__(self, chat_stream: BotChatSession, expression: Expression, created_time: float):
self.chat_stream = chat_stream
self.expression = expression
self.created_time = created_time
# self.message_count = 0 # Replaced by checking message list length
self.last_check_msg_count = 0
self.max_message_count = 30
self.max_duration = 15 * 60 # 15 minutes
# LLM for judging response
self.judge_model = LLMRequest(model_set=model_config.model_task_config.tool_use, request_type="reflect.tracker")
async def trigger_tracker(self) -> bool:
"""
触发追踪检查
Returns: True if resolved (should destroy tracker), False otherwise
"""
# Check timeout
if time.time() - self.created_time > self.max_duration:
logger.info(f"ReflectTracker for expr {self.expression.id} timed out (duration).")
return True
# Fetch messages since creation
msg_list = get_raw_msg_by_timestamp_with_chat(
chat_id=self.chat_stream.session_id,
timestamp_start=self.created_time,
timestamp_end=time.time(),
)
current_msg_count = len(msg_list)
# Check message limit
if current_msg_count > self.max_message_count:
logger.info(f"ReflectTracker for expr {self.expression.id} timed out (message count).")
return True
# If no new messages since last check, skip
if current_msg_count <= self.last_check_msg_count:
return False
self.last_check_msg_count = current_msg_count
# Build context block
# Use simple readable format
context_block = build_readable_messages(
msg_list,
replace_bot_name=True,
timestamp_mode="relative",
read_mark=0.0,
show_actions=False,
)
# LLM Judge
try:
prompt_template = prompt_manager.get_prompt("reflect_judge")
prompt_template.add_context("situation", str(self.expression.situation))
prompt_template.add_context("style", str(self.expression.style))
prompt_template.add_context("context_block", context_block)
prompt = await prompt_manager.render_prompt(prompt_template)
logger.info(f"ReflectTracker LLM Prompt: {prompt}")
response, _ = await self.judge_model.generate_response_async(prompt, temperature=0.1)
logger.info(f"ReflectTracker LLM Response: {response}")
# Parse JSON
import json
import re
from json_repair import repair_json
json_pattern = r"```json\s*(.*?)\s*```"
matches = re.findall(json_pattern, response, re.DOTALL) or [response]
json_obj = json.loads(repair_json(matches[0]))
judgment = json_obj.get("judgment")
if judgment == "Approve":
self.expression.checked = True
self.expression.rejected = False
self.expression.modified_by = "ai" # 通过LLM判断也标记为ai
self.expression.save()
logger.info(f"Expression {self.expression.id} approved by operator.")
return True
elif judgment == "Reject":
self.expression.checked = True
self.expression.modified_by = "ai" # 通过LLM判断也标记为ai
corrected_situation = json_obj.get("corrected_situation")
corrected_style = json_obj.get("corrected_style")
# 检查是否有更新
has_update = bool(corrected_situation or corrected_style)
if corrected_situation:
self.expression.situation = corrected_situation
if corrected_style:
self.expression.style = corrected_style
# 如果拒绝但未更新，标记为 rejected=1
self.expression.rejected = not has_update
self.expression.save()
if has_update:
logger.info(
f"Expression {self.expression.id} rejected and updated by operator. New situation: {corrected_situation}, New style: {corrected_style}"
)
else:
logger.info(
f"Expression {self.expression.id} rejected but no correction provided, marked as rejected=1."
)
return True
elif judgment == "Ignore":
logger.info(f"ReflectTracker for expr {self.expression.id} judged as Ignore.")
return False
except Exception as e:
logger.error(f"Error in ReflectTracker check: {e}")
return False
return False
# Global manager for trackers
class ReflectTrackerManager:
def __init__(self):
self.trackers: Dict[str, ReflectTracker] = {} # chat_id -> tracker
def add_tracker(self, chat_id: str, tracker: ReflectTracker):
self.trackers[chat_id] = tracker
def get_tracker(self, chat_id: str) -> Optional[ReflectTracker]:
return self.trackers.get(chat_id)
def remove_tracker(self, chat_id: str):
if chat_id in self.trackers:
del self.trackers[chat_id]
reflect_tracker_manager = ReflectTrackerManager()

22
src/chat/brain_chat/brain_chat.py
View File

@@ -252,28 +252,6 @@ class BrainChatting:
recent_messages_list = []
_reply_text = "" # 初始化reply_text变量，避免UnboundLocalError
# -------------------------------------------------------------------------
# ReflectTracker Check
# 在每次回复前检查一次上下文，看是否有反思问题得到了解答
# -------------------------------------------------------------------------
from src.bw_learner.reflect_tracker import reflect_tracker_manager
tracker = reflect_tracker_manager.get_tracker(self.stream_id)
if tracker:
resolved = await tracker.trigger_tracker()
if resolved:
reflect_tracker_manager.remove_tracker(self.stream_id)
logger.info(f"{self.log_prefix} ReflectTracker resolved and removed.")
# -------------------------------------------------------------------------
# Expression Reflection Check
# 检查是否需要提问表达反思
# -------------------------------------------------------------------------
from src.bw_learner.expression_reflector_old import expression_reflector_manager
reflector = expression_reflector_manager.get_or_create_reflector(self.stream_id)
asyncio.create_task(reflector.check_and_ask())
async with global_prompt_manager.async_message_scope(self.chat_stream.context.get_template_name()):
# 通过 MessageRecorder 统一提取消息并分发给 expression_learner 和 jargon_miner
# 在 replyer 执行时触发，统一管理时间窗口，避免重复获取消息

12
src/chat/heart_flow/heartFC_chat.py
View File

@@ -11,7 +11,6 @@ from src.common.utils.utils_config import ExpressionConfigUtils, ChatConfigUtils
from src.config.config import global_config
from src.config.file_watcher import FileChange
from src.chat.message_receive.chat_manager import chat_manager
from src.bw_learner.expression_reflector import ExpressionReflector
from src.bw_learner.expression_learner import ExpressionLearner
from src.bw_learner.jargon_miner import JargonMiner
@@ -67,8 +66,6 @@ class HeartFChatting:
self._enable_expression_use = expr_use # 允许使用表达方式，但不一定启用学习
self._enable_expression_learning = expr_learn # 允许学习表达方式
self._enable_jargon_learning = jargon_learn # 允许学习黑话
# 反思器
self._reflector: ExpressionReflector = ExpressionReflector(session_id)
# 表达学习器
self._expression_learner: ExpressionLearner = ExpressionLearner(session_id)
# 黑话挖掘器
@@ -199,7 +196,6 @@ class HeartFChatting:
async def _judge_and_response(self, mentioned_message: Optional["SessionMessage"] = None):
"""判定和生成回复"""
await self._trigger_reflector()
asyncio.create_task(self._trigger_expression_learning(self.message_cache))
# TODO: 完成反思器之后的逻辑
start_time = time.time()
@@ -228,13 +224,7 @@ class HeartFChatting:
except asyncio.CancelledError:
logger.info(f"{self.log_prefix} HeartFChatting: 结束了聊天")
# ====== 反思器和学习器触发逻辑 ======
async def _trigger_reflector(self):
await self._reflector.check_and_ask()
if self._reflector.reflect_tracker.tracking and await self._reflector.reflect_tracker.trigger_tracker():
logger.info(f"{self.log_prefix} 追踪检查已解决，结束追踪器")
self._reflector.reflect_tracker.reset_tracker() # 结束当前追踪器
# ====== 学习器触发逻辑 ======
async def _trigger_expression_learning(self, messages: List["SessionMessage"]):
self._expression_learner.add_messages(messages)
if time.time() - self._last_extraction_time < self._min_extraction_interval:

16
src/chat/heart_flow/heartFC_chat_old.py
View File

@@ -18,8 +18,6 @@ from src.chat.planner_actions.action_manager import ActionManager
from src.chat.heart_flow.hfc_utils_old import CycleDetail
from src.bw_learner.expression_learner_old import expression_learner_manager
from src.chat.heart_flow.frequency_control import frequency_control_manager
from src.bw_learner.reflect_tracker import reflect_tracker_manager
from src.bw_learner.expression_reflector_old import expression_reflector_manager
from src.bw_learner.message_recorder_old import extract_and_distribute_messages
from src.person_info.person_info import Person
from src.plugin_system.base.component_types import EventType, ActionInfo
@@ -298,20 +296,6 @@ class HeartFChatting:
recent_messages_list = []
_reply_text = "" # 初始化reply_text变量，避免UnboundLocalError
# -------------------------------------------------------------------------
# ReflectTracker Check
# 在每次回复前检查一次上下文，看是否有反思问题得到了解答
# -------------------------------------------------------------------------
reflector = expression_reflector_manager.get_or_create_reflector(self.session_id)
await reflector.check_and_ask()
tracker = reflect_tracker_manager.get_tracker(self.session_id)
if tracker:
resolved = await tracker.trigger_tracker()
if resolved:
reflect_tracker_manager.remove_tracker(self.session_id)
logger.info(f"{self.log_prefix} ReflectTracker resolved and removed.")
start_time = time.time()
async with global_prompt_manager.async_message_scope(self.chat_stream.context.get_template_name()):
# 通过 MessageRecorder 统一提取消息并分发给 expression_learner 和 jargon_miner

2
src/config/legacy_migration.py
View File

@@ -184,7 +184,7 @@ def _migrate_expression_groups(expr: dict[str, Any]) -> bool:
def _migrate_target_item_list(parent: dict[str, Any], key: str) -> bool:
"""
将 list[str] 的 "platform:id:type" 迁移为 list[{platform,item_id,rule_type}]
用于：memory.global_memory_blacklist / expression.allow_reflect 等。
用于：memory.global_memory_blacklist 等。
"""
raw = _as_list(parent.get(key))
if raw is None:

27
src/config/official_configs.py
View File

@@ -641,33 +641,6 @@ class ExpressionConfig(ConfigBase):
)
"""表达方式自动检查的额外自定义评估标准"""
expression_manual_reflect: bool = Field(
default=False,
json_schema_extra={
"x-widget": "switch",
"x-icon": "hand",
},
)
"""是否启用手动表达优化"""
manual_reflect_operator_id: Optional[TargetItem] = Field(
default=None,
json_schema_extra={
"x-widget": "custom",
"x-icon": "user-cog",
},
)
"""手动表达优化操作员ID"""
allow_reflect: list[TargetItem] = Field(
default_factory=list,
json_schema_extra={
"x-widget": "custom",
"x-icon": "shield",
},
)
"""允许进行表达反思的聊天流ID列表，只有在此列表中的聊天流才会提出问题并跟踪。如果列表为空，则所有聊天流都可以进行表达反思（前提是reflect为true）"""
all_global_jargon: bool = Field(
default=True,
json_schema_extra={