Skip to content

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

fix(session): release archive lock before task registration (#6175)

bot-of-qin-ctx7c34e43c5375
diff --git a/openviking/session/session.py b/openviking/session/session.py
index 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_id
from openviking.message import Message, Part
from openviking.message.part import TextPart, ToolPart
from openviking.server.config import ToolOutputExternalizationConfig
+from openviking.server.error_mapping import map_exception
from openviking.server.identity import RequestContext, Role
from openviking.session import working_memory as wm
from openviking.session.archive_store import (
@@ -68,6 +69,7 @@ from openviking.utils.model_retry import is_retryable_api_error, retry_async
from openviking.utils.time_utils import get_current_timestamp
from openviking.utils.token_estimation import estimate_text_tokens
from 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_messages
await 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.py
index 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.py
index ec0af852b..93cfc37b6 100644
--- a/tests/session/test_session_retention_integration.py
+++ b/tests/session/test_session_retention_integration.py
@@ -11,7 +11,9 @@ import pytest
from openviking.message import Message, TextPart, ToolPart
from 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_tracker
from openviking.session import working_memory as wm
from 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 MockLocalAGFS
async 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.py
index 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 pytest
from openviking.observability.context import get_root_observability_context
from 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 None
async 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(monkeypa
queued.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 None
marker = json.loads(viking_fs.files[marker_uri])
assert marker["stage"] == "cancelled"
assert marker["error"] == "session commit cancelled"