The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Memory calls must name one store before writing or staging a proposal."""
import copy
import json
from types import SimpleNamespace
import pytest
from agent.inline_tool_executors import INLINE_TOOL_EXECUTORS
from hermes_cli.config import load_config, save_config
from tools.memory_tool import MemoryStore, apply_memory_pending
from tools.registry import registry
from tools.skill_provenance import reset_current_write_origin, set_current_write_origin
from tools import write_approval as wa
def _call(route, store, args):
if route == "store":
return store.apply_batch(args.get("target"), args["operations"])
if route == "replay":
return apply_memory_pending({"action": "batch", **args}, store)
if route == "inline":
agent = SimpleNamespace(_memory_store=store, _memory_manager=None)
return json.loads(INLINE_TOOL_EXECUTORS["memory"](agent, args, None))
return json.loads(registry.dispatch("memory", args, store=store))
@pytest.mark.parametrize("route", ["registry", "inline", "store", "replay"])
@pytest.mark.parametrize("origin", ["direct", "foreground", "background_review"])
@pytest.mark.parametrize("target_fields,nested_fields", [
({}, {}),
({"target": None}, {}),
({}, {"target": "user"}),
({"target": "memory"}, {"target": "user"}),
])
def test_invalid_targets_leave_files_and_pending_queue_unchanged(
route, origin, target_fields, nested_fields,
):
store = MemoryStore()
store.load_from_disk()
for target in ("memory", "user"):
assert store.add(target, f"Existing {target} fact")["success"]
before = {t: store._path_for(t).read_bytes() for t in ("memory", "user")}
config = load_config()
config.setdefault("memory", {})["write_approval"] = origin != "direct"
save_config(config)
# A bad target in a later operation must reject the entire batch.
args = {**target_fields, "operations": [
{"action": "add", "content": "First fact"},
{"action": "add", "content": "Second fact", **nested_fields},
]}
original = copy.deepcopy(args)
token = set_current_write_origin(origin)
try:
result = _call(route, store, args)
finally:
reset_current_write_origin(token)
assert result["success"] is False, result
assert "target" in result["error"] and "top level" in result["error"]
assert "retry" in result["error"].lower()
assert not result.get("staged")
assert wa.list_pending(wa.MEMORY) == []
assert args == original
assert {t: store._path_for(t).read_bytes() for t in before} == before
@pytest.mark.parametrize("route", ["registry", "inline", "store", "replay"])
@pytest.mark.parametrize("nested", ["user", None])
def test_nested_target_matching_the_call_is_accepted(route, nested):
store = MemoryStore()
store.load_from_disk()
for name in ("memory", "user"):
assert store.add(name, f"Existing {name} fact")["success"]
memory_before = store._path_for("memory").read_bytes()
args = {"target": "user", "operations": [{"action": "add", "content": "Fact", "target": nested}]}
assert _call(route, store, args)["success"] is True
fresh = MemoryStore()
fresh.load_from_disk()
assert fresh._entries_for("user") == ["Existing user fact", "Fact"]
assert store._path_for("memory").read_bytes() == memory_before
@pytest.mark.parametrize("route", ["registry", "inline"])
@pytest.mark.parametrize("batch", [False, True])
@pytest.mark.parametrize("target", ["memory", "user"])
def test_missing_target_can_be_corrected_without_writing_to_the_other_store(route, batch, target):
store = MemoryStore()
store.load_from_disk()
for name in ("memory", "user"):
assert store.add(name, f"Existing {name} fact")["success"]
other = "user" if target == "memory" else "memory"
other_before = store._path_for(other).read_bytes()
snapshot = store.format_for_system_prompt(target)
operation = {"action": "add", "content": "User prefers metric units"}
args = {"operations": [operation]} if batch else operation
rejected = _call(route, store, args)
assert rejected["success"] is False, rejected
result = _call(route, store, {**args, "target": target})
assert result["success"] is True, result
fresh = MemoryStore()
fresh.load_from_disk()
assert fresh._entries_for(target) == [f"Existing {target} fact", operation["content"]]
assert store._path_for(other).read_bytes() == other_before
assert store.format_for_system_prompt(target) == snapshot