Skip to content
Python
13.9 KB
Raw Blame
import asyncio
import hashlib

import pytest

from one_memory.hy_sdk_types import HySdkMemoryRecord
from one_memory.imports.models import EvidenceInput, EvidenceOrigin, OriginMetadata, WrittenBy
from one_memory.imports.storage import EvidenceStore
from one_memory.memory_governance import MemoryDraft, MemoryGovernanceStore, MemoryKind
from one_memory.recall import (
    GovernedRecallTarget,
    RecallRequest,
    RecallState,
    SdkRecallTarget,
)
from one_memory.semantic_deadline import SemanticMemoryHit
from tests.person_door import as_person


def _confirmed_memory(governance, evidence, *, content: str, scope: str):
    request_key = hashlib.sha256(f"{scope}:{content}".encode()).hexdigest()
    memory = as_person(governance).create(
        MemoryDraft(
            user_id="local",
            kind=MemoryKind.CHAT,
            content=content,
            scopes=(scope,),
            evidence_ids=(evidence.evidence_id,),
        ),
        request_id=f"create:{request_key}",
    )
    return memory


def test_sdk_recall_does_not_invent_per_memory_harness_acl() -> None:
    async def search(_query):
        return (
            SemanticMemoryHit(
                memory_id="personal",
                score=0.9,
                formatted_content="formatted personal plus private member",
                member_ids=("member",),
                sdk_formatted=True,
                formatting_complete=True,
            ),
            SemanticMemoryHit(
                memory_id="private",
                score=0.8,
                formatted_content="private",
                sdk_formatted=True,
                formatting_complete=True,
            ),
        )

    async def get_memory(memory_id):
        return HySdkMemoryRecord(
            memory_id=memory_id,
            content="personal root" if memory_id == "personal" else "private",
            layer="l2_fact",
            status="active",
            is_latest=True,
            user_id="local",
            agent_id="one-memory",
            gmt_created=1_700_000_000,
        )

    receipt = asyncio.run(
        SdkRecallTarget(
            semantic_search=search,
            get_memory=get_memory,
        ).recall_async(RecallRequest(query="preference"))
    )

    assert receipt.state is RecallState.GROUNDED
    assert [hit.memory_id for hit in receipt.hits] == ["personal", "private"]
    assert receipt.hits[0].content == "formatted personal plus private member"
    assert receipt.hits[0].scopes == ()


def test_recall_is_confirmed_only_grounded_and_scope_bound(tmp_path) -> None:
    database = tmp_path / "one-memory.sqlite3"
    evidence_store = EvidenceStore(database)
    governance = MemoryGovernanceStore(database)
    evidence = evidence_store.put(
        EvidenceInput(
            source_id="cursor",
            conversation_id="conversation",
            message_id="message",
            role="user",
            written_by=WrittenBy.PERSON,
            verbatim="我是产品经理,项目采用本地优先架构。",
            origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
        )
    ).record
    personal = _confirmed_memory(
        governance,
        evidence,
        content="用户是一名产品经理",
        scope="all-apps",
    )
    _confirmed_memory(
        governance,
        evidence,
        content="项目采用本地优先架构",
        scope="workspace:v1:project",
    )
    target = GovernedRecallTarget(governance)

    result = target.recall(RecallRequest(query="产品经理"))

    assert result.state is RecallState.GROUNDED
    assert [hit.memory_id for hit in result.hits] == [personal.memory_id]
    assert result.hits[0].evidence_ids == (evidence.evidence_id,)
    assert all("workspace:v1:project" not in hit.scopes for hit in result.hits)

    workspace = target.recall(
        RecallRequest(
            query="项目采用什么架构?",
            scope="workspace:v1:project",
        )
    )
    assert [hit.content for hit in workspace.hits] == ["项目采用本地优先架构"]


def test_wildcard_scope_means_every_scope_just_like_it_does_in_qa(tmp_path) -> None:
    """`*` must mean the same thing on both read paths.

    Hosts recall through this path while the in-app answerer uses its own, and
    there `*` is a wildcard. Treating `*` here as a literal scope name matches
    nothing, so a host asking across scopes gets a silent empty result rather
    than the memory it was promised.
    """
    database = tmp_path / "one-memory.sqlite3"
    evidence_store = EvidenceStore(database)
    governance = MemoryGovernanceStore(database)
    evidence = evidence_store.put(
        EvidenceInput(
            source_id="cursor",
            conversation_id="conversation",
            message_id="message",
            role="user",
            written_by=WrittenBy.PERSON,
            verbatim="登录鉴权方案讨论:方式A、方式B、方式C 的优劣评估。",
            origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
        )
    ).record
    project = _confirmed_memory(
        governance,
        evidence,
        content="登录鉴权方案讨论:方式A、方式B、方式C 的优劣评估",
        scope="workspace:v1:project",
    )
    target = GovernedRecallTarget(governance)

    # The default personal scope must still not see project memories.
    assert target.recall(RecallRequest(query="登录鉴权方案")).state is RecallState.EMPTY

    across = target.recall(RecallRequest(query="登录鉴权方案", scope="*"))

    assert across.state is RecallState.GROUNDED
    assert [hit.memory_id for hit in across.hits] == [project.memory_id]


def test_recall_returns_empty_instead_of_unrelated_fallback(tmp_path) -> None:
    target = GovernedRecallTarget(MemoryGovernanceStore(tmp_path / "one-memory.sqlite3"))

    result = target.recall(RecallRequest(query="下周航班"))

    assert result.state is RecallState.EMPTY
    assert result.hits == ()


def test_recall_finds_a_single_chinese_character_query(tmp_path) -> None:
    database = tmp_path / "one-memory.sqlite3"
    evidence_store = EvidenceStore(database)
    governance = MemoryGovernanceStore(database)
    evidence = evidence_store.put(
        EvidenceInput(
            source_id="cursor",
            conversation_id="conversation",
            message_id="message",
            role="user",
            written_by=WrittenBy.PERSON,
            verbatim="张 的偏好",
            origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
        )
    ).record
    memory = _confirmed_memory(
        governance,
        evidence,
        content="张 的偏好",
        scope="all-apps",
    )

    result = GovernedRecallTarget(governance).recall(RecallRequest(query="张"))
    stopped = GovernedRecallTarget(governance).recall(RecallRequest(query="我"))

    assert result.state is RecallState.GROUNDED
    assert [hit.memory_id for hit in result.hits] == [memory.memory_id]
    assert stopped.state is RecallState.EMPTY
    assert stopped.hits == ()


def test_recall_stop_term_does_not_query_governance(tmp_path, monkeypatch) -> None:
    governance = MemoryGovernanceStore(tmp_path / "one-memory.sqlite3")

    def forbidden(*args, **kwargs):
        pytest.fail("Stop-term-only recall must not query governed memory storage")

    monkeypatch.setattr(governance, "find_confirmed_matching_terms", forbidden)

    result = GovernedRecallTarget(governance).recall(RecallRequest(query="我"))

    assert result.state is RecallState.EMPTY
    assert result.hits == ()


def test_recall_rejects_single_generic_term_overlap(tmp_path) -> None:
    database = tmp_path / "one-memory.sqlite3"
    evidence_store = EvidenceStore(database)
    governance = MemoryGovernanceStore(database)
    evidence = evidence_store.put(
        EvidenceInput(
            source_id="cursor",
            conversation_id="conversation",
            message_id="message",
            role="user",
            written_by=WrittenBy.PERSON,
            verbatim="将计划交给 WorkBuddy 进行方案评估优化。",
            origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
        )
    ).record
    _confirmed_memory(
        governance,
        evidence,
        content="将计划交给 WorkBuddy 进行方案评估优化",
        scope="workspace:v1:project",
    )

    result = GovernedRecallTarget(governance).recall(
        RecallRequest(
            query="这个项目的法律和开源许可方案是什么?",
            scope="workspace:v1:project",
        )
    )

    assert result.state is RecallState.EMPTY


def test_recall_uses_semantic_ids_when_words_do_not_overlap(tmp_path) -> None:
    database = tmp_path / "one-memory.sqlite3"
    evidence_store = EvidenceStore(database)
    governance = MemoryGovernanceStore(database)
    evidence = evidence_store.put(
        EvidenceInput(
            source_id="cursor",
            conversation_id="conversation",
            message_id="message",
            role="user",
            written_by=WrittenBy.PERSON,
            verbatim="我是产品经理。",
            origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
        )
    ).record
    personal = _confirmed_memory(
        governance,
        evidence,
        content="用户是一名产品经理",
        scope="all-apps",
    )

    async def semantic_search(_: str) -> tuple[str, ...]:
        return (personal.memory_id,)

    target = GovernedRecallTarget(governance, semantic_search=semantic_search)
    result = asyncio.run(target.recall_async(RecallRequest(query="我的职业是什么?")))

    assert [hit.memory_id for hit in result.hits] == [personal.memory_id]
    assert result.hits[0].score == 1


def test_recall_skips_oversized_hit_and_keeps_smaller_matches(tmp_path) -> None:
    database = tmp_path / "one-memory.sqlite3"
    evidence_store = EvidenceStore(database)
    governance = MemoryGovernanceStore(database)
    evidence = evidence_store.put(
        EvidenceInput(
            source_id="cursor",
            conversation_id="conversation",
            message_id="message",
            role="user",
            written_by=WrittenBy.PERSON,
            verbatim="产品经理偏好清晰沟通",
            origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
        )
    ).record
    small = _confirmed_memory(
        governance,
        evidence,
        content="产品经理偏好清晰沟通",
        scope="all-apps",
    )
    _confirmed_memory(
        governance,
        evidence,
        content="产品经理" + ("很" * 250),
        scope="all-apps",
    )

    result = GovernedRecallTarget(governance).recall(
        RecallRequest(query="产品经理", character_budget=200)
    )

    assert [hit.memory_id for hit in result.hits] == [small.memory_id]
    assert result.truncated is True


def test_recall_async_keeps_strong_semantic_when_weak_lexical_already_hits(tmp_path) -> None:
    """A weak substring hit must not skip the semantic channel.

    Chinese bigrams make everyday phrasing look grounded: 「开源许可证怎么选」
    overlaps 「开源」「许可」 on a recent review note, while the actual MIT
    decision has no literal overlap. Returning at the first non-empty lexical
    page would make that decision unreachable.
    """
    database = tmp_path / "one-memory.sqlite3"
    evidence_store = EvidenceStore(database)
    governance = MemoryGovernanceStore(database)
    evidence = evidence_store.put(
        EvidenceInput(
            source_id="cursor",
            conversation_id="conversation",
            message_id="message",
            role="user",
            written_by=WrittenBy.PERSON,
            verbatim="开源许可讨论。",
            origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
        )
    ).record
    strong = _confirmed_memory(
        governance,
        evidence,
        content="用户决定 One Memory 采用 MIT 协议发布。",
        scope="all-apps",
    )
    weak = _confirmed_memory(
        governance,
        evidence,
        content="这个开源项目的许可方案还在评审中,尚未定稿。",
        scope="all-apps",
    )
    searched: list[str] = []

    async def semantic_search(query: str) -> tuple[str, ...]:
        searched.append(query)
        return (strong.memory_id,)

    result = asyncio.run(
        GovernedRecallTarget(governance, semantic_search=semantic_search).recall_async(
            RecallRequest(query="开源许可证怎么选")
        )
    )

    assert searched == ["开源许可证怎么选"]
    ids = [hit.memory_id for hit in result.hits]
    assert strong.memory_id in ids
    assert weak.memory_id in ids
    assert ids[0] == strong.memory_id


def test_recall_async_keeps_lexical_hits_when_semantic_times_out(tmp_path) -> None:
    database = tmp_path / "one-memory.sqlite3"
    evidence_store = EvidenceStore(database)
    governance = MemoryGovernanceStore(database)
    evidence = evidence_store.put(
        EvidenceInput(
            source_id="cursor",
            conversation_id="conversation",
            message_id="message",
            role="user",
            written_by=WrittenBy.PERSON,
            verbatim="开源许可讨论。",
            origin_meta={EvidenceOrigin.FILE: OriginMetadata()},
        )
    ).record
    strong = _confirmed_memory(
        governance,
        evidence,
        content="用户决定 One Memory 采用 MIT 协议发布。",
        scope="all-apps",
    )
    weak = _confirmed_memory(
        governance,
        evidence,
        content="这个开源项目的许可方案还在评审中,尚未定稿。",
        scope="all-apps",
    )

    started = False

    async def semantic_search(_query: str) -> tuple[str, ...]:
        nonlocal started
        started = True
        await asyncio.sleep(4)
        return (strong.memory_id,)

    result = asyncio.run(
        GovernedRecallTarget(governance, semantic_search=semantic_search).recall_async(
            RecallRequest(query="开源许可证怎么选")
        )
    )

    assert started is True
    ids = [hit.memory_id for hit in result.hits]
    assert ids == [weak.memory_id]
    assert strong.memory_id not in ids