astrbot_plugin_memory_compa.../tests/test_summary_relationship.py

957 行
37 KiB
Python

from __future__ import annotations
import asyncio
import json
import sys
import tempfile
import unittest
from pathlib import Path
from types import SimpleNamespace
ROOT = Path(__file__).resolve().parents[1]
if str(ROOT.parent) not in sys.path:
sys.path.insert(0, str(ROOT.parent))
from core import context_orchestration as p3_contract
from core.bridge import MemoryCompanionBridge
from core.models import EntityRef, MemoryRecord, SearchResult, SessionContext
from core.service import MemoryCompanionService
from core.summarizer import MemorySummarizer
class _Response:
def __init__(self, text: str):
self.completion_text = text
class _TextProvider:
def __init__(self, text: str, delay: float = 0.0):
self.text = text
self.delay = delay
async def text_chat(self, **_kwargs):
if self.delay:
await asyncio.sleep(self.delay)
return _Response(self.text)
class _CapturingProvider:
def __init__(self, text: str):
self.text = text
self.prompt = ""
async def text_chat(self, **kwargs):
self.prompt = str(kwargs.get("prompt") or "")
return _Response(self.text)
class SummaryAndRelationshipTests(unittest.IsolatedAsyncioTestCase):
def make_service(self, config: dict | None = None, *, context=None) -> MemoryCompanionService:
temp_dir = tempfile.TemporaryDirectory()
self.addCleanup(temp_dir.cleanup)
service = MemoryCompanionService(
context=context,
config=config or {},
plugin_root=ROOT,
data_dir=Path(temp_dir.name),
)
self.addCleanup(service.close)
return service
async def test_async_close_finishes_background_cancellation_before_store_close(self) -> None:
service = self.make_service()
started = asyncio.Event()
finalized = asyncio.Event()
async def background_work() -> None:
started.set()
try:
await asyncio.Event().wait()
finally:
await asyncio.sleep(0)
finalized.set()
task = service._spawn_background(background_work(), label="shutdown_test")
self.assertIsNotNone(task)
await started.wait()
await service.aclose()
self.assertTrue(finalized.is_set())
self.assertTrue(task.done())
self.assertTrue(service.store._closed)
async def test_fast_context_capabilities_can_be_rolled_back_independently(self) -> None:
service = self.make_service(
{
"private_companion_bridge": {
"enabled": True,
"schedule_fast_context_enabled": False,
"outfit_fast_context_enabled": True,
}
}
)
status = service.companion_coordination_status()
self.assertFalse(status["schedule_fast_context"])
self.assertTrue(status["outfit_fast_context"])
async def test_schedule_fast_context_skips_semantic_providers_and_unrelated_memory(self) -> None:
service = self.make_service()
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
message_text="Private Companion 日程连续性",
)
await service.store.insert_memory(
MemoryRecord(
id="fast-schedule",
memory_type="schedule_fragment",
subject=EntityRef.bot_self(),
object=EntityRef(kind="user", id="u1"),
scope="private",
session_id=ctx.session_id,
visibility="bot_self",
reality_level="persona_life",
lifecycle="stable_memory",
content="傍晚回来继续剪视频。",
)
)
await service.store.insert_memory(
MemoryRecord(
id="unrelated-summary",
memory_type="conversation_summary",
subject=EntityRef(kind="user", id="u1"),
object=EntityRef.bot_self(),
scope="private",
session_id=ctx.session_id,
visibility="private_pair",
lifecycle="stable_memory",
content="一段与日程无关的旧聊天。",
)
)
await service.store.insert_memory(
MemoryRecord(
id="unrelated-manual",
memory_type="manual_memory",
subject=EntityRef(kind="user", id="u1"),
object=EntityRef.bot_self(),
scope="private",
session_id=ctx.session_id,
visibility="private_pair",
lifecycle="stable_memory",
content="用户明确记住过一条与日程无关的内衣话题。",
)
)
await service.store.insert_memory(
MemoryRecord(
id="unrelated-preference",
memory_type="user_preference",
subject=EntityRef(kind="user", id="u1"),
object=EntityRef.bot_self(),
scope="private",
session_id=ctx.session_id,
visibility="private_pair",
lifecycle="stable_memory",
content="用户喜欢胖次话题。",
)
)
async def fail_if_called(*_args, **_kwargs):
raise AssertionError("generic retrieval engine must not run for schedule_fast")
service._retrieval_engine = fail_if_called
bridge = MemoryCompanionBridge(service)
text = await bridge.compose_context(
query=ctx.message_text,
session_context={
"session_id": ctx.session_id, "scope": ctx.scope, "user_id": ctx.user_id,
"bot_id": ctx.bot_id, "message_text": ctx.message_text,
},
top_k=5,
max_chars=1200,
retrieval_profile="schedule_fast",
)
self.assertIn("傍晚回来继续剪视频", text)
self.assertNotIn("与日程无关的旧聊天", text)
self.assertNotIn("内衣话题", text)
self.assertNotIn("胖次话题", text)
self.assertEqual("schedule_fast_local", service._last_retrieval_path_info["path"])
self.assertEqual("skipped_schedule_fast", service._last_retrieval_path_info["embedding_reason"])
async def test_short_group_reply_chain_keeps_only_quote_relevant_memories(self) -> None:
service = self.make_service()
ctx = SessionContext(
session_id="qq:GroupMessage:g1",
scope="group",
group_id="g1",
user_id="u1",
bot_id="b1",
message_text="让比折给你送",
)
event = SimpleNamespace(
private_companion_reply_message_chain=[
{
"message_id": "quoted-1",
"depth": 1,
"text": "可不是嘛,界园欠我一个送包子的信使呢!",
}
]
)
relevant_open_loop = SearchResult(
MemoryRecord(id="package-promise", content="答应等信使打完界园后送包子。"),
2.4,
)
unrelated_schedule = SearchResult(
MemoryRecord(id="unrelated-school", content="Bot 自称不是小机器人而是普通高中生。"),
2.3,
)
relevant_action = SearchResult(
MemoryRecord(id="package-action", content="建议先找零食,等界园里的信使送包子。"),
2.2,
)
relevant_summary = SearchResult(
MemoryRecord(id="package-summary", content="群里讨论了界园路线和送包子的安排。"),
2.1,
)
blocked: list[dict] = []
anchor = service._short_reply_chain_anchor(ctx, event)
filtered = service._filter_short_reply_chain_slots(
{
"open_loop": [relevant_open_loop],
"self_timeline": [unrelated_schedule, relevant_action],
"conversation_summary": [relevant_summary],
},
anchor,
blocked,
)
selected_ids = {item.memory.id for items in filtered.values() for item in items}
self.assertIn("界园", anchor)
self.assertEqual({"package-promise", "package-action", "package-summary"}, selected_ids)
self.assertTrue(any(item.get("id") == "unrelated-school" for item in blocked))
self.assertLessEqual(sum(len(items) for items in filtered.values()), 3)
async def test_main_injection_applies_short_quote_limits_and_actor_guard(self) -> None:
service = self.make_service(
{
"memory_injection": {"enable_injection_logs": False, "max_chars": 1800},
"conversation_memory_advanced": {
"low_information_guard_enabled": False,
"topic_shift_guard_enabled": False,
},
}
)
ctx = SessionContext(
session_id="qq:GroupMessage:g1",
scope="group",
group_id="g1",
user_id="u1",
bot_id="b1",
message_text="让比折给你送",
)
event = SimpleNamespace(
private_companion_reply_message_chain=[
{
"message_id": "quoted-1",
"depth": 1,
"text": "可不是嘛,界园欠我一个送包子的信使呢!",
}
]
)
relevant_open_loop = SearchResult(
MemoryRecord(id="package-promise", content="答应等信使打完界园后送包子。"),
2.4,
)
unrelated_schedule = SearchResult(
MemoryRecord(id="unrelated-school", content="Bot 自称不是小机器人而是普通高中生。"),
2.3,
)
relevant_action = SearchResult(
MemoryRecord(id="package-action", content="建议先找零食,等界园里的信使送包子。"),
2.2,
)
relevant_summary = SearchResult(
MemoryRecord(id="package-summary", content="群里讨论了界园路线和送包子的安排。"),
2.1,
)
relevant_window = SearchResult(
MemoryRecord(id="package-window", content="刚才仍在聊界园和包子。"),
2.0,
)
async def fake_search_context_slots(*_args, **_kwargs):
slot_map = {
"open_loop": [relevant_open_loop],
"self_timeline": [unrelated_schedule, relevant_action],
"conversation_summary": [relevant_summary],
"current_window": [relevant_window],
}
return list(slot_map.values())[0], [], slot_map
service.search_context_slots = fake_search_context_slots
captured: dict[str, object] = {}
original_compose = service.injection.compose
def capture_compose(*args, **kwargs):
captured.update(kwargs)
if len(args) >= 3:
captured["max_chars"] = args[2]
return original_compose(*args, **kwargs)
service.injection.compose = capture_compose
req = SimpleNamespace(prompt="", system_prompt="", contexts=[], extra_user_content_parts=[])
await service.inject_memories(ctx, req, event=event)
state = getattr(req, "memory_companion_injection_state", {})
self.assertTrue(state.get("injected"))
self.assertEqual(
{"package-promise", "package-action", "package-summary"},
set(state.get("selected_memory_ids") or []),
)
self.assertNotIn("unrelated-school", state.get("selected_memory_ids") or [])
self.assertLessEqual(int(captured.get("max_chars") or 0), 1050)
self.assertTrue(captured.get("compact_memory"))
self.assertIn("人物、动作和地点尽量按原句对应", str(captured.get("intent_context") or ""))
async def test_recent_fact_guard_keeps_shower_fact_and_bot_acknowledgement(self) -> None:
self.assertEqual(set(), MemoryCompanionService._recent_fact_categories("你刚洗完澡吗?"))
self.assertEqual(set(), MemoryCompanionService._recent_fact_categories("我问你洗澡了吗?"))
self.assertEqual(
{"meal", "bath"},
MemoryCompanionService._recent_fact_categories("早吃过啦~刚才洗澡去了~"),
)
service = self.make_service(
{
"conversation_memory_advanced": {
"recent_fact_guard_enabled": True,
"recent_fact_guard_hours": 3,
"recent_fact_guard_event_limit": 24,
"recent_fact_guard_max_items": 4,
}
}
)
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
bot_id="b1",
message_text="我哪里凶你了,你不要冤枉人",
)
await service.store.add_timeline_event(
event_type="user_message",
session_id=ctx.session_id,
scope=ctx.scope,
subject_id=ctx.user_id,
object_id=ctx.user_id,
content="早吃过啦~刚才洗澡去了~",
metadata={"message_id": "shower-user"},
)
await service.store.add_timeline_event(
event_type="bot_response",
session_id=ctx.session_id,
scope=ctx.scope,
subject_id=ctx.bot_id,
object_id=ctx.user_id,
content="洗完澡是不是舒服多啦?",
metadata={"message_id": "shower-bot"},
)
recent_context = await service._recent_fact_guard_context(ctx)
injected = service.injection.compose(
ctx,
[],
max_chars=1800,
recent_fact_context=recent_context,
)
bridge = MemoryCompanionBridge(service)
bridged = await bridge.compose_injection(
"不是这样",
session_context={
"session_id": ctx.session_id, "scope": ctx.scope, "user_id": ctx.user_id,
"bot_id": ctx.bot_id, "message_text": ctx.message_text,
},
max_chars=1800,
)
self.assertIn("刚才洗澡去了", recent_context)
self.assertIn("Bot 随后已围绕此事回应", recent_context)
self.assertIn("洗完澡是不是舒服多啦", recent_context)
self.assertIn("<recent_fact_context>", injected)
self.assertIn("<recent_fact_context>", bridged)
self.assertIn("优先自然承认刚才没接住", injected)
async def test_topic_shift_guard_does_not_trim_astrbot_conversation_history(self) -> None:
service = self.make_service(
{
"memory_injection": {"enable_injection_logs": False},
"retrieval": {"mode": "basic"},
"conversation_memory_advanced": {
"topic_shift_guard_enabled": True,
"suppress_memory_on_topic_shift": True,
},
}
)
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
bot_id="b1",
message_text="给我发一张自拍",
)
await service.store.add_timeline_event(
event_type="user_message",
session_id=ctx.session_id,
scope=ctx.scope,
subject_id=ctx.user_id,
object_id=ctx.user_id,
content="刚才吃过晚饭,已经回宿舍了。",
metadata={"message_id": "state-before-photo"},
)
original_contexts = [
{"role": "user", "content": "早吃过啦,刚才洗澡去了。"},
{"role": "assistant", "content": "洗完澡舒服多啦?"},
{"role": "user", "content": "想看看你的自拍。"},
{"role": "assistant", "content": "等我一下。"},
{"role": "user", "content": "拍好了吗?"},
{"role": "assistant", "content": "快好啦。"},
]
req = SimpleNamespace(
prompt="",
system_prompt="",
contexts=[dict(item) for item in original_contexts],
extra_user_content_parts=[],
)
await service.inject_memories(ctx, req)
self.assertEqual(original_contexts, req.contexts)
async def test_cold_joke_request_skips_group_long_term_retrieval(self) -> None:
service = self.make_service({"memory_injection": {"enable_injection_logs": False}})
ctx = SessionContext(
session_id="qq:GroupMessage:g1",
scope="group",
platform="qq",
group_id="g1",
user_id="u1",
bot_id="b1",
message_text="给我讲个冷笑话",
)
async def fail_if_called(*_args, **_kwargs):
raise AssertionError("standalone generation must not start long-term retrieval")
service.search_context_slots = fail_if_called
captured: dict[str, object] = {}
original_compose = service.injection.compose
def capture_compose(*args, **kwargs):
captured["result_count"] = len(args[1]) if len(args) > 1 else -1
captured["intent_context"] = kwargs.get("intent_context", "")
return original_compose(*args, **kwargs)
service.injection.compose = capture_compose
req = SimpleNamespace(prompt="", system_prompt="", contexts=[], extra_user_content_parts=[])
await service.inject_memories(ctx, req)
self.assertEqual(0, captured.get("result_count"))
self.assertIn("独立的轻量创作请求", str(captured.get("intent_context") or ""))
state = getattr(req, "memory_companion_injection_state", {})
self.assertEqual([], state.get("selected_memory_ids") or [])
async def test_personalized_story_request_still_runs_long_term_retrieval(self) -> None:
service = self.make_service({"memory_injection": {"enable_injection_logs": False}})
ctx = SessionContext(
session_id="qq:GroupMessage:g1",
scope="group",
platform="qq",
group_id="g1",
user_id="u1",
bot_id="b1",
message_text="给我讲个符合我性格的故事",
)
called = False
async def fake_search(*_args, **_kwargs):
nonlocal called
called = True
return [], [], {}
service.search_context_slots = fake_search
req = SimpleNamespace(prompt="", system_prompt="", contexts=[], extra_user_content_parts=[])
await service.inject_memories(ctx, req)
self.assertTrue(called)
state = getattr(req, "memory_companion_injection_state", {})
self.assertTrue(state.get("injected"))
async def test_outfit_fast_context_balances_history_schedule_preference_and_photo(self) -> None:
service = self.make_service()
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
message_text="今日穿搭、历史穿搭、服装偏好和最近自拍",
)
p3_state = p3_contract.new_context_state(session_id=ctx.session_id, scope=ctx.scope)
for layer in ("persona", "runtime", "person", "scene"):
p3_contract.complete_layer(p3_state, layer)
ctx.context_orchestration = p3_contract.project_context_state(p3_state) or {}
ctx.context_orchestration_status = "accepted"
records = [
MemoryRecord(
id="outfit-schedule",
memory_type="schedule_fragment",
subject=EntityRef.bot_self(),
object=EntityRef(kind="user", id="u1"),
scope="private",
session_id=ctx.session_id,
visibility="bot_self",
reality_level="persona_life",
lifecycle="stable_memory",
content="今天下午需要出门,天气偏凉。",
),
MemoryRecord(
id="private_companion_daily_outfit_2026-07-13",
memory_type="persona_life",
subject=EntityRef.bot_self(),
scope="unknown",
session_id="private_companion:daily_outfit",
visibility="bot_self",
reality_level="persona_life",
lifecycle="stable_memory",
content="昨天的每日穿搭图使用了白色短袖和深蓝半裙。",
tags=["daily_outfit", "clothing"],
),
MemoryRecord(
id="outfit-preference",
memory_type="user_preference",
subject=EntityRef(kind="user", id="u1"),
object=EntityRef.bot_self(),
scope="private",
session_id=ctx.session_id,
visibility="private_pair",
lifecycle="stable_memory",
content="用户更喜欢浅蓝色外套和简洁配色。",
),
MemoryRecord(
id="outfit-photo",
memory_type="image_action",
subject=EntityRef.bot_self(),
object=EntityRef(kind="user", id="u1"),
scope="private",
session_id=ctx.session_id,
visibility="bot_self",
reality_level="bot_action",
lifecycle="stable_memory",
content="最近一张自拍是在窗边拍的半身照。",
),
MemoryRecord(
id="outfit-unrelated",
memory_type="conversation_summary",
subject=EntityRef(kind="user", id="u1"),
object=EntityRef.bot_self(),
scope="private",
session_id=ctx.session_id,
visibility="private_pair",
lifecycle="stable_memory",
content="一段与穿搭完全无关的旧聊天。",
),
MemoryRecord(
id="outfit-unrelated-image",
memory_type="image_action",
subject=EntityRef.bot_self(),
object=EntityRef(kind="user", id="u1"),
scope="private",
session_id=ctx.session_id,
visibility="bot_self",
reality_level="bot_action",
lifecycle="stable_memory",
content="最近生成了一张数据库架构示意图。",
),
]
for record in records:
await service.store.insert_memory(record)
async def fail_if_called(*_args, **_kwargs):
raise AssertionError("generic retrieval engine must not run for outfit_fast")
service._retrieval_engine = fail_if_called
text = await service.bridge_compose_context(
query=ctx.message_text,
session_context=ctx,
top_k=5,
max_chars=1400,
retrieval_profile="outfit_fast",
)
self.assertIn("天气偏凉", text)
self.assertIn("白色短袖和深蓝半裙", text)
self.assertIn("浅蓝色外套和简洁配色", text)
self.assertIn("窗边拍的半身照", text)
self.assertNotIn("与穿搭完全无关", text)
self.assertNotIn("数据库架构", text)
self.assertEqual("outfit_fast_local", service._last_retrieval_path_info["path"])
self.assertEqual("skipped_outfit_fast", service._last_retrieval_path_info["embedding_reason"])
self.assertTrue(service.companion_coordination_status()["outfit_fast_context"])
async def test_non_json_summary_is_rejected(self) -> None:
summarizer = MemorySummarizer(provider_timeout_seconds=1)
rows = [{"content": "一条需要总结的消息", "scope": "private", "subject_id": "u1"}]
with self.assertRaisesRegex(ValueError, "invalid JSON"):
await summarizer.summarize_with_provider(
_TextProvider("这不是 JSON,只是一段自由文本"),
rows=rows,
session_label="私聊 u1",
)
async def test_summary_provider_timeout_is_enforced(self) -> None:
summarizer = MemorySummarizer(provider_timeout_seconds=0.01)
rows = [{"content": "一条需要总结的消息", "scope": "private", "subject_id": "u1"}]
with self.assertRaisesRegex(TimeoutError, "总结模型在 0.01 秒内未返回"):
await summarizer.summarize_with_provider(
_TextProvider('{"summary":"ok"}', delay=0.1),
rows=rows,
session_label="私聊 u1",
)
async def test_summary_provider_attempts_do_not_repeat_same_runtime_provider(self) -> None:
provider = _TextProvider('{"summary":"ok"}')
async def get_provider_by_id(_provider_id):
return provider
async def get_using_provider(_session_id):
return provider
context = SimpleNamespace(
get_provider_by_id=get_provider_by_id,
get_using_provider=get_using_provider,
)
service = self.make_service(
{
"memory_summary": {
"provider_id": "ollama-summary",
"fallback_provider_id": "ollama-fallback",
}
},
context=context,
)
attempts = await service._summary_provider_attempts(
SessionContext(session_id="qq:FriendMessage:u1", scope="private", user_id="u1")
)
self.assertEqual(1, len(attempts))
self.assertEqual("primary", attempts[0]["source"])
self.assertIs(provider, attempts[0]["provider"])
async def test_summary_reports_only_rows_actually_sent_to_provider(self) -> None:
summarizer = MemorySummarizer(max_input_chars=1000, provider_timeout_seconds=1)
rows = [
{
"id": f"event-{index}",
"event_type": "user_message",
"scope": "private",
"subject_id": "u1",
"content": f"第{index}条" + ("很长的消息" * 120),
"occurred_at": f"2026-07-15T0{index}:00:00+08:00",
}
for index in range(1, 4)
]
provider = _CapturingProvider(
json.dumps(
{
"summary": "只总结实际看到的消息。",
"canonical_summary": "已消费事件摘要。",
"key_facts": ["事件有明确证据"],
"importance": 0.6,
},
ensure_ascii=False,
)
)
payload = await summarizer.summarize_with_provider(provider, rows=rows, session_label="测试")
consumed = payload.get("_consumed_event_ids") or []
self.assertGreaterEqual(len(consumed), 1)
self.assertLess(len(consumed), len(rows))
self.assertIn(consumed[-1], provider.prompt)
self.assertNotIn(rows[-1]["id"], provider.prompt)
async def test_retry_exhaustion_preserves_unsummarized_timeline(self) -> None:
service = self.make_service(
{
"memory_summary": {
"enabled": True,
"min_events": 1,
"trigger_event_count": 1,
"max_retries": 1,
}
}
)
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
)
timeline_id = await service.store.add_timeline_event(
event_type="user_message",
session_id=ctx.session_id,
scope=ctx.scope,
subject_id=ctx.user_id,
object_id=ctx.user_id,
content="不能丢失的原始时间线",
metadata={"message_id": "m-dead-letter"},
)
await service.store.record_summary_failure(
session_id=ctx.session_id,
scope=ctx.scope,
start_timeline_id=timeline_id,
end_timeline_id=timeline_id,
error="provider failed",
)
self.assertEqual("", await service.maybe_summarize_session(ctx))
row = service.store._conn.execute(
"SELECT summarized_at FROM timeline WHERE id=?", (timeline_id,)
).fetchone()
self.assertEqual("", row["summarized_at"])
failure = await service.store.get_summary_failure(ctx.session_id)
self.assertEqual("dead_letter", failure["metadata"]["state"])
async def test_transient_summary_failure_enters_quiet_cooldown(self) -> None:
service = self.make_service(
{
"memory_summary": {
"enabled": True,
"min_events": 1,
"trigger_event_count": 1,
"max_retries": 1,
"transient_retry_cooldown_minutes": 10,
}
}
)
ctx = SessionContext(
session_id="qq:GroupMessage:g1",
scope="group",
platform="qq",
group_id="g1",
user_id="u1",
)
timeline_id = await service.store.add_timeline_event(
event_type="user_message",
session_id=ctx.session_id,
scope=ctx.scope,
subject_id=ctx.user_id,
object_id=ctx.group_id,
content="等待连接恢复后再总结",
metadata={"message_id": "m-transient-cooldown"},
)
await service.store.record_summary_failure(
session_id=ctx.session_id,
scope=ctx.scope,
start_timeline_id=timeline_id,
end_timeline_id=timeline_id,
error="APIConnectionError: Connection error.",
)
async def fail_if_called(*_args, **_kwargs):
raise AssertionError("provider must not run during transient cooldown")
service._summary_provider_attempts = fail_if_called
self.assertEqual("", await service.maybe_summarize_session(ctx))
first = await service.store.get_summary_failure(ctx.session_id)
self.assertEqual("transient_cooldown", first["metadata"]["state"])
self.assertEqual("", await service.maybe_summarize_session(ctx))
second = await service.store.get_summary_failure(ctx.session_id)
self.assertEqual(first["updated_at"], second["updated_at"])
row = service.store._conn.execute(
"SELECT summarized_at FROM timeline WHERE id=?", (timeline_id,)
).fetchone()
self.assertEqual("", row["summarized_at"])
async def test_transient_summary_cooldown_auto_recovers(self) -> None:
service = self.make_service(
{
"memory_summary": {
"enabled": True,
"min_events": 1,
"trigger_event_count": 1,
"max_retries": 1,
"retry_backoff_seconds": 0,
"transient_retry_cooldown_minutes": 0,
}
}
)
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
bot_id="b1",
)
timeline_id = await service.store.add_timeline_event(
event_type="user_message",
session_id=ctx.session_id,
scope=ctx.scope,
subject_id=ctx.user_id,
object_id=ctx.bot_id,
content="网络恢复后可以自动完成总结",
metadata={"message_id": "m-transient-recover"},
)
await service.store.record_summary_failure(
session_id=ctx.session_id,
scope=ctx.scope,
start_timeline_id=timeline_id,
end_timeline_id=timeline_id,
error="Connection error.",
)
provider = _TextProvider(
json.dumps(
{
"summary": "网络恢复后完成了阶段总结。",
"canonical_summary": "用户确认网络恢复后可以继续总结。",
"persona_summary": "我在网络恢复后完成了阶段总结。",
"key_facts": ["连接已恢复"],
"topics": ["阶段总结"],
"importance": 0.6,
},
ensure_ascii=False,
)
)
async def attempts(*_args, **_kwargs):
return [{"source": "primary", "provider_id": "test-summary", "provider": provider}]
service._summary_provider_attempts = attempts
self.assertEqual("", await service.maybe_summarize_session(ctx))
failure = await service.store.get_summary_failure(ctx.session_id)
self.assertEqual("transient_cooldown", failure["metadata"]["state"])
memory_id = await service.maybe_summarize_session(ctx)
self.assertTrue(memory_id)
self.assertIsNone(await service.store.get_summary_failure(ctx.session_id))
row = service.store._conn.execute(
"SELECT summarized_at FROM timeline WHERE id=?", (timeline_id,)
).fetchone()
self.assertTrue(row["summarized_at"])
def test_summary_failure_transience_is_narrow(self) -> None:
self.assertTrue(MemoryCompanionService._summary_failure_is_transient("Connection error."))
self.assertTrue(MemoryCompanionService._summary_failure_is_transient("HTTP 503 Service Unavailable"))
self.assertTrue(MemoryCompanionService._summary_failure_is_transient("ReadTimeout"))
self.assertTrue(
MemoryCompanionService._summary_failure_is_transient(
"Error code: 402 - {'error': {'message': 'Insufficient Balance', 'code': 'invalid_request_error'}}"
)
)
self.assertTrue(MemoryCompanionService._summary_failure_is_transient("type=insufficient_quota"))
self.assertTrue(MemoryCompanionService._summary_failure_is_transient("You exceeded your current quota"))
self.assertFalse(MemoryCompanionService._summary_failure_is_transient("invalid JSON response"))
self.assertFalse(MemoryCompanionService._summary_failure_is_transient("empty summary content"))
self.assertFalse(
MemoryCompanionService._summary_failure_is_transient(
"invalid_request_error: messages must contain text"
)
)
async def test_one_message_advances_relationship_at_most_once(self) -> None:
service = self.make_service()
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
bot_id="b1",
message_id="turn-1",
)
results = [
SearchResult(
MemoryRecord(id=f"m{index}", metadata={"emotional_weight": 0.9, "relationship_weight": 0.7}),
score=1.0,
)
for index in range(3)
]
service._maybe_record_persona_touch(ctx, results)
service._maybe_record_persona_touch(ctx, results)
state = service._get_relationship_phase(ctx)
self.assertEqual(1, state["touch_count"])
self.assertEqual(["turn-1"], state["recent_touch_message_ids"])
saved = json.loads(service._RELATIONSHIP_PHASE_FILE.read_text(encoding="utf-8"))
self.assertIn(service._phase_key(ctx), saved)
async def test_intermediate_relationship_phase_can_downgrade(self) -> None:
service = self.make_service()
ctx = SessionContext(
session_id="qq:FriendMessage:u1",
scope="private",
platform="qq",
user_id="u1",
bot_id="b1",
)
state = {"phase": "close", "momentum": -0.25, "touch_count": 10}
service._maybe_transition_phase(ctx, state)
self.assertEqual("familiar", state["phase"])
async def test_phase_key_isolates_bot_and_group_member_and_bridge_normalizes(self) -> None:
service = self.make_service()
first = SessionContext(
session_id="qq:GroupMessage:g1",
scope="group",
platform="qq",
group_id="g1",
user_id="u1",
bot_id="b1",
)
second_member = SessionContext(
session_id=first.session_id,
scope="group",
platform="qq",
group_id="g1",
user_id="u2",
bot_id="b1",
)
second_bot = SessionContext(
session_id=first.session_id,
scope="group",
platform="qq",
group_id="g1",
user_id="u1",
bot_id="b2",
)
self.assertNotEqual(service._phase_key(first), service._phase_key(second_member))
self.assertNotEqual(service._phase_key(first), service._phase_key(second_bot))
private = SessionContext(
session_id="qq:FriendMessage:u9",
scope="private",
platform="qq",
user_id="u9",
bot_id="b1",
)
state = service._get_relationship_phase(private)
state["phase"] = "close"
bridge = MemoryCompanionBridge(service)
bridged = bridge.get_relationship_phase(session_id=private.session_id, scope="private")
self.assertIs(state, bridged)
if __name__ == "__main__":
unittest.main()