Skip to content

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

fix(memory): preserve owner for assistant-only event ranges (#4001)

Kcheneeff5a497360
diff --git a/openviking/prompts/templates/memory/events.yaml b/openviking/prompts/templates/memory/events.yaml
index f1879edd2..b49cc81cc 100644
--- a/openviking/prompts/templates/memory/events.yaml
+++ b/openviking/prompts/templates/memory/events.yaml
@@ -146,4 +146,7 @@ fields:
- Range: "start-end" (e.g., "0-3" means messages 0 to 3)
- Single index: "N" (e.g., "7" means only message 7)
- Mixed: "0-3,7,15-20" (ranges and single indices combined)
+ For events, ranges MUST include at least one user-role message that states or supports the event.
+ If an assistant message confirms, normalizes, or completes the event, include both the originating user message and the assistant message.
+ Never output assistant-only ranges for events.
merge_op: immutable
diff --git a/openviking/session/memory/memory_isolation_handler.py b/openviking/session/memory/memory_isolation_handler.py
index f9f4fe1bb..d7ffd2392 100644
--- a/openviking/session/memory/memory_isolation_handler.py
+++ b/openviking/session/memory/memory_isolation_handler.py
@@ -69,9 +69,11 @@ class MemoryIsolationHandler:
return messages if isinstance(messages, list) else []
def _message_target_id(self, msg: Any) -> Optional[str]:
+ if not self._is_peer_owner_message(msg):
+ return None
raw_peer_id = getattr(msg, "peer_id", None)
peer_id = safe_peer_id(raw_peer_id)
- if peer_id and self._is_peer_owner_message(msg) and self._can_write_peer(peer_id):
+ if peer_id and self._can_write_peer(peer_id):
return peer_id
if raw_peer_id in (None, "") and self.allow_self:
return _SELF_PEER_ID
@@ -143,6 +145,37 @@ class MemoryIsolationHandler:
peer_ids = list(dict.fromkeys(targets))
return peer_ids[0] if len(peer_ids) == 1 else None
+ def _unique_target_id_in_messages(self) -> Optional[str]:
+ targets = [
+ target_id for msg in self._messages() if (target_id := self._message_target_id(msg))
+ ]
+ target_ids = list(dict.fromkeys(targets))
+ return target_ids[0] if len(target_ids) == 1 else None
+
+ def _range_is_fully_in_bounds(self, ranges: Any) -> bool:
+ parts = str(ranges).split(",")
+ if not parts or any(not part.strip() for part in parts):
+ return False
+
+ message_count = len(self._messages())
+ if message_count == 0:
+ return False
+
+ try:
+ for part in parts:
+ bounds = part.strip().split("-")
+ if len(bounds) == 1:
+ start = end = int(bounds[0])
+ elif len(bounds) == 2 and all(bound.strip() for bound in bounds):
+ start, end = (int(bound) for bound in bounds)
+ else:
+ return False
+ if start < 0 or start > end or end >= message_count:
+ return False
+ except ValueError:
+ return False
+ return True
+
def render_schema_directories(self, memory_type_schema: MemoryTypeSchema) -> List[str]:
user_id = self.ctx.user.user_id if self.ctx and self.ctx.user else "default"
user_space = user_id
@@ -164,22 +197,29 @@ class MemoryIsolationHandler:
)
return directories
- def _range_targets(self, ranges: Any) -> List[str]:
+ def _range_targets(self, ranges: Any) -> tuple[List[str], bool]:
if not ranges or not self._extract_context:
- return []
+ return [], False
+ range_is_fully_in_bounds = self._range_is_fully_in_bounds(ranges)
try:
msg_range = self._extract_context.read_message_ranges(str(ranges))
except Exception:
logger.warning("Failed to parse memory ranges for peer memory: %s", ranges)
- return []
+ return [], False
target_ids = []
+ has_message = False
+ has_user_message = False
for msg_group in getattr(msg_range, "elements", []) or []:
for msg in msg_group:
+ has_message = True
+ if self._is_peer_owner_message(msg):
+ has_user_message = True
target_id = self._message_target_id(msg)
if target_id:
target_ids.append(target_id)
- return list(dict.fromkeys(target_ids))
+ can_fallback = range_is_fully_in_bounds and has_message and not has_user_message
+ return list(dict.fromkeys(target_ids)), can_fallback
def _resolve_operation_target_id(self, raw_peer_id: Any) -> Optional[str]:
peer_id = safe_peer_id(raw_peer_id)
@@ -214,9 +254,13 @@ class MemoryIsolationHandler:
operation.memory_fields.pop("peer_id", None)
target_ids = [_SELF_PEER_ID] if self.allow_self else []
elif operation.memory_fields.get("ranges") is not None:
- target_ids = self._range_targets(
+ target_ids, can_fallback = self._range_targets(
operation.memory_fields.get("ranges"),
)
+ if not target_ids and can_fallback:
+ fallback_target = self._unique_target_id_in_messages()
+ if fallback_target:
+ target_ids = [fallback_target]
operation.memory_fields.pop("peer_id", None)
else:
target_id = self._resolve_operation_target_id(
diff --git a/tests/session/memory/test_memory_isolation_handler.py b/tests/session/memory/test_memory_isolation_handler.py
index 21ccdc3aa..1ec666af8 100644
--- a/tests/session/memory/test_memory_isolation_handler.py
+++ b/tests/session/memory/test_memory_isolation_handler.py
@@ -6,12 +6,15 @@ Tests for MemoryIsolationHandler.
from unittest.mock import MagicMock, patch
+import pytest
+
from openviking.message.message import Message
from openviking.message.part import TextPart
from openviking.server.identity import RequestContext, Role
from openviking.session.memory.memory_isolation_handler import (
MemoryIsolationHandler,
)
+from openviking.session.memory.memory_updater import ExtractContext
from openviking_cli.session.user_id import UserIdentifier
@@ -543,6 +546,301 @@ class TestCalculateMemoryUris:
assert operation.memory_fields["user_id"] == "support_bot"
assert "peer_id" not in operation.memory_fields
+ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
+ def test_ranges_without_user_fall_back_to_unique_user_peer(self, mock_generate_uri):
+ mock_generate_uri.side_effect = lambda **kwargs: (
+ f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
+ )
+
+ ctx = create_ctx(user_id="support_bot")
+ messages = [
+ create_message("user", "peer event", peer_id="peer-a"),
+ create_message("assistant", "processed", peer_id="peer-a"),
+ ]
+ extract_ctx = create_mock_extract_context(messages)
+ mock_range = MagicMock()
+ mock_range.elements = [[messages[1]]]
+ extract_ctx.read_message_ranges.return_value = mock_range
+ handler = MemoryIsolationHandler(
+ ctx,
+ extract_ctx,
+ allow_self=False,
+ allowed_peer_ids={"peer-a"},
+ )
+
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ schema = MemoryTypeSchema(
+ memory_type="events",
+ filename_template="demo.md",
+ directory="viking://user/{user_space}/memories/events",
+ )
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"event_name": "demo", "ranges": "1-1"},
+ memory_type="events",
+ uris=[],
+ )
+
+ uris = handler.calculate_memory_uris(schema, operation, extract_ctx)
+
+ assert uris == ["viking://user/support_bot/peers/peer-a/memories/events/demo"]
+ assert "peer_id" not in operation.memory_fields
+
+ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
+ def test_ranges_without_user_fall_back_to_unique_self(self, mock_generate_uri):
+ mock_generate_uri.side_effect = lambda **kwargs: (
+ f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
+ )
+
+ ctx = create_ctx(user_id="support_bot")
+ messages = [
+ create_message("user", "self event"),
+ create_message("assistant", "processed", peer_id="assistant-peer"),
+ ]
+ extract_ctx = create_mock_extract_context(messages)
+ mock_range = MagicMock()
+ mock_range.elements = [[messages[1]]]
+ extract_ctx.read_message_ranges.return_value = mock_range
+ handler = MemoryIsolationHandler(
+ ctx,
+ extract_ctx,
+ allow_self=True,
+ allowed_peer_ids={"assistant-peer"},
+ )
+
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ schema = MemoryTypeSchema(
+ memory_type="events",
+ filename_template="demo.md",
+ directory="viking://user/{user_space}/memories/events",
+ )
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"event_name": "demo", "ranges": "1-1"},
+ memory_type="events",
+ uris=[],
+ )
+
+ uris = handler.calculate_memory_uris(schema, operation, extract_ctx)
+
+ assert uris == ["viking://user/support_bot/memories/events/demo"]
+ assert "peer_id" not in operation.memory_fields
+
+ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
+ def test_ranges_with_unowned_assistant_fall_back_to_unique_user_peer(self, mock_generate_uri):
+ mock_generate_uri.side_effect = lambda **kwargs: (
+ f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
+ )
+
+ ctx = create_ctx(user_id="support_bot")
+ messages = [
+ create_message("user", "peer event", peer_id="peer-a"),
+ create_message("assistant", "processed"),
+ ]
+ extract_ctx = create_mock_extract_context(messages)
+ mock_range = MagicMock()
+ mock_range.elements = [[messages[1]]]
+ extract_ctx.read_message_ranges.return_value = mock_range
+ handler = MemoryIsolationHandler(
+ ctx,
+ extract_ctx,
+ allow_self=True,
+ allowed_peer_ids={"peer-a"},
+ )
+
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ schema = MemoryTypeSchema(
+ memory_type="events",
+ filename_template="demo.md",
+ directory="viking://user/{user_space}/memories/events",
+ )
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"event_name": "demo", "ranges": "1-1"},
+ memory_type="events",
+ uris=[],
+ )
+
+ uris = handler.calculate_memory_uris(schema, operation, extract_ctx)
+
+ assert uris == ["viking://user/support_bot/peers/peer-a/memories/events/demo"]
+ assert "peer_id" not in operation.memory_fields
+
+ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
+ def test_ranges_without_user_do_not_fallback_to_ambiguous_users(self, mock_generate_uri):
+ mock_generate_uri.side_effect = lambda **kwargs: (
+ f"viking://user/{kwargs.get('user_space')}/memories/events/demo"
+ )
+
+ ctx = create_ctx(user_id="support_bot")
+ messages = [
+ create_message("user", "event a", peer_id="peer-a"),
+ create_message("user", "event b", peer_id="peer-b"),
+ create_message("assistant", "processed", peer_id="peer-a"),
+ ]
+ extract_ctx = create_mock_extract_context(messages)
+ mock_range = MagicMock()
+ mock_range.elements = [[messages[2]]]
+ extract_ctx.read_message_ranges.return_value = mock_range
+ handler = MemoryIsolationHandler(
+ ctx,
+ extract_ctx,
+ allow_self=False,
+ allowed_peer_ids={"peer-a", "peer-b"},
+ )
+
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ schema = MemoryTypeSchema(
+ memory_type="events",
+ filename_template="demo.md",
+ directory="viking://user/{user_space}/memories/events",
+ )
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"event_name": "demo", "ranges": "2-2"},
+ memory_type="events",
+ uris=[],
+ )
+
+ assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
+ mock_generate_uri.assert_not_called()
+
+ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
+ def test_ranges_without_user_ignore_assistant_only_peer(self, mock_generate_uri):
+ ctx = create_ctx(user_id="support_bot")
+ messages = [create_message("assistant", "processed", peer_id="peer-a")]
+ extract_ctx = create_mock_extract_context(messages)
+ mock_range = MagicMock()
+ mock_range.elements = [messages]
+ extract_ctx.read_message_ranges.return_value = mock_range
+ handler = MemoryIsolationHandler(
+ ctx,
+ extract_ctx,
+ allow_self=False,
+ allowed_peer_ids={"peer-a"},
+ )
+
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ schema = MemoryTypeSchema(
+ memory_type="events",
+ filename_template="demo.md",
+ directory="viking://user/{user_space}/memories/events",
+ )
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"event_name": "demo", "ranges": "0-0"},
+ memory_type="events",
+ uris=[],
+ )
+
+ assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
+ mock_generate_uri.assert_not_called()
+
+ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
+ def test_unallowed_range_user_does_not_fallback_to_another_user(self, mock_generate_uri):
+ ctx = create_ctx(user_id="support_bot")
+ messages = [
+ create_message("user", "allowed event", peer_id="peer-a"),
+ create_message("user", "denied event", peer_id="peer-b"),
+ ]
+ extract_ctx = create_mock_extract_context(messages)
+ mock_range = MagicMock()
+ mock_range.elements = [[messages[1]]]
+ extract_ctx.read_message_ranges.return_value = mock_range
+ handler = MemoryIsolationHandler(
+ ctx,
+ extract_ctx,
+ allow_self=False,
+ allowed_peer_ids={"peer-a"},
+ )
+
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ schema = MemoryTypeSchema(
+ memory_type="events",
+ filename_template="demo.md",
+ directory="viking://user/{user_space}/memories/events",
+ )
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"event_name": "demo", "ranges": "1-1"},
+ memory_type="events",
+ uris=[],
+ )
+
+ assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
+ mock_generate_uri.assert_not_called()
+
+ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
+ def test_invalid_ranges_do_not_fallback_to_all_messages(self, mock_generate_uri):
+ ctx = create_ctx(user_id="support_bot")
+ messages = [create_message("user", "peer event", peer_id="peer-a")]
+ extract_ctx = create_mock_extract_context(messages)
+ extract_ctx.read_message_ranges.side_effect = ValueError("invalid ranges")
+ handler = MemoryIsolationHandler(
+ ctx,
+ extract_ctx,
+ allow_self=False,
+ allowed_peer_ids={"peer-a"},
+ )
+
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ schema = MemoryTypeSchema(
+ memory_type="events",
+ filename_template="demo.md",
+ directory="viking://user/{user_space}/memories/events",
+ )
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"event_name": "demo", "ranges": "invalid"},
+ memory_type="events",
+ uris=[],
+ )
+
+ assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
+ mock_generate_uri.assert_not_called()
+
+ @pytest.mark.parametrize("ranges", ["99", "0,99", " , "])
+ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")
+ def test_invalid_real_ranges_do_not_fallback_to_conversation_owner(
+ self, mock_generate_uri, ranges
+ ):
+ ctx = create_ctx(user_id="support_bot")
+ messages = [
+ create_message("assistant", "processed", peer_id="peer-a"),
+ create_message("user", "peer event", peer_id="peer-a"),
+ ]
+ extract_ctx = ExtractContext(messages, split_long_text_messages=False)
+ handler = MemoryIsolationHandler(
+ ctx,
+ extract_ctx,
+ allow_self=False,
+ allowed_peer_ids={"peer-a"},
+ )
+
+ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation
+
+ schema = MemoryTypeSchema(
+ memory_type="events",
+ filename_template="demo.md",
+ directory="viking://user/{user_space}/memories/events",
+ )
+ operation = ResolvedOperation(
+ old_memory_file_content=None,
+ memory_fields={"event_name": "demo", "ranges": ranges},
+ memory_type="events",
+ uris=[],
+ )
+
+ assert handler.calculate_memory_uris(schema, operation, extract_ctx) == []
+ mock_generate_uri.assert_not_called()
+
@patch("openviking.session.memory.memory_isolation_handler.generate_uri")
def test_calculate_memory_uris_unallowed_peer_id_does_not_fallback(self, mock_generate_uri):
mock_generate_uri.side_effect = lambda **kwargs: (
diff --git a/tests/session/memory/test_schema_models.py b/tests/session/memory/test_schema_models.py
index 5fc694d48..a96f4f092 100644
--- a/tests/session/memory/test_schema_models.py
+++ b/tests/session/memory/test_schema_models.py
@@ -143,6 +143,16 @@ class TestSchemaModelGenerator:
assert "First test field" in model.model_fields["field1"].description
+ def test_events_ranges_description_requires_user_source(self, real_registry):
+ events = real_registry.get("events")
+ model = SchemaModelGenerator([events]).create_flat_data_model(events)
+
+ description = model.model_fields["ranges"].description
+
+ assert "MUST include at least one user-role message" in description
+ assert "include both the originating user message and the assistant message" in description
+ assert "Never output assistant-only ranges for events" in description
+
def test_render_description_template_conditional_branch(self):
memory_type = MemoryTypeSchema(
memory_type="conditional",