Python
# -*- coding: utf-8 -*-
"""
L7_INTENTION 层去重(0805 事故修复 · v2)单测。
覆盖:
1. Recall dedup(含超采样 + memory_at/valid_until/cosine 联合判重 + 异步删)
2. Writer batch dedup(只做批内,不查 VDB)
3. READ_REQUEST 日志携带 intention_limit(可观测性)
不依赖 chromadb / venus embedding / numpy,全内存假 VDB。
"""
from __future__ import annotations
import asyncio
import hashlib
import uuid
from datetime import date, datetime, timedelta
from typing import Any, Dict, List, Optional
from hy_memory.models.memory import MemoryLayer, MemoryStatus, MemoryNode
from hy_memory.pipelines._retrieval.intention import (
_cosine,
_memory_at_day,
_valid_until_key,
_partition_duplicates,
recall_intentions,
)
# ============================================================================
# Fakes
# ============================================================================
def _run(coro):
"""跑一次 coro,等所有后台任务(async delete)自然完成后再关 loop。"""
loop = asyncio.new_event_loop()
try:
result = loop.run_until_complete(coro)
# 让 fire-and-forget 的 create_task 有机会执行完
pending = [t for t in asyncio.all_tasks(loop) if not t.done()]
if pending:
loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
return result
finally:
loop.close()
class _FakeEmbedByHash:
"""按 text hash 分配 one-hot 稀疏向量:hash 相同 → cosine=1;不同 → cosine=0。"""
def __init__(self, dims: int = 64):
self.dims = dims
def vec_for(self, text: str) -> List[float]:
v = [0.0] * self.dims
# 确定性哈希:内建 hash() 每个进程随机化,会让不同文案偶发撞格、
# 被误判成复本,测试随 PYTHONHASHSEED 变 flaky。
v[int(hashlib.md5(text.encode()).hexdigest(), 16) % self.dims] = 1.0
return v
async def embed_batch(self, texts):
return [self.vec_for(t) for t in texts]
async def embed_queued(self, text):
return self.vec_for(text)
class _FakeVectorStore:
"""最小可用内存 VDB。search 按 dot-product 排序返回。"""
def __init__(self):
self._nodes: Dict[str, MemoryNode] = {}
self.delete_calls: List[str] = []
self.update_payload_calls: List[tuple] = []
async def upsert(self, node: MemoryNode) -> str:
nid = node.node_id or uuid.uuid4().hex
node.node_id = nid
self._nodes[nid] = node
return nid
async def delete(self, node_id: str):
self.delete_calls.append(node_id)
self._nodes.pop(node_id, None)
async def update_payload(self, node_id: str, patch: Dict[str, Any]):
self.update_payload_calls.append((node_id, patch))
n = self._nodes.get(node_id)
if not n:
return
for k, v in patch.items():
setattr(n, k, v)
async def search(
self,
*,
query_embedding=None,
isolation_key: str = "",
isolation_keys=None,
user_ids=None,
agent_ids=None,
layers=None,
limit: int = 10,
score_threshold: float = 0.0,
status_filter=None,
only_latest: bool = True,
**kwargs,
):
results = []
for nid, n in self._nodes.items():
if layers and n.layer not in layers:
continue
if isolation_keys:
if n.get_isolation_key() not in isolation_keys:
continue
elif isolation_key:
if n.get_isolation_key() != isolation_key:
continue
if user_ids and n.user_id not in user_ids:
continue
if agent_ids and n.agent_id not in agent_ids:
continue
if status_filter and n.status not in status_filter:
continue
if only_latest and not n.is_latest:
continue
emb = n.embedding or []
score = sum(a * b for a, b in zip(query_embedding or [], emb))
if score < score_threshold:
continue
results.append({"node_id": nid, "node": n, "score": score})
results.sort(key=lambda r: r["score"], reverse=True)
return results[:limit]
def _make_intention_node(
content: str,
*,
user_id: str = "u1",
agent_id: str = "a1",
session_id: str = "s1",
memory_at: Optional[datetime] = None,
valid_until: Optional[datetime] = None,
gmt_created: Optional[datetime] = None,
tags: Optional[List[str]] = None,
embedding: Optional[List[float]] = None,
dims: int = 64,
) -> MemoryNode:
n = MemoryNode(
node_id=uuid.uuid4().hex,
user_id=user_id,
agent_id=agent_id,
session_id=session_id,
layer=MemoryLayer.L7_INTENTION,
content=content,
embedding=embedding or _FakeEmbedByHash(dims).vec_for(content),
status=MemoryStatus.ACTIVE,
is_latest=True,
tags=list(tags or []),
memory_at=memory_at,
valid_until=valid_until,
)
if gmt_created is not None:
n.gmt_created = gmt_created
return n
# ============================================================================
# 1. Recall dedup 相关(含新的 memory_at + valid_until 判重规则)
# ============================================================================
def test_cosine_identical_and_orthogonal():
"""cosine 基础健壮性:同向量=1,正交=0,空/零向量=-inf。"""
v = [1.0, 0.0, 0.0]
assert _cosine(v, v) == 1.0
assert _cosine([1.0, 0.0], [0.0, 1.0]) == 0.0
assert _cosine([], v) == float("-inf")
assert _cosine([0.0, 0.0], v) == float("-inf")
def test_memory_at_day_and_valid_until_key():
"""memory_at / valid_until 归一化到 date 键。"""
dt = datetime(2025, 8, 6, 15, 30)
node = _make_intention_node("x", memory_at=dt, valid_until=dt)
assert _memory_at_day(node) == date(2025, 8, 6)
assert _valid_until_key(node) == date(2025, 8, 6)
node2 = _make_intention_node("x")
assert _memory_at_day(node2) is None
assert _valid_until_key(node2) is None
def test_partition_duplicates_same_day_same_valid_until_high_cosine_dedup():
"""同天 memory_at + 同 valid_until + cosine≈1 → 判重。保留 gmt 最早。"""
same_ma = datetime(2025, 8, 6, 10, 0)
same_vu = datetime(2025, 8, 8, 23, 59, 59)
n1 = _make_intention_node(
"用户月底要发布新品", memory_at=same_ma, valid_until=same_vu,
gmt_created=datetime(2025, 8, 6, 10, 0),
)
n2 = _make_intention_node(
"用户月底要发布新品", memory_at=same_ma, valid_until=same_vu,
gmt_created=datetime(2025, 8, 6, 10, 5), # 更晚
)
n3 = _make_intention_node(
"用户月底要发布新品", memory_at=same_ma, valid_until=same_vu,
gmt_created=datetime(2025, 8, 6, 10, 10), # 最晚
)
hits = [
{"node_id": n.node_id, "node": n, "score": 0.68}
for n in (n2, n1, n3) # 故意打乱顺序,测试保 gmt 最早不是保第一条
]
kept, delete_ids = _partition_duplicates(hits, threshold=0.95)
assert len(kept) == 1
assert kept[0]["node_id"] == n1.node_id # gmt 最早
assert set(delete_ids) == {n2.node_id, n3.node_id}
def test_partition_duplicates_different_memory_at_day_keeps_both():
"""content + valid_until 都一样,但 memory_at 不同天 → 不判重。"""
n_this_week = _make_intention_node(
"用户周五要开会",
memory_at=datetime(2025, 8, 4, 9, 0), # 周一
valid_until=datetime(2025, 8, 8, 23, 59),
)
n_next_week = _make_intention_node(
"用户周五要开会",
memory_at=datetime(2025, 8, 11, 9, 0), # 下周一
valid_until=datetime(2025, 8, 15, 23, 59),
)
hits = [
{"node_id": n_this_week.node_id, "node": n_this_week, "score": 0.7},
{"node_id": n_next_week.node_id, "node": n_next_week, "score": 0.7},
]
kept, delete_ids = _partition_duplicates(hits, threshold=0.95)
assert len(kept) == 2
assert delete_ids == []
def test_partition_duplicates_different_valid_until_keeps_both():
"""核心 case:同天说的两个"周五开会",指向不同会议(valid_until 不同)→ 保留两条。
"用户今天上午说 8/8 开会" vs "今天下午说 8/15 开会",content 一样、memory_at
同天,但 valid_until 不同。不能合并。
"""
same_ma = datetime(2025, 8, 6, 10, 0)
n_this_fri = _make_intention_node(
"用户周五要开会", memory_at=same_ma,
valid_until=datetime(2025, 8, 8, 23, 59), # 本周五
)
n_next_fri = _make_intention_node(
"用户周五要开会", memory_at=same_ma,
valid_until=datetime(2025, 8, 15, 23, 59), # 下周五
)
hits = [
{"node_id": n_this_fri.node_id, "node": n_this_fri, "score": 0.7},
{"node_id": n_next_fri.node_id, "node": n_next_fri, "score": 0.7},
]
kept, delete_ids = _partition_duplicates(hits, threshold=0.95)
assert len(kept) == 2, "different valid_until must not be deduped"
assert delete_ids == []
def test_partition_duplicates_different_users_keeps_both():
"""不同用户的同一天、同意图文本不能被判为复本(更不能硬删他人数据)。"""
same_ma = datetime(2025, 8, 6)
same_vu = datetime(2025, 8, 8)
alice = _make_intention_node(
"用户明天要开会", user_id="alice", memory_at=same_ma, valid_until=same_vu,
gmt_created=datetime(2025, 8, 1),
)
bob = _make_intention_node(
"用户明天要开会", user_id="bob", memory_at=same_ma, valid_until=same_vu,
gmt_created=datetime(2025, 8, 2),
)
hits = [
{"node_id": alice.node_id, "node": alice, "score": 0.9},
{"node_id": bob.node_id, "node": bob, "score": 0.9},
]
kept, delete_ids = _partition_duplicates(hits, threshold=0.95)
assert {h["node_id"] for h in kept} == {alice.node_id, bob.node_id}
assert delete_ids == []
def test_partition_duplicates_different_agents_keeps_both():
"""同 user 下不同 agent 的意图也属于不同作用域,不能互相覆盖。"""
same_ma = datetime(2025, 8, 6)
same_vu = datetime(2025, 8, 8)
a1 = _make_intention_node(
"用户明天要开会", user_id="u1", agent_id="agent_a",
memory_at=same_ma, valid_until=same_vu,
gmt_created=datetime(2025, 8, 1),
)
a2 = _make_intention_node(
"用户明天要开会", user_id="u1", agent_id="agent_b",
memory_at=same_ma, valid_until=same_vu,
gmt_created=datetime(2025, 8, 2),
)
hits = [
{"node_id": a1.node_id, "node": a1, "score": 0.9},
{"node_id": a2.node_id, "node": a2, "score": 0.9},
]
kept, delete_ids = _partition_duplicates(hits, threshold=0.95)
assert {h["node_id"] for h in kept} == {a1.node_id, a2.node_id}
assert delete_ids == []
def test_partition_duplicates_low_cosine_keeps_both():
"""content 不同(cosine 低)→ 不判重,即使 memory_at / valid_until 同。"""
same_ma = datetime(2025, 8, 6)
same_vu = datetime(2025, 8, 8)
n1 = _make_intention_node(
"用户周五要开会", memory_at=same_ma, valid_until=same_vu,
embedding=[1.0, 0.0],
)
n2 = _make_intention_node(
"用户周五要看牙医", memory_at=same_ma, valid_until=same_vu,
embedding=[0.0, 1.0],
)
hits = [
{"node_id": n1.node_id, "node": n1, "score": 0.6},
{"node_id": n2.node_id, "node": n2, "score": 0.6},
]
kept, delete_ids = _partition_duplicates(hits, threshold=0.95)
assert len(kept) == 2
assert delete_ids == []
def test_partition_duplicates_mixed_scenarios():
"""混合场景:4 条月底新品(同 memory_at + 同 valid_until)
+ 2 条家长会(同 memory_at + 不同 valid_until)
+ 1 条千岛湖(其他)→ 期望 kept=4 (1 新品 + 2 家长会 + 1 千岛湖)。"""
ma = datetime(2025, 8, 6)
vu_end_month = datetime(2025, 8, 31)
vu_this_fri = datetime(2025, 8, 8)
vu_next_fri = datetime(2025, 8, 15)
p1 = _make_intention_node(
"月底发新品", memory_at=ma, valid_until=vu_end_month,
gmt_created=datetime(2025, 8, 1),
)
p2 = _make_intention_node(
"月底发新品", memory_at=ma, valid_until=vu_end_month,
gmt_created=datetime(2025, 8, 2),
)
p3 = _make_intention_node(
"月底发新品", memory_at=ma, valid_until=vu_end_month,
gmt_created=datetime(2025, 8, 3),
)
p4 = _make_intention_node(
"月底发新品", memory_at=ma, valid_until=vu_end_month,
gmt_created=datetime(2025, 8, 4),
)
m1 = _make_intention_node("家长会", memory_at=ma, valid_until=vu_this_fri)
m2 = _make_intention_node("家长会", memory_at=ma, valid_until=vu_next_fri)
q1 = _make_intention_node("千岛湖", memory_at=ma, valid_until=None)
hits = [
{"node_id": n.node_id, "node": n, "score": 0.6}
for n in (p1, p2, p3, p4, m1, m2, q1)
]
kept, delete_ids = _partition_duplicates(hits, threshold=0.95)
kept_ids = {h["node_id"] for h in kept}
# 4 条新品压成 1(gmt 最早的 p1);2 条家长会不同 valid_until 全留;千岛湖留
assert p1.node_id in kept_ids
assert m1.node_id in kept_ids
assert m2.node_id in kept_ids
assert q1.node_id in kept_ids
assert set(delete_ids) == {p2.node_id, p3.node_id, p4.node_id}
assert len(kept) == 4
# ============================================================================
# recall_intentions 端到端
# ============================================================================
def test_recall_intentions_dedup_and_async_delete_end_to_end():
"""端到端:VDB 里 3 条完全一样的月底新品 + 1 条家长会;limit=3 时 kept=2,
另 2 条月底新品异步从 VDB 被删。"""
vs = _FakeVectorStore()
emb = _FakeEmbedByHash(dims=32)
fixed_now = datetime(2025, 8, 6, 12, 0)
ma = datetime(2025, 8, 6)
vu = datetime(2025, 8, 31, 23, 59)
p_ids = []
for i in range(3):
n = _make_intention_node(
"用户月底要发布新品", dims=32,
memory_at=ma, valid_until=vu,
gmt_created=datetime(2025, 8, 1 + i),
embedding=emb.vec_for("用户月底要发布新品"),
)
_run(vs.upsert(n))
p_ids.append(n.node_id)
m = _make_intention_node(
"用户下周五要开家长会", dims=32,
memory_at=ma, valid_until=datetime(2025, 8, 15),
embedding=emb.vec_for("用户下周五要开家长会"),
)
_run(vs.upsert(m))
# query 用"月底新品",dot=1.0 排前 3;家长会 dot=0
q = emb.vec_for("用户月底要发布新品")
result = _run(recall_intentions(
vs, q, user_ids=["u1"], agent_ids=["a1"], limit=3, now=fixed_now,
))
# 4 条 hit,dedup 后 kept=2(1 新品 + 1 家长会),限 3 返回 2
contents = [h["node"].content for h in result]
assert contents.count("用户月底要发布新品") == 1
# p1(gmt 最早)应该留下,其余 2 条被异步删
assert p_ids[0] in {h["node_id"] for h in result}
assert set(vs.delete_calls) == {p_ids[1], p_ids[2]}
def test_recall_intentions_forwards_isolation_keys():
"""session 过滤路径只生成 isolation_keys;intention 必须原样透传给 VDB。"""
class _RecordingStore:
def __init__(self):
self.kwargs = None
async def search(self, **kwargs):
self.kwargs = kwargs
return []
vs = _RecordingStore()
_run(recall_intentions(
vs, [0.0], isolation_keys=["u1::a1::s1"], limit=5,
))
assert vs.kwargs["isolation_keys"] == ["u1::a1::s1"]
assert vs.kwargs["user_ids"] is None
assert vs.kwargs["agent_ids"] is None
vs2 = _RecordingStore()
_run(recall_intentions(
vs2, [0.0], isolation_key="u1::a1::s1", limit=5,
))
assert vs2.kwargs["isolation_key"] == "u1::a1::s1"
def test_recall_intentions_isolation_keys_prevent_cross_user_leak():
"""带 isolation_keys 时只能召回该作用域的意图,且不会误删其他用户。"""
vs = _FakeVectorStore()
emb = _FakeEmbedByHash(dims=32)
ma = datetime(2025, 8, 6)
vu = datetime(2025, 8, 8)
alice = _make_intention_node(
"用户明天要开会", user_id="u1", dims=32,
memory_at=ma, valid_until=vu,
embedding=emb.vec_for("用户明天要开会"),
)
bob = _make_intention_node(
"用户明天要开会", user_id="u2", dims=32,
memory_at=ma, valid_until=vu,
embedding=emb.vec_for("用户明天要开会"),
)
_run(vs.upsert(alice))
_run(vs.upsert(bob))
hits = _run(recall_intentions(
vs, emb.vec_for("用户明天要开会"),
isolation_keys=["u1::a1::s1"], limit=10,
now=datetime(2025, 8, 6, 12, 0),
))
assert {h["node_id"] for h in hits} == {alice.node_id}
assert vs.delete_calls == []
def test_recall_intentions_different_valid_until_all_returned():
"""两个 memory_at 相同、valid_until 不同的意图 → 都召回,都不删。"""
vs = _FakeVectorStore()
emb = _FakeEmbedByHash(dims=32)
fixed_now = datetime(2025, 8, 6, 12, 0)
ma = datetime(2025, 8, 6)
n_this = _make_intention_node(
"用户周五要开会", dims=32, memory_at=ma,
valid_until=datetime(2025, 8, 8, 23, 59),
embedding=emb.vec_for("用户周五要开会"),
)
n_next = _make_intention_node(
"用户周五要开会", dims=32, memory_at=ma,
valid_until=datetime(2025, 8, 15, 23, 59),
embedding=emb.vec_for("用户周五要开会"),
)
_run(vs.upsert(n_this))
_run(vs.upsert(n_next))
q = emb.vec_for("用户周五要开会")
result = _run(recall_intentions(vs, q, user_ids=["u1"], limit=10, now=fixed_now))
assert len(result) == 2
assert vs.delete_calls == []
def test_recall_intentions_expired_converted_to_l2():
"""valid_until 已过 → 惰性 update_payload 转 L2_FACT,不进返回结果。"""
vs = _FakeVectorStore()
emb = _FakeEmbedByHash(dims=32)
yesterday = datetime.now() - timedelta(days=1)
n = _make_intention_node(
"老的过期意图", dims=32,
memory_at=datetime(2025, 1, 1),
valid_until=yesterday,
embedding=emb.vec_for("老的过期意图"),
)
_run(vs.upsert(n))
q = emb.vec_for("老的过期意图")
result = _run(recall_intentions(vs, q, user_ids=["u1"], limit=10))
assert result == []
assert vs.update_payload_calls == [(n.node_id, {"layer": MemoryLayer.L2_FACT.value})]
def test_recall_intentions_limit_zero_short_circuit():
"""limit=0 → 立即返回 [],不查 VDB。"""
vs = _FakeVectorStore()
result = _run(recall_intentions(vs, [1.0] * 32, user_ids=["u1"], limit=0))
assert result == []
def test_recall_intentions_oversample_larger_than_limit():
"""fetch_limit 应比 limit 大很多;VDB 里 10 条完全正交的意图 + limit=3
→ 应能拿到 3 条不重复;由于 embedding 完全正交,dedup 一条都不该删。"""
vs = _FakeVectorStore()
fixed_now = datetime(2025, 8, 6, 12, 0)
ma = datetime(2025, 8, 6)
dims = 128
def _one_hot(idx: int) -> List[float]:
v = [0.0] * dims
v[idx] = 1.0
return v
# 用明确的 one-hot 索引,保证 10 条向量完全正交(cosine=0)
for i in range(10):
n = _make_intention_node(
f"意图 #{i}", dims=dims, memory_at=ma,
embedding=_one_hot(i),
)
_run(vs.upsert(n))
# query 命中意图 #3(cosine=1),其他 cosine=0
q = _one_hot(3)
result = _run(recall_intentions(
vs, q, user_ids=["u1"], limit=3, now=fixed_now,
))
# limit=3 返回不超过 3 条;且没有任何 delete(向量全正交)
assert len(result) <= 3
assert vs.delete_calls == []
# ============================================================================
# 2. Writer batch dedup(只做批内、不查 VDB)
# ============================================================================
def _make_writer():
from hy_memory.config import MemoryConfig
from hy_memory.pipelines.writer import MemoryWriter
cfg = MemoryConfig.from_env()
writer = MemoryWriter(
cfg,
embed_service=_FakeEmbedByHash(dims=32),
vector_store=_FakeVectorStore(),
cache=None,
)
return writer
def _make_req(user_id="u1", agent_id="a1"):
from hy_memory.pipelines.base import WriteRequest
return WriteRequest(
content="", messages=[], user_id=user_id, agent_id=agent_id,
session_id="s1", request_id=uuid.uuid4().hex,
memory_at=datetime(2025, 8, 6, 10, 0),
)
def test_writer_batch_dedup_pure_function_same_valid_until():
"""纯函数:3 条同 content + 同 valid_until → drop 2 条。"""
from hy_memory.pipelines.writer import MemoryWriter
emb = _FakeEmbedByHash(dims=16)
vu = datetime(2025, 8, 8)
intentions = [
{"content": "月底发新品", "valid_until": vu, "tags": ["work"]},
{"content": "月底发新品", "valid_until": vu, "tags": ["deadline"]},
{"content": "月底发新品", "valid_until": vu, "tags": ["product"]},
]
embeddings = [emb.vec_for(it["content"]) for it in intentions]
drop_idx = MemoryWriter._intention_batch_dedup(intentions, embeddings)
assert drop_idx == [1, 2]
def test_writer_batch_dedup_different_valid_until_keeps_all():
"""核心 case:同 content,valid_until 不同 → 都保留,不判重。"""
from hy_memory.pipelines.writer import MemoryWriter
emb = _FakeEmbedByHash(dims=16)
intentions = [
{"content": "周五要开会", "valid_until": datetime(2025, 8, 8)}, # 本周五
{"content": "周五要开会", "valid_until": datetime(2025, 8, 15)}, # 下周五
]
embeddings = [emb.vec_for(it["content"]) for it in intentions]
drop_idx = MemoryWriter._intention_batch_dedup(intentions, embeddings)
assert drop_idx == []
def test_writer_batch_dedup_none_valid_until_all_none_treated_same():
"""valid_until 全为 None 且同 content → 依然判重(None 视作同一 key)。"""
from hy_memory.pipelines.writer import MemoryWriter
emb = _FakeEmbedByHash(dims=16)
intentions = [
{"content": "老板画的饼", "valid_until": None},
{"content": "老板画的饼", "valid_until": None},
]
embeddings = [emb.vec_for(it["content"]) for it in intentions]
drop_idx = MemoryWriter._intention_batch_dedup(intentions, embeddings)
assert drop_idx == [1]
def test_writer_batch_dedup_none_vs_some_not_deduped():
"""一条 valid_until=None,一条有 → 分属不同桶,不判重。"""
from hy_memory.pipelines.writer import MemoryWriter
emb = _FakeEmbedByHash(dims=16)
intentions = [
{"content": "写小说", "valid_until": None},
{"content": "写小说", "valid_until": datetime(2025, 12, 31)},
]
embeddings = [emb.vec_for(it["content"]) for it in intentions]
drop_idx = MemoryWriter._intention_batch_dedup(intentions, embeddings)
assert drop_idx == []
def test_writer_batch_dedup_different_content_keeps_all():
"""content 不同 → cosine 低,不判重。"""
from hy_memory.pipelines.writer import MemoryWriter
# 用明确的 one-hot 索引保证 3 个 embedding 完全正交(cosine=0)
def _one_hot(idx: int, dims: int = 64) -> List[float]:
v = [0.0] * dims
v[idx] = 1.0
return v
intentions = [
{"content": "月底发新品", "valid_until": None},
{"content": "周五开家长会", "valid_until": None},
{"content": "国庆去千岛湖", "valid_until": None},
]
embeddings = [_one_hot(0), _one_hot(1), _one_hot(2)]
drop_idx = MemoryWriter._intention_batch_dedup(intentions, embeddings)
assert drop_idx == []
def test_writer_store_intentions_e2e_batch_dedup():
"""_store_intentions 端到端:3 条复读 + 1 条新意图 → VDB 里只落 2 个。"""
vs = _FakeVectorStore()
from hy_memory.config import MemoryConfig
from hy_memory.pipelines.writer import MemoryWriter
cfg = MemoryConfig.from_env()
writer = MemoryWriter(cfg, embed_service=_FakeEmbedByHash(dims=32),
vector_store=vs, cache=None)
req = _make_req()
vu = datetime(2025, 8, 8)
intentions = [
{"content": "月底发新品", "valid_until": vu, "tags": ["a"]},
{"content": "月底发新品", "valid_until": vu, "tags": ["b"]},
{"content": "月底发新品", "valid_until": vu, "tags": ["c"]},
{"content": "周五要开会", "valid_until": vu, "tags": []},
]
ids = _run(writer._store_intentions(intentions, req, vs, req.request_id))
assert len(ids) == 2 # 3 条月底新品压成 1 + 周五开会 1
assert len(vs._nodes) == 2
# ============================================================================
# 3. READ_REQUEST 日志携带 intention_limit
# ============================================================================
def test_log_request_records_intention_limit():
import json
from hy_memory.pipelines._retrieval.trace import ReadTraceLogger
captured = []
class _StubCache:
async def store_pipeline_log(self, **kwargs):
captured.append(kwargs)
async def _main():
tl = ReadTraceLogger(cache=_StubCache(), request_id="r",
user_id="u", agent_id="a", reader_version="v")
await tl.log_request(
query="q", limit=5, layers=None, min_score=0.0,
schema_min_score=None, schema_limit=None,
user_ids=[], agent_ids=[], session_ids=[],
intention_limit=20,
)
_run(_main())
parsed = captured[-1]["parsed"]
if isinstance(parsed, str):
parsed = json.loads(parsed)
assert parsed["intention_limit"] == 20
def test_log_request_intention_limit_default_none():
import json
from hy_memory.pipelines._retrieval.trace import ReadTraceLogger
captured = []
class _StubCache:
async def store_pipeline_log(self, **kwargs):
captured.append(kwargs)
async def _main():
tl = ReadTraceLogger(cache=_StubCache(), request_id="r",
user_id="u", agent_id="a", reader_version="v")
await tl.log_request(
query="q", limit=5, layers=None, min_score=0.0,
schema_min_score=None, schema_limit=None,
user_ids=[], agent_ids=[], session_ids=[],
)
_run(_main())
parsed = captured[-1]["parsed"]
if isinstance(parsed, str):
parsed = json.loads(parsed)
assert "intention_limit" in parsed
assert parsed["intention_limit"] is None