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
"""Mock gateway turns through the external loader, Hermes manager and HTTP client."""
import json
import threading
from contextlib import contextmanager
from contextvars import ContextVar
from types import SimpleNamespace
import httpx
import pytest
from hermes_cli.config import yaml
@contextmanager
def profile_scope(home):
from agent.secret_scope import build_profile_secret_scope, reset_secret_scope, set_secret_scope
from hermes_constants import reset_hermes_home_override, set_hermes_home_override
token = set_hermes_home_override(home)
secrets = set_secret_scope(build_profile_secret_scope(home))
try:
yield
finally:
reset_secret_scope(secrets)
reset_hermes_home_override(token)
class GatewayBackend:
"""In-memory HTTP service: capture/archive plus deterministic indexed fixtures."""
def __init__(self):
self.pending = []
self.archived = []
self.searches = []
self.requests = []
self.batch_failures = 0
self.reject_context = False
self.reject_session_search = False
self.unconfirmed_context = False
self.reject_identity = False
self.profile = None
self.upload_started = None
self.release_upload = None
def __call__(self, request):
path = request.url.path
payload = json.loads(request.content) if request.content else {}
self.requests.append((request, payload))
result = {}
if path == "/health":
return httpx.Response(200, json={"status": "ok", "healthy": True, "version": "0.4.21"})
if path == "/api/v1/system/status":
if self.reject_identity:
return httpx.Response(503)
result = {"user": "tenant"}
elif path.endswith("/messages/batch") or path.endswith("/messages"):
if self.upload_started:
self.upload_started.set()
assert self.release_upload.wait(10)
if path.endswith("/batch") and self.batch_failures:
self.batch_failures -= 1
return httpx.Response(500, json={"error": {"message": "temporary capture failure"}})
self.pending.extend(payload.get("messages", [payload]))
elif path.endswith("/commit"):
assert payload == {"keep_recent_count": 0}
self.archived.extend(self.pending)
self.pending.clear()
result = {"status": "accepted"}
elif path.startswith("/api/v1/sessions/"):
result = {"pending_tokens": len(self.pending)}
elif path.startswith("/api/v1/search/"):
self.searches.append((request, payload))
if self.reject_session_search and payload.get("session_id"):
return httpx.Response(503)
if payload.get("mode") == "context" and self.reject_context:
return httpx.Response(422)
actor = request.headers.get("X-OpenViking-Actor-Peer", "")
roots = payload.get("target_uri")
if roots is None:
all_peers = not actor or (
payload.get("mode") == "context" and payload.get("peer_scope", "all") == "all"
)
roots = (
["viking://user/tenant", "viking://resources"]
if all_peers
else [
"viking://user/tenant/memories",
f"viking://user/tenant/peers/{actor}",
"viking://resources",
]
)
docs = [("common", "viking://user/tenant/memories/preferences/common.md")]
if self.profile:
docs += [("profile", "viking://user/tenant/memories/profile.md")]
docs += [
(name, f"viking://user/tenant/peers/telegram.{name}/memories/preferences/fact.md")
for name in ("alice", "bob", "assistant")
]
docs += [("resource", "viking://resources/manual/readme.md")]
allowed = [
(name, uri)
for name, uri in docs
if any(uri.startswith(root.rstrip("/") + "/") for root in roots)
]
if "resource" not in payload.get("context_type", []):
allowed = [(name, uri) for name, uri in allowed if name != "resource"]
if payload.get("mode") == "context":
result = {
"rendered": " ".join(name for name, _ in allowed),
"entries": [],
"stats": {"peer_scope": payload.get("peer_scope", "all")},
}
if self.unconfirmed_context:
result = {"rendered": "WRONG_BOB_CONTEXT", "entries": [], "stats": {}}
else:
result = {
"memories": [
{"uri": uri, "score": 0.9, "abstract": name, "level": 2}
for name, uri in allowed
]
}
elif path == "/api/v1/fs/ls":
result = []
elif path.startswith("/api/v1/content/"):
if not (self.profile and request.url.params.get("uri", "").endswith("/memories/profile.md")):
return httpx.Response(404)
result = self.profile
return httpx.Response(200, json={"status": "ok", "result": result})
def initialize(
external_provider, monkeypatch, *, name="gateway", scope="peer", compress="off", **identity
):
from agent.memory_manager import MemoryManager
home, provider, module, _ = external_provider(name)
config = {
"endpoint": f"http://{name}.test",
"use_ovcli_config": False,
"agent": "telegram.assistant",
"api_key": "mock-key",
"recall_scope": scope,
"recall_compress": compress,
"recall_prefer_abstract": True,
"recall_resources": True,
"recall_timeout_seconds": 10,
"recall_request_timeout_seconds": 5,
}
(home / "config.yaml").write_text(
yaml.safe_dump({"memory": {"provider": "openviking", "openviking": config}})
)
backend = GatewayBackend()
client = httpx.Client(transport=httpx.MockTransport(backend))
monkeypatch.setattr(module, "_get_httpx", lambda: client)
manager = MemoryManager(external_prefetch_timeout=10)
manager.add_provider(provider)
with profile_scope(home):
manager.initialize_all(
session_id="shared-group",
hermes_home=str(home),
platform="telegram",
user_id="alice",
**identity,
)
return home, provider, module, manager, backend
@pytest.mark.parametrize("compress", ["off", "server"])
@pytest.mark.parametrize("scope", [None, "shared", "peer"])
def test_gateway_capture_commit_and_sender_scoped_recall(
external_provider, monkeypatch, scope, compress
):
from agent.turn_context import _memory_turn_start_and_prefetch
home, provider, _, manager, backend = initialize(
external_provider, monkeypatch, scope=scope, compress=compress
)
agent = SimpleNamespace(
_memory_manager=manager,
_user_turn_count=0,
session_id="shared-group",
_emit_status=lambda _: None,
)
try:
with profile_scope(home):
for index, sender in enumerate(("alice", "bob", "alice"), start=1):
author = {"id": sender, "name": sender, "is_bot": False}
query = f"Remember my {sender} drink preference"
agent._user_turn_count = index
recalled = _memory_turn_start_and_prefetch(agent, query, author)
assert "common" in recalled
if scope == "peer":
assert sender in recalled
assert ("bob" if sender == "alice" else "alice") not in recalled
assert "assistant" not in recalled
elif scope == "shared":
assert "alice" in recalled and "bob" in recalled
elif compress == "off":
assert (
"assistant" in recalled
and "alice" not in recalled
and "bob" not in recalled
)
manager.sync_all(
query,
"Acknowledged",
session_id="shared-group",
turn_author=author,
messages=[
{"role": "user", "content": query},
{"role": "assistant", "content": "Acknowledged"},
],
)
assert manager.flush_pending(timeout=10)
assert provider._drain_writers("shared-group", timeout=10)
provider.on_session_end([])
assert provider._drain_finalizers(timeout=10)
assert [m["peer_id"] for m in backend.archived if m["role"] == "user"] == [
"telegram.alice",
"telegram.bob",
"telegram.alice",
]
assert all(
m["peer_id"] == "telegram.assistant"
for m in backend.archived
if m["role"] == "assistant"
)
assert backend.pending == []
assert not provider._state_path("pending", "shared-group").exists()
# Sender recall never changes the configured identity used for capture/tools.
with profile_scope(home):
provider.handle_tool_call("viking_search", {"query": "preference"})
assert backend.searches[-1][0].headers["X-OpenViking-Actor-Peer"] == "telegram.assistant"
finally:
manager.shutdown_all()
def test_first_turn_list_recall_does_not_repeat_profile(external_provider, monkeypatch):
home, provider, _, manager, backend = initialize(external_provider, monkeypatch, scope=None)
monkeypatch.setenv("OPENVIKING_RECALL_PREFER_ABSTRACT", "false") # default: full L2 reads
backend.profile = "PROFILE_BODY Alice drinks oolong."
profile_uri = "viking://user/tenant/memories/profile.md"
try:
with profile_scope(home):
first = provider.prefetch("Remember my drink preference", session_id="shared-group")
later = provider.prefetch("Remember my drink preference", session_id="shared-group")
assert f'<user-profile uri="{profile_uri}">' in first
assert first.count("PROFILE_BODY") == first.count(profile_uri) == 1
assert "common" in first and "common" in later
assert profile_uri not in later
finally:
manager.shutdown_all()
@pytest.mark.parametrize("batch_failures,structured", [(1, True), (4, True), (0, False)])
def test_delayed_capture_keeps_author_through_fallback(
external_provider, monkeypatch, batch_failures, structured
):
home, provider, _, manager, backend = initialize(external_provider, monkeypatch)
backend.batch_failures = batch_failures
backend.upload_started, backend.release_upload = threading.Event(), threading.Event()
try:
with profile_scope(home):
manager.on_turn_start(1, "Alice fact", author_id="alice")
provider.sync_turn(
"Alice fact",
"Reply",
session_id="shared-group",
turn_author={"id": "alice"},
messages=[{"role": "user", "content": "Alice fact"}] if structured else None,
)
assert backend.upload_started.wait(5)
manager.on_turn_start(2, "Bob fact", author_id="bob")
backend.release_upload.set()
assert provider._drain_writers("shared-group", timeout=10)
assert backend.pending
assert {m["peer_id"] for m in backend.pending if m["role"] == "user"} == {"telegram.alice"}
finally:
backend.release_upload.set()
manager.shutdown_all()
@pytest.mark.parametrize("author_id", [None, "", "bob"])
def test_missing_author_and_context_fallback_keep_scope(external_provider, monkeypatch, author_id):
home, provider, _, manager, backend = initialize(
external_provider, monkeypatch, compress="server"
)
try:
with profile_scope(home):
manager.on_turn_start(1, "Alice fact", author_id="alice")
manager.on_turn_start(2, "Recall preferences", author_id=author_id)
for fault in ("reject_context", "unconfirmed_context"):
setattr(backend, fault, True)
result = provider.prefetch("Recall preferences", session_id="shared-group")
assert "common" in result and "resource" in result
assert "alice" not in result and "assistant" not in result and "WRONG" not in result
assert ("bob" in result) == bool(author_id)
assert backend.searches[-1][1]["target_uri"]
setattr(backend, fault, False)
backend.reject_identity = True
backend.searches.clear()
assert provider.prefetch("Recall preferences", session_id="shared-group") == ""
assert not backend.searches
finally:
manager.shutdown_all()
def test_peer_identity_alt_ids_and_profile_settings(external_provider, monkeypatch):
home_a, provider_a, module_a, manager_a, _ = initialize(
external_provider, monkeypatch, name="profile-a", user_id_alt="stable-alice"
)
home_b, provider_b, _, manager_b, _ = initialize(
external_provider, monkeypatch, name="profile-b", scope="shared"
)
try:
for home, provider, expected in (
(home_a, provider_a, "peer"),
(home_b, provider_b, "shared"),
(home_a, provider_a, "peer"),
):
with profile_scope(home):
assert provider._recall_config()["scope"] == expected
with profile_scope(home_a):
provider_a.on_turn_start(1, "hello", author_id="alice")
assert provider_a._current_sender_peer() == "telegram.stable-alice"
provider_a.on_turn_start(2, "hello", author_id="bob")
assert provider_a._current_sender_peer() == "telegram.bob"
assert module_a._gateway_peer_id("telegram", "alice") != module_a._gateway_peer_id(
"discord", "alice"
)
assert module_a._gateway_peer_id("telegram", "a/b") != module_a._gateway_peer_id(
"telegram", "a?b"
)
peer = module_a._gateway_peer_id("telegram", "a/b" * 100)
assert len(peer) <= 128 and "/" not in peer
provider_a.save_config({"recall_scope": "shared"}, str(home_a))
assert (
yaml.safe_load((home_a / "config.yaml").read_text())["memory"]["openviking"][
"recall_scope"
]
== "shared"
)
finally:
manager_a.shutdown_all()
manager_b.shutdown_all()
def test_find_fallback_retains_sender_roots(external_provider, monkeypatch):
home, provider, _, manager, backend = initialize(external_provider, monkeypatch)
backend.reject_session_search = True
try:
with profile_scope(home):
manager.on_turn_start(1, "Recall preferences", author_id="bob")
result = provider.prefetch("Recall preferences", session_id="shared-group")
assert "bob" in result and "common" in result and "resource" in result
assert "alice" not in result and "assistant" not in result
assert backend.searches[-1][0].url.path == "/api/v1/search/find"
assert backend.searches[-1][1]["target_uri"] == backend.searches[-2][1]["target_uri"]
finally:
manager.shutdown_all()
@pytest.mark.parametrize("platform,expected", [("telegram", "telegram.alice"), ("", None)])
def test_older_hooks_and_no_gateway_sender(external_provider, monkeypatch, platform, expected):
home, provider, _, manager, backend = initialize(external_provider, monkeypatch)
try:
with profile_scope(home):
provider._gateway_platform = platform
provider._user_id = provider._sender_peer("alice")
# Older Hermes does not pass per-turn author metadata.
provider.on_turn_start(1, "Remember this")
provider.sync_turn("Remember this", "OK", session_id="shared-group")
assert provider._drain_writers("shared-group", timeout=10)
assert backend.pending[0].get("peer_id") == expected
backend.pending.clear()
# An explicit missing author must clear the initialized sender.
provider.on_turn_start(2, "Remember another fact", author_id=None)
provider.sync_turn(
"Remember another fact", "OK", session_id="shared-group", turn_author={"id": None}
)
assert provider._drain_writers("shared-group", timeout=10)
assert "peer_id" not in backend.pending[0]
finally:
manager.shutdown_all()
def test_recall_scope_default_and_environment_override(external_provider, monkeypatch):
_, provider, module, _ = external_provider("config")
schema = {field["key"]: field for field in provider.get_config_schema()}
assert schema["recall_scope"]["choices"] == ["shared", "peer"]
assert module.OpenVikingMemoryProvider._setting("recall_scope", {}) is None
monkeypatch.setenv("OPENVIKING_RECALL_SCOPE", "peer")
assert provider._setting("recall_scope", {"recall_scope": "shared"}) == "peer"
monkeypatch.delenv("OPENVIKING_RECALL_SCOPE")
assert provider._setting("recall_scope", {"recall_scope": "invalid"}) is None
def pause_first_worker(module, monkeypatch):
entered, release = threading.Event(), threading.Event()
spawn = module.spawn_context_thread
count = 0
def delayed(body, *, name):
nonlocal count
if name == "openviking-sync":
count += 1
if count == 1:
def paused():
entered.set()
assert release.wait(10)
body()
return spawn(paused, name=name)
return spawn(body, name=name)
monkeypatch.setattr(module, "spawn_context_thread", delayed)
return entered, release
def user_texts(messages):
return [m["parts"][0]["text"] for m in messages if m["role"] == "user"]
@pytest.mark.parametrize("boundary", ["end", "switch", "threshold"])
def test_delayed_worker_preserves_order_context_and_commit(
external_provider, monkeypatch, boundary
):
home, provider, module, manager, backend = initialize(external_provider, monkeypatch)
entered, release = pause_first_worker(module, monkeypatch)
uploaded = threading.Event()
context = ContextVar("upload-author", default="missing")
seen = []
run = module._TurnUpload.run
def record(upload):
seen.append(context.get())
result = run(upload)
uploaded.set()
return result
monkeypatch.setattr(module._TurnUpload, "run", record)
if boundary == "threshold":
monkeypatch.setattr(provider, "_setting", lambda *_args, **_kwargs: 0)
try:
with profile_scope(home):
for number, author in enumerate(("alice", "bob", "alice"), 1):
token = context.set(f"{author}-{number}")
try:
manager.sync_all(
f"Turn {number}", "Reply", session_id="shared-group",
turn_author={"id": author},
)
assert manager.flush_pending(timeout=5)
finally:
context.reset(token)
if number == 1:
assert entered.wait(5)
# No later upload may overtake a worker paused before its write lock.
assert not uploaded.wait(0.5)
assert not provider._drain_writers("shared-group", timeout=0.01)
if boundary == "switch":
provider.on_session_switch("next-session")
assert provider._session_id == "next-session"
elif boundary == "end":
monkeypatch.setattr(module, "_SESSION_DRAIN_TIMEOUT", 0.01)
provider.on_session_end([])
assert backend.archived == []
release.set()
assert provider._drain_writers("shared-group", timeout=10)
if boundary == "end":
provider.on_session_end([])
assert provider._drain_finalizers(timeout=10)
assert user_texts(backend.archived) == ["Turn 1", "Turn 2", "Turn 3"]
assert seen == ["alice-1", "bob-2", "alice-3"]
assert [m["peer_id"] for m in backend.archived if m["role"] == "user"] == [
"telegram.alice", "telegram.bob", "telegram.alice",
]
assert backend.pending == []
assert provider._inflight_writers == {}
assert provider._upload_tails == {}
assert not provider._state_path("pending", "shared-group").exists()
finally:
release.set()
manager.shutdown_all()
def test_upload_order_does_not_wait_for_previous_metadata(external_provider, monkeypatch):
home, provider, _, manager, backend = initialize(external_provider, monkeypatch)
checking, release, second_written = (threading.Event() for _ in range(3))
check = provider._maybe_commit_live_session
calls = 0
def delay_metadata(*args):
nonlocal calls
calls += 1
if calls == 1:
checking.set()
assert release.wait(10)
else:
second_written.set()
check(*args)
monkeypatch.setattr(provider, "_maybe_commit_live_session", delay_metadata)
try:
with profile_scope(home):
provider.sync_turn("First", "Reply")
assert checking.wait(5)
provider.sync_turn("Second", "Reply")
assert second_written.wait(5)
assert user_texts(backend.pending) == ["First", "Second"]
assert not provider._drain_writers("shared-group", timeout=0.01)
release.set()
assert provider._drain_writers("shared-group", timeout=5)
finally:
release.set()
manager.shutdown_all()
def test_failed_worker_start_does_not_break_upload_order(external_provider, monkeypatch):
home, provider, module, manager, backend = initialize(external_provider, monkeypatch)
entered, release = pause_first_worker(module, monkeypatch)
spawn = module.spawn_context_thread
calls = 0
def fail_second_start(body, *, name):
nonlocal calls
thread = spawn(body, name=name)
if name == "openviking-sync":
calls += 1
if calls == 2:
def fail():
raise RuntimeError("No thread available")
thread.start = fail
return thread
monkeypatch.setattr(module, "spawn_context_thread", fail_second_start)
try:
with profile_scope(home):
provider.sync_turn("First", "Reply")
assert entered.wait(5)
provider.sync_turn("Cannot start", "Reply")
provider.sync_turn("Third", "Reply")
assert not provider._drain_writers("shared-group", timeout=0.1)
assert backend.pending == []
release.set()
assert provider._drain_writers("shared-group", timeout=5)
assert user_texts(backend.pending) == ["First", "Third"]
provider.sync_turn("Fourth", "Reply")
assert provider._drain_writers("shared-group", timeout=5)
assert user_texts(backend.pending) == ["First", "Third", "Fourth"]
assert provider._upload_tails == {}
assert provider._inflight_writers == {}
finally:
release.set()
manager.shutdown_all()
@pytest.mark.parametrize("fail_all", [False, True])
def test_failed_upload_releases_next_turn(external_provider, monkeypatch, fail_all):
home, provider, module, manager, backend = initialize(external_provider, monkeypatch)
entered, release = pause_first_worker(module, monkeypatch)
run = module._TurnUpload.run
def fail_first(upload):
if upload.user_content == "First":
backend.batch_failures = 4
if fail_all:
# Exhaust the individual-message fallback too, then allow the next turn.
def offline(*_args):
raise OSError("offline")
monkeypatch.setattr(upload.client, "post", offline)
result = run(upload)
backend.batch_failures = 0
return result
monkeypatch.setattr(module._TurnUpload, "run", fail_first)
try:
with profile_scope(home):
for text in ("First", "Second"):
provider.sync_turn(text, "Reply", messages=[{"role": "user", "content": text}])
if text == "First":
assert entered.wait(5)
release.set()
assert provider._drain_writers("shared-group", timeout=5)
assert user_texts(backend.pending) == (["Second"] if fail_all else ["First", "Second"])
assert provider._upload_tails == {}
finally:
release.set()
manager.shutdown_all()
def test_other_session_upload_is_not_blocked_by_paused_worker(external_provider, monkeypatch):
home, provider, module, manager, backend = initialize(external_provider, monkeypatch)
entered, release = pause_first_worker(module, monkeypatch)
try:
with profile_scope(home):
provider.sync_turn("First session", "Reply", session_id="first")
assert entered.wait(5)
provider.sync_turn("Second session", "Reply", session_id="second")
assert provider._drain_writers("second", timeout=5)
assert user_texts(backend.pending) == ["Second session"]
release.set()
manager.shutdown_all()
assert user_texts(backend.pending) == ["Second session", "First session"]
assert provider._inflight_writers == {}
assert provider._upload_tails == {}
finally:
release.set()
manager.shutdown_all()