Skip to content
Merged
Show file tree
Hide file tree
Changes from 1 commit
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
memory_ref.revision
  • Loading branch information
Alanxtl committed Aug 19, 2026
commit 01cc8beadb6830a3a25ba3005dc33da40c492cfe
37 changes: 29 additions & 8 deletions integrations/hermes/plugins/powercontext/__init__.py
Original file line number Diff line number Diff line change
Expand Up @@ -268,6 +268,16 @@ def _citation_from_response(response: Any) -> dict[str, Any] | None:
}


def _entry_identity(citation: Any) -> dict[str, str] | None:
if not isinstance(citation, dict):
return None
entry_id = str(citation.get("entry_id", "")).strip()
entry_version_id = str(citation.get("entry_version_id", "")).strip()
if not entry_id or not entry_version_id:
return None
return {"entry_id": entry_id, "entry_version_id": entry_version_id}


class PowerContextMemoryProvider(MemoryProvider):
"""Hermes provider backed by a running PowerContext server."""

Expand Down Expand Up @@ -800,10 +810,17 @@ def _remember_new(self, target: str, text: str) -> None:
if citation is None:
citation = self._find_memory_citation(text)
if citation is not None:
self._memory_map[key] = citation
self._save_memory_map()
identity = _entry_identity(citation)
if identity is not None:
self._memory_map[key] = identity
self._save_memory_map()

def _find_memory_citation(self, text: str) -> dict[str, Any] | None:
def _find_memory_citation(
self,
text: str,
*,
identity: dict[str, str] | None = None,
) -> dict[str, Any] | None:
try:
response = self._client.search_memory(
self._scope_id,
Expand All @@ -820,17 +837,21 @@ def _find_memory_citation(self, text: str) -> dict[str, Any] | None:
continue
citation = hit.get("citation")
normalized = _citation_from_response({"entry": {"citation": citation}})
if normalized is not None:
if normalized is not None and (identity is None or _entry_identity(normalized) == identity):
return normalized
return None

def _lookup_memory_citation(self, target: str, text: str) -> tuple[str, dict[str, Any] | None]:
key = self._memory_item_key(target, text)
citation = self._memory_map.get(key)
if citation is None:
stored = self._memory_map.get(key)
identity = _entry_identity(stored)
citation = self._find_memory_citation(text, identity=identity)
if citation is None and identity is None:
Comment thread
This conversation was marked as resolved.
Resolved
citation = self._find_memory_citation(text)
if citation is not None:
self._memory_map[key] = citation
if citation is not None:
stable_identity = _entry_identity(citation)
if stable_identity is not None and self._memory_map.get(key) != stable_identity:
self._memory_map[key] = stable_identity
self._save_memory_map()
return key, citation

Expand Down
82 changes: 72 additions & 10 deletions tests/integrations/test_hermes_provider.py
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,8 @@ def __init__(self) -> None:
self.calls: list[tuple[str, tuple, dict]] = []
self.base_url = "http://powercontext.test:8000"
self._remember_count = 0
self._revision = 0
self._memory_entries: dict[str, dict] = {}
self.memory_extraction = True

def prepare_context(self, scope_id, query, *, max_bytes):
Expand All @@ -55,27 +57,46 @@ def flush_memory(self, scope_id):

def search_memory(self, scope_id, query, *, limit, mode):
self.calls.append(("search_memory", (scope_id, query), {"limit": limit, "mode": mode}))
return {"hits": [{"text": "a memory"}]}
hits = [
{"text": text, "citation": citation}
for text, citation in self._memory_entries.items()
if query.lower() in text.lower()
]
return {"hits": hits or [{"text": "a memory"}]}

def get_memory_entry(self, scope_id, citation):
self.calls.append(("get_memory_entry", (scope_id, citation), {}))
return {"text": "a memory"}

def remember_memory(self, scope_id, *, kind, text, reason=None):
self._remember_count += 1
self._revision += 1
for citation in self._memory_entries.values():
citation["memory_ref"]["revision"] = self._revision
citation = {
"memory_ref": {
"family": "memory",
"artifact_id": f"memory-{self._remember_count}",
"revision": self._revision,
},
"entry_id": f"entry-{self._remember_count}",
"entry_version_id": f"entry-version-{self._remember_count}",
}
self._memory_entries[text] = citation
self.calls.append(("remember_memory", (scope_id, kind, text), {"reason": reason}))
return {
"status": "remembered",
"entry": {
"citation": {
"memory_ref": {"family": "memory", "artifact_id": f"memory-{self._remember_count}", "revision": 1},
"entry_id": f"entry-{self._remember_count}",
"entry_version_id": f"entry-version-{self._remember_count}",
}
},
"entry": {"citation": citation},
}

def retire_memory_entry(self, scope_id, citation, *, reason=None):
assert citation["memory_ref"]["revision"] == self._revision
self._revision += 1
identity = (citation["entry_id"], citation["entry_version_id"])
for text, stored in list(self._memory_entries.items()):
if (stored["entry_id"], stored["entry_version_id"]) == identity:
del self._memory_entries[text]
break
self.calls.append(("retire_memory_entry", (scope_id, citation), {"reason": reason}))
return {"status": "retired"}

Expand Down Expand Up @@ -320,15 +341,56 @@ def test_memory_write_retires_mapped_entries_for_replace_and_remove(provider_and

assert [call[0] for call in client.calls] == [
"remember_memory",
"search_memory",
"retire_memory_entry",
"remember_memory",
"search_memory",
"retire_memory_entry",
]
assert client.calls[1][1][1]["entry_id"] == "entry-1"
assert client.calls[3][1][1]["entry_id"] == "entry-2"
assert client.calls[2][1][1]["entry_id"] == "entry-1"
assert client.calls[5][1][1]["entry_id"] == "entry-2"
assert provider._memory_map == {}


def test_memory_map_refreshes_revision_after_multiple_writes(provider_and_client):
provider, client = provider_and_client

provider.on_memory_write("add", "user", "The user prefers uv.")
provider._wait_for_background()
provider.on_memory_write("add", "user", "The project uses Python.")
provider._wait_for_background()

first_key = provider._memory_item_key("user", "The user prefers uv.")
assert provider._memory_map[first_key] == {
"entry_id": "entry-1",
"entry_version_id": "entry-version-1",
}

provider.on_memory_write(
"replace",
"user",
"The user prefers rye.",
{"old_text": "The user prefers uv."},
)
provider._wait_for_background()
provider.on_memory_write(
"remove",
"user",
"",
{"old_text": "The user prefers rye."},
)
provider._wait_for_background()

retire_calls = [call for call in client.calls if call[0] == "retire_memory_entry"]
assert [call[1][1]["memory_ref"]["revision"] for call in retire_calls] == [2, 4]
assert provider._memory_map == {
provider._memory_item_key("user", "The project uses Python."): {
"entry_id": "entry-2",
"entry_version_id": "entry-version-2",
}
}


def test_memory_write_skips_replace_and_remove_without_old_text(provider_and_client):
provider, client = provider_and_client

Expand Down