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 __future__ import annotations
import inspect
from types import SimpleNamespace
from unittest.mock import AsyncMock
import pytest
from openviking.message import Message, TextPart
from openviking.server.identity import RequestContext, Role
from openviking.session import create_session_compressor
from openviking.session.compressor_v3 import (
SessionCompressorV3,
_commit_experience_snapshot,
_experience_root_uri,
_experience_snapshot_provenance,
_experience_trajectory_map,
_report_extraction_telemetry,
_visible_experience_snapshot_uris,
)
from openviking.session.memory.dataclass import (
MemoryFile,
MemoryOperationSkipCode,
ResolvedOperation,
ResolvedOperations,
SkippedMemoryOperation,
StoredLink,
)
from openviking.session.memory.memory_updater import (
MemoryReadError,
MemoryUpdateError,
MemoryUpdateResult,
)
from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
from openviking.session.train import (
Case,
ExperienceSet,
PolicyApplyResult,
PolicyPlanItem,
PolicyUpdatePlan,
Rollout,
RolloutAnalysis,
RolloutTrainingResult,
Rubric,
RubricCriterion,
RubricEvaluation,
StreamingPolicyTrainerConfig,
Trajectory,
)
from openviking.session.train.components.session_commit import _case_spec_message_to_request
from openviking.telemetry import OperationTelemetry, bind_telemetry
from openviking_cli.exceptions import ConflictError
from openviking_cli.session.user_id import UserIdentifier
def _ctx() -> RequestContext:
return RequestContext(user=UserIdentifier.the_default_user("u"), role=Role.ROOT)
def _messages() -> list[Message]:
return [
Message(
id="m1",
role="user",
parts=[TextPart("请处理重复预订,只取消确认是重复的那一单。")],
),
Message(
id="m2",
role="assistant",
parts=[TextPart("已读取两个预订,确认第二个是重复记录并取消。")],
),
]
def _case_operation() -> ResolvedOperation:
return ResolvedOperation(
old_memory_file_content=None,
memory_type="cases",
uris=["viking://user/u/memories/cases/重复预订处理.md"],
memory_fields={
"case_name": "重复预订处理",
"task_signature": "处理重复预订并只取消确认重复的订单",
"input": '{"summary":"用户要求处理重复预订","preconditions":["存在两个相似预订"]}',
"rubric": '{"name":"重复预订处理Rubric","description":"成功且高效处理重复预订","criteria":[{"name":"先验证重复","description":"取消前必须确认哪一单是重复订单","required":true,"weight":0.6},{"name":"只取消重复项","description":"不得影响有效订单","required":true,"weight":0.4}]}',
"evidence": "助手根据读取结果确认重复项并完成取消。",
},
)
def test_factory_defaults_to_v3():
compressor = create_session_compressor(vikingdb=None)
assert isinstance(compressor, SessionCompressorV3)
@pytest.mark.asyncio
async def test_commit_extraction_propagates_template_conflict():
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
conflict = ConflictError("Conflicting memory template snapshots; Re-extract before retrying")
compressor._extract_user_memories = AsyncMock(side_effect=conflict)
compressor._write_final_memory_diff = AsyncMock()
with pytest.raises(ConflictError) as raised:
await compressor.extract_long_term_memories(
messages=_messages(),
ctx=_ctx(),
allowed_memory_types={"profile"},
# The Session commit worker uses this mode: a conflict must reach it,
# not turn into an empty successful extraction or memory diff.
strict_extract_errors=True,
)
assert raised.value is conflict
compressor._write_final_memory_diff.assert_not_awaited()
def test_factory_ignores_deprecated_memory_version():
assert isinstance(
create_session_compressor(vikingdb=None, memory_version="v2"), SessionCompressorV3
)
assert isinstance(
create_session_compressor(vikingdb=None, memory_version="unsupported"),
SessionCompressorV3,
)
def test_extract_long_term_memories_preserves_legacy_positional_parameter_order():
parameter_names = list(
inspect.signature(SessionCompressorV3.extract_long_term_memories).parameters
)
assert parameter_names[-4:] == [
"allow_self_memory",
"allowed_peer_ids",
"event_search_tags",
"peer_memory_enabled",
]
def test_report_extraction_telemetry_handles_placeholder_error_targets():
operations = ResolvedOperations(
upsert_operations=[
ResolvedOperation(
old_memory_file_content=None,
memory_fields={},
memory_type="events",
uris=["unknown"],
)
],
delete_file_contents=[],
errors=[],
)
result = MemoryUpdateResult()
result.add_written("unknown")
result.add_edited("viking://user/u/memories/preferences/pref.md")
result.add_deleted("viking://user/u/memories/events/old.md")
result.add_error("events(page_id=xyz)", ValueError("Missing resolved URI"))
telemetry = OperationTelemetry(operation="session.commit", enabled=True)
with bind_telemetry(telemetry):
_report_extraction_telemetry(result, operations)
summary = telemetry.finish().summary
extract = summary["memory"]["extract"]
assert extract["actions"] == {
"created": 1,
"merged": 1,
"deleted": 1,
"failed": 1,
}
assert extract["actions_by_type"] == {
"events": {"created": 1, "deleted": 1},
"preferences": {"merged": 1},
"unknown": {"failed": 1},
}
@pytest.mark.asyncio
async def test_memory_diff_includes_intentionally_skipped_operations(monkeypatch):
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(),
)
compressor = SessionCompressorV3(vikingdb=None)
result = MemoryUpdateResult()
result.add_skipped(
SkippedMemoryOperation(
memory_type="events",
page_id=101,
reason_code=MemoryOperationSkipCode.INVALID_RANGES,
reason="No valid event range could be resolved",
)
)
diff = await compressor._build_memory_diff(
result=result,
operations=ResolvedOperations(
upsert_operations=[],
delete_file_contents=[],
errors=[],
),
viking_fs=SimpleNamespace(),
ctx=_ctx(),
archive_uri="viking://user/u/sessions/s1/history/archive_001",
)
assert diff["skipped_operations"] == [
{
"memory_type": "events",
"page_id": 101,
"reason_code": "invalid_ranges",
"reason": "No valid event range could be resolved",
}
]
assert diff["summary"] == {
"total_adds": 0,
"total_updates": 0,
"total_deletes": 0,
"total_skipped": 1,
}
@pytest.mark.asyncio
async def test_v3_skips_agent_training_when_agent_evolution_is_disabled(monkeypatch):
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(),
)
compressor = SessionCompressorV3(vikingdb=None)
compressor._extract_user_memories = AsyncMock(
return_value=SimpleNamespace(
contexts=[],
cases=[_training_case()],
memory_diff={"operations": {}},
case_uri_by_name={},
skipped_operations=[
{
"memory_type": "profile",
"reason_code": "peer_memory_disabled",
"reason": "Peer memory writes are disabled",
}
],
)
)
compressor.train_from_extracted_cases = AsyncMock()
compressor._write_final_memory_diff = AsyncMock()
result = await compressor.extract_long_term_memories(
messages=_messages(),
ctx=_ctx(),
allowed_memory_types={"cases", "profile"},
agent_evolution_enabled=False,
)
compressor.train_from_extracted_cases.assert_not_awaited()
assert result == []
@pytest.mark.asyncio
async def test_v3_extracts_session_skills_when_agent_evolution_is_disabled(monkeypatch):
config = SimpleNamespace(
memory=SimpleNamespace(session_skill_extraction_enabled=True),
)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_openviking_config",
lambda: config,
)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(),
)
compressor = SessionCompressorV3(
vikingdb=None,
skill_processor=SimpleNamespace(),
)
compressor._extract_user_memories = AsyncMock(
return_value=SimpleNamespace(
contexts=[],
cases=[],
memory_diff={"operations": {}},
case_uri_by_name={},
)
)
compressor.train_from_extracted_cases = AsyncMock()
compressor.extract_session_skills = AsyncMock(
return_value={
"case_count": 0,
"submitted": 0,
"skill_submitted": 1,
"skill_uris": ["viking://user/u/skills/code-review/SKILL.md"],
}
)
compressor._write_final_memory_diff = AsyncMock()
result = await compressor.extract_long_term_memories(
messages=_messages(),
ctx=_ctx(),
allowed_memory_types={"profile", "preferences"},
agent_evolution_enabled=False,
)
compressor.train_from_extracted_cases.assert_not_awaited()
compressor.extract_session_skills.assert_awaited_once()
assert result["session_skills"] == [
{
"uri": "viking://user/u/skills/code-review/SKILL.md",
"archive_uri": "",
}
]
@pytest.mark.asyncio
async def test_v3_skill_only_extraction_submits_gradients_without_agent_memories(monkeypatch):
from openviking.session.train import PatchSemanticGradient
skill_uri = "viking://user/u/skills/code-review/SKILL.md"
gradient = PatchSemanticGradient(
before_file=None,
after_file=MemoryFile(
uri=skill_uri,
content="## Workflow\n- Read changed files first.",
memory_type="skills",
extra_fields={"skill_name": "code-review"},
),
base_version=None,
rationale="test",
links=[],
confidence=0.9,
metadata={},
)
analyzer = SimpleNamespace(
extract_trajectory_memories=AsyncMock(
return_value={"contexts": [], "skill_gradients": [gradient]}
)
)
trainer = SimpleNamespace(
submit_gradients=AsyncMock(
return_value=SimpleNamespace(apply_result=SimpleNamespace(written_uris=[skill_uri]))
)
)
compressor = SessionCompressorV3(
vikingdb=None,
rollout_analyzer=analyzer,
skill_processor=SimpleNamespace(),
)
compressor._session_skill_extraction_enabled = lambda: True
compressor._get_session_skill_trainer = AsyncMock(return_value=trainer)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(),
)
result = await compressor.extract_session_skills(
messages=_messages(),
ctx=_ctx(),
archive_uri="viking://user/u/sessions/s1/history/archive_001",
)
analyzer.extract_trajectory_memories.assert_awaited_once()
assert analyzer.extract_trajectory_memories.await_args.kwargs["include_trajectories"] is False
trainer.submit_gradients.assert_awaited_once_with([gradient])
assert result == {
"case_count": 0,
"submitted": 0,
"skill_submitted": 1,
"skill_uris": [skill_uri],
}
@pytest.mark.asyncio
async def test_v3_skips_agent_training_when_execution_memory_types_are_filtered(monkeypatch):
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(),
)
compressor = SessionCompressorV3(vikingdb=None)
compressor._extract_user_memories = AsyncMock(
return_value=SimpleNamespace(
contexts=[],
cases=[_training_case()],
memory_diff={"operations": {}},
case_uri_by_name={},
)
)
compressor.train_from_extracted_cases = AsyncMock()
compressor._write_final_memory_diff = AsyncMock()
await compressor.extract_long_term_memories(
messages=_messages(),
ctx=_ctx(),
allowed_memory_types={"cases", "profile"},
agent_evolution_enabled=True,
)
compressor.train_from_extracted_cases.assert_not_awaited()
@pytest.mark.asyncio
async def test_v3_passes_allowed_execution_types_to_agent_training(monkeypatch):
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(),
)
compressor = SessionCompressorV3(vikingdb=None)
compressor._extract_user_memories = AsyncMock(
return_value=SimpleNamespace(
contexts=[],
cases=[_training_case()],
memory_diff={"operations": {}},
case_uri_by_name={},
)
)
compressor.train_from_extracted_cases = AsyncMock(
return_value={"case_count": 1, "submitted": 1}
)
compressor._write_final_memory_diff = AsyncMock()
await compressor.extract_long_term_memories(
messages=_messages(),
ctx=_ctx(),
allowed_memory_types={"cases", "trajectories"},
agent_evolution_enabled=True,
)
assert compressor.train_from_extracted_cases.await_args.kwargs["allowed_memory_types"] == {
"trajectories"
}
@pytest.mark.asyncio
async def test_v3_initializes_only_allowed_memory_files(monkeypatch):
initialized_with = []
class DummyRegistry:
async def initialize_memory_files(self, ctx, allowed_memory_types=None):
del ctx
initialized_with.append(allowed_memory_types)
class DummyOrchestrator:
async def run(self):
return None, []
compressor = SessionCompressorV3(vikingdb=None)
compressor._get_or_create_react = lambda **kwargs: DummyOrchestrator()
compressor._write_final_memory_diff = AsyncMock()
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(),
)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_default_registry",
lambda: DummyRegistry(),
)
await compressor.extract_long_term_memories(
messages=_messages(),
ctx=_ctx(),
allowed_memory_types={"profile"},
agent_evolution_enabled=False,
)
assert initialized_with == [{"profile"}]
def test_experience_root_uri_requires_request_user():
with pytest.raises(ValueError, match="RequestContext.user.user_id is required"):
_experience_root_uri(SimpleNamespace(user=None))
def test_case_experience_links_require_policy_root_uri():
traj_uri = "viking://user/u/memories/trajectories/t.md"
plan = PolicyUpdatePlan(
items=[
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="exp",
target_uri=None,
before_content=None,
after_content="exp",
links=[
StoredLink(
from_uri="",
to_uri=traj_uri,
link_type="derived_from",
weight=1.0,
)
],
)
]
)
apply_result = PolicyApplyResult(
updated_policy_set=ExperienceSet(root_uri="", policies=[]),
written_uris=["viking://user/u/memories/experiences/exp.md"],
)
from openviking.session.compressor_v3 import _case_experience_links_via_trajectories
with pytest.raises(ValueError, match="updated_policy_set.root_uri is required"):
_case_experience_links_via_trajectories(
case_uri="viking://user/u/memories/cases/case.md",
trajectory_uris={traj_uri},
plan=plan,
apply_result=apply_result,
)
def test_case_experience_links_exclude_experiences_that_failed_to_persist():
traj_uri = "viking://user/u/memories/trajectories/t.md"
exp_uri = "viking://user/u/memories/experiences/exp.md"
plan = PolicyUpdatePlan(
items=[
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="exp",
target_uri=exp_uri,
before_content=None,
after_content="exp",
links=[
StoredLink(
from_uri=exp_uri,
to_uri=traj_uri,
link_type="derived_from",
weight=1.0,
)
],
)
]
)
apply_result = PolicyApplyResult(
updated_policy_set=ExperienceSet(
root_uri="viking://user/u/memories/experiences",
policies=[],
),
written_uris=[],
errors=[f"{exp_uri}: failed to acquire encrypted write lock"],
)
from openviking.session.compressor_v3 import _case_experience_links_via_trajectories
assert (
_case_experience_links_via_trajectories(
case_uri="viking://user/u/memories/cases/case.md",
trajectory_uris={traj_uri},
plan=plan,
apply_result=apply_result,
)
== []
)
@pytest.mark.asyncio
async def test_train_from_extracted_cases_submits_streaming_rollout(monkeypatch):
submitted_gradients = []
submitted_analyses = []
class FakeTrainer:
policy_set = ExperienceSet(
root_uri="viking://user/u/memories/experiences",
policies=[],
)
async def submit_gradients(self, gradients, *, analysis=None, rollout=None):
submitted_gradients.append(gradients)
submitted_analyses.append(analysis)
return RolloutTrainingResult(
analyses=[analysis] if analysis else [],
gradients=list(gradients),
plan=PolicyUpdatePlan(items=[], metadata={}),
apply_result=PolicyApplyResult(
updated_policy_set=self.policy_set,
written_uris=[],
errors=[],
),
metadata={},
)
class FakeAnalyzer:
async def analyze(self, rollout, context):
return RolloutAnalysis(
evaluation=RubricEvaluation(
passed=True,
score=1.0,
criterion_results=[],
feedback=[],
),
trajectories=[
Trajectory(
name="duplicate_booking",
uri="viking://user/u/memories/trajectories/t1.md",
content="trajectory content",
outcome="success",
retrieval_anchor="",
)
],
gradients=[],
)
async def fake_estimate_exp_gradients(self, *args, **kwargs):
# Return one dummy gradient so we can verify submission
from openviking.session.memory.dataclass import MemoryFile
from openviking.session.train import PatchSemanticGradient
return [
PatchSemanticGradient(
before_file=None,
after_file=MemoryFile(
uri="viking://user/u/memories/experiences/e1.md",
content="new exp",
memory_type="experiences",
extra_fields={"experience_name": "e1"},
),
base_version=1,
rationale="test",
links=[],
confidence=0.9,
metadata={},
)
]
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(ls=AsyncMock(return_value=[])),
)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_streaming_policy_trainer",
AsyncMock(return_value=FakeTrainer()),
)
monkeypatch.setattr(
"openviking.session.train.components.gradient_estimator.ExperienceGradientEstimator.estimate",
fake_estimate_exp_gradients,
)
compressor = SessionCompressorV3(
vikingdb=None,
rollout_analyzer=FakeAnalyzer(),
streaming_trainer_config=StreamingPolicyTrainerConfig(
max_wait_seconds=60,
max_gradients_per_update=8,
),
)
cases = [_training_case()]
result = await compressor.train_from_extracted_cases(
cases=cases,
messages=_messages(),
ctx=_ctx(),
session_id="s1",
)
assert result["case_count"] == 1
assert result["submitted"] == 1
assert len(submitted_gradients) == 1
assert len(submitted_gradients[0]) == 1 # one exp gradient per case
# Verify analysis was used
assert submitted_analyses[0] is not None
assert submitted_analyses[0].trajectories[0].name == "duplicate_booking"
assert cases[0].name == "duplicate_booking"
@pytest.mark.asyncio
async def test_train_from_extracted_cases_skips_experience_updates_when_not_allowed(monkeypatch):
analyzed = []
class FakeTrainer:
policy_set = ExperienceSet(
root_uri="viking://user/u/memories/experiences",
policies=[],
)
class FakeAnalyzer:
async def analyze(self, rollout, context):
del context
analyzed.append(rollout)
return RolloutAnalysis(
evaluation=RubricEvaluation(
passed=True,
score=1.0,
criterion_results=[],
feedback=[],
),
trajectories=[
Trajectory(
name="duplicate_booking",
uri="viking://user/u/memories/trajectories/t1.md",
content="trajectory content",
outcome="success",
retrieval_anchor="",
)
],
gradients=[],
)
estimate = AsyncMock(side_effect=AssertionError("experience estimation must be skipped"))
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(ls=AsyncMock(return_value=[])),
)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_streaming_policy_trainer",
AsyncMock(return_value=FakeTrainer()),
)
monkeypatch.setattr(
"openviking.session.train.components.gradient_estimator.ExperienceGradientEstimator.estimate",
estimate,
)
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=FakeAnalyzer())
result = await compressor.train_from_extracted_cases(
cases=[_training_case()],
messages=_messages(),
ctx=_ctx(),
session_id="s1",
allowed_memory_types={"trajectories"},
)
assert len(analyzed) == 1
assert result["submitted"] == 1
estimate.assert_not_awaited()
@pytest.mark.asyncio
@pytest.mark.parametrize("apply_error", [False, True, "links"])
async def test_v3_extract_uses_patch_merge_without_directory_lock(monkeypatch, apply_error):
applied_operations = []
trained_cases = []
uri = _case_operation().uris[0]
link = StoredLink(from_uri=uri, to_uri=uri + ".other.md", link_type="related_to")
class DummyRegistry:
async def initialize_memory_files(self, ctx, allowed_memory_types=None):
del ctx, allowed_memory_types
return None
class DummyOrchestrator:
async def run(self):
return (
ResolvedOperations(
upsert_operations=[_case_operation()],
delete_file_contents=[],
errors=[],
resolved_links=[link] if apply_error == "links" else [],
),
[],
)
class FakeStreamingUpdater:
async def submit(self, request):
applied_operations.append(request.operations)
result = MemoryUpdateResult()
if apply_error:
result.add_error(uri, MemoryReadError(uri, TimeoutError("read timeout")))
else:
result.add_written(uri)
return SimpleNamespace(operations=request.operations, apply_result=result)
compressor = SessionCompressorV3(
vikingdb=None,
rollout_analyzer=SimpleNamespace(),
vlm_resolver=SimpleNamespace(get_vlm=AsyncMock(return_value=SimpleNamespace())),
)
compressor._get_or_create_react = lambda **kwargs: DummyOrchestrator()
async def fake_train_from_extracted_cases(**kwargs):
trained_cases.extend(kwargs["cases"])
return {"case_count": len(kwargs["cases"]), "submitted": len(kwargs["cases"])}
compressor.train_from_extracted_cases = fake_train_from_extracted_cases
monkeypatch.setattr(
"openviking.session.compressor_v3.get_viking_fs",
lambda: SimpleNamespace(write_file=AsyncMock()),
)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_default_registry",
lambda: DummyRegistry(),
)
monkeypatch.setattr(
"openviking.session.memory.account_templates.resolve_account_memory_registry",
AsyncMock(return_value=DummyRegistry()),
)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_streaming_memory_updater",
AsyncMock(return_value=FakeStreamingUpdater()),
)
extraction = compressor.extract_long_term_memories(
messages=_messages(),
ctx=_ctx(),
allowed_memory_types={"cases", "profile", "trajectories", "experiences"},
strict_extract_errors=True,
)
if apply_error:
with pytest.raises(MemoryUpdateError):
await extraction
assert trained_cases == []
return
contexts = await extraction
assert len(applied_operations) == 1
assert applied_operations[0].upsert_operations[0].memory_type == "cases"
assert [case.name for case in trained_cases] == ["重复预订处理"]
assert contexts[0].uri.endswith("重复预订处理.md")
@pytest.mark.asyncio
async def test_v3_extract_trains_only_canonical_case_after_patch_merge(monkeypatch):
trained_kwargs = []
canonical_uri = "viking://user/u/memories/cases/duplicate_booking.md"
loser_uri = "viking://user/u/memories/cases/duplicate_booking_duplicate.md"
canonical_fields = {
"case_name": "duplicate_booking",
"task_signature": "Handle duplicate bookings safely.",
"input": '{"summary":"cancel only the confirmed duplicate booking"}',
"rubric": (
'{"name":"duplicate_booking_rubric","description":"Verify duplicate handling",'
'"criteria":[{"name":"verify_duplicate","description":"The assistant verifies '
'which booking is duplicate before cancellation.","required":true,"weight":1.0}]}'
),
"evidence": "Canonical merged case evidence.",
}
def case_op(uri: str, name: str) -> ResolvedOperation:
fields = dict(canonical_fields)
fields["case_name"] = name
return ResolvedOperation(
old_memory_file_content=None,
memory_type="cases",
uris=[uri],
memory_fields=fields,
)
class DummyRegistry:
async def initialize_memory_files(self, ctx, allowed_memory_types=None):
del ctx, allowed_memory_types
return None
class DummyOrchestrator:
async def run(self):
return (
ResolvedOperations(
upsert_operations=[
case_op(canonical_uri, "duplicate_booking"),
case_op(loser_uri, "duplicate_booking_duplicate"),
],
delete_file_contents=[],
errors=[],
),
[],
)
class FakeFS:
async def read_file(self, uri, ctx=None):
del ctx
if uri != canonical_uri:
raise FileNotFoundError(uri)
return MemoryFileUtils.write(
MemoryFile(
uri=canonical_uri,
content="",
memory_type="cases",
extra_fields=dict(canonical_fields),
)
)
async def write_file(self, uri, content, ctx=None):
del uri, content, ctx
class FakeStreamingUpdater:
async def submit(self, request):
del request
result = MemoryUpdateResult()
result.add_written(canonical_uri)
return SimpleNamespace(
operations=ResolvedOperations(
upsert_operations=[case_op(canonical_uri, "duplicate_booking")],
delete_file_contents=[],
errors=[],
),
apply_result=result,
)
compressor = SessionCompressorV3(vikingdb=None)
compressor._get_or_create_react = lambda **kwargs: DummyOrchestrator()
async def fake_train_from_extracted_cases(**kwargs):
trained_kwargs.append(kwargs)
return {"case_count": len(kwargs["cases"]), "submitted": len(kwargs["cases"])}
compressor.train_from_extracted_cases = fake_train_from_extracted_cases
monkeypatch.setattr("openviking.session.compressor_v3.get_viking_fs", lambda: FakeFS())
monkeypatch.setattr(
"openviking.session.compressor_v3.get_default_registry",
lambda: DummyRegistry(),
)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_streaming_memory_updater",
AsyncMock(return_value=FakeStreamingUpdater()),
)
contexts = await compressor.extract_long_term_memories(
messages=_messages(),
ctx=_ctx(),
allowed_memory_types={"cases", "profile", "trajectories", "experiences"},
)
assert [context.uri for context in contexts] == [canonical_uri]
assert len(trained_kwargs) == 1
assert [case.name for case in trained_kwargs[0]["cases"]] == ["duplicate_booking"]
assert trained_kwargs[0]["cases"][0].metadata["case_uris"] == [canonical_uri]
assert trained_kwargs[0]["case_uri_by_name"] == {"duplicate_booking": canonical_uri}
def _training_case() -> Case:
return Case(
name="duplicate_booking",
task_signature="Handle duplicate bookings safely.",
input={"summary": "cancel only the duplicate booking", "task_id": "task-1"},
rubric=Rubric(
name="duplicate_booking_rubric",
description="Verify duplicates before cancellation.",
criteria=[
RubricCriterion(
name="verify_duplicate",
description="The assistant verifies which booking is the duplicate before acting.",
required=True,
weight=1.0,
)
],
),
metadata={"evidence": "The rollout contains duplicate-booking handling evidence."},
)
def _case_spec_message(case: Case | None = None) -> Message:
rollout = Rollout(
case=case or _training_case(),
messages=[],
policy_snapshot_id="snapshot-1",
)
request = _case_spec_message_to_request(rollout)
return Message(
id="case-spec",
role="system",
parts=[TextPart(text=request["parts"][0]["text"])],
)
@pytest.mark.asyncio
async def test_v3_training_case_spec_fast_path_skips_user_memory_extraction_and_strips_control_message():
case_spec = _case_spec_message()
rollout_messages = _messages()
written = []
trained = []
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
async def fail_extract_user_memories(**kwargs):
raise AssertionError("fast path must not run LLM user-memory extraction")
async def fake_write_training_case_memory(**kwargs):
written.append(kwargs["case"])
result = MemoryUpdateResult()
result.add_written("viking://user/u/memories/cases/duplicate_booking.md")
return result
async def fake_train_from_extracted_cases(**kwargs):
trained.append(kwargs)
return {"case_count": len(kwargs["cases"]), "submitted": len(kwargs["cases"])}
compressor._extract_user_memories = fail_extract_user_memories
compressor._write_training_case_memory = fake_write_training_case_memory
compressor.train_from_extracted_cases = fake_train_from_extracted_cases
compressor._write_final_memory_diff = AsyncMock()
contexts = await compressor.extract_long_term_memories(
messages=[case_spec, *rollout_messages],
ctx=_ctx(),
session_id="s1",
archive_uri="viking://user/u/sessions/s1/history/archive_001",
allowed_memory_types={"cases", "trajectories", "experiences"},
)
assert [case.name for case in written] == ["duplicate_booking"]
assert [case.name for case in trained[0]["cases"]] == ["duplicate_booking"]
assert trained[0]["messages"] == rollout_messages
assert contexts[0].uri == "viking://user/u/memories/cases/duplicate_booking.md"
@pytest.mark.asyncio
async def test_v3_training_case_spec_does_not_write_case_when_evolution_disabled():
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
compressor._extract_user_memories = AsyncMock(
return_value=SimpleNamespace(
contexts=[],
cases=[],
memory_diff=None,
case_uri_by_name={},
)
)
compressor._write_training_case_memory = AsyncMock()
compressor.train_from_extracted_cases = AsyncMock()
compressor._write_final_memory_diff = AsyncMock()
contexts = await compressor.extract_long_term_memories(
messages=[_case_spec_message(), *_messages()],
ctx=_ctx(),
session_id="s1",
archive_uri="viking://user/u/sessions/s1/history/archive_001",
allowed_memory_types={"cases", "trajectories", "experiences"},
agent_evolution_enabled=False,
)
assert contexts == []
compressor._write_training_case_memory.assert_not_awaited()
compressor.train_from_extracted_cases.assert_not_awaited()
assert compressor._extract_user_memories.await_args.kwargs["allowed_memory_types"] == set()
@pytest.mark.asyncio
async def test_v3_training_case_spec_fast_path_not_used_with_user_memory_policy():
extracted = False
trained = []
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
async def fake_extract_user_memories(**kwargs):
nonlocal extracted
extracted = True
return SimpleNamespace(contexts=[], cases=[])
async def fake_train_from_extracted_cases(**kwargs):
trained.append(kwargs)
return {"case_count": 0, "submitted": 0}
compressor._extract_user_memories = fake_extract_user_memories
compressor.train_from_extracted_cases = fake_train_from_extracted_cases
contexts = await compressor.extract_long_term_memories(
messages=[_case_spec_message(), *_messages()],
ctx=_ctx(),
allowed_memory_types={"cases", "profile"},
)
assert contexts == []
assert extracted is True
assert trained == []
@pytest.mark.asyncio
async def test_v3_training_case_spec_fast_path_rejects_invalid_protocol():
message = _case_spec_message()
assert isinstance(message.parts[0], TextPart)
message.parts[0].text = message.parts[0].text.replace(
"openviking.batch_train.case_spec.v1",
"openviking.batch_train.case_spec.v0",
)
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
with pytest.raises(ValueError, match="protocol mismatch"):
await compressor.extract_long_term_memories(
messages=[message, *_messages()],
ctx=_ctx(),
allowed_memory_types={"cases", "trajectories", "experiences"},
)
def test_training_case_spec_message_uses_fast_path_protocol():
message = _case_spec_message()
part = message.parts[0]
assert isinstance(part, TextPart)
text = part.text
assert text.startswith("# OpenViking Batch Training CaseSpec v1")
assert "openviking.batch_train.case_spec.v1" in text
assert "duplicate_booking_rubric" in text
def test_training_case_spec_message_uses_original_case_name_for_trials():
case = _training_case()
case.name = "tau2_airline_train_1_t0"
case.task_signature = "tau2:airline:train:1:trial:0"
case.input.update(
{
"domain": "airline",
"split": "train",
"data_split": "airline_train",
"task_id": "1",
"task_no": 1,
"train_trial": 0,
"original_case_name": "tau2_airline_train_1",
}
)
message = _case_spec_message(case)
payload = __import__(
"openviking.session.compressor_v3", fromlist=["_training_case_spec_payload_from_message"]
)._training_case_spec_payload_from_message(message)
assert payload["case"]["name"] == "tau2_airline_train_1"
assert payload["case"]["task_signature"] == "tau2:airline:train:1"
assert payload["case"]["metadata"]["rollout_case_name"] == "tau2_airline_train_1_t0"
@pytest.mark.asyncio
async def test_v3_fast_path_writes_final_memory_diff_with_case_traj_and_exp(monkeypatch):
archive_uri = "viking://user/u/sessions/s1/history/archive_001"
writes: dict[str, str] = {}
class FakeFS:
async def write_file(self, uri, content, ctx=None):
del ctx
writes[uri] = content
async def read_file(self, uri, ctx=None):
del ctx
if uri.endswith("/cases/duplicate_booking.md"):
return "# duplicate_booking\n\n<!-- MEMORY_FIELDS\n{}\n-->"
if uri.endswith("/experiences/booking_duplicate_handling.md"):
return "new exp content\n\n<!-- MEMORY_FIELDS\n{}\n-->"
raise FileNotFoundError(uri)
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
async def fake_write_training_case_memory(**kwargs):
result = MemoryUpdateResult()
result.add_written("viking://user/u/memories/cases/duplicate_booking.md")
return SimpleNamespace(
result=result,
memory_diff={
"archive_uri": archive_uri,
"trace_id": None,
"extracted_at": "now",
"operations": {
"adds": [
{
"uri": "viking://user/u/memories/cases/duplicate_booking.md",
"memory_type": "cases",
"after": "# duplicate_booking",
}
],
"updates": [],
"deletes": [],
},
"skipped_operations": [
{
"memory_type": "preferences",
"page_id": 102,
"reason_code": "peer_not_allowed",
"reason": "Target peer is outside the allowed memory scope",
}
],
"summary": {
"total_adds": 1,
"total_updates": 0,
"total_deletes": 0,
"total_skipped": 1,
},
},
)
async def fake_train_from_extracted_cases(**kwargs):
return {
"case_count": 1,
"submitted": 1,
"memory_diff": {
"archive_uri": archive_uri,
"trace_id": None,
"extracted_at": "now",
"operations": {
"adds": [
{
"uri": "viking://user/u/memories/trajectories/duplicate_booking.md",
"memory_type": "trajectories",
"after": "trajectory content",
}
],
"updates": [
{
"uri": "viking://user/u/memories/experiences/booking_duplicate_handling.md",
"memory_type": "experiences",
"before": "old exp content",
"after": "new exp content",
}
],
"deletes": [],
},
"summary": {"total_adds": 1, "total_updates": 1, "total_deletes": 0},
},
}
compressor._write_training_case_memory = fake_write_training_case_memory
compressor.train_from_extracted_cases = fake_train_from_extracted_cases
monkeypatch.setattr("openviking.session.compressor_v3.get_viking_fs", lambda: FakeFS())
contexts = await compressor.extract_long_term_memories(
messages=[_case_spec_message(), *_messages()],
ctx=_ctx(),
session_id="s1",
archive_uri=archive_uri,
allowed_memory_types={"cases", "trajectories", "experiences"},
)
assert contexts[0].uri.endswith("/cases/duplicate_booking.md")
diff = __import__("json").loads(writes[f"{archive_uri}/memory_diff.json"])
assert [item["memory_type"] for item in diff["operations"]["adds"]] == [
"cases",
"trajectories",
]
assert [item["memory_type"] for item in diff["operations"]["updates"]] == ["experiences"]
assert diff["skipped_operations"] == [
{
"memory_type": "preferences",
"page_id": 102,
"reason_code": "peer_not_allowed",
"reason": "Target peer is outside the allowed memory scope",
}
]
assert diff["summary"] == {
"total_adds": 2,
"total_updates": 1,
"total_deletes": 0,
"total_skipped": 1,
}
@pytest.mark.asyncio
async def test_v3_builds_training_memory_diff_from_streaming_result(monkeypatch):
archive_uri = "viking://user/u/sessions/s1/history/archive_001"
class FakeFS:
async def read_file(self, uri, ctx=None):
del ctx
assert uri.endswith("/experiences/booking_duplicate_handling.md")
return "new exp content\n\n<!-- MEMORY_FIELDS\n{}\n-->"
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
plan = PolicyUpdatePlan(
items=[
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="booking_duplicate_handling",
target_uri="viking://user/u/memories/experiences/booking_duplicate_handling.md",
before_content="old exp content",
after_content="new exp content fallback",
links=[
StoredLink(
from_uri="viking://user/u/memories/experiences/booking_duplicate_handling.md",
to_uri="viking://user/u/memories/trajectories/duplicate_booking.md",
link_type="derived_from",
weight=1.0,
)
],
)
]
)
training_result = RolloutTrainingResult(
analyses=[
RolloutAnalysis(
evaluation=RubricEvaluation(
passed=True,
score=1.0,
criterion_results=[],
feedback=[],
),
trajectories=[
Trajectory(
name="duplicate_booking",
uri="viking://user/u/memories/trajectories/duplicate_booking.md",
content="trajectory content",
outcome="success",
retrieval_anchor="Stage: final",
)
],
)
],
gradients=[],
plan=plan,
apply_result=PolicyApplyResult(
updated_policy_set=ExperienceSet(
root_uri="viking://user/u/memories/experiences",
policies=[],
),
written_uris=["viking://user/u/memories/experiences/booking_duplicate_handling.md"],
),
)
diff = await compressor._build_training_memory_diff(
training_result=training_result,
viking_fs=FakeFS(),
ctx=_ctx(),
archive_uri=archive_uri,
)
assert diff["summary"] == {
"total_adds": 1,
"total_updates": 1,
"total_deletes": 0,
"total_skipped": 0,
}
assert diff["operations"]["adds"][0]["memory_type"] == "trajectories"
update = diff["operations"]["updates"][0]
assert update["memory_type"] == "experiences"
assert update["before"] == "old exp content"
assert update["after"] == "new exp content"
@pytest.mark.asyncio
async def test_v3_training_memory_diff_filters_batch_items_by_current_analysis_trajectory(
monkeypatch,
):
archive_uri = "viking://user/u/sessions/s1/history/archive_001"
traj_a = "viking://user/u/memories/trajectories/traj_a.md"
traj_b = "viking://user/u/memories/trajectories/traj_b.md"
exp_a = "viking://user/u/memories/experiences/exp_a.md"
exp_b = "viking://user/u/memories/experiences/exp_b.md"
class FakeFS:
async def read_file(self, uri, ctx=None):
del ctx
return {
exp_a: "exp a\n\n<!-- MEMORY_FIELDS\n{}\n-->",
exp_b: "exp b\n\n<!-- MEMORY_FIELDS\n{}\n-->",
}[uri]
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=SimpleNamespace())
training_result = RolloutTrainingResult(
analyses=[
RolloutAnalysis(
evaluation=RubricEvaluation(
passed=True, score=1.0, criterion_results=[], feedback=[]
),
trajectories=[
Trajectory(
name="traj_a",
uri=traj_a,
content="trajectory a",
outcome="success",
retrieval_anchor="",
)
],
)
],
gradients=[],
plan=PolicyUpdatePlan(
items=[
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="exp_a",
target_uri=exp_a,
before_content=None,
after_content="exp a fallback",
links=[
StoredLink(
from_uri=exp_a,
to_uri=traj_a,
link_type="derived_from",
weight=1.0,
)
],
),
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="exp_b",
target_uri=exp_b,
before_content=None,
after_content="exp b fallback",
links=[
StoredLink(
from_uri=exp_b,
to_uri=traj_b,
link_type="derived_from",
weight=1.0,
)
],
),
]
),
apply_result=PolicyApplyResult(
updated_policy_set=ExperienceSet(
root_uri="viking://user/u/memories/experiences",
policies=[],
),
written_uris=[exp_a, exp_b],
),
)
diff = await compressor._build_training_memory_diff(
training_result=training_result,
viking_fs=FakeFS(),
ctx=_ctx(),
archive_uri=archive_uri,
)
assert diff["summary"] == {
"total_adds": 2,
"total_updates": 0,
"total_deletes": 0,
"total_skipped": 0,
}
assert [op["uri"] for op in diff["operations"]["adds"]] == [traj_a, exp_a]
def test_v3_maps_each_written_experience_to_its_source_trajectories():
traj_a = "viking://user/u/memories/trajectories/traj_a.md"
traj_b = "viking://user/u/memories/trajectories/traj_b.md"
exp_a = "viking://user/u/memories/experiences/exp_a.md"
exp_b = "viking://user/u/memories/experiences/exp_b.md"
plan = PolicyUpdatePlan(
items=[
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="exp_a",
target_uri=exp_a,
before_content=None,
after_content="exp a",
links=[
StoredLink(
from_uri=exp_a,
to_uri=traj_a,
link_type="derived_from",
weight=1.0,
)
],
),
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="exp_b",
target_uri=exp_b,
before_content=None,
after_content="exp b",
links=[
StoredLink(
from_uri=exp_b,
to_uri=traj_b,
link_type="derived_from",
weight=1.0,
)
],
),
]
)
apply_result = PolicyApplyResult(
updated_policy_set=ExperienceSet(
root_uri="viking://user/u/memories/experiences",
policies=[],
),
written_uris=[exp_a, exp_b],
)
assert _experience_trajectory_map(
plan=plan,
apply_result=apply_result,
trajectory_uris={traj_a, traj_b},
) == {
exp_a: [traj_a],
exp_b: [traj_b],
}
def test_v3_snapshot_provenance_uses_complete_shared_batch_result():
traj_a = "viking://user/u/memories/trajectories/traj_a.md"
traj_b = "viking://user/u/memories/trajectories/traj_b.md"
exp_a = "viking://user/u/memories/experiences/exp_a.md"
exp_b = "viking://user/u/memories/experiences/exp_b.md"
def plan_item(experience_uri: str, trajectory_uri: str) -> PolicyPlanItem:
return PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name=experience_uri.rsplit("/", 1)[-1].removesuffix(".md"),
target_uri=experience_uri,
before_content=None,
after_content="updated",
links=[
StoredLink(
from_uri=experience_uri,
to_uri=trajectory_uri,
link_type="derived_from",
weight=1.0,
)
],
)
root = "viking://user/u/memories/experiences"
batch_result = SimpleNamespace(
analyses=[
SimpleNamespace(trajectories=[SimpleNamespace(uri=traj_a)]),
SimpleNamespace(trajectories=[SimpleNamespace(uri=traj_b)]),
],
plan=PolicyUpdatePlan(items=[plan_item(exp_a, traj_a), plan_item(exp_b, traj_b)]),
apply_result=PolicyApplyResult(
updated_policy_set=ExperienceSet(root_uri=root, policies=[]),
written_uris=[exp_a, exp_b],
),
)
scoped_result = SimpleNamespace(
analyses=[batch_result.analyses[0]],
plan=PolicyUpdatePlan(items=[batch_result.plan.items[0]]),
apply_result=PolicyApplyResult(
updated_policy_set=ExperienceSet(root_uri=root, policies=[]),
written_uris=[exp_a],
),
batch_result=batch_result,
)
apply_result, trajectory_map = _experience_snapshot_provenance(scoped_result)
assert apply_result is batch_result.apply_result
assert trajectory_map == {
exp_a: [traj_a],
exp_b: [traj_b],
}
def test_visible_experience_snapshot_uris_only_returns_applied_body_changes():
root = "viking://user/u/memories/experiences"
changed_uri = f"{root}/changed.md"
metadata_only_uri = f"{root}/metadata_only.md"
failed_uri = f"{root}/failed.md"
deleted_uri = f"{root}/deleted.md"
content_write_uri = f"{root}/content_write.md"
plan = PolicyUpdatePlan(
items=[
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="changed",
target_uri=changed_uri,
before_content="before",
after_content="after",
),
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="metadata_only",
target_uri=metadata_only_uri,
before_content="unchanged",
after_content="unchanged",
),
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="failed",
target_uri=failed_uri,
before_content="before",
after_content="after",
),
PolicyPlanItem(
kind="delete",
memory_type="experiences",
target_name="deleted",
target_uri=deleted_uri,
before_content="old content",
after_content=None,
),
]
)
apply_result = PolicyApplyResult(
updated_policy_set=ExperienceSet(root_uri=root, policies=[]),
written_uris=[changed_uri, metadata_only_uri, content_write_uri],
deleted_uris=[deleted_uri],
)
assert _visible_experience_snapshot_uris(
plan=plan,
apply_result=apply_result,
) == [changed_uri, deleted_uri]
@pytest.mark.asyncio
async def test_commit_experience_snapshot_skips_when_no_visible_content_changed():
viking_fs = SimpleNamespace(commit=AsyncMock())
await _commit_experience_snapshot(
viking_fs,
ctx=_ctx(),
experience_uris=[],
archive_uri="viking://user/u/sessions/session-1/history/archive_001",
)
viking_fs.commit.assert_not_awaited()
@pytest.mark.asyncio
async def test_v3_training_links_case_to_trajectory_and_experience_via_trajectory(monkeypatch):
case_uri = "viking://user/u/memories/cases/duplicate_booking.md"
traj_uri = "viking://user/u/memories/trajectories/duplicate_booking.md"
exp_uri = "viking://user/u/memories/experiences/booking_duplicate_handling.md"
deleted_exp_uri = "viking://user/u/memories/experiences/legacy_booking_handling.md"
class FakeFS:
def __init__(self):
self.commits = []
self.files = {
case_uri: MemoryFileUtils.write(
MemoryFile(
uri=case_uri,
content="# duplicate_booking",
memory_type="cases",
extra_fields={"memory_type": "cases", "case_name": "duplicate_booking"},
),
content_template=(
"# {{ case_name }}\n\n"
"## Linked Experiences\n"
"{% for link in links or [] %}"
"{% set target_uri = link.to_uri or '' %}"
"{% if '/memories/experiences/' in target_uri %}"
"- [{{ uri_basename(target_uri) }}]({{ link_target(target_uri) }})\n"
"{% endif %}"
"{% endfor %}"
),
),
traj_uri: MemoryFileUtils.write(
MemoryFile(
uri=traj_uri,
content="trajectory content",
memory_type="trajectories",
extra_fields={
"memory_type": "trajectories",
"trajectory_name": "duplicate_booking",
},
backlinks=[
StoredLink(
from_uri=exp_uri,
to_uri=traj_uri,
link_type="derived_from",
weight=1.0,
match_text=None,
description="",
).model_dump()
],
)
),
exp_uri: MemoryFileUtils.write(
MemoryFile(
uri=exp_uri,
content="old exp content",
memory_type="experiences",
extra_fields={
"memory_type": "experiences",
"experience_name": "booking_duplicate_handling",
},
)
),
}
async def read_file(self, uri, ctx=None):
del ctx
return self.files[uri]
async def write_file(self, uri, content, ctx=None, lease_ref=None):
del ctx, lease_ref
self.files[uri] = content
async def ls(self, uri, output="original", ctx=None):
del uri, output, ctx
return []
async def commit(self, **kwargs):
self.commits.append(kwargs)
class FakeTrainer:
policy_set = ExperienceSet(root_uri="viking://user/u/memories/experiences", policies=[])
async def submit_gradients(
self,
gradients,
*,
analysis=None,
rollout=None,
batch_finalizer=None,
):
del gradients, analysis, rollout
plan = PolicyUpdatePlan(
items=[
PolicyPlanItem(
kind="upsert",
memory_type="experiences",
target_name="booking_duplicate_handling",
target_uri=exp_uri,
before_content="old exp content",
after_content="new exp content",
links=[
StoredLink(
from_uri=exp_uri,
to_uri=traj_uri,
link_type="derived_from",
weight=1.0,
match_text=None,
description="",
)
],
),
PolicyPlanItem(
kind="delete",
memory_type="experiences",
target_name="legacy_booking_handling",
target_uri=deleted_exp_uri,
before_content="legacy exp content",
after_content=None,
),
]
)
result = RolloutTrainingResult(
analyses=[],
gradients=[],
plan=plan,
apply_result=PolicyApplyResult(
updated_policy_set=ExperienceSet(
root_uri="viking://user/u/memories/experiences",
policies=[],
),
written_uris=[exp_uri],
deleted_uris=[deleted_exp_uri],
errors=[],
),
metadata={},
)
if batch_finalizer is not None:
await batch_finalizer(result)
return result
class FakeAnalyzer:
async def analyze(self, rollout, context):
del rollout, context
return RolloutAnalysis(
evaluation=RubricEvaluation(
passed=True, score=1.0, criterion_results=[], feedback=[]
),
trajectories=[
Trajectory(
name="duplicate_booking",
uri=traj_uri,
content="trajectory content",
outcome="success",
retrieval_anchor="",
)
],
gradients=[],
)
async def fake_estimate_exp_gradients(self, *args, **kwargs):
from openviking.session.train import PatchSemanticGradient
return [
PatchSemanticGradient(
before_file=None,
after_file=MemoryFile(
uri=exp_uri,
content="new exp content",
memory_type="experiences",
extra_fields={"experience_name": "booking_duplicate_handling"},
),
base_version=1,
rationale="test",
links=[],
confidence=0.9,
metadata={},
)
]
fs = FakeFS()
monkeypatch.setattr("openviking.session.compressor_v3.get_viking_fs", lambda: fs)
monkeypatch.setattr(
"openviking.session.compressor_v3.get_streaming_policy_trainer",
AsyncMock(return_value=FakeTrainer()),
)
monkeypatch.setattr(
"openviking.session.train.components.gradient_estimator.ExperienceGradientEstimator.estimate",
fake_estimate_exp_gradients,
)
compressor = SessionCompressorV3(vikingdb=None, rollout_analyzer=FakeAnalyzer())
result = await compressor.train_from_extracted_cases(
cases=[_training_case()],
case_uri_by_name={"duplicate_booking": case_uri},
messages=_messages(),
ctx=_ctx(),
session_id="session-1",
archive_uri="viking://user/u/sessions/session-1/history/archive_001",
)
assert result["submitted"] == 1
case_file = MemoryFileUtils.read(fs.files[case_uri], uri=case_uri)
assert any(
link["to_uri"] == traj_uri
and link["link_type"] == "related_to"
and link.get("match_text") is None
and link.get("description") == ""
for link in case_file.links
)
assert any(
link["to_uri"] == exp_uri
and link["link_type"] == "related_to"
and link.get("match_text") is None
and link.get("description") == ""
for link in case_file.links
)
linked_experiences_section = (
fs.files[case_uri].split("## Linked Experiences", 1)[1].split("<!-- MEMORY_FIELDS", 1)[0]
)
assert (
"[booking_duplicate_handling](../experiences/booking_duplicate_handling.md)"
in linked_experiences_section
)
assert "duplicate_booking.md" not in linked_experiences_section
traj_file = MemoryFileUtils.read(fs.files[traj_uri], uri=traj_uri)
assert any(link["from_uri"] == case_uri for link in traj_file.backlinks)
exp_file = MemoryFileUtils.read(fs.files[exp_uri], uri=exp_uri)
assert any(link["from_uri"] == case_uri for link in exp_file.backlinks)
assert fs.commits == [
{
"message": (
"Update experience memories from session commit "
"viking://user/u/sessions/session-1/history/archive_001\n"
"OpenViking-Experience-Trajectory-Map: "
'{"viking://user/u/memories/experiences/booking_duplicate_handling.md":'
'["viking://user/u/memories/trajectories/duplicate_booking.md"]}'
),
"paths": [exp_uri, deleted_exp_uri],
"ctx": _ctx(),
}
]