Skip to content

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

fix(kernel): stop conflating storage failures with not-found (#3417)

Zayn Jarvis2c80d44349dc
diff --git a/openviking/core/directories.py b/openviking/core/directories.py
index faa132ba2..03496da64 100644
--- a/openviking/core/directories.py
+++ b/openviking/core/directories.py
@@ -24,6 +24,8 @@ if TYPE_CHECKING:
from openviking.storage import VikingDBManager
from openviking.storage.viking_fs import VikingFS
+from openviking_cli.exceptions import NotFoundError
+
@dataclass
class DirectoryDefinition:
@@ -308,7 +310,7 @@ class DirectoryInitializer:
viking_fs = self._get_viking_fs()
await viking_fs.abstract(uri, ctx=ctx)
return True
- except Exception:
+ except (FileNotFoundError, NotFoundError):
return False
async def _initialize_children(
diff --git a/openviking/service/task_store.py b/openviking/service/task_store.py
index d2312b62d..e2aea069e 100644
--- a/openviking/service/task_store.py
+++ b/openviking/service/task_store.py
@@ -9,7 +9,7 @@ from copy import deepcopy
from typing import Any, Dict, List, Optional, Protocol
from openviking.pyagfs import AsyncAGFSClient
-from openviking.pyagfs.exceptions import AGFSAlreadyExistsError
+from openviking.pyagfs.exceptions import AGFSAlreadyExistsError, AGFSNotFoundError
SYSTEM_TASK_ACCOUNT_ID = "_system"
SYSTEM_TASK_USER_ID = "root"
@@ -65,7 +65,7 @@ class PersistentTaskStore:
path = self._task_path(account_id, user_id, task_id)
try:
raw = await self._agfs.read(path)
- except Exception:
+ except (AGFSNotFoundError, FileNotFoundError):
return None
return json.loads(_decode_bytes(raw))
@@ -75,7 +75,7 @@ class PersistentTaskStore:
directory = self._task_dir(account_id, user_id)
try:
items = await self._agfs.ls(directory)
- except Exception:
+ except (AGFSNotFoundError, FileNotFoundError):
return []
tasks: List[Dict[str, Any]] = []
for item in items:
@@ -84,9 +84,9 @@ class PersistentTaskStore:
continue
try:
raw = await self._agfs.read(path)
- tasks.append(json.loads(_decode_bytes(raw)))
- except Exception:
+ except (AGFSNotFoundError, FileNotFoundError):
continue
+ tasks.append(json.loads(_decode_bytes(raw)))
return tasks
async def delete(self, task_id: str, *, account_id: str, user_id: Optional[str] = None) -> None:
diff --git a/openviking/session/session.py b/openviking/session/session.py
index 51f0f8c30..63ea40fac 100644
--- a/openviking/session/session.py
+++ b/openviking/session/session.py
@@ -17,6 +17,7 @@ from openviking.core.namespace import canonical_session_uri
from openviking.core.peer_id import normalize_peer_id, safe_peer_id
from openviking.message import Message, Part
from openviking.message.part import ContextPart, TextPart, ToolPart
+from openviking.pyagfs.exceptions import AGFSClientError, AGFSHTTPError, AGFSNotFoundError
from openviking.server.config import ToolOutputExternalizationConfig
from openviking.server.identity import RequestContext, Role
from openviking.session.memory.constants import EXECUTION_MEMORY_TYPES
@@ -45,7 +46,7 @@ from openviking.telemetry.request_wait_tracker import get_request_wait_tracker
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, truncate_text_to_token_budget
-from openviking_cli.exceptions import FailedPreconditionError
+from openviking_cli.exceptions import FailedPreconditionError, NotFoundError
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils import get_logger, run_async
from openviking_cli.utils.config import get_openviking_config
@@ -68,6 +69,21 @@ _SESSION_PHASE1_LOCK_TIMEOUT_SECONDS = 30.0
_MEMORY_STEP_NAMES = ("long_term", "execution")
+class _ArchiveMessagesCorruptError(ValueError):
+ """Raised when an archive messages file cannot be deserialized."""
+
+
+def _is_storage_not_found(exc: BaseException) -> bool:
+ if isinstance(exc, AGFSClientError):
+ return isinstance(exc, AGFSNotFoundError) or (
+ isinstance(exc, AGFSHTTPError) and exc.status_code == 404
+ )
+ if isinstance(exc, (FileNotFoundError, NotFoundError)):
+ nested = exc.__cause__ or exc.__context__
+ return nested is None or _is_storage_not_found(nested)
+ return False
+
+
def _wm_debug(msg: str) -> None:
"""Log a WM v2 debug message via the standard logger."""
logger.debug("wm_v2: %s", msg)
@@ -529,7 +545,9 @@ class Session:
if line.strip()
]
logger.info(f"Session loaded: {self.session_id} ({len(self._messages)} messages)")
- except (FileNotFoundError, Exception):
+ except Exception as exc:
+ if not _is_storage_not_found(exc):
+ raise
logger.debug(f"Session {self.session_id} not found, starting fresh")
# Restore compression_index (scan history directory)
@@ -543,8 +561,9 @@ class Session:
self._compression.compression_index = max_index
self._stats.compression_count = len(archives)
logger.debug(f"Restored compression_index: {max_index}")
- except Exception:
- pass
+ except Exception as exc:
+ if not _is_storage_not_found(exc):
+ raise
# Load .meta.json
try:
@@ -552,7 +571,9 @@ class Session:
f"{self._session_uri}/.meta.json", ctx=self.ctx
)
self._meta = SessionMeta.from_dict(json.loads(meta_content))
- except Exception:
+ except Exception as exc:
+ if not _is_storage_not_found(exc):
+ raise
# Old session without meta — derive from existing data
self._meta.message_count = len(self._messages)
self._meta.commit_count = self._compression.compression_index
@@ -613,7 +634,9 @@ class Session:
try:
await self._viking_fs.stat(self._session_uri, ctx=self.ctx)
return True
- except Exception:
+ except Exception as exc:
+ if not _is_storage_not_found(exc):
+ raise
return False
async def ensure_exists(self) -> None:
@@ -1906,8 +1929,9 @@ class Session:
try:
await self._viking_fs.read_file(f"{msg.archive_uri}/.done", ctx=self.ctx)
- except Exception:
- pass
+ except Exception as exc:
+ if not _is_storage_not_found(exc):
+ raise
else:
if task.status.value == "completed":
return
@@ -1923,8 +1947,9 @@ class Session:
failed = json.loads(
await self._viking_fs.read_file(f"{msg.archive_uri}/.failed.json", ctx=self.ctx)
)
- except Exception:
- pass
+ except Exception as exc:
+ if not _is_storage_not_found(exc):
+ raise
else:
await tracker.fail(
msg.task_id,
@@ -1953,9 +1978,18 @@ class Session:
)
return
- archive_messages = await self._read_archive_messages(msg.archive_uri)
+ archive_error = ""
+ try:
+ archive_messages = await self._read_archive_messages(msg.archive_uri)
+ except _ArchiveMessagesCorruptError as exc:
+ archive_messages = []
+ archive_error = f"session commit archive has invalid messages: {exc}"
+ except Exception as exc:
+ if not _is_storage_not_found(exc):
+ raise
+ archive_messages = []
if not archive_messages:
- error = "session commit archive has no messages"
+ error = archive_error or "session commit archive has no messages"
await self._write_failed_marker(
msg.archive_uri,
stage="archive_read",
@@ -2966,10 +3000,7 @@ class Session:
async def _read_archive_messages(self, archive_uri: str) -> List[Message]:
"""Read archived messages from one archive."""
- try:
- content = await self._viking_fs.read_file(f"{archive_uri}/messages.jsonl", ctx=self.ctx)
- except Exception:
- return []
+ content = await self._viking_fs.read_file(f"{archive_uri}/messages.jsonl", ctx=self.ctx)
messages: List[Message] = []
for line in content.strip().split("\n"):
@@ -2977,8 +3008,8 @@ class Session:
continue
try:
messages.append(Message.from_dict(json.loads(line)))
- except Exception:
- continue
+ except (json.JSONDecodeError, AttributeError, KeyError, TypeError, ValueError) as exc:
+ raise _ArchiveMessagesCorruptError("invalid message record") from exc
return messages
@@ -3294,7 +3325,15 @@ class Session:
for state in states:
if state.archive_id in covered or state.state == "completed":
continue
- messages.extend(await self._read_archive_messages(state.archive_uri))
+ try:
+ messages.extend(await self._read_archive_messages(state.archive_uri))
+ except Exception as exc:
+ if not _is_storage_not_found(exc):
+ raise
+ logger.warning(
+ "Skipping pending archive %s because messages.jsonl is missing",
+ state.archive_uri,
+ )
return self._stable_deduplicate_messages(messages)
async def _get_pending_archive_messages(self) -> List[Message]:
diff --git a/openviking/storage/queuefs/named_queue.py b/openviking/storage/queuefs/named_queue.py
index 50e543d35..9b22a1743 100644
--- a/openviking/storage/queuefs/named_queue.py
+++ b/openviking/storage/queuefs/named_queue.py
@@ -8,6 +8,7 @@ from datetime import datetime
from typing import Any, Callable, Dict, List, Optional, Union
from openviking.pyagfs import AGFSSyncClientProtocol, AsyncAGFSClient
+from openviking.pyagfs.exceptions import AGFSAlreadyExistsError, AGFSNotFoundError
from openviking_cli.utils.logger import get_logger
logger = get_logger(__name__)
@@ -195,9 +196,8 @@ class NamedQueue:
if not self._initialized:
try:
await self._async_agfs.mkdir(self.path)
- except Exception as e:
- if "exist" not in str(e).lower():
- logger.warning(f"[NamedQueue] Failed to ensure queue {self.name}: {e}")
+ except (AGFSAlreadyExistsError, FileExistsError):
+ pass
self._initialized = True
async def enqueue(self, data: Union[str, Dict[str, Any]]) -> str:
@@ -323,16 +323,17 @@ class NamedQueue:
try:
content = await self._async_agfs.read(size_file)
- if not content:
+ if content is None:
return 0
if isinstance(content, bytes):
- return int(content.decode("utf-8").strip())
+ text = content.decode("utf-8")
elif isinstance(content, str):
- return int(content.strip())
+ text = content
else:
- return 0
- except Exception as e:
- logger.debug(f"[NamedQueue] Get size failed for {self.name}: {e}")
+ raise TypeError(f"Unexpected queue size response: {type(content).__name__}")
+ text = text.strip()
+ return int(text) if text else 0
+ except (AGFSNotFoundError, FileNotFoundError):
return 0
async def clear(self) -> bool:
diff --git a/tests/unit/session/test_session_commit_resume.py b/tests/unit/session/test_session_commit_resume.py
index fce05a8f3..549e38abf 100644
--- a/tests/unit/session/test_session_commit_resume.py
+++ b/tests/unit/session/test_session_commit_resume.py
@@ -7,7 +7,7 @@ from unittest.mock import AsyncMock
import pytest
from openviking.message import Message, TextPart
-from openviking.service.task_tracker import TaskTracker, set_task_tracker
+from openviking.service.task_tracker import TaskStatus, TaskTracker, set_task_tracker
from openviking.session.session import Session
from openviking.storage.queuefs.session_commit_msg import SessionCommitMsg
@@ -84,3 +84,62 @@ async def test_resume_queued_commit_continues_phase2(monkeypatch):
assert [
item.id for item in session._run_memory_extraction.await_args.kwargs["messages"]
] == ["archived"]
+
+
[email protected]("archive_content", [None, "{invalid json", "{}"])
+async def test_resume_queued_commit_fails_terminally_for_unreadable_archive(
+ monkeypatch, archive_content
+):
+ session_uri = "viking://user/sessions/session-1"
+ archive_uri = f"{session_uri}/history/archive_001"
+ files = {}
+ if archive_content is not None:
+ files[f"{archive_uri}/messages.jsonl"] = archive_content
+ viking_fs = _MemoryVikingFS(files)
+ session = Session(viking_fs=viking_fs, session_id="session-1", session_uri=session_uri)
+ tracker = TaskTracker(_TaskStore())
+ set_task_tracker(tracker)
+ monkeypatch.setattr(session, "_run_memory_extraction", AsyncMock())
+ message = SessionCommitMsg(
+ task_id="task-1",
+ session_id="session-1",
+ session_uri=session_uri,
+ archive_uri=archive_uri,
+ user={"account_id": "default", "user_id": "default"},
+ )
+
+ try:
+ await session.resume_queued_commit(message)
+ task = await tracker.get("task-1")
+ finally:
+ set_task_tracker(None)
+
+ assert task.status == TaskStatus.FAILED
+ failed = json.loads(files[f"{archive_uri}/.failed.json"])
+ assert failed["stage"] == "archive_read"
+ session._run_memory_extraction.assert_not_awaited()
+
+
+async def test_session_context_skips_pending_archive_with_missing_messages(monkeypatch):
+ session_uri = "viking://user/sessions/session-1"
+ archive_uri = f"{session_uri}/history/archive_001"
+ session = Session(
+ viking_fs=_MemoryVikingFS({}),
+ session_id="session-1",
+ session_uri=session_uri,
+ )
+ monkeypatch.setattr(
+ session,
+ "_list_archive_refs",
+ AsyncMock(
+ return_value=[
+ {"archive_id": "archive_001", "archive_uri": archive_uri, "index": 1}
+ ]
+ ),
+ )
+
+ context = await session.get_context_for_search(query="test")
+
+ assert context == {"latest_archive_overview": "", "current_messages": []}