Python
# -*- coding: utf-8 -*-
"""
list_by_user payload-only 调用点:`with_vectors=False` 是否真的传到了后端。
背景:VectorStoreBase.list_by_user 加了 `with_vectors` 开关(默认 True 保持
向后兼容),只需要 payload/tags/metadata 的调用点必须显式传 False,
避免把 embedding 一并拉回;否则一次列举可能顺带带回 MB 级向量。
本次修复覆盖的调用点(在 fix/list-by-user-without-vectors 分支上):
client.py:
- `_list_vdb_bucket` (list API,序列化为 list item)
- `async_get_basic_info` (只读 custom.basic_info_kv + 链)
- `async_build_entity_store` (只用 node_id/content 重建 entity)
- `async_clone_user` 里 dst 空检查 (只判长度)
writer.py:
- `_get_recent_history` (只读 content/node_id/gmt_created)
- `_collect_existing_tags` (已在同一分支上覆盖)
basic_profile.py:
- `_find_latest_l0` (只读 layer/custom/is_latest)
- `_assemble_full_kv` (只读 custom.basic_info_kv)
反向断言(必须保留 embedding 的调用点):
- `async_clone_user` src 全量复制 (embedding 会被 to_dict/from_dict 拷贝)
"""
from datetime import datetime, timedelta
import asyncio
import uuid
import pytest
from hy_memory.models.memory import (
MemoryLayer,
MemoryNode,
MemoryStatus,
)
def run(coro):
loop = asyncio.new_event_loop()
try:
return loop.run_until_complete(coro)
finally:
loop.close()
# ---------------------------------------------------------------------------
# fake vector store:抓 list_by_user 的每次 kwargs
# ---------------------------------------------------------------------------
class RecordingVectorStore:
"""只关心 list_by_user 传参;返回值可预置。"""
def __init__(self, nodes=None):
self.nodes = nodes or []
self.calls = [] # 每次 list_by_user 的 kwargs
self.get_calls = []
async def list_by_user(self, **kwargs):
self.calls.append(kwargs)
return list(self.nodes)
async def get_by_id(self, node_id):
self.get_calls.append(node_id)
return None
# 下列接口在部分调用路径里会被引用,给出安全的默认实现
async def delete_entities_for_memory(self, **kwargs):
return None
async def upsert_batch(self, nodes):
return [n.node_id for n in nodes]
def _basic_info_node(kv=None, is_latest=True, gmt_created=None):
n = MemoryNode(
node_id=str(uuid.uuid4()),
user_id="u1",
agent_id="a1",
session_id="s1",
content="basic info",
layer=MemoryLayer.L0_BASIC_INFO,
status=MemoryStatus.ACTIVE,
is_latest=is_latest,
)
n.custom = {"basic_info_kv": kv or {"name": "alvin"}}
n.gmt_created = gmt_created or datetime.utcnow()
return n
def _summary_node(content, session_id="s1", memory_at=None):
n = MemoryNode(
node_id=str(uuid.uuid4()),
user_id="u1",
agent_id="a1",
session_id=session_id,
content=content,
layer=MemoryLayer.L3_SUMMARY,
status=MemoryStatus.ACTIVE,
)
n.memory_at = memory_at or datetime.utcnow()
n.gmt_created = n.memory_at
return n
def _l1_raw_node(content, gmt=None):
n = MemoryNode(
node_id=str(uuid.uuid4()),
user_id="u1",
agent_id="a1",
session_id="s1",
content=content,
layer=MemoryLayer.L1_RAW,
status=MemoryStatus.ACTIVE,
)
n.gmt_created = gmt or datetime.utcnow()
return n
def _l2_fact_node(content):
n = MemoryNode(
node_id=str(uuid.uuid4()),
user_id="u1",
agent_id="a1",
session_id="s1",
content=content,
layer=MemoryLayer.L2_FACT,
status=MemoryStatus.ACTIVE,
)
return n
# ---------------------------------------------------------------------------
# basic_profile.py:_find_latest_l0 / _assemble_full_kv
# ---------------------------------------------------------------------------
class TestBasicProfilePayloadOnly:
def test_find_latest_l0_omits_vectors(self):
from hy_memory.agent.tools.basic_profile import _find_latest_l0
store = RecordingVectorStore([_basic_info_node()])
node = run(_find_latest_l0(store, user_id="u1"))
assert node is not None
assert len(store.calls) == 1
assert store.calls[0].get("with_vectors") is False, (
"_find_latest_l0 只用 layer/custom/is_latest 判定链头,不需要 embedding"
)
def test_assemble_full_kv_omits_vectors(self):
from hy_memory.agent.tools.basic_profile import _assemble_full_kv
store = RecordingVectorStore([
_basic_info_node(kv={"name": "alvin"},
gmt_created=datetime.utcnow() - timedelta(days=1)),
_basic_info_node(kv={"city": "sh"}, gmt_created=datetime.utcnow()),
])
kv = run(_assemble_full_kv(
store, user_id="u1", allowed_fields=None,
))
assert kv == {"name": "alvin", "city": "sh"}
assert len(store.calls) == 1
assert store.calls[0].get("with_vectors") is False, (
"_assemble_full_kv 只读 custom.basic_info_kv,不需要 embedding"
)
# ---------------------------------------------------------------------------
# writer.py:_get_recent_history
# ---------------------------------------------------------------------------
class TestWriterPayloadOnly:
def _writer(self):
from hy_memory.pipelines.writer import MemoryWriter
return MemoryWriter.__new__(MemoryWriter)
def _request(self):
from hy_memory.pipelines.writer import WriteRequest
req = WriteRequest.__new__(WriteRequest)
req.user_id = "u1"
req.agent_id = "a1"
req.session_id = "s1"
req.memory_at = datetime.utcnow()
return req
def test_get_recent_history_omits_vectors(self):
writer = self._writer()
base = datetime.utcnow()
store = RecordingVectorStore([
_l1_raw_node("[user]: hi\n[assistant]: hello",
gmt=base - timedelta(seconds=2)),
_l1_raw_node("[user]: how are you\n[assistant]: fine",
gmt=base - timedelta(seconds=1)),
])
history = run(writer._get_recent_history(
store, user_id="u1", agent_id="a1", max_turns=10,
))
assert "hi" in history and "hello" in history
assert len(store.calls) == 1
assert store.calls[0].get("with_vectors") is False, (
"_get_recent_history 只读 content/node_id/gmt_created,不需要 embedding"
)
# ---------------------------------------------------------------------------
# client.py:_list_vdb_bucket / async_get_basic_info /
# async_build_entity_store / async_clone_user (dst + src 反向断言)
# ---------------------------------------------------------------------------
class TestClientPayloadOnly:
def _client_with(self, store):
"""构造一个只带最小 self 属性的裸 client 实例。
真实 client 有 _loop_thread / _cache / _graph_store 等一堆运行时依赖;
这里只测 list_by_user 的传参,其他埋点走 no-op。
"""
from hy_memory.client import HyMemoryClient
c = HyMemoryClient.__new__(HyMemoryClient)
c._vector_store = store
# 关掉 op_log 埋点(走 early return)
c._cache = None
# 关掉 graph store 埋点(多数方法只在 non-None 时才引用)
c._graph_store = None
return c
def test_list_vdb_bucket_omits_vectors(self):
store = RecordingVectorStore([])
client = self._client_with(store)
run(client._list_vdb_bucket(
user_id="u1", agent_id="a1",
limit=10, offset=0, order="desc",
))
# user-level L0 需要额外一次不带 agent 的查询;两路都只读 payload。
assert len(store.calls) == 2
assert all(call.get("with_vectors") is False for call in store.calls), (
"list API 只序列化 payload 到 list item,不需要 embedding"
)
assert "agent_id" not in store.calls[1] and "agent_ids" not in store.calls[1]
def test_async_get_basic_info_omits_vectors(self, monkeypatch):
# 避开 evolution 展开的额外 IO:patch 成透传恒等
async def _fake_expand(vs, hits):
return hits
monkeypatch.setattr(
"hy_memory.pipelines._retrieval.evolution.expand_evolution_chains",
_fake_expand,
)
store = RecordingVectorStore([_basic_info_node()])
client = self._client_with(store)
# 公开方法带 @_ensure_internal_loop,需要 self._loop_thread;这里只验证 list_by_user 传参,
# 绕过装饰器直接拿原函数(functools.wraps 保留在 __wrapped__)。
from hy_memory.client import HyMemoryClient
raw = HyMemoryClient.async_get_user_basic_info.__wrapped__
result = run(raw(client, user_id="u1"))
assert result["memories"], "至少要能取到一条 basic info"
assert store.calls, "必须真的走了 list_by_user"
assert store.calls[0].get("with_vectors") is False, (
"async_get_user_basic_info 只读 custom.basic_info_kv/content/tags/chain"
)
def test_async_build_entity_store_omits_vectors(self, monkeypatch):
# patch entity indexer:不真的 embed,只关心是否走对了 list 参数
async def _fake_index(**kwargs):
return 1
monkeypatch.setattr(
"hy_memory.pipelines._retrieval.entity_store.index_memory_entities",
_fake_index,
)
store = RecordingVectorStore([_l2_fact_node("t1"), _l2_fact_node("t2")])
client = self._client_with(store)
client._embed_service = None # index_memory_entities 已 patch
from hy_memory.client import HyMemoryClient
raw = HyMemoryClient.async_build_entity_store.__wrapped__
result = run(raw(client, user_id="u1", agent_id="a1", rebuild=False))
assert result["success"] is True
assert result["memories_scanned"] == 2
assert store.calls, "必须真的走了 list_by_user"
assert store.calls[0].get("with_vectors") is False, (
"entity rebuild 只用 node_id/content,重新 embed entity 名"
)
def test_async_clone_user_dst_check_omits_vectors_src_keeps_them(self):
"""Clone checks agent + user-level L0 on both source and destination.
Destination checks are payload-only. Source reads must retain vectors:
src 全量复制走 to_dict/from_dict 深拷贝,to_dict 会把 embedding 一并
序列化到新节点;若 src 侧 with_vectors=False,克隆节点 embedding 会
丢失,导致新用户后续 recall 命中率归零——这是绝对不能改的口径。
"""
# 调用顺序:dst agent、dst L0、src agent、src L0。
class _ClonefakeStore(RecordingVectorStore):
async def list_by_user(self, *args, **kwargs):
# dst 检查真实调用是位置参数 list_by_user(dst_user_id, agent_id=..., limit=1, with_vectors=False)
# 归一化到 kwargs 记录,便于断言
if args:
kwargs = {**kwargs, "user_id": args[0]}
self.calls.append(kwargs)
# 目标侧两次检查都返回空。
if len(self.calls) <= 2:
return []
# 源侧返回一条带 embedding 的节点。
node = MemoryNode(
node_id=str(uuid.uuid4()),
user_id="src",
agent_id="a1",
session_id="s1",
content="src memory",
layer=MemoryLayer.L2_FACT,
status=MemoryStatus.ACTIVE,
)
node.embedding = [0.1] * 16
return [node]
async def upsert_batch(self, nodes):
self._upserted = list(nodes)
return [n.node_id for n in nodes]
async def delete_by_metadata(self, **kwargs):
# rollback 兜底,返回 no-op
return 0
store = _ClonefakeStore()
client = self._client_with(store)
from hy_memory.client import HyMemoryClient
raw = HyMemoryClient.async_clone_user.__wrapped__
result = run(raw(
client, src_user_id="src", dst_user_id="dst", agent_id="a1",
))
assert result["success"] is True, result
assert len(store.calls) == 4
# dst agent + dst user-level L0:只判存在性,不需要 embedding。
assert all(call.get("with_vectors") is False for call in store.calls[:2])
# src agent + src user-level L0:必须默认(未传,等价于 True)。
assert all(call.get("with_vectors", True) is True for call in store.calls[2:])
# 顺带确认写入的新节点真的带了 embedding
assert hasattr(store, "_upserted") and store._upserted, "src 必须真的 upsert 了"
assert store._upserted[0].embedding, "克隆节点必须保留 embedding"