Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

fix(session): avoid duplicate trajectory extraction across cases (#6273)

DuTao3ef6c5f7f6ff
diff --git a/openviking/prompts/templates/memory/trajectories.yaml b/openviking/prompts/templates/memory/trajectories.yaml
index d912beab1..cb2ba82cf 100644
--- a/openviking/prompts/templates/memory/trajectories.yaml
+++ b/openviking/prompts/templates/memory/trajectories.yaml
@@ -35,6 +35,16 @@ fields:
Use exactly one of: success, failure, partial, unfinished, unknown.
merge_op: immutable
+ - name: related_case_ids
+ type: string_list
+ description: |
+ When Candidate Cases are provided, return the IDs of the cases supported by this trajectory in the same extraction response.
+ Use only IDs from Candidate Cases; multiple IDs are allowed. Return [] when none match.
+ Use the candidate task descriptions only for association. Derive the trajectory from the archived conversation, never invent actions to match a case.
+ Do not link every case merely because they share an archive.
+ When Candidate Cases are absent, return [] without choosing cases; the system handles single-case association.
+ merge_op: immutable
+
- name: task_query
type: string
description: |
diff --git a/openviking/session/compressor_v3.py b/openviking/session/compressor_v3.py
index 698f8c200..cb0e89fbb 100644
--- a/openviking/session/compressor_v3.py
+++ b/openviking/session/compressor_v3.py
@@ -14,7 +14,7 @@ from __future__ import annotations
import json
import re
-from dataclasses import dataclass, field
+from dataclasses import asdict, dataclass, field, replace
from datetime import datetime, timezone
from typing import TYPE_CHECKING, Any, List, Optional
from uuid import uuid4
@@ -86,6 +86,7 @@ from openviking.session.train import (
get_streaming_policy_trainer,
make_streaming_policy_trainer_key,
)
+from openviking.session.train.components.trajectory_analyzer import _evaluation_feedback_message
from openviking.storage.viking_fs import get_viking_fs
from openviking.telemetry import get_current_telemetry, tracer
from openviking_cli.utils import get_logger
@@ -1043,77 +1044,117 @@ class SessionCompressorV3:
)
case_uri_map = dict(case_uri_by_name or {})
-
+ evaluator = getattr(self.rollout_analyzer, "evaluator", None)
+ extraction_groups: dict[str, list[Rollout]] = {}
+ candidates_by_name = {
+ case.name: {
+ "id": f"c{index + 1}",
+ "name": case.name,
+ "task_signature": case.task_signature,
+ "input": case.input,
+ "uri": _case_uri_for_case(case, case_uri_map),
+ }
+ for index, case in enumerate(cases)
+ }
for case in cases:
- case_uri = _case_uri_for_case(case, case_uri_map)
rollout = Rollout(
case=case,
messages=list(messages),
policy_snapshot_id=policy_snapshot_id,
)
- # Analyze once — trajectories + skill patches co-extracted
- analysis = await self.rollout_analyzer.analyze(rollout, analysis_context)
-
- # Experience path: estimate gradients, then submit to exp trainer
- exp_gradients = []
- if experiences_allowed:
- exp_gradients = await ExperienceGradientEstimator(
- viking_fs=viking_fs,
- vlm_resolver=self.vlm_resolver,
- ).estimate(analysis, exp_trainer.policy_set, gradient_context)
- exp_training_result = _trajectory_only_training_result(
- analysis=analysis,
- rollout=rollout,
- policy_set=exp_trainer.policy_set,
- )
- if exp_gradients:
- fallback_trajectory_uris = {
- uri
- for trajectory in analysis.trajectories
- if (uri := str(getattr(trajectory, "uri", "") or ""))
- }
-
- async def commit_experience_batch(
- batch_result: RolloutTrainingResult,
- *,
- _fallback_trajectory_uris: set[str] = fallback_trajectory_uris,
- ) -> None:
- persisted_result = (
- getattr(batch_result, "batch_result", None) or batch_result
- )
- snapshot_apply_result, experience_trajectory_map = (
- _experience_snapshot_provenance(
- batch_result,
- fallback_trajectory_uris=_fallback_trajectory_uris,
- )
- )
- await _commit_experience_snapshot(
- viking_fs,
- ctx=ctx,
- experience_uris=_visible_experience_snapshot_uris(
- plan=persisted_result.plan,
- apply_result=snapshot_apply_result,
+ if evaluator is not None:
+ rollout.evaluation = await evaluator.evaluate(
+ rollout, analysis_context.evaluator_context
+ )
+ feedback = ""
+ if rollout.evaluation is not None and analysis_context.inject_evaluation_feedback:
+ feedback = _evaluation_feedback_message(rollout.evaluation).content
+ extraction_groups.setdefault(feedback, []).append(rollout)
+
+ reported_trajectory_uris: set[str] = set()
+ for rollouts in extraction_groups.values():
+ rollout = rollouts[0]
+ candidates = [candidates_by_name[item.case.name] for item in rollouts]
+ case_context = replace(analysis_context, case_candidates=candidates)
+ analysis = await self.rollout_analyzer.analyze(rollout, case_context)
+ analysis.metadata["case_associations_required"] = len(candidates) > 1
+ if collect_memory_diff:
+ # Keep every extracted trajectory, including those with no matching case.
+ memory_diffs.append(
+ await self._build_training_memory_diff(
+ training_result=_trajectory_only_training_result(
+ analysis=analysis,
+ rollout=rollout,
+ policy_set=exp_trainer.policy_set,
),
+ viking_fs=viking_fs,
+ ctx=ctx,
archive_uri=archive_uri,
- experience_trajectory_map=experience_trajectory_map,
+ reported_trajectory_uris=reported_trajectory_uris,
)
+ )
- exp_training_result = await exp_trainer.submit_gradients(
- exp_gradients,
- analysis=analysis,
- rollout=rollout,
- batch_finalizer=commit_experience_batch,
+ # Sharing extraction does not discard case-specific scores used by training.
+ training_groups: dict[str, list[Rollout]] = {}
+ for item in rollouts:
+ evaluation_key = json.dumps(
+ asdict(item.evaluation) if item.evaluation is not None else None,
+ sort_keys=True,
+ default=str,
)
- if case_uri:
- await self._link_case_to_training_outputs(
- analysis=analysis,
- case_uri=case_uri,
- plan=exp_training_result.plan,
- apply_result=exp_training_result.apply_result,
- ctx=ctx,
+ training_groups.setdefault(evaluation_key, []).append(item)
+
+ for training_rollouts in training_groups.values():
+ training_rollout = training_rollouts[0]
+ trajectories = analysis.trajectories
+ if len(training_rollouts) < len(rollouts):
+ case_uris = {
+ candidates_by_name[item.case.name]["uri"] for item in training_rollouts
+ }
+ trajectories = [
+ trajectory
+ for trajectory in trajectories
+ if case_uris.intersection(trajectory.metadata.get("case_uris", []))
+ ]
+ training_analysis = replace(
+ analysis,
+ evaluation=training_rollout.evaluation or analysis.evaluation,
+ trajectories=trajectories,
+ )
+ exp_training_result = await self._train_commit_analysis(
+ analysis=training_analysis,
+ rollout=training_rollout,
+ trainer=exp_trainer,
+ gradient_context=gradient_context,
+ experiences_allowed=experiences_allowed,
viking_fs=viking_fs,
+ ctx=ctx,
+ archive_uri=archive_uri,
)
- # Skill path: co-extracted skill gradients go directly to skill trainer
+ for item in training_rollouts:
+ case_uri = candidates_by_name[item.case.name]["uri"]
+ if case_uri:
+ await self._link_case_to_training_outputs(
+ analysis=training_analysis,
+ case_uri=case_uri,
+ plan=exp_training_result.plan,
+ apply_result=exp_training_result.apply_result,
+ ctx=ctx,
+ viking_fs=viking_fs,
+ )
+ submitted += len(training_rollouts)
+ if collect_memory_diff:
+ memory_diff = await self._build_training_memory_diff(
+ training_result=exp_training_result,
+ viking_fs=viking_fs,
+ ctx=ctx,
+ archive_uri=archive_uri,
+ reported_trajectory_uris=reported_trajectory_uris,
+ )
+ if _memory_diff_has_changes(memory_diff):
+ memory_diffs.append(memory_diff)
+
+ # Co-extracted skills are submitted once for this extraction result.
if skill_trainer is not None and analysis.gradients:
skill_gradients = [
g for g in analysis.gradients if _gradient_memory_type(g) == "skills"
@@ -1131,25 +1172,10 @@ class SessionCompressorV3:
if uri:
skill_uris.append(str(uri))
- submitted += 1
-
- if collect_memory_diff:
- # Build diff from the strongly typed training result returned by
- # submit_gradients. Do not use exp_trainer.last_apply_result here:
- # it is only a PolicyApplyResult and does not carry analyses/plan,
- # so trajectory and experience diffs would be lost.
- memory_diff = await self._build_training_memory_diff(
- training_result=exp_training_result,
- viking_fs=viking_fs,
- ctx=ctx,
- archive_uri=archive_uri,
- )
- if _memory_diff_has_changes(memory_diff):
- memory_diffs.append(memory_diff)
-
tracer.info(
"Submitted commit case memories to streaming train: "
f"case_count={len(cases)} submitted={submitted} "
+ f"analysis_count={len(extraction_groups)} "
f"skill_submitted={skill_submitted}",
console=self.streaming_trainer_config.trace_console,
)
@@ -1172,6 +1198,55 @@ class SessionCompressorV3:
raise
return {"case_count": len(cases), "submitted": 0, "error": str(exc)}
+ async def _train_commit_analysis(
+ self,
+ *,
+ analysis: RolloutAnalysis,
+ rollout: Rollout,
+ trainer: Any,
+ gradient_context: ExperienceGradientContext,
+ experiences_allowed: bool,
+ viking_fs: Any,
+ ctx: RequestContext,
+ archive_uri: str,
+ ) -> RolloutTrainingResult:
+ gradients = []
+ if experiences_allowed:
+ gradients = await ExperienceGradientEstimator(
+ viking_fs=viking_fs,
+ vlm_resolver=self.vlm_resolver,
+ ).estimate(analysis, trainer.policy_set, gradient_context)
+ if not gradients:
+ return _trajectory_only_training_result(
+ analysis=analysis,
+ rollout=rollout,
+ policy_set=trainer.policy_set,
+ )
+
+ async def commit_experience_batch(batch_result: RolloutTrainingResult) -> None:
+ persisted_result = getattr(batch_result, "batch_result", None) or batch_result
+ snapshot_apply_result, experience_trajectory_map = _experience_snapshot_provenance(
+ batch_result,
+ fallback_trajectory_uris={trajectory.uri for trajectory in analysis.trajectories},
+ )
+ await _commit_experience_snapshot(
+ viking_fs,
+ ctx=ctx,
+ experience_uris=_visible_experience_snapshot_uris(
+ plan=persisted_result.plan,
+ apply_result=snapshot_apply_result,
+ ),
+ archive_uri=archive_uri,
+ experience_trajectory_map=experience_trajectory_map,
+ )
+
+ return await trainer.submit_gradients(
+ gradients,
+ analysis=analysis,
+ rollout=rollout,
+ batch_finalizer=commit_experience_batch,
+ )
+
async def _build_training_memory_diff(
self,
*,
@@ -1179,6 +1254,7 @@ class SessionCompressorV3:
viking_fs: Any,
ctx: RequestContext,
archive_uri: str,
+ reported_trajectory_uris: set[str] | None = None,
) -> dict[str, Any]:
adds: list[dict[str, Any]] = []
updates: list[dict[str, Any]] = []
@@ -1191,6 +1267,10 @@ class SessionCompressorV3:
if not uri or uri in seen_trajectory_uris:
continue
seen_trajectory_uris.add(uri)
+ if reported_trajectory_uris is not None:
+ if uri in reported_trajectory_uris:
+ continue
+ reported_trajectory_uris.add(uri)
adds.append(
{
"uri": uri,
@@ -1845,6 +1925,12 @@ def _case_trajectory_links(
) -> list[StoredLink]:
links: list[StoredLink] = []
for trajectory in getattr(analysis, "trajectories", []) or []:
+ case_uris = trajectory.metadata.get("case_uris")
+ if case_uris is not None:
+ if case_uri not in case_uris:
+ continue
+ elif analysis.metadata.get("case_associations_required"):
+ continue
uri = str(getattr(trajectory, "uri", "") or "")
if not uri or "/memories/trajectories/" not in uri:
continue
diff --git a/openviking/session/memory/agent_trajectory_context_provider.py b/openviking/session/memory/agent_trajectory_context_provider.py
index c60015fed..e73a6d980 100644
--- a/openviking/session/memory/agent_trajectory_context_provider.py
+++ b/openviking/session/memory/agent_trajectory_context_provider.py
@@ -9,6 +9,7 @@ co-extract reusable executable skills in the same ReAct pass.
from __future__ import annotations
+import json
from typing import Any, Dict, List
from openviking.server.identity import RequestContext
@@ -49,11 +50,13 @@ class AgentTrajectoryContextProvider(SessionExtractContextProvider):
*args,
include_trajectories: bool = True,
include_session_skills: bool = False,
+ case_candidates: list[dict[str, Any]] | None = None,
**kwargs,
):
super().__init__(*args, **kwargs)
self._include_trajectories = include_trajectories
self._include_session_skills = include_session_skills
+ self.case_candidates = list(case_candidates or [])
self._skill_provider = SessionSkillContextProvider(*args, **kwargs)
self._sync_skill_provider_state()
@@ -103,9 +106,22 @@ class AgentTrajectoryContextProvider(SessionExtractContextProvider):
if not isinstance(self.messages, list):
logger.warning(f"Expected List[Message], got {type(self.messages)}")
return []
- return [self._build_conversation_message()]
- self._sync_skill_provider_state()
- return await self._skill_provider.prefetch()
+ messages = [self._build_conversation_message()]
+ else:
+ self._sync_skill_provider_state()
+ messages = await self._skill_provider.prefetch()
+ if len(self.case_candidates) > 1:
+ candidates = [
+ {key: case[key] for key in ("id", "name", "task_signature", "input")}
+ for case in self.case_candidates
+ ]
+ messages.append(
+ {
+ "role": "user",
+ "content": "## Candidate Cases\n" + json.dumps(candidates, ensure_ascii=False),
+ }
+ )
+ return messages
async def execute_tool(self, tool_call) -> Any:
if not self._include_session_skills:
diff --git a/openviking/session/memory/extraction_output_protocol/python_protocol.py b/openviking/session/memory/extraction_output_protocol/python_protocol.py
index 0bce203d6..a697c4084 100644
--- a/openviking/session/memory/extraction_output_protocol/python_protocol.py
+++ b/openviking/session/memory/extraction_output_protocol/python_protocol.py
@@ -1576,6 +1576,7 @@ def _field_type_name(field_type: FieldType) -> str:
FieldType.INT64: "int",
FieldType.FLOAT32: "float",
FieldType.BOOL: "bool",
+ FieldType.STRING_LIST: "list[str]",
}.get(field_type, "object")
diff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.py
index 9aac1d6b1..7e629563a 100644
--- a/openviking/session/memory/memory_updater.py
+++ b/openviking/session/memory/memory_updater.py
@@ -221,6 +221,7 @@ class ExtractContext:
*,
split_long_text_messages: bool = True,
source_archive_uri: str = "",
+ extraction_scope: str = "",
):
if chunk_meta is None:
if split_long_text_messages:
@@ -232,6 +233,7 @@ class ExtractContext:
self.chunk_meta = chunk_meta
self.page_id_map = PageIdMap()
self.source_archive_uri = (source_archive_uri or "").rstrip("/")
+ self.extraction_scope = extraction_scope
@classmethod
def _build_extraction_messages(
@@ -411,15 +413,18 @@ class ExtractContext:
return datetime.now().strftime("%Y%m%d%H%M%S")
def get_source_archive_suffix(self) -> str:
- """Namespace filenames by their full source archive without exposing its path.
+ """Namespace filenames by archive and optional extraction input scope.
- Keep legacy naming for callers outside session commits that have no archive.
- The suffix is stable across retries, not a new random record identifier.
+ Preserve the existing suffix when no scope is supplied. Different scopes
+ can hold distinct analyses of the same archive, while retries stay stable.
"""
- if not self.source_archive_uri:
+ if not self.source_archive_uri and not self.extraction_scope:
return ""
- digest = hashlib.sha256(self.source_archive_uri.encode("utf-8")).hexdigest()[:16]
- return f"_{digest}"
+ digest = hashlib.sha256(self.source_archive_uri.encode("utf-8"))
+ if self.extraction_scope:
+ digest.update(b"\0")
+ digest.update(self.extraction_scope.encode("utf-8"))
+ return f"_{digest.hexdigest()[:16]}"
def get_event_content(
self, ranges_str: str, summary: str | None, ratio_threshold: float = 0.2
diff --git a/openviking/session/memory/merge_op/base.py b/openviking/session/memory/merge_op/base.py
index 413ac6c28..7ba6e2886 100644
--- a/openviking/session/memory/merge_op/base.py
+++ b/openviking/session/memory/merge_op/base.py
@@ -18,6 +18,7 @@ class FieldType(str, Enum):
INT64 = "int64"
FLOAT32 = "float32"
BOOL = "bool"
+ STRING_LIST = "string_list"
# ============================================================================
@@ -29,6 +30,7 @@ _FIELD_TYPE_TO_PYTHON: Dict[FieldType, Type[Any]] = {
FieldType.INT64: int,
FieldType.FLOAT32: float,
FieldType.BOOL: bool,
+ FieldType.STRING_LIST: List[str],
}
@@ -40,7 +42,7 @@ def get_python_type_for_field(field_type: FieldType, default: Type[Any] = str) -
default: Default type if field_type is not recognized
Returns:
- Corresponding Python type (str, int, float, or bool)
+ Corresponding Python type (str, int, float, bool, or List[str])
"""
return _FIELD_TYPE_TO_PYTHON.get(field_type, default)
diff --git a/openviking/session/memory/session_extract_context_provider.py b/openviking/session/memory/session_extract_context_provider.py
index ef3020e60..58e1fd1d7 100644
--- a/openviking/session/memory/session_extract_context_provider.py
+++ b/openviking/session/memory/session_extract_context_provider.py
@@ -71,10 +71,12 @@ class SessionExtractContextProvider(ExtractContextProvider):
vlm_config: Optional["VLMHandle"] = None,
*,
source_archive_uri: str = "",
+ extraction_scope: str = "",
):
self.messages = list(messages) if isinstance(messages, list) else messages
self.latest_archive_overview = latest_archive_overview
self._source_archive_uri = source_archive_uri
+ self._extraction_scope = extraction_scope
self._output_language = self._detect_language()
self._registry = memory_registry # Lazy defaults if no account snapshot was supplied.
self._schema_directories = None
@@ -119,6 +121,7 @@ class SessionExtractContextProvider(ExtractContextProvider):
self.messages if isinstance(self.messages, list) else [],
split_long_text_messages=self.split_long_text_messages_for_extraction,
source_archive_uri=self._source_archive_uri,
+ extraction_scope=self._extraction_scope,
)
return self._extract_context
diff --git a/openviking/session/train/components/trajectory_analyzer.py b/openviking/session/train/components/trajectory_analyzer.py
index 6066d670b..ce3e00b38 100644
--- a/openviking/session/train/components/trajectory_analyzer.py
+++ b/openviking/session/train/components/trajectory_analyzer.py
@@ -4,7 +4,7 @@
from __future__ import annotations
-from dataclasses import dataclass
+from dataclasses import dataclass, field
from typing import Any
from openviking.config.vlm import VLMResolver
@@ -60,6 +60,7 @@ class TrajectoryAnalyzerContext:
inject_evaluation_feedback: bool = True
include_session_skills: bool = False
source_archive_uri: str = ""
+ case_candidates: list[dict[str, Any]] = field(default_factory=list)
@dataclass(slots=True)
@@ -87,10 +88,11 @@ class TrajectoryRolloutAnalyzer:
raise ValueError("TrajectoryAnalyzerContext.request_context is required")
evaluation = await self._evaluate_rollout(rollout, context)
+ feedback_injected = evaluation is not None and context.inject_evaluation_feedback
extraction_messages = _messages_with_evaluation_feedback(
rollout.messages,
evaluation=evaluation,
- enabled=evaluation is not None and context.inject_evaluation_feedback,
+ enabled=feedback_injected,
)
result = await self.extract_trajectory_memories(
messages=extraction_messages,
@@ -100,6 +102,9 @@ class TrajectoryRolloutAnalyzer:
include_session_skills=context.include_session_skills,
case_name=getattr(rollout.case, "name", ""),
source_archive_uri=context.source_archive_uri,
+ case_candidates=context.case_candidates,
+ # Only feedback present in the extraction input changes trajectory identity.
+ extraction_scope=extraction_messages[-1].content if feedback_injected else "",
)
contexts = list((result or {}).get("contexts", []))
skill_gradients = list((result or {}).get("skill_gradients", []))
@@ -149,6 +154,8 @@ class TrajectoryRolloutAnalyzer:
include_session_skills: bool = False,
case_name: str = "",
source_archive_uri: str = "",
+ case_candidates: list[dict[str, Any]] | None = None,
+ extraction_scope: str = "",
) -> dict[str, list[Any]]:
"""Extract trajectory and/or reusable skill operations from rollout messages.
@@ -179,6 +186,8 @@ class TrajectoryRolloutAnalyzer:
include_session_skills=include_session_skills,
vlm_config=vlm_config,
source_archive_uri=source_archive_uri,
+ case_candidates=case_candidates,
+ extraction_scope=extraction_scope,
)
consumed_experience_uris = collect_read_experience_uris(messages, ctx=ctx)
phase_result = await self._run_trajectory_extract_phase(
@@ -270,7 +279,11 @@ class TrajectoryRolloutAnalyzer:
ctx=ctx,
)
- _ensure_trajectory_case_name(traj_ops, case_name=case_name)
+ _bind_trajectory_cases(
+ traj_ops,
+ case_name=case_name,
+ case_candidates=provider.case_candidates,
+ )
_apply_trajectory_source_archive_uri(traj_ops, source_archive_uri)
memory_result = MemoryUpdateResult()
@@ -412,16 +425,37 @@ def _evaluation_from_trajectories(trajectories: list[Trajectory]) -> RubricEvalu
)
-def _ensure_trajectory_case_name(operations: ResolvedOperations, *, case_name: str) -> None:
- case_name = str(case_name or "").strip()
- if not case_name:
- return
+def _bind_trajectory_cases(
+ operations: ResolvedOperations,
+ *,
+ case_name: str,
+ case_candidates: list[dict[str, Any]],
+) -> None:
+ cases_by_id = {case["id"]: case for case in case_candidates}
for op in getattr(operations, "upsert_operations", []) or []:
if getattr(op, "memory_type", None) != _TRAJECTORY_MEMORY_TYPE:
continue
- fields = getattr(op, "memory_fields", None)
- if isinstance(fields, dict):
- fields["case_name"] = case_name
+ fields = op.memory_fields
+ related_ids = fields.pop("related_case_ids", None) or []
+ if not case_candidates:
+ if case_name:
+ fields["case_name"] = case_name
+ continue
+ if len(case_candidates) == 1:
+ related_ids = list(cases_by_id)
+ fields["case_name"] = case_candidates[0]["name"]
+ else:
+ fields.pop("case_name", None)
+ unknown_ids = set(related_ids) - cases_by_id.keys()
+ if unknown_ids:
+ logger.warning("Ignoring unknown trajectory case IDs: %s", sorted(unknown_ids))
+ fields["case_uris"] = list(
+ dict.fromkeys(
+ cases_by_id[case_id]["uri"]
+ for case_id in related_ids
+ if case_id in cases_by_id and cases_by_id[case_id]["uri"]
+ )
+ )
def _apply_trajectory_source_archive_uri(
diff --git a/tests/session/test_compressor_v3.py b/tests/session/test_compressor_v3.py
index 81f5ff378..1e11015f3 100644
--- a/tests/session/test_compressor_v3.py
+++ b/tests/session/test_compressor_v3.py
@@ -720,84 +720,6 @@ async def test_train_from_extracted_cases_skips_experience_updates_when_not_allo
estimate.assert_not_awaited()
-async def test_train_from_extracted_multiple_case_memories_analyzes_bound_rollouts(monkeypatch):
- seen_rollouts = []
- rollout_messages = _messages()
-
- class FakeTrainer:
- policy_set = ExperienceSet(
- root_uri="viking://user/u/memories/experiences",
- policies=[],
- )
-
- class FakeAnalyzer:
- async def analyze(self, rollout, context):
- del context
- seen_rollouts.append(rollout)
- return RolloutAnalysis(
- evaluation=RubricEvaluation(
- passed=True,
- score=1.0,
- criterion_results=[],
- feedback=[],
- ),
- trajectories=[],
- gradients=[],
- )
-
- async def fake_estimate_exp_gradients(self, *args, **kwargs):
- return []
-
- 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,
- )
-
- case_a = _training_case()
- case_b = Case(
- name="case_b",
- task_signature="Handle a second extracted case.",
- input={"summary": "second case"},
- rubric=case_a.rubric,
- )
-
- compressor = SessionCompressorV3(
- vikingdb=None,
- rollout_analyzer=FakeAnalyzer(),
- streaming_trainer_config=StreamingPolicyTrainerConfig(
- max_wait_seconds=60,
- max_gradients_per_update=8,
- ),
- )
-
- result = await compressor.train_from_extracted_cases(
- cases=[case_a, case_b],
- messages=rollout_messages,
- ctx=_ctx(),
- session_id="s1",
- )
-
- assert result["case_count"] == 2
- assert result["submitted"] == 2
- assert [rollout.case.name for rollout in seen_rollouts] == [
- "duplicate_booking",
- "case_b",
- ]
- assert [rollout.messages for rollout in seen_rollouts] == [
- rollout_messages,
- rollout_messages,
- ]
-
-
@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):
diff --git a/tests/session/train/test_commit_case_trajectories.py b/tests/session/train/test_commit_case_trajectories.py
new file mode 100644
index 000000000..6d6580460
--- /dev/null
+++ b/tests/session/train/test_commit_case_trajectories.py
@@ -0,0 +1,369 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+"""Core commit outcomes: shared extraction, precise links, and per-case evaluation."""
+
+import json
+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.compressor_v3 import SessionCompressorV3
+from openviking.session.memory.dataclass import MemoryFile, ResolvedOperation, ResolvedOperations
+from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
+from openviking.session.train import (
+ Case,
+ ExperienceSet,
+ PolicyApplyResult,
+ PolicyPlanItem,
+ PolicyUpdatePlan,
+ RolloutTrainingResult,
+ Rubric,
+ RubricEvaluation,
+)
+from openviking.session.train.components.trajectory_analyzer import (
+ TrajectoryAnalyzerContext,
+ TrajectoryRolloutAnalyzer,
+)
+from openviking_cli.session.user_id import UserIdentifier
+
+
+class CommitFS:
+ agfs = None
+
+ def __init__(self):
+ self.files = {}
+
+ async def read_file(self, uri, ctx=None):
+ if uri not in self.files:
+ raise FileNotFoundError(uri)
+ return self.files[uri]
+
+ async def write_file(self, uri, content, ctx=None, **kwargs):
+ self.files[uri] = content
+
+ async def ls(self, *args, **kwargs):
+ return []
+
+
+class CommitTrainer:
+ def __init__(self, fs):
+ self.fs = fs
+ self.policy_set = ExperienceSet(
+ root_uri="viking://user/u/memories/experiences", policies=[]
+ )
+ self.calls = []
+
+ async def submit_gradients(self, gradients, *, analysis, rollout, batch_finalizer=None):
+ self.calls.append((analysis, gradients))
+ items = []
+ for gradient in gradients:
+ after = MemoryFileUtils.write(gradient.after_file)
+ uri = gradient.target_uri
+ items.append(
+ PolicyPlanItem(
+ kind="upsert",
+ memory_type=gradient.after_file.memory_type,
+ target_name=gradient.target_name,
+ target_uri=uri,
+ before_content=self.fs.files.get(uri),
+ after_content=after,
+ links=gradient.links,
+ )
+ )
+ self.fs.files[uri] = after
+ result = RolloutTrainingResult(
+ analyses=[analysis],
+ gradients=gradients,
+ plan=PolicyUpdatePlan(items=items),
+ apply_result=PolicyApplyResult(
+ updated_policy_set=self.policy_set,
+ written_uris=[item.target_uri for item in items],
+ ),
+ )
+ if batch_finalizer:
+ await batch_finalizer(result)
+ return result
+
+
+def commit_runtime(monkeypatch):
+ config = SimpleNamespace(
+ output_language_override="",
+ language_fallback="en",
+ memory=SimpleNamespace(
+ eager_prefetch=False,
+ prefetch_search_topn=5,
+ link_enabled=False,
+ custom_templates_dir=None,
+ experimental_memory_switch=False,
+ maintenance_review_tokens=4096,
+ extraction_output_format="json",
+ session_skill_extraction_enabled=False,
+ ),
+ )
+ for module in (
+ "openviking_cli.utils.config",
+ "openviking.session.memory.utils.language",
+ "openviking.session.memory.session_extract_context_provider",
+ "openviking.session.memory.extract_loop",
+ "openviking.session.compressor_v3",
+ ):
+ monkeypatch.setattr(f"{module}.get_openviking_config", lambda: config)
+ fs = CommitFS()
+ trainer, skill_trainer = CommitTrainer(fs), CommitTrainer(fs)
+ monkeypatch.setattr("openviking.session.compressor_v3.get_viking_fs", lambda: fs)
+ monkeypatch.setattr(
+ "openviking.session.compressor_v3.get_streaming_policy_trainer",
+ AsyncMock(return_value=trainer),
+ )
+ monkeypatch.setattr(
+ SessionCompressorV3, "_get_session_skill_trainer", AsyncMock(return_value=skill_trainer)
+ )
+
+ async def experience_output(self, trajectory, context):
+ return ResolvedOperations(
+ upsert_operations=[
+ ResolvedOperation(
+ memory_type="experiences",
+ uris=[f"{trainer.policy_set.root_uri}/{trajectory.name}.md"],
+ old_memory_file_content=None,
+ memory_fields={"experience_name": trajectory.name, "content": "Learned lesson"},
+ )
+ ],
+ delete_file_contents=[],
+ errors=[],
+ )
+
+ monkeypatch.setattr(
+ "openviking.session.train.components.gradient_estimator.ExperienceGradientEstimator._run_extract_loop",
+ experience_output,
+ )
+ ctx = RequestContext(user=UserIdentifier.the_default_user("u"), role=Role.ROOT)
+ cases = [
+ Case(
+ name=name,
+ task_signature=name,
+ input={"summary": name},
+ rubric=Rubric(name="r", description="task completed", criteria=[]),
+ )
+ for name in ("book", "cancel")
+ ]
+ case_uris = {case.name: f"viking://user/u/memories/cases/{case.name}.md" for case in cases}
+ for case in cases:
+ uri = case_uris[case.name]
+ fs.files[uri] = MemoryFileUtils.write(
+ MemoryFile(
+ uri=uri,
+ memory_type="cases",
+ content=case.name,
+ extra_fields={"case_name": case.name},
+ )
+ )
+ return SimpleNamespace(
+ config=config,
+ fs=fs,
+ trainer=trainer,
+ skill_trainer=skill_trainer,
+ ctx=ctx,
+ cases=cases,
+ case_uris=case_uris,
+ )
+
+
+def _model_response(rows, output_format, *, skill=False):
+ operations = {"trajectories": []}
+ for index, (name, ids) in enumerate(rows):
+ fields = {
+ "trajectory_name": name,
+ "outcome": "success",
+ "task_query": "Book and cancel",
+ "retrieval_anchor": name,
+ "content": f"# {name}\nExecution steps",
+ "related_case_ids": ids or [],
+ }
+ operations["trajectories"].append({"page_id": 100 + index, **fields})
+ if skill:
+ operations["session_skills"] = [
+ {
+ "page_id": 200,
+ "skill_name": "booking",
+ "description": "Booking workflow",
+ "content": "## Workflow\nVerify the booking first.",
+ }
+ ]
+ if output_format == "json":
+ return json.dumps(operations)
+ return "\n".join(
+ [
+ f"sdk.create_{kind}("
+ + ", ".join(f"{key}={value!r}" for key, value in fields.items() if key != "page_id")
+ + ")"
+ for kind, items in operations.items()
+ for fields in items
+ ]
+ + ["sdk.commit()"]
+ )
+
+
+async def _commit(
+ runtime, rows, *, evaluator=None, single=False, output_format="json", skill=False
+):
+ runtime.config.memory.extraction_output_format = output_format
+ runtime.config.memory.session_skill_extraction_enabled = skill
+ responses = iter(rows)
+ model = SimpleNamespace(
+ model="test",
+ get_completion_async=AsyncMock(
+ side_effect=lambda **kwargs: _model_response(
+ next(responses), output_format, skill=skill
+ )
+ ),
+ )
+ analyzer = TrajectoryRolloutAnalyzer(viking_fs=runtime.fs, vlm=model, evaluator=evaluator)
+ compressor = SessionCompressorV3(
+ vikingdb=None,
+ rollout_analyzer=analyzer,
+ skill_processor=object() if skill else None,
+ )
+ result = await compressor.train_from_extracted_cases(
+ cases=runtime.cases[:1] if single else runtime.cases,
+ case_uri_by_name=runtime.case_uris,
+ messages=[
+ Message(
+ id="m",
+ role="user",
+ parts=[TextPart("Book a trip, then cancel it.")],
+ created_at="2026-10-19T00:00:00",
+ )
+ ],
+ ctx=runtime.ctx,
+ archive_uri="viking://user/u/sessions/s/history/archive_001",
+ collect_memory_diff=True,
+ strict_extract_errors=True,
+ )
+ return result, model.get_completion_async
+
+
[email protected]("output_format", ["json", "python"])
[email protected]("single", [True, False])
+async def test_commit_extracts_once_and_persists_precise_case_links(
+ commit_runtime, output_format, single
+):
+ runtime = commit_runtime
+ rows = (
+ [("book", None)]
+ if single
+ else [
+ ("book", ["c1"]),
+ ("cancel", ["c2"]),
+ ("shared", ["c1", "c2"]),
+ ("other", []),
+ ]
+ )
+ result, model = await _commit(
+ runtime, [rows], single=single, output_format=output_format, skill=True
+ )
+
+ assert result["submitted"] == (1 if single else 2)
+ assert model.await_count == len(runtime.trainer.calls) == len(runtime.skill_trainer.calls) == 1
+ files = {uri: MemoryFileUtils.read(raw, uri=uri) for uri, raw in runtime.fs.files.items()}
+ trajectories = {
+ mf.extra_fields["trajectory_name"]: mf
+ for uri, mf in files.items()
+ if "/memories/trajectories/" in uri
+ }
+ assert set(trajectories) == {name for name, _ in rows}
+ for case in runtime.cases[:1] if single else runtime.cases:
+ names = {"book"} if single else {case.name, "shared"}
+ targets = {link["to_uri"] for link in files[runtime.case_uris[case.name]].links}
+ assert targets == {trajectories[name].uri for name in names} | {
+ f"{runtime.trainer.policy_set.root_uri}/{name}.md" for name in names
+ }
+ assert all(
+ any(link["from_uri"] == runtime.case_uris[case.name] for link in files[uri].backlinks)
+ for uri in targets
+ )
+ assert all("related_case_ids" not in mf.extra_fields for mf in trajectories.values())
+ adds = result["memory_diff"]["operations"]["adds"]
+ assert len({item["uri"] for item in adds if item["memory_type"] == "trajectories"}) == len(rows)
+ assert len([item for item in adds if item["memory_type"] == "trajectories"]) == len(rows)
+
+
[email protected]("evaluation_mode", ["same", "different_feedback", "scores_only"])
+async def test_commit_preserves_evaluator_training_semantics(
+ commit_runtime, monkeypatch, evaluation_mode
+):
+ runtime = commit_runtime
+ same = evaluation_mode == "same"
+ evaluations = [
+ RubricEvaluation(passed=True, score=1.0, criterion_results=[], feedback=[]),
+ RubricEvaluation(
+ passed=same, score=1.0 if same else 0.0, criterion_results=[], feedback=[]
+ ),
+ ]
+ evaluator = SimpleNamespace(evaluate=AsyncMock(side_effect=evaluations))
+ if evaluation_mode == "scores_only":
+ monkeypatch.setattr(
+ "openviking.session.compressor_v3.TrajectoryAnalyzerContext",
+ lambda **kwargs: TrajectoryAnalyzerContext(**kwargs, inject_evaluation_feedback=False),
+ )
+ separate_extraction = evaluation_mode == "different_feedback"
+ rows = (
+ [[("shared", None)], [("shared", None)]]
+ if separate_extraction
+ else [
+ [
+ ("book", ["c1"]),
+ ("cancel", ["c2"]),
+ ("shared", ["c1", "c2"]),
+ ("other", []),
+ ]
+ ]
+ )
+ result, model = await _commit(runtime, rows, evaluator=evaluator)
+
+ assert result["submitted"] == evaluator.evaluate.await_count == 2
+ assert model.await_count == (2 if separate_extraction else 1)
+ calls = runtime.trainer.calls
+ assert [analysis.evaluation.score for analysis, _ in calls] == ([1.0] if same else [1.0, 0.0])
+ assert [gradients[0].confidence for _, gradients in calls] == pytest.approx(
+ [0.9] if same else [0.9, 0.7]
+ )
+ expected_training = (
+ [{"book", "cancel", "shared", "other"}]
+ if same
+ else (
+ [{"shared"}, {"shared"}]
+ if separate_extraction
+ else [{"book", "shared"}, {"cancel", "shared"}]
+ )
+ )
+ assert [{t.name for t in analysis.trajectories} for analysis, _ in calls] == expected_training
+ adds = result["memory_diff"]["operations"]["adds"]
+ assert len([item for item in adds if item["memory_type"] == "trajectories"]) == sum(
+ map(len, rows)
+ )
+ case_trajectories = []
+ for case in runtime.cases:
+ uri = runtime.case_uris[case.name]
+ mf = MemoryFileUtils.read(runtime.fs.files[uri], uri=uri)
+ expected_names = {"shared"} if separate_extraction else {case.name, "shared"}
+ assert {
+ link["to_uri"] for link in mf.links if "/memories/experiences/" in link["to_uri"]
+ } == {f"{runtime.trainer.policy_set.root_uri}/{name}.md" for name in expected_names}
+ trajectory_uris = {
+ link["to_uri"] for link in mf.links if "/memories/trajectories/" in link["to_uri"]
+ }
+ case_trajectories.append(trajectory_uris)
+ if separate_extraction:
+ assert len(trajectory_uris) == 1
+ trajectory_uri = next(iter(trajectory_uris))
+ trajectory = MemoryFileUtils.read(runtime.fs.files[trajectory_uri], uri=trajectory_uri)
+ assert trajectory.extra_fields["case_uris"] == [uri]
+ if separate_extraction:
+ assert case_trajectories[0].isdisjoint(case_trajectories[1])