feat: complete M6.1.3-R2 through M6.1.7 bot personal archive contract
M6.1.3-R2 非五类兼容:值级隐私加固(base64/data URI/中缀路径/私钥),
真实陪伴 DTO 形状回归;信封字段剥离补全并统一先解包再剥离,
避免双插件分别部署时新旧载荷形状指纹不一致进死信。
M6.1.4 创作/媒体/主观分域:新增 idx_memories_domain_type_time;
路径中缀边界类扩为 ^|[\s=:;,]。
M6.1.5 Bot 专用检索 Profiles:新增 core/bot_profiles.py 定义五个 Profile,
固定域/类型/时间窗/条数/排序/注入字段/权限;新增 list_bot_profile_memories
把时间窗过滤下推到 SQL,避免近期记录过多时历史 Profile 静默返回空。
M6.1.6 分层只读 API:/bot-archive/{profiles,query,locked-frame},GET only。
M6.1.7 隐私权限收口:通用 memory_update/delete/lifecycle 拒绝 Bot 域写入
(此前可绕过受控归档路径,并使 payload_fingerprint 变陈导致后续归档进死信);
导出补 memory_domain 与域普查,修复 export→import 把 bot_self_schedule
降级成 bot_self_legacy 的问题。
测试:319 项通过(不含 test_security_cache,缺可选检索依赖)。
联合 E2E 135 项全部通过。
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
这个提交存在于:
父节点
bbd94d35a9
当前提交
e3f9e0b212
共有 19 个文件被更改,包括 3083 次插入 和 204 次删除
|
|
@ -1,13 +1,28 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
from datetime import date as date_type
|
||||
from datetime import datetime
|
||||
from typing import Any
|
||||
|
||||
from .models import clean_text, json_dumps
|
||||
from .models import clean_text, stable_fingerprint
|
||||
|
||||
BOT_PERSONAL_MEMORY_DOMAIN = "bot_self_schedule"
|
||||
BOT_PERSONAL_SESSION_ID = "bot_personal"
|
||||
BOT_PERSONAL_SCOPE = "private"
|
||||
BOT_PERSONAL_VISIBILITY = "bot_self"
|
||||
BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION = "1.0"
|
||||
BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION = "1.0"
|
||||
BOT_PERSONAL_MAX_PAYLOAD_BYTES = 16 * 1024
|
||||
BOT_PERSONAL_WINDOWS = frozenset({"late_night", "morning", "afternoon", "evening"})
|
||||
# 信封字段:这些键只走 kwarg,留在 body 里会进指纹。created_at/updated_at 尤其危险——
|
||||
# 它们随墙钟漂移,会让同一条记录重投时变成 version_conflict。
|
||||
BOT_PERSONAL_ENVELOPE_KEYS = frozenset({
|
||||
"record_id", "memory_domain", "memory_type", "subject", "date", "window", "occurred_at",
|
||||
"created_at", "updated_at", "source_kind", "source_refs", "certainty", "evidence_level",
|
||||
"status", "version", "idempotency_key", "payload_schema_version",
|
||||
})
|
||||
|
||||
BOT_PERSONAL_MEMORY_TYPES = {
|
||||
"bot_schedule_plan",
|
||||
|
|
@ -24,24 +39,198 @@ BOT_PERSONAL_MEMORY_TYPES = {
|
|||
"bot_proactive_message",
|
||||
}
|
||||
|
||||
BOT_PERSONAL_TYPE_CONTRACTS = {
|
||||
"bot_schedule_plan": {"source_kind": "planned", "evidence_level": "L0", "reality_level": "planned", "lifecycle": "planned_projection"},
|
||||
"bot_observed_activity": {"source_kind": "observed", "evidence_level": "caller", "reality_level": "observed_activity", "lifecycle": "stable_memory"},
|
||||
"bot_schedule_reconciliation": {"source_kind": "reconciled", "evidence_level": "caller", "reality_level": "reconciled", "lifecycle": "stable_memory"},
|
||||
"bot_window_snapshot": {"source_kind": "projection", "evidence_level": "caller", "reality_level": "window_projection", "lifecycle": "stable_memory"},
|
||||
"bot_daily_diary": {"source_kind": "subjective", "evidence_level": "caller", "reality_level": "subjective", "lifecycle": "stable_memory"},
|
||||
"bot_creative_work": {"source_kind": "creative", "evidence_level": "caller", "reality_level": "creative_work", "lifecycle": "stable_memory"},
|
||||
"bot_media_memory": {"source_kind": "media", "evidence_level": "caller", "reality_level": "media_index", "lifecycle": "stable_memory"},
|
||||
"bot_subjective_memory": {"source_kind": "subjective", "evidence_level": "caller", "reality_level": "subjective", "lifecycle": "stable_memory"},
|
||||
"bot_shared_activity": {"source_kind": "shared", "evidence_level": "caller", "reality_level": "shared_activity", "lifecycle": "stable_memory"},
|
||||
"bot_detail_fragment": {"source_kind": "detail", "evidence_level": "caller", "reality_level": "detail_fragment", "lifecycle": "stable_memory"},
|
||||
"bot_calendar_event": {"source_kind": "calendar", "evidence_level": "caller", "reality_level": "calendar_history", "lifecycle": "stable_memory"},
|
||||
"bot_proactive_message": {"source_kind": "proactive", "evidence_level": "caller", "reality_level": "proactive_action", "lifecycle": "stable_memory"},
|
||||
}
|
||||
|
||||
_FORBIDDEN_KEY_PARTS = (
|
||||
"prompt", "chat", "conversation", "message_history", "raw_message", "cookie", "token",
|
||||
"secret", "credential", "password", "authorization", "bearer", "base64", "binary",
|
||||
"media_bytes", "image_bytes", "audio_bytes", "video_bytes", "file_path", "filepath",
|
||||
"absolute_path", "local_path", "raw_payload", "transcript",
|
||||
)
|
||||
_FORBIDDEN_VALUE_PATTERNS = (
|
||||
re.compile(r"(?i)^bearer\s+\S+"),
|
||||
re.compile(r"(?i)^(?:sk|ghp|xox[baprs])-[-_A-Za-z0-9]{12,}"),
|
||||
re.compile(r"(?i)(?:password|passwd|secret|token|api[_-]?key)\s*[=:]\s*\S+"),
|
||||
# 本机路径:前缀式(保留 R1 行为,比陪伴侧更严,任意 / 开头都拒)
|
||||
re.compile(r"^(?:[A-Za-z]:[\\/]|/|\\\\)"),
|
||||
# 本机路径:中缀式。R1 只锚定行首,"照片保存在 C:\\private\\a.png" 可绕过;
|
||||
# 与陪伴侧 bot_personal_dto._looks_sensitive_value 对齐。clean_text 已把空白折叠成单空格,
|
||||
# 因此 (?:^|[\s=]) 足以覆盖,不存在换行绕过。
|
||||
# 边界类含 : ; , 是因为路径常跟在分隔符后面(`photo:D:\...`、`标题:C:/x`),只有 ^|\s|= 会漏检。
|
||||
# `https://` 不受影响:`s:/` 前面是 `p`,不在边界类里。与陪伴侧 _looks_sensitive_value 保持一致。
|
||||
re.compile(r"(?i)(?:^|[\s=:;,])(?:[A-Za-z]:[\\/]|\\\\|/home/|/root/|/tmp/|/var/|/volume\d+/)"),
|
||||
# 合同明确禁止 Base64 与媒体二进制
|
||||
re.compile(r"(?i)base64,"),
|
||||
re.compile(r"(?i)^data:[a-z0-9.+-]*/?[a-z0-9.+-]*[;,]"),
|
||||
# 私钥与证书材料
|
||||
re.compile(r"(?i)-----begin "),
|
||||
)
|
||||
|
||||
|
||||
class BotPersonalValidationError(ValueError):
|
||||
def __init__(self, error_code: str, field: str = "", message: str = ""):
|
||||
self.error_code = clean_text(error_code, 80) or "invalid_payload"
|
||||
self.field = clean_text(field, 160)
|
||||
self.message = clean_text(message, 300) or self.error_code
|
||||
super().__init__(self.message)
|
||||
|
||||
|
||||
def _field_name(value: Any) -> str:
|
||||
return clean_text(value, 80).strip().lower().replace("-", "_")
|
||||
|
||||
|
||||
def _sanitize_value(value: Any, *, path: str = "payload", depth: int = 0) -> Any:
|
||||
if depth > 8:
|
||||
raise BotPersonalValidationError("privacy_rejected", path, "payload nesting too deep")
|
||||
if isinstance(value, dict):
|
||||
if len(value) > 64:
|
||||
raise BotPersonalValidationError("payload_too_large", path, "too many payload fields")
|
||||
result: dict[str, Any] = {}
|
||||
for raw_key, raw_value in value.items():
|
||||
key = clean_text(raw_key, 80)
|
||||
normalized_key = _field_name(key)
|
||||
if not key:
|
||||
raise BotPersonalValidationError("invalid_field", path, "empty payload key")
|
||||
if any(part in normalized_key for part in _FORBIDDEN_KEY_PARTS):
|
||||
raise BotPersonalValidationError("privacy_rejected", f"{path}.{key}", "sensitive or raw field is not accepted")
|
||||
result[key] = _sanitize_value(raw_value, path=f"{path}.{key}", depth=depth + 1)
|
||||
return result
|
||||
if isinstance(value, (list, tuple)):
|
||||
if len(value) > 64:
|
||||
raise BotPersonalValidationError("payload_too_large", path, "too many list items")
|
||||
return [_sanitize_value(item, path=f"{path}[{index}]", depth=depth + 1) for index, item in enumerate(value)]
|
||||
if isinstance(value, str):
|
||||
text = clean_text(value, BOT_PERSONAL_MAX_PAYLOAD_BYTES)
|
||||
if any(pattern.search(text) for pattern in _FORBIDDEN_VALUE_PATTERNS):
|
||||
raise BotPersonalValidationError("privacy_rejected", path, "credential, base64 or local path is not accepted")
|
||||
return text
|
||||
if value is None or isinstance(value, (bool, int, float)):
|
||||
return value
|
||||
raise BotPersonalValidationError("invalid_field", path, "unsupported payload value")
|
||||
|
||||
|
||||
def _raw_payload_size(value: Any) -> int:
|
||||
try:
|
||||
return len(json.dumps(value, ensure_ascii=False, separators=(",", ":")).encode("utf-8"))
|
||||
except (TypeError, ValueError, OverflowError) as exc:
|
||||
raise BotPersonalValidationError("invalid_payload", "payload", f"payload is not JSON serializable: {exc}")
|
||||
|
||||
|
||||
def normalize_bot_personal_payload(value: Any, limit: int = 1200) -> dict[str, Any]:
|
||||
if not isinstance(value, dict):
|
||||
return {}
|
||||
result: dict[str, Any] = {}
|
||||
for key, item in list(value.items())[:32]:
|
||||
name = clean_text(key, 80)
|
||||
if not name or name in {"user", "group", "event", "raw_message", "prompt"}:
|
||||
continue
|
||||
if isinstance(item, (str, int, float, bool)) or item is None:
|
||||
result[name] = clean_text(item, limit) if isinstance(item, str) else item
|
||||
elif isinstance(item, dict):
|
||||
result[name] = normalize_bot_personal_payload(item, 320)
|
||||
elif isinstance(item, (list, tuple)):
|
||||
result[name] = [clean_text(entry, 240) if isinstance(entry, str) else entry for entry in list(item)[:24]]
|
||||
return result
|
||||
raise BotPersonalValidationError("invalid_payload", "payload", "payload must be an object")
|
||||
if _raw_payload_size(value) > BOT_PERSONAL_MAX_PAYLOAD_BYTES:
|
||||
raise BotPersonalValidationError("payload_too_large", "payload", "raw payload exceeds maximum size")
|
||||
sanitized = _sanitize_value(value, path="payload")
|
||||
if len(json.dumps(sanitized, ensure_ascii=False, separators=(",", ":")).encode("utf-8")) > BOT_PERSONAL_MAX_PAYLOAD_BYTES:
|
||||
raise BotPersonalValidationError("payload_too_large", "payload", "payload exceeds maximum size")
|
||||
return sanitized
|
||||
|
||||
|
||||
def validate_bot_personal_envelope(*, memory_type: str, payload: dict[str, Any], date: str, occurred_at: str, source_refs: Any, window: str, certainty: Any, evidence_level: str, version: Any, idempotency_key: str, payload_schema_version: str, status: str = "") -> dict[str, Any]:
|
||||
normalized_type = clean_text(memory_type, 80).lower()
|
||||
if normalized_type not in BOT_PERSONAL_MEMORY_TYPES:
|
||||
raise BotPersonalValidationError("invalid_memory_type", "memory_type", normalized_type or "missing")
|
||||
if not isinstance(payload, dict):
|
||||
raise BotPersonalValidationError("invalid_payload", "payload", "payload must be an object")
|
||||
record_date = clean_text(date, 40)
|
||||
try:
|
||||
date_type.fromisoformat(record_date)
|
||||
except ValueError:
|
||||
raise BotPersonalValidationError("invalid_date", "date", record_date or "missing")
|
||||
normalized_window = clean_text(window, 40).lower()
|
||||
if normalized_window not in BOT_PERSONAL_WINDOWS:
|
||||
raise BotPersonalValidationError("invalid_window", "window", normalized_window or "missing")
|
||||
occurred = clean_text(occurred_at, 80)
|
||||
try:
|
||||
parsed_occurred = datetime.fromisoformat(occurred.replace("Z", "+00:00"))
|
||||
except ValueError:
|
||||
raise BotPersonalValidationError("invalid_occurred_at", "occurred_at", occurred or "missing")
|
||||
if parsed_occurred.tzinfo is None or parsed_occurred.utcoffset() is None:
|
||||
raise BotPersonalValidationError("invalid_occurred_at", "occurred_at", "timezone offset is required")
|
||||
try:
|
||||
refs_value = _sanitize_value({"source_refs": source_refs}, path="source_refs").get("source_refs")
|
||||
except BotPersonalValidationError:
|
||||
raise
|
||||
refs = [clean_text(item, 240) for item in (refs_value if isinstance(refs_value, list) else []) if clean_text(item, 240)]
|
||||
if not refs:
|
||||
raise BotPersonalValidationError("missing_source_refs", "source_refs", "at least one source reference is required")
|
||||
try:
|
||||
certainty_value = float(certainty)
|
||||
except (TypeError, ValueError):
|
||||
raise BotPersonalValidationError("invalid_certainty", "certainty", "certainty must be numeric")
|
||||
if not 0.0 <= certainty_value <= 1.0:
|
||||
raise BotPersonalValidationError("invalid_certainty", "certainty", "certainty must be between 0 and 1")
|
||||
normalized_evidence = clean_text(evidence_level, 40).upper()
|
||||
if normalized_evidence not in {"L0", "L1", "L2", "L3"}:
|
||||
raise BotPersonalValidationError("invalid_evidence_level", "evidence_level", normalized_evidence or "missing")
|
||||
if normalized_type == "bot_schedule_plan" and normalized_evidence != "L0":
|
||||
raise BotPersonalValidationError("invalid_evidence_level", "evidence_level", "bot_schedule_plan requires L0")
|
||||
try:
|
||||
version_value = int(version)
|
||||
except (TypeError, ValueError):
|
||||
raise BotPersonalValidationError("invalid_version", "version", "version must be a positive integer")
|
||||
if version_value < 1:
|
||||
raise BotPersonalValidationError("invalid_version", "version", "version must be a positive integer")
|
||||
key = clean_text(idempotency_key, 240)
|
||||
if not key:
|
||||
raise BotPersonalValidationError("missing_idempotency_key", "idempotency_key", "idempotency_key is required")
|
||||
schema = clean_text(payload_schema_version, 40)
|
||||
if schema != BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION:
|
||||
raise BotPersonalValidationError("unsupported_payload_schema", "payload_schema_version", schema or "missing")
|
||||
return {
|
||||
"memory_type": normalized_type,
|
||||
"date": record_date,
|
||||
"occurred_at": occurred,
|
||||
"source_refs": refs,
|
||||
"window": normalized_window,
|
||||
"certainty": certainty_value,
|
||||
"evidence_level": normalized_evidence,
|
||||
"version": version_value,
|
||||
"idempotency_key": key,
|
||||
"payload_schema_version": schema,
|
||||
"status": clean_text(status, 60),
|
||||
}
|
||||
|
||||
|
||||
def bot_personal_record_id(memory_type: str, idempotency_key: str) -> str:
|
||||
return "botmem_" + stable_fingerprint(BOT_PERSONAL_MEMORY_DOMAIN, clean_text(memory_type, 80).lower(), clean_text(idempotency_key, 240))[:24]
|
||||
|
||||
|
||||
def bot_personal_payload_fingerprint(*, memory_type: str, payload: dict[str, Any], date: str, window: str, occurred_at: str, source_refs: list[str], certainty: float, evidence_level: str, status: str, version: int, idempotency_key: str, payload_schema_version: str, source_kind: str) -> str:
|
||||
canonical = {
|
||||
"memory_type": clean_text(memory_type, 80).lower(),
|
||||
"payload": payload,
|
||||
"date": clean_text(date, 40),
|
||||
"window": clean_text(window, 40),
|
||||
"occurred_at": clean_text(occurred_at, 80),
|
||||
"source_refs": list(source_refs),
|
||||
"certainty": float(certainty),
|
||||
"evidence_level": clean_text(evidence_level, 40).upper(),
|
||||
"status": clean_text(status, 60),
|
||||
"version": int(version),
|
||||
"idempotency_key": clean_text(idempotency_key, 240),
|
||||
"payload_schema_version": clean_text(payload_schema_version, 40),
|
||||
"source_kind": clean_text(source_kind, 60),
|
||||
}
|
||||
canonical_json = json.dumps(canonical, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
|
||||
return stable_fingerprint(canonical_json)
|
||||
|
||||
|
||||
def bot_personal_content(memory_type: str, payload: dict[str, Any]) -> str:
|
||||
label = clean_text(memory_type, 80)
|
||||
return f"Bot个人记忆[{label}]:{json_dumps(normalize_bot_personal_payload(payload, 800))}"
|
||||
summary = clean_text(payload.get("summary") or payload.get("title") or payload.get("activity") or label, 800)
|
||||
return f"Bot个人归档[{label}]:{summary}"
|
||||
|
|
|
|||
155
core/bot_profiles.py
普通文件
155
core/bot_profiles.py
普通文件
|
|
@ -0,0 +1,155 @@
|
|||
"""M6.1.5 Bot 专用检索 Profile 定义。
|
||||
|
||||
每个 Profile 固定七件事:允许域、允许类型、时间范围、最大条数、排序、注入字段、权限。
|
||||
调用方只能选 Profile 名,不能自带过滤条件——否则「专用检索」会退化成把一堆类型塞进
|
||||
一次通用检索(M6.1.5 之前正是如此:陪伴侧一次性传 11 个 memory_type,拼一个 1400 字的
|
||||
大 query,当前状态和历史记忆混在同一批结果里,谁也分不清「现在要做什么」和「昨天做了什么」)。
|
||||
|
||||
时间范围用 `min_age_days` / `max_age_days` 表达,都以「相对现在的天数」计:
|
||||
- `bot_schedule_current` 只看最近 1 天,回答「现在/今天」;
|
||||
- `bot_schedule_history` 从 1 天前起算,回答「昨天/过去」——两者刻意不重叠,
|
||||
这样历史结果永远不可能被当成当前运行态。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Any
|
||||
|
||||
BOT_PROFILE_DOMAIN = "bot_self_schedule"
|
||||
|
||||
# 注入字段白名单。serialize_memory 会带出全部 metadata(人格权重、指纹、幂等键等内部字段),
|
||||
# 原样注进提示词既浪费预算又外泄内部结构,所以每个 Profile 只投影自己需要的字段。
|
||||
_BASE_FIELDS = ("id", "memory_type", "content", "occurred_at", "date", "window", "reality_level")
|
||||
|
||||
BOT_RETRIEVAL_PROFILES: dict[str, dict[str, Any]] = {
|
||||
"bot_schedule_current": {
|
||||
"description": "当前窗口的运行态补充:只用于补足本地日程,不能替代它",
|
||||
"memory_types": ("bot_schedule_plan", "bot_observed_activity",
|
||||
"bot_window_snapshot", "bot_schedule_reconciliation"),
|
||||
"min_age_days": None,
|
||||
"max_age_days": 1,
|
||||
"limit": 6,
|
||||
"order": "occurred_at_desc",
|
||||
"fields": _BASE_FIELDS + ("source_kind", "status"),
|
||||
},
|
||||
"bot_schedule_history": {
|
||||
"description": "回忆过去的日程:起点是 1 天前,与 current 刻意不重叠",
|
||||
"memory_types": ("bot_schedule_plan", "bot_observed_activity", "bot_schedule_reconciliation",
|
||||
"bot_window_snapshot", "bot_calendar_event", "bot_detail_fragment"),
|
||||
"min_age_days": 1,
|
||||
"max_age_days": 90,
|
||||
"limit": 8,
|
||||
"order": "occurred_at_desc",
|
||||
"fields": _BASE_FIELDS + ("source_kind", "status"),
|
||||
},
|
||||
"bot_creative": {
|
||||
"description": "创作里程碑与媒体索引",
|
||||
"memory_types": ("bot_creative_work", "bot_media_memory"),
|
||||
"min_age_days": None,
|
||||
"max_age_days": 180,
|
||||
"limit": 6,
|
||||
"order": "occurred_at_desc",
|
||||
"fields": _BASE_FIELDS + ("source_kind",),
|
||||
},
|
||||
"bot_subjective": {
|
||||
"description": "主观内容:梦境与日记,必须可被识别为主观而非事实",
|
||||
"memory_types": ("bot_subjective_memory", "bot_daily_diary"),
|
||||
"min_age_days": None,
|
||||
"max_age_days": 90,
|
||||
"limit": 5,
|
||||
"order": "occurred_at_desc",
|
||||
"fields": _BASE_FIELDS + ("epistemic_type",),
|
||||
},
|
||||
"locked_frame_personal": {
|
||||
"description": "Locked Frame 人格连续性:近期全类型少量取样",
|
||||
"memory_types": ("bot_schedule_plan", "bot_observed_activity", "bot_schedule_reconciliation",
|
||||
"bot_window_snapshot", "bot_daily_diary", "bot_creative_work",
|
||||
"bot_media_memory", "bot_subjective_memory", "bot_shared_activity",
|
||||
"bot_detail_fragment", "bot_calendar_event", "bot_proactive_message"),
|
||||
"min_age_days": None,
|
||||
"max_age_days": 7,
|
||||
"limit": 10,
|
||||
"order": "occurred_at_desc",
|
||||
"fields": _BASE_FIELDS + ("source_kind", "epistemic_type"),
|
||||
},
|
||||
}
|
||||
|
||||
BOT_PROFILE_NAMES = tuple(BOT_RETRIEVAL_PROFILES)
|
||||
|
||||
|
||||
class BotProfileError(ValueError):
|
||||
def __init__(self, error_code: str, message: str = "") -> None:
|
||||
self.error_code = error_code
|
||||
self.message = message or error_code
|
||||
super().__init__(self.message)
|
||||
|
||||
|
||||
def get_bot_profile(name: str) -> dict[str, Any]:
|
||||
profile = BOT_RETRIEVAL_PROFILES.get(str(name or "").strip().lower())
|
||||
if not profile:
|
||||
raise BotProfileError("unknown_profile", f"unknown bot retrieval profile: {name}")
|
||||
return profile
|
||||
|
||||
|
||||
def _parse_moment(value: Any) -> datetime | None:
|
||||
try:
|
||||
return datetime.fromisoformat(str(value or "").replace("Z", "+00:00"))
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def profile_time_bounds(profile: dict[str, Any], now: datetime) -> tuple[datetime | None, datetime | None]:
|
||||
"""返回 (最早, 最晚)。最晚由 min_age_days 决定——它把「太新」的记录挡在历史 Profile 之外。"""
|
||||
earliest = None
|
||||
latest = None
|
||||
if profile.get("max_age_days") is not None:
|
||||
earliest = now - timedelta(days=int(profile["max_age_days"]))
|
||||
if profile.get("min_age_days") is not None:
|
||||
latest = now - timedelta(days=int(profile["min_age_days"]))
|
||||
return earliest, latest
|
||||
|
||||
|
||||
def record_within_profile_window(occurred_at: Any, profile: dict[str, Any], now: datetime) -> bool:
|
||||
moment = _parse_moment(occurred_at)
|
||||
if moment is None:
|
||||
# 时间解析不了就不进任何 Profile:宁可少注入,也不要把无法定位时间的记录
|
||||
# 当成「当前」或「历史」注进提示词。
|
||||
return False
|
||||
if moment.tzinfo is None:
|
||||
return False
|
||||
earliest, latest = profile_time_bounds(profile, now)
|
||||
if earliest is not None and moment < earliest:
|
||||
return False
|
||||
if latest is not None and moment > latest:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def project_profile_fields(item: dict[str, Any], profile: dict[str, Any]) -> dict[str, Any]:
|
||||
"""按 Profile 的注入字段白名单投影,metadata 里的字段允许上浮到顶层。"""
|
||||
metadata = item.get("metadata") if isinstance(item.get("metadata"), dict) else {}
|
||||
projected: dict[str, Any] = {}
|
||||
for field in profile["fields"]:
|
||||
if field in item and item.get(field) not in (None, ""):
|
||||
projected[field] = item[field]
|
||||
elif field in metadata and metadata.get(field) not in (None, ""):
|
||||
projected[field] = metadata[field]
|
||||
return projected
|
||||
|
||||
|
||||
def describe_bot_profiles() -> dict[str, Any]:
|
||||
"""capability 用:把 Profile 契约原样暴露给调用方,避免两侧各自猜测限制。"""
|
||||
return {
|
||||
name: {
|
||||
"description": profile["description"],
|
||||
"memory_domain": BOT_PROFILE_DOMAIN,
|
||||
"memory_types": list(profile["memory_types"]),
|
||||
"min_age_days": profile["min_age_days"],
|
||||
"max_age_days": profile["max_age_days"],
|
||||
"limit": profile["limit"],
|
||||
"order": profile["order"],
|
||||
"fields": list(profile["fields"]),
|
||||
"read_only": True,
|
||||
}
|
||||
for name, profile in BOT_RETRIEVAL_PROFILES.items()
|
||||
}
|
||||
|
|
@ -305,65 +305,58 @@ class MemoryCompanionBridge:
|
|||
occurred_at: str = "",
|
||||
idempotency_key: str = "",
|
||||
**kwargs: Any,
|
||||
) -> str:
|
||||
) -> dict[str, Any]:
|
||||
recorder = getattr(self._plugin, "record_bot_personal_memory", None)
|
||||
if not callable(recorder):
|
||||
raise RuntimeError("bot_personal_memory_unavailable")
|
||||
return await recorder(
|
||||
return {"ok": False, "record_id": "", "deduplicated": False, "version": 0, "error_code": "bridge_method_unavailable"}
|
||||
result = await recorder(
|
||||
memory_type=memory_type,
|
||||
payload=payload or {},
|
||||
occurred_at=occurred_at,
|
||||
idempotency_key=idempotency_key,
|
||||
**kwargs,
|
||||
)
|
||||
return result if isinstance(result, dict) else {"ok": False, "record_id": "", "deduplicated": False, "version": 0, "error_code": "invalid_bridge_response"}
|
||||
|
||||
async def _record_bot_personal_type(
|
||||
self,
|
||||
memory_type: str,
|
||||
*,
|
||||
payload: dict[str, Any] | None = None,
|
||||
occurred_at: str = "",
|
||||
idempotency_key: str = "",
|
||||
**kwargs: Any,
|
||||
) -> str:
|
||||
return await self.record_bot_personal_memory(
|
||||
memory_type=memory_type,
|
||||
payload=payload,
|
||||
occurred_at=occurred_at,
|
||||
idempotency_key=idempotency_key,
|
||||
**kwargs,
|
||||
)
|
||||
async def _record_bot_personal_type(self, memory_type: str, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self.record_bot_personal_memory(memory_type=memory_type, **kwargs)
|
||||
|
||||
async def record_bot_schedule_plan(self, **kwargs: Any) -> str:
|
||||
async def record_bot_schedule_plan(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_schedule_plan", **kwargs)
|
||||
|
||||
async def record_bot_observed_activity(self, **kwargs: Any) -> str:
|
||||
async def record_bot_observed_activity(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_observed_activity", **kwargs)
|
||||
|
||||
async def record_bot_schedule_reconciliation(self, **kwargs: Any) -> str:
|
||||
async def record_bot_schedule_reconciliation(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_schedule_reconciliation", **kwargs)
|
||||
|
||||
async def record_bot_window_snapshot(self, **kwargs: Any) -> str:
|
||||
async def record_bot_window_snapshot(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_window_snapshot", **kwargs)
|
||||
|
||||
async def record_bot_daily_diary(self, **kwargs: Any) -> str:
|
||||
async def record_bot_daily_diary(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_daily_diary", **kwargs)
|
||||
|
||||
async def record_bot_creative_work(self, **kwargs: Any) -> str:
|
||||
async def record_bot_creative_work(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_creative_work", **kwargs)
|
||||
|
||||
async def record_bot_media_memory(self, **kwargs: Any) -> str:
|
||||
async def record_bot_media_memory(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_media_memory", **kwargs)
|
||||
|
||||
async def record_bot_subjective_memory(self, **kwargs: Any) -> str:
|
||||
async def record_bot_subjective_memory(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_subjective_memory", **kwargs)
|
||||
|
||||
async def record_bot_shared_activity(self, **kwargs: Any) -> str:
|
||||
async def record_bot_shared_activity(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_shared_activity", **kwargs)
|
||||
|
||||
async def record_bot_detail_fragment(self, **kwargs: Any) -> str:
|
||||
async def record_bot_detail_fragment(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_detail_fragment", **kwargs)
|
||||
|
||||
async def record_bot_calendar_event(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_calendar_event", **kwargs)
|
||||
|
||||
async def record_bot_proactive_message(self, **kwargs: Any) -> dict[str, Any]:
|
||||
return await self._record_bot_personal_type("bot_proactive_message", **kwargs)
|
||||
|
||||
async def search_bot_personal_memory(
|
||||
self,
|
||||
query: str = "",
|
||||
|
|
@ -375,6 +368,35 @@ class MemoryCompanionBridge:
|
|||
if not callable(getter):
|
||||
return []
|
||||
return await getter(query, limit=limit, memory_types=memory_types)
|
||||
|
||||
# ---- M6.1.5 Bot 专用检索 Profile ----
|
||||
# 调用方只选 Profile 名;域/类型/时间窗/条数/排序/注入字段全部由记忆侧固定,
|
||||
# 不接受调用方自带过滤条件——那样就退回成全库通用检索了。
|
||||
|
||||
async def search_bot_personal_profile(
|
||||
self, profile: str, query: str = "", *, limit: int | None = None,
|
||||
) -> dict[str, Any]:
|
||||
getter = getattr(self._plugin, "search_bot_personal_profile", None)
|
||||
if not callable(getter):
|
||||
return {"profile": profile, "memories": [], "read_only": True,
|
||||
"warnings": ["bridge_method_unavailable"]}
|
||||
return await getter(profile, query, limit=limit)
|
||||
|
||||
async def search_bot_schedule(
|
||||
self, query: str = "", *, history: bool = False, limit: int | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""`history=False` 回答「现在要做什么」,`True` 回答「昨天做了什么」,两个窗口不重叠。"""
|
||||
return await self.search_bot_personal_profile(
|
||||
"bot_schedule_history" if history else "bot_schedule_current", query, limit=limit)
|
||||
|
||||
async def search_bot_creative_memory(self, query: str = "", *, limit: int | None = None) -> dict[str, Any]:
|
||||
return await self.search_bot_personal_profile("bot_creative", query, limit=limit)
|
||||
|
||||
async def search_bot_subjective_memory(self, query: str = "", *, limit: int | None = None) -> dict[str, Any]:
|
||||
return await self.search_bot_personal_profile("bot_subjective", query, limit=limit)
|
||||
|
||||
async def search_locked_frame_personal_memory(self, query: str = "", *, limit: int | None = None) -> dict[str, Any]:
|
||||
return await self.search_bot_personal_profile("locked_frame_personal", query, limit=limit)
|
||||
async def search(
|
||||
self,
|
||||
query: str,
|
||||
|
|
|
|||
|
|
@ -51,6 +51,42 @@ def stable_fingerprint(*parts: Any) -> str:
|
|||
return hashlib.sha1(raw.encode("utf-8", errors="ignore")).hexdigest()
|
||||
|
||||
|
||||
# 域判定的唯一来源:`MemoryRecord.ensure_defaults` 与 `user_memory_boundary.infer_memory_domain`
|
||||
# 必须使用同一份集合,避免两处内联清单漂移。这些常量定义在最底层模块,
|
||||
# 由 `user_memory_boundary` 再导出,避免 models ←→ user_memory_boundary 循环导入。
|
||||
BOT_SELF_MEMORY_TYPES = frozenset({
|
||||
"self_action",
|
||||
"persona_life",
|
||||
"proactive_message",
|
||||
"schedule_fragment",
|
||||
"companion_note",
|
||||
"calendar_event",
|
||||
"agenda_snapshot",
|
||||
"timeline_event",
|
||||
})
|
||||
BOT_SELF_REALITY_LEVELS = frozenset({"bot_action", "persona_life", "llm_tool_assertion"})
|
||||
USER_MEMORY_TYPES = frozenset({
|
||||
"user_fact",
|
||||
"user_event",
|
||||
"user_decision",
|
||||
"user_summary",
|
||||
"user_profile",
|
||||
"user_preference",
|
||||
"user_habit",
|
||||
"relationship_claim",
|
||||
"explicit_memory",
|
||||
"manual_memory",
|
||||
"conversation_event",
|
||||
"conversation_summary",
|
||||
"important_event",
|
||||
"daily_digest",
|
||||
"tool_memory",
|
||||
})
|
||||
# 用户记忆写入门禁独立于域判定:本地生成的衰减总结属于聚合产物,
|
||||
# 不得经外部用户记忆 Bridge 当成用户事实写入,但它的域仍按来源片段判定。
|
||||
USER_MEMORY_WRITE_BLOCKED_TYPES = BOT_SELF_MEMORY_TYPES | {"memory_decay_summary"}
|
||||
|
||||
|
||||
@dataclass(slots=True)
|
||||
class EntityRef:
|
||||
kind: str = "user"
|
||||
|
|
@ -145,9 +181,9 @@ class MemoryRecord:
|
|||
reality = clean_text(self.reality_level, 80).lower()
|
||||
if memory_type == "calendar_event":
|
||||
self.memory_domain = "calendar_history"
|
||||
elif self.visibility == "bot_self" or reality in {"bot_action", "persona_life", "llm_tool_assertion"} or memory_type in {"self_action", "persona_life", "proactive_message", "schedule_fragment", "companion_note", "calendar_event", "agenda_snapshot", "timeline_event"}:
|
||||
elif self.visibility == "bot_self" or reality in BOT_SELF_REALITY_LEVELS or memory_type in BOT_SELF_MEMORY_TYPES:
|
||||
self.memory_domain = "bot_self_legacy"
|
||||
elif getattr(self.subject, "kind", "") == "user" or memory_type in {"user_fact", "user_event", "user_decision", "user_summary", "user_profile", "user_preference", "user_habit", "relationship_claim", "explicit_memory", "manual_memory", "conversation_event", "conversation_summary", "important_event", "daily_digest", "tool_memory"}:
|
||||
elif getattr(self.subject, "kind", "") == "user" or memory_type in USER_MEMORY_TYPES:
|
||||
self.memory_domain = "user_memory"
|
||||
else:
|
||||
self.memory_domain = "unknown"
|
||||
|
|
|
|||
|
|
@ -313,6 +313,9 @@ class PortableMemoryArchive:
|
|||
timeline = await self.store.recent_timeline(limit=1_000_000)
|
||||
acl_rules = await self.store.list_acl_rules()
|
||||
acl_policies = await self.store.list_acl_policies()
|
||||
domain_counts: dict[str, int] = {}
|
||||
for memory in memories:
|
||||
domain_counts[memory.memory_domain or "unknown"] = domain_counts.get(memory.memory_domain or "unknown", 0) + 1
|
||||
counts = {
|
||||
"memory": len(memories),
|
||||
"identity": len(identities),
|
||||
|
|
@ -332,6 +335,8 @@ class PortableMemoryArchive:
|
|||
"exported_at": now.isoformat(timespec="seconds"),
|
||||
"encoding": "utf-8",
|
||||
"counts": counts,
|
||||
# 域普查:运维一眼能看出用户域/Bot 域各多少条,恢复后可据此核对没有串域
|
||||
"memory_domain_counts": domain_counts,
|
||||
"excluded": ["memory_embeddings", "injection_logs", "provider_credentials"],
|
||||
}
|
||||
fd, temp_name = tempfile.mkstemp(suffix=".tmp", prefix=path.stem, dir=str(path.parent))
|
||||
|
|
@ -501,6 +506,10 @@ class PortableMemoryArchive:
|
|||
return {
|
||||
"id": memory.id,
|
||||
"memory_type": memory.memory_type,
|
||||
# 域必须随记录一起导出。缺了它,导入时 ensure_defaults 会按 visibility 重新推断,
|
||||
# 把 bot_self_schedule 降级成 bot_self_legacy —— 检索 Profile 全部失效,
|
||||
# 重新归档还会撞 domain_conflict。运维的备份恢复正好走这条路径。
|
||||
"memory_domain": memory.memory_domain,
|
||||
"subject": {"kind": memory.subject.kind, "id": memory.subject.id, "name": memory.subject.name, "role": memory.subject.role},
|
||||
"object": {"kind": memory.object.kind, "id": memory.object.id, "name": memory.object.name, "role": memory.object.role},
|
||||
"scope": memory.scope,
|
||||
|
|
@ -537,6 +546,8 @@ class PortableMemoryArchive:
|
|||
return MemoryRecord(
|
||||
id=clean_text(data.get("id"), 120),
|
||||
memory_type=clean_text(data.get("memory_type"), 80) or "imported_memory",
|
||||
# 老导出没有这个字段,留空则由 ensure_defaults 按 visibility 重新推断(旧行为)
|
||||
memory_domain=clean_text(data.get("memory_domain"), 60),
|
||||
subject=EntityRef(
|
||||
kind=clean_text(subject.get("kind"), 40) or "user",
|
||||
id=clean_text(subject.get("id"), 120),
|
||||
|
|
|
|||
278
core/service.py
278
core/service.py
|
|
@ -30,15 +30,32 @@ from .astrbot_compat import (
|
|||
)
|
||||
from .bridge import serialize_memory
|
||||
from .bot_personal import (
|
||||
BOT_PERSONAL_ENVELOPE_KEYS,
|
||||
BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
BOT_PERSONAL_MEMORY_TYPES,
|
||||
BOT_PERSONAL_SCOPE,
|
||||
BOT_PERSONAL_SESSION_ID,
|
||||
BOT_PERSONAL_VISIBILITY,
|
||||
BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION,
|
||||
BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION,
|
||||
BOT_PERSONAL_MAX_PAYLOAD_BYTES,
|
||||
BOT_PERSONAL_TYPE_CONTRACTS,
|
||||
BotPersonalValidationError,
|
||||
bot_personal_content,
|
||||
bot_personal_payload_fingerprint,
|
||||
bot_personal_record_id,
|
||||
normalize_bot_personal_payload,
|
||||
validate_bot_personal_envelope,
|
||||
)
|
||||
from .temporal_context import build_reply_delay
|
||||
from .bot_profiles import (
|
||||
BotProfileError,
|
||||
describe_bot_profiles,
|
||||
get_bot_profile,
|
||||
profile_time_bounds,
|
||||
project_profile_fields,
|
||||
record_within_profile_window,
|
||||
)
|
||||
from .temporal_context import build_reply_delay, local_now
|
||||
from .chat_import import HistoricalChatImporter
|
||||
from .classifier import MemoryClassifier
|
||||
from .config import ConfigView
|
||||
|
|
@ -872,42 +889,125 @@ class MemoryCompanionService:
|
|||
occurred_at: str = "",
|
||||
idempotency_key: str = "",
|
||||
source_plugin: str = "private_companion",
|
||||
source_refs: list[str] | None = None,
|
||||
date: str = "",
|
||||
window: str = "",
|
||||
certainty: float | None = None,
|
||||
evidence_level: str = "",
|
||||
version: int | None = None,
|
||||
payload_schema_version: str = "",
|
||||
status: str = "",
|
||||
importance: float = 0.55,
|
||||
confidence: float = 0.82,
|
||||
) -> str:
|
||||
normalized_type = clean_text(memory_type, 80).lower()
|
||||
if normalized_type not in BOT_PERSONAL_MEMORY_TYPES:
|
||||
raise UserMemoryBoundaryError(f"bot_personal_memory_type:{normalized_type or 'unknown'}")
|
||||
safe_payload = normalize_bot_personal_payload(payload or {})
|
||||
key = clean_text(idempotency_key, 240)
|
||||
memory_id = self.stable_id("bot_personal", key or normalized_type, json_dumps(safe_payload))
|
||||
metadata = dict(safe_payload)
|
||||
metadata.update({
|
||||
"memory_domain": BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
"bot_personal": True,
|
||||
"idempotency_key": key,
|
||||
"source_refs": safe_payload.get("source_refs", []),
|
||||
"epistemic_type": "subjective" if normalized_type == "bot_subjective_memory" else "observed",
|
||||
})
|
||||
reality_level = "persona_life" if normalized_type in {"bot_subjective_memory", "bot_daily_diary"} else "bot_action"
|
||||
return await self.record_external_event(
|
||||
memory_id=memory_id,
|
||||
content=bot_personal_content(normalized_type, safe_payload),
|
||||
memory_type=normalized_type,
|
||||
memory_domain=BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
scope=BOT_PERSONAL_SCOPE,
|
||||
session_id=BOT_PERSONAL_SESSION_ID,
|
||||
visibility=BOT_PERSONAL_VISIBILITY,
|
||||
sayability="indirect",
|
||||
reality_level=reality_level,
|
||||
lifecycle="stable_memory",
|
||||
confidence=confidence,
|
||||
importance=importance,
|
||||
tags=["bot_personal", normalized_type],
|
||||
metadata=metadata,
|
||||
source_plugin=source_plugin,
|
||||
occurred_at=clean_text(occurred_at, 80),
|
||||
)
|
||||
) -> dict[str, Any]:
|
||||
base = {"ok": False, "record_id": "", "deduplicated": False, "version": 0, "error_code": None}
|
||||
if not self.config.bool("private_companion_bridge.accept_external_records", True):
|
||||
return {**base, "error_code": "bridge_write_disabled"}
|
||||
if payload is not None and not isinstance(payload, dict):
|
||||
return {**base, "error_code": "invalid_payload", "error": "payload must be an object", "field": "payload"}
|
||||
raw_payload = payload if isinstance(payload, dict) else {}
|
||||
try:
|
||||
safe_payload = normalize_bot_personal_payload(raw_payload)
|
||||
# 兼容旧版陪伴:它把整包信封当 payload 送,除 payload 外全是信封字段。
|
||||
# 必须先解包再剥离——反过来的话内层的 source_refs 等字段会留在 body 里,
|
||||
# 与新版直接送 body 的形状指纹不同,双插件分别部署的滚动升级窗口里
|
||||
# 同一条记录就会 version_conflict → 死信。
|
||||
body_source = safe_payload
|
||||
inner_payload = safe_payload.get("payload")
|
||||
if isinstance(inner_payload, dict) and set(safe_payload) - BOT_PERSONAL_ENVELOPE_KEYS == {"payload"}:
|
||||
body_source = inner_payload
|
||||
body_payload = {
|
||||
key: value
|
||||
for key, value in body_source.items()
|
||||
if key not in BOT_PERSONAL_ENVELOPE_KEYS
|
||||
}
|
||||
envelope = validate_bot_personal_envelope(
|
||||
memory_type=memory_type,
|
||||
payload=body_payload,
|
||||
date=date or safe_payload.get("date", ""),
|
||||
occurred_at=occurred_at or safe_payload.get("occurred_at", ""),
|
||||
source_refs=source_refs if source_refs is not None else safe_payload.get("source_refs"),
|
||||
window=window or safe_payload.get("window", ""),
|
||||
certainty=certainty if certainty is not None else safe_payload.get("certainty"),
|
||||
evidence_level=evidence_level or safe_payload.get("evidence_level", ""),
|
||||
version=version if version is not None else safe_payload.get("version"),
|
||||
idempotency_key=idempotency_key or safe_payload.get("idempotency_key", ""),
|
||||
payload_schema_version=payload_schema_version or safe_payload.get("payload_schema_version") or BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION,
|
||||
status=status or safe_payload.get("status", ""),
|
||||
)
|
||||
record_date = envelope["date"]
|
||||
contract = BOT_PERSONAL_TYPE_CONTRACTS[envelope["memory_type"]]
|
||||
record_id = bot_personal_record_id(envelope["memory_type"], envelope["idempotency_key"])
|
||||
status_value = envelope["status"]
|
||||
evidence_value = contract["evidence_level"] if contract["evidence_level"] != "caller" else envelope["evidence_level"]
|
||||
payload_fingerprint = bot_personal_payload_fingerprint(
|
||||
memory_type=envelope["memory_type"],
|
||||
payload=body_payload,
|
||||
date=record_date,
|
||||
window=envelope["window"],
|
||||
occurred_at=envelope["occurred_at"],
|
||||
source_refs=envelope["source_refs"],
|
||||
certainty=envelope["certainty"],
|
||||
evidence_level=evidence_value,
|
||||
status=status_value,
|
||||
version=envelope["version"],
|
||||
idempotency_key=envelope["idempotency_key"],
|
||||
payload_schema_version=envelope["payload_schema_version"],
|
||||
source_kind=contract["source_kind"],
|
||||
)
|
||||
metadata = dict(body_payload)
|
||||
metadata.update({
|
||||
"memory_domain": BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
"bot_personal": True,
|
||||
"date": record_date,
|
||||
"window": envelope["window"],
|
||||
"occurred_at": envelope["occurred_at"],
|
||||
"source_kind": contract["source_kind"],
|
||||
"source_refs": envelope["source_refs"],
|
||||
"certainty": envelope["certainty"],
|
||||
"evidence_level": contract["evidence_level"] if contract["evidence_level"] != "caller" else envelope["evidence_level"],
|
||||
"version": envelope["version"],
|
||||
"idempotency_key": envelope["idempotency_key"],
|
||||
"payload_schema_version": envelope["payload_schema_version"],
|
||||
"payload_fingerprint": payload_fingerprint,
|
||||
"status": status_value,
|
||||
"epistemic_type": "subjective" if envelope["memory_type"] == "bot_daily_diary" else contract["source_kind"],
|
||||
})
|
||||
record = MemoryRecord(
|
||||
id=record_id,
|
||||
memory_type=envelope["memory_type"],
|
||||
memory_domain=BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
subject=EntityRef.bot_self(),
|
||||
object=EntityRef.bot_self(),
|
||||
scope=BOT_PERSONAL_SCOPE,
|
||||
session_id=BOT_PERSONAL_SESSION_ID,
|
||||
visibility=BOT_PERSONAL_VISIBILITY,
|
||||
sayability="indirect",
|
||||
reality_level=contract["reality_level"],
|
||||
lifecycle=contract["lifecycle"],
|
||||
content=bot_personal_content(envelope["memory_type"], body_payload),
|
||||
evidence="; ".join(envelope["source_refs"]),
|
||||
confidence=confidence,
|
||||
importance=importance,
|
||||
tags=["bot_personal", envelope["memory_type"], contract["source_kind"]],
|
||||
metadata=metadata,
|
||||
source_plugin=clean_text(source_plugin, 120) or "private_companion",
|
||||
occurred_at=envelope["occurred_at"],
|
||||
)
|
||||
result = await self.store.upsert_bot_personal_memory(
|
||||
record,
|
||||
payload_fingerprint=payload_fingerprint,
|
||||
version=envelope["version"],
|
||||
idempotency_key=envelope["idempotency_key"],
|
||||
)
|
||||
if result.get("action") in {"created", "updated"}:
|
||||
self._schedule_memory_embedding(record.id, record)
|
||||
return {**base, "ok": result.get("action") in {"created", "updated", "deduplicated"}, "record_id": result.get("record_id", record_id), "deduplicated": bool(result.get("deduplicated")), "version": int(result.get("version") or envelope["version"]), "error_code": result.get("error_code"), "action": result.get("action")}
|
||||
except BotPersonalValidationError as exc:
|
||||
return {**base, "error_code": exc.error_code, "error": exc.message, "field": exc.field}
|
||||
except Exception as exc:
|
||||
logger.exception("[MemoryCompanion] Bot Personal 归档失败: %s", exc)
|
||||
return {**base, "error_code": "internal_error", "error": clean_text(exc, 240)}
|
||||
|
||||
async def search_bot_personal_memory(
|
||||
self,
|
||||
|
|
@ -931,6 +1031,69 @@ class MemoryCompanionService:
|
|||
and (not allowed_types or record.memory_type in allowed_types)
|
||||
][: max(1, min(100, int(limit or 10)))]
|
||||
return [serialize_memory(record, reason="bot_personal_profile") for record in selected]
|
||||
|
||||
async def search_bot_personal_profile(
|
||||
self,
|
||||
profile: str,
|
||||
query: str = "",
|
||||
*,
|
||||
limit: int | None = None,
|
||||
now: datetime | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""M6.1.5:按 Profile 检索 Bot 个人记忆。
|
||||
|
||||
调用方只能选 Profile 名,允许域/类型/时间范围/条数/排序/注入字段全部由 Profile 固定。
|
||||
`limit` 只能往小调,调不大——否则一次调用就能把整个 Profile 的上限突破掉。
|
||||
"""
|
||||
profile_name = clean_text(profile, 80).lower()
|
||||
try:
|
||||
spec = get_bot_profile(profile_name)
|
||||
except BotProfileError as exc:
|
||||
return {"profile": profile_name, "memories": [], "read_only": True,
|
||||
"warnings": [exc.error_code]}
|
||||
moment = now or local_now()
|
||||
allowed_types = set(spec["memory_types"])
|
||||
effective_limit = spec["limit"] if limit is None else max(1, min(int(spec["limit"]), int(limit)))
|
||||
# 时间窗与类型直接进 SQL:在 Python 里后筛会被「按时间倒序截断」坑掉——
|
||||
# 近期记录一多,落在历史窗里的行根本进不了结果集,Profile 会静默返回空。
|
||||
earliest, latest = profile_time_bounds(spec, moment)
|
||||
records = await self.store.list_bot_profile_memories(
|
||||
memory_domain=BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
memory_types=sorted(allowed_types),
|
||||
occurred_from=earliest.isoformat() if earliest else "",
|
||||
occurred_to=latest.isoformat() if latest else "",
|
||||
query=clean_text(query, 500),
|
||||
limit=max(effective_limit * 3, 30),
|
||||
)
|
||||
selected = [
|
||||
record for record in records
|
||||
# 域是硬边界:Profile 永远只读 Bot 域,任何情况下都不返回用户记忆
|
||||
if record.memory_domain == BOT_PERSONAL_MEMORY_DOMAIN
|
||||
and record.memory_type in allowed_types
|
||||
and record_within_profile_window(record.occurred_at, spec, moment)
|
||||
]
|
||||
selected.sort(key=lambda r: str(r.occurred_at or ""), reverse=spec["order"] == "occurred_at_desc")
|
||||
# 不走 serialize_memory:它按自己的清单挑字段(且不返回 metadata),
|
||||
# Profile 需要的 date/window/source_kind/epistemic_type 都在 metadata 里,取不到。
|
||||
projected = [
|
||||
project_profile_fields({
|
||||
"id": record.id,
|
||||
"memory_type": record.memory_type,
|
||||
"content": record.content,
|
||||
"occurred_at": record.occurred_at,
|
||||
"reality_level": record.reality_level,
|
||||
"metadata": record.metadata if isinstance(record.metadata, dict) else {},
|
||||
}, spec)
|
||||
for record in selected[:effective_limit]
|
||||
]
|
||||
return {
|
||||
"profile": profile_name,
|
||||
"memory_domain": BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
"read_only": True,
|
||||
"limit": effective_limit,
|
||||
"memories": projected,
|
||||
"warnings": [],
|
||||
}
|
||||
async def bridge_search(
|
||||
self,
|
||||
query: str,
|
||||
|
|
@ -948,9 +1111,48 @@ class MemoryCompanionService:
|
|||
def bridge_probe_bot_personal_memory_capabilities(self) -> dict[str, Any]:
|
||||
return {
|
||||
"available": True,
|
||||
"write_enabled": self.config.bool("private_companion_bridge.accept_external_records", True),
|
||||
"read_only": False,
|
||||
"memory_domain": BOT_PERSONAL_MEMORY_DOMAIN,
|
||||
"accepted_memory_types": sorted(BOT_PERSONAL_MEMORY_TYPES),
|
||||
"dedicated_methods": [
|
||||
"record_bot_schedule_plan",
|
||||
"record_bot_observed_activity",
|
||||
"record_bot_schedule_reconciliation",
|
||||
"record_bot_window_snapshot",
|
||||
"record_bot_daily_diary",
|
||||
],
|
||||
"compatibility_methods": [
|
||||
"record_bot_personal_memory",
|
||||
"record_bot_creative_work",
|
||||
"record_bot_media_memory",
|
||||
"record_bot_subjective_memory",
|
||||
"record_bot_shared_activity",
|
||||
"record_bot_detail_fragment",
|
||||
"record_bot_calendar_event",
|
||||
"record_bot_proactive_message",
|
||||
],
|
||||
# M6.1.5:把 Profile 契约原样暴露出去,调用方不必猜测类型/时间窗/条数上限
|
||||
"retrieval_profiles": describe_bot_profiles(),
|
||||
"retrieval_methods": [
|
||||
"search_bot_personal_profile",
|
||||
"search_bot_schedule",
|
||||
"search_bot_creative_memory",
|
||||
"search_bot_subjective_memory",
|
||||
"search_locked_frame_personal_memory",
|
||||
],
|
||||
"capability_schema_version": BOT_PERSONAL_CAPABILITY_SCHEMA_VERSION,
|
||||
"payload_schema_version": BOT_PERSONAL_PAYLOAD_SCHEMA_VERSION,
|
||||
"max_payload_bytes": BOT_PERSONAL_MAX_PAYLOAD_BYTES,
|
||||
"error_codes": [
|
||||
"bridge_method_unavailable", "invalid_bridge_response", "bridge_write_disabled",
|
||||
"invalid_memory_type", "invalid_payload", "invalid_field", "payload_too_large",
|
||||
"privacy_rejected", "invalid_date", "invalid_window", "invalid_occurred_at",
|
||||
"missing_source_refs", "missing_occurred_at", "missing_date", "missing_window",
|
||||
"invalid_certainty", "invalid_evidence_level", "invalid_version",
|
||||
"missing_idempotency_key", "unsupported_payload_schema", "stale_version",
|
||||
"version_conflict", "idempotency_conflict", "domain_conflict", "internal_error",
|
||||
],
|
||||
"four_window_schedule": True,
|
||||
"daily_diary": True,
|
||||
"idempotent_writes": True,
|
||||
|
|
@ -2432,7 +2634,7 @@ class MemoryCompanionService:
|
|||
error: str = "",
|
||||
) -> None:
|
||||
usage = self._extract_token_usage(resp, prompt, completion)
|
||||
now_dt = datetime.now()
|
||||
now_dt = local_now()
|
||||
now_ts = time.time()
|
||||
day = now_dt.strftime("%Y-%m-%d")
|
||||
hour = now_dt.strftime("%Y-%m-%dT%H:00")
|
||||
|
|
@ -7087,7 +7289,7 @@ class MemoryCompanionService:
|
|||
if not check_like:
|
||||
return False
|
||||
try:
|
||||
hour = datetime.now().hour
|
||||
hour = local_now().hour
|
||||
except Exception:
|
||||
return True
|
||||
return hour >= 23 or hour < 7
|
||||
|
|
@ -7606,7 +7808,7 @@ class MemoryCompanionService:
|
|||
def _compute_time_of_day(self) -> str:
|
||||
"""Compute time-of-day category for atmosphere hints."""
|
||||
try:
|
||||
hour = datetime.now().hour
|
||||
hour = local_now().hour
|
||||
except Exception:
|
||||
return ""
|
||||
if 23 <= hour or hour < 4:
|
||||
|
|
|
|||
148
core/store.py
148
core/store.py
|
|
@ -107,8 +107,9 @@ class MemoryStore:
|
|||
if self._conn.in_transaction:
|
||||
self._conn.rollback()
|
||||
self._recover_connection_sync()
|
||||
result = operation(*args)
|
||||
self._database_recovery_successes += 1
|
||||
return operation(*args)
|
||||
return result
|
||||
|
||||
async def _run_recoverable_database_operation(self, operation: Any, *args: Any) -> Any:
|
||||
return await asyncio.to_thread(self._run_with_database_recovery_sync, operation, *args)
|
||||
|
|
@ -499,6 +500,13 @@ class MemoryStore:
|
|||
self._conn.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_memories_fingerprint ON memories(content_fingerprint)"
|
||||
)
|
||||
# M6.1.4:创作/媒体/主观等 Bot 个人类型按「类型 + 时间」回溯,
|
||||
# idx_memories_domain 的前缀是 (domain, lifecycle, scope, ...),用不上 memory_type,
|
||||
# 这类查询只能退化成域内全扫。
|
||||
self._conn.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_memories_domain_type_time "
|
||||
"ON memories(memory_domain, memory_type, occurred_at DESC)"
|
||||
)
|
||||
self._conn.execute(
|
||||
"CREATE INDEX IF NOT EXISTS idx_timeline_summary ON timeline(session_id, summarized_at, occurred_at)"
|
||||
)
|
||||
|
|
@ -1333,6 +1341,80 @@ class MemoryStore:
|
|||
self._conn.commit()
|
||||
return record.id
|
||||
|
||||
async def upsert_bot_personal_memory(
|
||||
self,
|
||||
record: MemoryRecord,
|
||||
*,
|
||||
payload_fingerprint: str,
|
||||
version: int,
|
||||
idempotency_key: str,
|
||||
) -> dict[str, Any]:
|
||||
return await self._run_recoverable_database_operation(
|
||||
self._upsert_bot_personal_memory_sync,
|
||||
record,
|
||||
payload_fingerprint,
|
||||
version,
|
||||
idempotency_key,
|
||||
)
|
||||
|
||||
def _upsert_bot_personal_memory_sync(
|
||||
self,
|
||||
record: MemoryRecord,
|
||||
payload_fingerprint: str,
|
||||
version: int,
|
||||
idempotency_key: str,
|
||||
) -> dict[str, Any]:
|
||||
record.ensure_defaults()
|
||||
record.updated_at = utc_now()
|
||||
data = record.to_db()
|
||||
metadata = dict(record.metadata or {})
|
||||
metadata["payload_fingerprint"] = clean_text(payload_fingerprint, 80)
|
||||
metadata["version"] = int(version)
|
||||
metadata["idempotency_key"] = clean_text(idempotency_key, 240)
|
||||
record.metadata = metadata
|
||||
data["metadata"] = json_dumps(metadata)
|
||||
with self._lock:
|
||||
row = self._conn.execute("SELECT * FROM memories WHERE id=?", (record.id,)).fetchone()
|
||||
if row is None:
|
||||
columns = ", ".join(data.keys())
|
||||
placeholders = ", ".join(f":{key}" for key in data.keys())
|
||||
self._conn.execute(f"INSERT INTO memories ({columns}) VALUES ({placeholders})", data)
|
||||
self._upsert_memory_fts_row(self._conn.execute("SELECT * FROM memories WHERE id=?", (record.id,)).fetchone())
|
||||
self._conn.commit()
|
||||
return {"record_id": record.id, "deduplicated": False, "version": int(version), "action": "created"}
|
||||
stored = MemoryRecord.from_row(row)
|
||||
stored_metadata = dict(stored.metadata or {})
|
||||
stored_domain = clean_text(stored.memory_domain, 80)
|
||||
if stored_domain != "bot_self_schedule":
|
||||
return {"record_id": record.id, "deduplicated": False, "version": int(stored_metadata.get("version") or 0), "action": "error", "error_code": "domain_conflict"}
|
||||
stored_key = clean_text(stored_metadata.get("idempotency_key"), 240)
|
||||
if stored_key and stored_key != clean_text(idempotency_key, 240):
|
||||
return {"record_id": record.id, "deduplicated": False, "version": int(stored_metadata.get("version") or 0), "action": "error", "error_code": "idempotency_conflict"}
|
||||
stored_version = int(stored_metadata.get("version") or 1)
|
||||
stored_fingerprint = clean_text(stored_metadata.get("payload_fingerprint"), 80)
|
||||
incoming_fingerprint = clean_text(payload_fingerprint, 80)
|
||||
if int(version) < stored_version:
|
||||
return {"record_id": record.id, "deduplicated": False, "version": stored_version, "action": "error", "error_code": "stale_version"}
|
||||
if int(version) == stored_version:
|
||||
if stored_fingerprint == incoming_fingerprint:
|
||||
return {"record_id": record.id, "deduplicated": True, "version": stored_version, "action": "deduplicated"}
|
||||
return {"record_id": record.id, "deduplicated": False, "version": stored_version, "action": "error", "error_code": "version_conflict"}
|
||||
history = stored_metadata.get("version_history")
|
||||
if not isinstance(history, list):
|
||||
history = []
|
||||
history.append({"version": stored_version, "payload_fingerprint": stored_fingerprint, "updated_at": stored.updated_at})
|
||||
metadata["version_history"] = history[-8:]
|
||||
record.created_at = stored.created_at
|
||||
record.metadata = metadata
|
||||
data = record.to_db()
|
||||
data["created_at"] = stored.created_at
|
||||
data["updated_at"] = utc_now()
|
||||
assignments = ", ".join(f"{key}=:{key}" for key in data if key != "id" and key != "created_at")
|
||||
self._conn.execute(f"UPDATE memories SET {assignments} WHERE id=:id", data)
|
||||
self._upsert_memory_fts_row(self._conn.execute("SELECT * FROM memories WHERE id=?", (record.id,)).fetchone())
|
||||
self._conn.commit()
|
||||
return {"record_id": record.id, "deduplicated": False, "version": int(version), "action": "updated"}
|
||||
|
||||
def _upsert_review_sync(self, memory_id: str, reason: str) -> None:
|
||||
now = utc_now()
|
||||
self._conn.execute(
|
||||
|
|
@ -3864,8 +3946,8 @@ class MemoryStore:
|
|||
params.append(clean_text(group_id, 120))
|
||||
if entity_id:
|
||||
entity = clean_text(entity_id, 120)
|
||||
where += " AND (subject_id=? OR object_id=? OR group_id=? OR session_id LIKE ?)"
|
||||
params.extend([entity, entity, entity, f"%{entity}%"])
|
||||
where += " AND (subject_id=? OR object_id=? OR group_id=? OR session_id LIKE ? ESCAPE '\\')"
|
||||
params.extend([entity, entity, entity, self._like_pattern(entity)])
|
||||
with self._lock:
|
||||
rows = self._conn.execute(
|
||||
f"""
|
||||
|
|
@ -3878,6 +3960,66 @@ class MemoryStore:
|
|||
).fetchall()
|
||||
return [MemoryRecord.from_row(row) for row in rows]
|
||||
|
||||
async def list_bot_profile_memories(
|
||||
self,
|
||||
*,
|
||||
memory_domain: str,
|
||||
memory_types: list[str],
|
||||
occurred_from: str = "",
|
||||
occurred_to: str = "",
|
||||
query: str = "",
|
||||
limit: int = 10,
|
||||
) -> list[MemoryRecord]:
|
||||
"""M6.1.5:按 Profile 约束直接在 SQL 里筛。
|
||||
|
||||
不能复用 list_memories 再在 Python 里过滤——它按 occurred_at DESC 截断,
|
||||
近期记录一多,落在历史时间窗里的行根本进不了结果集,Profile 会静默返回空。
|
||||
走 idx_memories_domain_type_time。
|
||||
"""
|
||||
return await self._run_recoverable_database_operation(
|
||||
self._list_bot_profile_memories_sync,
|
||||
clean_text(memory_domain, 60),
|
||||
[clean_text(item, 80) for item in (memory_types or []) if clean_text(item, 80)],
|
||||
clean_text(occurred_from, 80),
|
||||
clean_text(occurred_to, 80),
|
||||
clean_text(query, 500),
|
||||
max(1, min(200, int(limit or 10))),
|
||||
)
|
||||
|
||||
def _list_bot_profile_memories_sync(
|
||||
self,
|
||||
memory_domain: str,
|
||||
memory_types: list[str],
|
||||
occurred_from: str,
|
||||
occurred_to: str,
|
||||
query: str,
|
||||
limit: int,
|
||||
) -> list[MemoryRecord]:
|
||||
if not memory_domain or not memory_types:
|
||||
return []
|
||||
params: list[Any] = [memory_domain]
|
||||
where = "memory_domain=? AND review_status != 'pending'"
|
||||
where += f" AND memory_type IN ({','.join('?' * len(memory_types))})"
|
||||
params.extend(memory_types)
|
||||
# occurred_at 是 ISO-8601 带偏移的字符串,同一时区下字典序即时间序;
|
||||
# 边界比较只用于粗筛,精确判定仍由 record_within_profile_window 完成。
|
||||
if occurred_from:
|
||||
where += " AND occurred_at >= ?"
|
||||
params.append(occurred_from)
|
||||
if occurred_to:
|
||||
where += " AND occurred_at <= ?"
|
||||
params.append(occurred_to)
|
||||
if query:
|
||||
like = f"%{query}%"
|
||||
where += " AND (content LIKE ? OR evidence LIKE ?)"
|
||||
params.extend([like, like])
|
||||
with self._lock:
|
||||
rows = self._conn.execute(
|
||||
f"SELECT * FROM memories WHERE {where} ORDER BY occurred_at DESC, created_at DESC LIMIT ?",
|
||||
(*params, limit),
|
||||
).fetchall()
|
||||
return [MemoryRecord.from_row(row) for row in rows]
|
||||
|
||||
async def list_memory_buckets(self, limit: int = 160) -> list[dict[str, Any]]:
|
||||
return await asyncio.to_thread(self._list_memory_buckets_sync, limit)
|
||||
|
||||
|
|
|
|||
|
|
@ -23,6 +23,18 @@ LONG_TERM_TYPES = {
|
|||
}
|
||||
|
||||
|
||||
def local_now(*, timezone_name: str = DEFAULT_TIMEZONE) -> datetime:
|
||||
"""记忆侧统一的“当前本地时间”。
|
||||
|
||||
必须带时区:容器 TZ 为 UTC 时,naive `datetime.now()` 会让时段判定和
|
||||
token 分桶相对配置时区偏 8 小时。
|
||||
"""
|
||||
try:
|
||||
return datetime.now(ZoneInfo(timezone_name or DEFAULT_TIMEZONE))
|
||||
except Exception:
|
||||
return datetime.now(LOCAL_TZ)
|
||||
|
||||
|
||||
def _parse_datetime(value: Any, *, timezone_name: str = DEFAULT_TIMEZONE) -> datetime | None:
|
||||
text = clean_text(value, 120)
|
||||
if not text:
|
||||
|
|
|
|||
|
|
@ -2,7 +2,14 @@ from __future__ import annotations
|
|||
|
||||
from typing import Any
|
||||
|
||||
from .models import MemoryRecord, clean_text
|
||||
from .models import (
|
||||
BOT_SELF_MEMORY_TYPES,
|
||||
BOT_SELF_REALITY_LEVELS,
|
||||
USER_MEMORY_TYPES,
|
||||
USER_MEMORY_WRITE_BLOCKED_TYPES,
|
||||
MemoryRecord,
|
||||
clean_text,
|
||||
)
|
||||
|
||||
USER_MEMORY_DOMAIN = "user_memory"
|
||||
BOT_SELF_LEGACY_DOMAIN = "bot_self_legacy"
|
||||
|
|
@ -10,35 +17,22 @@ MIXED_MEMORY_DOMAIN = "shared_or_mixed"
|
|||
UNKNOWN_MEMORY_DOMAIN = "unknown"
|
||||
CALENDAR_HISTORY_DOMAIN = "calendar_history"
|
||||
|
||||
USER_MEMORY_TYPES = frozenset({
|
||||
"user_fact",
|
||||
"user_event",
|
||||
"user_decision",
|
||||
"user_summary",
|
||||
"user_profile",
|
||||
"user_preference",
|
||||
"user_habit",
|
||||
"relationship_claim",
|
||||
"explicit_memory",
|
||||
"manual_memory",
|
||||
"conversation_event",
|
||||
"conversation_summary",
|
||||
"important_event",
|
||||
"daily_digest",
|
||||
"tool_memory",
|
||||
})
|
||||
BOT_SELF_MEMORY_TYPES = frozenset({
|
||||
"self_action",
|
||||
"persona_life",
|
||||
"proactive_message",
|
||||
"schedule_fragment",
|
||||
"companion_note",
|
||||
"calendar_event",
|
||||
"agenda_snapshot",
|
||||
"timeline_event",
|
||||
"memory_decay_summary",
|
||||
})
|
||||
BOT_SELF_REALITY_LEVELS = frozenset({"bot_action", "persona_life", "llm_tool_assertion"})
|
||||
# 类型/真实性集合的定义在 `core/models.py`,此处只做再导出,
|
||||
# 保证域判定与写入门禁只有一份来源(详见 models.py 注释)。
|
||||
__all__ = [
|
||||
"USER_MEMORY_DOMAIN",
|
||||
"BOT_SELF_LEGACY_DOMAIN",
|
||||
"MIXED_MEMORY_DOMAIN",
|
||||
"UNKNOWN_MEMORY_DOMAIN",
|
||||
"CALENDAR_HISTORY_DOMAIN",
|
||||
"USER_MEMORY_TYPES",
|
||||
"BOT_SELF_MEMORY_TYPES",
|
||||
"BOT_SELF_REALITY_LEVELS",
|
||||
"USER_MEMORY_WRITE_BLOCKED_TYPES",
|
||||
"UserMemoryBoundaryError",
|
||||
"infer_memory_domain",
|
||||
"validate_user_memory_record",
|
||||
]
|
||||
|
||||
|
||||
class UserMemoryBoundaryError(ValueError):
|
||||
|
|
@ -75,7 +69,7 @@ def validate_user_memory_record(record: MemoryRecord, *, require_evidence: bool
|
|||
raise UserMemoryBoundaryError("missing_group_id")
|
||||
if clean_text(record.visibility, 40).lower() == "bot_self":
|
||||
raise UserMemoryBoundaryError("bot_self_visibility")
|
||||
if clean_text(record.memory_type, 80).lower() in BOT_SELF_MEMORY_TYPES:
|
||||
if clean_text(record.memory_type, 80).lower() in USER_MEMORY_WRITE_BLOCKED_TYPES:
|
||||
raise UserMemoryBoundaryError(f"bot_self_memory_type:{record.memory_type}")
|
||||
if clean_text(record.reality_level, 80).lower() in BOT_SELF_REALITY_LEVELS:
|
||||
raise UserMemoryBoundaryError(f"bot_self_reality_level:{record.reality_level}")
|
||||
|
|
|
|||
133
docs/运维记忆错题本.md
133
docs/运维记忆错题本.md
|
|
@ -155,3 +155,136 @@
|
|||
- 修复或规避:新增 Bot 个人类型白名单和显式 Bridge 包装;默认检索继续阻止 Bot 域;Locked Frame 只读页面只接收 Bot 个人域或陪伴旧本地记录;远端 Bridge 失败时不阻断陪伴侧本地写入。
|
||||
- 预防规则:任何 Bot 自身日程读取必须显式使用 Bot personal profile;页面、Bridge、服务三层都要检查域、主体、可见性和来源,不能只看标签。
|
||||
- 验证证据:M6_MEMORY_TESTS_OK;compileall -q core tests page_api.py;git diff --check;专用 Bridge、幂等写入、默认检索隔离和观察窗分类已复核。
|
||||
|
||||
## 2026-07-26 — Bot Personal 独立域不等于真实性、幂等和只读合同完成
|
||||
|
||||
- 阶段:M6.1.1~M6.1.6 源码复盘
|
||||
- 类型:API契约 / 数据隔离 / 功能行为
|
||||
- 现象:`bot_self_schedule` 已独立,但 `bot_schedule_plan` 被统一写成 observed/bot_action;记录 ID 同时包含幂等键和 payload,同键不同载荷会产生新 ID;Locked Frame 仍依赖陪伴插件私有运行对象。
|
||||
- 根因:Bot Personal 只完成类型和域骨架,尚未按类型定义真实性、字段必填、稳定 ID、版本竞争、专用 Profile 和纯归档只读 API。
|
||||
- 修复或规避:先冻结按类型合同和稳定幂等 ID,加入版本比较与递归白名单清洗;再实现 current/history/creative/subjective/locked-frame Profiles 和分层只读 API。
|
||||
- 预防规则:能力探测返回 `idempotent_writes=true` 前必须覆盖“同键不同 payload”和乱序版本测试;计划永远不能沿用 observed/bot_action 默认值。
|
||||
- 验证证据:`core/service.py:867`、`core/store.py:1213`、`core/bot_personal.py:28`、`page_api.py:1229`、`docs/OPS双插件完整复盘与功能调整总方案.md`。
|
||||
## 2026-07-26 — M6.1.3-A Bot 归档可靠写入合同
|
||||
|
||||
- 阶段:M6.1.3-A 记忆侧归档合同、可靠幂等写入和五类 Bridge
|
||||
- 类型:API契约 / 数据隔离 / 测试
|
||||
- 现象:旧 Bot Personal 写入把 payload 拼入 record_id、所有类型统一映射为 bot_action,通用 SQLite UPSERT 可静默覆盖乱序版本,递归隐私清洗也会静默丢弃字段。
|
||||
- 根因:此前只有逻辑域和类型骨架,没有独立的 envelope 校验、版本竞争和 Bot 专用原子写入路径。
|
||||
- 修复或规避:冻结 capability/payload schema 1.0;record_id 只由域、类型和幂等键生成;新增同键去重、新版本更新、旧版本拒绝和同版本冲突;五类类型固化真实性;递归拒绝敏感字段、完整聊天、凭据、Base64、媒体二进制和本机路径;写入强制 bot_self_schedule 与 bot_self。
|
||||
- 预防规则:任何 Bridge 能力只有在返回合同、错误码、版本竞争和隐私拒绝均有测试后才可声明 FROZEN;计划不得复用 observed/bot_action 默认值。
|
||||
- 验证证据:M6.1.3-A 定向 9 项通过;OPS 纯测试 143 项通过;compileall 通过;git diff --check 通过;共享合同已更新为 FROZEN。
|
||||
|
||||
## 2026-07-26 — M6.1.3-R1 联合审查阻断修复
|
||||
|
||||
- 阶段:R1 记忆侧严格字段、canonical fingerprint、超限拒绝和兼容回归
|
||||
- 类型:API契约 / 数据隔离 / 测试
|
||||
- 现象:联合审查复现出非法日期、非法窗口、无时区时间可写入;20KB 字符串被静默截断;fingerprint 未覆盖 Envelope;plan 允许非 L0;旧 creative/media/subjective/shared 类型会落入 observed;部分运行错误码未声明。
|
||||
- 根因:第一版只完成 Bot 域和幂等骨架,没有把 FROZEN Envelope 的所有语义字段统一送入验证与 canonical fingerprint,非五类类型也使用了过宽默认合同。
|
||||
- 修复或规避:增加严格日期/窗口/时区解析;原始 JSON payload 先验大小再清洗;fingerprint 覆盖 payload、日期、窗口、发生时间、来源、确定性、证据等级、状态、版本、幂等键、schema 和 source_kind;plan 强制 L0;非五类恢复显式真实性和兼容 wrapper;错误码与 capability/共享合同同步。
|
||||
- 预防规则:FROZEN 合同的每个落库语义字段都必须有单独变化冲突测试;任何清洗前截断都视为数据完整性风险;旧能力不能用 observed 兜底。
|
||||
- 验证证据:R1 定向 15 项通过;OPS 纯测试 143 项通过;compileall 和 git diff --check 通过;共享合同字段规范仍为 FROZEN 1.0,实施验收保持 REOPEN_REQUIRED。
|
||||
|
||||
## 2026-07-26 — 兼容回归不能只用喂满 Envelope 的夹具
|
||||
|
||||
- 阶段:M6.1.3-R1 联合复验
|
||||
- 类型:API契约 / 测试 / 数据隔离
|
||||
- 现象:R1 七项必修全部通过联合复验(严格时间、完整 fingerprint、超限拒绝、L0 规则、错误码覆盖、专用/通用一致);但“非五类兼容”测试因夹具恒带 date/window/occurred_at 而全绿,真实陪伴 DTO(date 为空)在联合链路上被 `invalid_date` 拒绝,5 个旧 kind 归档中断。
|
||||
- 根因:`envelope_payload` 夹具验证的是提供方视角的兼容,没有覆盖调用方真实 DTO 形状;另值级隐私清洗缺 `base64,`/`data:` URI 与路径中缀检测,弱于陪伴侧(纵深防御缺口)。
|
||||
- 修复或规避:M6.1.3-R2——补“date 由 occurred_at 派生”的真实形状兼容回归(date 为空仍必须 invalid_date,不放松校验,主修在陪伴侧);`_FORBIDDEN_VALUE_PATTERNS` 增加 base64/data URI 与中缀路径模式并配正反例。
|
||||
- 预防规则:对外兼容能力的回归必须包含调用方真实序列化输出样本;声明“禁止 Base64/本机路径”的合同必须有对应值级检测与测试,不能只依赖键名黑名单和上游拦截。
|
||||
- 验证证据:`docs/M6.1.3双插件真实联合验收报告-R1复验.md` P1-R2-1、P2-1;联合 E2E L 组与 P 组扫描。
|
||||
|
||||
## 2026-07-26 — 审计 Batch 1:报告的 B21 症状与源码不符,域判定集合被当成写入门禁
|
||||
|
||||
- 阶段:OPS 源码审计整改 Batch 1(B12、B21、B23、B13)
|
||||
- 类型:API契约 / 数据隔离 / 测试
|
||||
- 现象:审计报告 B21 断言「`ensure_defaults` 缺 `memory_decay_summary`,衰减总结被判成 `user_memory`」。回读 `core/models.py:100` 发现 `memory_domain` 字段默认值是 `"unknown"`(真值),而 `ensure_defaults` 的分类分支写的是 `if not self.memory_domain:`,因此该分支**只在调用方显式传 `memory_domain=""` 时才执行**;`core/service.py:4269` 的衰减总结没有传域,落库实际是 `unknown`,被 `_memory_domain_block_reason` 判为 `missing_user_subject`,从来没有被判成 `user_memory`。
|
||||
- 根因:`user_memory_boundary.BOT_SELF_MEMORY_TYPES` 同时承担两件互相冲突的事——① 域判定(`infer_memory_domain`)② 用户记忆 Bridge 的写入门禁。`memory_decay_summary` 只应属于 ②;把它塞进同一个集合,才导致「models 的内联清单」与「boundary 的清单」看起来漂移。三个分类器里 `models.ensure_defaults` 与 `user_memory_migration._classify:104` 都判用户域,只有 `infer_memory_domain` 判 `bot_self_legacy`,少数派才是需要拆分的那一个。
|
||||
- 修复或规避:域判定的三个集合下沉到 `core/models.py`(最底层模块,避免 models ←→ user_memory_boundary 循环导入),由 `user_memory_boundary` 再导出,两个分类器共用同一个 frozenset 对象;新增 `USER_MEMORY_WRITE_BLOCKED_TYPES = BOT_SELF_MEMORY_TYPES | {"memory_decay_summary"}` 专供 `validate_user_memory_record` 的写入门禁,拒绝行为与错误码 `bot_self_memory_type:memory_decay_summary` 保持不变。**未按报告字面把衰减总结改判 `bot_self_legacy`**:那样会让默认开启(`memory_decay_enabled` default true)的睡眠衰减在压缩后既归档原片段、又屏蔽总结,等于把记忆从召回面彻底抹掉。
|
||||
- 预防规则:① 报告给出的「症状」必须先用源码复现再动手,dataclass 默认值为真值时 `if not field:` 分支可能是事实上的死分支;② 一个常量集合只能服务一个语义,域判定与写入门禁必须分开命名;③ 收紧写入门禁允许,放宽不允许——改动后必须有「同一条记录仍被拒绝且错误码不变」的用例;④ 任何会改变 `memory_domain` 归类的改动,都要先算「检索是否还召回得到」,压缩/归档链路上的域变更等同数据可用性变更。
|
||||
- 遗留(新发现,未在本批修):衰减总结当前落库域为 `unknown`,检索前置过滤直接屏蔽,而源片段已被 `archive_memories` 归档(`lifecycle=archived` 被候选查询排除),因此**睡眠衰减压缩后的内容在主线检索中不可召回**。这是 B10(域放行意图)同一类问题,需与 B10 一起确认产品意图后处理。
|
||||
- 验证证据:`tests/test_audit_batch1_fixes.py::MemoryDomainConstantSourceTests`(6 项:常量同一对象、`ensure_defaults` 不再内联清单、两分类器一致、衰减总结域一致、写入门禁仍拒绝且错误码不变、默认值陷阱固化);OPS 纯测试 198 项通过;联合 E2E 85/81/4 与 R1 基线失败集合完全一致。
|
||||
|
||||
## 2026-07-26 — 审计 Batch 1:未转义 LIKE、恢复计数与记忆侧 naive 时钟
|
||||
|
||||
- 阶段:OPS 源码审计整改 Batch 1
|
||||
- 类型:数据隔离 / 可观测性 / 时间感知
|
||||
- 现象:
|
||||
- B12 `core/store.py:3941`:`list_memories(entity_id=...)` 用 `f"%{entity}%"` 裸 LIKE。实测 `entity_id="u_1"` 会同时命中 `qq:FriendMessage:uX1`(`_` 被当成单字符通配),跨会话串记忆。
|
||||
- B23 `core/store.py:110`:`_database_recovery_successes += 1` 写在 `return operation(*args)` 之前,恢复后重试再次失败也计为成功,`wal_health` 的恢复成功率指标失真。
|
||||
- B13 `core/service.py:2548/7203/7722`:时段判定与 token 分桶用 naive `datetime.now()`,UTC 容器上相对全局 `Asia/Shanghai` 偏 8 小时,`by_day`/`by_hour` 键和「深夜查岗」判定都会错档。
|
||||
- 根因:同文件已有 `_like_pattern`/`_like_id` 转义工具但该处漏用;计数语义把「已尝试恢复」当成「恢复成功」;记忆侧没有统一的「当前本地时间」入口,各处各写。
|
||||
- 修复或规避:B12 改 `session_id LIKE ? ESCAPE '\'` + `self._like_pattern(entity)`;B23 先 `result = operation(*args)` 成功后再自增;B13 在 `core/temporal_context.py` 新增公共 `local_now(timezone_name=DEFAULT_TIMEZONE)`(带时区、非法时区回落 `Asia/Shanghai`),三处调用点统一改走它。
|
||||
- 预防规则:① 任何 LIKE 都必须走转义 helper 并显式带 `ESCAPE`,禁止裸 `%{value}%`;② 成功类计数器只能在被计数的操作真正返回之后自增;③ 记忆侧禁止 naive `datetime.now()`,一律走 `local_now()` 或显式 tz,并用 AST 扫描把这条规则钉死在测试里。
|
||||
- 验证证据:`tests/test_audit_batch1_fixes.py` 的 `EntityLikeEscapeTests`(3 项,含 `_`/`%` 反例与正常 ID 正例)、`DatabaseRecoveryCounterTests`(3 项,含二次失败不计数、成功只计一次、非路径错误不动计数器)、`MemorySideTimezoneTests`(5 项,含 AST 扫描 `core/*.py`+`page_api.py`+`main.py` 无 naive `datetime.now()`);改前/改后 SQL 对照已实测(改前返回 `mem_neighbor`+`mem_underscore`,改后只返回 `mem_underscore`)。
|
||||
|
||||
## 2026-07-26 — 记忆纯测试的 181 项只有 pytest 能收齐
|
||||
|
||||
- 阶段:审计 Batch 1 回归基线
|
||||
- 类型:测试 / 环境
|
||||
- 现象:优化方案 README 写「记忆纯测试(现 181 项)」,但 `python -m unittest` 按模块跑只有 143 项,容易被误判为「测试少了 38 项」。
|
||||
- 根因:`tests/test_archive_contract.py`、`test_bot_personal_memory.py`、`test_q6_user_fact_bridge.py`、`test_temporal_context.py` 用的是模块级 `test_*` 函数,`unittest` 只收集 `TestCase` 子类,收不到这些函数。
|
||||
- 修复或规避:以 pytest 收集数为纯测试口径,命令固定为 `python -m pytest -q --ignore=tests/test_security_cache.py`(`test_security_cache` 导入普通陪伴分支且本机无 AstrBot 宿主包,属环境阻塞不是业务回归);需要 unittest 口径时另记 `TestCase` 计数。
|
||||
- 预防规则:报告里的测试项数必须写清收集器;换收集器前后的数字不可直接相减当成回归。
|
||||
- 验证证据:本轮基线 pytest 181 项通过 / unittest 143 项通过;补测后 pytest 198 项通过 / unittest 160 项通过。
|
||||
|
||||
## 2026-07-26 — 值级隐私模式锚定行首,等于只防了「整条就是路径」
|
||||
|
||||
- 阶段:M6.1.3-R2 记忆侧防御加固(M2)
|
||||
- 类型:隐私 / API契约 / 测试
|
||||
- 现象:`_FORBIDDEN_VALUE_PATTERNS` 的路径模式写成 `^(?:[A-Za-z]:[\/]|/|\\)`,只有「整个字符串就是一条路径」才拦得住。实测 8 类真实写法全部漏过:`data:image/png;base64,...`、`封面图 base64,xxx`、`照片保存在 D:\private\a.png 了`、`\nas\share`、`/home/`、`/tmp/`、`/volume1/`、`-----BEGIN RSA PRIVATE KEY-----`。合同第 130 行明写禁止 Base64、媒体二进制和任意本机绝对路径,所以这不是纵深防御的可选项,是合同缺口。
|
||||
- 根因:写模式时脑子里的样本是「字段值 = 路径」,而真实 payload 里路径几乎总是嵌在中文句子中间。另一边陪伴侧 `_looks_sensitive_value()` 早就用了 `(?:^|[\s=])` 中缀写法,两侧从未对照过。
|
||||
- 修复或规避:保留原前缀模式(本侧 `^/` 比陪伴侧更严,不能退),新增中缀路径、`base64,`、`data:` URI、`-----begin ` 四条,与陪伴侧对齐。`clean_text()` 在匹配前已把空白折叠成单空格,因此 `(?:^|[\s=])` 不存在换行绕过。全部复用 `privacy_rejected`,capability 的 25 码清单无需变动。
|
||||
- 预防规则:值级敏感检测一律按「嵌在自然语言里」设计,禁止只写 `^` 锚定;双方各有一份检测规则时,要有一个直接对照两份规则的用例,而不是各自测各自的。误杀同样要钉死:正常中文句子、`docs/a.md`、`./x`、`https://` 必须有反例测试。
|
||||
- 验证证据:`tests/test_m6_r2_real_dto_shape.py` 14 条正例(全部 `privacy_rejected`)+ 9 条反例(全部写入成功);逐条对比 R1 四模式与 R2 八模式,8 类漏检全部转为拦截,正常文本仍不误杀;记忆侧 243 项、联合 E2E 90 项通过。
|
||||
|
||||
## 2026-07-26 — 兼容回归要用调用方真实序列化输出,不是自造夹具(执行记录)
|
||||
|
||||
- 阶段:M6.1.3-R2 记忆侧回归(M1)
|
||||
- 类型:测试 / API契约
|
||||
- 现象:承接上一条同名预防规则。本轮落地时确认,本仓 `tests/test_bot_personal_memory.py` 的 `envelope_payload()` 恒在 payload 里塞满 date/window/occurred_at,而陪伴真实 DTO 是「信封字段走 kwarg、body 里根本没有 date」的两层结构;两种形状连字段位置都不同,自造夹具再全也测不到真实链路。另外 `test_non_five_legacy_types_keep_explicit_truth_mapping` 只覆盖 6 类,`bot_calendar_event` 从未被测过——而它正是 E2E L 组失败的五个 kind 之一。
|
||||
- 根因:提供方写兼容测试时按自己的 API 签名造夹具,没有拿调用方的实际输出做样本。
|
||||
- 修复或规避:新增 `tests/test_m6_r2_real_dto_shape.py`:能拿到陪伴仓时直接 import 它真实的 `build_bot_personal_dto`(该模块只依赖标准库,可独立载入)跑 7 类;拿不到时退回逐字复刻的真实形状样本,两条路径都保证 body 里没有 date。补齐 `bot_calendar_event`,并加一条断言把覆盖集合钉在 `BOT_PERSONAL_TYPE_CONTRACTS` 减严格五类上,防止以后新增类型漏测。
|
||||
- 预防规则:跨插件兼容回归必须包含调用方真实序列化输出样本;「覆盖了哪几类」这种事要用集合断言钉住,不能靠人肉核对清单。
|
||||
- 验证证据:`tests/test_m6_r2_real_dto_shape.py` 45 项通过(含 7 类真实 DTO + 7 类复刻样本 + calendar_event 专项 + date 空/非法/naive occurred_at 三条「不放松校验」);记忆侧总计 243 项通过,`compileall` 通过。
|
||||
|
||||
## 2026-07-27 — 滚动升级窗口里,payload 形状变化就是一次静默数据丢失
|
||||
|
||||
- 阶段:M6.1.4 分域与形状归一
|
||||
- 类型:API契约 / 部署 / 测试
|
||||
- 现象:陪伴侧把非五类的通用回退从「整包送 envelope」改成「送 body」。两种形状剥离信封字段后内容其实等价,但指纹不同——整包形状剥完只剩 `{"payload": {...}}`,body 形状剥完是 `{...}`。双插件是分别部署的(M6.1.8 明确先记忆后陪伴),升级窗口里同一条记录会先后以两种形状到达,第二次必然 `version_conflict` → 永久错 → 死信。另外发现 `created_at`/`updated_at` 不在剥离清单里,它们随墙钟漂移,同一条记录隔一小时重投就变 `version_conflict`。
|
||||
- 根因:剥离清单是按「验证需要哪些字段」列的,不是按「哪些是信封字段」列的,于是漏了一批只在整包形状下才会出现的键。归一化顺序也有坑:必须**先解包再剥离**,反过来内层的 `source_refs` 会留在 body 里,两种形状仍然对不上。
|
||||
- 修复或规避:提取 `BOT_PERSONAL_ENVELOPE_KEYS`(17 个)作为唯一事实源;`record_bot_personal_memory` 先判断「除 payload 外全是信封字段」再解包,然后统一剥离。两种形状因此产生同一个指纹,旧版陪伴仍可写入。
|
||||
- 预防规则:接收方的兼容性不能只保证「旧形状不报错」,还要保证「旧形状与新形状指纹一致」——否则升级窗口里的重投会被当成内容冲突。凡是分别部署的两个组件,改动线上载荷形状时必须补一条「新旧形状互认」的回归。
|
||||
- 验证证据:`tests/test_m6_r2_real_dto_shape.py::test_whole_envelope_shape_stays_backward_compatible`(两种形状 → `deduplicated`)与 `test_envelope_timestamps_do_not_drift_the_fingerprint`;联合 E2E 101 项全通过。
|
||||
|
||||
## 2026-07-27 — 域索引的前缀顺序决定了它对分类型检索毫无用处
|
||||
|
||||
- 阶段:M6.1.4 创作/媒体/主观独立索引
|
||||
- 类型:性能 / 数据模型
|
||||
- 现象:`idx_memories_domain` 是 `(memory_domain, lifecycle, scope, group_id, subject_id)`。而创作/媒体/主观的检索形态是「域内按 `memory_type` 过滤、按时间倒序取最近若干条」,`memory_type` 不在索引前缀里,这类查询只能退化成域内全扫描。索引存在,但对这条路径完全用不上。
|
||||
- 根因:索引是按「Bot 域 vs 用户域」的隔离需求建的,没有按后续 Profile 检索的实际形态复核过;有索引这件事本身容易让人以为已经覆盖。
|
||||
- 修复或规避:新增 `idx_memories_domain_type_time (memory_domain, memory_type, occurred_at DESC)`,匹配「域 + 类型 + 时间倒序」这一形态。M6.1.5 的 Bot Profiles 全部走这条。
|
||||
- 预防规则:加索引前先写出目标查询的 WHERE + ORDER BY,再对照索引前缀逐列核;「表上已经有索引」不能作为「这条查询走了索引」的证据。
|
||||
- 验证证据:`tests/test_m6_r4_creative_media_domain.py::test_domain_type_time_index_exists` 与分类型过滤三项。
|
||||
|
||||
## 2026-07-27 — 「先按时间倒序取 N 条,再在内存里筛时间窗」等于把历史查询废掉
|
||||
|
||||
- 阶段:M6.1.5 Bot 专用检索 Profiles
|
||||
- 类型:数据模型 / 性能 / 测试
|
||||
- 现象:`bot_schedule_history` 上线即静默返回空。实现是 `list_memories(limit=N)` 再在 Python 里按时间窗过滤,而 `list_memories` 本身按 `occurred_at DESC` 排序截断——只要近期记录够多,落在「1 到 90 天前」这个窗口里的行根本进不了那 N 条结果集。单元测试里数据少,怎么测都是对的;联合 E2E 因为前面各组已经积累了大量当天记录,一跑就空。
|
||||
- 根因:把「范围约束」和「取前 N 条」的顺序搞反了。SQL 的 LIMIT 作用在排序之后,任何写在 Python 里的后置过滤都是在一个已经被截断的集合上做的。
|
||||
- 修复或规避:新增 `list_bot_profile_memories()`,把域、类型、`occurred_at` 区间全部放进 WHERE,走 M6.1.4 建的 `idx_memories_domain_type_time`;Python 侧只保留精确边界判定。补 `test_many_recent_records_do_not_starve_the_history_profile`(60 条当天记录 + 1 条三天前)钉死。
|
||||
- 预防规则:凡是「过滤条件 + LIMIT」的查询,过滤必须进 SQL;在内存里后筛只有在「先取全量」时才等价。这类 bug 在小数据集上永远测不出来,回归用例必须显式构造「近期记录远多于 limit」的场景。
|
||||
- 验证证据:`tests/test_m6_r5_bot_profiles.py` 28 项;联合 E2E S 组「历史 Profile 只给过去内容,不含当天」。
|
||||
|
||||
## 2026-07-27 — 检索 Profile 的价值全在「调用方改不了」
|
||||
|
||||
- 阶段:M6.1.5 Profile 契约
|
||||
- 类型:API契约 / 隐私
|
||||
- 现象:改造前只有一个 `search_bot_personal_memory(query, limit, memory_types)`,类型和条数都由调用方传。陪伴侧的用法是一次性传 11 个类型、limit 5——所谓「Bot 专用检索」实质就是一次全库通用检索,当前状态和历史记忆混在同一批结果里返回。
|
||||
- 根因:把 Profile 理解成「一组默认参数」,而不是「一份调用方改不了的契约」。只要类型、时间窗、条数任意一项可以被调用方覆盖,专用检索就会退化回通用检索。
|
||||
- 修复或规避:`core/bot_profiles.py` 把七件事(域/类型/时间范围/条数/排序/注入字段/权限)全部固定在记忆侧;调用方只能选 Profile 名,`limit` 只能往小调不能往大调;注入字段走白名单投影,`serialize_memory` 带出的人格权重、指纹、幂等键一律不出现在结果里;capability 公布契约,两侧不必各自猜测限制。
|
||||
- 预防规则:给出「专用入口」时,先列清楚哪些维度必须由提供方固定;每个维度都要有一条「调用方试图突破 → 被夹住」的测试,否则契约只是文档里的一句话。
|
||||
- 验证证据:`test_every_profile_pins_all_seven_dimensions`、`test_limit_can_be_lowered_but_not_raised`、`test_projection_drops_internal_fields`、`test_profiles_never_return_user_memories`;联合 E2E S 组 13 项。
|
||||
|
|
|
|||
40
docs/错题本.md
40
docs/错题本.md
|
|
@ -200,3 +200,43 @@
|
|||
- 修复或规避:新增只读 `knowledge_graph_observation()` 数据合同和观察窗;复用 GET `/graph`,返回统计、节点、关系和 `readonly=true`,前端只渲染 SVG、统计卡片和详情查看,不增加删除、编辑、合并或写入按钮。
|
||||
- 预防规则:所有可视化观察功能默认只读;任何修改能力必须单独设计 POST 合同、二次确认、审计和回滚,不能从观察图直接派生。
|
||||
- 验证证据:面板回归 `9` 项通过;Node `--check`、Python `py_compile` 通过;临时 SQLite 验证返回 2 个节点、1 条关系和 `readonly=True`。
|
||||
|
||||
## 2026-07-26 — M6.1.3-A Bot 归档可靠写入合同
|
||||
|
||||
- 阶段:M6.1.3-A 记忆侧归档合同、可靠幂等写入和五类 Bridge
|
||||
- 类型:API契约 / 数据隔离 / 测试
|
||||
- 现象:旧 Bot Personal 写入把 payload 拼入 record_id、所有类型统一映射为 bot_action,通用 SQLite UPSERT 可静默覆盖乱序版本,递归隐私清洗也会静默丢弃字段。
|
||||
- 根因:此前只有逻辑域和类型骨架,没有独立的 envelope 校验、版本竞争和 Bot 专用原子写入路径。
|
||||
- 修复或规避:冻结 capability/payload schema 1.0;record_id 只由域、类型和幂等键生成;新增同键去重、新版本更新、旧版本拒绝和同版本冲突;五类类型固化真实性;递归拒绝敏感字段、完整聊天、凭据、Base64、媒体二进制和本机路径;写入强制 bot_self_schedule 与 bot_self。
|
||||
- 预防规则:任何 Bridge 能力只有在返回合同、错误码、版本竞争和隐私拒绝均有测试后才可声明 FROZEN;计划不得复用 observed/bot_action 默认值。
|
||||
- 验证证据:M6.1.3-A 定向 9 项通过;OPS 纯测试 143 项通过;compileall 通过;git diff --check 通过;共享合同已更新为 FROZEN。
|
||||
|
||||
## 2026-07-26 — Envelope 校验不能只检查非空和 body payload
|
||||
|
||||
- 阶段:M6.1.3 联合审查
|
||||
- 类型:API契约 / 数据完整性 / 测试
|
||||
- 现象:非法日期、窗口和时间可落库;同版本只改变 source_refs/window/certainty 会被去重;20KB 字符串被静默截断后接受。
|
||||
- 根因:时间字段只做非空校验,fingerprint 未覆盖完整 Envelope,字符串在大小检查前被截断。
|
||||
- 修复或规避:R1 增加严格格式和枚举校验、canonical Envelope fingerprint、原始大小检查和超限拒绝。
|
||||
- 预防规则:幂等比较必须覆盖所有持久化语义字段;任何合同声明“拒绝”的数据都不得通过预处理静默变形后落库。
|
||||
- 验证证据:联合审查最小复现已分别得到 `ok=true`、`deduplicated=true` 和落库 4000 字符结果。
|
||||
|
||||
## 2026-07-26 — M6.1.3-R1 联合审查阻断修复
|
||||
|
||||
- 阶段:R1 记忆侧严格字段、canonical fingerprint、超限拒绝和兼容回归
|
||||
- 类型:API契约 / 数据隔离 / 测试
|
||||
- 现象:联合审查复现出非法日期、非法窗口、无时区时间可写入;20KB 字符串被静默截断;fingerprint 未覆盖 Envelope;plan 允许非 L0;旧 creative/media/subjective/shared 类型会落入 observed;部分运行错误码未声明。
|
||||
- 根因:第一版只完成 Bot 域和幂等骨架,没有把 FROZEN Envelope 的所有语义字段统一送入验证与 canonical fingerprint,非五类类型也使用了过宽默认合同。
|
||||
- 修复或规避:增加严格日期/窗口/时区解析;原始 JSON payload 先验大小再清洗;fingerprint 覆盖 payload、日期、窗口、发生时间、来源、确定性、证据等级、状态、版本、幂等键、schema 和 source_kind;plan 强制 L0;非五类恢复显式真实性和兼容 wrapper;错误码与 capability/共享合同同步。
|
||||
- 预防规则:FROZEN 合同的每个落库语义字段都必须有单独变化冲突测试;任何清洗前截断都视为数据完整性风险;旧能力不能用 observed 兜底。
|
||||
- 验证证据:R1 定向 15 项通过;OPS 纯测试 143 项通过;compileall 和 git diff --check 通过;共享合同字段规范仍为 FROZEN 1.0,实施验收保持 REOPEN_REQUIRED。
|
||||
|
||||
## 2026-07-26 — M6.1.3-R2 非五类回归与值级隐私加固
|
||||
|
||||
- 阶段:R2 记忆侧真实调用方形状回归 + 值级隐私加固(本侧不放松任何校验)
|
||||
- 类型:API契约 / 隐私 / 测试
|
||||
- 现象:R1 说「旧 creative/media/subjective/shared 类型不再落入 observed」,本仓测试也确实全绿——但真实链路上五个旧 kind 全被 `invalid_date` 拒绝。根因在陪伴侧 DTO 不派生 date,而本侧测不出来,是因为 `envelope_payload()` 夹具恒在 payload 里塞满 date/window/occurred_at,形状与调用方真实输出(信封字段走 kwarg、body 里没有 date)根本不同。另外 `_FORBIDDEN_VALUE_PATTERNS` 的路径模式 `^` 锚定,只防「整条就是路径」,句子中间的 `D:\...`、`/home/...`、`base64,`、`data:` URI 全部漏过——而合同第 130 行明写禁止这些,属合同缺口而非可选加固。
|
||||
- 根因:提供方按自己的 API 签名造夹具,没拿调用方实际输出当样本;敏感模式按「字段值 = 敏感值」设计,没按「敏感值嵌在自然语言里」设计。两处都因对端恰好有补偿(陪伴侧先拦、合同强制覆盖 source_kind)而长期看不出来。
|
||||
- 修复或规避:新增 `tests/test_m6_r2_real_dto_shape.py`——优先 import 陪伴仓真实的 `build_bot_personal_dto` 产出信封,拿不到时退回逐字复刻样本,两条路径 body 里都没有 date;补齐 R1 漏测的 `bot_calendar_event`,并用集合断言把覆盖范围钉在 `BOT_PERSONAL_TYPE_CONTRACTS` 减严格五类上。`_FORBIDDEN_VALUE_PATTERNS` 由 4 条增至 8 条(保留原前缀模式,新增中缀路径 / `base64,` / `data:` URI / `-----begin `)。date 校验一字未改,`date=""`、`2026-13-45`、naive `occurred_at` 三条负例钉死。
|
||||
- 预防规则:跨插件兼容回归必须包含调用方真实序列化输出样本,禁止只用提供方自造夹具;值级敏感检测一律按中缀设计并配反例防误杀;「覆盖了哪几类」要用集合断言钉住,不能靠人肉核对。
|
||||
- 验证证据:新增 45 项通过;记忆侧总计 243 项通过;`compileall` 通过;无新增错误码(全部复用 `privacy_rejected`,capability 25 码不变);联合 E2E 90 项全通过、非五类 7/7;实施验收由 `REOPEN_REQUIRED` 转 `LOCAL_ACCEPTED`。
|
||||
|
|
|
|||
92
page_api.py
92
page_api.py
|
|
@ -18,11 +18,13 @@ from zoneinfo import ZoneInfo
|
|||
from quart import jsonify, request, send_file
|
||||
|
||||
try:
|
||||
from .core.bot_profiles import describe_bot_profiles
|
||||
from .core.bridge import serialize_memory
|
||||
from .core.identity import normalize_session_context_fields
|
||||
from .core.models import SessionContext, clean_text
|
||||
from .core.user_memory_boundary import USER_MEMORY_DOMAIN
|
||||
except ImportError:
|
||||
from core.bot_profiles import describe_bot_profiles
|
||||
from core.bridge import serialize_memory
|
||||
from core.identity import normalize_session_context_fields
|
||||
from core.models import SessionContext, clean_text
|
||||
|
|
@ -120,6 +122,10 @@ class PluginPageApi:
|
|||
("/import/livingmemory/run", self.import_run, ["POST"], "MemoryCompanion Page import run"),
|
||||
("/persona-state", self.persona_state, ["GET"], "MemoryCompanion Page persona state"),
|
||||
("/acl/matrix", self.acl_matrix, ["GET"], "MemoryCompanion Page ACL matrix"),
|
||||
# M6.1.6:Bot 长期归档只读视图。只读、只出 Bot 域,写入仍走受控归档路径。
|
||||
("/bot-archive/profiles", self.bot_archive_profiles, ["GET"], "MemoryCompanion Bot archive profile contracts (M6.1.6)"),
|
||||
("/bot-archive/query", self.bot_archive_query, ["GET"], "MemoryCompanion Bot archive read-only query (M6.1.6)"),
|
||||
("/bot-archive/locked-frame", self.bot_archive_locked_frame, ["GET"], "MemoryCompanion Locked Frame personal DTO (M6.1.6)"),
|
||||
]
|
||||
for prefix in PAGE_API_PREFIXES:
|
||||
for route, handler, methods, desc in routes:
|
||||
|
|
@ -421,6 +427,49 @@ class PluginPageApi:
|
|||
bucket.pop("pending_count", None)
|
||||
return self._ok({"buckets": buckets})
|
||||
|
||||
# ---- M6.1.6 Bot 长期归档只读视图 ----
|
||||
# 页面只调这三个端点读 Bot 归档,不碰 /memories 那套通用入口——通用入口按域/类型自由过滤,
|
||||
# 既拿不到 Profile 的时间窗与字段白名单,也没法保证「用户域绝不混入」。
|
||||
|
||||
async def bot_archive_profiles(self):
|
||||
"""公布 Profile 契约,页面据此渲染分区,不必自己猜类型和条数。"""
|
||||
return self._ok({
|
||||
"data_source": "memory_archive",
|
||||
"source_plugin": "memory_companion",
|
||||
"read_only": True,
|
||||
"profiles": describe_bot_profiles(),
|
||||
})
|
||||
|
||||
async def bot_archive_query(self):
|
||||
profile = clean_text(request.args.get("profile", ""), 80)
|
||||
query = clean_text(request.args.get("q", ""), 200)
|
||||
limit = self._query_int("limit", 0)
|
||||
result = await self.plugin.service.search_bot_personal_profile(
|
||||
profile, query, limit=limit or None)
|
||||
return self._ok({
|
||||
"data_source": "memory_archive",
|
||||
"source_plugin": "memory_companion",
|
||||
**result,
|
||||
})
|
||||
|
||||
async def bot_archive_locked_frame(self):
|
||||
"""Locked Frame 人格连续性 DTO:近期全类型少量取样,按类型分组便于页面直接渲染。"""
|
||||
result = await self.plugin.service.search_bot_personal_profile(
|
||||
"locked_frame_personal", clean_text(request.args.get("q", ""), 200))
|
||||
grouped: dict[str, list[dict[str, Any]]] = {}
|
||||
for item in result.get("memories", []):
|
||||
grouped.setdefault(str(item.get("memory_type") or "unknown"), []).append(item)
|
||||
return self._ok({
|
||||
"data_source": "memory_archive",
|
||||
"source_plugin": "memory_companion",
|
||||
"read_only": True,
|
||||
"profile": result.get("profile"),
|
||||
"memory_domain": result.get("memory_domain"),
|
||||
"groups": grouped,
|
||||
"total": len(result.get("memories", [])),
|
||||
"warnings": result.get("warnings", []),
|
||||
})
|
||||
|
||||
async def memories(self):
|
||||
limit = self._query_int("limit", 50)
|
||||
query = clean_text(request.args.get("q", ""), 200)
|
||||
|
|
@ -456,17 +505,36 @@ class PluginPageApi:
|
|||
payload["content_fingerprint"] = record.content_fingerprint
|
||||
return self._ok({"memory": payload})
|
||||
|
||||
async def memory_update(self):
|
||||
payload = await self._json()
|
||||
memory_id = clean_text(payload.get("id"), 120)
|
||||
async def _reject_if_bot_domain(self, memory_id: str, action: str):
|
||||
"""M6.1.7-3:Bot 域记录不接受通用写入,只能走受控归档路径。
|
||||
|
||||
受控路径带幂等键、版本、指纹和隐私校验;从这里带外改一条 Bot 记录,
|
||||
不仅绕过全部校验,还会让它的 payload_fingerprint 变陈——下一次正常归档
|
||||
同一个幂等键就会撞 version_conflict(永久错)直接进死信,归档链路从此静默失效。
|
||||
|
||||
返回错误响应表示应当拒绝;返回 None 表示放行。
|
||||
"""
|
||||
if not memory_id:
|
||||
return self._err("missing id", 400)
|
||||
record = await self.plugin.service.store.get_memory(memory_id)
|
||||
if not record:
|
||||
return self._err("memory not found", 404)
|
||||
domain = clean_text(getattr(record, "memory_domain", ""), 60)
|
||||
if domain and domain != USER_MEMORY_DOMAIN:
|
||||
logger.warning("[MemoryCompanionPage] 拒绝对非用户域记录的通用%s: id=%s domain=%s", action, memory_id, domain)
|
||||
return self._err(f"non_user_memory_{action}_locked", 409)
|
||||
return None
|
||||
|
||||
async def memory_update(self):
|
||||
payload = await self._json()
|
||||
memory_id = clean_text(payload.get("id"), 120)
|
||||
rejection = await self._reject_if_bot_domain(memory_id, "update")
|
||||
if rejection is not None:
|
||||
return rejection
|
||||
record = await self.plugin.service.store.get_memory(memory_id)
|
||||
requested_visibility = clean_text(payload.get("visibility"), 40)
|
||||
if getattr(record, "memory_domain", "") != USER_MEMORY_DOMAIN and requested_visibility not in {"", "internal"}:
|
||||
return self._err("non_user_memory_visibility_locked", 409)
|
||||
if not memory_id:
|
||||
return self._err("missing id", 400)
|
||||
ok = await self.plugin.service.store.update_memory_payload(
|
||||
memory_id,
|
||||
memory_type=payload.get("memory_type"),
|
||||
|
|
@ -483,12 +551,18 @@ class PluginPageApi:
|
|||
|
||||
async def memory_delete(self):
|
||||
payload = await self._json()
|
||||
ok = await self.plugin.service.store.delete_memory(clean_text(payload.get("id"), 120))
|
||||
memory_id = clean_text(payload.get("id"), 120)
|
||||
rejection = await self._reject_if_bot_domain(memory_id, "delete")
|
||||
if rejection is not None:
|
||||
return rejection
|
||||
ok = await self.plugin.service.store.delete_memory(memory_id)
|
||||
return self._ok({"deleted": ok})
|
||||
|
||||
async def memory_visibility(self):
|
||||
payload = await self._json()
|
||||
memory_id = clean_text(payload.get("id"), 120)
|
||||
if not memory_id:
|
||||
return self._err("missing id", 400)
|
||||
record = await self.plugin.service.store.get_memory(memory_id)
|
||||
if not record:
|
||||
return self._err("memory not found", 404)
|
||||
|
|
@ -503,8 +577,12 @@ class PluginPageApi:
|
|||
|
||||
async def memory_lifecycle(self):
|
||||
payload = await self._json()
|
||||
memory_id = clean_text(payload.get("id"), 120)
|
||||
rejection = await self._reject_if_bot_domain(memory_id, "lifecycle")
|
||||
if rejection is not None:
|
||||
return rejection
|
||||
ok = await self.plugin.service.store.update_memory_lifecycle(
|
||||
clean_text(payload.get("id"), 120),
|
||||
memory_id,
|
||||
clean_text(payload.get("lifecycle"), 40),
|
||||
)
|
||||
return self._ok({"updated": ok})
|
||||
|
|
|
|||
340
tests/test_audit_batch1_fixes.py
普通文件
340
tests/test_audit_batch1_fixes.py
普通文件
|
|
@ -0,0 +1,340 @@
|
|||
"""OPS 源码审计 Batch 1(记忆侧)定向回归。
|
||||
|
||||
覆盖 B12(未转义 LIKE)、B21(域判定常量单一来源)、B23(恢复成功计数)、
|
||||
B13(记忆侧时区统一为带时区)。
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import ast
|
||||
import sqlite3
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
if str(ROOT.parent) not in sys.path:
|
||||
sys.path.insert(0, str(ROOT.parent))
|
||||
|
||||
from core import models, service as service_module, user_memory_boundary as boundary
|
||||
from core.models import EntityRef, MemoryRecord
|
||||
from core.store import MemoryStore
|
||||
from core.temporal_context import local_now
|
||||
from core.user_memory_boundary import UserMemoryBoundaryError, infer_memory_domain, validate_user_memory_record
|
||||
|
||||
|
||||
def make_store(test: unittest.TestCase) -> MemoryStore:
|
||||
temp_dir = tempfile.TemporaryDirectory()
|
||||
test.addCleanup(temp_dir.cleanup)
|
||||
store = MemoryStore(Path(temp_dir.name) / "memory.db")
|
||||
store.initialize()
|
||||
test.addCleanup(store.close)
|
||||
return store
|
||||
|
||||
|
||||
def user_memory(memory_id: str, *, user_id: str, session_id: str, content: str) -> MemoryRecord:
|
||||
return MemoryRecord(
|
||||
id=memory_id,
|
||||
memory_type="user_fact",
|
||||
memory_domain="user_memory",
|
||||
subject=EntityRef(kind="user", id=user_id, name=user_id),
|
||||
object=EntityRef.bot_self(),
|
||||
scope="private",
|
||||
session_id=session_id,
|
||||
platform="qq",
|
||||
message_id=f"msg-{memory_id}",
|
||||
visibility="private_pair",
|
||||
lifecycle="stable_memory",
|
||||
content=content,
|
||||
evidence=content,
|
||||
)
|
||||
|
||||
|
||||
class EntityLikeEscapeTests(unittest.IsolatedAsyncioTestCase):
|
||||
"""B12 · core/store.py 的 entity_id 过滤必须转义 LIKE 通配符。"""
|
||||
|
||||
async def test_underscore_in_entity_id_does_not_match_other_sessions(self) -> None:
|
||||
store = make_store(self)
|
||||
await store.insert_memory(
|
||||
user_memory("mem_underscore", user_id="u_1", session_id="qq:FriendMessage:u_1", content="下划线用户的记忆。")
|
||||
)
|
||||
await store.insert_memory(
|
||||
user_memory("mem_neighbor", user_id="uX1", session_id="qq:FriendMessage:uX1", content="另一个会话的记忆。")
|
||||
)
|
||||
|
||||
rows = await store.list_memories(entity_id="u_1", limit=50)
|
||||
|
||||
self.assertEqual({"mem_underscore"}, {row.id for row in rows})
|
||||
|
||||
async def test_percent_in_entity_id_does_not_match_other_sessions(self) -> None:
|
||||
store = make_store(self)
|
||||
await store.insert_memory(
|
||||
user_memory("mem_percent", user_id="a%b", session_id="qq:FriendMessage:a%b", content="百分号用户的记忆。")
|
||||
)
|
||||
await store.insert_memory(
|
||||
user_memory("mem_wildcard", user_id="aQQb", session_id="qq:FriendMessage:aQQb", content="不应被通配命中的记忆。")
|
||||
)
|
||||
|
||||
rows = await store.list_memories(entity_id="a%b", limit=50)
|
||||
|
||||
self.assertEqual({"mem_percent"}, {row.id for row in rows})
|
||||
|
||||
async def test_exact_entity_id_still_matches_by_session_suffix(self) -> None:
|
||||
store = make_store(self)
|
||||
await store.insert_memory(
|
||||
user_memory("mem_plain", user_id="995051631", session_id="qq:FriendMessage:995051631", content="普通用户的记忆。")
|
||||
)
|
||||
|
||||
rows = await store.list_memories(entity_id="995051631", limit=50)
|
||||
|
||||
self.assertEqual({"mem_plain"}, {row.id for row in rows})
|
||||
|
||||
|
||||
class DatabaseRecoveryCounterTests(unittest.TestCase):
|
||||
"""B23 · 恢复成功计数只能在重试真正成功后自增。"""
|
||||
|
||||
@staticmethod
|
||||
def path_error() -> sqlite3.OperationalError:
|
||||
return sqlite3.OperationalError("unable to open database file")
|
||||
|
||||
def test_second_failure_is_not_counted_as_recovery_success(self) -> None:
|
||||
store = make_store(self)
|
||||
calls: list[int] = []
|
||||
|
||||
def always_fail(*_args: object) -> object:
|
||||
calls.append(1)
|
||||
raise self.path_error()
|
||||
|
||||
with self.assertRaises(sqlite3.OperationalError):
|
||||
store._run_with_database_recovery_sync(always_fail)
|
||||
|
||||
self.assertEqual(2, len(calls), "首次执行 + 恢复后重试各一次")
|
||||
self.assertEqual(1, store._database_recovery_attempts)
|
||||
self.assertEqual(0, store._database_recovery_successes)
|
||||
|
||||
def test_successful_retry_counts_once(self) -> None:
|
||||
store = make_store(self)
|
||||
state = {"calls": 0}
|
||||
|
||||
def fail_once(*_args: object) -> str:
|
||||
state["calls"] += 1
|
||||
if state["calls"] == 1:
|
||||
raise self.path_error()
|
||||
return "ok"
|
||||
|
||||
self.assertEqual("ok", store._run_with_database_recovery_sync(fail_once))
|
||||
self.assertEqual(1, store._database_recovery_attempts)
|
||||
self.assertEqual(1, store._database_recovery_successes)
|
||||
|
||||
def test_non_path_error_is_reraised_without_touching_counters(self) -> None:
|
||||
store = make_store(self)
|
||||
|
||||
def other_failure(*_args: object) -> object:
|
||||
raise sqlite3.OperationalError("no such table: memories")
|
||||
|
||||
with self.assertRaises(sqlite3.OperationalError):
|
||||
store._run_with_database_recovery_sync(other_failure)
|
||||
|
||||
self.assertEqual(0, store._database_recovery_attempts)
|
||||
self.assertEqual(0, store._database_recovery_successes)
|
||||
|
||||
|
||||
class MemoryDomainConstantSourceTests(unittest.TestCase):
|
||||
"""B21 · 域判定集合只有一份来源,且用户记忆写入门禁不放松。"""
|
||||
|
||||
def test_boundary_reexports_the_same_frozensets_as_models(self) -> None:
|
||||
self.assertIs(models.BOT_SELF_MEMORY_TYPES, boundary.BOT_SELF_MEMORY_TYPES)
|
||||
self.assertIs(models.BOT_SELF_REALITY_LEVELS, boundary.BOT_SELF_REALITY_LEVELS)
|
||||
self.assertIs(models.USER_MEMORY_TYPES, boundary.USER_MEMORY_TYPES)
|
||||
self.assertIs(models.USER_MEMORY_WRITE_BLOCKED_TYPES, boundary.USER_MEMORY_WRITE_BLOCKED_TYPES)
|
||||
|
||||
def test_models_no_longer_inlines_domain_type_literals(self) -> None:
|
||||
source = (ROOT / "core" / "models.py").read_text(encoding="utf-8-sig")
|
||||
tree = ast.parse(source)
|
||||
ensure_defaults = next(
|
||||
node
|
||||
for node in ast.walk(tree)
|
||||
if isinstance(node, ast.FunctionDef) and node.name == "ensure_defaults"
|
||||
)
|
||||
inlined = [
|
||||
element.value
|
||||
for node in ast.walk(ensure_defaults)
|
||||
if isinstance(node, ast.Set)
|
||||
for element in node.elts
|
||||
if isinstance(element, ast.Constant)
|
||||
]
|
||||
self.assertEqual([], inlined, "ensure_defaults 不得再内联域判定类型清单")
|
||||
|
||||
def test_ensure_defaults_and_infer_agree_on_bot_self_types(self) -> None:
|
||||
for memory_type in sorted(models.BOT_SELF_MEMORY_TYPES):
|
||||
with self.subTest(memory_type=memory_type):
|
||||
record = MemoryRecord(
|
||||
memory_type=memory_type,
|
||||
memory_domain="",
|
||||
subject=EntityRef(kind="user", id="u1"),
|
||||
)
|
||||
record.ensure_defaults()
|
||||
# calendar_event 由更前置的日历分支接管(B10 另行确认意图)。
|
||||
expected = "calendar_history" if memory_type == "calendar_event" else "bot_self_legacy"
|
||||
self.assertEqual(expected, record.memory_domain)
|
||||
|
||||
probe = MemoryRecord(
|
||||
memory_type=memory_type,
|
||||
memory_domain="",
|
||||
subject=EntityRef(kind="user", id="u1"),
|
||||
)
|
||||
self.assertEqual("bot_self_legacy", infer_memory_domain(probe))
|
||||
|
||||
def test_decay_summary_domain_follows_source_records_not_bot_self(self) -> None:
|
||||
record = MemoryRecord(
|
||||
memory_type="memory_decay_summary",
|
||||
memory_domain="",
|
||||
subject=EntityRef(kind="user", id="u1"),
|
||||
reality_level="llm_summary",
|
||||
)
|
||||
record.ensure_defaults()
|
||||
self.assertEqual("user_memory", record.memory_domain)
|
||||
self.assertEqual(
|
||||
record.memory_domain,
|
||||
infer_memory_domain(
|
||||
MemoryRecord(
|
||||
memory_type="memory_decay_summary",
|
||||
memory_domain="",
|
||||
subject=EntityRef(kind="user", id="u1"),
|
||||
reality_level="llm_summary",
|
||||
)
|
||||
),
|
||||
"两个分类器对衰减总结必须给出同一个域",
|
||||
)
|
||||
|
||||
def test_decay_summary_is_still_rejected_by_the_user_memory_write_gate(self) -> None:
|
||||
record = MemoryRecord(
|
||||
memory_type="memory_decay_summary",
|
||||
memory_domain="user_memory",
|
||||
subject=EntityRef(kind="user", id="u1"),
|
||||
object=EntityRef.bot_self(),
|
||||
scope="private",
|
||||
session_id="qq:FriendMessage:u1",
|
||||
message_id="msg-1",
|
||||
visibility="private_pair",
|
||||
reality_level="llm_summary",
|
||||
content="衰减总结正文。",
|
||||
evidence="来源片段。",
|
||||
)
|
||||
|
||||
with self.assertRaises(UserMemoryBoundaryError) as caught:
|
||||
validate_user_memory_record(record)
|
||||
|
||||
self.assertEqual("bot_self_memory_type:memory_decay_summary", caught.exception.reason)
|
||||
|
||||
def test_memory_domain_default_is_not_empty_so_classification_needs_explicit_reset(self) -> None:
|
||||
# 记录既有陷阱:memory_domain 默认 "unknown" 为真值,
|
||||
# ensure_defaults 的分类分支只在调用方显式传 "" 时才会执行。
|
||||
self.assertEqual("unknown", MemoryRecord().memory_domain)
|
||||
untouched = MemoryRecord(memory_type="user_fact", subject=EntityRef(kind="user", id="u1"))
|
||||
untouched.ensure_defaults()
|
||||
self.assertEqual("unknown", untouched.memory_domain)
|
||||
|
||||
|
||||
class MemorySideTimezoneTests(unittest.TestCase):
|
||||
"""B13 · 记忆侧时钟必须带时区,容器 TZ 不能改变分桶与时段判定。"""
|
||||
|
||||
def test_local_now_is_timezone_aware_and_uses_configured_zone(self) -> None:
|
||||
now = local_now()
|
||||
self.assertIsNotNone(now.tzinfo)
|
||||
expected = datetime.now(timezone.utc).astimezone(ZoneInfo("Asia/Shanghai"))
|
||||
self.assertEqual(expected.utcoffset(), now.utcoffset())
|
||||
self.assertEqual(expected.date(), now.date())
|
||||
self.assertEqual(expected.hour, now.hour)
|
||||
|
||||
def test_local_now_falls_back_when_timezone_name_is_invalid(self) -> None:
|
||||
now = local_now(timezone_name="Not/AZone")
|
||||
self.assertIsNotNone(now.tzinfo)
|
||||
self.assertEqual(datetime.now(ZoneInfo("Asia/Shanghai")).utcoffset(), now.utcoffset())
|
||||
|
||||
def test_no_naive_datetime_now_call_remains_in_memory_plugin(self) -> None:
|
||||
targets = sorted((ROOT / "core").glob("*.py")) + [ROOT / "page_api.py", ROOT / "main.py"]
|
||||
offenders: list[str] = []
|
||||
for path in targets:
|
||||
tree = ast.parse(path.read_text(encoding="utf-8-sig"))
|
||||
for node in ast.walk(tree):
|
||||
if (
|
||||
isinstance(node, ast.Call)
|
||||
and isinstance(node.func, ast.Attribute)
|
||||
and node.func.attr == "now"
|
||||
and isinstance(node.func.value, ast.Name)
|
||||
and node.func.value.id == "datetime"
|
||||
and not node.args
|
||||
and not node.keywords
|
||||
):
|
||||
offenders.append(f"{path.name}:{node.lineno}")
|
||||
self.assertEqual([], offenders, "记忆侧不得使用 naive datetime.now()")
|
||||
|
||||
def test_time_of_day_and_rest_check_read_the_local_clock(self) -> None:
|
||||
fixed = datetime(2026, 7, 26, 1, 30, tzinfo=ZoneInfo("Asia/Shanghai"))
|
||||
original = service_module.local_now
|
||||
service_module.local_now = lambda *args, **kwargs: fixed
|
||||
try:
|
||||
self.assertEqual(
|
||||
"late_night",
|
||||
service_module.MemoryCompanionService._compute_time_of_day(object()),
|
||||
)
|
||||
self.assertTrue(service_module.MemoryCompanionService._message_is_short_rest_check("查岗"))
|
||||
finally:
|
||||
service_module.local_now = original
|
||||
|
||||
def test_token_buckets_use_local_day_and_hour_keys(self) -> None:
|
||||
fixed = datetime(2026, 7, 26, 1, 30, tzinfo=ZoneInfo("Asia/Shanghai"))
|
||||
original = service_module.local_now
|
||||
service_module.local_now = lambda *args, **kwargs: fixed
|
||||
try:
|
||||
recorder = _TokenUsageRecorder()
|
||||
service_module.MemoryCompanionService._record_token_usage(
|
||||
recorder,
|
||||
task="unit_test",
|
||||
provider_id="p1",
|
||||
prompt="hello",
|
||||
completion="world",
|
||||
)
|
||||
finally:
|
||||
service_module.local_now = original
|
||||
|
||||
self.assertIn("2026-07-26", recorder._token_usage["by_day"])
|
||||
self.assertIn("2026-07-26T01:00", recorder._token_usage["by_hour"])
|
||||
|
||||
|
||||
class _TokenUsageRecorder:
|
||||
"""只提供 `_record_token_usage` 需要的最小依赖,避免拉起整个服务。"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._token_usage: dict[str, object] = {}
|
||||
self.saved = 0
|
||||
|
||||
def _save_token_usage(self) -> None:
|
||||
self.saved += 1
|
||||
|
||||
def _extract_token_usage(self, *_args: object, **_kwargs: object) -> dict[str, object]:
|
||||
return {
|
||||
"prompt_tokens": 1,
|
||||
"completion_tokens": 1,
|
||||
"total_tokens": 2,
|
||||
"cached_tokens": 0,
|
||||
"cache_read_tokens": 0,
|
||||
"cache_write_tokens": 0,
|
||||
"estimated": True,
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def _safe_int(value: object) -> int:
|
||||
try:
|
||||
return int(value or 0)
|
||||
except (TypeError, ValueError):
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
@ -1,103 +1,283 @@
|
|||
import asyncio
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
|
||||
from core.bridge import MemoryCompanionBridge
|
||||
from core.models import EntityRef, MemoryRecord
|
||||
from core.retrieval import RetrievalEngine
|
||||
from core.service import MemoryCompanionService
|
||||
from core.store import MemoryStore
|
||||
from core.visibility import VisibilityPolicy
|
||||
from core.retrieval import RetrievalEngine
|
||||
|
||||
|
||||
class Config:
|
||||
def __init__(self, enabled=True):
|
||||
self.enabled = enabled
|
||||
|
||||
def bool(self, key, default=True):
|
||||
return self.enabled
|
||||
|
||||
|
||||
def make_service(temp_dir, enabled=True):
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.config = Config(enabled)
|
||||
service.store = MemoryStore(Path(temp_dir) / "memory.db")
|
||||
service.store.initialize()
|
||||
service._schedule_memory_embedding = lambda *args, **kwargs: None
|
||||
return service
|
||||
|
||||
|
||||
def envelope_payload(index=1, **extra):
|
||||
payload = {
|
||||
"date": "2026-07-26",
|
||||
"window": "afternoon",
|
||||
"occurred_at": "2026-07-26T15:00:00+08:00",
|
||||
"source_refs": [f"companion:event:{index}"],
|
||||
"certainty": 0.9,
|
||||
"evidence_level": "L2",
|
||||
"version": 1,
|
||||
"idempotency_key": f"m6.1.3:{index}",
|
||||
"payload_schema_version": "1.0",
|
||||
"summary": "完成一次真实活动摘要",
|
||||
}
|
||||
payload.update(extra)
|
||||
return payload
|
||||
|
||||
|
||||
def write(service, memory_type, payload, **kwargs):
|
||||
return asyncio.run(service.record_bot_personal_memory(memory_type=memory_type, payload=payload, **kwargs))
|
||||
|
||||
|
||||
def test_bot_personal_capability_contract():
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.config = Config()
|
||||
payload = service.bridge_probe_bot_personal_memory_capabilities()
|
||||
assert payload["available"] is True
|
||||
assert payload["memory_domain"] == "bot_self_schedule"
|
||||
assert payload["four_window_schedule"] is True
|
||||
assert payload["user_memory_isolation"] is True
|
||||
assert payload["capability_schema_version"] == "1.0"
|
||||
assert payload["payload_schema_version"] == "1.0"
|
||||
assert set(payload["dedicated_methods"]) == {
|
||||
"record_bot_schedule_plan",
|
||||
"record_bot_observed_activity",
|
||||
"record_bot_schedule_reconciliation",
|
||||
"record_bot_window_snapshot",
|
||||
"record_bot_daily_diary",
|
||||
}
|
||||
|
||||
|
||||
def test_bot_personal_write_forces_domain_and_stable_idempotency():
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
calls = []
|
||||
|
||||
async def fake_record_external_event(**kwargs):
|
||||
calls.append(kwargs)
|
||||
return kwargs["memory_id"]
|
||||
|
||||
service.record_external_event = fake_record_external_event
|
||||
first = asyncio.run(service.record_bot_personal_memory(
|
||||
memory_type="bot_window_snapshot",
|
||||
payload={"date": "2026-07-25", "window": "morning", "source_refs": ["snapshot:1"]},
|
||||
occurred_at="2026-07-25T12:00:00+08:00",
|
||||
idempotency_key="window_snapshot:2026-07-25:morning",
|
||||
))
|
||||
second = asyncio.run(service.record_bot_personal_memory(
|
||||
memory_type="bot_window_snapshot",
|
||||
payload={"date": "2026-07-25", "window": "morning", "source_refs": ["snapshot:1"]},
|
||||
occurred_at="2026-07-25T12:00:00+08:00",
|
||||
idempotency_key="window_snapshot:2026-07-25:morning",
|
||||
))
|
||||
assert first == second
|
||||
assert calls[0]["memory_domain"] == "bot_self_schedule"
|
||||
assert calls[0]["visibility"] == "bot_self"
|
||||
assert calls[0]["session_id"] == "bot_personal"
|
||||
|
||||
|
||||
def test_bot_personal_search_excludes_user_memory():
|
||||
def test_five_types_have_truth_mapping_and_unified_return():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
store = MemoryStore(Path(temp) / "memory.db")
|
||||
store.initialize()
|
||||
store_records = [
|
||||
MemoryRecord(
|
||||
id="bot-1",
|
||||
memory_type="bot_daily_diary",
|
||||
memory_domain="bot_self_schedule",
|
||||
subject=EntityRef.bot_self(),
|
||||
scope="private",
|
||||
session_id="bot_personal",
|
||||
visibility="bot_self",
|
||||
reality_level="persona_life",
|
||||
content="Bot 今天完成了创作。",
|
||||
occurred_at="2026-07-25T21:00:00+08:00",
|
||||
),
|
||||
MemoryRecord(
|
||||
id="user-1",
|
||||
memory_type="user_fact",
|
||||
memory_domain="user_memory",
|
||||
subject=EntityRef(kind="user", id="u1"),
|
||||
scope="private",
|
||||
session_id="private:u1",
|
||||
visibility="private_pair",
|
||||
reality_level="real_user_fact",
|
||||
content="用户也喜欢创作。",
|
||||
),
|
||||
service = make_service(temp)
|
||||
cases = [
|
||||
("bot_schedule_plan", "planned", "planned", "planned"),
|
||||
("bot_observed_activity", "observed", "observed_activity", "observed"),
|
||||
("bot_schedule_reconciliation", "reconciled", "reconciled", "reconciled"),
|
||||
("bot_window_snapshot", "projection", "window_projection", "projection"),
|
||||
("bot_daily_diary", "subjective", "subjective", "subjective"),
|
||||
]
|
||||
for record in store_records:
|
||||
asyncio.run(store.insert_memory(record))
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.store = store
|
||||
results = asyncio.run(service.search_bot_personal_memory("创作", limit=10))
|
||||
assert [item["id"] for item in results] == ["bot-1"]
|
||||
store.close()
|
||||
for index, (memory_type, source_kind, reality_level, expected_kind) in enumerate(cases, 1):
|
||||
payload = envelope_payload(index)
|
||||
if memory_type == "bot_schedule_plan":
|
||||
payload["evidence_level"] = "L0"
|
||||
payload["idempotency_key"] = f"truth:{index}"
|
||||
result = write(service, memory_type, payload)
|
||||
assert result["ok"] is True
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.memory_domain == "bot_self_schedule"
|
||||
assert record.subject.kind == "bot"
|
||||
assert record.metadata["source_kind"] == source_kind == expected_kind
|
||||
assert record.reality_level == reality_level
|
||||
if memory_type == "bot_schedule_plan":
|
||||
assert record.reality_level != "observed_activity"
|
||||
assert record.reality_level != "bot_action"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_default_retrieval_blocks_bot_personal_domain():
|
||||
engine = RetrievalEngine(MemoryStore(Path(tempfile.gettempdir()) / "unused-m6.db"), VisibilityPolicy())
|
||||
assert engine._memory_domain_block_reason(MemoryRecord(memory_domain="bot_self_schedule")) == "missing_user_subject"
|
||||
def test_stable_id_and_idempotent_same_payload():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
payload = envelope_payload(1)
|
||||
first = write(service, "bot_window_snapshot", payload)
|
||||
second = write(service, "bot_window_snapshot", payload)
|
||||
assert first["record_id"] == second["record_id"]
|
||||
assert second["deduplicated"] is True
|
||||
assert second["action"] == "deduplicated"
|
||||
assert first["version"] == second["version"] == 1
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_bridge_missing_bot_personal_write_degrades_explicitly():
|
||||
bridge = MemoryCompanionBridge(object())
|
||||
try:
|
||||
asyncio.run(bridge.record_bot_personal_memory(
|
||||
memory_type="bot_daily_diary",
|
||||
payload={"date": "2026-07-25"},
|
||||
idempotency_key="diary:2026-07-25",
|
||||
))
|
||||
except RuntimeError as exc:
|
||||
assert str(exc) == "bot_personal_memory_unavailable"
|
||||
else:
|
||||
raise AssertionError("missing Bot personal Bridge must fail explicitly")
|
||||
def test_newer_version_updates_same_id_and_stale_version_is_rejected():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
payload = envelope_payload(2)
|
||||
payload["evidence_level"] = "L0"
|
||||
first = write(service, "bot_schedule_plan", payload)
|
||||
newer = dict(payload, version=2, summary="修订后的计划")
|
||||
updated = write(service, "bot_schedule_plan", newer)
|
||||
stale = write(service, "bot_schedule_plan", dict(payload, version=1, summary="旧计划"))
|
||||
assert updated["ok"] is True
|
||||
assert updated["record_id"] == first["record_id"]
|
||||
assert updated["version"] == 2
|
||||
assert stale["ok"] is False
|
||||
assert stale["error_code"] == "stale_version"
|
||||
record = asyncio.run(service.store.get_memory(first["record_id"]))
|
||||
assert record.metadata["version"] == 2
|
||||
assert record.created_at
|
||||
assert record.updated_at
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_same_version_different_payload_is_conflict():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
write(service, "bot_observed_activity", envelope_payload(3))
|
||||
conflict = write(service, "bot_observed_activity", envelope_payload(3, summary="不同摘要"))
|
||||
assert conflict["ok"] is False
|
||||
assert conflict["error_code"] == "version_conflict"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_recursive_privacy_rejection_is_explicit():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
result = write(service, "bot_daily_diary", envelope_payload(4, details={"nested": [{"token": "secret-value"}]}))
|
||||
assert result["ok"] is False
|
||||
assert result["error_code"] == "privacy_rejected"
|
||||
assert "details" in result["field"]
|
||||
result = write(service, "bot_daily_diary", envelope_payload(5, media={"path": "C:\\private\\photo.png"}))
|
||||
assert result["error_code"] == "privacy_rejected"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_domain_isolation_and_user_query_block():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
bot_result = write(service, "bot_daily_diary", envelope_payload(6))
|
||||
user_record = MemoryRecord(
|
||||
id="user-1",
|
||||
memory_type="user_fact",
|
||||
memory_domain="user_memory",
|
||||
subject=EntityRef(kind="user", id="u1"),
|
||||
scope="private",
|
||||
session_id="private:u1",
|
||||
visibility="private_pair",
|
||||
reality_level="real_user_fact",
|
||||
content="用户也在活动。",
|
||||
)
|
||||
asyncio.run(service.store.insert_memory(user_record))
|
||||
bot_results = asyncio.run(service.search_bot_personal_memory("活动", limit=10))
|
||||
assert [item["id"] for item in bot_results] == [bot_result["record_id"]]
|
||||
engine = RetrievalEngine(service.store, VisibilityPolicy())
|
||||
assert engine._memory_domain_block_reason(MemoryRecord(memory_domain="bot_self_schedule")) == "missing_user_subject"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_bridge_has_five_methods_and_missing_bridge_returns_error_object():
|
||||
class Plugin:
|
||||
async def record_bot_personal_memory(self, **kwargs):
|
||||
return {"ok": True, "record_id": "x", "deduplicated": False, "version": 1, "error_code": None}
|
||||
|
||||
bridge = MemoryCompanionBridge(Plugin())
|
||||
payload = envelope_payload(7)
|
||||
for method_name in (
|
||||
"record_bot_schedule_plan",
|
||||
"record_bot_observed_activity",
|
||||
"record_bot_schedule_reconciliation",
|
||||
"record_bot_window_snapshot",
|
||||
"record_bot_daily_diary",
|
||||
):
|
||||
result = asyncio.run(getattr(bridge, method_name)(payload=payload))
|
||||
assert result["ok"] is True
|
||||
missing = MemoryCompanionBridge(object())
|
||||
result = asyncio.run(missing.record_bot_daily_diary(payload=payload))
|
||||
assert result["ok"] is False
|
||||
assert result["error_code"] == "bridge_method_unavailable"
|
||||
|
||||
|
||||
def test_invalid_date_window_and_timezone_are_rejected():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
assert write(service, "bot_daily_diary", dict(envelope_payload(20), date="not-a-date"))["error_code"] == "invalid_date"
|
||||
assert write(service, "bot_daily_diary", dict(envelope_payload(21), window="not_a_window"))["error_code"] == "invalid_window"
|
||||
assert write(service, "bot_daily_diary", dict(envelope_payload(22), occurred_at="2026-07-26T15:00:00"))["error_code"] == "invalid_occurred_at"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_raw_payload_over_16k_is_rejected_without_storage():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
payload = envelope_payload(23, summary="x" * 20000)
|
||||
result = write(service, "bot_daily_diary", payload)
|
||||
assert result["ok"] is False
|
||||
assert result["error_code"] == "payload_too_large"
|
||||
assert asyncio.run(service.store.list_memories(limit=20, visibility="bot_self")) == []
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_same_version_envelope_changes_conflict_and_fingerprint_covers_fields():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
payload = envelope_payload(24)
|
||||
first = write(service, "bot_observed_activity", payload)
|
||||
changed = dict(payload, window="evening", certainty=0.5, evidence_level="L1", status="completed", source_refs=["companion:event:changed"])
|
||||
result = write(service, "bot_observed_activity", changed)
|
||||
assert result["ok"] is False
|
||||
assert result["error_code"] == "version_conflict"
|
||||
record = asyncio.run(service.store.get_memory(first["record_id"]))
|
||||
assert record.metadata["window"] == "afternoon"
|
||||
assert record.metadata["certainty"] == 0.9
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_non_five_legacy_types_keep_explicit_truth_mapping():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
cases = {
|
||||
"bot_creative_work": "creative_work",
|
||||
"bot_media_memory": "media_index",
|
||||
"bot_subjective_memory": "subjective",
|
||||
"bot_shared_activity": "shared_activity",
|
||||
"bot_detail_fragment": "detail_fragment",
|
||||
"bot_proactive_message": "proactive_action",
|
||||
}
|
||||
for index, (memory_type, reality_level) in enumerate(cases.items(), 30):
|
||||
payload = envelope_payload(index, idempotency_key=f"legacy:{index}", evidence_level="L2")
|
||||
result = write(service, memory_type, payload)
|
||||
assert result["ok"] is True
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.reality_level == reality_level
|
||||
assert record.metadata["source_kind"] != "observed"
|
||||
assert record.metadata["evidence_level"] == "L2"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_dedicated_and_generic_bridge_paths_share_fingerprint():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
bridge = MemoryCompanionBridge(service)
|
||||
payload = envelope_payload(40, idempotency_key="same:bridge", evidence_level="L2")
|
||||
first = asyncio.run(bridge.record_bot_creative_work(payload=payload))
|
||||
second = asyncio.run(bridge.record_bot_personal_memory(memory_type="bot_creative_work", payload=payload))
|
||||
assert first["ok"] is True
|
||||
assert second["ok"] is True
|
||||
assert second["deduplicated"] is True
|
||||
assert first["record_id"] == second["record_id"]
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_capability_error_codes_cover_runtime_validation_errors():
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.config = Config()
|
||||
capability = service.bridge_probe_bot_personal_memory_capabilities()
|
||||
declared = set(capability["error_codes"])
|
||||
assert {"invalid_date", "invalid_window", "invalid_occurred_at", "invalid_field", "payload_too_large", "version_conflict"} <= declared
|
||||
|
||||
|
||||
def test_write_disabled_returns_contract_error():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp, enabled=False)
|
||||
result = write(service, "bot_daily_diary", envelope_payload(8))
|
||||
assert result["ok"] is False
|
||||
assert result["error_code"] == "bridge_write_disabled"
|
||||
service.store.close()
|
||||
|
|
|
|||
357
tests/test_m6_r2_real_dto_shape.py
普通文件
357
tests/test_m6_r2_real_dto_shape.py
普通文件
|
|
@ -0,0 +1,357 @@
|
|||
"""M6.1.3-R2 真实陪伴 DTO 形状兼容回归 + 值级隐私加固回归。
|
||||
|
||||
R1 的教训写在这里:本仓所有 bot_personal 用例的夹具都恒带 date/window/occurred_at,
|
||||
验证的是"喂满字段的兼容"。而调用方(陪伴插件)真实吐出的 DTO 里,非五类旧 kind 天然没有
|
||||
date,于是"兼容能力"在真实链路上全线 invalid_date,测试却全绿。
|
||||
|
||||
因此本模块坚持用**调用方的真实序列化输出**做回归:能拿到陪伴仓时直接调它的
|
||||
build_bot_personal_dto,拿不到时也用逐字复刻的真实形状样本,绝不使用提供方自造的满字段夹具。
|
||||
|
||||
本侧不放松任何校验:date 为空仍必须 invalid_date(主修在陪伴侧)。
|
||||
"""
|
||||
import asyncio
|
||||
import importlib.util
|
||||
import json
|
||||
import sys
|
||||
import tempfile
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from core.bot_personal import BOT_PERSONAL_TYPE_CONTRACTS
|
||||
from core.service import MemoryCompanionService
|
||||
from core.store import MemoryStore
|
||||
|
||||
TZ = timezone(timedelta(hours=8))
|
||||
NOW = datetime(2026, 7, 27, 18, 0, 0, tzinfo=TZ)
|
||||
COMPANION_ROOT = Path(__file__).resolve().parents[2] / "astrbot_plugin_private_companion-main"
|
||||
|
||||
# 陪伴侧 _memory_companion_archive_type 里的七个非五类 kind → memory_type → 期望 reality_level
|
||||
LEGACY_KINDS = (
|
||||
("creative_progress", "bot_creative_work", "creative_work"),
|
||||
("daily_outfit", "bot_media_memory", "media_index"),
|
||||
("dream_fragment", "bot_subjective_memory", "subjective"),
|
||||
("shared_activity", "bot_shared_activity", "shared_activity"),
|
||||
("detail_enhancement", "bot_detail_fragment", "detail_fragment"),
|
||||
("calendar_event", "bot_calendar_event", "calendar_history"),
|
||||
("proactive_message", "bot_proactive_message", "proactive_action"),
|
||||
)
|
||||
|
||||
|
||||
class Config:
|
||||
def __init__(self, enabled=True):
|
||||
self.enabled = enabled
|
||||
|
||||
def bool(self, key, default=True):
|
||||
return self.enabled
|
||||
|
||||
|
||||
def make_service(temp_dir):
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.config = Config()
|
||||
service.store = MemoryStore(Path(temp_dir) / "memory.db")
|
||||
service.store.initialize()
|
||||
service._schedule_memory_embedding = lambda *args, **kwargs: None
|
||||
return service
|
||||
|
||||
|
||||
def load_companion_dto_module():
|
||||
"""加载陪伴插件真实的 DTO 构造器(该模块只依赖标准库,可独立载入)。"""
|
||||
module_path = COMPANION_ROOT / "bot_personal_dto.py"
|
||||
if not module_path.exists():
|
||||
return None
|
||||
if "companion_bot_personal_dto" in sys.modules:
|
||||
return sys.modules["companion_bot_personal_dto"]
|
||||
spec = importlib.util.spec_from_file_location("companion_bot_personal_dto", module_path)
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
sys.modules["companion_bot_personal_dto"] = module
|
||||
spec.loader.exec_module(module)
|
||||
return module
|
||||
|
||||
|
||||
def archive_like_companion(service, envelope, *, whole_envelope=False):
|
||||
"""复刻 _memory_companion_send_bot_archive 的非五类(通用回退)调用形状。
|
||||
|
||||
M6.1.4 起两条路径一律送 body payload(信封字段只走 kwarg)。`whole_envelope=True`
|
||||
保留旧的整包信封形状,用来验证信封字段剥离仍然生效、指纹不受时间戳漂移影响。
|
||||
"""
|
||||
return asyncio.run(service.record_bot_personal_memory(
|
||||
memory_type=envelope["memory_type"],
|
||||
payload=envelope if whole_envelope else envelope["payload"],
|
||||
occurred_at=envelope["occurred_at"],
|
||||
idempotency_key=envelope["idempotency_key"],
|
||||
source_refs=list(envelope["source_refs"]),
|
||||
date=envelope["date"],
|
||||
window=envelope["window"],
|
||||
certainty=envelope["certainty"],
|
||||
evidence_level=envelope["evidence_level"],
|
||||
version=envelope["version"],
|
||||
payload_schema_version=envelope["payload_schema_version"],
|
||||
status=envelope["status"],
|
||||
source_plugin="private_companion",
|
||||
))
|
||||
|
||||
|
||||
def real_shape_envelope(memory_type, index, *, occurred_at="2026-07-27T18:00:00+08:00", **overrides):
|
||||
"""逐字复刻陪伴 DTO 的真实输出形状。
|
||||
|
||||
要点:body 里没有 date —— 这正是 R1 夹具掩盖掉的那一点;date 由 occurred_at 派生后
|
||||
只出现在信封层。
|
||||
"""
|
||||
contract = BOT_PERSONAL_TYPE_CONTRACTS[memory_type]
|
||||
envelope = {
|
||||
"record_id": f"local:legacy:{index}",
|
||||
"memory_domain": "bot_self_schedule",
|
||||
"memory_type": memory_type,
|
||||
"subject": "bot_self",
|
||||
"date": occurred_at[:10],
|
||||
"window": "evening",
|
||||
"occurred_at": occurred_at,
|
||||
"created_at": occurred_at,
|
||||
"updated_at": occurred_at,
|
||||
"source_kind": contract["source_kind"],
|
||||
"source_refs": [f"legacy:{index}"],
|
||||
"certainty": 0.6,
|
||||
"evidence_level": "L1",
|
||||
"status": "active",
|
||||
"version": 1,
|
||||
"idempotency_key": f"legacy:{memory_type}:{index}",
|
||||
"payload_schema_version": "1.0",
|
||||
"payload": {"summary": "旧能力真实形状样本", "namespace": "bot_self_timeline",
|
||||
"source_refs": [f"legacy:{index}"]},
|
||||
}
|
||||
envelope.update(overrides)
|
||||
return envelope
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# M1 · 真实陪伴 DTO 形状兼容回归
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
@pytest.mark.skipif(not (COMPANION_ROOT / "bot_personal_dto.py").exists(),
|
||||
reason="陪伴插件不在同一工作区,退回 real_shape_envelope 复刻样本")
|
||||
@pytest.mark.parametrize("kind,memory_type,reality_level", LEGACY_KINDS)
|
||||
def test_real_companion_dto_without_date_is_accepted(kind, memory_type, reality_level):
|
||||
"""用陪伴插件真实的 build_bot_personal_dto 产出信封,payload 刻意不带 date。"""
|
||||
dto_mod = load_companion_dto_module()
|
||||
assert dto_mod is not None
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
dto = dto_mod.build_bot_personal_dto(
|
||||
memory_type=memory_type, kind=kind, namespace="bot_self_timeline",
|
||||
payload={"summary": "真实调用方输出", "source_refs": [f"{kind}:1"]},
|
||||
idempotency_key=f"real:{kind}", occurred_at="2026-07-27T18:00:00+08:00", now=NOW)
|
||||
assert dto.date == "2026-07-27", "陪伴侧应已从 occurred_at 派生日期"
|
||||
assert "date" not in dto.payload, "真实 body 里本来就没有 date,夹具不得替它补上"
|
||||
result = archive_like_companion(service, dto.envelope())
|
||||
assert result["ok"] is True, result
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.reality_level == reality_level
|
||||
assert record.metadata["source_kind"] != "observed"
|
||||
assert record.metadata["date"] == "2026-07-27"
|
||||
service.store.close()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("kind,memory_type,reality_level", LEGACY_KINDS)
|
||||
def test_real_shape_sample_is_accepted_and_not_mislabelled(kind, memory_type, reality_level):
|
||||
"""不依赖陪伴仓的复刻样本:body 无 date,date 只在信封层。"""
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
envelope = real_shape_envelope(memory_type, index=kind)
|
||||
result = archive_like_companion(service, envelope)
|
||||
assert result["ok"] is True, result
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.reality_level == reality_level
|
||||
assert record.metadata["source_kind"] == BOT_PERSONAL_TYPE_CONTRACTS[memory_type]["source_kind"]
|
||||
assert record.metadata["source_kind"] != "observed"
|
||||
assert record.memory_type == memory_type
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_calendar_event_truth_mapping_is_covered():
|
||||
"""R1 的 non_five 用例漏了 bot_calendar_event,这里单独钉死。"""
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
envelope = real_shape_envelope("bot_calendar_event", index="cal",
|
||||
occurred_at="2026-07-25T22:30:00+08:00", window="late_night")
|
||||
result = archive_like_companion(service, envelope)
|
||||
assert result["ok"] is True, result
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.reality_level == "calendar_history"
|
||||
assert record.metadata["source_kind"] == "calendar"
|
||||
assert record.metadata["date"] == "2026-07-25"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_whole_envelope_shape_stays_backward_compatible():
|
||||
"""旧的整包信封形状仍必须接受,且与 body 形状产生同一个指纹。"""
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
body_first = archive_like_companion(service, real_shape_envelope("bot_creative_work", index="compat"))
|
||||
assert body_first["ok"] is True, body_first
|
||||
again = archive_like_companion(
|
||||
service, real_shape_envelope("bot_creative_work", index="compat"), whole_envelope=True)
|
||||
assert again["ok"] is True, again
|
||||
assert again["action"] == "deduplicated", "两种形状指纹不一致"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_envelope_timestamps_do_not_drift_the_fingerprint():
|
||||
"""created_at/updated_at 属信封字段,漂移不得让同一条记录变成 version_conflict。"""
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
first = real_shape_envelope("bot_creative_work", index="drift")
|
||||
assert archive_like_companion(service, first, whole_envelope=True)["ok"] is True
|
||||
later = dict(first, created_at="2026-07-27T23:59:00+08:00", updated_at="2026-07-27T23:59:00+08:00")
|
||||
result = archive_like_companion(service, later, whole_envelope=True)
|
||||
assert result["ok"] is True, result
|
||||
assert result["action"] == "deduplicated", result
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_all_seven_legacy_types_are_covered_by_this_module():
|
||||
"""防止以后新增合同类型时本模块悄悄漏测。"""
|
||||
covered = {memory_type for _, memory_type, _ in LEGACY_KINDS}
|
||||
strict = {"bot_schedule_plan", "bot_observed_activity", "bot_schedule_reconciliation",
|
||||
"bot_window_snapshot", "bot_daily_diary"}
|
||||
assert covered == set(BOT_PERSONAL_TYPE_CONTRACTS) - strict
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 合同不放松:date 仍是强校验
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_empty_date_is_still_rejected():
|
||||
"""主修在陪伴侧;本侧绝不放松,否则两边同时改会引入新的不一致。"""
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
envelope = real_shape_envelope("bot_creative_work", index="nodate", date="")
|
||||
result = archive_like_companion(service, envelope)
|
||||
assert result["ok"] is False
|
||||
assert result["error_code"] == "invalid_date"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_malformed_date_is_still_rejected():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
envelope = real_shape_envelope("bot_creative_work", index="baddate", date="2026-13-45")
|
||||
result = archive_like_companion(service, envelope)
|
||||
assert result["ok"] is False
|
||||
assert result["error_code"] == "invalid_date"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_naive_occurred_at_is_still_rejected():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
envelope = real_shape_envelope("bot_creative_work", index="naive",
|
||||
occurred_at="2026-07-27T18:00:00")
|
||||
result = archive_like_companion(service, envelope)
|
||||
assert result["ok"] is False
|
||||
assert result["error_code"] == "invalid_occurred_at"
|
||||
service.store.close()
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# M2 · 值级隐私加固(正例:必须拒;反例:不得误杀)
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
FORBIDDEN_VALUES = [
|
||||
("data_uri_png", "data:image/png;base64,iVBORw0KGgoAAAANSUhEUg=="),
|
||||
("data_uri_plain", "data:text/plain;charset=utf-8,hello"),
|
||||
("base64_infix", "封面图:base64,iVBORw0KGgoAAAANSUhEUg=="),
|
||||
("windows_path_infix", "照片保存在 D:\\private\\photos\\a.png 了"),
|
||||
("unc_path_infix", "备份放在 \\\\nas\\share\\bak 里"),
|
||||
("home_path_infix", "日志在 /home/bot/logs/run.log"),
|
||||
("tmp_path_infix", "临时文件写到 /tmp/session.json"),
|
||||
("var_path_infix", "落在 /var/log/astrbot.log"),
|
||||
("volume_path_infix", "NAS 上是 /volume1/media/a.png"),
|
||||
("path_after_equals", "path=/root/.ssh/id_rsa"),
|
||||
("private_key", "-----BEGIN RSA PRIVATE KEY----- MIIEowIBAAK"),
|
||||
("windows_path_prefix", "C:\\Users\\bot\\secret.txt"),
|
||||
("credential_pair", "password=hunter2"),
|
||||
("bearer_token", "Bearer abcdefghijklmnop"),
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("label,value", FORBIDDEN_VALUES, ids=[x[0] for x in FORBIDDEN_VALUES])
|
||||
def test_forbidden_values_are_rejected(label, value):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
envelope = real_shape_envelope("bot_creative_work", index=f"bad:{label}")
|
||||
envelope["payload"] = dict(envelope["payload"], note=value)
|
||||
result = archive_like_companion(service, envelope)
|
||||
assert result["ok"] is False, f"{label} 应被拒绝: {value!r}"
|
||||
assert result["error_code"] == "privacy_rejected", result
|
||||
service.store.close()
|
||||
|
||||
|
||||
ALLOWED_VALUES = [
|
||||
("chinese_sentence", "今天把机房的机柜标签重新打印了一遍,顺手理了理走线。"),
|
||||
("relative_path", "文档在 docs/a.md 里"),
|
||||
("dot_relative_path", "脚本是 ./scripts/run.sh"),
|
||||
("https_url", "参考 https://example.com/guide 这一篇"),
|
||||
("time_range", "09:00-10:00 之间完成"),
|
||||
("ratio_with_colon", "data:统计口径按窗口聚合"),
|
||||
("plain_word_base64", "这段说明里提到了 base64 编码的概念"),
|
||||
("colon_text", "结论: 部署稳定"),
|
||||
("version_text", "版本 v1.2.3 已发布"),
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("label,value", ALLOWED_VALUES, ids=[x[0] for x in ALLOWED_VALUES])
|
||||
def test_normal_values_are_not_false_positives(label, value):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
envelope = real_shape_envelope("bot_creative_work", index=f"ok:{label}")
|
||||
envelope["payload"] = dict(envelope["payload"], note=value)
|
||||
result = archive_like_companion(service, envelope)
|
||||
assert result["ok"] is True, f"{label} 被误杀: {value!r} -> {result}"
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_hardened_patterns_add_no_new_error_code():
|
||||
"""M3:加固只复用 privacy_rejected,capability 清单无需变动。"""
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.config = Config()
|
||||
declared = set(service.bridge_probe_bot_personal_memory_capabilities()["error_codes"])
|
||||
assert "privacy_rejected" in declared
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
live = make_service(temp)
|
||||
envelope = real_shape_envelope("bot_creative_work", index="codes")
|
||||
envelope["payload"] = dict(envelope["payload"], note="data:image/png;base64,AAAA")
|
||||
result = archive_like_companion(live, envelope)
|
||||
assert result["error_code"] in declared
|
||||
live.store.close()
|
||||
|
||||
|
||||
def test_rejected_payload_leaves_no_row_behind():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
envelope = real_shape_envelope("bot_creative_work", index="norow")
|
||||
envelope["payload"] = dict(envelope["payload"], note="D:\\private\\a.png")
|
||||
result = archive_like_companion(service, envelope)
|
||||
assert result["ok"] is False
|
||||
rows = service.store._conn.execute(
|
||||
"SELECT COUNT(*) FROM memories WHERE memory_domain='bot_self_schedule'").fetchone()[0]
|
||||
assert rows == 0
|
||||
service.store.close()
|
||||
|
||||
|
||||
def test_stored_legacy_record_carries_no_local_path_or_base64():
|
||||
"""写入成功的记录整行 dump 里不得出现路径/base64 痕迹。"""
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
envelope = real_shape_envelope("bot_proactive_message", index="clean")
|
||||
envelope["payload"] = dict(envelope["payload"], has_image=True, image_name="jifang.png")
|
||||
result = archive_like_companion(service, envelope)
|
||||
assert result["ok"] is True, result
|
||||
service.store._conn.row_factory = None
|
||||
dump = json.dumps([list(map(str, row)) for row in service.store._conn.execute(
|
||||
"SELECT * FROM memories WHERE memory_domain='bot_self_schedule'")], ensure_ascii=False)
|
||||
for marker in ("base64,", "-----BEGIN", "D:\\", "/home/", "/tmp/"):
|
||||
assert marker not in dump, marker
|
||||
assert "jifang.png" in dump
|
||||
service.store.close()
|
||||
|
|
@ -0,0 +1,195 @@
|
|||
"""M6.1.4 创作 / 媒体 / 主观记忆分域回归(记忆侧)。
|
||||
|
||||
对应队列第 7 节「记忆插件」四条:独立 schema/索引/过滤、保留来源链不压成字符串、
|
||||
限制媒体引用路径、mixed 活动显式拆分不得同时进用户域与 Bot 域。
|
||||
"""
|
||||
import asyncio
|
||||
import json
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from core.bot_personal import BOT_PERSONAL_TYPE_CONTRACTS
|
||||
from core.service import MemoryCompanionService
|
||||
from core.store import MemoryStore
|
||||
|
||||
OCCURRED = "2026-07-27T18:00:00+08:00"
|
||||
|
||||
|
||||
class Config:
|
||||
def __init__(self, enabled=True):
|
||||
self.enabled = enabled
|
||||
|
||||
def bool(self, key, default=True):
|
||||
return self.enabled
|
||||
|
||||
|
||||
def make_service(temp_dir):
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.config = Config()
|
||||
service.store = MemoryStore(Path(temp_dir) / "memory.db")
|
||||
service.store.initialize()
|
||||
service._schedule_memory_embedding = lambda *args, **kwargs: None
|
||||
return service
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def service():
|
||||
"""断言失败时也要关库:否则 Windows 删不掉 memory.db,PermissionError 会盖住真正的失败。"""
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
svc = make_service(temp)
|
||||
try:
|
||||
yield svc
|
||||
finally:
|
||||
svc.store.close()
|
||||
|
||||
|
||||
def archive(service, memory_type, body, *, key="k1", occurred_at=OCCURRED, evidence="L1"):
|
||||
"""复刻陪伴侧非五类的通用回退调用形状。"""
|
||||
envelope = {
|
||||
"record_id": f"local:{key}", "memory_domain": "bot_self_schedule",
|
||||
"memory_type": memory_type, "subject": "bot_self", "date": occurred_at[:10],
|
||||
"window": "evening", "occurred_at": occurred_at, "created_at": occurred_at,
|
||||
"updated_at": occurred_at, "source_kind": BOT_PERSONAL_TYPE_CONTRACTS[memory_type]["source_kind"],
|
||||
"source_refs": [f"ref:{key}"], "certainty": 0.6, "evidence_level": evidence,
|
||||
"status": "active", "version": 1, "idempotency_key": key,
|
||||
"payload_schema_version": "1.0", "payload": body,
|
||||
}
|
||||
return asyncio.run(service.record_bot_personal_memory(
|
||||
memory_type=memory_type, payload=envelope["payload"], occurred_at=envelope["occurred_at"],
|
||||
idempotency_key=envelope["idempotency_key"], source_refs=list(envelope["source_refs"]),
|
||||
date=envelope["date"], window=envelope["window"], certainty=envelope["certainty"],
|
||||
evidence_level=envelope["evidence_level"], version=envelope["version"],
|
||||
payload_schema_version="1.0", status=envelope["status"], source_plugin="private_companion"))
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 1. 独立 schema / 索引 / 过滤
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_creative_media_subjective_have_distinct_contracts():
|
||||
"""三类不能共用同一套真实性标注,否则检索侧无法分域过滤。"""
|
||||
creative = BOT_PERSONAL_TYPE_CONTRACTS["bot_creative_work"]
|
||||
media = BOT_PERSONAL_TYPE_CONTRACTS["bot_media_memory"]
|
||||
subjective = BOT_PERSONAL_TYPE_CONTRACTS["bot_subjective_memory"]
|
||||
levels = {creative["reality_level"], media["reality_level"], subjective["reality_level"]}
|
||||
kinds = {creative["source_kind"], media["source_kind"], subjective["source_kind"]}
|
||||
assert levels == {"creative_work", "media_index", "subjective"}
|
||||
assert kinds == {"creative", "media", "subjective"}
|
||||
|
||||
|
||||
def test_domain_type_time_index_exists(service):
|
||||
names = {row[0] for row in service.store._conn.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='memories'")}
|
||||
assert "idx_memories_domain_type_time" in names
|
||||
|
||||
|
||||
def test_each_type_is_filterable_on_its_own(service):
|
||||
for i, mt in enumerate(("bot_creative_work", "bot_media_memory", "bot_subjective_memory")):
|
||||
assert archive(service, mt, {"summary": f"s{i}"}, key=f"k{i}")["ok"] is True
|
||||
for mt, expected in (("bot_creative_work", 1), ("bot_media_memory", 1), ("bot_subjective_memory", 1)):
|
||||
rows = service.store._conn.execute(
|
||||
"SELECT COUNT(*) FROM memories WHERE memory_domain='bot_self_schedule' AND memory_type=?",
|
||||
(mt,)).fetchone()[0]
|
||||
assert rows == expected, mt
|
||||
|
||||
|
||||
def test_subjective_types_are_marked_epistemically(service):
|
||||
for mt in ("bot_subjective_memory", "bot_daily_diary"):
|
||||
result = archive(service, mt, {"summary": "梦/日记"}, key=f"sub:{mt}")
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.metadata["epistemic_type"] == "subjective", mt
|
||||
creative = archive(service, "bot_creative_work", {"summary": "创作"}, key="cw")
|
||||
record = asyncio.run(service.store.get_memory(creative["record_id"]))
|
||||
assert record.metadata["epistemic_type"] == "creative"
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 2. 保留来源链,不把结构化对象压成字符串
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_structured_body_survives_round_trip(service):
|
||||
body = {
|
||||
"project_id": "novel-1", "current_chars": 2400, "chunk_index": 2,
|
||||
"threads": ["线索甲", "线索乙"],
|
||||
"important": ["事实甲"],
|
||||
"nested": {"a": 1, "b": [1, 2, 3]},
|
||||
}
|
||||
result = archive(service, "bot_creative_work", body, key="chain")
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.metadata["threads"] == ["线索甲", "线索乙"], "列表被压成字符串"
|
||||
assert record.metadata["nested"] == {"a": 1, "b": [1, 2, 3]}, "嵌套对象被压平"
|
||||
assert record.metadata["current_chars"] == 2400
|
||||
assert isinstance(record.metadata["current_chars"], int), "数字被转成字符串"
|
||||
|
||||
|
||||
def test_source_refs_stay_a_list_not_a_joined_string(service):
|
||||
result = archive(service, "bot_media_memory", {"media_id": "abc"}, key="refs")
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.metadata["source_refs"] == ["ref:refs"]
|
||||
assert isinstance(record.metadata["source_refs"], list)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 3. 限制媒体引用路径
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
MEDIA_PATH_CASES = [
|
||||
("windows_abs", {"media_path": "D:\\astrbot\\media\\a.png"}),
|
||||
("posix_abs", {"media_path": "/home/bot/media/a.png"}),
|
||||
("path_after_colon", {"note": "存在:D:\\media\\a.png"}),
|
||||
("data_uri", {"thumbnail": "data:image/png;base64,AAAA"}),
|
||||
("base64_infix", {"note": "缩略图 base64,AAAA"}),
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("label,body", MEDIA_PATH_CASES, ids=[c[0] for c in MEDIA_PATH_CASES])
|
||||
def test_media_records_reject_local_paths_and_binaries(service, label, body):
|
||||
result = archive(service, "bot_media_memory", dict(body, media_id="abc"), key=f"bad:{label}")
|
||||
assert result["ok"] is False, f"{label} 应被拒绝"
|
||||
assert result["error_code"] == "privacy_rejected", result
|
||||
rows = service.store._conn.execute("SELECT COUNT(*) FROM memories").fetchone()[0]
|
||||
assert rows == 0
|
||||
|
||||
|
||||
def test_media_index_fields_are_accepted(service):
|
||||
"""只存标识/名称/类型/尺寸的媒体索引必须能落库,否则合同要求无法实现。"""
|
||||
result = archive(service, "bot_media_memory", {
|
||||
"media_id": "9f8e7d6c5b4a3210", "media_kind": "generated_image",
|
||||
"media_name": "out_001.png", "width": 1024, "height": 1024,
|
||||
"mime": "image/png", "summary": "机房夜景里的猫",
|
||||
}, key="media:ok")
|
||||
assert result["ok"] is True, result
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.metadata["media_name"] == "out_001.png"
|
||||
assert record.metadata["width"] == 1024
|
||||
assert record.reality_level == "media_index"
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 4. mixed 活动不得同时进用户域与 Bot 域
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_bot_personal_records_are_pinned_to_the_bot_domain(service):
|
||||
result = archive(service, "bot_shared_activity", {
|
||||
"summary": "和主人一起排障",
|
||||
# 调用方即使谎报域/主体,也不得越界
|
||||
"memory_domain": "user_facts", "scope": "private", "subject": {"kind": "user", "id": "u1"},
|
||||
}, key="mixed")
|
||||
assert result["ok"] is True, result
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.memory_domain == "bot_self_schedule"
|
||||
assert record.subject.kind == "bot"
|
||||
assert record.object.kind == "bot"
|
||||
rows = service.store._conn.execute(
|
||||
"SELECT COUNT(*) FROM memories WHERE memory_domain!='bot_self_schedule'").fetchone()[0]
|
||||
assert rows == 0, "同一条记录同时出现在用户域"
|
||||
|
||||
|
||||
def test_shared_activity_keeps_its_own_reality_level(service):
|
||||
result = archive(service, "bot_shared_activity", {"summary": "共同活动"}, key="shared")
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.reality_level == "shared_activity"
|
||||
assert record.metadata["source_kind"] == "shared"
|
||||
assert record.metadata["source_kind"] != "observed"
|
||||
280
tests/test_m6_r5_bot_profiles.py
普通文件
280
tests/test_m6_r5_bot_profiles.py
普通文件
|
|
@ -0,0 +1,280 @@
|
|||
"""M6.1.5 Bot 专用检索 Profile 回归(记忆侧)。
|
||||
|
||||
Profile 的价值全在「固定」二字:域、类型、时间范围、条数、排序、注入字段、权限
|
||||
一旦有一项可以被调用方绕过,专用检索就退回成全库通用检索。本模块逐项钉死这七件事,
|
||||
外加队列第 8 节的三条出口条件。
|
||||
"""
|
||||
import asyncio
|
||||
import tempfile
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from core.bot_personal import BOT_PERSONAL_TYPE_CONTRACTS
|
||||
from core.bot_profiles import BOT_PROFILE_NAMES, BOT_RETRIEVAL_PROFILES, describe_bot_profiles
|
||||
from core.bridge import MemoryCompanionBridge
|
||||
from core.models import EntityRef, MemoryRecord
|
||||
from core.service import MemoryCompanionService
|
||||
from core.store import MemoryStore
|
||||
|
||||
TZ = timezone(timedelta(hours=8))
|
||||
NOW = datetime(2026, 7, 27, 18, 0, 0, tzinfo=TZ)
|
||||
|
||||
|
||||
class Config:
|
||||
def bool(self, key, default=True):
|
||||
return True
|
||||
|
||||
def int(self, key, default=0):
|
||||
return default
|
||||
|
||||
def text(self, key, default=""):
|
||||
return default
|
||||
|
||||
|
||||
def make_service(temp_dir):
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.config = Config()
|
||||
service.store = MemoryStore(Path(temp_dir) / "memory.db")
|
||||
service.store.initialize()
|
||||
service._schedule_memory_embedding = lambda *args, **kwargs: None
|
||||
return service
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def service():
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
svc = make_service(temp)
|
||||
try:
|
||||
yield svc
|
||||
finally:
|
||||
svc.store.close()
|
||||
|
||||
|
||||
def archive(service, memory_type, *, key, days_ago=0, summary="记录"):
|
||||
occurred = (NOW - timedelta(days=days_ago)).isoformat()
|
||||
return asyncio.run(service.record_bot_personal_memory(
|
||||
memory_type=memory_type,
|
||||
payload={"summary": summary},
|
||||
occurred_at=occurred, idempotency_key=key, source_refs=[f"ref:{key}"],
|
||||
date=occurred[:10], window="evening", certainty=0.6,
|
||||
evidence_level="L0" if memory_type == "bot_schedule_plan" else "L1",
|
||||
version=1, payload_schema_version="1.0", status="active",
|
||||
source_plugin="private_companion"))
|
||||
|
||||
|
||||
def search(service, profile, **kwargs):
|
||||
return asyncio.run(service.search_bot_personal_profile(profile, "", now=NOW, **kwargs))
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Profile 契约本身
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_five_profiles_are_defined():
|
||||
assert set(BOT_PROFILE_NAMES) == {
|
||||
"bot_schedule_current", "bot_schedule_history",
|
||||
"bot_creative", "bot_subjective", "locked_frame_personal"}
|
||||
|
||||
|
||||
@pytest.mark.parametrize("name", BOT_PROFILE_NAMES)
|
||||
def test_every_profile_pins_all_seven_dimensions(name):
|
||||
spec = BOT_RETRIEVAL_PROFILES[name]
|
||||
described = describe_bot_profiles()[name]
|
||||
assert described["memory_domain"] == "bot_self_schedule" # 允许域
|
||||
assert spec["memory_types"] # 类型
|
||||
assert "min_age_days" in spec and "max_age_days" in spec # 时间范围
|
||||
assert isinstance(spec["limit"], int) and spec["limit"] > 0 # 最大条数
|
||||
assert spec["order"] == "occurred_at_desc" # 排序
|
||||
assert spec["fields"] # 注入字段
|
||||
assert described["read_only"] is True # 权限
|
||||
|
||||
|
||||
@pytest.mark.parametrize("name", BOT_PROFILE_NAMES)
|
||||
def test_profile_types_are_all_real_contract_types(name):
|
||||
for memory_type in BOT_RETRIEVAL_PROFILES[name]["memory_types"]:
|
||||
assert memory_type in BOT_PERSONAL_TYPE_CONTRACTS, memory_type
|
||||
|
||||
|
||||
def test_current_and_history_windows_do_not_overlap():
|
||||
"""重叠的话同一条记录会既算「现在」又算「过去」,模型分不清该照做还是回忆。"""
|
||||
current = BOT_RETRIEVAL_PROFILES["bot_schedule_current"]
|
||||
history = BOT_RETRIEVAL_PROFILES["bot_schedule_history"]
|
||||
assert current["max_age_days"] <= history["min_age_days"]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 时间范围
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_current_profile_only_returns_recent_records(service):
|
||||
archive(service, "bot_observed_activity", key="today", days_ago=0, summary="今天做的事")
|
||||
archive(service, "bot_observed_activity", key="old", days_ago=5, summary="五天前做的事")
|
||||
result = search(service, "bot_schedule_current")
|
||||
contents = " ".join(m.get("content", "") for m in result["memories"])
|
||||
assert "今天做的事" in contents
|
||||
assert "五天前做的事" not in contents
|
||||
|
||||
|
||||
def test_history_profile_excludes_today(service):
|
||||
archive(service, "bot_observed_activity", key="today", days_ago=0, summary="今天做的事")
|
||||
archive(service, "bot_observed_activity", key="old", days_ago=5, summary="五天前做的事")
|
||||
result = search(service, "bot_schedule_history")
|
||||
contents = " ".join(m.get("content", "") for m in result["memories"])
|
||||
assert "五天前做的事" in contents
|
||||
assert "今天做的事" not in contents, "历史 Profile 不得把当前记录当成过去返回"
|
||||
|
||||
|
||||
def test_many_recent_records_do_not_starve_the_history_profile(service):
|
||||
"""时间窗必须进 SQL。
|
||||
|
||||
在 Python 里后筛的话,「按 occurred_at 倒序取 N 条再过滤」会让近期记录把名额占满,
|
||||
历史窗里的行根本进不了结果集,Profile 静默返回空——联合 E2E 里就是这么暴露出来的。
|
||||
"""
|
||||
for i in range(60):
|
||||
archive(service, "bot_observed_activity", key=f"recent{i}", days_ago=0, summary=f"今天第{i}件事")
|
||||
archive(service, "bot_observed_activity", key="buried", days_ago=3, summary="三天前被埋掉的事")
|
||||
memories = search(service, "bot_schedule_history")["memories"]
|
||||
assert memories, "历史 Profile 不应因近期记录过多而返回空"
|
||||
assert any("三天前被埋掉的事" in m.get("content", "") for m in memories)
|
||||
|
||||
|
||||
def test_records_outside_max_age_are_dropped(service):
|
||||
archive(service, "bot_subjective_memory", key="ancient", days_ago=400, summary="很久以前的梦")
|
||||
assert search(service, "bot_subjective")["memories"] == []
|
||||
|
||||
|
||||
def test_records_without_timezone_are_dropped(service):
|
||||
"""时间定位不了的记录,宁可不注入,也不能被当成「当前」。"""
|
||||
record = MemoryRecord(
|
||||
id="botmem_naive", memory_type="bot_observed_activity", memory_domain="bot_self_schedule",
|
||||
subject=EntityRef.bot_self(), object=EntityRef.bot_self(), scope="private",
|
||||
session_id="bot_personal", visibility="bot_self", sayability="indirect",
|
||||
reality_level="observed_activity", lifecycle="stable_memory", content="没有时区的记录",
|
||||
evidence="x", confidence=0.8, importance=0.5, tags=["bot_personal"],
|
||||
metadata={"memory_domain": "bot_self_schedule"}, source_plugin="private_companion",
|
||||
occurred_at="2026-07-27T18:00:00")
|
||||
asyncio.run(service.store.upsert_bot_personal_memory(
|
||||
record, payload_fingerprint="fp", version=1, idempotency_key="naive"))
|
||||
result = search(service, "bot_schedule_current")
|
||||
assert all("没有时区" not in m.get("content", "") for m in result["memories"])
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 类型、条数、排序
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_each_profile_returns_only_its_own_types(service):
|
||||
for i, mt in enumerate(BOT_PERSONAL_TYPE_CONTRACTS):
|
||||
archive(service, mt, key=f"t{i}", days_ago=0)
|
||||
for name, spec in BOT_RETRIEVAL_PROFILES.items():
|
||||
if spec["min_age_days"]:
|
||||
continue # 历史 Profile 的窗口里没有今天的记录
|
||||
result = search(service, name)
|
||||
returned = {m["memory_type"] for m in result["memories"]}
|
||||
assert returned <= set(spec["memory_types"]), (name, returned)
|
||||
|
||||
|
||||
def test_limit_can_be_lowered_but_not_raised(service):
|
||||
for i in range(9):
|
||||
archive(service, "bot_observed_activity", key=f"n{i}", days_ago=0)
|
||||
assert len(search(service, "bot_schedule_current", limit=2)["memories"]) == 2
|
||||
# 试图突破 Profile 上限(6)应被夹住
|
||||
raised = search(service, "bot_schedule_current", limit=99)
|
||||
assert raised["limit"] == BOT_RETRIEVAL_PROFILES["bot_schedule_current"]["limit"]
|
||||
assert len(raised["memories"]) <= 6
|
||||
|
||||
|
||||
def test_results_are_ordered_newest_first(service):
|
||||
archive(service, "bot_creative_work", key="a", days_ago=10, summary="较早创作")
|
||||
archive(service, "bot_creative_work", key="b", days_ago=2, summary="较晚创作")
|
||||
memories = search(service, "bot_creative")["memories"]
|
||||
assert len(memories) == 2
|
||||
assert memories[0]["occurred_at"] > memories[1]["occurred_at"]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 注入字段与权限
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
INTERNAL_FIELDS = ("payload_fingerprint", "idempotency_key", "persona_importance",
|
||||
"relationship_weight", "content_fingerprint", "evidence")
|
||||
|
||||
|
||||
def test_projection_drops_internal_fields(service):
|
||||
archive(service, "bot_observed_activity", key="proj", days_ago=0)
|
||||
item = search(service, "bot_schedule_current")["memories"][0]
|
||||
for field in INTERNAL_FIELDS:
|
||||
assert field not in item, field
|
||||
assert set(item) <= set(BOT_RETRIEVAL_PROFILES["bot_schedule_current"]["fields"])
|
||||
|
||||
|
||||
def test_subjective_profile_exposes_epistemic_type(service):
|
||||
archive(service, "bot_subjective_memory", key="dream", days_ago=0, summary="梦到机房飘雪")
|
||||
item = search(service, "bot_subjective")["memories"][0]
|
||||
assert item["epistemic_type"] == "subjective", "主观内容必须可被识别为主观"
|
||||
|
||||
|
||||
def test_profiles_are_read_only(service):
|
||||
assert search(service, "bot_creative")["read_only"] is True
|
||||
|
||||
|
||||
def test_unknown_profile_returns_empty_with_warning(service):
|
||||
result = search(service, "全库随便搜")
|
||||
assert result["memories"] == []
|
||||
assert "unknown_profile" in result["warnings"]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 出口条件
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_profiles_never_return_user_memories(service):
|
||||
"""出口条件:用户事实查询不返回 Bot 内容,反过来 Profile 也不得返回用户记忆。"""
|
||||
user_record = MemoryRecord(
|
||||
id="usr_1", memory_type="user_fact", memory_domain="user_memory",
|
||||
subject=EntityRef(kind="user", id="u1"), object=EntityRef.bot_self(), scope="private",
|
||||
session_id="bot_personal", visibility="bot_self", sayability="direct",
|
||||
reality_level="real_user_fact", lifecycle="stable_memory", content="用户喜欢喝美式",
|
||||
evidence="x", confidence=0.9, importance=0.6, tags=["user"],
|
||||
metadata={"memory_domain": "user_memory"}, source_plugin="memory_companion",
|
||||
occurred_at=NOW.isoformat())
|
||||
asyncio.run(service.store.insert_memory(user_record))
|
||||
for name in BOT_PROFILE_NAMES:
|
||||
result = search(service, name)
|
||||
assert all("美式" not in m.get("content", "") for m in result["memories"]), name
|
||||
|
||||
|
||||
def test_capability_publishes_the_profile_contract(service):
|
||||
cap = service.bridge_probe_bot_personal_memory_capabilities()
|
||||
assert set(cap["retrieval_profiles"]) == set(BOT_PROFILE_NAMES)
|
||||
assert "search_bot_schedule" in cap["retrieval_methods"]
|
||||
assert cap["retrieval_profiles"]["bot_creative"]["read_only"] is True
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Bridge 具名入口
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_named_bridge_methods_map_to_the_right_profiles(service):
|
||||
bridge = MemoryCompanionBridge(service)
|
||||
cases = (
|
||||
(lambda: bridge.search_bot_schedule(""), "bot_schedule_current"),
|
||||
(lambda: bridge.search_bot_schedule("", history=True), "bot_schedule_history"),
|
||||
(lambda: bridge.search_bot_creative_memory(""), "bot_creative"),
|
||||
(lambda: bridge.search_bot_subjective_memory(""), "bot_subjective"),
|
||||
(lambda: bridge.search_locked_frame_personal_memory(""), "locked_frame_personal"),
|
||||
)
|
||||
for call, expected in cases:
|
||||
assert asyncio.run(call())["profile"] == expected
|
||||
|
||||
|
||||
def test_bridge_reports_unavailable_when_plugin_lacks_profiles():
|
||||
"""旧版记忆插件没有 Profile 方法时要给出稳定信号,好让陪伴侧回退。"""
|
||||
class Plugin:
|
||||
pass
|
||||
bridge = MemoryCompanionBridge(Plugin())
|
||||
result = asyncio.run(bridge.search_bot_personal_profile("bot_creative"))
|
||||
assert result["memories"] == []
|
||||
assert "bridge_method_unavailable" in result["warnings"]
|
||||
198
tests/test_m6_r6_bot_archive_api.py
普通文件
198
tests/test_m6_r6_bot_archive_api.py
普通文件
|
|
@ -0,0 +1,198 @@
|
|||
"""M6.1.6 记忆侧 Bot 归档只读 API 回归。
|
||||
|
||||
队列第 9 节的页面规则里有两条是硬约束:
|
||||
- 长期归档标明来自记忆插件(响应必须自带来源标识);
|
||||
- 页面只调稳定只读 API,不访问另一个插件私有对象。
|
||||
|
||||
这里直接调 PageAPI 的处理函数,绕开 HTTP 层但走真实实现,验证契约本身。
|
||||
"""
|
||||
import asyncio
|
||||
import sys
|
||||
import tempfile
|
||||
import types
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
|
||||
import pytest
|
||||
|
||||
from core.bot_profiles import BOT_PROFILE_NAMES
|
||||
from core.models import EntityRef, MemoryRecord
|
||||
from core.service import MemoryCompanionService
|
||||
from core.store import MemoryStore
|
||||
|
||||
# page_api 在导入期就需要 quart;本仓不带 Web 依赖,按其它测试同款方式打桩。
|
||||
if "quart" not in sys.modules:
|
||||
_quart = types.ModuleType("quart")
|
||||
_quart.jsonify = lambda body: body
|
||||
_quart.request = types.SimpleNamespace(args={})
|
||||
_quart.send_file = lambda *a, **k: None
|
||||
sys.modules["quart"] = _quart
|
||||
|
||||
import page_api as page_api_module
|
||||
|
||||
TZ = timezone(timedelta(hours=8))
|
||||
NOW = datetime(2026, 7, 27, 18, 0, 0, tzinfo=TZ)
|
||||
|
||||
|
||||
class Config:
|
||||
def bool(self, key, default=True):
|
||||
return True
|
||||
|
||||
def int(self, key, default=0):
|
||||
return default
|
||||
|
||||
def text(self, key, default=""):
|
||||
return default
|
||||
|
||||
|
||||
class FakeRequest:
|
||||
"""替代 quart.request:只提供 args。"""
|
||||
|
||||
def __init__(self, args=None):
|
||||
self.args = dict(args or {})
|
||||
|
||||
|
||||
class Recorded:
|
||||
"""替代 quart.jsonify:原样返回 dict,方便断言。"""
|
||||
|
||||
@staticmethod
|
||||
def jsonify(body):
|
||||
return body
|
||||
|
||||
|
||||
def make_service(temp_dir):
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.config = Config()
|
||||
service.store = MemoryStore(Path(temp_dir) / "memory.db")
|
||||
service.store.initialize()
|
||||
service._schedule_memory_embedding = lambda *args, **kwargs: None
|
||||
return service
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def api(monkeypatch):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
monkeypatch.setattr(page_api_module, "jsonify", Recorded.jsonify)
|
||||
instance = object.__new__(page_api_module.PluginPageApi)
|
||||
instance.plugin = SimpleNamespace(service=service)
|
||||
try:
|
||||
yield instance, service, monkeypatch
|
||||
finally:
|
||||
service.store.close()
|
||||
|
||||
|
||||
def archive(service, memory_type, *, key, days_ago=0, summary="记录"):
|
||||
occurred = (NOW - timedelta(days=days_ago)).isoformat()
|
||||
return asyncio.run(service.record_bot_personal_memory(
|
||||
memory_type=memory_type, payload={"summary": summary}, occurred_at=occurred,
|
||||
idempotency_key=key, source_refs=[f"ref:{key}"], date=occurred[:10], window="evening",
|
||||
certainty=0.6, evidence_level="L0" if memory_type == "bot_schedule_plan" else "L1",
|
||||
version=1, payload_schema_version="1.0", status="active", source_plugin="private_companion"))
|
||||
|
||||
|
||||
def call(api_bundle, handler_name, args=None):
|
||||
instance, _, monkeypatch = api_bundle
|
||||
monkeypatch.setattr(page_api_module, "request", FakeRequest(args))
|
||||
return asyncio.run(getattr(instance, handler_name)())
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_profiles_endpoint_publishes_the_contract(api):
|
||||
body = call(api, "bot_archive_profiles")
|
||||
assert body["success"] is True
|
||||
assert set(body["profiles"]) == set(BOT_PROFILE_NAMES)
|
||||
assert body["read_only"] is True
|
||||
|
||||
|
||||
def test_every_response_declares_it_comes_from_the_memory_plugin(api):
|
||||
"""页面必须能区分「运行态来自陪伴」和「长期归档来自记忆」。"""
|
||||
for handler, args in (("bot_archive_profiles", None),
|
||||
("bot_archive_query", {"profile": "bot_creative"}),
|
||||
("bot_archive_locked_frame", None)):
|
||||
body = call(api, handler, args)
|
||||
assert body["data_source"] == "memory_archive", handler
|
||||
assert body["source_plugin"] == "memory_companion", handler
|
||||
|
||||
|
||||
def test_query_returns_only_the_requested_profile(api):
|
||||
_, service, _ = api
|
||||
archive(service, "bot_creative_work", key="c1", summary="小说推进")
|
||||
archive(service, "bot_subjective_memory", key="d1", summary="梦到机房飘雪")
|
||||
body = call(api, "bot_archive_query", {"profile": "bot_creative"})
|
||||
contents = " ".join(m.get("content", "") for m in body["memories"])
|
||||
assert "小说推进" in contents
|
||||
assert "梦到机房飘雪" not in contents
|
||||
assert body["read_only"] is True
|
||||
assert body["memory_domain"] == "bot_self_schedule"
|
||||
|
||||
|
||||
def test_query_rejects_unknown_profile_without_falling_back_to_everything(api):
|
||||
_, service, _ = api
|
||||
archive(service, "bot_creative_work", key="c1", summary="小说推进")
|
||||
body = call(api, "bot_archive_query", {"profile": "全库随便搜"})
|
||||
assert body["memories"] == []
|
||||
assert "unknown_profile" in body["warnings"]
|
||||
|
||||
|
||||
def test_query_limit_cannot_exceed_the_profile_cap(api):
|
||||
_, service, _ = api
|
||||
for i in range(9):
|
||||
archive(service, "bot_creative_work", key=f"c{i}", summary=f"创作{i}")
|
||||
body = call(api, "bot_archive_query", {"profile": "bot_creative", "limit": "999"})
|
||||
assert body["limit"] == 6
|
||||
assert len(body["memories"]) <= 6
|
||||
|
||||
|
||||
def test_locked_frame_groups_by_memory_type(api):
|
||||
_, service, _ = api
|
||||
archive(service, "bot_creative_work", key="c1", summary="小说推进")
|
||||
archive(service, "bot_subjective_memory", key="d1", summary="梦到机房飘雪")
|
||||
body = call(api, "bot_archive_locked_frame")
|
||||
assert set(body["groups"]) == {"bot_creative_work", "bot_subjective_memory"}
|
||||
assert body["total"] == 2
|
||||
assert body["profile"] == "locked_frame_personal"
|
||||
|
||||
|
||||
def test_bot_archive_never_exposes_user_memories(api):
|
||||
_, service, _ = api
|
||||
user_record = MemoryRecord(
|
||||
id="usr_1", memory_type="user_fact", memory_domain="user_memory",
|
||||
subject=EntityRef(kind="user", id="u1"), object=EntityRef.bot_self(), scope="private",
|
||||
session_id="bot_personal", visibility="bot_self", sayability="direct",
|
||||
reality_level="real_user_fact", lifecycle="stable_memory", content="用户喜欢喝美式",
|
||||
evidence="x", confidence=0.9, importance=0.6, tags=["user"],
|
||||
metadata={"memory_domain": "user_memory"}, source_plugin="memory_companion",
|
||||
occurred_at=NOW.isoformat())
|
||||
asyncio.run(service.store.insert_memory(user_record))
|
||||
for handler, args in (("bot_archive_query", {"profile": "locked_frame_personal"}),
|
||||
("bot_archive_locked_frame", None)):
|
||||
body = call(api, handler, args)
|
||||
assert "美式" not in str(body), handler
|
||||
|
||||
|
||||
def test_bot_archive_endpoints_expose_no_internal_fields(api):
|
||||
_, service, _ = api
|
||||
archive(service, "bot_creative_work", key="c1", summary="小说推进")
|
||||
body = call(api, "bot_archive_query", {"profile": "bot_creative"})
|
||||
for item in body["memories"]:
|
||||
for field in ("payload_fingerprint", "idempotency_key", "evidence", "persona_importance"):
|
||||
assert field not in item, field
|
||||
|
||||
|
||||
def test_bot_archive_endpoints_are_registered_get_only(api):
|
||||
"""只读端点不得注册写方法——Bot 域的写入只走受控归档路径。"""
|
||||
instance, service, _ = api
|
||||
registered = []
|
||||
instance.plugin = SimpleNamespace(
|
||||
service=service,
|
||||
context=SimpleNamespace(
|
||||
register_web_api=lambda path, handler, methods, desc: registered.append((path, tuple(methods)))),
|
||||
)
|
||||
instance.register_routes()
|
||||
bot_routes = [(path, methods) for path, methods in registered if "/bot-archive/" in path]
|
||||
assert len(bot_routes) == 3, bot_routes
|
||||
for path, methods in bot_routes:
|
||||
assert methods == ("GET",), path
|
||||
315
tests/test_m6_r7_domain_isolation.py
普通文件
315
tests/test_m6_r7_domain_isolation.py
普通文件
|
|
@ -0,0 +1,315 @@
|
|||
"""M6.1.7 三域隔离、通用写入拒绝与页面状态码回归(记忆侧)。
|
||||
|
||||
对应队列第 10 节「记忆插件主责」第 2/3/4 条:
|
||||
- 用户域 / Bot 域 / mixed 域在查询、页面、Bridge、导出四层的隔离;
|
||||
- Bot 域通用修改/删除明确拒绝,只允许受控归档路径写入;
|
||||
- 页面 API 的真实 HTTP 状态码。
|
||||
|
||||
管理会话与 Origin/CSRF 由 AstrBot 宿主的 `register_web_api` 提供,插件不自建第二套;
|
||||
本模块只钉住插件自己能控的部分:写入端点一律 POST(不可被跨站的普通链接触发)、
|
||||
错误路径返回正确状态码。宿主鉴权在 VM 实机验收核对。
|
||||
"""
|
||||
import asyncio
|
||||
import json
|
||||
import sys
|
||||
import tempfile
|
||||
import types
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
|
||||
import pytest
|
||||
|
||||
from core.bridge import MemoryCompanionBridge
|
||||
from core.models import EntityRef, MemoryRecord
|
||||
from core.operations import PortableMemoryArchive
|
||||
from core.service import MemoryCompanionService
|
||||
from core.store import MemoryStore
|
||||
from core.user_memory_boundary import USER_MEMORY_DOMAIN
|
||||
|
||||
if "quart" not in sys.modules:
|
||||
_quart = types.ModuleType("quart")
|
||||
_quart.jsonify = lambda body: body
|
||||
_quart.request = types.SimpleNamespace(args={})
|
||||
_quart.send_file = lambda *a, **k: None
|
||||
sys.modules["quart"] = _quart
|
||||
|
||||
import page_api as page_api_module
|
||||
|
||||
TZ = timezone(timedelta(hours=8))
|
||||
NOW = datetime(2026, 7, 27, 18, 0, 0, tzinfo=TZ)
|
||||
BOT_DOMAIN = "bot_self_schedule"
|
||||
|
||||
|
||||
class Response(dict):
|
||||
"""替代 quart 响应:既是 dict 又能挂 status_code。"""
|
||||
|
||||
status_code = 200
|
||||
|
||||
|
||||
def _jsonify(body):
|
||||
response = Response(body)
|
||||
response.status_code = 200
|
||||
return response
|
||||
|
||||
|
||||
class Config:
|
||||
def bool(self, key, default=True):
|
||||
return True
|
||||
|
||||
def int(self, key, default=0):
|
||||
return default
|
||||
|
||||
def text(self, key, default=""):
|
||||
return default
|
||||
|
||||
|
||||
class FakeRequest:
|
||||
def __init__(self, args=None, body=None):
|
||||
self.args = dict(args or {})
|
||||
self._body = dict(body or {})
|
||||
|
||||
async def get_json(self, silent=False):
|
||||
return self._body
|
||||
|
||||
|
||||
def make_service(temp_dir):
|
||||
service = object.__new__(MemoryCompanionService)
|
||||
service.config = Config()
|
||||
service.store = MemoryStore(Path(temp_dir) / "memory.db")
|
||||
service.store.initialize()
|
||||
service._schedule_memory_embedding = lambda *args, **kwargs: None
|
||||
service.portable_archive = PortableMemoryArchive(service.store, temp_dir)
|
||||
return service
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def api(monkeypatch):
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
service = make_service(temp)
|
||||
monkeypatch.setattr(page_api_module, "jsonify", _jsonify)
|
||||
instance = object.__new__(page_api_module.PluginPageApi)
|
||||
instance.plugin = SimpleNamespace(service=service)
|
||||
try:
|
||||
yield instance, service, monkeypatch
|
||||
finally:
|
||||
service.store.close()
|
||||
|
||||
|
||||
def call(bundle, handler, args=None, body=None):
|
||||
instance, _, monkeypatch = bundle
|
||||
monkeypatch.setattr(page_api_module, "request", FakeRequest(args, body))
|
||||
return asyncio.run(getattr(instance, handler)())
|
||||
|
||||
|
||||
def archive_bot(service, memory_type="bot_creative_work", *, key="b1", summary="创作里程碑"):
|
||||
occurred = NOW.isoformat()
|
||||
result = asyncio.run(service.record_bot_personal_memory(
|
||||
memory_type=memory_type, payload={"summary": summary}, occurred_at=occurred,
|
||||
idempotency_key=key, source_refs=[f"ref:{key}"], date=occurred[:10], window="evening",
|
||||
certainty=0.6, evidence_level="L1", version=1, payload_schema_version="1.0",
|
||||
status="active", source_plugin="private_companion"))
|
||||
assert result["ok"] is True, result
|
||||
return result["record_id"]
|
||||
|
||||
|
||||
def insert_user(service, memory_id="usr_1", content="用户喜欢喝美式"):
|
||||
record = MemoryRecord(
|
||||
id=memory_id, memory_type="user_fact", memory_domain=USER_MEMORY_DOMAIN,
|
||||
subject=EntityRef(kind="user", id="u1"), object=EntityRef.bot_self(), scope="private",
|
||||
session_id="s1", visibility="private_pair", sayability="direct",
|
||||
reality_level="real_user_fact", lifecycle="stable_memory", content=content,
|
||||
evidence="x", confidence=0.9, importance=0.6, tags=["user"], metadata={},
|
||||
source_plugin="memory_companion", occurred_at=NOW.isoformat())
|
||||
asyncio.run(service.store.insert_memory(record))
|
||||
return memory_id
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 第 3 条:Bot 域通用修改/删除明确拒绝
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
@pytest.mark.parametrize("handler,body_extra", [
|
||||
("memory_delete", {}),
|
||||
("memory_update", {"content": "被改写的内容"}),
|
||||
("memory_lifecycle", {"lifecycle": "archived"}),
|
||||
("memory_visibility", {"visibility": "private_pair"}),
|
||||
])
|
||||
def test_generic_write_endpoints_reject_bot_domain(api, handler, body_extra):
|
||||
_, service, _ = api
|
||||
record_id = archive_bot(service)
|
||||
response = call(api, handler, body=dict(body_extra, id=record_id))
|
||||
assert response.status_code == 409, (handler, response)
|
||||
assert response["success"] is False
|
||||
assert "locked" in response["error"], response
|
||||
|
||||
|
||||
def test_rejected_write_leaves_the_bot_record_untouched(api):
|
||||
_, service, _ = api
|
||||
record_id = archive_bot(service, summary="原始里程碑")
|
||||
call(api, "memory_delete", body={"id": record_id})
|
||||
call(api, "memory_update", body={"id": record_id, "content": "被改写"})
|
||||
record = asyncio.run(service.store.get_memory(record_id))
|
||||
assert record is not None, "Bot 归档记录被通用删除端点删掉了"
|
||||
assert "原始里程碑" in record.content
|
||||
assert record.memory_domain == BOT_DOMAIN
|
||||
|
||||
|
||||
def test_user_domain_writes_still_work(api):
|
||||
"""拒绝只针对 Bot 域,用户记忆的正常管理不能被误伤。"""
|
||||
_, service, _ = api
|
||||
memory_id = insert_user(service)
|
||||
updated = call(api, "memory_update", body={"id": memory_id, "content": "用户改喝手冲"})
|
||||
assert updated["success"] is True, updated
|
||||
deleted = call(api, "memory_delete", body={"id": memory_id})
|
||||
assert deleted["success"] is True
|
||||
assert deleted["deleted"] is True
|
||||
assert asyncio.run(service.store.get_memory(memory_id)) is None
|
||||
|
||||
|
||||
def test_controlled_archive_path_still_writes_bot_records(api):
|
||||
"""封的是通用入口,不是归档能力本身。"""
|
||||
_, service, _ = api
|
||||
first = archive_bot(service, key="ctl", summary="第一版")
|
||||
again = asyncio.run(service.record_bot_personal_memory(
|
||||
memory_type="bot_creative_work", payload={"summary": "第二版"},
|
||||
occurred_at=NOW.isoformat(), idempotency_key="ctl", source_refs=["ref:ctl"],
|
||||
date=NOW.date().isoformat(), window="evening", certainty=0.6, evidence_level="L1",
|
||||
version=2, payload_schema_version="1.0", status="active", source_plugin="private_companion"))
|
||||
assert again["ok"] is True, again
|
||||
assert again["record_id"] == first
|
||||
assert "第二版" in asyncio.run(service.store.get_memory(first)).content
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 第 4 条:真实 HTTP 状态码 + 写入端点方法约束
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
@pytest.mark.parametrize("handler", ["memory_delete", "memory_update", "memory_lifecycle", "memory_visibility"])
|
||||
def test_missing_id_returns_400(api, handler):
|
||||
response = call(api, handler, body={})
|
||||
assert response.status_code == 400, (handler, response)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("handler", ["memory_delete", "memory_update", "memory_lifecycle", "memory_visibility"])
|
||||
def test_unknown_id_returns_404(api, handler):
|
||||
response = call(api, handler, body={"id": "does-not-exist"})
|
||||
assert response.status_code == 404, (handler, response)
|
||||
|
||||
|
||||
def test_write_endpoints_are_post_only(api):
|
||||
"""写入端点不得挂在 GET 上——GET 可以被跨站的普通链接直接触发。"""
|
||||
instance, service, _ = api
|
||||
registered = []
|
||||
instance.plugin = SimpleNamespace(
|
||||
service=service,
|
||||
context=SimpleNamespace(
|
||||
register_web_api=lambda path, handler, methods, desc: registered.append((path, tuple(methods)))),
|
||||
)
|
||||
instance.register_routes()
|
||||
# 只看真正改状态的端点。`/preview` 是只读预演;`/maintenance/sleep` 自己按方法分流
|
||||
# (GET 返回状态、POST 才执行),都不算把写操作挂在 GET 上。
|
||||
write_markers = ("/update", "/delete", "/apply", "/rollback", "/upsert",
|
||||
"/clear", "/import/run", "/start", "/pause", "/resume")
|
||||
offenders = [
|
||||
(path, methods) for path, methods in registered
|
||||
if any(marker in path for marker in write_markers)
|
||||
and "/preview" not in path and "GET" in methods
|
||||
]
|
||||
assert not offenders, offenders
|
||||
|
||||
|
||||
def test_read_only_bot_archive_routes_never_accept_writes(api):
|
||||
instance, service, _ = api
|
||||
registered = []
|
||||
instance.plugin = SimpleNamespace(
|
||||
service=service,
|
||||
context=SimpleNamespace(
|
||||
register_web_api=lambda path, handler, methods, desc: registered.append((path, tuple(methods)))),
|
||||
)
|
||||
instance.register_routes()
|
||||
for path, methods in registered:
|
||||
if "/bot-archive/" in path:
|
||||
assert methods == ("GET",), path
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 第 2 条:查询、页面、Bridge、导出四层隔离
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def test_layer_query_keeps_domains_apart(api):
|
||||
_, service, _ = api
|
||||
archive_bot(service, summary="Bot 的创作里程碑")
|
||||
insert_user(service, content="用户喜欢喝美式")
|
||||
profile = asyncio.run(service.search_bot_personal_profile("bot_creative", "", now=NOW))
|
||||
assert all("美式" not in m.get("content", "") for m in profile["memories"])
|
||||
|
||||
|
||||
def test_layer_page_keeps_domains_apart(api):
|
||||
_, service, _ = api
|
||||
archive_bot(service, summary="Bot 的创作里程碑")
|
||||
insert_user(service, content="用户喜欢喝美式")
|
||||
body = call(api, "bot_archive_query", args={"profile": "bot_creative"})
|
||||
assert "美式" not in str(body)
|
||||
assert body["memory_domain"] == BOT_DOMAIN
|
||||
|
||||
|
||||
def test_layer_bridge_pins_domain_even_when_caller_lies(api):
|
||||
_, service, _ = api
|
||||
result = asyncio.run(service.record_bot_personal_memory(
|
||||
memory_type="bot_shared_activity",
|
||||
payload={"summary": "共同排障", "memory_domain": USER_MEMORY_DOMAIN,
|
||||
"subject": {"kind": "user", "id": "u1"}},
|
||||
occurred_at=NOW.isoformat(), idempotency_key="mixed", source_refs=["ref:mixed"],
|
||||
date=NOW.date().isoformat(), window="evening", certainty=0.6, evidence_level="L1",
|
||||
version=1, payload_schema_version="1.0", status="active", source_plugin="private_companion"))
|
||||
assert result["ok"] is True, result
|
||||
record = asyncio.run(service.store.get_memory(result["record_id"]))
|
||||
assert record.memory_domain == BOT_DOMAIN
|
||||
assert record.subject.kind == "bot"
|
||||
rows = service.store._conn.execute(
|
||||
"SELECT COUNT(*) FROM memories WHERE memory_domain=?", (USER_MEMORY_DOMAIN,)).fetchone()[0]
|
||||
assert rows == 0, "mixed 活动同时进了用户域"
|
||||
|
||||
|
||||
def test_layer_export_preserves_memory_domain(api):
|
||||
"""导出漏掉 memory_domain 的话,恢复时 bot_self_schedule 会被降级成 bot_self_legacy,
|
||||
检索 Profile 全部失效,重新归档还会撞 domain_conflict。备份恢复正好走这条路。"""
|
||||
_, service, _ = api
|
||||
archive_bot(service, summary="Bot 的创作里程碑")
|
||||
insert_user(service)
|
||||
result = asyncio.run(service.export_portable_data())
|
||||
lines = Path(result["path"]).read_text(encoding="utf-8").splitlines()
|
||||
header = json.loads(lines[0])
|
||||
memories = [json.loads(line)["data"] for line in lines[1:] if json.loads(line)["record_type"] == "memory"]
|
||||
domains = {m["memory_domain"] for m in memories}
|
||||
assert BOT_DOMAIN in domains and USER_MEMORY_DOMAIN in domains, domains
|
||||
assert header["memory_domain_counts"].get(BOT_DOMAIN) == 1
|
||||
assert header["memory_domain_counts"].get(USER_MEMORY_DOMAIN) == 1
|
||||
|
||||
|
||||
def test_layer_export_round_trip_does_not_downgrade_bot_domain(api):
|
||||
_, service, _ = api
|
||||
archive_bot(service, summary="Bot 的创作里程碑")
|
||||
result = asyncio.run(service.export_portable_data())
|
||||
payload = next(
|
||||
json.loads(line)["data"] for line in Path(result["path"]).read_text(encoding="utf-8").splitlines()
|
||||
if json.loads(line)["record_type"] == "memory")
|
||||
restored = PortableMemoryArchive._memory_record(payload, "batch-1")
|
||||
assert restored.memory_domain == BOT_DOMAIN, "恢复后 Bot 域被降级"
|
||||
|
||||
|
||||
def test_legacy_export_without_domain_still_imports(api):
|
||||
"""老导出没有 memory_domain 字段,必须仍能导入(回落到旧推断),不能直接崩。"""
|
||||
payload = {
|
||||
"id": "old_1", "memory_type": "bot_creative_work",
|
||||
"subject": {"kind": "bot", "id": "self"}, "object": {"kind": "bot", "id": "self"},
|
||||
"scope": "private", "session_id": "bot_personal", "visibility": "bot_self",
|
||||
"sayability": "indirect", "reality_level": "creative_work", "lifecycle": "stable_memory",
|
||||
"content": "旧导出记录", "evidence": "x", "confidence": 0.8, "importance": 0.5,
|
||||
"tags": [], "metadata": {}, "occurred_at": NOW.isoformat(),
|
||||
}
|
||||
restored = PortableMemoryArchive._memory_record(payload, "batch-old")
|
||||
restored.ensure_defaults() # 与 store 写入时同款调用
|
||||
assert restored.memory_domain # 有值即可,具体值由旧推断决定
|
||||
assert restored.content == "旧导出记录"
|
||||
正在加载…
添加表格
在新工单中引用