Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock, patch
import pytest
from openviking.session.memory.dataclass import (
MemoryField,
MemoryFile,
MemoryOperationSkip,
MemoryOperationSkipCode,
MemoryTypeSchema,
ResolvedOperation,
ResolvedOperations,
WikiLink,
)
from openviking.session.memory.extract_loop import ExtractLoop
from openviking.session.memory.extraction_output_protocol import (
create_extraction_output_protocol,
)
from openviking.session.memory.merge_op import FieldType, MergeOp
from openviking.session.memory.page_id_map import PageIdMap
class AttrDict(dict):
__getattr__ = dict.get
class TestResolveOperations:
@staticmethod
def _event_schema():
return MemoryTypeSchema(
memory_type="events",
description="event memory",
directory="viking://user/{{ user_space }}/memories/events",
filename_template="{{ event_name }}.md",
operation_mode="add_only",
fields=[
MemoryField(
name="event_name",
field_type=FieldType.STRING,
merge_op=MergeOp.IMMUTABLE,
),
MemoryField(
name="ranges",
field_type=FieldType.STRING,
merge_op=MergeOp.IMMUTABLE,
),
],
)
@pytest.mark.asyncio
async def test_event_low_page_id_never_reuses_existing_profile(self):
schema = self._event_schema()
page_id_map = PageIdMap()
for index in range(4):
page_id_map.get_page_id(f"viking://user/alice/memories/filler-{index}.md")
profile_uri = "viking://user/alice/memories/profile.md"
assert page_id_map.get_page_id(profile_uri) == 5
profile = MemoryFile(uri=profile_uri, memory_type="profile", content="profile")
event_uri = "viking://user/alice/memories/events/2026/08/27/demo.md"
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [schema]
context_provider.read_file_contents = {profile_uri: profile}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.calculate_memory_uris.return_value = [event_uri]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(page_id_map=page_id_map)
operations, _ = await loop.resolve_operations(
AttrDict(events=[{"event_name": "demo", "ranges": "0", "page_id": 5}])
)
operation = operations.upsert_operations[0]
assert operation.page_id == 100
assert operation.uris == [event_uri]
assert operation.old_memory_file_content is None
assert page_id_map.resolve(5) == profile_uri
isolation_handler.calculate_memory_uris.assert_called_once()
@pytest.mark.asyncio
async def test_event_unknown_low_page_id_is_normalized_and_written(self):
schema = self._event_schema()
page_id_map = PageIdMap()
event_uri = "viking://user/alice/memories/events/2026/08/27/demo.md"
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [schema]
context_provider.read_file_contents = {}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.calculate_memory_uris.return_value = [event_uri]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(page_id_map=page_id_map)
operations, _ = await loop.resolve_operations(
AttrDict(events=[{"event_name": "demo", "ranges": "0", "page_id": 5}])
)
operation = operations.upsert_operations[0]
assert operation.page_id == 100
assert operation.uris == [event_uri]
assert operation.resolution_skip is None
@pytest.mark.asyncio
async def test_existing_page_id_from_other_memory_type_is_rejected(self):
schema = MemoryTypeSchema(
memory_type="entities",
directory="viking://user/{{ user_space }}/memories/entities",
filename_template="{{ name }}.md",
fields=[],
)
profile_uri = "viking://user/alice/memories/profile.md"
profile = MemoryFile(uri=profile_uri, memory_type="profile", content="profile")
page_id_map = PageIdMap()
assert page_id_map.get_page_id(profile_uri) == 1
context_provider = Mock()
profile_schema = MemoryTypeSchema(
memory_type="profile",
directory="viking://user/{{ user_space }}/memories",
filename_template="profile.md",
fields=[],
)
context_provider.get_memory_schemas.return_value = [schema, profile_schema]
context_provider.read_file_contents = {profile_uri: profile}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.render_schema_directories.side_effect = lambda current_schema: [
(
"viking://user/alice/memories/entities"
if current_schema.memory_type == "entities"
else "viking://user/alice/memories"
)
]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(page_id_map=page_id_map)
operations, _ = await loop.resolve_operations(AttrDict(entities=[{"page_id": 1}]))
operation = operations.upsert_operations[0]
assert operation.uris == []
assert operation.old_memory_file_content is None
assert operation.resolution_skip is not None
assert (
operation.resolution_skip.reason_code == MemoryOperationSkipCode.PAGE_ID_TYPE_MISMATCH
)
isolation_handler.calculate_memory_uris.assert_not_called()
@pytest.mark.asyncio
async def test_type_mismatched_page_id_is_rejected_from_links_and_replacements(self):
entity_schema = MemoryTypeSchema(
memory_type="entities",
directory="viking://user/{{ user_space }}/memories/entities",
filename_template="{{ name }}.md",
fields=[],
)
experience_schema = MemoryTypeSchema(
memory_type="experiences",
directory="viking://user/{{ user_space }}/memories/experiences",
filename_template="{{ experience_name }}.md",
fields=[],
)
profile_uri = "viking://user/alice/memories/profile.md"
old_entity_uri = "viking://user/alice/memories/entities/old-project.md"
experience_uri = "viking://user/alice/memories/experiences/trip.md"
page_id_map = PageIdMap()
assert page_id_map.get_page_id(profile_uri) == 1
assert page_id_map.get_page_id(old_entity_uri) == 2
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [entity_schema, experience_schema]
context_provider.read_file_contents = {
profile_uri: MemoryFile(uri=profile_uri, memory_type="profile", content="profile"),
old_entity_uri: MemoryFile(
uri=old_entity_uri,
memory_type="entities",
content="old entity",
),
}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.render_schema_directories.side_effect = lambda schema: [
schema.directory.replace("{{ user_space }}", "alice")
]
isolation_handler.calculate_memory_uris.return_value = [experience_uri]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(page_id_map=page_id_map)
loop._link_enabled = True
operations, raw_links = await loop.resolve_operations(
AttrDict(
entities=[{"page_id": 1, "name": "wrong-project"}],
experiences=[{"page_id": 100, "experience_name": "trip"}],
links=[WikiLink(f=1, t=100, link_type="related_to", match_text=None)],
delete_ids=[{"delete_page_id": 2, "replacement_page_id": 1}],
)
)
mismatched_operation = operations.upsert_operations[0]
assert mismatched_operation.uris == []
assert mismatched_operation.resolution_skip is not None
assert (
mismatched_operation.resolution_skip.reason_code
== MemoryOperationSkipCode.PAGE_ID_TYPE_MISMATCH
)
assert raw_links == []
assert operations.delete_file_contents == []
assert operations.delete_replacements == {}
await loop.finalize_operations(operations, raw_links)
assert operations.resolved_links == []
@pytest.mark.asyncio
async def test_existing_page_id_uses_path_when_metadata_is_dirty(self):
schema = MemoryTypeSchema(
memory_type="profile",
directory="viking://user/{{ user_space }}/memories",
filename_template="profile.md",
fields=[],
)
profile_uri = "viking://user/alice/memories/profile.md"
dirty_profile = MemoryFile(
uri=profile_uri,
memory_type="events",
content="profile",
)
page_id_map = PageIdMap()
assert page_id_map.get_page_id(profile_uri) == 1
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [schema]
context_provider.read_file_contents = {profile_uri: dirty_profile}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.render_schema_directories.return_value = ["viking://user/alice/memories"]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(page_id_map=page_id_map)
operations, _ = await loop.resolve_operations(AttrDict(profile=[{"page_id": 1}]))
operation = operations.upsert_operations[0]
assert operation.uris == [profile_uri]
assert operation.old_memory_file_content is dirty_profile
assert operation.resolution_skip is None
@pytest.mark.asyncio
async def test_add_only_resolution_never_reuses_existing_page(self):
schema = MemoryTypeSchema(
memory_type="trajectories",
directory="viking://user/{{ user_space }}/memories/trajectories",
filename_template="{{ trajectory_name }}.md",
operation_mode="add_only",
fields=[],
)
trajectory_uri = "viking://user/alice/memories/trajectories/demo.md"
old_uri = "viking://user/alice/memories/trajectories/old.md"
page_id_map = PageIdMap()
old_page_id = page_id_map.get_page_id(old_uri)
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [schema]
context_provider.read_file_contents = {
old_uri: MemoryFile(uri=old_uri, memory_type="trajectories", content="old trajectory")
}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.calculate_memory_uris.return_value = [trajectory_uri]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(page_id_map=page_id_map)
operations, _ = await loop.resolve_operations(
AttrDict(trajectories=[{"trajectory_name": "demo", "page_id": old_page_id}])
)
operation = operations.upsert_operations[0]
assert operation.page_id == 100
assert operation.uris == [trajectory_uri]
assert operation.old_memory_file_content is None
assert page_id_map.resolve(old_page_id) == old_uri
@pytest.mark.asyncio
async def test_new_page_ids_are_unique_across_memory_types(self):
event_schema = self._event_schema()
profile_schema = MemoryTypeSchema(
memory_type="profile",
directory="viking://user/{{ user_space }}/memories",
filename_template="profile.md",
fields=[],
)
entity_schema = MemoryTypeSchema(
memory_type="entities",
directory="viking://user/{{ user_space }}/memories/entities",
filename_template="{{ name }}.md",
fields=[],
)
uris = {
"events": "viking://user/alice/memories/events/demo.md",
"profile": "viking://user/alice/memories/profile.md",
"entities": "viking://user/alice/memories/entities/target.md",
}
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [
event_schema,
profile_schema,
entity_schema,
]
context_provider.read_file_contents = {}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.calculate_memory_uris.side_effect = lambda **kwargs: [
uris[kwargs["memory_type_schema"].memory_type]
]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(page_id_map=PageIdMap())
loop._link_enabled = True
raw_operations = AttrDict(
events=[{"event_name": "demo", "ranges": "0", "page_id": 100}],
profile=[{"summary": "profile", "page_id": 100}],
entities=[{"name": "target", "page_id": 101}],
links=[WikiLink(f=100, t=101, match_text=None)],
)
operations, raw_links = await loop.resolve_operations(raw_operations)
assert [operation.page_id for operation in operations.upsert_operations] == [102, 100, 101]
assert raw_links == []
repeated_operations, repeated_links = await loop.resolve_operations(raw_operations)
assert [operation.page_id for operation in repeated_operations.upsert_operations] == [
102,
100,
101,
]
assert repeated_links == []
await loop.finalize_operations(operations, raw_links)
assert operations.resolved_links == []
@pytest.mark.asyncio
async def test_duplicate_non_event_page_ids_are_normalized(self):
profile_schema = MemoryTypeSchema(
memory_type="profile",
directory="viking://user/{{ user_space }}/memories",
filename_template="profile.md",
fields=[],
)
entity_schema = MemoryTypeSchema(
memory_type="entities",
directory="viking://user/{{ user_space }}/memories/entities",
filename_template="{{ name }}.md",
fields=[],
)
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [profile_schema, entity_schema]
context_provider.read_file_contents = {}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.calculate_memory_uris.side_effect = lambda **kwargs: [
(
"viking://user/alice/memories/profile.md"
if kwargs["memory_type_schema"].memory_type == "profile"
else f"viking://user/alice/memories/entities/{kwargs['operation'].memory_fields['name']}.md"
)
]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(page_id_map=PageIdMap())
operations, raw_links = await loop.resolve_operations(
AttrDict(
profile=[{"summary": "profile", "page_id": 100}],
entities=[
{"name": "duplicate", "page_id": 100},
{"name": "target", "page_id": 102},
],
links=[WikiLink(f=100, t=102, match_text=None)],
)
)
assert [operation.page_id for operation in operations.upsert_operations] == [100, 101, 102]
assert raw_links == []
@pytest.mark.asyncio
async def test_delete_with_ambiguous_new_replacement_page_id_is_skipped(self):
profile_schema = MemoryTypeSchema(
memory_type="profile",
directory="viking://user/{{ user_space }}/memories",
filename_template="profile.md",
fields=[],
)
entity_schema = MemoryTypeSchema(
memory_type="entities",
directory="viking://user/{{ user_space }}/memories/entities",
filename_template="{{ name }}.md",
fields=[],
)
deleted_uri = "viking://user/alice/memories/entities/deleted.md"
deleted_file = MemoryFile(uri=deleted_uri, memory_type="entities", content="deleted")
page_id_map = PageIdMap()
assert page_id_map.get_page_id(deleted_uri) == 1
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [profile_schema, entity_schema]
context_provider.read_file_contents = {deleted_uri: deleted_file}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.calculate_memory_uris.side_effect = lambda **kwargs: [
(
"viking://user/alice/memories/profile.md"
if kwargs["memory_type_schema"].memory_type == "profile"
else "viking://user/alice/memories/entities/replacement.md"
)
]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(page_id_map=page_id_map)
operations, _ = await loop.resolve_operations(
AttrDict(
profile=[{"summary": "profile", "page_id": 100}],
entities=[{"name": "replacement", "page_id": 100}],
delete_ids=[{"delete_page_id": 1, "replacement_page_id": 100}],
)
)
assert operations.delete_file_contents == []
assert operations.delete_replacements == {}
@pytest.mark.asyncio
async def test_existing_page_id_keeps_existing_uri_and_identity_fields(self):
schema = MemoryTypeSchema(
memory_type="entities",
description="entity memory",
directory="viking://user/{{ user_space }}/memories/entities",
filename_template="{{ name }}.md",
fields=[
MemoryField(name="name", field_type=FieldType.STRING, merge_op=MergeOp.IMMUTABLE),
MemoryField(name="owner", field_type=FieldType.STRING, merge_op=MergeOp.REPLACE),
MemoryField(name="count", field_type=FieldType.INT64, merge_op=MergeOp.SUM),
MemoryField(name="content", field_type=FieldType.STRING, merge_op=MergeOp.PATCH),
],
)
existing_uri = "viking://user/alice/memories/entities/Melanie.md"
old_file = MemoryFile(
uri=existing_uri,
content="old content",
memory_type="entities",
extra_fields={"name": "Melanie", "owner": "Alice", "count": 2},
)
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [schema]
context_provider._get_registry.return_value = Mock(get=Mock(return_value=schema))
context_provider.read_file_contents = {existing_uri: old_file}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, role_scope=None: item
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(
page_id_map=SimpleNamespace(resolve=lambda page_id: existing_uri)
)
operations, _ = await loop.resolve_operations(
AttrDict(
entities=[{"content": "new content", "page_id": 7}],
delete_uris=[],
)
)
operation = operations.upsert_operations[0]
assert operation.uris == [existing_uri]
assert operation.old_memory_file_content is old_file
assert operation.memory_fields["name"] == "Melanie"
assert "owner" not in operation.memory_fields
assert "count" not in operation.memory_fields
assert operation.memory_fields["content"] == "new content"
isolation_handler.calculate_memory_uris.assert_not_called()
@pytest.mark.asyncio
async def test_existing_page_id_keeps_new_replace_and_sum_values(self):
schema = MemoryTypeSchema(
memory_type="entities",
description="entity memory",
fields=[
MemoryField(name="name", field_type=FieldType.STRING, merge_op=MergeOp.IMMUTABLE),
MemoryField(name="owner", field_type=FieldType.STRING, merge_op=MergeOp.REPLACE),
MemoryField(name="count", field_type=FieldType.INT64, merge_op=MergeOp.SUM),
],
)
existing_uri = "viking://user/alice/memories/entities/Melanie.md"
old_file = MemoryFile(
uri=existing_uri,
content="old content",
memory_type="entities",
extra_fields={"name": "Melanie", "owner": "Alice", "count": 2},
)
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [schema]
context_provider.read_file_contents = {existing_uri: old_file}
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, role_scope=None: item
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._extract_context = SimpleNamespace(
page_id_map=SimpleNamespace(resolve=lambda page_id: existing_uri)
)
operations, _ = await loop.resolve_operations(
AttrDict(entities=[{"name": "Ignored", "owner": "Bob", "count": 3, "page_id": 7}])
)
operation = operations.upsert_operations[0]
assert operation.memory_fields["name"] == "Melanie"
assert operation.memory_fields["owner"] == "Bob"
assert operation.memory_fields["count"] == 3
def test_unresolved_page_ids_are_ignored(self):
loop = ExtractLoop(vlm=Mock(model="test-model"), viking_fs=Mock(), context_provider=Mock())
loop._extract_context = Mock()
loop._extract_context.page_id_map = Mock()
loop._extract_context.page_id_map._id_to_uri = {
100: "viking://user/user_sample_0/memories/trajectories/a.md"
}
loop._extract_context.page_id_map.resolve.side_effect = lambda page_id: {
100: "viking://user/user_sample_0/memories/trajectories/a.md"
}.get(page_id)
loop._extract_context.page_id_map.register_new_page_id = Mock()
raw_links = [WikiLink(f=100, t=102, match_text="trip")]
resolved = loop._resolve_links(raw_links, upsert_operations=[])
assert resolved == []
class TestResolveLinksMultiUri:
def test_normalize_operation_links_remaps_unregistered_low_page_id(self):
page_id_map = PageIdMap()
links = [WikiLink(f=5, t=7, match_text="event")]
normalized = ExtractLoop._normalize_operation_links(
links,
{5: [100]},
page_id_map,
)
assert len(normalized) == 1
assert normalized[0].f == 100
assert normalized[0].t == 7
def test_normalize_operation_links_drops_collision_with_existing_page(self):
page_id_map = PageIdMap()
for index in range(5):
page_id_map.get_page_id(f"viking://user/alice/memories/existing-{index}.md")
links = [WikiLink(f=5, t=7, match_text="ambiguous")]
normalized = ExtractLoop._normalize_operation_links(
links,
{5: [100]},
page_id_map,
)
assert normalized == []
def test_shared_page_id_pairs_matching_user_uris_only(self):
loop = ExtractLoop(vlm=Mock(model="test-model"), viking_fs=Mock(), context_provider=Mock())
loop._extract_context = Mock()
loop._extract_context.page_id_map = Mock()
loop._extract_context.page_id_map._id_to_uri = {}
loop._extract_context.page_id_map.resolve.return_value = None
loop._extract_context.page_id_map.register_new_page_id = Mock()
raw_links = [WikiLink(f=100, t=101, match_text="trip")]
upsert_operations = [
ResolvedOperation(
memory_fields={},
memory_type="experiences",
uris=[
"viking://user/a/memories/experiences/source.md",
"viking://user/b/memories/experiences/source.md",
],
page_id=100,
),
ResolvedOperation(
memory_fields={},
memory_type="experiences",
uris=[
"viking://user/a/memories/experiences/target.md",
"viking://user/b/memories/experiences/target.md",
],
page_id=101,
),
]
resolved = loop._resolve_links(raw_links, upsert_operations=upsert_operations)
assert {(link.from_uri, link.to_uri) for link in resolved} == {
(
"viking://user/a/memories/experiences/source.md",
"viking://user/a/memories/experiences/target.md",
),
(
"viking://user/b/memories/experiences/source.md",
"viking://user/b/memories/experiences/target.md",
),
}
def test_shared_page_id_self_link_is_ignored(self):
loop = ExtractLoop(vlm=Mock(model="test-model"), viking_fs=Mock(), context_provider=Mock())
loop._extract_context = Mock()
loop._extract_context.page_id_map = Mock()
loop._extract_context.page_id_map._id_to_uri = {}
loop._extract_context.page_id_map.resolve.return_value = None
raw_links = [WikiLink(f=100, t=100, match_text="trip")]
upsert_operations = [
ResolvedOperation(
memory_fields={},
memory_type="experiences",
uris=[
"viking://user/a/memories/experiences/source.md",
"viking://user/b/memories/experiences/source.md",
],
page_id=100,
)
]
assert loop._resolve_links(raw_links, upsert_operations=upsert_operations) == []
class TestResolutionRepair:
@staticmethod
def _loop(ctx=None):
return ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=Mock(),
isolation_handler=Mock(),
ctx=ctx,
)
def test_retryable_resolution_issues_include_ranges(self):
operations = ResolvedOperations(
upsert_operations=[
ResolvedOperation(
memory_fields={"ranges": "99"},
memory_type="events",
uris=[],
page_id=100,
resolution_skip=MemoryOperationSkip(
reason_code=MemoryOperationSkipCode.INVALID_RANGES,
reason="Message ranges are malformed or out of bounds",
),
)
],
delete_file_contents=[],
errors=[],
)
loop = self._loop()
issues = loop._retryable_resolution_issues(operations)
assert issues == [
{
"memory_type": "events",
"page_id": 100,
"reason_code": "invalid_ranges",
"reason": "Message ranges are malformed or out of bounds",
"operation": {"ranges": "99"},
}
]
loop._output_protocol = create_extraction_output_protocol("json")
instruction = loop._build_resolution_repair_instruction(issues)
assert "valid in-bounds message indexes" in instruction
assert '"reason_code": "invalid_ranges"' in instruction
assert "server has preserved all successful operations" in instruction
def test_policy_skip_is_not_retried(self):
operations = ResolvedOperations(
upsert_operations=[
ResolvedOperation(
memory_fields={},
memory_type="events",
uris=[],
page_id=100,
resolution_skip=MemoryOperationSkip(
reason_code=MemoryOperationSkipCode.PEER_MEMORY_DISABLED,
reason="Peer memory writes are disabled",
),
)
],
delete_file_contents=[],
errors=[],
)
assert self._loop()._retryable_resolution_issues(operations) == []
def test_non_event_resolution_skip_is_not_retried(self):
operations = ResolvedOperations(
upsert_operations=[
ResolvedOperation(
memory_fields={"ranges": "99"},
memory_type="trajectories",
uris=[],
page_id=100,
resolution_skip=MemoryOperationSkip(
reason_code=MemoryOperationSkipCode.INVALID_RANGES,
reason="Message ranges are malformed or out of bounds",
),
)
],
delete_file_contents=[],
errors=[],
)
assert self._loop()._retryable_resolution_issues(operations) == []
def test_missing_request_context_is_not_retried(self):
operations = ResolvedOperations(
upsert_operations=[
ResolvedOperation(
memory_fields={"ranges": "0"},
memory_type="events",
uris=[],
page_id=100,
resolution_skip=MemoryOperationSkip(
reason_code=MemoryOperationSkipCode.NO_WRITABLE_TARGET,
reason="No writable memory target could be resolved",
),
)
],
delete_file_contents=[],
errors=[],
)
assert self._loop(ctx=None)._retryable_resolution_issues(operations) == []
def test_missing_or_failing_isolation_handler_preserves_legacy_retry(self):
operations = ResolvedOperations(
upsert_operations=[
ResolvedOperation(
memory_fields={"ranges": "0"},
memory_type="events",
uris=[],
page_id=100,
resolution_skip=MemoryOperationSkip(
reason_code=MemoryOperationSkipCode.NO_WRITABLE_TARGET,
reason="No writable memory target could be resolved",
),
)
],
delete_file_contents=[],
errors=[],
)
ctx = SimpleNamespace(user=SimpleNamespace(user_id="alice"))
missing_handler = self._loop(ctx=ctx)
missing_handler._isolation_handler = None
assert len(missing_handler._retryable_resolution_issues(operations)) == 1
failing_handler = self._loop(ctx=ctx)
failing_handler._isolation_handler.has_writable_message_target.side_effect = RuntimeError(
"target lookup failed"
)
assert len(failing_handler._retryable_resolution_issues(operations)) == 1
@pytest.mark.parametrize(
("resolution_skip_code", "has_writable_target", "expected_llm_calls"),
[
(MemoryOperationSkipCode.INVALID_RANGES, False, 2),
(MemoryOperationSkipCode.NO_WRITABLE_TARGET, False, 1),
(MemoryOperationSkipCode.NO_WRITABLE_TARGET, True, 2),
],
)
@pytest.mark.asyncio
async def test_run_repairs_only_actionable_event_and_preserves_successful_profile(
self, resolution_skip_code, has_writable_target, expected_llm_calls
):
schema = TestResolveOperations._event_schema()
profile_schema = MemoryTypeSchema(
memory_type="profile",
directory="viking://user/{{ user_space }}/memories",
filename_template="profile.md",
fields=[],
)
event_uri = "viking://user/alice/memories/events/2026/08/27/demo.md"
profile_uri = "viking://user/alice/memories/profile.md"
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [schema, profile_schema]
context_provider.get_output_language.return_value = "zh-CN"
context_provider.get_tools.return_value = []
context_provider.get_extract_context.return_value = SimpleNamespace(page_id_map=PageIdMap())
context_provider.prefetch = AsyncMock(return_value=[])
context_provider.read_file_contents = {}
context_provider.instruction.return_value = "base instruction"
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
isolation_handler.has_writable_message_target.return_value = has_writable_target
event_resolution_attempts = 0
def calculate_memory_uris(*, memory_type_schema, operation, **kwargs):
nonlocal event_resolution_attempts
if memory_type_schema.memory_type == "profile":
return [profile_uri]
event_resolution_attempts += 1
if event_resolution_attempts == 1:
operation.resolution_skip = MemoryOperationSkip(
reason_code=resolution_skip_code,
reason=(
"Message ranges are malformed or out of bounds"
if resolution_skip_code == MemoryOperationSkipCode.INVALID_RANGES
else "No writable memory target could be resolved"
),
)
return []
operation.resolution_skip = None
return [event_uri]
isolation_handler.calculate_memory_uris.side_effect = calculate_memory_uris
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
ctx=SimpleNamespace(user=SimpleNamespace(user_id="alice")),
)
loop._call_llm = AsyncMock(
side_effect=[
(
[],
AttrDict(
events=[{"event_name": "demo", "ranges": "99", "page_id": 5}],
profile=[{"page_id": 101, "summary": "keep me"}],
),
),
(
[],
AttrDict(events=[{"event_name": "demo", "ranges": "0", "page_id": 100}]),
),
]
)
loop._check_unread_existing_files = AsyncMock(return_value=[])
loop._validate_patch_operations = AsyncMock(return_value=[])
loop.finalize_operations = AsyncMock()
with (
patch("openviking.session.memory.extract_loop.get_openviking_config") as mock_config,
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.generate_all_models"
),
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.create_structured_operations_model"
) as mock_create_model,
):
mock_config.return_value = SimpleNamespace(memory=SimpleNamespace(link_enabled=False))
mock_create_model.return_value = SimpleNamespace(
model_fields={"events": None},
model_json_schema=lambda: {},
)
final_operations, _ = await loop.run()
assert loop._call_llm.await_count == expected_llm_calls
assert event_resolution_attempts == expected_llm_calls
assert len(final_operations.upsert_operations) == 2
assert final_operations.upsert_operations[0].uris == (
[event_uri] if expected_llm_calls == 2 else []
)
assert final_operations.upsert_operations[0].page_id == 100
assert final_operations.upsert_operations[1].memory_type == "profile"
assert final_operations.upsert_operations[1].uris == [profile_uri]
assert final_operations.upsert_operations[1].memory_fields["summary"] == "keep me"
repair_messages = [
message["content"]
for message in loop._call_llm.await_args_list[-1].args[0]
if message["role"] == "user" and "Resolution issues:" in message["content"]
]
if expected_llm_calls == 2:
assert len(repair_messages) == 1
assert f'"reason_code": "{resolution_skip_code.value}"' in repair_messages[0]
assert '"event_name": "demo"' in repair_messages[0]
else:
assert repair_messages == []
def test_merge_event_repair_ignores_unrequested_memory_types(self):
original_profile = ResolvedOperation(
memory_fields={"summary": "original"},
memory_type="profile",
uris=["viking://user/alice/memories/profile.md"],
page_id=1,
)
failed_event = ResolvedOperation(
memory_fields={"ranges": "99"},
memory_type="events",
uris=[],
page_id=100,
resolution_skip=MemoryOperationSkip(
reason_code=MemoryOperationSkipCode.INVALID_RANGES,
reason="invalid",
),
)
repaired_event = ResolvedOperation(
memory_fields={"ranges": "0"},
memory_type="events",
uris=["viking://user/alice/memories/events/demo.md"],
page_id=100,
)
hallucinated_profile = original_profile.model_copy(
update={"memory_fields": {"summary": "changed"}}
)
merged = ExtractLoop._merge_event_resolution_repair(
ResolvedOperations(
upsert_operations=[original_profile, failed_event],
delete_file_contents=[],
errors=[],
),
ResolvedOperations(
upsert_operations=[repaired_event, hallucinated_profile],
delete_file_contents=[],
errors=[],
),
)
assert merged.upsert_operations == [original_profile, repaired_event]
def test_event_repair_subset_filters_extra_events_and_preserves_failed_id(self):
successful_event = ResolvedOperation(
memory_fields={"event_name": "success", "ranges": "0", "summary": "success"},
memory_type="events",
uris=["viking://user/alice/memories/events/success.md"],
page_id=100,
)
failed_event = ResolvedOperation(
memory_fields={"event_name": "failed", "ranges": "99", "summary": "original"},
memory_type="events",
uris=[],
page_id=101,
resolution_skip=MemoryOperationSkip(
reason_code=MemoryOperationSkipCode.INVALID_RANGES,
reason="invalid",
),
)
original = ResolvedOperations(
upsert_operations=[successful_event, failed_event],
delete_file_contents=[],
errors=[],
)
subset = ExtractLoop._event_resolution_repair_subset(
AttrDict(
events=[
{
"event_name": "success",
"ranges": "0",
"summary": "duplicate",
"page_id": 100,
},
{
"event_name": "failed",
"ranges": "0",
"summary": "changed",
"page_id": 999,
},
{
"event_name": "failed",
"ranges": "0",
"summary": "changed",
"page_id": 101,
},
],
profile=[{"page_id": 1, "summary": "ignore"}],
),
original,
)
assert subset.events == [
{
"event_name": "failed",
"ranges": "0",
"summary": "original",
"page_id": 101,
}
]
assert subset.delete_ids == []
assert subset.links == []
def test_merge_event_repair_rejects_changed_or_duplicate_page_id(self):
failed_event = ResolvedOperation(
memory_fields={"event_name": "failed", "ranges": "99"},
memory_type="events",
uris=[],
page_id=101,
resolution_skip=MemoryOperationSkip(
reason_code=MemoryOperationSkipCode.INVALID_RANGES,
reason="invalid",
),
)
changed_id = failed_event.model_copy(
update={
"uris": ["viking://user/alice/memories/events/changed.md"],
"page_id": 102,
"resolution_skip": None,
}
)
duplicate_a = failed_event.model_copy(
update={
"uris": ["viking://user/alice/memories/events/a.md"],
"resolution_skip": None,
}
)
duplicate_b = duplicate_a.model_copy(
update={"uris": ["viking://user/alice/memories/events/b.md"]}
)
original = ResolvedOperations(
upsert_operations=[failed_event],
delete_file_contents=[],
errors=[],
)
changed_id_result = ExtractLoop._merge_event_resolution_repair(
original,
ResolvedOperations(
upsert_operations=[changed_id],
delete_file_contents=[],
errors=[],
),
)
duplicate_result = ExtractLoop._merge_event_resolution_repair(
original,
ResolvedOperations(
upsert_operations=[duplicate_a, duplicate_b],
delete_file_contents=[],
errors=[],
),
)
assert changed_id_result.upsert_operations == [failed_event]
assert duplicate_result.upsert_operations == [failed_event]
@pytest.mark.asyncio
async def test_run_keeps_first_pass_when_event_repair_cannot_be_parsed(self):
event_schema = TestResolveOperations._event_schema()
profile_schema = MemoryTypeSchema(
memory_type="profile",
directory="viking://user/{{ user_space }}/memories",
filename_template="profile.md",
fields=[],
)
profile_uri = "viking://user/alice/memories/profile.md"
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [event_schema, profile_schema]
context_provider.get_output_language.return_value = "zh-CN"
context_provider.get_tools.return_value = []
context_provider.get_extract_context.return_value = SimpleNamespace(page_id_map=PageIdMap())
context_provider.prefetch = AsyncMock(return_value=[])
context_provider.read_file_contents = {}
context_provider.instruction.return_value = "base instruction"
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, **kwargs: item
def calculate_memory_uris(*, memory_type_schema, operation, **kwargs):
if memory_type_schema.memory_type == "profile":
return [profile_uri]
operation.resolution_skip = MemoryOperationSkip(
reason_code=MemoryOperationSkipCode.INVALID_RANGES,
reason="Message ranges are malformed or out of bounds",
)
return []
isolation_handler.calculate_memory_uris.side_effect = calculate_memory_uris
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
max_iterations=1,
)
loop._call_llm = AsyncMock(
side_effect=[
(
[],
AttrDict(
events=[{"event_name": "demo", "ranges": "99", "page_id": 5}],
profile=[{"page_id": 101, "summary": "keep me"}],
),
),
([], None),
([], None),
]
)
loop.finalize_operations = AsyncMock()
with (
patch("openviking.session.memory.extract_loop.get_openviking_config") as mock_config,
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.generate_all_models"
),
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.create_structured_operations_model"
) as mock_create_model,
):
mock_config.return_value = SimpleNamespace(memory=SimpleNamespace(link_enabled=False))
mock_create_model.return_value = SimpleNamespace(
model_fields={"events": None, "profile": None},
model_json_schema=lambda: {},
)
final_operations, _ = await loop.run()
assert loop._call_llm.await_count == 3
assert len(final_operations.upsert_operations) == 2
assert final_operations.upsert_operations[0].memory_type == "events"
assert (
final_operations.upsert_operations[0].resolution_skip.reason_code
== MemoryOperationSkipCode.INVALID_RANGES
)
assert final_operations.upsert_operations[1].memory_type == "profile"
assert final_operations.upsert_operations[1].uris == [profile_uri]
assert final_operations.errors == []
class TestPageIdInstruction:
@pytest.mark.asyncio
async def test_run_always_includes_page_id_rules_when_links_disabled(self):
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [
SimpleNamespace(memory_type="experiences")
]
context_provider.get_output_language.return_value = "zh-CN"
context_provider.get_tools.return_value = []
extract_context = Mock()
extract_context.page_id_map = PageIdMap()
context_provider.get_extract_context.return_value = extract_context
context_provider.prefetch = AsyncMock(return_value=[])
context_provider.read_file_contents = {}
context_provider.instruction.return_value = "base instruction"
context_provider._get_registry.return_value = Mock()
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, role_scope=None: item
isolation_handler.calculate_memory_uris.return_value = [
"viking://user/alice/memories/experiences/chat.md"
]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._call_llm = AsyncMock(
return_value=(
[],
AttrDict(
experiences=[{"experience_name": "chat", "content": "updated", "page_id": 100}]
),
)
)
loop._check_unread_existing_files = AsyncMock(return_value=[])
loop.finalize_operations = AsyncMock()
with (
patch("openviking.session.memory.extract_loop.get_openviking_config") as mock_config,
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.generate_all_models"
),
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.create_structured_operations_model"
) as mock_create_model,
):
mock_config.return_value = SimpleNamespace(
memory=SimpleNamespace(link_enabled=False, extraction_output_format="json")
)
mock_create_model.return_value = SimpleNamespace(model_json_schema=lambda: {})
await loop.run()
system_content = loop._call_llm.await_args.args[0][0]["content"]
assert "## Page ID Rules" in system_content
assert "## Read Format Rules" not in system_content
assert 'Every memory item you create or edit MUST include "page_id".' in system_content
assert (
"The read tool accepts `uri`, optional `offset` (0-indexed), and optional `limit`."
not in system_content
)
assert "each visible line is prefixed with `line_number<TAB>`" not in system_content
assert (
"Never include the line-number prefix itself in `search`, `replace`, or `delete`."
not in system_content
)
assert (
"For existing items, use the page_id shown in the supplied memory context."
in system_content
)
assert "For new items, assign a unique page_id >= 100." in system_content
assert "When editing an existing item, reuse its existing page_id." in system_content
assert "Link fields" not in system_content
@pytest.mark.asyncio
async def test_run_includes_link_page_id_rule_when_links_enabled(self):
context_provider = Mock()
context_provider.get_memory_schemas.return_value = [
SimpleNamespace(memory_type="experiences")
]
context_provider.get_output_language.return_value = "zh-CN"
context_provider.get_tools.return_value = []
extract_context = Mock()
extract_context.page_id_map = PageIdMap()
context_provider.get_extract_context.return_value = extract_context
context_provider.prefetch = AsyncMock(return_value=[])
context_provider.read_file_contents = {}
context_provider.instruction.return_value = "base instruction"
context_provider._get_registry.return_value = Mock()
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = None
isolation_handler.fill_identity_fields.side_effect = lambda item, role_scope=None: item
isolation_handler.calculate_memory_uris.return_value = [
"viking://user/alice/memories/experiences/chat.md"
]
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._call_llm = AsyncMock(
return_value=(
[],
AttrDict(
experiences=[{"experience_name": "chat", "content": "updated", "page_id": 100}],
links=[],
),
)
)
loop._check_unread_existing_files = AsyncMock(return_value=[])
loop.finalize_operations = AsyncMock()
with (
patch("openviking.session.memory.extract_loop.get_openviking_config") as mock_config,
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.generate_all_models"
),
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.create_structured_operations_model"
) as mock_create_model,
):
mock_config.return_value = SimpleNamespace(
memory=SimpleNamespace(link_enabled=True, extraction_output_format="json")
)
mock_create_model.return_value = SimpleNamespace(model_json_schema=lambda: {})
await loop.run()
system_content = loop._call_llm.await_args.args[0][0]["content"]
assert "## Page ID Rules" in system_content
assert "## Read Format Rules" not in system_content
assert "## Link Rules" in system_content
assert "Link fields `f` and `t` must reference these page_id values." in system_content
assert "each visible line is prefixed with `line_number<TAB>`" not in system_content
assert "Only create links when the relationship is meaningful" in system_content
class TestFinalOperationsHydration:
@pytest.mark.asyncio
async def test_run_logs_final_operations_after_old_memory_file_is_hydrated(self):
old_file = MemoryFile(
uri="viking://user/Caroline/memories/experiences/chat.md", content="old"
)
context_provider = Mock()
schema = MemoryTypeSchema(memory_type="experiences", fields=[])
context_provider.get_memory_schemas.return_value = [schema]
context_provider.get_output_language.return_value = "zh-CN"
context_provider.get_tools.return_value = []
extract_context = Mock()
extract_context.page_id_map = PageIdMap()
extract_context.page_id_map.get_page_id(old_file.uri)
context_provider.get_extract_context.return_value = extract_context
context_provider.prefetch = AsyncMock(return_value=[])
context_provider.read_file_contents = {old_file.uri: old_file}
context_provider.instruction.return_value = "test instruction"
context_provider._get_registry.return_value = Mock()
isolation_handler = Mock()
isolation_handler.get_read_scope.return_value = "user://Caroline"
isolation_handler.fill_identity_fields.side_effect = lambda item, role_scope=None: item
loop = ExtractLoop(
vlm=Mock(model="test-model"),
viking_fs=Mock(),
context_provider=context_provider,
isolation_handler=isolation_handler,
)
loop._call_llm = AsyncMock(
return_value=(
[],
AttrDict(
experiences=[{"experience_name": "chat", "content": "updated", "page_id": 1}]
),
)
)
loop._check_unread_existing_files = AsyncMock(return_value=[])
loop.finalize_operations = AsyncMock()
with (
patch("openviking.session.memory.extract_loop.get_openviking_config") as mock_config,
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.generate_all_models"
),
patch(
"openviking.session.memory.extract_loop.SchemaModelGenerator.create_structured_operations_model"
) as mock_create_model,
patch("openviking.session.memory.extract_loop.tracer.info") as mock_tracer_info,
):
mock_config.return_value = SimpleNamespace(
memory=SimpleNamespace(link_enabled=False, extraction_output_format="json")
)
mock_create_model.return_value = SimpleNamespace(model_json_schema=lambda: {})
final_operations, _ = await loop.run()
assert extract_context.page_id_map.resolve(1) == old_file.uri
op = final_operations.upsert_operations[0]
assert op.page_id == 1
assert op.old_memory_file_content is old_file
assert final_operations.resolved_links == []
logged_messages = [call.args[0] for call in mock_tracer_info.call_args_list]
final_log = next(
message for message in logged_messages if message.startswith("final_operations=")
)
assert '"old_memory_file_content":null' not in final_log
class TestExtractionMaxOutputTokens:
"""The extraction floor (32768) suits Doubao; vlm.max_tokens must override it."""
def _loop(self, *, vlm_max_tokens, per_loop=None):
loop = ExtractLoop(
vlm=Mock(model="test-model", max_tokens=vlm_max_tokens),
viking_fs=Mock(),
context_provider=Mock(),
isolation_handler=Mock(),
max_output_tokens=per_loop,
)
loop._resolve_effective_max_output_tokens()
return loop
def test_default_floor_used_when_unconfigured(self):
loop = self._loop(vlm_max_tokens=None)
assert loop._effective_max_output_tokens == 32768
def test_vlm_max_tokens_overrides_default_for_small_models(self):
loop = self._loop(vlm_max_tokens=16384)
assert loop._effective_max_output_tokens == 16384
def test_per_loop_value_wins_over_config(self):
loop = self._loop(vlm_max_tokens=16384, per_loop=8192)
assert loop._effective_max_output_tokens == 8192