Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
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.yamlindex 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: immutablediff --git a/openviking/session/memory/memory_isolation_handler.py b/openviking/session/memory/memory_isolation_handler.pyindex 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 Noneraw_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_idif 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 [], Falsetarget_ids = []+ has_message = False+ has_user_message = Falsefor 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 = Truetarget_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_fallbackdef _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.pyindex 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 Messagefrom openviking.message.part import TextPartfrom openviking.server.identity import RequestContext, Rolefrom openviking.session.memory.memory_isolation_handler import (MemoryIsolationHandler,)+from openviking.session.memory.memory_updater import ExtractContextfrom 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.pyindex 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",