ac9a94ade3
* fix: handle observations regeneration when memories get deleted
* feat: add clear_memory_observations endpoint and regenerate clients
- Add DELETE /banks/{id}/memories/{memory_id}/observations endpoint
- Add observations lifecycle/invalidation section to docs
- Regenerate OpenAPI spec and all clients (Python, TypeScript, Go, Rust)
* refactor: use dedicated response model for clear_memory_observations, remove code example from docs
457 lines
20 KiB
Python
457 lines
20 KiB
Python
"""
|
|
Tests for observation invalidation when source memories are deleted.
|
|
|
|
These tests verify that:
|
|
1. Observations are deleted (not just updated) when their source memories are removed
|
|
2. Remaining source memories are reset for re-consolidation (consolidated_at=NULL)
|
|
3. The clear_observations_for_memory method correctly clears observations and
|
|
resets the target memory itself for re-consolidation
|
|
4. delete_bank(fact_type=...) also cleans up affected observations
|
|
"""
|
|
import uuid
|
|
from unittest.mock import AsyncMock, patch
|
|
|
|
import pytest
|
|
|
|
from hindsight_api import RequestContext
|
|
from hindsight_api.engine.memory_engine import MemoryEngine
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
async def _insert_memory(conn, bank_id: str, text: str, fact_type: str = "experience") -> uuid.UUID:
|
|
"""Insert a memory unit directly, bypassing LLM retain pipeline."""
|
|
mem_id = uuid.uuid4()
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO memory_units (id, bank_id, text, fact_type, event_date, created_at, updated_at, consolidated_at)
|
|
VALUES ($1, $2, $3, $4, NOW(), NOW(), NOW(), NOW())
|
|
""",
|
|
mem_id,
|
|
bank_id,
|
|
text,
|
|
fact_type,
|
|
)
|
|
return mem_id
|
|
|
|
|
|
async def _insert_observation(
|
|
conn, bank_id: str, text: str, source_memory_ids: list[uuid.UUID]
|
|
) -> uuid.UUID:
|
|
"""Insert an observation unit directly."""
|
|
obs_id = uuid.uuid4()
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO memory_units (
|
|
id, bank_id, text, fact_type, event_date, source_memory_ids, proof_count, created_at, updated_at
|
|
) VALUES ($1, $2, $3, 'observation', NOW(), $4, $5, NOW(), NOW())
|
|
""",
|
|
obs_id,
|
|
bank_id,
|
|
text,
|
|
source_memory_ids,
|
|
len(source_memory_ids),
|
|
)
|
|
return obs_id
|
|
|
|
|
|
async def _get_observation_ids(conn, bank_id: str) -> list[str]:
|
|
rows = await conn.fetch(
|
|
"SELECT id FROM memory_units WHERE bank_id = $1 AND fact_type = 'observation'",
|
|
bank_id,
|
|
)
|
|
return [str(r["id"]) for r in rows]
|
|
|
|
|
|
async def _get_consolidated_at(conn, memory_id: uuid.UUID):
|
|
return await conn.fetchval(
|
|
"SELECT consolidated_at FROM memory_units WHERE id = $1",
|
|
memory_id,
|
|
)
|
|
|
|
|
|
async def _ensure_bank(memory: MemoryEngine, bank_id: str, request_context: RequestContext):
|
|
await memory.get_bank_profile(bank_id=bank_id, request_context=request_context)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: delete_memory_unit
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestDeleteMemoryUnitObservationCleanup:
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_source_memory_removes_observation(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Deleting a source memory removes observations derived from it."""
|
|
bank_id = f"test-invalidate-del-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice goes hiking every weekend.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice enjoys hiking regularly.", [m1, m2])
|
|
|
|
await memory.delete_memory_unit(str(m1), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been deleted"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_source_memory_resets_remaining_source_consolidated_at(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""After deleting a source memory, remaining source memories are reset for re-consolidation."""
|
|
bank_id = f"test-invalidate-reset-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice goes hiking every weekend.")
|
|
await _insert_observation(conn, bank_id, "Alice enjoys hiking regularly.", [m1, m2])
|
|
|
|
# Verify m2 starts with consolidated_at set
|
|
assert await _get_consolidated_at(conn, m2) is not None
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.delete_memory_unit(str(m1), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
# m2 should have consolidated_at reset to NULL
|
|
consolidated_at = await _get_consolidated_at(conn, m2)
|
|
assert consolidated_at is None, "Remaining source memory should be reset for re-consolidation"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_non_source_memory_leaves_observations_intact(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Deleting a memory that is not a source of any observation leaves observations unchanged."""
|
|
bank_id = f"test-invalidate-noop-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice goes hiking every weekend.")
|
|
unrelated = await _insert_memory(conn, bank_id, "Bob likes cycling.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice enjoys hiking regularly.", [m1, m2])
|
|
|
|
await memory.delete_memory_unit(str(unrelated), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) in obs_ids, "Observation should remain untouched"
|
|
# m1 and m2 should still be consolidated
|
|
assert await _get_consolidated_at(conn, m1) is not None
|
|
assert await _get_consolidated_at(conn, m2) is not None
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_sole_source_memory_removes_observation_no_remaining_reset(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""When an observation has only one source and it's deleted, observation is removed with no remaining memories to reset."""
|
|
bank_id = f"test-invalidate-sole-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice enjoys hiking.", [m1])
|
|
|
|
await memory.delete_memory_unit(str(m1), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been deleted"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_observation_type_memory_does_not_trigger_invalidation(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Deleting a memory with fact_type='observation' directly does not trigger invalidation logic."""
|
|
bank_id = f"test-invalidate-obstype-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice enjoys hiking.", [m1])
|
|
|
|
# Delete the observation directly (not the source memory)
|
|
await memory.delete_memory_unit(str(obs_id), request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
# Source memory should still be consolidated (not reset)
|
|
assert await _get_consolidated_at(conn, m1) is not None
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: delete_document
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestDeleteDocumentObservationCleanup:
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_deleting_document_removes_observations(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Deleting a document removes observations derived from its memory units."""
|
|
bank_id = f"test-invalidate-doc-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
|
|
# Create a document and attach memories to it
|
|
async with pool.acquire() as conn:
|
|
doc_id = str(uuid.uuid4()) # documents.id is TEXT
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO documents (id, bank_id, original_text, content_hash, created_at, updated_at)
|
|
VALUES ($1, $2, 'some doc', 'hash123', NOW(), NOW())
|
|
""",
|
|
doc_id,
|
|
bank_id,
|
|
)
|
|
m1 = uuid.uuid4()
|
|
m2 = uuid.uuid4()
|
|
for mem_id, text in [(m1, "Alice loves hiking."), (m2, "Alice goes hiking every weekend.")]:
|
|
await conn.execute(
|
|
"""
|
|
INSERT INTO memory_units (id, bank_id, text, fact_type, event_date, document_id, created_at, updated_at, consolidated_at)
|
|
VALUES ($1, $2, $3, 'experience', NOW(), $4, NOW(), NOW(), NOW())
|
|
""",
|
|
mem_id,
|
|
bank_id,
|
|
text,
|
|
doc_id,
|
|
)
|
|
|
|
# Standalone memory (not in document)
|
|
m3 = await _insert_memory(conn, bank_id, "Alice is an avid outdoor person.")
|
|
|
|
# Observation referencing both doc memories and the standalone memory
|
|
obs_id = await _insert_observation(
|
|
conn, bank_id, "Alice enjoys outdoor activities.", [m1, m2, m3]
|
|
)
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.delete_document(str(doc_id), bank_id, request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been deleted"
|
|
|
|
# m3 (remaining source) should be reset for re-consolidation
|
|
consolidated_at = await _get_consolidated_at(conn, m3)
|
|
assert consolidated_at is None, "Remaining source memory should be reset"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: delete_bank with fact_type filter
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestDeleteBankByTypeObservationCleanup:
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clearing_experience_memories_removes_affected_observations(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Clearing all experience memories removes observations sourced from them."""
|
|
bank_id = f"test-invalidate-banktype-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
exp1 = await _insert_memory(conn, bank_id, "Alice went hiking last week.", "experience")
|
|
world1 = await _insert_memory(conn, bank_id, "Alice is a hiker.", "world")
|
|
obs_id = await _insert_observation(
|
|
conn, bank_id, "Alice is a regular hiker.", [exp1, world1]
|
|
)
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
await memory.delete_bank(bank_id, fact_type="experience", request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should have been deleted"
|
|
|
|
# world1 (remaining source) should be reset for re-consolidation
|
|
consolidated_at = await _get_consolidated_at(conn, world1)
|
|
assert consolidated_at is None, "World memory should be reset for re-consolidation"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clearing_unrelated_type_leaves_observations_intact(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Clearing memories of a type that is not a source of any observation leaves observations untouched."""
|
|
bank_id = f"test-invalidate-banktype-noop-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
world1 = await _insert_memory(conn, bank_id, "Alice is a hiker.", "world")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice is a regular hiker.", [world1])
|
|
|
|
# Deleting 'experience' type should not affect observations sourced only from 'world'
|
|
await memory.delete_bank(bank_id, fact_type="experience", request_context=request_context)
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) in obs_ids, "Observation should remain untouched"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Tests: clear_observations_for_memory
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class TestClearObservationsForMemory:
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clears_observations_and_resets_all_source_memories(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Clearing observations for a memory deletes them and resets all related source memories."""
|
|
bank_id = f"test-clear-obs-mem-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice hikes every weekend.")
|
|
obs_id = await _insert_observation(conn, bank_id, "Alice is an avid hiker.", [m1, m2])
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
result = await memory.clear_observations_for_memory(
|
|
bank_id, str(m1), request_context=request_context
|
|
)
|
|
|
|
assert result["deleted_count"] == 1
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs_id) not in obs_ids, "Observation should be deleted"
|
|
|
|
# Both m1 (target) and m2 (remaining source) should be reset
|
|
assert await _get_consolidated_at(conn, m1) is None, "Target memory should be reset"
|
|
assert await _get_consolidated_at(conn, m2) is None, "Remaining source should be reset"
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_no_observations_returns_zero(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Returns 0 when the memory has no associated observations."""
|
|
bank_id = f"test-clear-obs-noop-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
|
|
result = await memory.clear_observations_for_memory(
|
|
bank_id, str(m1), request_context=request_context
|
|
)
|
|
|
|
assert result["deleted_count"] == 0
|
|
|
|
async with pool.acquire() as conn:
|
|
# Memory should still be consolidated (no observations were cleared)
|
|
assert await _get_consolidated_at(conn, m1) is not None
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_only_clears_observations_referencing_target_memory(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""Clearing observations for m1 does not affect observations that only reference m2."""
|
|
bank_id = f"test-clear-obs-selective-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice hikes every weekend.")
|
|
m3 = await _insert_memory(conn, bank_id, "Alice climbed a mountain.")
|
|
|
|
obs1_id = await _insert_observation(conn, bank_id, "Alice is an avid hiker.", [m1, m2])
|
|
obs2_id = await _insert_observation(conn, bank_id, "Alice is a mountaineer.", [m3])
|
|
|
|
result = await memory.clear_observations_for_memory(
|
|
bank_id, str(m1), request_context=request_context
|
|
)
|
|
|
|
assert result["deleted_count"] == 1
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs1_id) not in obs_ids, "obs1 (references m1) should be deleted"
|
|
assert str(obs2_id) in obs_ids, "obs2 (does not reference m1) should remain"
|
|
|
|
# m3 should still be consolidated
|
|
assert await _get_consolidated_at(conn, m3) is not None
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_multiple_observations_for_same_memory_all_cleared(
|
|
self, memory: MemoryEngine, request_context: RequestContext
|
|
):
|
|
"""All observations referencing the target memory are cleared in one call."""
|
|
bank_id = f"test-clear-obs-multi-{uuid.uuid4().hex[:8]}"
|
|
await _ensure_bank(memory, bank_id, request_context)
|
|
|
|
pool = await memory._get_pool()
|
|
async with pool.acquire() as conn:
|
|
m1 = await _insert_memory(conn, bank_id, "Alice loves hiking.")
|
|
m2 = await _insert_memory(conn, bank_id, "Alice hikes every weekend.")
|
|
|
|
obs1_id = await _insert_observation(conn, bank_id, "Alice hikes often.", [m1])
|
|
obs2_id = await _insert_observation(conn, bank_id, "Alice is outdoorsy.", [m1, m2])
|
|
|
|
# Patch out consolidation so it doesn't re-set consolidated_at before we can check it
|
|
with patch.object(memory, "submit_async_consolidation", new=AsyncMock()):
|
|
result = await memory.clear_observations_for_memory(
|
|
bank_id, str(m1), request_context=request_context
|
|
)
|
|
|
|
assert result["deleted_count"] == 2
|
|
|
|
async with pool.acquire() as conn:
|
|
obs_ids = await _get_observation_ids(conn, bank_id)
|
|
assert str(obs1_id) not in obs_ids
|
|
assert str(obs2_id) not in obs_ids
|
|
|
|
# m1 and m2 should both be reset
|
|
assert await _get_consolidated_at(conn, m1) is None
|
|
assert await _get_consolidated_at(conn, m2) is None
|
|
|
|
await memory.delete_bank(bank_id, request_context=request_context)
|