Skip to content

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

fix(memory): Event memory writes reusing existing page IDs (#4388)

DuTao6248d4e41c33
diff --git a/openviking/session/memory/dataclass.py b/openviking/session/memory/dataclass.py
index 3fd6ec4ae..3c4254e0c 100644
--- a/openviking/session/memory/dataclass.py
+++ b/openviking/session/memory/dataclass.py
@@ -180,6 +180,7 @@ class MemoryOperationSkipCode(str, Enum):
INVALID_RANGES = "invalid_ranges"
AMBIGUOUS_TARGET = "ambiguous_target"
NO_WRITABLE_TARGET = "no_writable_target"
+ PAGE_ID_TYPE_MISMATCH = "page_id_type_mismatch"
class MemoryOperationSkip(BaseModel):
diff --git a/openviking/session/memory/extract_loop.py b/openviking/session/memory/extract_loop.py
index 016457374..5abd15a96 100644
--- a/openviking/session/memory/extract_loop.py
+++ b/openviking/session/memory/extract_loop.py
@@ -9,6 +9,7 @@ Reference: bot/vikingbot/agent/loop.py AgentLoop structure
import asyncio
import json
import re
+from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Tuple
from openviking.models.vlm.base import ToolCall, VLMBase
@@ -17,12 +18,15 @@ from openviking.session.memory.dataclass import (
DeleteId,
MemoryFile,
MemoryOperationSkip,
+ MemoryOperationSkipCode,
ResolvedOperation,
ResolvedOperations,
StoredLink,
+ WikiLink,
)
from openviking.session.memory.memory_isolation_handler import MemoryIsolationHandler
from openviking.session.memory.merge_op import FieldType, MergeOp, PatchOp
+from openviking.session.memory.page_id_map import ResponsePageIdAllocator
from openviking.session.memory.schema_model_generator import SchemaModelGenerator
from openviking.session.memory.tools import (
MEMORY_TOOLS_REGISTRY,
@@ -41,6 +45,23 @@ from openviking_cli.utils.config import get_openviking_config
logger = get_logger(__name__)
+@dataclass
+class _EventRepairOperations:
+ """Server-filtered operation set accepted from one Event repair response."""
+
+ events: List[Dict[str, Any]]
+ delete_ids: List[Any] = field(default_factory=list)
+ links: List[WikiLink] = field(default_factory=list)
+
+
+_EVENT_RETRYABLE_RESOLUTION_SKIP_CODES = {
+ MemoryOperationSkipCode.INVALID_PEER_ID,
+ MemoryOperationSkipCode.INVALID_RANGES,
+ MemoryOperationSkipCode.AMBIGUOUS_TARGET,
+ MemoryOperationSkipCode.NO_WRITABLE_TARGET,
+}
+
+
_CANNED_REFUSAL_RE = re.compile(
r"(抱歉|不好意思|很遗憾|sorry).{0,20}"
r"(无法|不能|未能|不给|没有找到|未找到|can't|cannot|unable|won't|not able)",
@@ -158,6 +179,8 @@ class ExtractLoop:
# Reset format retry counter for each run
self._format_retry_count = 0
patch_repair_count = 0
+ resolution_repair_count = 0
+ pending_resolution_repair: Optional[Tuple[ResolvedOperations, List]] = None
# 从 provider 获取 schemas(内部自动加载 registry)
schemas = self.context_provider.get_memory_schemas(self.ctx)
@@ -285,7 +308,41 @@ The final output of the model must strictly follow the JSON Schema format shown
# If model returned final operations, check if refetch is needed
if operations is not None:
- final_operations, raw_links = await self.resolve_operations(operations)
+ if pending_resolution_repair is not None:
+ operations = self._event_resolution_repair_subset(
+ operations,
+ pending_resolution_repair[0],
+ )
+ candidate_operations, candidate_links = await self.resolve_operations(operations)
+ if pending_resolution_repair is not None:
+ base_operations, base_links = pending_resolution_repair
+ final_operations = self._merge_event_resolution_repair(
+ base_operations,
+ candidate_operations,
+ )
+ raw_links = base_links
+ pending_resolution_repair = None
+ else:
+ final_operations = candidate_operations
+ raw_links = candidate_links
+ resolution_issues = self._retryable_resolution_issues(final_operations)
+ if resolution_issues and resolution_repair_count == 0:
+ resolution_repair_count += 1
+ pending_resolution_repair = (final_operations, raw_links)
+ max_iterations += 1
+ self._disable_tools_for_iteration = True
+ messages.append(
+ {
+ "role": "user",
+ "content": self._build_resolution_repair_instruction(resolution_issues),
+ }
+ )
+ tracer.info(
+ "Extended max_iterations to "
+ f"{max_iterations} for retry memory target resolution",
+ console=True,
+ )
+ continue
# Check if any write_uris target existing files that weren't read
refetch_uris = await self._check_unread_existing_files(final_operations)
if refetch_uris:
@@ -336,6 +393,15 @@ The final output of the model must strictly follow the JSON Schema format shown
# If it's the last iteration, treat unparseable response as
# "no memory operations" rather than failing hard.
if iteration >= max_iterations:
+ if pending_resolution_repair is not None:
+ final_operations, raw_links = pending_resolution_repair
+ pending_resolution_repair = None
+ tracer.info(
+ "Event resolution repair response could not be parsed; "
+ "keeping the first-pass operations",
+ console=True,
+ )
+ break
tracer.info(
"Memory extraction final response could not be parsed as JSON operations "
f"after {max_iterations} iterations — treating as no operations "
@@ -368,16 +434,319 @@ The final output of the model must strictly follow the JSON Schema format shown
return final_operations, tools_used
+ def _retryable_resolution_issues(self, operations: ResolvedOperations) -> List[Dict[str, Any]]:
+ issues: List[Dict[str, Any]] = []
+ for operation in operations.upsert_operations:
+ resolution_skip = operation.resolution_skip
+ if (
+ operation.uris
+ or operation.memory_type != "events"
+ or resolution_skip is None
+ or resolution_skip.reason_code not in _EVENT_RETRYABLE_RESOLUTION_SKIP_CODES
+ ):
+ continue
+ if resolution_skip.reason_code == MemoryOperationSkipCode.NO_WRITABLE_TARGET and (
+ not self.ctx or not self.ctx.user
+ ):
+ continue
+ issue = {
+ "memory_type": operation.memory_type,
+ "page_id": operation.page_id,
+ "reason_code": resolution_skip.reason_code.value,
+ "reason": resolution_skip.reason,
+ "operation": operation.memory_fields,
+ }
+ issues.append(issue)
+ return issues
+
+ @staticmethod
+ def _build_resolution_repair_instruction(issues: List[Dict[str, Any]]) -> str:
+ details = json.dumps(issues, ensure_ascii=False, indent=2)
+ return (
+ "Some event operations could not resolve a safe write target. "
+ "Return only corrected event operations for the failed items below; leave every "
+ "other memory-type field, delete_ids, and links empty. The server has preserved "
+ "all successful operations from the previous response. "
+ "Reuse exactly the page_id shown for each failed event. "
+ "For event ranges, use valid in-bounds message indexes and include the user-role "
+ "message that establishes the event so its owner can be resolved. "
+ "Do not target a disallowed or ambiguous peer. Output ONLY one JSON object matching "
+ "the required schema.\n\n"
+ f"Resolution issues:\n{details}"
+ )
+
+ @staticmethod
+ def _is_event_schema(schema: Any) -> bool:
+ return (
+ getattr(schema, "memory_type", None) == "events"
+ and getattr(schema, "operation_mode", None) == "add_only"
+ )
+
+ def _uri_belongs_to_schema(self, uri: str, schema: Any) -> Optional[bool]:
+ """Return a path-based ownership result without trusting file metadata."""
+ render_directories = getattr(self._isolation_handler, "render_schema_directories", None)
+ if not callable(render_directories):
+ return None
+ try:
+ directories = render_directories(schema)
+ except Exception:
+ return None
+ if not isinstance(directories, (list, tuple, set)):
+ return None
+ directories = [
+ directory.rstrip("/") for directory in directories if isinstance(directory, str)
+ ]
+ if not directories:
+ return None
+ filename_template = str(getattr(schema, "filename_template", "") or "").lstrip("/")
+ if not filename_template:
+ return None
+ if schema.filename_has_variables():
+ return any(uri.startswith(f"{directory}/") for directory in directories)
+ return any(uri == f"{directory}/{filename_template}" for directory in directories)
+
+ def _memory_type_for_uri(self, uri: str) -> Optional[str]:
+ matches = [
+ schema.memory_type
+ for schema in self.context_provider.get_memory_schemas(self.ctx)
+ if self._uri_belongs_to_schema(uri, schema) is True
+ ]
+ unique_matches = list(dict.fromkeys(matches))
+ return unique_matches[0] if len(unique_matches) == 1 else None
+
+ @staticmethod
+ def _is_retryable_event_operation(operation: ResolvedOperation) -> bool:
+ return bool(
+ operation.memory_type == "events"
+ and not operation.uris
+ and operation.resolution_skip is not None
+ and operation.resolution_skip.reason_code in _EVENT_RETRYABLE_RESOLUTION_SKIP_CODES
+ )
+
+ @classmethod
+ def _event_resolution_repair_subset(
+ cls,
+ operations: Any,
+ original: ResolvedOperations,
+ ) -> _EventRepairOperations:
+ """Keep only one range repair for each failed Event and preserve its original fields."""
+ failed_events = {
+ operation.page_id: operation
+ for operation in original.upsert_operations
+ if cls._is_retryable_event_operation(operation) and operation.page_id is not None
+ }
+ candidates: Dict[int, List[Dict[str, Any]]] = {}
+ for item in getattr(operations, "events", None) or []:
+ item_dict = dict(item)
+ page_id = item_dict.get("page_id")
+ if page_id in failed_events:
+ candidates.setdefault(page_id, []).append(item_dict)
+
+ repaired_items: List[Dict[str, Any]] = []
+ for page_id, failed_operation in failed_events.items():
+ page_candidates = candidates.get(page_id, [])
+ if len(page_candidates) != 1:
+ if page_candidates:
+ logger.warning(
+ "Ignoring ambiguous Event repair response for page_id=%s: count=%s",
+ page_id,
+ len(page_candidates),
+ )
+ continue
+
+ candidate = page_candidates[0]
+ expected_name = failed_operation.memory_fields.get("event_name")
+ if candidate.get("event_name") != expected_name or candidate.get("ranges") is None:
+ logger.warning(
+ "Ignoring mismatched Event repair response for page_id=%s",
+ page_id,
+ )
+ continue
+
+ repaired_item = {
+ key: value
+ for key, value in failed_operation.memory_fields.items()
+ if key not in {"memory_type", "user_id"}
+ }
+ repaired_item["ranges"] = candidate["ranges"]
+ repaired_item["page_id"] = page_id
+ repaired_items.append(repaired_item)
+
+ return _EventRepairOperations(events=repaired_items)
+
+ @classmethod
+ def _merge_event_resolution_repair(
+ cls,
+ original: ResolvedOperations,
+ repair: ResolvedOperations,
+ ) -> ResolvedOperations:
+ """Replace only failed Events; preserve every other first-pass operation."""
+ failed_page_ids = {
+ operation.page_id
+ for operation in original.upsert_operations
+ if cls._is_retryable_event_operation(operation)
+ }
+ failed_event_names = {
+ operation.page_id: operation.memory_fields.get("event_name")
+ for operation in original.upsert_operations
+ if cls._is_retryable_event_operation(operation)
+ }
+ repaired_events: Dict[int, ResolvedOperation] = {}
+ duplicate_page_ids = set()
+ for operation in repair.upsert_operations:
+ if (
+ operation.memory_type != "events"
+ or operation.page_id not in failed_page_ids
+ or operation.memory_fields.get("event_name")
+ != failed_event_names.get(operation.page_id)
+ ):
+ continue
+ if operation.page_id in repaired_events:
+ duplicate_page_ids.add(operation.page_id)
+ continue
+ repaired_events[operation.page_id] = operation
+ for page_id in duplicate_page_ids:
+ repaired_events.pop(page_id, None)
+
+ merged_operations: List[ResolvedOperation] = []
+ for operation in original.upsert_operations:
+ if cls._is_retryable_event_operation(operation):
+ repaired_operation = repaired_events.get(operation.page_id)
+ merged_operations.append(repaired_operation or operation)
+ continue
+ merged_operations.append(operation)
+
+ return original.model_copy(
+ update={
+ "upsert_operations": merged_operations,
+ }
+ )
+
+ @staticmethod
+ def _normalize_page_id_reference(
+ raw_page_id: Optional[int],
+ page_id_assignments: Dict[int, List[int]],
+ page_id_map: Any,
+ ) -> Tuple[Optional[int], bool]:
+ """Return the normalized response ID and whether the reference is ambiguous."""
+ if raw_page_id is None:
+ return None, False
+ assigned_ids = page_id_assignments.get(raw_page_id, [])
+ if not assigned_ids:
+ return raw_page_id, False
+
+ unique_ids = list(dict.fromkeys(assigned_ids))
+ existing_uri = page_id_map.resolve(raw_page_id) if page_id_map else None
+ if len(unique_ids) != 1 or (existing_uri is not None and unique_ids[0] != raw_page_id):
+ return None, True
+ return unique_ids[0], False
+
+ @classmethod
+ def _normalize_operation_links(
+ cls,
+ raw_links: List[WikiLink],
+ page_id_assignments: Dict[int, List[int]],
+ page_id_map: Any,
+ ) -> List[WikiLink]:
+ if not raw_links or not page_id_assignments:
+ return raw_links
+
+ normalized_links: List[WikiLink] = []
+ for link in raw_links:
+ updates: Dict[str, int] = {}
+ ambiguous = False
+ for field_name in ("f", "t"):
+ raw_page_id = getattr(link, field_name, None)
+ normalized_page_id, is_ambiguous = cls._normalize_page_id_reference(
+ raw_page_id,
+ page_id_assignments,
+ page_id_map,
+ )
+ if is_ambiguous:
+ ambiguous = True
+ break
+ if normalized_page_id != raw_page_id:
+ updates[field_name] = normalized_page_id
+ if ambiguous:
+ logger.warning(
+ "Skipping ambiguous memory link after page_id normalization: f=%s, t=%s",
+ link.f,
+ link.t,
+ )
+ continue
+ normalized_links.append(link.model_copy(update=updates) if updates else link)
+ return normalized_links
+
+ def _assign_response_page_ids(
+ self,
+ operations: Any,
+ schemas: List[Any],
+ page_id_map: Any,
+ ) -> Tuple[Dict[Tuple[int, int], int], Dict[int, List[int]]]:
+ """Assign unique IDs to new logical operations within one candidate response."""
+ entries: List[Tuple[int, int, Optional[int], bool]] = []
+ for schema_index, schema in enumerate(schemas):
+ value = getattr(operations, schema.memory_type, None)
+ if value is None:
+ continue
+ items = value if isinstance(value, list) else [value]
+ is_event = self._is_event_schema(schema)
+ for item_index, item in enumerate(items):
+ requested_page_id = dict(item).get("page_id")
+ entries.append((schema_index, item_index, requested_page_id, is_event))
+
+ assigned_page_ids: Dict[Tuple[int, int], int] = {}
+ page_id_assignments: Dict[int, List[int]] = {}
+ page_id_allocator = None
+
+ # Preserve non-Event behavior where possible. Events are always new and therefore
+ # allocate after every other memory type has claimed its response-local ID.
+ for event_phase in (False, True):
+ for schema_index, item_index, requested_page_id, is_event in entries:
+ if is_event != event_phase:
+ continue
+ existing_uri = None
+ if requested_page_id is not None and page_id_map is not None:
+ existing_uri = page_id_map.resolve(requested_page_id)
+ if not is_event and existing_uri is not None:
+ page_id = requested_page_id
+ else:
+ if page_id_allocator is None:
+ allocator_factory = getattr(
+ page_id_map,
+ "new_page_id_allocator",
+ None,
+ )
+ page_id_allocator = (
+ allocator_factory()
+ if callable(allocator_factory)
+ else ResponsePageIdAllocator()
+ )
+ page_id = page_id_allocator.allocate(requested_page_id)
+
+ assigned_page_ids[(schema_index, item_index)] = page_id
+ if requested_page_id is not None:
+ page_id_assignments.setdefault(requested_page_id, []).append(page_id)
+
+ return assigned_page_ids, page_id_assignments
+
async def resolve_operations(self, operations) -> tuple[ResolvedOperations, List]:
tracer.info(f"operations={JsonUtils.dumps(operations)}")
upsert_operations: List[ResolvedOperation] = []
delete_file_contents: List[MemoryFile] = []
errors: List[str] = []
+ invalid_reference_page_ids: set[int] = set()
role_scope = self._isolation_handler.get_read_scope()
page_id_map = getattr(self._extract_context, "page_id_map", None)
+ schemas = list(self.context_provider.get_memory_schemas(self.ctx))
+ assigned_page_ids, page_id_assignments = self._assign_response_page_ids(
+ operations,
+ schemas,
+ page_id_map,
+ )
- for schema in self.context_provider.get_memory_schemas(self.ctx):
+ for schema_index, schema in enumerate(schemas):
memory_type = schema.memory_type
value = getattr(operations, memory_type, None)
if value is None:
@@ -385,7 +754,7 @@ The final output of the model must strictly follow the JSON Schema format shown
items = value if isinstance(value, list) else [value]
- for item in items:
+ for item_index, item in enumerate(items):
item_dict = dict(item)
item_dict["memory_type"] = memory_type
identity_resolution_skip = None
@@ -419,7 +788,9 @@ The final output of the model must strictly follow the JSON Schema format shown
if not isinstance(identity_resolution_skip, MemoryOperationSkip):
identity_resolution_skip = None
- page_id = item_dict.pop("page_id", None)
+ requested_page_id = item_dict.pop("page_id", None)
+ page_id = assigned_page_ids[(schema_index, item_index)]
+ is_event = self._is_event_schema(schema)
resolved_op = ResolvedOperation(
old_memory_file_content=None,
memory_fields=item_dict,
@@ -429,16 +800,36 @@ The final output of the model must strictly follow the JSON Schema format shown
resolution_skip=identity_resolution_skip,
)
- if page_id is not None and page_id_map is not None:
- resolved_uri = page_id_map.resolve(page_id)
+ if is_event:
+ # Event page_ids are temporary link anchors. They must never select an
+ # existing memory file; URI collision handling remains unchanged downstream.
+ resolved_op.uris = self._isolation_handler.calculate_memory_uris(
+ memory_type_schema=schema,
+ operation=resolved_op,
+ extract_context=self._extract_context,
+ )
+ elif requested_page_id is not None and page_id_map is not None:
+ resolved_uri = page_id_map.resolve(requested_page_id)
if resolved_uri:
- resolved_op.uris = [resolved_uri]
- # Existing page IDs retain their historical precedence over
- # an invalid peer hint. Keep the hint runtime-only and do
- # not persist it into memory metadata.
- resolved_op.resolution_skip = None
old_content = self.context_provider.read_file_contents.get(resolved_uri)
- if old_content is not None:
+ belongs_to_schema = self._uri_belongs_to_schema(resolved_uri, schema)
+ if belongs_to_schema is False:
+ invalid_reference_page_ids.add(requested_page_id)
+ existing_memory_type = self._memory_type_for_uri(resolved_uri)
+ resolved_op.resolution_skip = MemoryOperationSkip(
+ reason_code=MemoryOperationSkipCode.PAGE_ID_TYPE_MISMATCH,
+ reason=(
+ f"page_id {page_id} belongs to memory type "
+ f"{existing_memory_type or 'another schema'}, not {memory_type}"
+ ),
+ )
+ else:
+ resolved_op.uris = [resolved_uri]
+ # Existing page IDs retain their historical precedence over
+ # an invalid peer hint. Keep the hint runtime-only and do
+ # not persist it into memory metadata.
+ resolved_op.resolution_skip = None
+ if old_content is not None and resolved_op.uris:
resolved_op.old_memory_file_content = old_content
immutable_fields = {
field.name
@@ -476,21 +867,54 @@ The final output of the model must strictly follow the JSON Schema format shown
old_content = self.context_provider.read_file_contents.get(delete_uri)
if not old_content:
continue
- delete_file_contents.append(old_content)
-
replacement_page_id = delete_id.replacement_page_id
- if replacement_page_id is None:
- continue
- replacement_uri = page_id_map.resolve(replacement_page_id)
- if not replacement_uri:
- for op in upsert_operations:
- if op.page_id == replacement_page_id and op.uris:
- replacement_uri = op.uris[0]
- break
+ replacement_uri = None
+ if replacement_page_id is not None:
+ if replacement_page_id in invalid_reference_page_ids:
+ logger.warning(
+ "Skipping delete with type-mismatched replacement page_id: "
+ "delete_page_id=%s, replacement_page_id=%s",
+ delete_id.delete_page_id,
+ delete_id.replacement_page_id,
+ )
+ continue
+ replacement_page_id, ambiguous = self._normalize_page_id_reference(
+ replacement_page_id,
+ page_id_assignments,
+ page_id_map,
+ )
+ if ambiguous:
+ logger.warning(
+ "Skipping delete with ambiguous replacement page_id: "
+ "delete_page_id=%s, replacement_page_id=%s",
+ delete_id.delete_page_id,
+ delete_id.replacement_page_id,
+ )
+ continue
+ replacement_uri = page_id_map.resolve(replacement_page_id)
+ if not replacement_uri:
+ for op in upsert_operations:
+ if op.page_id == replacement_page_id and op.uris:
+ replacement_uri = op.uris[0]
+ break
+
+ delete_file_contents.append(old_content)
if replacement_uri and replacement_uri != delete_uri:
delete_replacements[delete_uri] = replacement_uri
raw_links = getattr(operations, "links", None) or []
+ if invalid_reference_page_ids:
+ raw_links = [
+ link
+ for link in raw_links
+ if link.f not in invalid_reference_page_ids
+ and link.t not in invalid_reference_page_ids
+ ]
+ raw_links = self._normalize_operation_links(
+ raw_links,
+ page_id_assignments,
+ page_id_map,
+ )
resolved = ResolvedOperations(
upsert_operations=upsert_operations,
delete_file_contents=delete_file_contents,
@@ -507,7 +931,6 @@ The final output of the model must strictly follow the JSON Schema format shown
return resolved, raw_links
-
def _normalize_delete_ids(self, raw_delete_ids: List[Any]) -> List[DeleteId]:
delete_ids: List[DeleteId] = []
for raw in raw_delete_ids:
diff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.py
index 6768a7b88..769c8b4c6 100644
--- a/openviking/session/memory/memory_updater.py
+++ b/openviking/session/memory/memory_updater.py
@@ -906,6 +906,7 @@ class MemoryUpdater:
if resolution_skip.reason_code in {
MemoryOperationSkipCode.INVALID_PEER_ID,
MemoryOperationSkipCode.INVALID_RANGES,
+ MemoryOperationSkipCode.PAGE_ID_TYPE_MISMATCH,
}:
logger.warning(message)
else:
diff --git a/openviking/session/memory/page_id_map.py b/openviking/session/memory/page_id_map.py
index 4624e2b49..e85949ccc 100644
--- a/openviking/session/memory/page_id_map.py
+++ b/openviking/session/memory/page_id_map.py
@@ -14,13 +14,43 @@ page_id information is injected into LLM context by annotating read results
with [page_id: N], not by generating a separate mapping table.
"""
-from typing import Dict, Optional
+from typing import Dict, Iterable, Optional
from openviking_cli.utils import get_logger
logger = get_logger(__name__)
+class ResponsePageIdAllocator:
+ """Allocate unique new-page IDs for one candidate LLM response."""
+
+ def __init__(self, registered_page_ids: Iterable[int] = ()):
+ self._registered_page_ids = set(registered_page_ids)
+ self._allocated_page_ids: set[int] = set()
+ self._next_page_id = 100
+
+ def allocate(self, requested_page_id: Optional[int]) -> int:
+ if (
+ requested_page_id is not None
+ and requested_page_id >= 100
+ and requested_page_id not in self._registered_page_ids
+ and requested_page_id not in self._allocated_page_ids
+ ):
+ page_id = requested_page_id
+ else:
+ page_id = self._next_page_id
+ while page_id in self._registered_page_ids or page_id in self._allocated_page_ids:
+ page_id += 1
+
+ self._allocated_page_ids.add(page_id)
+ while (
+ self._next_page_id in self._registered_page_ids
+ or self._next_page_id in self._allocated_page_ids
+ ):
+ self._next_page_id += 1
+ return page_id
+
+
class PageIdMap:
"""Temporary mapping from page_id to URI for one ExtractLoop run."""
@@ -44,6 +74,9 @@ class PageIdMap:
if uri not in self._uri_to_id:
self._uri_to_id[uri] = page_id
+ def new_page_id_allocator(self) -> ResponsePageIdAllocator:
+ return ResponsePageIdAllocator(self._id_to_uri)
+
def resolve(self, page_id: int) -> Optional[str]:
"""Resolve page_id to URI."""
return self._id_to_uri.get(page_id)
diff --git a/openviking/session/memory/schema_model_generator.py b/openviking/session/memory/schema_model_generator.py
index fdf821da5..b36d0d84f 100644
--- a/openviking/session/memory/schema_model_generator.py
+++ b/openviking/session/memory/schema_model_generator.py
@@ -153,11 +153,17 @@ class SchemaModelGenerator:
),
)
+ page_id_json_schema = {"type": "integer"}
+ page_id_description = "Temporary page_id for identifying the target memory item."
+ if memory_type.memory_type == "events" and memory_type.operation_mode == "add_only":
+ page_id_json_schema["minimum"] = 100
+ page_id_description = "Unique page_id for this new event; it MUST be at least 100."
+
field_definitions["page_id"] = (
- Annotated[int, WithJsonSchema({"type": "integer"})],
+ Annotated[int, WithJsonSchema(page_id_json_schema)],
Field(
...,
- description="Temporary page_id for identifying the target memory item.",
+ description=page_id_description,
),
)
diff --git a/tests/session/memory/test_schema_models.py b/tests/session/memory/test_schema_models.py
index 3ba88e7fb..7b99a1824 100644
--- a/tests/session/memory/test_schema_models.py
+++ b/tests/session/memory/test_schema_models.py
@@ -273,6 +273,46 @@ class TestSchemaModelGenerator:
"Temporary page_id for identifying the target memory item."
)
+ def test_event_page_id_schema_requires_new_page_range(self):
+ memory_type = MemoryTypeSchema(
+ memory_type="events",
+ operation_mode="add_only",
+ filename_template="{{ event_name }}.md",
+ directory="viking://user/{{ user_space }}/memories/events",
+ fields=[
+ MemoryField(
+ name="event_name",
+ field_type=FieldType.STRING,
+ merge_op=MergeOp.IMMUTABLE,
+ )
+ ],
+ )
+
+ model = SchemaModelGenerator([memory_type]).create_flat_data_model(memory_type)
+ schema = model.model_json_schema()
+
+ assert schema["properties"]["page_id"]["minimum"] == 100
+ assert "MUST be at least 100" in schema["properties"]["page_id"]["description"]
+ # Runtime resolution normalizes bad model output instead of dropping the event.
+ assert model.model_validate({"page_id": 5, "event_name": "demo"}).page_id == 5
+
+ def test_non_event_add_only_page_id_schema_is_unchanged(self):
+ memory_type = MemoryTypeSchema(
+ memory_type="trajectories",
+ operation_mode="add_only",
+ filename_template="{{ trajectory_name }}.md",
+ directory="viking://user/{{ user_space }}/memories/trajectories",
+ fields=[],
+ )
+
+ model = SchemaModelGenerator([memory_type]).create_flat_data_model(memory_type)
+ page_id_schema = model.model_json_schema()["properties"]["page_id"]
+
+ assert "minimum" not in page_id_schema
+ assert page_id_schema["description"] == (
+ "Temporary page_id for identifying the target memory item."
+ )
+
def test_existing_patch_can_omit_immutable_fields_but_new_item_cannot(
self, real_registry
):
diff --git a/tests/unit/session/memory/test_extract_loop_match_text.py b/tests/unit/session/memory/test_extract_loop_match_text.py
index 7417c54f7..937b692b5 100644
--- a/tests/unit/session/memory/test_extract_loop_match_text.py
+++ b/tests/unit/session/memory/test_extract_loop_match_text.py
@@ -9,8 +9,11 @@ import pytest
from openviking.session.memory.dataclass import (
MemoryField,
MemoryFile,
+ MemoryOperationSkip,
+ MemoryOperationSkipCode,
MemoryTypeSchema,
ResolvedOperation,
+ ResolvedOperations,
WikiLink,
)
from openviking.session.memory.extract_loop import ExtractLoop
@@ -23,6 +26,456 @@ class AttrDict(dict):
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_non_event_add_only_resolution_is_unchanged(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"
+ 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 = [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=PageIdMap())
+
+ operations, _ = await loop.resolve_operations(
+ AttrDict(trajectories=[{"trajectory_name": "demo", "page_id": 105}])
+ )
+
+ operation = operations.upsert_operations[0]
+ assert operation.page_id == 105
+ assert operation.uris == [trajectory_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(
@@ -150,6 +603,34 @@ class TestResolveOperations:
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()
@@ -216,6 +697,453 @@ class TestResolveLinksMultiUri:
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=[],
+ )
+
+ issues = self._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"},
+ }
+ ]
+ instruction = ExtractLoop._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) == []
+
+ @pytest.mark.asyncio
+ async def test_run_repairs_only_failed_event_and_preserves_successful_profile(self):
+ 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
+ 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=MemoryOperationSkipCode.INVALID_RANGES,
+ reason="Message ranges are malformed or out of bounds",
+ )
+ 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,
+ )
+ 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 == 2
+ assert event_resolution_attempts == 2
+ assert len(final_operations.upsert_operations) == 2
+ assert final_operations.upsert_operations[0].uris == [event_uri]
+ 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"]
+ ]
+ assert len(repair_messages) == 1
+ assert '"reason_code": "invalid_ranges"' in repair_messages[0]
+ assert '"event_name": "demo"' in repair_messages[0]
+
+ 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):
diff --git a/tests/unit/session/memory/test_page_id_map.py b/tests/unit/session/memory/test_page_id_map.py
index 6e19bf382..f83105740 100644
--- a/tests/unit/session/memory/test_page_id_map.py
+++ b/tests/unit/session/memory/test_page_id_map.py
@@ -57,3 +57,31 @@ class TestPageIdMap:
assert pim.get_page_id("viking://profile.md") == existing_id
assert pim.resolve(existing_id) == "viking://profile.md"
assert pim.resolve(100) == "viking://profile.md"
+
+ def test_response_allocator_normalizes_low_requested_id(self):
+ pim = PageIdMap()
+ pim.get_page_id("viking://user/a/memories/profile.md")
+ allocator = pim.new_page_id_allocator()
+
+ assert allocator.allocate(1) == 100
+
+ def test_response_allocator_preserves_available_new_id(self):
+ pim = PageIdMap()
+ allocator = pim.new_page_id_allocator()
+
+ assert allocator.allocate(105) == 105
+ assert allocator.allocate(105) == 100
+
+ def test_response_allocator_skips_registered_and_allocated_ids(self):
+ pim = PageIdMap()
+ pim.register_new_page_id("viking://new-item", 100)
+ allocator = pim.new_page_id_allocator()
+
+ assert allocator.allocate(None) == 101
+ assert allocator.allocate(None) == 102
+
+ def test_new_response_can_reuse_unregistered_page_id(self):
+ pim = PageIdMap()
+
+ assert pim.new_page_id_allocator().allocate(100) == 100
+ assert pim.new_page_id_allocator().allocate(100) == 100