Skip to content

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

fix(session): serialize initialization with message writes (#5978)

bot-of-qin-ctxf7973249740a
diff --git a/openviking/session/session.py b/openviking/session/session.py
index 2ab01e8f3..084115951 100644
--- a/openviking/session/session.py
+++ b/openviking/session/session.py
@@ -615,15 +615,23 @@ class Session:
async def ensure_exists(self) -> None:
"""Materialize session root and messages file if missing."""
- if await self.exists():
- return
- await self._viking_fs.mkdir(self._session_uri, exist_ok=True, ctx=self.ctx)
- await self._viking_fs.write_file(
- f"{self._session_uri}/messages.jsonl",
- "",
- ctx=self.ctx,
+ # Initial state must not overwrite a concurrent append or commit.
+ session_path = self._viking_fs._uri_to_path(self._session_uri, ctx=self.ctx)
+ lease = await self._viking_fs._async_agfs.pathlock_acquire_exact(
+ session_path, timeout_secs=_SESSION_PHASE1_LOCK_TIMEOUT_SECONDS
)
- await self._save_meta()
+ try:
+ if await self.exists():
+ return
+ await self._viking_fs.mkdir(self._session_uri, exist_ok=True, ctx=self.ctx)
+ await self._viking_fs.write_file(
+ f"{self._session_uri}/messages.jsonl",
+ "",
+ ctx=self.ctx,
+ )
+ await self._save_meta()
+ finally:
+ await self._viking_fs._async_agfs.pathlock_release(lease)
async def _save_meta(self, lease_ref: Optional[Any] = None) -> None:
"""Persist .meta.json to storage using an optional held PathLock lease."""
diff --git a/tests/server/test_api_sessions.py b/tests/server/test_api_sessions.py
index 9226df929..1240aef32 100644
--- a/tests/server/test_api_sessions.py
+++ b/tests/server/test_api_sessions.py
@@ -581,32 +581,63 @@ async def test_direct_session_add_message_records_last_message_at(service):
assert session.meta.last_message_at
-async def test_add_message_records_last_message_at_with_single_meta_save(
+async def test_session_initialization_preserves_concurrent_message(
client: httpx.AsyncClient,
+ service,
monkeypatch,
):
- create_resp = await client.post("/api/v1/sessions", json={})
- session_id = create_resp.json()["result"]["session_id"]
- save_session_ids = []
- original_save_meta = Session._save_meta
-
- async def counting_save_meta(self, *args, **kwargs):
- save_session_ids.append(self.session_id)
- await original_save_meta(self, *args, **kwargs)
-
- monkeypatch.setattr(Session, "_save_meta", counting_save_meta)
-
- resp = await client.post(
- f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Hello, world!"},
- )
- assert resp.status_code == 200
-
- assert save_session_ids == [session_id]
-
- session_resp = await client.get(f"/api/v1/sessions/{session_id}")
- assert session_resp.status_code == 200
- assert session_resp.json()["result"]["last_message_at"]
+ session_id = "concurrent-initialization"
+ ctx = RequestContext(user=DEFAULT_USER, role=Role(Role.ROOT))
+ session_uri = f"viking://user/default/sessions/{session_id}"
+ initial_meta_ready = asyncio.Event()
+ finish_initialization = asyncio.Event()
+ append_started = asyncio.Event()
+ original_write = service.viking_fs.write_file
+ original_append = Session._append_messages_authoritatively
+
+ async def pause_initial_meta(uri, content, **kwargs):
+ if uri == f"{session_uri}/.meta.json" and not json.loads(content)["message_count"]:
+ initial_meta_ready.set()
+ await finish_initialization.wait()
+ return await original_write(uri, content, **kwargs)
+
+ async def append(self, messages):
+ if self.session_id == session_id:
+ append_started.set()
+ return await original_append(self, messages)
+
+ monkeypatch.setattr(service.viking_fs, "write_file", pause_initial_meta)
+ monkeypatch.setattr(Session, "_append_messages_authoritatively", append)
+ create_task = asyncio.create_task(
+ client.post("/api/v1/sessions", json={"session_id": session_id})
+ )
+ message_task = None
+ try:
+ await asyncio.wait_for(initial_meta_ready.wait(), timeout=5)
+ message_task = asyncio.create_task(
+ client.post(
+ f"/api/v1/sessions/{session_id}/messages",
+ json={"role": "user", "content": "message during initialization"},
+ )
+ )
+ await asyncio.wait_for(append_started.wait(), timeout=5)
+ # Without the session lock the append finishes before the initial meta
+ # overwrites it. With the lock it waits for initialization to finish.
+ await asyncio.wait({message_task}, timeout=1)
+ finally:
+ finish_initialization.set()
+ tasks = [task for task in (create_task, message_task) if task is not None]
+ responses = await asyncio.wait_for(asyncio.gather(*tasks), timeout=5)
+
+ assert all(response.status_code == 200 for response in responses)
+ meta = json.loads(await service.viking_fs.read_file(f"{session_uri}/.meta.json", ctx=ctx))
+ messages = await service.viking_fs.read_file(f"{session_uri}/messages.jsonl", ctx=ctx)
+ assert [json.loads(line)["parts"][0]["text"] for line in messages.splitlines()] == [
+ "message during initialization"
+ ]
+ assert meta["message_count"] == 1
+ assert meta["pending_tokens"] > 0
+ assert meta["last_message_at"]
async def test_add_message_ignores_extra_metadata_fields(client: httpx.AsyncClient):