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(session): release archive lock before task registration (#6175)
bot-of-qin-ctx7c34e43c5375
diff --git a/openviking/session/session.py b/openviking/session/session.pyindex e98ba5ceb..57fa420a8 100644--- a/openviking/session/session.py+++ b/openviking/session/session.py@@ -21,6 +21,7 @@ from openviking.core.peer_id import normalize_peer_id, safe_peer_idfrom openviking.message import Message, Partfrom openviking.message.part import TextPart, ToolPartfrom openviking.server.config import ToolOutputExternalizationConfig+from openviking.server.error_mapping import map_exceptionfrom openviking.server.identity import RequestContext, Rolefrom openviking.session import working_memory as wmfrom openviking.session.archive_store import (@@ -68,6 +69,7 @@ from openviking.utils.model_retry import is_retryable_api_error, retry_asyncfrom openviking.utils.time_utils import get_current_timestampfrom openviking.utils.token_estimation import estimate_text_tokensfrom openviking_cli.exceptions import (+ InternalError,NotFoundError,)from openviking_cli.session.user_id import UserIdentifier@@ -1652,15 +1654,6 @@ class Session:queue_msg.to_dict(),)- phase1_stage = "task_tracker_create"- await get_task_tracker().create(- "session_commit",- resource_id=self.session_id,- account_id=self.ctx.account_id,- user_id=self.ctx.user.user_id,- task_id=task_id,- )-phase1_stage = "phase1_persist"self._messages = retained_messagesawait self._write_to_agfs_async(messages=self._messages)@@ -1728,6 +1721,25 @@ class Session:self._compression.original_count += len(messages_to_archive)logger.info(f"Archived: {len(messages_to_archive)} messages → {archive_uri}/")+ # Registration must not hold the session lock or roll back published Phase 1.+ try:+ await get_task_tracker().create(+ "session_commit",+ resource_id=self.session_id,+ account_id=self.ctx.account_id,+ user_id=self.ctx.user.user_id,+ task_id=task_id,+ )+ except Exception as exc:+ error = map_exception(exc) or InternalError(str(exc))+ error.details.update(+ task_id=task_id,+ archive_uri=archive_uri,+ archived=True,+ stage="task_tracker_create",+ )+ raise error+return {"session_id": self.session_id,"status": "accepted",diff --git a/openviking/storage/queuefs/session_commit_processor.py b/openviking/storage/queuefs/session_commit_processor.pyindex 98320bc82..7d42519b7 100644--- a/openviking/storage/queuefs/session_commit_processor.py+++ b/openviking/storage/queuefs/session_commit_processor.py@@ -68,13 +68,6 @@ class SessionCommitProcessor(DequeueHandlerBase):if not await session.exists():error = f"Session '{msg.session_id}' no longer exists"tracker = get_task_tracker()- await tracker.create(- "session_commit",- resource_id=msg.session_id,- account_id=ctx.account_id,- user_id=ctx.user.user_id,- task_id=msg.task_id,- )await tracker.fail(msg.task_id,error,@@ -124,6 +117,14 @@ class SessionCommitProcessor(DequeueHandlerBase):msg, ctx = self._parse_message(data)except (json.JSONDecodeError, KeyError, TypeError, ValueError) as exc:return ProcessResult.failed(str(exc))+ # Failed registration must retain queue work; processing errors remain terminal.+ await get_task_tracker().create(+ "session_commit",+ resource_id=msg.session_id,+ account_id=ctx.account_id,+ user_id=ctx.user.user_id,+ task_id=msg.task_id,+ )with bind_task_context_from_message(data):try:processed = await self._process(msg, ctx)diff --git a/tests/session/test_session_retention_integration.py b/tests/session/test_session_retention_integration.pyindex ec0af852b..93cfc37b6 100644--- a/tests/session/test_session_retention_integration.py+++ b/tests/session/test_session_retention_integration.py@@ -11,7 +11,9 @@ import pytestfrom openviking.message import Message, TextPart, ToolPartfrom openviking.models.vlm.base import ToolCall, VLMResponse-from openviking.service.task_tracker import get_task_tracker+from openviking.pyagfs.exceptions import AGFSIoError+from openviking.service.task_store import PersistentTaskStore+from openviking.service.task_tracker import TaskTracker, get_task_trackerfrom openviking.session import working_memory as wmfrom openviking.session.checkpoints import (CheckpointPlanner,@@ -20,7 +22,10 @@ from openviking.session.checkpoints import (CheckpointRequest as _CheckpointRequest,)from openviking.session.memory.constants import AGENT_EVOLUTION_MEMORY_TYPES-from openviking.session.session import _ArchiveSummaryResult+from openviking.session.session import Session, _ArchiveSummaryResult+from openviking.storage.viking_fs import VikingFS+from openviking_cli.exceptions import UnavailableError+from tests.utils.mock_agfs import MockLocalAGFSasync def _write_archive(@@ -1803,41 +1808,37 @@ async def test_phase1_root_rewrite_failure_marks_orphan_archive_failed(assert [message["parts"][0]["text"] for message in context["messages"]] == ["retained tail"]-async def test_phase1_enqueues_before_root_rewrite_and_publishes_ready_last(- client,- monkeypatch,-):- session = client(session_id="phase1_publish_order_test")+async def test_phase1_publishes_and_unlocks_before_task_registration(tmp_path, monkeypatch):+ fs = VikingFS(agfs=MockLocalAGFS(root_path=tmp_path))+ tracker = TaskTracker(PersistentTaskStore(fs.agfs))+ monkeypatch.setattr("openviking.service.task_tracker.get_task_tracker", lambda: tracker)+ monkeypatch.setattr("openviking.session.session._enabled_memory_types", lambda: set())+ session = Session(viking_fs=fs, session_id="phase1_publish_order_test")await session.ensure_exists()- session.add_message("user", [TextPart("archive me")])- observations: list[tuple[list[str], str]] = []+ await session.add_message_async("user", [TextPart("archive me")])- class InspectingQueueManager:- async def enqueue(self, _queue_name, data):- root = await session._read_live_messages_strict()- archive_uri = data["archive_uri"]- observations.append(- (- [message.content for message in root],- (await session._read_phase1_meta(archive_uri)).get("status", ""),- )- )+ async def enqueue(_queue_name, data):+ assert len(await session._read_live_messages_strict()) == 1+ assert (await session._read_phase1_meta(data["archive_uri"]))["status"] == "preparing"+ async def create_task(task, *, reject_if_active=False):+ lease = await fs._async_agfs.pathlock_acquire_tree(+ fs._uri_to_path(session.uri, ctx=session.ctx)+ )+ await fs._async_agfs.pathlock_release(lease)+ raise AGFSIoError("task store unavailable")++ monkeypatch.setattr(tracker._store, "create", create_task)monkeypatch.setattr(- "openviking.storage.queuefs.get_queue_manager",- lambda: InspectingQueueManager(),+ "openviking.storage.queuefs.get_queue_manager", lambda: SimpleNamespace(enqueue=enqueue))-- result = await session.commit_async()- session.add_message("user", [TextPart("wait for predecessor")])- second = await session.commit_async()- assert observations == [- (["archive me"], "preparing"),- (["wait for predecessor"], "preparing"),- ]- assert (await session._read_phase1_meta(result["archive_uri"]))["status"] == "ready"- assert (await session._read_phase1_meta(second["archive_uri"]))["status"] == "ready"+ with pytest.raises(UnavailableError, match="task store unavailable") as error:+ await session.commit_async()+ archive_uri = error.value.details["archive_uri"]+ assert error.value.details["archived"] is True+ assert (await session._read_phase1_meta(archive_uri))["status"] == "ready"assert await session._read_live_messages_strict() == []+ assert not await fs.exists(f"{archive_uri}/.failed.json", ctx=session.ctx)async def test_interrupted_phase1_recovers_when_root_rewrite_is_durable(diff --git a/tests/storage/test_session_commit_processor_identity.py b/tests/storage/test_session_commit_processor_identity.pyindex 5c184413b..cf60c99ad 100644--- a/tests/storage/test_session_commit_processor_identity.py+++ b/tests/storage/test_session_commit_processor_identity.py@@ -9,6 +9,10 @@ worker binds the committing account/user (so tokens are not attributed to"""import json+from types import SimpleNamespace+from unittest.mock import AsyncMock, Mock++import pytestfrom openviking.observability.context import get_root_observability_contextfrom openviking.server.identity import RequestContext, Role@@ -37,15 +41,6 @@ class _FakeSession:return self._processed-class _FakeSessionService:- def __init__(self, captured: dict, processed: bool = True) -> None:- self._captured = captured- self._processed = processed-- def session(self, ctx, session_id, session_uri=None):- return _FakeSession(self._captured, self._processed)--class _MemoryVikingFS:def __init__(self) -> None:self.files: dict[str, str] = {}@@ -57,14 +52,6 @@ class _MemoryVikingFS:self.files[uri] = content-class _SingleSessionService:- def __init__(self, session: Session) -> None:- self._session = session-- def session(self, ctx, session_id, session_uri=None):- return self._session--def _make_msg() -> SessionCommitMsg:return SessionCommitMsg(task_id="task-1",@@ -75,18 +62,26 @@ def _make_msg() -> SessionCommitMsg:)-async def test_process_binds_committing_identity_to_root_context():+async def test_process_binds_committing_identity_to_root_context(monkeypatch):captured: dict = {}- processor = SessionCommitProcessor(- _FakeSessionService(captured),+ session = _FakeSession(captured)+ processor = SessionCommitProcessor(SimpleNamespace(session=Mock(return_value=session)))+ tracker = SimpleNamespace(create=AsyncMock(side_effect=OSError("store unavailable")))+ monkeypatch.setattr(+ "openviking.storage.queuefs.session_commit_processor.get_task_tracker", lambda: tracker)- ctx = RequestContext(user=UserIdentifier("acme", "alice"), role=Role.USER)-- result = await processor._process(_make_msg(), ctx)-- assert result is True- assert captured["account_id"] == "acme"- assert captured["user_id"] == "alice"+ message = {"data": _make_msg().to_dict()}+ with pytest.raises(OSError, match="store unavailable"):+ await processor.on_dequeue(message)+ tracker.create.side_effect = None+ session.load = AsyncMock(side_effect=ValueError("invalid session message"))+ result = await processor.on_dequeue(message)+ assert result.outcome is ProcessOutcome.FAILED+ assert result.error == "invalid session message"+ session.load.side_effect = None+ assert (await processor.on_dequeue(message)).outcome is ProcessOutcome.SUCCESS+ assert captured == {"account_id": "acme", "user_id": "alice"}+ assert get_root_observability_context() is Noneasync def test_process_requeues_deferred_commit_and_resets_root_context(monkeypatch):@@ -97,7 +92,7 @@ async def test_process_requeues_deferred_commit_and_resets_root_context(monkeypaqueued.append((queue_name, data))processor = SessionCommitProcessor(- _FakeSessionService({}, processed=False),+ SimpleNamespace(session=Mock(return_value=_FakeSession({}, processed=False))),)monkeypatch.setattr("openviking.storage.queuefs.get_queue_manager",@@ -121,15 +116,13 @@ async def test_cancelled_queued_commit_writes_terminal_marker_before_returning()session_uri=msg.session_uri,)processor = SessionCommitProcessor(- _SingleSessionService(session),+ SimpleNamespace(session=Mock(return_value=session)),)marker_uri = f"{msg.archive_uri}/.failed.json"result = await processor.on_cancelled({"data": json.dumps(msg.to_dict())})assert result.outcome is ProcessOutcome.CANCELLED- assert result.value is None- assert result.error is Nonemarker = json.loads(viking_fs.files[marker_uri])assert marker["stage"] == "cancelled"assert marker["error"] == "session commit cancelled"