418 lines
13 KiB
Python
418 lines
13 KiB
Python
import importlib.util
|
|
import json
|
|
import os
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
|
|
HERMES_ROOT = Path("/home/tom/hermes-agent")
|
|
PLUGIN_PATH = Path(__file__).resolve().parents[1] / "plugins" / "memory" / "memory_system" / "__init__.py"
|
|
|
|
|
|
def load_plugin_module():
|
|
if str(HERMES_ROOT) not in sys.path:
|
|
sys.path.insert(0, str(HERMES_ROOT))
|
|
spec = importlib.util.spec_from_file_location("memory_system_plugin", PLUGIN_PATH)
|
|
module = importlib.util.module_from_spec(spec)
|
|
assert spec.loader is not None
|
|
spec.loader.exec_module(module)
|
|
return module
|
|
|
|
|
|
class FakeClient:
|
|
def __init__(self, commit_status="success"):
|
|
self.posts = []
|
|
self.gets = []
|
|
self.deletes = []
|
|
self.commit_status = commit_status
|
|
|
|
def post(self, path, payload=None):
|
|
self.posts.append((path, payload or {}))
|
|
if path == "/memory-system/users":
|
|
return {
|
|
"status": "success",
|
|
"account": {
|
|
"status": "ok",
|
|
"result": {
|
|
"account_id": f"{payload['user_id']}_account",
|
|
"admin_user_id": payload["user_id"],
|
|
"user_key": f"{payload['user_id']}-key",
|
|
},
|
|
},
|
|
}
|
|
if path == "/memory-system/search":
|
|
return {
|
|
"status": "success",
|
|
"items": [
|
|
{
|
|
"source_backend": "openviking",
|
|
"content": "likes latte",
|
|
"score": 0.9,
|
|
"uri": "viking://user/user-1/memories/a",
|
|
"vector": [0.1, 0.2],
|
|
},
|
|
{
|
|
"source_backend": "everos",
|
|
"memory": "prefers warm coffee",
|
|
"memory_type": "profile",
|
|
"original_data": {"large": "payload"},
|
|
},
|
|
],
|
|
"backends": {
|
|
"openviking": {"status": "success", "result": {"verbose": True}},
|
|
"everos": {"status": "success", "result": {"verbose": True}},
|
|
},
|
|
}
|
|
if path.endswith("/commit"):
|
|
return {"status": self.commit_status}
|
|
if path == "/memory-system/memories":
|
|
return {"status": "success", "memory": {"status": "ok", "result": {"uri": payload.get("uri")}}}
|
|
return {"status": "success"}
|
|
|
|
def get(self, path):
|
|
self.gets.append(path)
|
|
if path.startswith("/memory-system/memories/content"):
|
|
return {"status": "success", "memory": {"status": "ok", "result": {"content": "# Python"}}}
|
|
if path.startswith("/memory-system/memories"):
|
|
return {"status": "success", "memory": {"status": "ok", "result": {"children": []}}}
|
|
return {"status": "success", "profile": {"coffee": "latte"}}
|
|
|
|
def delete(self, path):
|
|
self.deletes.append(path)
|
|
return {"status": "success", "memory": {"status": "ok", "result": {"estimated_deleted_count": 1}}}
|
|
|
|
|
|
def make_provider():
|
|
module = load_plugin_module()
|
|
provider = module.MemorySystemMemoryProvider()
|
|
provider._client = FakeClient()
|
|
provider._endpoint = "http://127.0.0.1:1934"
|
|
provider._user_id = "user-1"
|
|
provider._user_key = "user-1-key"
|
|
provider._session_id = "session-1"
|
|
provider._commit_every_turns = 0
|
|
provider._commit_interval_seconds = 0
|
|
return provider
|
|
|
|
|
|
def wait_for_sync(provider):
|
|
thread = provider._sync_thread
|
|
if thread and thread.is_alive():
|
|
thread.join(timeout=2.0)
|
|
|
|
|
|
def test_initialize_loads_config_from_hermes_env_file(tmp_path, monkeypatch):
|
|
module = load_plugin_module()
|
|
hermes_home = tmp_path / ".hermes"
|
|
hermes_home.mkdir()
|
|
env_file = hermes_home / ".env"
|
|
env_file.write_text(
|
|
"\n".join(
|
|
[
|
|
"MEMORY_SYSTEM_ENDPOINT=http://127.0.0.1:1934",
|
|
"MEMORY_SYSTEM_USER_ID=file-user",
|
|
"MEMORY_SYSTEM_USER_KEY=file-user-key",
|
|
"MEMORY_SYSTEM_COMMIT_EVERY_TURNS=3",
|
|
"MEMORY_SYSTEM_COMMIT_INTERVAL_SECONDS=60",
|
|
"MEMORY_SYSTEM_TIMEOUT_SECONDS=123",
|
|
]
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
for key in list(os.environ):
|
|
if key.startswith("MEMORY_SYSTEM_"):
|
|
monkeypatch.delenv(key, raising=False)
|
|
monkeypatch.chdir(tmp_path)
|
|
|
|
class InitClient(FakeClient):
|
|
def __init__(self, endpoint, api_key="", timeout=0):
|
|
super().__init__()
|
|
self.endpoint = endpoint
|
|
self.api_key = api_key
|
|
self.timeout = timeout
|
|
|
|
def health(self):
|
|
return True
|
|
|
|
monkeypatch.setattr(module, "_MemorySystemClient", InitClient)
|
|
provider = module.MemorySystemMemoryProvider()
|
|
|
|
provider.initialize("session-1", hermes_home=str(hermes_home))
|
|
|
|
assert provider._endpoint == "http://127.0.0.1:1934"
|
|
assert provider._user_id == "file-user"
|
|
assert provider._user_key == "file-user-key"
|
|
assert provider._commit_every_turns == 3
|
|
assert provider._commit_interval_seconds == 60
|
|
assert provider._timeout == 123
|
|
assert provider._client.endpoint == "http://127.0.0.1:1934"
|
|
assert provider._client.timeout == 123
|
|
|
|
|
|
def test_sync_turn_posts_user_and_assistant_messages():
|
|
provider = make_provider()
|
|
|
|
provider.sync_turn("hello", "hi there")
|
|
wait_for_sync(provider)
|
|
|
|
assert provider._client.posts == [
|
|
(
|
|
"/memory-system/messages",
|
|
{
|
|
"user_id": "user-1",
|
|
"user_key": "user-1-key",
|
|
"session_id": "session-1",
|
|
"user_message": "hello",
|
|
"assistant_message": "hi there",
|
|
"metadata": {"source": "hermes", "provider": "memory_system"},
|
|
},
|
|
)
|
|
]
|
|
|
|
|
|
def test_on_session_end_commits_after_turn_sync():
|
|
provider = make_provider()
|
|
provider.sync_turn("hello", "hi there")
|
|
|
|
provider.on_session_end([])
|
|
|
|
assert provider._client.posts[-1] == (
|
|
"/memory-system/sessions/session-1/commit",
|
|
{"user_id": "user-1", "user_key": "user-1-key"},
|
|
)
|
|
|
|
|
|
def test_sync_turn_commits_every_configured_turns():
|
|
provider = make_provider()
|
|
provider._commit_every_turns = 2
|
|
provider._commit_interval_seconds = 0
|
|
|
|
provider.sync_turn("turn 1", "reply 1")
|
|
wait_for_sync(provider)
|
|
provider.sync_turn("turn 2", "reply 2")
|
|
wait_for_sync(provider)
|
|
|
|
assert provider._client.posts[-1] == (
|
|
"/memory-system/sessions/session-1/commit",
|
|
{"user_id": "user-1", "user_key": "user-1-key"},
|
|
)
|
|
assert provider._last_commit_turn == 2
|
|
|
|
|
|
def test_partial_commit_does_not_mark_turns_committed():
|
|
provider = make_provider()
|
|
provider._client = FakeClient(commit_status="partial_success")
|
|
provider._turn_count = 2
|
|
|
|
response = provider._commit_session("session-1")
|
|
|
|
assert response["status"] == "partial_success"
|
|
assert provider._last_commit_turn == 0
|
|
|
|
|
|
def test_on_session_end_skips_when_periodic_commit_is_current():
|
|
provider = make_provider()
|
|
provider._commit_every_turns = 1
|
|
provider._commit_interval_seconds = 0
|
|
provider.sync_turn("hello", "hi there")
|
|
wait_for_sync(provider)
|
|
|
|
provider.on_session_end([])
|
|
|
|
commit_posts = [
|
|
post for post in provider._client.posts if post[0] == "/memory-system/sessions/session-1/commit"
|
|
]
|
|
assert len(commit_posts) == 1
|
|
|
|
|
|
def test_search_tool_uses_memory_system_api():
|
|
provider = make_provider()
|
|
|
|
result = json.loads(provider.handle_tool_call("memory_system_search", {"query": "coffee", "limit": 3}))
|
|
|
|
assert result["status"] == "success"
|
|
assert result["items"] == [
|
|
{
|
|
"source_backend": "openviking",
|
|
"score": 0.9,
|
|
"text": "likes latte",
|
|
"uri": "viking://user/user-1/memories/a",
|
|
},
|
|
{
|
|
"source_backend": "everos",
|
|
"memory_type": "profile",
|
|
"text": "prefers warm coffee",
|
|
},
|
|
]
|
|
assert "backends" not in result
|
|
assert "vector" not in json.dumps(result)
|
|
assert "original_data" not in json.dumps(result)
|
|
assert provider._client.posts[-1] == (
|
|
"/memory-system/search",
|
|
{
|
|
"user_id": "user-1",
|
|
"user_key": "user-1-key",
|
|
"session_id": "session-1",
|
|
"query": "coffee",
|
|
"use_llm": False,
|
|
"limit": 3,
|
|
},
|
|
)
|
|
|
|
|
|
def test_profile_tool_reads_user_profile():
|
|
provider = make_provider()
|
|
|
|
result = json.loads(provider.handle_tool_call("memory_system_profile", {}))
|
|
|
|
assert result["profile"] == {"coffee": "latte"}
|
|
assert provider._client.gets == ["/memory-system/users/user-1/profile?user_key=user-1-key"]
|
|
|
|
|
|
def test_remember_tool_writes_and_commits():
|
|
provider = make_provider()
|
|
|
|
result = json.loads(provider.handle_tool_call("memory_system_remember", {"content": "likes latte"}))
|
|
|
|
assert result["status"] == "success"
|
|
assert provider._client.posts == [
|
|
(
|
|
"/memory-system/messages",
|
|
{
|
|
"user_id": "user-1",
|
|
"user_key": "user-1-key",
|
|
"session_id": "session-1",
|
|
"user_message": "likes latte",
|
|
"metadata": {"source": "hermes", "provider": "memory_system"},
|
|
},
|
|
),
|
|
(
|
|
"/memory-system/sessions/session-1/commit",
|
|
{"user_id": "user-1", "user_key": "user-1-key"},
|
|
),
|
|
]
|
|
|
|
|
|
def test_initialize_creates_user_when_user_key_is_not_configured(tmp_path, monkeypatch):
|
|
module = load_plugin_module()
|
|
for key in list(os.environ):
|
|
if key.startswith("MEMORY_SYSTEM_"):
|
|
monkeypatch.delenv(key, raising=False)
|
|
monkeypatch.setenv("MEMORY_SYSTEM_ENDPOINT", "http://127.0.0.1:1934")
|
|
monkeypatch.setenv("MEMORY_SYSTEM_USER_ID", "new-user")
|
|
monkeypatch.chdir(tmp_path)
|
|
|
|
class InitClient(FakeClient):
|
|
def __init__(self, endpoint, api_key="", timeout=0):
|
|
super().__init__()
|
|
self.endpoint = endpoint
|
|
|
|
def health(self):
|
|
return True
|
|
|
|
monkeypatch.setattr(module, "_MemorySystemClient", InitClient)
|
|
provider = module.MemorySystemMemoryProvider()
|
|
|
|
provider.initialize("session-1")
|
|
|
|
assert provider._user_key == "new-user-key"
|
|
assert provider._client.posts == [("/memory-system/users", {"user_id": "new-user"})]
|
|
|
|
|
|
def test_memory_tool_schemas_include_memory_management_tools():
|
|
provider = make_provider()
|
|
|
|
tool_names = {schema["name"] for schema in provider.get_tool_schemas()}
|
|
|
|
assert {
|
|
"memory_system_memory_list",
|
|
"memory_system_memory_read",
|
|
"memory_system_memory_write",
|
|
"memory_system_memory_delete",
|
|
} <= tool_names
|
|
|
|
|
|
def test_memory_list_tool_calls_memories_endpoint():
|
|
provider = make_provider()
|
|
|
|
result = json.loads(provider.handle_tool_call("memory_system_memory_list", {"recursive": True}))
|
|
|
|
assert result["status"] == "success"
|
|
assert provider._client.gets == [
|
|
"/memory-system/memories?user_id=user-1&user_key=user-1-key&uri=viking%3A%2F%2Fuser%2Fmemories&recursive=true"
|
|
]
|
|
|
|
|
|
def test_memory_read_tool_calls_memory_content_endpoint():
|
|
provider = make_provider()
|
|
|
|
result = json.loads(provider.handle_tool_call(
|
|
"memory_system_memory_read",
|
|
{"uri": "viking://user/memories/preferences/python.md"},
|
|
))
|
|
|
|
assert result["status"] == "success"
|
|
assert provider._client.gets == [
|
|
"/memory-system/memories/content?user_id=user-1&user_key=user-1-key&uri=viking%3A%2F%2Fuser%2Fmemories%2Fpreferences%2Fpython.md"
|
|
]
|
|
|
|
|
|
def test_memory_write_tool_posts_memory_payload():
|
|
provider = make_provider()
|
|
|
|
result = json.loads(provider.handle_tool_call(
|
|
"memory_system_memory_write",
|
|
{
|
|
"uri": "viking://user/memories/preferences/python.md",
|
|
"content": "# Python",
|
|
"mode": "replace",
|
|
"wait": True,
|
|
},
|
|
))
|
|
|
|
assert result["status"] == "success"
|
|
assert provider._client.posts == [
|
|
(
|
|
"/memory-system/memories",
|
|
{
|
|
"user_id": "user-1",
|
|
"user_key": "user-1-key",
|
|
"uri": "viking://user/memories/preferences/python.md",
|
|
"content": "# Python",
|
|
"mode": "replace",
|
|
"wait": True,
|
|
},
|
|
)
|
|
]
|
|
|
|
|
|
def test_memory_delete_tool_deletes_memory_uri_non_recursive_by_default():
|
|
provider = make_provider()
|
|
|
|
result = json.loads(provider.handle_tool_call(
|
|
"memory_system_memory_delete",
|
|
{"uri": "viking://user/memories/preferences/python.md"},
|
|
))
|
|
|
|
assert result["status"] == "success"
|
|
assert provider._client.deletes == [
|
|
"/memory-system/memories?user_id=user-1&user_key=user-1-key&uri=viking%3A%2F%2Fuser%2Fmemories%2Fpreferences%2Fpython.md&recursive=false"
|
|
]
|
|
|
|
|
|
def test_register_adds_provider():
|
|
module = load_plugin_module()
|
|
|
|
class Ctx:
|
|
def __init__(self):
|
|
self.providers = []
|
|
|
|
def register_memory_provider(self, provider):
|
|
self.providers.append(provider)
|
|
|
|
ctx = Ctx()
|
|
module.register(ctx)
|
|
|
|
assert len(ctx.providers) == 1
|
|
assert ctx.providers[0].name == "memory_system"
|